Quantum error correction with only two extra qubits

TL;DR

This paper presents fault-tolerant quantum error correction methods that require only two additional qubits, enabling efficient protection of quantum information with minimal qubit overhead.

Contribution

Introduction of fault-tolerant error-correction procedures using only two ancilla qubits applicable to various distance-three codes.

Findings

Allows testing of the [[5,1,3]] code with only seven qubits total.

Techniques extend to [[7,1,3]] and [[15,7,3]] codes.

Enables protection of seven qubits on a 17-qubit device.

Abstract

Noise rates in quantum computing experiments have dropped dramatically, but reliable qubits remain precious. Fault-tolerance schemes with minimal qubit overhead are therefore essential. We introduce fault-tolerant error-correction procedures that use only two ancilla qubits. The procedures are based on adding "flags" to catch the faults that can lead to correlated errors on the data. They work for various distance-three codes. In particular, our scheme allows one to test the [[5,1,3]] code, the smallest error-correcting code, using only seven qubits total. Our techniques also apply to the [[7,1,3]] and [[15,7,3]] Hamming codes, thus allowing to protect seven encoded qubits on a device with only 17 physical qubits.

Tables

Table 1. Table 1: Numbers of ancilla qubits required for different fault-tolerant syndrome-extraction methods. Shor’s method, using a verified cat state, requires w + 1 𝑤 1 w+1 ancilla qubits, where w 𝑤 w is the largest weight of a stabilizer generator. (The [ [ 9 , 1 , 3 ] ] delimited-[] 9 1 3 {[\![}9,1,3{]\!]} Bacon-Shor code is an exception, as it is a subsystem code.) Stephens, Yoder and Kim  Stephens ( 2014 ); Yoder and Kim ( 2017 ) have proposed using a cat state on only max ⁡ { 3 , ⌈ w / 2 ⌉ } 3 𝑤 2 \max\{3,\lceil w/2\rceil\} qubits, combined with a decoding trick from  DiVincenzo and Aliferis ( 2007 ) ; see Appendix  A . When applicable, our flagged error-correction procedure needs only two extra qubits, as observed for the [ [ 7 , 1 , 3 ] ] delimited-[] 7 1 3 {[\![}7,1,3{]\!]} code by  Yoder and Kim ( 2017 ) . Codes marked ⋄ ⋄ \diamond are Hamming codes.

	Ancilla qubits required for
	Shor	Decoded
Code	cat state	half cat	Flagged
$[[5,1,3]]$	5	3	2
$\diamond$ $[[7,1,3]]$	5	3	2 Yoder and Kim (2017)
$[[9,1,3]]$	1	–	–
$[[8,3,3]]$	7	3	2
$[[10,4,3]]$	9	4	2
$[[11,5,3]]$	9	4	2
$\diamond$ $[[15,7,3]]$	9	4	2
$\diamond$ $[[31,21,3]]$	17	8	2
$\diamond$ $[[2^r-1,2^r-1-2r,3]]$	$2^{r-1}+1$	$2^{r-2}$	2

Equations

$$1,Z_7,Z_6{Z}_7,Z_5{Z}_6{Z}_7\sim Z_4$$

$$\begin{array}{c}1,Z_8,Z_{\{8,9\}},Z_{\{8,9,10\}},Z_{\{8,9,10,12\}},Z_{\{8,9,10,11,12\}},\\ Z_{\{8,9,10,11,12,14\}},Z_{\{8,9,10,11,12,13,14\}}\end{array}$$

Full text

In particular, our scheme allows one to test the ${[\![}5,1,3{]\!]}$ code, the smallest error-correcting code, using only seven qubits total. Our techniques also apply to the ${[\![}7,1,3{]\!]}$ and ${[\![}15,7,3{]\!]}$ Hamming codes, thus allowing to protect seven encoded qubits on a device with only $17$ physical qubits.

I Introduction

Fault-tolerant quantum computation is possible: quantum computers can tolerate noise and imperfections. Fault tolerance will be necessary for running quantum algorithms on large-scale quantum computers. However, fault-tolerance schemes have substantial overhead; many physical qubits are used for each encoded, logical qubit. This means that on small- and medium-scale devices in the near future, it will be difficult to test fault tolerance, and to explore the efficacy of different fault-tolerance schemes. We aim to reduce the qubit overhead, especially for small devices.

Five-qubit systems are enough to test very limited fault-tolerance schemes Linke et al. (2016); Gottesman (2016). The ${[\![}4,1,2{]\!]}$ Bacon-Shor subsystem code encodes one logical qubit into four physical qubits. A fifth qubit is needed for fault-tolerant error detection. Since the code has distance two, it can only detect an error, not correct it.

Until recently, the smallest known scheme that can correct an error used the ${[\![}9,1,3{]\!]}$ Bacon-Shor code, plus a tenth ancilla qubit. Although smaller, more efficient error-correcting codes are known, such as the ${[\![}5,1,3{]\!]}$ perfect code (the smallest distance-three code), the ${[\![}7,1,3{]\!]}$ Steane code, or the ${[\![}8,3,3{]\!]}$ code, fault-tolerance schemes using these codes have required at least as many qubits total. For example, Shor-style syndrome extraction Shor (1996); DiVincenzo and Aliferis (2007) requires $w+1$ or $w$ ancilla qubits, where $w$ is the largest weight of a stabilizer generator. Steane-style error correction Steane (1997, 2002); DiVincenzo and Aliferis (2007) uses at least a full code block of extra qubits, and Knill’s scheme Knill (2005a) uses an encoded EPR state and thus at least two ancilla code blocks.

Yoder and Kim Yoder and Kim (2017) have given fault-tolerance schemes using the ${[\![}5,1,3{]\!]}$ code with eight qubits total, and the ${[\![}7,1,3{]\!]}$ code with nine qubits total. Extending the latter construction, we introduce fault-tolerance procedures that use only two extra qubits. Figure 1 highlights some examples, and Table 1 compares the qubit overhead of our scheme to the Shor and Stephens-Yoder-Kim methods (described in Appendix A). In particular, with the ${[\![}5,1,3{]\!]}$ code our scheme uses only seven qubits total, or ten qubits with the ${[\![}8,3,3{]\!]}$ code. A particularly promising application is to the ${[\![}15,7,3{]\!]}$ Hamming code: $17$ physical qubits suffice to protect seven encoded qubits. In Chao and Reichardt (2017), we give fault-tolerant procedures for applying arbitrary Clifford operations on these encoded qubits, also using only two extra qubits, and fault-tolerant universal operations with four extra qubits, $19$ total. Substantial fault-tolerance tests can therefore be run on a quantum computer with fewer than twenty qubits.

Our procedures here are based on adding “flags” to the syndrome-extraction circuits in order to catch the faults that can lead to correlated errors on the data. Figure 2(c) shows an example. Provided that syndromes are extracted in a careful order, detecting the possible presence of a correlated error is enough to correct it.

II Two-qubit fault-tolerant error correction for the ${[\![}5,1,3{]\!]}$ code

The perfect ${[\![}5,1,3{]\!]}$ code Laflamme et al. (1996) has the stabilizer generators, and logical $X$ and $Z$ operators of Fig. 2(a). (For the basics of stabilizer algebra, quantum error-correcting codes and fault-tolerant quantum computation, we refer the reader to Gottesman (2010).)

The syndrome for the first stabilizer, $XZZXI$, can be extracted by the circuit in Fig. 2(b), where $Z$ indicates a ${|0\rangle},{|1\rangle}$ measurement, and  . However, this circuit is not fault tolerant. For example, if the second gate fails and after it is applied an $IZ$ fault, then this fault will propagate through the subsequent gates to become an $IIZXI$ error on the data. Thus a single fault can create a weight-two error on the data, and even a perfect error-correction procedure will correct this error in the wrong direction, creating the logical error $IIZXZ\sim\macc@depth\char 1\relax\frozen@everymath{\macc@group}\macc@set@skewchar\macc@nested@a 111{X}$.

To fix this problem, we instead extract the $XZZXI$ syndrome using the circuit in Fig. 2(c). With no faults, this circuit behaves exactly the same as that of Fig. 2(b), and the $X$-basis (${|+\rangle},{|-\rangle}$) measurement will always give ${|+\rangle}$. The purpose of the ${|+\rangle}$ ancilla qubit, which we term a “flag,” is to detect gate faults that can propagate to correlated errors, weight two or higher, on the data. Failures after gates $a$ and $d$ cannot create correlated errors. The failures after gates $b$ and $c$ that can create correlated errors are listed in Fig. 2(d). ($Y$ failures on the second qubit have the same effect on the data as $Z$ failures.) These failures will all be detected, causing a ${|-\rangle}$ measurement outcome. Moreover, observe that the seven distinct data errors have distinct, nontrivial syndromes.

The complete error-correction procedure is given by:

Error-correction procedure

Use the circuit of Fig. 2(c) to extract the $XZZXI$ syndrome.

1. (a)

If the flag qubit is measured as ${|-\rangle}$, then use the unflagged circuits analogous to Fig. 2(b) to extract all four syndromes. Finish by applying the corresponding correction from among $IIIII$, $IIZXI$, $IXZXI$, $IYZXI$, $IZZXI$, $IIIXI$, $IIXXI$, $IIYXI$. 2. (b)

Otherwise, if the syndrome is $-1$, i.e., the syndrome qubit is measured as ${|1\rangle}$, then use unflagged circuits to extract all four syndromes. Finish by applying the corresponding correction of weight $\leq 1$. 2. 2.

(If the flag was not raised and the syndrome was trivial, then) Similarly extract the $IXZZX$ syndrome. If the flag is raised, then use unflagged circuits to extract the four syndromes, and finish by applying the correction from among $IIIII$, $IIIIX$, $IXXII$, $IIIXX$, $XIIIY$, $IXIII$, $IIIZX$, $IIIYX$. If the syndrome is nontrivial, then use unflagged circuits to extract the four syndromes, and finish by applying the correction of weight $\leq 1$. 3. 3.

Similarly extract the $XIXZZ$ syndrome, and correct if the flag is raised or the syndrome is nontrivial. 4. 4.

Similarly extract the $ZXIXZ$ syndrome, and correct if the flag is raised or the syndrome is nontrivial.

We now argue that this procedure is fault tolerant.

• •

If there are no faults, then it appropriately corrects the data to the codespace.

• •

If the data lies in the codespace and there is at most one faulty gate in the error-correction procedure, then:

• –

If all syndromes and flags are trivial, then the data can have at most a weight-one error. (No correction is applied.)

• –

If a flag is raised or a syndrome is nontrivial, then the subsequent unflagged syndrome extractions are perfect, and suffice to correct either a possibly correlated error (if the flag is raised) or a weight $\leq 1$ error (if no flag is raised but the syndrome is nontrivial).

Let us point out that when a syndrome extracted by a flagged circuit is nontrivial, then even if the flag is not raised we still extract all four syndromes (using unflagged circuits) before applying a correction. This is because a fault on the data could have been introduced in the middle of syndrome extraction. For example, if we extract the first syndrome as $+1$, but a $Z_{1}$ error is then added to the data, the remaining syndromes will be $+1,-1,+1$. The correction for $(+,+,-,+)$ is $Z_{3}$, but were we to apply this correction the data would end up with error $ZIZII$. This moral is that nontrivial syndromes cannot be trusted unless they are repeated.

We give two-ancilla-qubit fault-tolerant state preparation and measurement circuits in Appendix B.

III Two-qubit fault-tolerant error correction for Hamming codes

The Hamming codes are a family of ${[\![}2^{r}-1,2^{r}-1-2r,3{]\!]}$ quantum error-correcting codes, for $r=3,4,5,\ldots$. They are self-dual perfect CSS codes.

III.1 ${[\![}7,1,3{]\!]}$ Steane code

The ${[\![}7,1,3{]\!]}$ code, known as Steane’s code Steane (1996a), has the stabilizers and logical operators given in Fig. 3(a).

The circuit in Fig. 3(b) extracts the $IIIZZZZ$ syndrome. As in Fig. 2(b), any single gate fault that leads to a data error of weight $\geq 2$ will also make the $X$ measurement output ${|-\rangle}$. Moreover, if that measurement gives ${|-\rangle}$ with a single fault, the error’s possible $Z$ components are

[TABLE]

These errors are distinguishable by their $X$ syndromes.

Similar circuits work for the other stabilizers, thus giving a two-qubit fault-tolerant error-correction procedure.

III.2 ${[\![}15,7,3{]\!]}$ Hamming code

The $r=4$, ${[\![}15,7,3{]\!]}$ code has four $X$ and four $Z$ stabilizers each given by the parity checks of Fig. 3(c). Observe that the columns form the numbers $1$ through $2^{r}-1$, written in binary; this holds for each Hamming code.

For a subset $S$, let $Z_{S}=\prod_{j\in S}Z_{j}$. The circuit of Fig. 3(d) works to fault-tolerantly extract the first $Z$ syndrome, for $Z_{\{8,\ldots,15\}}$. If the flag is triggered by a single fault, then the possible error $Z$ components are

[TABLE]

Once again, these errors are distinguishable by their $X$ syndromes. (The order of the CNOT gates is important.)

Appendix C gives a single-ancilla fault-tolerant circuit to prepare encoded ${|0^{7}\rangle}$.

III.3 General Hamming codes

Claim 1**.**

Syndromes for the ${[\![}2^{r}-1,2^{r}-1-2r,3{]\!]}$ Hamming code can be fault-tolerantly extracted with two qubits.

Proof.

Consider the stabilizer $Z_{\{2^{r-1},\ldots,2^{r}-1\}}$. As in Figs. 3(b) and 3(d), we give a permutation of the last $2^{r-1}$ qubits so that, when the flag is triggered, the possible $Z$ errors have distinct syndromes.

Let $p(x)$ be a degree-$(r-1)$ primitive polynomial over $\mathrm{GF}(2)$. For $j=0,\ldots,2^{r-1}-2$, let $q_{j}(x)=x^{j}\mod p$; these are distinct polynomials of degree $\leq r-2$. Furthermore, the remainders of their cumulative sums, $\sum_{i=0}^{j}x^{i}$, are also distinct. (Otherwise, if $0\equiv x^{j+1}+\ldots+x^{k}=x^{j+1}(x^{k-j}+1)/(x+1)$, then considering the lowest-order terms give $x^{k-j}+1\equiv 0$, contradicting that $p$ is primitive.)

The desired permutation is $2^{r-1},q_{0}(2)+2^{r-1},q_{1}(2)+2^{r-1},\ldots,q_{2^{r-1}-2}(2)+2^{r-1}$. ∎

IV Two-qubit fault-tolerant

error correction for

other distance-three codes

Figure 4 presents ${[\![}8,3,3{]\!]}$, ${[\![}10,4,3{]\!]}$ and ${[\![}11,5,3{]\!]}$ codes Gottesman (1996); Steane (1996b); Calderbank et al. (1997). Many other distance-three codes are given in the code tables at Grassl (2007).

The general property required for our flagged procedure to work for measuring an operator is: for an operator $Z_{1}Z_{2}Z_{3}\ldots Z_{w}$ (up to qubit permutations and local Clifford unitaries), the different errors $P_{j}Z_{j+1}\ldots Z_{w}$, for $P\in\{I,X,Y,Z\}$ and $j\in\{2,\ldots,w-1\}$, should have distinct and nontrivial syndromes. (For a CSS code, for which $X$ and $Z$ errors can be corrected separately, it is enough that the syndromes for different errors be different for $P\in\{I,Z\}$.)

We have verified this property for some qubit permutation of each of the stabilizer generators for the ${[\![}10,4,3{]\!]}$ and ${[\![}11,5,3{]\!]}$ codes from Fig. 4. For the ${[\![}8,3,3{]\!]}$ code, we have found permutations that work for each of the stabilizer generators except $X^{\otimes 8}$ and $Z^{\otimes 8}$. However, we can replace these stabilizer generators with, respectively, $XXYZIYZI$ and $ZZIXYIXY$, which do satisfy the desired property. For example, to extract the syndrome of $XXYZIYZI$, couple the qubits to the ancilla in the order $1,2,3,6,4,7$. (With the order $1,2,3,4,6,7$, the errors $IIIIIYZI$ and $IXYZIYZI$ have the same syndrome.)

Therefore, for all of these codes, two ancilla qubits are enough to fault-tolerantly extract the syndromes and apply error correction.

V Two-qubit fault-tolerant error detection for ${[\![}n,n-2,2{]\!]}$ codes

The idea of flagging faults that can spread badly is also useful for error-detecting codes.

For even $n$, the ${[\![}n,n-2,2{]\!]}$ error-detecting code has stabilizers $X^{\otimes n}$ and $Z^{\otimes n}$, and logical operators $\macc@depth\char 1\relax\frozen@everymath{\macc@group}\macc@set@skewchar\macc@nested@a 111{X}_{j}=X_{1}X_{j+1}$, $\macc@depth\char 1\relax\frozen@everymath{\macc@group}\macc@set@skewchar\macc@nested@a 111{Z}_{j}=Z_{j+1}Z_{n}$ for $j=1,\ldots,n-2$.

Observe that extracting a syndrome with a single ancilla qubit is not fault tolerant because, for example, a $Z$ fault at either location indicated with a {\color[rgb]{1,0,0}\bigstar} in Fig. 5(a) results in an undetectable logical error. With a flag qubit, the circuit is fault tolerant; any single fault is either detectable or creates no data error.

This approach works for any $n$. One way of interpreting it is that the ancilla is encoded into the two-qubit $Z$-error detecting code, with stabilizers $XX$ and logical operators $\macc@depth\char 1\relax\frozen@everymath{\macc@group}\macc@set@skewchar\macc@nested@a 111{X}=XI$ and $\macc@depth\char 1\relax\frozen@everymath{\macc@group}\macc@set@skewchar\macc@nested@a 111{Z}=ZZ$. This code detects the single $Z$ faults that can propagate back to the data.

In Appendix D we give single-ancilla fault-tolerant circuits for initialization and projective measurement.

VI Simulations and conclusion

In order to get a sense for the practicality of the two-qubit error-correction schemes, we simulate error correction using a standard depolarizing noise error model on the one- and two-qubit operations Knill (2005b).111The source code is at https://github.com/chaor11/twoqubitec. Figure 6 shows the results from simulating at least $10^{6}$ consecutive error-correction rounds for each value of the CNOT failure rate $p$. Observe that for the ${[\![}15,7,3{]\!]}$ code, Steane-style error correction, which extracts all stabilizer syndromes at once, performs better than either the Shor-style or two-qubit procedures. For the ${[\![}5,1,3{]\!]}$ and ${[\![}7,1,3{]\!]}$ codes, the different error-correction methods are all very close. Note that we do not introduce memory errors on resting qubits, and nor do we add errors for moving qubits into position to apply the gates; we leave more detailed simulations and optimizations to future work.

We have focused on extracting syndromes using two ancilla qubits in order to minimize the qubit overhead. With just one more qubit, however, fault-tolerant syndrome extraction becomes considerably simpler. Consider for example the circuit in Fig. 7 for extracting a $ZZZZ$ syndrome.

Every CNOT gate into the syndrome qubit has its own flag, to catch $Z$ faults that can lead to correlated $Z$ errors on the data. The flags allow for closely localizing any fault, thereby easing error recovery. For example, if there is a single fault and only the second flag above is triggered, then the $Z$ error on the data can be $IIII$, $IZZZ$ or $IIZZ$. The regions covered by the flags overlap so that no $Z$ fault is missed. This technique is most effective if qubit initialization and measurement is fast. Less extreme versions of the technique, in which some gates share flags, can also be used. In Chao and Reichardt (2017) we use variants of this technique to apply operations fault tolerantly to data in a block code, with little qubit overhead.

For a large code with many stabilizers, it can be inefficient to extract the syndromes one at a time. The circuit in Fig. 8(a) extracts two of the ${[\![}7,1,3{]\!]}$ code’s syndromes at once, using a shared flag. Figure 8(b) uses a shared flag to extract all three $Z$ syndromes. A single fault can lead to at most a weight-one $X$ error and, if the flag is not triggered, a weight-one $Z$ error. If the flag is triggered, the gates are arranged so that the different $Z$ errors are distinguishable. The circuit uses four qubits and $15$ CNOT gates, versus seven qubits and $25$ CNOT gates for Steane-style extraction with ancilla decoding DiVincenzo and Aliferis (2007); however the syndrome $001$ can occur with errors $\boldsymbol{1}$, $Z_{1}$, $Z_{3}$ or $Z_{5}$ and so, unlike in Steane’s scheme, must be verified before applying a correction.

The design space for fault-tolerant error correction thus expands considerably with more allowed qubits. A natural problem is to extend the flag technique to medium-size codes of higher distance.

Acknowledgements

We thank Qian Yu for suggesting the construction of Claim 1, and thank Ted Yoder, Earl Campbell and James Wootton for helpful comments. Research supported by NSF grant CCF-1254119 and ARO grant W911NF-12-1-0541.

Appendix A Stephens-Yoder-Kim space-optimized syndrome extraction

For a distance-three code, Shor’s method Shor (1996) uses $w+1$ ancilla qubits to fault-tolerantly extract the syndrome of a weight-$w$ stabilizer, by preparing and verifying a $w$-qubit cat state $\tfrac{1}{\sqrt{2}}({|0^{w}\rangle}+{|1^{w}\rangle})$. For example, to extract an $XXXX$ syndrome, $w=4$, run the following circuit:

[TABLE]

The $Z$ measurement is to catch correlated $X$ errors. If it returns ${|0\rangle}$, apply four CNOT gates into the data qubits and measure each ancilla in the $X$ basis.

For $w=4$ and $w=7$, DiVincenzo and Aliferis DiVincenzo and Aliferis (2007) give circuits that use unverified $w$-qubit cat states, that interact with the data without waiting for a measurement to finish. Instead of measuring the cat state immediately after coupling it to the data, they first apply a carefully designed decoding circuit. They conjecture the technique extends to arbitrary $w$.

In fact, one can do better. Stephens Stephens (2014) has proposed that for $w\leq 8$, four ancilla qubits are enough to fault-tolerantly extract the syndrome, and Yoder and Kim Yoder and Kim (2017) have shown that three qubits are enough for $w=4$. We will show that in general, for a distance-three code, $\max\{3,\lceil w/2\rceil\}$ qubits suffice to fault-tolerantly extract a weight-$w$ stabilizer’s syndrome. Unlike our two-qubit schemes, this method can also be “deterministic” Cross et al. (2009).

The basic idea is to follow the DiVincenzo-Aliferis method, except coupling two data qubits to each ancilla qubit; with appropriate corrections, this remains fault tolerant. Figure 9(a) sketches the technique for the minimum number, three, of ancilla qubits, and Fig. 9(b) shows the construction for $w=10$. The general case follows a similar pattern.

Observe that in Fig. 9(b) a failure of gate a can propagate to a data error $P_{1}X_{2}$ for any $P\in\{I,X,Y,Z\}$. A failure of gate b can create a $P_{2}$ data error. The $X_{2}$ correction, applied when the $Z$ measurements output $1000$, ensures that at the end the data has an error of weight $\leq 1$. The corrections for $Z$ measurements $0100$, $0010$, $0001$ and $1111$ are similar. Failures at locations $c$ and $d$ can cause data errors of weight four or six, respectively, but these are caught and corrected for with $Z$ measurements $1100$ or $1110$. It is important that after the coupling to the data no single fault can cause the measurements to give $1100$ or $1110$.

Appendix B Fault-tolerant state preparation and measurement for the ${[\![}5,1,3{]\!]}$ code

B.1 State preparation

The black portion of the circuit in Fig. 10(a) prepares, up to Paulis, encoded ${|+\rangle}$, the five-cycle graph state with stabilizers $ZXZII$ and its cyclic permutations. Then three of the syndromes are measured. Provided that there is at most one gate fault, and the syndrome (blue) and flag (red) measurements are trivial, the output has at most a weight-one error. One can apply transversal Clifford operators to obtain encoded ${|0\rangle}$.

B.2 Measurement

Although logical $Z$ is transversal, $\macc@depth\char 1\relax\frozen@everymath{\macc@group}\macc@set@skewchar\macc@nested@a 111{X}=XXXXX$, it is not fault tolerant to measure $X$ transversally. The problem is that, as the ${[\![}5,1,3{]\!]}$ code is not CSS, the $X$ measurements do not give sufficient information to correct errors. Fortunately, we can apply the same flag trick that we used for error correction. We give a two-ancilla-qubit fault-tolerant circuit for destructively measuring $\macc@depth\char 1\relax\frozen@everymath{\macc@group}\macc@set@skewchar\macc@nested@a 111{X}$.

Let $s_{1}$ be the result of measuring $XZIIZ$ using a flag, as in part I of Fig. 10(b).

If the flag is raised, skip to part IV. Apply the five-$C\!Z$ decoding circuit, measure the qubits and decode to get the answer. (Given that the flag was raised, the data error can be $IIIII$, $IZIII$, $XZIII$, $YZIII$ or $ZZIII$ before decoding, and $IIIII,IZIII,XIIIZ,YIIIZ$ or $ZZIII$ after. These errors can be distinguished and corrected for.) 2. 2.

Measure $ZXZII$ with a flag, and call the result $s_{2}$, as in part II of Fig. 10(b).

If the flag is raised, then return $s_{1}$.

If the flag is not raised, and $s_{2}\neq s_{1}$, then there has been a fault, which can mean a data error of weight $\leq 1$. Skip to part IV: decode, measure and correct the result for the $16$ possible errors $IIIII,XIIII,\ldots,IIIIZ$. 3. 3.

Measure $IIZXZ$ with a flag and call the result $s_{3}$, as in part III.

If the flag is raised, then return $s_{1}=s_{2}$.

Otherwise, if $s_{3}=s_{1}=s_{2}$ then return this value.

If $s_{3}\neq s_{1}=s_{2}$, then in part IV decode, measure and correct the result for the $16$ errors of weight $\leq 1$.

This procedure is fault tolerant. For example, if the flag is raised while extracting $s_{2}$, then, provided the circuit has only one fault, $s_{1}$ must have been correct.

Appendix C Fault-tolerant state preparation

for the ${[\![}15,7,3{]\!]}$ code

Figure 11 gives a fault-tolerant circuit to prepare ${|0^{7}\rangle}$ encoded in the ${[\![}15,7,3{]\!]}$ code. We have condensed CNOT gates with the same control wire. The state is accepted provided that the measurement returns ${|0\rangle}$. Note that since the code is perfect CSS, we need not worry about $Z$ faults propagating and only need to check for $X$ faults. (Any $Z$ error is equivalent to either the identity or a weight-one error.)

The circuit is fault tolerant only for $X$ and $Z$ faults considered separately. For example, if the $\text{CNOT}_{1,15}$ gate fails as $ZX$, the state will be accepted with the weight-two error $Z_{1}X_{15}$—but as the $X$ and $Z$ parts of this error each have weight one, the error is correctable.

Other encoded computational basis states can be prepared by applying logical $X$ operators to ${|0^{7}\rangle}$.

Appendix D Fault-tolerant state preparation and measurement for the ${[\![}n,n-2,2{]\!]}$ codes

We give one-qubit fault-tolerant circuits for state preparation and projective measurement, for the ${[\![}n,n-2,2{]\!]}$ codes.

D.1 State preparation

Encoded ${|0^{n-2}\rangle}$ is a cat state $\tfrac{1}{\sqrt{2}}({|0^{n}\rangle}+{|1^{n}\rangle})$. It can be prepared fault tolerantly by

[TABLE]

where the $Z$ measurement should return ${|0\rangle}$.

Encoded states ${|+^{j}0^{n-2-j}\rangle}$ can be prepared by applying targeted logical Hadamard gates to encoded ${|0^{n-2}\rangle}$. However, it is easier to prepare them directly. For $j$ odd, encoded ${|+^{j}0^{n-2-j}\rangle}$ is $\tfrac{1}{2}({|+^{j+1}\rangle}+{|-\rangle}^{j+1})\otimes({|0^{n-j-1}\rangle}+{|1^{n-j-1}\rangle})$, i.e., the tensor product of cat and dual cat states. The states can be prepared separately as in (1). The following circuit for $n=6$, $j=2$ generalizes naturally to any even $j$:

[TABLE]

The black portion prepares the state, while the red parts catch faults using postselected $Z$ and $X$ measurements.

D.2 Measurement

The qubits can all be simultaneously be measured in the $X$ or $Z$ logical bases by transversal $X$ or $Z$ measurement. To projectively measure just $\macc@depth\char 1\relax\frozen@everymath{\macc@group}\macc@set@skewchar\macc@nested@a 111{Z}_{j}$ fault tolerantly, measure it twice using one ancilla:

[TABLE]

Different results indicate an error. Similar circuits work for measuring $\macc@depth\char 1\relax\frozen@everymath{\macc@group}\macc@set@skewchar\macc@nested@a 111{Z}_{i}\macc@depth\char 1\relax\frozen@everymath{\macc@group}\macc@set@skewchar\macc@nested@a 111{Z}_{j}=Z_{i+1}Z_{j+1}$ for $i\neq j$, and for measuring $\prod_{j}\macc@depth\char 1\relax\frozen@everymath{\macc@group}\macc@set@skewchar\macc@nested@a 111{Z}_{j}=Z_{1}Z_{n}$ and $\prod_{j\neq i}\macc@depth\char 1\relax\frozen@everymath{\macc@group}\macc@set@skewchar\macc@nested@a 111{Z}_{j}=Z_{1}Z_{i+1}$. To projectively measure other parities, use a two-ancilla circuit as in Fig. 5(b). Of course, symmetrical circuits work for measuring logical $X$ operators.