Chapter 13 - Topological Quantum Error Correction

Surface Code

Introduction

Surface codes are topological quantum error-correcting codes in which we can think of qubits being arranged on a 2-D lattice of qubits with only nearest neighbor interactions. This in practice may prove to be a very useful feature, since for many systems interacting qubits that are close to each other is substantially less difficult than ones that are further apart. We can think of physical qubits as being arranged on the edges of a lattice as shown in Figure 1. An example of the surface code are toric code and planar code, the main difference between both of them is the boundary condition. In the toric code, the boundaries are periodic whereas in the case of the planar code, the boundaries are not periodic. In the toric code, the qubits are arranged on a lattice which can be thought of as spread over a surface of a torus, and in a planar code case we think of the data qubits as living on a simple 2-D plane and ancilla qubits on the faces and the intersections.

Figure 1
A two-dimensional array implementation of the surface code. Data qubits are open circles, measurements (ancilla) qubits are filled circles.
The yellow area is to measure-Z qubits while the green area is to measure-X qubits.

The stabilizer generators for the surface code are the tensor products of Z on the four data qubits around each face, and the tensor products of X on the four data qubits around each intersection. Neighbouring stabilizers share two data qubits ensuring that adjacent X and Z stabilizers commute. The qubit Z eigenstate are called the ground state $\left\vert {g}\right\rangle$ and the excited state $\left\vert {e}\right\rangle$. The ground state is the +1 eigenstate of Z, with $Z\left\vert {g}\right\rangle =+\left\vert {g}\right\rangle$, and the excited state is the -1 eigenstate, with $Z\left\vert {e}\right\rangle =-\left\vert {e}\right\rangle$. It is tempting to think of the qubit as a kind of quantum transistor, with the ground state corresponding to "off" and the excited state to "on". However, in distinct contrast to a classical logical element, a qubit can exist in a superposition of its eigenstate, $\left\vert {\psi }\right\rangle =\alpha \left\vert {g}\right\rangle +\beta \left\vert {g}\right\rangle$, so a qubit can be both "off" and on" at the same time. A measurment $M_{Z}$ of the qubit will however return only one of two possible measurement outcomes,+1 with the qubit state projected to $\left\vert {g}\right\rangle$, or -1 with the qubit state projected to $\left\vert {e}\right\rangle$ .

A planar code has four boundaries, two that are called “smooth” and two that are called “rough”. Smooth boundaries have four-term Z stabilizer generators, and three-term X stabilizer generators, whereas rough boundaries have four-term X stabilizer generators and three-term Z stabilizer generators. A planar code, with two rough and two smooth boundaries can encode a single logical qubit (as in Figure 2). Also look at http://arxiv.org/abs/1208.0928 [42] it is an excellent reference as it represents a comprehensive review of the surface code, also written for the absolute beginner.

Figure 2
Examples of smooth and rough boundaries. This figure has been copied with a permission from the authors of Phy. Rev. A. [43]

Syndrome Extraction and Error Detection

Detecting errors involves measuring check operators, and observing which ones give a value of -1 (due to anti-commuting with errors). This information helps us guess where errors occurred. In practice, of course, errors do not have to occur on their own, and often one can observe multiple instances next to each other. In these cases, the error operators form error chains throughout the lattice. Since only the ends of such error chains anti-commute with the check operators, determining where errors occurred often involves guessing the most likely scenario. In the planar case, the chains connect opposite boundaries of the same type (either left to right, or top to bottom), and in the toric case, chains that span all the way across a given dimension of the lattice. They turn out to the change the encoded, logical state of the qubit and hence are called logical errors. Two examples are shown Figures 3 and 4. $Z_{L}$ is a chain of Z operators that connects two rough boundaries, and $X_{L}$ chain of X operators that connects two smooth ones.

Figure 3
Examples of error syndromes on the Surface code (planar and toric). The state is initialized to the +1 eigenstate of all stabilizers.
Shaded qubits indicate locations of X errors. This figure has been copied with a permission from the authors of Master thesis [46] Figure 4
A planar surface code in which a logical Z (X) error is a chain of Z (X) operators that spans the whole lattice, and connects rough (smooth) boundaries.
This figure has been copied with a permission from the authors of Master thesis [46] Figure 5
We can encode two qubits in a toric code, since there are no boundaries.
This shows how logical operations are done on a) the first qubit, and b) the second.
In both cases, the logical operations involve applying a set of operators (either X or Z) in a chain that goes around one of the dimensions of the torus.
This figure has been copied with a permission from the authors of Phy. Rev. A. [43]

The ancilla qubits are used for determining the measurement outcomes of the four-term (and three-term on boundaries) check operators without actually needing to measure them directly. We call these outcomes syndromes, and use them to determine where errors have occurred. A generic circuit capable of determining the sign of a stabilize in Figure 6. The approach consists of initializing the ancilla qubits, performing a collection of CNOT gates with neighboring data qubits, and finally reading out (measuring) the ancillas.

Figure 6
a) General circuit determining the sign of a stabilizer S.
b) Circuit determining the sign of a stabilizer XXXX.
c) Circuit determining the sign of a stabilizer ZZZZ.

The orientation of the CNOT gates is different when dealing with ancilla qubits that are located on the vertices, from the ones that sit on the plaquettes. In the former case, the ancilla qubits play the role of control, while the data qubits are targets. The situation is reversed in the latter scenario. An example of the plaquette readout is shown in Figure 7. The syndrome is now the change in eigenvalues measured between sequential timeslices, just as the syndrome for error-free syndrome extraction likely set of errors that is consistent with the observed syndrome, now in three dimensions: two spatial and one temporal.

A syndrome measurement typically involves six steps:
ancilla qubit initialization, CNOTs with the four surrounding data qubits fewer on boundaries in a planar code case, and finally ancilla qubit readout.
This example shows a temporal order of the CNOT gates of north, west, east, and south. This figure has been copied with a permission from the authors of Phy. Rev. A. [43]

Error Correction

After each ancilla is read, its value is checked against a result from the previous iteration, and if the values differ, the syndrome change location (in time and space) is recorded. Next, a matching of all the syndrome changes collected up to this point is used to guess where errors occurred. An example of this is shown in Figure 8, where we can see that in this particular scenario, a collection of X errors (shown as Xs in blue) after six readout cycles, have led to the given space-time locations of syndrome changes (red dots). We stress that one could get the same readout pattern from a different set of errors, hence the best we can do when guessing where the errors occurred is find a guess that is the most likely scenario.

To do this, we observe that shorter error chains are more likely than longer ones and therefore use a minimum-weight matching algorithm to match the syndrome change locations and obtain a likely error pattern. Before the matching algorithm can find a minimum-weight solution, however, we need to convert our matching results into something that the matching algorithm can understand. This is done by converting all the syndrome change results into a graph, with the locations of the syndrome changes representing the graph’s nodes, and edges between these nodes having a weight which depends on the distance between them. The edge weight is measured in faces along the spatial dimensions and ancilla qubit readout cycles along the time dimension.

Finally, the corrected lattice is then passed onto error detection routines which can determine whether a logical error has occurred. If it has, then the simulation is stopped and the previous cycle step (at which the simulation was “frozen”) recorded. If no logical error has been detected, the simulation is reverted to the state just before the “perfect readout” cycle began and continues on.

a) An example of syndrome change locations (red dots) after six readout cycles. The X operators represent the actual errors that the lattice suffered,
which lead to the given syndrome change location pattern. These now have to be matched to obtain a guess as to where the errors happened.
b) The matching of syndrome changes gives us information on which errors should be corrected.
This figure has been copied with a permission from the authors of Master thesis [46]

References

1. Austin Fowler, Matteo Mariantoni, John Martinis, Andrew Cleland, http://arxiv.org/abs/1208.0928, Submitted on 4 Aug 2012.
2. Austin Fowler, Ashley Stephens, and Peter Groszkowski, Phy. Rev. A. 80 052312 (2009).
3. David Wang, Austin Fowler, and Lloyd Hollenberg, Phy. Rev. A, 83, 020302 (2010).
4. Austin Fowler, David Wang, and Lloyd Hollenberg, Quantum Information & Computation 11, 8-18 (2011).
5. Peter Groszkowski, Master thesis, Waterloo, Ontario, Canada, 2009.