Encoder Circuit For Surface Code using Measurement-Based Quantum Computing Model

The first complication we face while correcting quantum errors is that there is no way to protect the quantum information by making extra copies of it, as done in classical coding schemes. No-cloning theorem prohibits making a copy of the qubit thus making quantum error correction difficult to implement.

The second complication is that quantum computers are susceptible to both bit ($\mathbf{X}$)-flip and phase ($\mathbf{Z}$)-flip errors. We should be able to correct both errors simultaneously. But since there is no classical analog of phase flip errors it is hard to devise a quantum error correcting code that allows us to achieve simultaneous correction of both $\mathbf{X}$- and $\mathbf{Z}$-errors.

The last complication is due to the fact that we cannot measure qubits without losing quantum information. The problem of wavefunction collapse due to measurement renders quantum error correction hard to achieve as we would not be able to detect and correct errors without measuring the qubits. We will see in the later sections how stabilizer formalism allows us to overcome this complication.

Despite the obstacles, it turns out that quantum error correction is possible. Quantum error-correcting codes (QECC) can be viewed as a mapping from $k$ qubits to $n$ qubits, that is, it maps a Hilbert space of $2^{k}$ dimensions to a Hilbert space of $2^{n}$ dimensions. The extra $n-k$ qubits allow us to store the information stored in the $k$ logical qubits in a redundant manner, thereby protecting it from errors. The basic principles required to construct a QECC are: 1) To construct a code it is necessary to have an idea of the errors that we want to correct; 2) The principle of redundant information is used in QECC. If a part of the resource is damaged by errors, the logical qubit can still be accurately recovered from the rest of the redundant qubits.

We already saw in the previous section the types of errors that may occur in quantum computation. One of the four possible things can happen to the qubit: nothing ($\mathbf{I}$), qubit flip ($\mathbf{X}$), phase flip ($\mathbf{Z}$), or both ($\mathbf{Y}=i\mathbf{X}\mathbf{Z}$). In an $n$-qubit Hilbert space, the evolution of qubit can be expanded in terms of the operators $\mathbb{P}_{n}=\left\{\mathbf{I},\mathbf{X},\mathbf{Y},\mathbf{Z}\right\}^{\otimes n}$. Thus, we can express the action of a unitary operator ($\mathbf{U}$) on n-qubits and their environment as

where $\mathbf{E}_{a}\in\mathbb{P}_{n}$ are the $n$-qubit Pauli operator, $a$ runs over all $2^{2n}$ possible combinations of $\mathbb{P}_{n}$ and $|e_{a}\rangle_{E}$ are the states of the environment. Some important properties of the Pauli group $\mathbb{P}_{n}$ are:

• •

  Each element of $\mathbb{P}_{n}$ is unitary.

• •

  $\forall\mathbf{M}\in\mathbb{P}_{n}$; $\mathbf{M}^{2}=\mathbf{I}$ or $\mathbf{M}^{2}=-\mathbf{I}$

• •

  Any two elements $\mathbf{M},\mathbf{N}\in\mathbb{P}_{n}$ either commute, i.e., $[\mathbf{M},\mathbf{N}]=0$, or anticommute, i.e., $\left\{\mathbf{M},\mathbf{N}\right\}=0$.

To understand how to construct a QECC we will first define some important quantities:

Definition 1: Each Pauli operator can be assigned a weight $t$ which is an integer with $0\leq t\leq n$; the weight is the number of qubits acted upon by non-trivial Pauli operators, that is $\mathbf{X}$, $\mathbf{Y}$, and $\mathbf{Z}$. For example, let us look at some Pauli operators acting on a 4-qubit Hilbert space

Using this definition we see that if we are able to devise a QECC that can identify a subset $\mathcal{E}\subseteq\mathbb{P}_{n}$ whose elements have weight $t$, then that QECC can correct $t$ errors.

Definition 2: Choose a subgroup $\mathbb{S}\subseteq\mathbb{P}_{n}$ which satisfies $[\mathbf{M},\mathbf{N}]=0$ $\forall\;\mathbf{M},\mathbf{N}\in\mathbb{S}$. Such a subgroup $\mathbb{S}$ defines an eigenspace $\mathcal{H}_{\mathbb{S}}\subseteq\mathcal{H}_{2^{n}}$. This space is called code subspace. Basis vectors of code subspace are protected from errors. Important properties of code subspace are:

• •

  If the subgroup $\mathbb{S}$ has $n-k$ generators, then the space $\mathcal{H}_{\mathbb{S}}$ has $2^{k}$ dimensions.

• •

  Any operator $\mathbf{M}\in\mathbb{S}$ is a stabilizer of any state $|\psi\rangle\in\mathcal{H}_{\mathbb{S}}$, that is

  $$\mathbf{M}|\psi\rangle=|\psi\rangle.$$

  (4)

This is why these QECCs are also called stabilizer codes. We will construct QECC in such a way that it is capable of correcting errors $\mathbf{E}_{a}\in\mathcal{E}$ which anti-commutes with operators from the group $\mathbb{S}$. Therefore, if $\mathbf{M}\in\mathbb{S}$ and $\mathbf{E}_{a}\in\mathcal{E}$, then for $|\psi\rangle\in\mathcal{H}_{\mathbb{S}}$ we will have

We see that if the eigenvalue of the operator is -1 then the state is affected by the error $\mathbf{E}_{a}$. Therefore, when constructing a QECC we must proceed as follows: 1) Determine the error operators that we want to correct; 2) From all the possible Pauli operators, choose those which commute with themselves and at the same time anti-commute with the error operators.

Now, a necessary and sufficient condition that must be satisfied by code subspace to make QECC work [14] is,

Here, $|i\rangle$ and $|j\rangle$ are two codewords that belong to $\mathcal{H}_{\mathbb{S}}$, and $\mathbf{E}_{a}$ and $\mathbf{E}_{b}$ are two different errors that we want to correct. Equation 6 is also known as the Knill-Laflamme error correction condition. In simple words, the above condition means that different errors should affect states differently. If two different errors change the state in the same way then there is no way to distinguish which error occurred and hence one cannot correct it too. To get a better understanding see Appendix 8.1 where we have explained, using a simple example, how quantum error correcting codes are devised.

Definition 3: Let $\mathbb{S}$ be the stabilizer group and $\mathcal{H}_{\mathbb{S}}$ be the corresponding QECC, then we define [7] the normalizer $\mathbb{N}_{\mathbb{S}}$ of $\mathbb{S}$ in $\mathbb{P}_{n}$ as

Now, if we have an error $\mathbf{E}\in\mathbb{N}_{\mathbb{S}}$ then our QECC will not be able to detect this error. This is because the eigenvalue of $\mathbf{E}|\psi\rangle\in\mathcal{H}_{\mathbb{S}}$ when operated with $\mathbf{M}\in\mathbb{S}$ remains +1.

Furthermore, errors in $\mathbb{S}$ are not really errors per se, because they leave the encoded state unchanged. This means that our QECC will detect all errors that are either in $S$ or anticommuting with some element of $\mathbb{S}$, that is $\mathbf{E}\in\mathbb{S}\cup(\mathbb{P}-\mathbb{N}_{S})$. In simple words, we can say that QECC only detects errors that are outside of $\mathbb{N}_{S}\backslash\mathbb{S}$.

Definition 4: The distance $d$ of $\mathcal{H}_{\mathbb{S}}$ is the weight of the smallest Pauli operator $\mathbf{N}$ in $\mathbb{N}_{\mathbb{S}}\backslash\mathbb{S}$.

A stabilizer code with distance $d$ will correct $\lfloor\frac{d-1}{2}\rfloor$ errors, or in other words, any QECC that corrects $t$ errors has distance 2$t$+1. We can also think of the distance of QECC in the following way: If we look at a subset of $\lfloor\frac{d-1}{2}\rfloor$ qubits, then no information is revealed about the encoded state, that is, the reduced density matrix tells nothing about the relative phases; hence the superposition persists. Logical operators belong to the normalizer set $\mathbb{N}(S)$. Fowler et al. [1] defined the distance of the surface code as the minimum number of physical qubit bit-flips or phase-flips needed to define a logical $\mathbf{X}_{L}$ or $\mathbf{Z}_{L}$ operator. We will look into this more deeply in Section 4.2
Definition 5: To define the error syndrome $f(\mathbf{M})$ for a stabilizer code, let $f_{M}:\mathbb{P}_{n}\rightarrow\mathbb{Z}_{2}$

Then $f(\mathbf{E})=(f_{M_{1}}(\mathbf{E}),\dots,f_{M_{n-k}})$, where $M_{1},\dots,M_{n-k}$ are the generators of $\mathbb{S}$, is a ($n-k$)-bit binary number. Note that $f(E)$ can have $2^{n-k}$ different values. Two different errors $\mathbf{E}$ and $\mathbf{F}$ have the same error syndrome if they commute with the same set of generators of $\mathbb{S}$. Then, this would mean that $\mathbf{E}^{\dagger}\mathbf{F}\in\mathbb{N}_{\mathbb{S}}$. The error syndrome can distinguish different errors if $\mathbf{E}^{\dagger}\mathbf{F}\notin\mathbb{N}_{\mathbb{S}}$. Further, if $\mathbf{E}^{\dagger}\mathbf{F}\in\mathbb{S}$ then $\mathbf{E}$ and $\mathbf{F}$ act in the same way on the codeword. Hence, there is no need to distinguish them. Therefore, we can conclude that the QECC corrects errors for which $\mathbf{E}^{\dagger}\mathbf{F}\notin\mathbb{N}_{\mathbb{S}}\backslash\mathbb{S}$ for all pairs $(\mathbf{E},\mathbf{F})$. From this condition, we can see how the distance of QECC is $2t+1$. If our QECC corrects $t$ errors the product $E^{\dagger}F$ can act on at most 2$t$ qubits. Since to correct the errors $\mathbf{E}^{\dagger}\mathbf{F}$ must be outside $\mathbb{N}_{\mathbb{S}}\backslash\mathbb{S}$, we will have the weight of smallest Pauli operator in $\mathbb{N}_{\mathbb{S}}\backslash\mathbb{S}$, which is defined as the distance, as 2$t$+1. Now, in order to perform an error correction operation, all we need to do is measure the eigenvalue of each generator of the stabilizer. For a non-degenerate code, error syndrome will be different for different errors and hence will exactly tell which error to correct. Unlike a non-degenerate code, for a degenerate code, there exist pairs of errors $(\mathbf{E},\mathbf{F})$ that have the same error syndrome. This occurs if $\mathbb{S}$ has elements of weight less than distance $d$.

We know that elements of $\mathbb{N}_{\mathbb{S}}$ commute with elements of the $\mathbb{S}$, in fact, $\mathbb{S}$ lies inside $\mathbb{N}_{\mathbb{S}}$. This means $\mathbb{N}_{\mathbb{S}}$ moves codewords around within $\mathcal{H}_{\mathbb{S}}$, and hence we can interpret it as encoded operations on the codewords. Only elements in $\mathbb{N}_{\mathbb{S}}/\mathbb{S}$ acts non-trivially on $\mathcal{H}_{\mathbb{S}}$. Here, $\mathbb{N}_{\mathbb{S}}/\mathbb{S}$ is the quotient or factor group, which is the set of cosets of $\mathbb{S}$ in $\mathbb{N}_{\mathbb{S}}$, and is defined as

Note that we can only define quotient group $\mathbb{N}_{\mathbb{S}}/\mathbb{S}$ when $\mathbb{S}$ is an invariant subgroup of $\mathbb{N}_{\mathbb{S}}$. This is precisely the case here as, by definition, $\mathbb{N}_{\mathbb{S}}$ commutes with every element of $\mathbb{S}$, and hence the right cosets ($\mathbb{S}a_{i}\;\forall\;a_{i}\in\mathbb{N}_{\mathbb{S}}\backslash\mathbb{S}$) will be the same as left cosets ($a_{i}\mathbb{S}\;\forall\;a_{i}\in\mathbb{N}_{\mathbb{S}}\backslash\mathbb{S}$). It is possible to show that this group is a Pauli group with size $k-n-r$. Putting these considerations together we can define an automorphism $\mathbb{N}_{\mathbb{S}}/\mathbb{S}\rightarrow\mathbb{P}_{k}$. We will write X_i and Z_i, where $i=1,\dots,k$, as the encoded/logical operators. X_i maps to X in $\mathbb{P}_{k}$ and Z_i maps to Z in $\mathbb{P}_{k}$.

The most important ingredient of MBQC is the cluster state. Cluster state is a special type of entangled state that allows for universal quantum computation using local measurement [17]. A 2$D$ cluster state, as shown in Figure 1, can be thought of as a blank slate upon which we can draw the quantum circuit using local measurements. Cluster states are a particular case of graph states. For a particular graph $\mathcal{C}$ = ($C$, E), where $C$ are the vertices and $E$ edges; we use the following algorithm to generate cluster states: 1) To each vertex $i\in C$ we associate the qubit $|+\rangle$; 2) Next all the pairs of neighboring qubits $(i,j)\in E$ are entangled by the CZ operation which is defined as

As a result, we can write the cluster state $\mathcal{C}$ as

The cluster state $|G\rangle_{C}$ satisfies the following set of eigenvalue equations

where $N(i)$ is the set of neighbouring vertices of vertex $i$. Also, $\lambda\in\{0,1\}\;\forall\;a\in\mathcal{C}$. We define $K^{(a)}$

as the stabilizers of the cluster state. We notice that stabilizers corresponding to different sites commute with each other. This means there exist a set of common eigenstates. All the eigenstates form a group and every one of them is equally good for computation. Eigenstates within this group with the same set of eigenvalues $\{\kappa\}$ form an equivalence class. There are $2^{|C|}$ such equivalence classes corresponding to every $2^{|C|}$ eigenvalue sets $\{\kappa\}$. We can choose any one of the equivalence classes and select any one element from it as its representative. $2^{|C|}$ such representatives from every equivalence class forms the |$C$|-qubit Hilbert space. Note that elements of the equivalence class are orthogonal to each other [18].

There are essentially two ways to create a cluster state. The first way is to measure all the stabilizers $\mathbf{K}^{(i)}$ given in Equation 13 for $i\in C$ on an arbitrary $|C|$-qubit state or to cool into the ground state of the Hamiltonian $\hat{\mathbf{H}}_{K}=-\hbar g\sum_{i\in C}\kappa_{a}\mathbf{K}^{(i)}$. A more practical way is to first create a product state $|+\rangle_{C}=\bigotimes_{i\in C}|+\rangle_{i}$. Then we apply a unitary transformation $\mathbf{S}^{(C)}$, which is given as

on the product state $|+\rangle_{C}$. $\mathbf{S}^{ab}$ has the form

The condition $b-a\in\gamma_{D}$ in Equation 14 restricts the interaction of a qubit with only its nearest neighbors. Therefore, in dimension ($D=1,2,3$), we will have $\gamma_{1}=\{1\}$, $\gamma_{2}=\{(1,0)^{T},(0,1)^{T}\}$, and $\gamma_{3}=\{(1,0,0)^{T},(0,1,0)^{T},(0,0,1)^{T}\}$.

There always exist qubits on the cluster state that are not needed in realizing a quantum circuit. We can remove these redundant qubits by measuring them in the $\mathbf{Z}-$ basis. The resulting entangled state is again a cluster state. To see this we write the cluster state after measurement as a product of entangled quantum state on the cluster $C_{N}$ of the unmeasured qubits and product state on cluster $C\backslash C_{N}$ of qubits which are measured. Therefore,

where $|Z\rangle_{C\backslash C_{N}}=\bigotimes_{i\in C\backslash C_{N}}|s_{i}\rangle_{i,z}$ and $s_{i}$ are the results of the $\sigma_{z}-$measurements. $|G\rangle_{C}$ is the initial cluster state. We notice that we can also write $|Z\rangle_{C\backslash C_{N}}\otimes|G^{\prime}\rangle_{C_{N}}$ as follows

The term in the above equation is the projection operator $\mathcal{P}$ corresponding to the $\mathbf{Z}-$measurements. Since $|G\rangle_{C}$ satisfies Equation 12 we insert $K^{(i)}$ with $i\in C_{N}$ in the r.h.s of the above equation between the projector and the state, and simplify it to obtain

with the new stabilizers of the remaining unmeasured qubits

and the set $\{\kappa_{a}^{\prime}\}$ specifying the eigenvalues

To obtain the second equality in Equation 18 we used the fact that projection operator $\mathcal{P}$ and correlation operator $K^{(a)}$ commute with each other as they act on different qubits. To obtain the last equality we apply $\bigotimes_{b\in N(a)\cap C\backslash C_{N}}\mathbf{Z}^{(b)}$ on $|Z\rangle_{C\backslash C_{N}}$ to get $(-1)^{\sum_{b\in N(a)\cap C\backslash C_{N}}s_{b}}|Z\rangle_{C\backslash C_{N}}$. The new correlation operators $K^{\prime(a)}$ act only on the cluster qubits in $C_{N}$ and obey the following eigenvalue equations as can be seen from Equation 18

The above equation proves that the residual state $|G^{\prime}\rangle_{C_{N}}$ is again a cluster state. We also note that the measurement results of the removed qubits influence the process of computation. Since, any cluster state $|G^{\prime}\rangle_{C_{N}}$ is equally good for computation we can put $\lambda^{\prime}=0$. The above analysis shows that we can discard the redundant qubits by measuring them in the $\mathbf{Z}-$ basis.

To implement a gate $g$ we take a cluster $\mathcal{C}(g)$. We divide it into three sections; an input section $\mathcal{C}_{I}(g)$, a body $\mathcal{C}_{B}(g)$ and an output section $\mathcal{C}_{O}(g)$ such that

The input qubits in $\mathcal{C}_{I}(g)$ are prepared in the state $\left|\psi_{\text{in }}\right\rangle$ on which we need to apply the gate $g$, while the qubits in $\mathcal{C}_{B}(g)\cup\mathcal{C}_{O}(g)$ are in the usual $|+\rangle=|0\rangle_{x}$ state. We entangle the qubits via the interaction $\mathbf{S}^{(\mathcal{C}(g))}$ given in equation 14. To realize the gate on the state $\left|\psi_{\text{in }}\right\rangle$ appropriate measurements are applied to the qubits in $\mathcal{C}_{B}(g)$. It was seen that apart from required operation $\mathbf{U}_{g}$ corresponding to the gate $g$ obtained on the output qubits $\mathcal{C}_{O}(g)$, we get an extra Pauli operation $\mathbf{U}_{e}$ which depends on the measurement outcomes of the qubits measured in $\mathcal{C}_{B}(g)$ [18], that is,

where

Here, $n=|I|=|O|$ and $\{\mathbf{X},\mathbf{Z}\}^{[i]}$ denotes Pauli operator acting on the logical qubit $i$ and not the cluster qubits. The values $x_{i},\;z_{i}\in\{0,1\}$ are computed from the measurement outcomes $\{s_{k}|k\in\mathcal{C}_{I}(g)\cup\mathcal{C}_{B}(g)\}$.

Now, we define a theorem that provides a criterion describing the functioning of the gate in MBQC.

Theorem 1: Let $\mathcal{C}(g)=\mathcal{C}_{I}(g)\cup\mathcal{C}_{B}(g)\cup\mathcal{C}_{O}(g)$ be a cluster used to implement a unitary transformation $\mathbf{U}$ corresponding to gate $g$, and $|\phi\rangle_{\mathcal{C}_{g}}$ be the cluster state. Suppose the state $|\psi\rangle_{\mathcal{C}_{g}}=P_{\{s\}}^{\left(\mathcal{C}_{B}(g)\right)}(\mathcal{M})|\phi\rangle_{\mathcal{C}(g)}$ obeys the 2$n$ eigenvalue equations for the measurement pattern $\mathcal{M}$,

with $\lambda_{x,i},\lambda_{z,i}\in\{0,1\}$ depends on the measurement outcomes of qubits in $\mathcal{C}_{M}(g)$ which are measured according to $\mathcal{M}$ and $1\leq i\leq n$. $n$ is the number of input qubits. We can, then, realize gate $g$ on the cluster state using Scheme 3.3 with measurement pattern described by $\mathcal{M}$, and the measurements of the qubits in $\mathcal{C}_{I}(g)$ being X measurement. After measurement, we can relate input and output states as

where $\mathbf{U}_{\Sigma}$ is the byproduct operator given by

where $s_{i}\in\{0,1\}$ is the measurement outcome of $\mathbf{X}$ measurement performed on the $\mathcal{C}_{I}(g)$.

In the next section, we have implemented the theory we have developed till now to implement surface codes on $3\times 3$ and $5\times 5$ cluster states. Before we start discussing our work we would like to state an important lemma that would be helpful during our discussion on stabilizer evolution in the later sections

Lemma 1 If $\mathbb{S}=\left\{\mathbf{S}_{i}\right\}_{i=1}^{m}$ are the stabilizers of a state $|\psi\rangle$ then $\left\{\mathbf{U}\mathbf{S}_{i}\mathbf{U}^{\dagger}\right\}_{i=1}^{m}$ are the stabilizers of the state $\mathbf{U}|\psi\rangle$, where $\mathbf{U}$ is an unitary operator.

Let us suppose that a bit-flip error occurs on one of the data qubits. The two adjacent measure-Z qubits will detect this because the sign of these measure-Z qubits will change. This will also change the quiescent state

This shows that $\mathbf{X}_{a}|\psi\rangle$ is an eigenstate of $\mathbf{Z}$ stabilizer but with an opposite sign. This will be more clear with the following example: Let us assume that a bit-flip error occurs on the $7^{\text{th}}$ data qubit. We select the quiescent state $|\psi\rangle$ corresponding to the set $\{1,-1,-1,1,1,\cdots\}$, which has measurement outcomes of all the 12 measure qubits. Since, bit-flip error occurs on the $7^{\text{th}}$ data qubit, sign of the measurement outcome at $6^{\text{th}}$ and $8^{\text{th}}$ measure-Z qubits will change. Similarly, we can detect phase-flip errors. If instead of a bit-flip error on 7${}^{\text{th}}$ data qubit a phase-flip error occurs then measurement outcome at $4^{\text{th}}$ and $9^{\text{th}}$ measure-X qubit will flip signs.

Now, to correct for the bit-flip we apply a second $\mathbf{X}_{a}$ operator on the corrupted data qubit. The same can be done for the phase-flip errors where we apply $\mathbf{Z}_{a}$ on the data qubit to correct for the error. An issue with applying an extra gate operation for practical purposes is that we cannot obtain $100\%$ fidelity. This could introduce more errors in the surface code. Instead, the errors are corrected using a classical control software which changes the sign of measurement qubits that get flipped due to errors.

A planar 2D surface code with a single boundary cannot encode any qubit. This is because all the possible 1-chains are homologically equivalent. Therefore, the first homology group $\mathbb{H}_{1}$ will be isomorphic to the trivial group $\mathbb{Z}_{1}$. Since it does not have any generators there will be no encoded qubit. It may seem that the surface code in Figure 2 can also not encode any qubit, but that is not the case. This is because it has two different kinds of boundaries. There is a boundary that terminates with measure-X qubits, which in literature is referred to as smooth boundary. The other boundary terminates with a measure-Z qubit, called rough boundary. Since there are two different types of boundaries the first homology group $\mathbb{H}_{1}$ will be isomorphic to $\mathbb{Z}_{2}$. Since $\mathbb{Z}_{2}$ has one generator, the surface code will encode 1 qubit. This can also be seen in Figure 3. It has 25 data qubits and 24 measure qubits, so there are $2\times 25$ degrees of freedom in the data qubits and $2\times 24$ constraints from the stabilizer measurements. The two unconstrained degrees of freedom act as a logical or encoded qubit [1][21].

We can now define logical operators that allow us to manipulate these additional degrees of freedom. Logical operators form closed 1-chain cycles. In Figure 3 operators $\mathbf{X}_{L}$ (in blue) and $\mathbf{Z}_{L}$ (in red) show the two possible logical operators acting on the data qubits. We note that the product chain $\mathbf{X}_{L}$ and $\mathbf{Z}_{L}$ is closed 1-cycles and homologically inequivalent (See Appendix 8.3 to read more on the homology of curves). They represent the two equivalence classes of $\mathbb{H}_{1}$. We can choose other chains of single qubit operator products to define different $\mathbf{X}_{L}$ and $\mathbf{Z}_{L}$. Consider for example the chain $\mathbf{X}_{L}^{\prime}=\mathbf{X}_{1}\mathbf{X}_{8}\mathbf{X}_{9}\mathbf{X}_{10}\mathbf{X}_{3}\mathbf{X}_{4}$ also shown in Figure 3. It can be easily seen that it is homologically equivalent to $\mathbf{X}_{L}$ and hence belong to the same equivalence class (See the Section 8.4). Notice that we can write $\mathbf{X}_{L}^{\prime}=(\mathbf{X}_{2}\mathbf{X}_{8}\mathbf{X}_{9}\mathbf{X}_{10})\mathbf{X}_{L}$. The term in the parentheses is the stabilizer operator. Therefore, if we operate on a quiescent state $|\psi\rangle$ with $\mathbf{X}_{L}^{\prime}$ we will get the same state obtained when $\mathbf{X}_{L}$ is applied on $|\psi\rangle$ up to an overall phase. Hence, there is only one linearly independent $\mathbf{X}_{L}$ operator for this array.

At first glance this result may seem mysterious; after all, if we operate on the array with a loop of $\mathbf{X}$ operators corresponding to a stabilizer $\mathbf{X}_{\text{loop}}=\mathbf{X}_{2}\mathbf{X}_{8}\mathbf{X}_{9}\mathbf{X}_{10}$ we are bit-flipping four data qubits so the state $|\psi\rangle^{\prime}=\mathbf{X}_{\text{loop}}|\psi\rangle$ should be different from $|\psi\rangle$. The only way $|\psi\rangle$ and $|\psi\rangle^{\prime}$ are the same is if $|\psi\rangle$ already contains the superposition of un-bit-flipped and bit-flipped data qubits. This is precisely how we define surface code. A surface code state is the superposition of all homologically equivalent cycles. A stabilizer loop like $\mathbf{X}_{\text{loop}}$ will only lead to homologically equivalent configurations. Look at Appendix 8.3 to get a mathematical perspective and intuitive understanding of the homology of curves.

Notice that the $\mathbf{Z}_{L}$ operator chain is in the dual lattice, which makes it a 1-cochain. Since in the dual lattice we have measure-X qubits (i.e., $|+\rangle$ and $|-\rangle$ are the basis states); the face stabilizer will be a loop of $\mathbf{Z}$ operators. So, we see that the same argument applies to the $\mathbf{Z}_{L}$ operator.

In this subsection, we are going to demonstrate a way of finding the distance of a surface code in reference to finding the logical operators and then using that to create a set of operators that commutes with the stabilizer generator which in technical language is termed as the centralizers of stabilizers generator. As discussed in Section 2.3, the minimum weight of the elements of the centralizer of the stabilizer generator would provide the distance of the code. We defined the logical operator by creating a chain of operators commute with our stabilizer generator. As seen above in a simple 2D surface code there are 2 homologically inequivalent 1-cycles and hence two logical operators $\mathbf{X}_{L}$ and $\mathbf{Z}_{L}$. Fowler et al. [1] defined the distance of a 2D surface code as the minimum weight of the logical operators. For simple geometries in which we can encode only one qubit.

To investigate a surface code that captures our attention, we employ Algorithm 1, a modified version of the algorithm proposed by [22] for realizing stabilizer codes. This algorithm enables us to determine the ultimate stabilizer generator of the evolving cluster state. Subsequently, the cluster state undergoes a transformation using a suitable measurement pattern.

Algorithm 1 involves a meticulous selection process, wherein the stabilizer operator is carefully chosen to commute with every measurement operator during each

cycle specified by the measurement pattern. It depends on considering the cases of commutation relation between the evolving stabilizer generators (beginning from the initial cluster state generators) and the measurement pattern under consideration. At each cycle for an element of the measurement operator, we store the stabilizers in $\mathbf{K}_{c}$ or $\mathbf{K}_{ac}$ depending on whether the element commute or anti commute with measurement operator respectively. If the anticommuting array ($\mathbf{K}_{ac}$) contains more than one element, we multiply the elements within themselves and append the new terms in the commuting array (i.e., in $\mathbf{K}_{c}$) to get the final stabilizer generators corresponding to a particular measurement operator. We repeat the process for each element of the measurement array to get the final stabilizer for our cluster state. This ensures that the desired stabilizer generators commute within themselves and with the prescribed measurement patterns.

The algorithm is implemented using the AWS Braket platforms and requires the Qiskit libraries. The resulting stabilizer generators obtained from this implementation will be utilized in the subsequent subsections, with an aim to demonstrate and study the observed changes compared to the established CNOT implementation for 3×3 and 5×5 circuits.

In this section, we will conduct a comparable analysis on the stabilizer evolution of a 3×3 array of qubits, consisting of a cluster of 9 qubits, following a specific measurement pattern. This measurement pattern is an extension of the pattern utilized in the previous section. As illustrated in Figure 4, the measurement pattern involves Z-measurements on qubits ${1,7}$ and X-measurements on qubits ${3,5}$. The resulting circuit, which will be used for subsequent computations, takes the following form: