Surface codes: Towards practical large-scale quantum computation

Milestone

Surface codes: Towards practical large-scale quantum computation

Austin G. Fowler, Matteo Mariantoni, John M. Martinis, and Andrew N. Cleland

Phys. Rev. A 86, 032324 – Published 18 September 2012

An article within the collection: Physical Review A 50^th Anniversary Milestones

Abstract

This article provides an introduction to surface code quantum computing. We first estimate the size and speed of a surface code quantum computer. We then introduce the concept of the stabilizer, using two qubits, and extend this concept to stabilizers acting on a two-dimensional array of physical qubits, on which we implement the surface code. We next describe how logical qubits are formed in the surface code array and give numerical estimates of their fault tolerance. We outline how logical qubits are physically moved on the array, how qubit braid transformations are constructed, and how a braid between two logical qubits is equivalent to a controlled-not. We then describe the single-qubit Hadamard, $\hat{S}$ and $\hat{T}$ operators, completing the set of required gates for a universal quantum computer. We conclude by briefly discussing physical implementations of the surface code. We include a number of Appendices in which we provide supplementary information to the main text.

28 More

Received 2 August 2012

DOI:https://doi.org/10.1103/PhysRevA.86.032324

Collections

This article appears in the following collection:

Physical Review A 50^th Anniversary Milestones

The collection contains papers that have made important contributions to atomic, molecular, and optical physics and quantum information by announcing significant discoveries or by initiating new areas of research.

Authors & Affiliations

Austin G. Fowler

Centre for Quantum Computation and Communication Technology, School of Physics, The University of Melbourne, Victoria 3010, Australia

Matteo Mariantoni, John M. Martinis, and Andrew N. Cleland

Department of Physics, University of California, Santa Barbara, California 93106-9530, USA and California Nanosystems Institute, University of California, Santa Barbara, California 93106-9530, USA

Article Text (Subscription Required)

Click to Expand

References (Subscription Required)

Click to Expand

Issue

Vol. 86, Iss. 3 — September 2012

Reuse & Permissions

Access Options

Author publication services for translation and copyediting assistance advertisement

Images

Figure 1
(a) A two-dimensional array implementation of the surface code. Data qubits are open circles ( $\circ$ ), measurement qubits are solid circles ( $•$ ), with measure- $Z$ qubits colored green (dark) and measure- $X$ qubits colored orange (light). Away from the boundaries, each data qubit contacts four measure qubits, and each measure qubit contacts four data qubits; the measure qubits perform four-terminal measurements. On the boundaries, the measure qubits contact only three data qubits and perform three-terminal measurements, and the data qubits contact either two or three measure qubits. The solid line surrounding the array indicates the array boundary. (b) Geometric sequence of operations (left), and quantum circuit (right) for one surface code cycle for a measure- $Z$ qubit, which stabilizes ${\hat{Z}}_{a} {\hat{Z}}_{b} {\hat{Z}}_{c} {\hat{Z}}_{d}$ . (c) Geometry and quantum circuit for a measure- $X$ qubit, which stabilizes ${\hat{X}}_{a} {\hat{X}}_{b} {\hat{X}}_{c} {\hat{X}}_{d}$ . The two identity $\hat{I}$ operators for the measure- $Z$ process, which are performed by simply waiting, ensure that the timing on the measure- $X$ qubit matches that of the measure- $Z$ qubit, the former undergoing two Hadamard $\hat{H}$ operations. The identity operators come at the beginning and end of the sequence, reducing the impact of any errors during these steps.Reuse & Permissions
Figure 2
Schematic evolution of measurement outcomes (solid circles with $\pm$ signs), over a segment of the 2D array. Time progresses moving up from the array at the bottom of the figure, with measurement steps occurring in each horizontal plane. Vertical heavy red (gray) lines connect time steps in which a measurement outcome has changed, with the spatial correlation indicating an $\hat{X}$ bit-flip error, a $\hat{Z}$ phase-flip error, a $\hat{Y} = \hat{Z} \hat{X}$ error, and temporal correlation a measurement ( $M$ ) error, which is sequential in time.Reuse & Permissions
Figure 3
A square 2D array of data qubits, with $X$ boundaries on the left and right and $Z$ boundaries on the top and bottom. The array has 41 data qubits, but only 40 $\hat{X}$ and $\hat{Z}$ stabilizers. A product chain ${\hat{X}}_{L} = {\hat{X}}_{1} {\hat{X}}_{2} {\hat{X}}_{3} {\hat{X}}_{4} {\hat{X}}_{5}$ of $\hat{X}$ operators connects the two $X$ boundaries, commutes with all the array stabilizers and changes the array state from the quiescent state $| ψ 〉$ to $| ψ_{X} 〉 = {\hat{X}}_{L} | ψ 〉$ with the same measurement outcomes as $| ψ 〉$ . A second product chain ${\hat{Z}}_{L} = {\hat{Z}}_{6} {\hat{Z}}_{7} {\hat{Z}}_{3} {\hat{Z}}_{8} {\hat{Z}}_{9}$ connects the two $Z$ boundaries and commutes with the array stabilizers; it changes the array state from $| ψ 〉$ to $| ψ_{Z} 〉 = {\hat{Z}}_{L} | ψ 〉$ . The operator chains ${\hat{X}}_{L}$ and ${\hat{Z}}_{L}$ anticommute. A modification of the ${\hat{X}}_{L}$ chain to the chain ${\hat{X}}_{L}^{'} = {\hat{X}}_{1} {\hat{X}}_{10} {\hat{X}}_{11} {\hat{X}}_{12} {\hat{X}}_{3} {\hat{X}}_{4} {\hat{X}}_{5}$ generates a quiescent state $| ψ_{X^{'}} 〉 = X_{2, 10, 11, 12} | ψ_{X} 〉$ , related to $| ψ_{X} 〉$ by the result of the measurement $X_{2, 10, 11, 12} = \pm 1$ of the encircled measure- $X$ qubit (outlined in black).Reuse & Permissions
Figure 4
(a) Numerical simulations of surface code error rates and how these error rates scale with the distance $d$ of the array. Per-step error rates $p$ less than the per-step threshold error rate of $p_{th} = 0.57 %$ (dashed vertical line) yield surface code logical error rates $P_{L}$ that vanish rapidly with increasing $d$ . This threshold corresponds to roughly a 4 $%$ error rate for the entire surface code measurement cycle. (b) Estimated error rates, using statistical arguments given in main text, for array distances $d = 3$ , 7, 11, 25, and 55. Note the estimate gives a logical error rate $P_{L}$ and a per-step threshold that are qualitatively similar to those from the more precise simulations.Reuse & Permissions
Figure 5
(a) An example where two measure- $Z$ qubits report errors in a single row of a 2D array, marked by “E”s. This error report could be generated by (b) two $\hat{X}$ errors appearing in the same surface code cycle on the second and third data qubit from the left or (c) three $\hat{X}$ errors appearing in the other three data qubits in the row.Reuse & Permissions
Figure 6
Estimated number of physical qubits $n_{q}$ per logical qubit, versus the single-step error rate $p$ , the latter normalized to the threshold error rate $p_{th}$ , plotted for different target logical error rates $P_{L}$ . Notation on the right axis corresponds to the array distance $d$ for a single logical qubit.Reuse & Permissions
Figure 7
${\hat{X}}_{L}$ error rate $P_{L}$ per surface code cycle as a function of the per-step physical error rate $p$ , considering only (a) class 0 (data qubit) errors, (b) class 1 (measure qubit) errors, and (c) class 2 (cnot) errors (see text for full definition). For the class 1 errors in (b), results are for initialization and measurement errors in measure- $Z$ qubits, with two opportunities per surface code cycle, while the equivalent for measure- $X$ qubits includes Hadamard errors, with four opportunities per cycle.Reuse & Permissions
Figure 8
Contours of the three error class error rates $p_{0}$ , $p_{1}$ , and $p_{2}$ that combine to give the error threshold, corresponding to the total logical error rate $P_{L} = 0.02$ . Data are from a distance $d = 9$ numerical simulation, and lines are guides for the eye. The green dot (upper vertical axis) is the class 2 error rate giving $P_{L} = 0.02$ with no class 0 or class 1 errors.Reuse & Permissions
Figure 9
A single $Z$ -cut qubit. The array boundary is indicated by a solid black line (top), while the other three sides of the array continue outwards indefinitely. Two logical operators, ${\hat{X}}_{L} = {\hat{X}}_{1} {\hat{X}}_{2} {\hat{X}}_{3}$ from the array's outer $X$ boundary to the internal $X$ boundary of the $Z$ -cut hole, and ${\hat{Z}}_{L} = {\hat{Z}}_{3} {\hat{Z}}_{4} {\hat{Z}}_{5} {\hat{Z}}_{6}$ surrounding the $Z$ -cut hole, are shown. Note that the operator chains for ${\hat{X}}_{L}$ and ${\hat{Z}}_{L}$ have one physical data qubit in common (data qubit 3).Reuse & Permissions
Figure 10
A double $Z$ -cut qubit, formed by turning off two measure- $Z$ qubits. For each $Z$ -cut hole we can define the logical operators ${\hat{X}}_{L 1}$ and ${\hat{Z}}_{L 1}$ , ${\hat{X}}_{L 2}$ and ${\hat{Z}}_{L 2}$ , where ${\hat{X}}_{L 1}$ and ${\hat{X}}_{L 2}$ reach from the array $X$ boundary on the right to the internal $X$ boundary of each $Z$ -cut hole, and ${\hat{Z}}_{L 1}$ and ${\hat{Z}}_{L 2}$ are loops surrounding each $Z$ -cut hole. We can replace ${\hat{X}}_{L 1}$ (dashed blue line) with the product ${\hat{X}}_{L 1} {\hat{X}}_{L 2}$ , which performs an ${\hat{X}}_{L}$ bit flip of both qubit holes and, along with ${\hat{X}}_{L 2}$ , provides equivalent functionality to the two separate $\hat{X}$ operators. However, the product ${\hat{X}}_{L 1} {\hat{X}}_{L 2}$ can be multiplied by all the outlined $\hat{X}$ stabilizers, which at most give a sign change to the operator, to yield the equivalent operator ${\hat{X}}_{L}$ (solid blue line) that links the two qubit holes.Reuse & Permissions
Figure 11
(a) A double $Z$ -cut and (b) a double $X$ -cut qubit, formed in a large array by turning off two measure- $Z$ qubits and two measure- $X$ qubits, respectively; the array is assumed to extend outwards indefinitely. For the double $Z$ -cut qubit the logical operators comprise an ${\hat{X}}_{L} = {\hat{X}}_{1} {\hat{X}}_{2} {\hat{X}}_{3}$ chain that links one $Z$ -cut hole's internal $X$ boundary to the other, and a ${\hat{Z}}_{L} = {\hat{Z}}_{3} {\hat{Z}}_{4} {\hat{Z}}_{5} {\hat{Z}}_{6}$ loop that encloses the lower $Z$ -cut hole. For the $X$ -cut qubit we have the ${\hat{Z}}_{L} = {\hat{Z}}_{1} {\hat{Z}}_{2} {\hat{Z}}_{3}$ chain that links the two internal $X$ -cut holes’ $Z$ boundaries and the ${\hat{X}}_{L} = {\hat{X}}_{3} {\hat{X}}_{4} {\hat{X}}_{5} {\hat{X}}_{6}$ loop that encloses the lower $X$ -cut hole. The ${\hat{X}}_{L}$ and ${\hat{Z}}_{L}$ operator chains share one data qubit, data qubit 3 for both examples, so the operators anticommute. Note that the loop operators ( ${\hat{Z}}_{L}$ for the $Z$ -cut qubit and ${\hat{X}}_{L}$ for the $X$ -cut qubit) can surround either of the two holes in the qubit, as discussed in the text.Reuse & Permissions
Figure 12
Example of how ${\hat{Z}}_{L}$ and ${\hat{X}}_{L}$ operators are handled in the control software. Here we commute a ${\hat{Z}}_{L}$ logical operator [colored blue (light)] on one qubit with an identity ${\hat{I}}_{L}$ [colored blue (light)] on a second qubit through a sequence of logical operations (colored black), here including two Hadamards and a cnot, ending with a measurement of each qubit. (a) We start with ${\hat{Z}}_{L}$ operating on qubit 1 with the ${\hat{I}}_{L}$ identity on qubit 2. (b) The two operations are commuted one step to the right, with ${\hat{Z}}_{L}$ transformed by the Hadamard to an ${\hat{X}}_{L}$ . (c) The two operations are commuted through the cnot, with ${\hat{X}}_{L}$ on qubit 1 remaining unchanged while ${\hat{I}}_{L}$ on the second qubit transforms to ${\hat{X}}_{L}$ . (d) ${\hat{X}}_{L}$ on qubit 1 is transformed by the second Hadamard to ${\hat{Z}}_{L}$ , and finally (e) the ${\hat{Z}}_{L}$ on qubit 1 changes the sign of the $\hat{X}$ measurement from $M_{X} = \pm 1$ to $- M_{X} = \mp 1$ , while the ${\hat{X}}_{L}$ on qubit 2 does nothing to that qubit's $\hat{X}$ measurement.Reuse & Permissions
Figure 13
Easy initialization of an $X$ -cut logical qubit. Using the logical qubit's upper hole, the stable measure- $X$ outcome just prior to creating the qubit hole by turning off the measure- $X$ qubit is equal to the initial logical eigenvalue of the qubit.Reuse & Permissions
Figure 14
$\hat{Z}$ eigenstate (difficult) initialization of an $X$ -cut logical qubit. The process steps are as follows. (a) Starting with a fully stabilized array, we (b) turn off a column of four measure- $X$ qubits, switch the adjacent measure- $Z$ qubits from four- to three-terminal measurements, and perform $\hat{Z}$ measurements of the data qubits numbered 1, 2, and 3 to maintain error tracking. (c) We reset (reinitialize) the data qubits 1, 2, and 3 to $| g 〉$ and (d) turn two of the measure- $X$ qubits back on and switch the adjacent measure- $Z$ qubits back to four-terminal measurements, leaving us with a logical qubit initialized in $| g_{L} 〉$ due to step (c).Reuse & Permissions
Figure 15
$Z$ -axis (difficult) measurement process for an $X$ -cut logical qubit. We start (a) with an $X$ -cut qubit, for which we display the logical operators ${\hat{X}}_{L}$ and ${\hat{Z}}_{L}$ , and begin the measurement (b) by turning off the measure- $X$ qubits between the two qubit cuts while also switching the neighboring measure- $Z$ qubits from four- to three-terminal measurements. We measure the unstabilized data qubits along $\hat{Z}$ . The product of the measurement outcomes is the measurement of ${\hat{Z}}_{L}$ . A pending ${\hat{Z}}_{L}$ operator would have no effect, while a pending ${\hat{X}}_{L}$ would be used to reverse the sign of this measurement outcome. We then (c) reset the qubits to their ground states $| g 〉$ and (d) destroy the logical qubit by turning on all the stabilizers.Reuse & Permissions
Figure 16
$Z$ -cut qubit with a five-stabilizer hole, showing only the upper qubit multicell hole. The logical operator ${\hat{Z}}_{L}$ is the chain ${\hat{Z}}_{L} = {\hat{Z}}_{1} {\hat{Z}}_{2} {\hat{Z}}_{3} {\hat{Z}}_{4} {\hat{Z}}_{5} {\hat{Z}}_{6} {\hat{Z}}_{7} {\hat{Z}}_{8}$ , shown in red (gray). The four $\hat{Z}$ stabilizers ${\hat{Z}}_{s 1}$ , ${\hat{Z}}_{s 2}$ , ${\hat{Z}}_{s 3}$ , and ${\hat{Z}}_{s 4}$ are turned off along with the $\hat{X}$ stabilizer ${\hat{X}}_{s 1}$ and the four internal data qubits measured along $X$ for error tracking. The initial value of ${\hat{Z}}_{L}$ is equal to the product of the four $\hat{Z}$ stabilizer measurements just prior to turning the stabilizers off (note this stabilizer product commutes with each of the individual data qubit measurements $M_{X}$ ).Reuse & Permissions
Figure 17
Process for moving a $Z$ -cut logical qubit hole vertically down by one cell in the 2D array. (a) Logical qubit with ${\hat{X}}_{L} = {\hat{X}}_{1} {\hat{X}}_{2} {\hat{X}}_{3}$ and ${\hat{Z}}_{L} = {\hat{Z}}_{3} {\hat{Z}}_{4} {\hat{Z}}_{5} {\hat{Z}}_{6}$ . (b) We extend the ${\hat{Z}}_{L}$ operator by multiplying it by the $\hat{Z}$ stabilizer just below the lower qubit hole: ${\hat{Z}}_{L}^{e} = ({\hat{Z}}_{6} {\hat{Z}}_{7} {\hat{Z}}_{8} {\hat{Z}}_{9}) {\hat{Z}}_{L} = {\hat{Z}}_{3} {\hat{Z}}_{4} {\hat{Z}}_{5} {\hat{Z}}_{7} {\hat{Z}}_{8} {\hat{Z}}_{9}$ . We next turn off this $\hat{Z}$ stabilizer and also turn the surrounding four-terminal $\hat{X}$ stabilizers into three-terminal stabilizers, leaving data qubit 6 without any stabilizer measurements. We perform an $\hat{X}$ measurement of data qubit 6 (using either an idle measure- $Z$ qubit or directly measuring the data qubit, as shown). (c) We define the extended operator ${\hat{X}}_{L}^{'}$ by multiplying ${\hat{X}}_{L}$ by ${\hat{X}}_{6}$ : ${\hat{X}}_{L}^{'} = {\hat{X}}_{6} {\hat{X}}_{L} = {\hat{X}}_{1} {\hat{X}}_{2} {\hat{X}}_{3} {\hat{X}}_{6}$ . We now turn on the $\hat{Z}$ stabilizer just above qubit 6; we wait $d$ surface code cycles in order to properly establish the value of this stabilizer. We define ${\hat{Z}}_{L}^{'}$ as the product of this $\hat{Z}$ stabilizer and ${\hat{Z}}_{L}^{e}$ : ${\hat{Z}}_{L}^{'} = {\hat{Z}}_{6} {\hat{Z}}_{7} {\hat{Z}}_{8} {\hat{Z}}_{9}$ .Reuse & Permissions
Figure 18
Process for moving a $Z$ -cut logical qubit hole through multiple cells, using a simplified representation where the ${\hat{X}}_{L}$ chain is a blue (light) line linking the logical qubit holes and passing through the data qubits (open circles), and the ${\hat{Z}}_{L}$ loop is in red (gray). The upper (gray) and lower (white) $Z$ -cut holes enclose idle $\hat{Z}$ stabilizers; the outlines of these holes have measure- $X$ qubits on the vertices with data qubits on the edges. (a) Initial state, showing the logical operators ${\hat{X}}_{L}$ and ${\hat{Z}}_{L}$ , with the initial (premove) software-corrected $\hat{Z}$ stabilizer measurement outcomes $Z_{s 2}^{i}, Z_{s 3}^{i}, ..., Z_{s, n}^{i}$ . The $\hat{Z}$ stabilizers involved in the next step are shown with thin black outlines; the $j$ th stabilizer ${\hat{Z}}_{s, j}$ is the stabilizer cell marked by that stabilizer's initial measurement outcome $Z_{s, j}^{i}$ . (b) Extension of ${\hat{Z}}_{L}$ to ${\hat{Z}}_{L}^{e}$ , with $\hat{X}$ measurements of the isolated data qubits yielding the measurement eigenvalues $X_{1}^{e}, X_{2}^{e}, ..., X_{n - 1}^{e}$ [data qubits filled in blue (light)]. (c) Final state, with ${\hat{Z}}_{L}^{'}$ the shifted ${\hat{Z}}_{L}$ logical operator and ${\hat{X}}_{L}^{'}$ the extended chain for ${\hat{X}}_{L}$ , with the $\hat{Z}$ stabilizers (thin black outlines) turned back on; after waiting $d$ surface code cycles, we establish the software-corrected final (postmove) measurement outcomes $Z_{s 1}^{f}, Z_{s 2}^{f}, ..., Z_{s, n - 1}^{f}$ .Reuse & Permissions
Figure 19
Braid transformation of a single $Z$ -cut qubit in a fully stabilized array, showing steps affecting the ${\hat{X}}_{L}$ operator [delineated in blue (dark)]. (a) Double $Z$ -cut qubit with the logical operator ${\hat{X}}_{L}$ , showing the three data qubits (open circles) that define the logical operator. (b) Extended opening (heavy gray) for first move in the braid. Data qubits isolated by the extension are measured in $\hat{X}$ with outcomes $X_{1}^{e}, ..., X_{8}^{e}$ . (c) The ${\hat{X}}_{L}$ operator (blue, dark) is extended to ${\hat{X}}_{L}^{'} = {\hat{X}}_{1}, ..., {\hat{X}}_{8} {\hat{X}}_{L}$ . (d) Second move in the braid, which again involves measuring isolated data qubits in $\hat{X}$ . (e) The ${\hat{X}}_{L}^{'}$ operator is extended to ${\hat{X}}_{L}^{''}$ and now includes the original chain linking the two qubit holes and in addition a closed loop of operators. (f) The closed loop is completely stabilized by the nine $\hat{X}$ stabilizers ${\hat{X}}_{s 1}, ... {\hat{, X}}_{s 9}$ [blue (dark) squares]. We can thus reduce the operator chain ${\hat{X}}_{L}^{''}$ to a chain ${\hat{X}}_{L}^{'''}$ that is identical to the original ${\hat{X}}_{L}$ , other than possible sign changes. The sign changes are captured as in the multicell move by defining the power $p_{X}$ through ${(- 1)}^{p_{X}} \equiv X_{s 1}^{f} X_{s 2}^{f}, ..., X_{s 9}^{f} = \pm 1$ , given by the product of all the $\hat{X}$ stabilizer measurement outcomes enclosed by the ${\hat{X}}_{L}^{''}$ loop. The power $p_{X} = 0 (1)$ determines whether a ${\hat{Z}}_{L}$ by-product operator does not (does) appear, multiplying the final wave function.Reuse & Permissions
Figure 20
Braid transformation of a ${\hat{Z}}_{L}$ operator on a single $Z$ -cut qubit in a fully stabilized array. (a) Double $Z$ -cut qubit with ${\hat{Z}}_{L}$ in red (gray); data qubits are open circles; dashed line linking the two qubit holes does not represent an operator. (b) Extended opening [solid red (gray) loop] for first move in the braid. The premove $\hat{Z}$ stabilizer outcomes $Z_{s 2}^{i}, ..., Z_{s 9}^{i}$ are all equal to $\pm 1$ . The ${\hat{Z}}_{L}^{e}$ operator [solid red (gray) loop] is extended from ${\hat{Z}}_{L}$ , ${\hat{Z}}_{L}^{e} \equiv {\hat{Z}}_{s 2}, ... {\hat{, Z}}_{s 9} {\hat{Z}}_{L}$ . (c) The extended opening is closed up by turning on the stabilizers ${\hat{Z}}_{s 1}, ..., {\hat{Z}}_{s 8}$ and waiting $d$ surface code cycles to obtain the error-corrected outcomes $Z_{s 1}^{e}, ..., Z_{s 8}^{e}$ . The new ${\hat{Z}}_{L}^{'}$ operator is the red (gray) loop formed by four data qubit $\hat{Z}$ operators, equal to ${\hat{Z}}_{L}^{'} = ({\hat{Z}}_{s 1}, ... {\hat{, Z}}_{s 8}) ({\hat{Z}}_{s 2}, ... {\hat{, Z}}_{s 9}) {\hat{Z}}_{L}$ . (d) Second move in the braid, which involves extending ${\hat{Z}}_{L}^{'}$ to ${\hat{Z}}_{L}^{e^{'}}$ , using the associated $\hat{Z}$ stabilizer outcomes. (e) The final ${\hat{Z}}_{L}^{''}$ is a closed loop of four data qubit operators identical to the original ${\hat{Z}}_{L}$ . ${\hat{Z}}_{L}^{''}$ may differ in sign with respect to ${\hat{Z}}_{L}$ , captured by defining ${(- 1)}^{p_{Z}} \equiv (Z_{s 9}^{f}, ..., Z_{s 12}^{f}) (Z_{s 10}^{i}, ..., Z_{s 13}^{i}) (Z_{s 1}^{f}, ..., Z_{s 8}^{f}) (Z_{s 2}^{i}, ..., Z_{s 9}^{i}) = \pm 1$ . The power $p_{Z}$ determines whether an ${\hat{X}}_{L}$ by-product operator appears, multiplying the final wave function.Reuse & Permissions
Figure 21
A braid on a $Z$ -cut qubit, where the lower $Z$ -cut hole of the qubit is braided around the upper $X$ -cut hole of an $X$ -cut qubit. The braid's effect on the ${\hat{X}}_{L 1}$ operator on $Z$ -cut qubit 1 is displayed. (a) $Z$ -cut qubit (above) and $X$ -cut qubit (below) with corresponding logical operators; data qubits are shown as open circles. (b) Extension for first move in braid, where data qubits are measured along $\hat{X}$ , with measurement outcomes $X_{1}^{e}, X_{2}^{e}, ..., X_{8}^{e}$ . (c) ${\hat{X}}_{L 1}$ operator is extended in length to ${\hat{X}}_{L 1}^{'}$ . (d) Extension for second move in braid, where data qubits are measured along $\hat{X}$ with measurement outcomes $X_{9}^{e}, ..., X_{12}^{e}$ . (e) ${\hat{X}}_{L 1}^{''}$ operator is extended in length, comprising the original chain plus a closed loop of data qubit operators, the loop enclosing the upper hole of the $X$ -cut qubit. (f) The loop part of the ${\hat{X}}_{L 1}^{''}$ operator is moved through the enclosed stabilized cells, leaving a loop of $\hat{X}$ data qubit operators that is equal to ${\hat{X}}_{L 2}$ on the second qubit, with ${\hat{X}}_{L 1}$ unchanged from before the braid (other than possible sign changes).Reuse & Permissions
Figure 22
(a)–(d) Illustration of the braid transformation of the ${\hat{I}}_{L 1} \otimes {\hat{X}}_{L 2}$ operator product. After the move, there is no net change of either operator.Reuse & Permissions
Figure 23
Braid transformation of ${\hat{I}}_{L 1} \otimes {\hat{Z}}_{L 2}$ . (a) Prior to the move, displaying ${\hat{I}}_{L 1}$ on qubit 1 and ${\hat{Z}}_{L 2}$ on qubit 2. Data qubits are shown as open circles where relevant. (b) The ${\hat{Z}}_{L 2}$ operator is extended by multiplying it by a set of stabilizers (dotted boxes), resulting in the heavy red (gray) line that is equivalent to the original ${\hat{Z}}_{L 2}$ , with the exception of possible sign changes. (c) Qubit 1's hole is moved through the path opened up by extending ${\hat{Z}}_{L 2}$ . (d) ${\hat{Z}}_{L 2}$ is moved back to its original form, leaving behind a loop of $\hat{Z}$ physical qubit operators that comprise a ${\hat{Z}}_{L 1}$ operator on qubit 1.Reuse & Permissions
Figure 24
(a) Logical cnot between two $Z$ -cut qubits. The control, target in, and the second ancilla (in $| +_{L} 〉$ ) are all $Z$ -cut qubits, while the first ancilla is an $X$ -cut qubit. The logical cnots are all between $Z$ - and $X$ -cut qubits, generated by braiding transformations. The measure outcomes $M_{Z}$ and $M_{X}$ signal how the output state should be interpreted, as described in the main text. (b) Simplified representation using braids, with black lines for $Z$ -cut qubits and blue (light) lines for the $X$ -cut qubit. There are a pair of lines for each logical qubit, one line for each qubit hole. The two lines join when a logical qubit is created or measured. (c) Even more condensed representation. (d) Logical cnot between two $X$ -cut qubits. The control, target in, and the first ancilla are all $X$ -cut qubits, while the second ancilla is a $Z$ -cut qubit. The logical cnots are all between $X$ - and $Z$ -cut qubits, generated by braiding transformations with the $Z$ -cut as the control. The measure outcomes $M_{Z}$ and $M_{X}$ signal how the output state should be interpreted. (e) Simplified representation, with black lines for the $Z$ -cut qubits and blue (light) for the $X$ -cut qubit. (f) Even more simplified representation.Reuse & Permissions
Figure 25
Schematic of circuit used to implement a single-qubit control, triple target logical cnot (circuit equivalent on right), using the same notation as was used in Fig. 24. The blue (light) lines are the logical $X$ -cut qubits used for the control and targets, and the black line is an ancillary logical $Z$ -cut qubit that serves as an intermediary between the $X$ -cut qubits. The sequence involves a total of six logical qubits, analogous to Fig. 24.Reuse & Permissions
Figure 26
Initial 2D array for the logical Hadamard example. The spacing and size of the $Z$ -cut qubit holes corresponds to a distance $d = 7$ . The two holes in the center of the array form the logical qubit that is the target for the logical Hadamard and for which we display the ${\hat{X}}_{L}$ and ${\hat{Z}}_{L}$ logical operators. The dashed box outlines the limits for what is shown in Figs. 27 and 28.Reuse & Permissions
Figure 27
(a) In the first surface code cycle for the Hadamard, a ring of $\hat{X}$ stabilizers surrounding the target logical qubit is turned off, and the four-terminal $\hat{Z}$ stabilizers on the ring's borders are reduced to three- and two-terminal measurements. The data qubits isolated within the ring itself are measured in the $\hat{Z}$ basis to maintain error tracking with the reduced-size $\hat{Z}$ stabilizers. This stabilizer measurement pattern is applied three times (three is specific to the distance-7 qubits used here; see Ref. [45]). (b) The ${\hat{Z}}_{L}$ operator (dashed red line) is multiplied by all the black outline $\hat{Z}$ stabilizers, transforming ${\hat{Z}}_{L}$ to a chain of operators (solid red line) going from left to right. (c) In the next surface code cycle, all $\hat{X}$ and $\hat{Z}$ stabilizers in 2D patch outside the dashed box are turned off, widening the ring into a “moat” as in (d), eliminating the two qubit holes. In the same cycle, all isolated data qubits are measured on the $\hat{Z}$ basis, except those colored blue (light), which are measured in the $\hat{X}$ basis to preserve error tracking with the adjacent three-terminal $\hat{X}$ stabilizers. Note that the other unstabilized data qubits do not need to be measured, as changes in their quantum states will be accounted for once their respective stabilizers are turned back on. (e) Before the next surface code cycle starts, a physical Hadamard is performed on all data qubits, swapping ${\hat{X}}_{L}$ and ${\hat{Z}}_{L}$ and the stabilizer identities. (f) Following the Hadamard, a pair of swap operations is performed between each patch data qubit and its neighboring measure qubits, first between each data qubit and the measure qubit above it, then between each measure qubit and the data qubit to its left. This shifts the patch by one stabilizer cell in the array, aligning the measure qubits in the patch with those in the larger array. The dashed box shows the location of the patch prior to these swaps. This sequence continues in Fig. 28.Reuse & Permissions
Figure 28
(Continued from Fig. 27) (g) In the next surface code cycle, most of the $\hat{X}$ and $\hat{Z}$ stabilizers are turned back on, leaving two $Z$ -cut enlarged holes and a ring, one stabilizer cell wide, isolating the 2D patch from the array, as in Fig. 27a. The $Z$ -cut holes are positioned so that the ${\hat{X}}_{L}$ chain ends on the internal boundary of each hole. The ${\hat{Z}}_{L}$ chain (dashed red line) is multiplied by all the black outline $\hat{Z}$ stabilizers, leaving a ${\hat{Z}}_{L}$ loop (solid red line) that encloses the right $Z$ -cut hole. (h) In the subsequent surface code cycle, and the first step of returning the $Z$ -cut holes to original locations, the $Z$ -cut holes are expanded and ${\hat{Z}}_{L}$ and ${\hat{X}}_{L}$ modified accordingly. This move is split in two steps to preserve the distance $d$ during this process; the process pauses here for $d$ surface code cycles to establish all values in time. (i) In the second step of returning the $Z$ -cut holes to their original locations, the $Z$ -cuts are expanded to encompass the original positions. The stabilizer measurements are performed twice. (j) In the final step, the cuts are reduced to their original size, as in Fig. 26. This stabilizer measurement pattern is applied three times (see Ref. [45]). Following this, the isolated patch is reconnected by turning on the appropriate stabilizers.Reuse & Permissions
Figure 29
Logic circuit that implements the ${\hat{S}}_{L}$ gate. The circuit uses the ancilla state $| Y_{L} 〉 = (| g_{L} 〉 + i | e_{L} 〉) / \sqrt{2}$ , on which two controlled logical cnots and two logical Hadamards are performed, resulting in the input state $| ψ_{L} 〉$ being transformed to ${\hat{S}}_{L} | ψ_{L} 〉$ . Note that as ${\hat{S}}_{L}^{†} = {\hat{Z}}_{L} {\hat{S}}_{L}$ , the same circuit transforms $| ψ_{L} 〉$ to ${\hat{Z}}_{L} {\hat{S}}_{L}^{†} | ψ_{L} 〉$ , where ${\hat{Z}}_{L}$ is a by-product operator.Reuse & Permissions
Figure 30
Logic circuit for the ${\hat{T}}_{L}$ gate. The circuit uses the ancilla state $| A_{L} 〉 = (| g_{L} 〉 + e^{i π / 4} | e_{L} 〉) / \sqrt{2}$ , which is used to control a cnot on the target state $| ψ_{L} 〉$ , transforming the ancilla to the output state $| φ_{L} 〉$ . The cnot target state is measured along ${\hat{Z}}_{L}$ , resulting in a projective, probabilistic outcome. Following this, the cnot control qubit is processed by a conditional ${\hat{S}}_{L}$ gate: If the ${\hat{Z}}_{L}$ measurement $M_{Z}$ yields a $+ 1$ outcome, the output state is the desired one, $| φ_{L} 〉 = {\hat{T}}_{L} | ψ_{L} 〉$ , and the ${\hat{S}}_{L}$ gate is not applied. If, however, the measurement yields a $- 1$ outcome, the output is $| φ_{L} 〉 = {\hat{X}}_{L} {\hat{T}}_{L}^{†}$ and the ${\hat{S}}_{L}$ gate is applied, resulting in the output ${\hat{X}}_{L} {\hat{Z}}_{L} {\hat{T}}_{L} | ψ_{L} 〉$ . Note the double lines represent the classical measurement data with a probabilistic outcome, with these data controlling the ${\hat{S}}_{L}$ gate. The bracketed operators in the output correspond to $M_{Z} = + 1$ ( ${\hat{I}}_{L}$ ) and $M_{Z} = - 1$ ( ${\hat{X}}_{L} {\hat{Z}}_{L}$ ).Reuse & Permissions
Figure 31
Sequence to generate a short $X$ cut qubit. (a) surface code array, with the array extending indefinitely outside the region shown here. (b) Two $\hat{X}$ stabilizers are turned off, creating a short $X$ cut qubit, with a single data qubit separating the two holes. (c) In the next surface code cycle, the central data qubit (qubit 5) is measured along $\hat{X}$ simultaneously with the measurement of the four-terminal $\hat{Z}$ stabilizers adjacent to it; the remainder of the array has the standard surface code cycle for all stabilizers. This creates a logical qubit initialized in either $| +_{L} 〉$ ( $X_{5} = + 1$ ) or $| -_{L} 〉$ ( $X_{5} = - 1$ ). Prior to starting the next surface code cycle, the central data qubit is rotated using ${\hat{R}}_{Z} (θ)$ to the desired final state $| g_{L} 〉 + e^{i θ} | e_{L} 〉$ . (d) The surface code stabilization is restarted. After this the short qubit is enlarged to protect against errors.Reuse & Permissions
Figure 32
Distillation circuit for the $| Y_{L} 〉$ ancilla state. A logical Bell pair is created (dashed box, bottom left), and one qubit from the pair is encoded with 6 ancilla logical qubits using the Steane code [14, 47]. The seven encoded qubits are then each rotated with an ${\hat{S}}_{L}$ gate (dotted blue); the ancilla states used by the ${\hat{S}}_{L}$ gates are precisely the $| Y_{L} 〉$ states that are being purified, produced in the first round of distillation by state injection in a short qubit, or are from a prior round of distillation. The output from each ${\hat{S}}_{L}$ gate is then measured along ${\hat{X}}_{L}$ , and the results indicate whether the output state $| ψ_{L} 〉$ in the other qubit of the Bell pair should be discarded, or is a purified version of $| Y_{L} 〉$ , possibly involving a ${\hat{Z}}_{L}$ phase flip (in software) as discussed in the main text.Reuse & Permissions
Figure 33
Distillation circuit for the $| A_{L} 〉$ ancilla state [14, 47]. (a) A logical Bell pair is created (dashed box, bottom left), and one qubit from the pair encoded with 14 ancilla logical qubits using the Reed-Muller code [12, 47]. The 15 encoded logical qubits are then each rotated with a ${\hat{T}}_{L}^{†}$ gate (dotted blue). The ancillae for the ${\hat{T}}_{L}^{†}$ gates are the $| A_{L} 〉$ states that are being purified, either prepared by state injection in a short qubit or produced in a previous distillation round. Following the ${\hat{T}}_{L}^{†}$ gates, 15 ${\hat{X}}_{L}$ measurements $M_{X}$ are made, with the measurement pattern indicating whether to discard the output state $| ψ_{L} 〉$ of the other qubit of the Bell pair or indicating that $| ψ_{L} 〉$ is a purified $| A_{L} 〉$ state, possibly with an additional ${\hat{Z}}_{L}$ by-product operator. (b) Diagram for the ${\hat{T}}_{L}^{†}$ gate, which is similar to the ${\hat{T}}_{L}$ gate in Fig. 30, with a cnot using the imperfect $| A_{L} 〉$ (blue, light) as the control on the input state $| χ_{L} 〉$ . When the measurement $M_{Z} = - 1$ , the output is ${\hat{X}}_{L} {\hat{T}}_{L}^{†} | χ_{L} 〉$ ; the ${\hat{X}}_{L}$ has no effect when the $M_{X}$ measurement is made in panel (a). When the measurement $M_{Z} = + 1$ , the output is ${\hat{T}}_{L} | χ_{L} 〉$ , and must be corrected (up to by-product operators) using the ${\hat{S}}_{L}$ circuit in Fig. 29, giving ${\hat{S}}_{L} {\hat{T}}_{L} | χ_{L} 〉 = {\hat{Z}}_{L} {\hat{T}}_{L}^{†} | χ_{L} 〉$ . The by-product operator ${\hat{Z}}_{L}$ will reverse the sign of the measurement $M_{X}$ that occurs after this gate in panel (a).Reuse & Permissions
Figure 34
(a) Two data qubits $a$ and $b$ are stabilized by one measure- $Z$ and one measure- $X$ qubit, connected as shown. (b) Quantum circuit for the two measure qubits operating on the two data qubits. The cnot order is critical: First, the measure- $X$ qubit acts as the control of the cnot on data qubits $a$ followed by that on $b$ ; the two cnots are preceded and followed by a Hadamard $\hat{H}$ . The measure- $Z$ qubit is then the target of a cnot with $a$ as the control, followed by that with $b$ as a control. The two identity $\hat{I}$ operators for the measure- $Z$ process, which are performed by simply waiting, ensure that the timing on the measure- $Z$ qubit matches that of the measure- $X$ qubit. The measurement operators that correspond to steps 3 through 6 of the control sequence, followed by the projective measurement at the end of the circuit, are indicated below the relevant cnots, with the measure- $X$ qubit stabilizing the product ${\hat{X}}_{a} {\hat{X}}_{b}$ and the measure- $Z$ qubit stabilizing ${\hat{Z}}_{a} {\hat{Z}}_{b}$ .Reuse & Permissions
Figure 35
(a) The left panel shows original portion of the $| \hat{Y} 〉$ distillation circuit, involving the $\hat{S}$ gate followed by measurement $M_{X}$ , whereas the right panel shows the expanded $\hat{S}$ circuit displaying the logical cnot and measurements $M_{Z}^{'}$ and $M_{X}^{'}$ . (b) Same as (a) but for a portion of the $| A 〉$ distillation circuit, involving the ${\hat{T}}^{†}$ gate. A conditional $\hat{S}$ gate is applied to the upper qubit if $M_{Z}^{'} = + 1$ .Reuse & Permissions

Physical Review A

covering atomic, molecular, and optical physics and quantum information