Fault-tolerant quantum computation with few qubits

TL;DR

This paper presents a fault-tolerant quantum computation scheme using only 17 qubits with the 15-qubit Hamming code, enabling universal operations with minimal overhead suitable for small-scale quantum devices.

Contribution

It introduces fault-tolerant procedures for Clifford operations on encoded qubits using only two additional qubits, significantly reducing qubit overhead for fault-tolerance.

Findings

Fault-tolerant Clifford operations achieved with 17 qubits.

Universal fault-tolerant computation possible with 19 qubits.

Techniques include gadgets, code symmetries, and pieceable fault tolerance.

Abstract

Reliable qubits are difficult to engineer, but standard fault-tolerance schemes use seven or more physical qubits to encode each logical qubit, with still more qubits required for error correction. The large overhead makes it hard to experiment with fault-tolerance schemes with multiple encoded qubits. The 15-qubit Hamming code protects seven encoded qubits to distance three. We give fault-tolerant procedures for applying arbitrary Clifford operations on these encoded qubits, using only two extra qubits, 17 total. In particular, individual encoded qubits within the code block can be targeted. Fault-tolerant universal computation is possible with four extra qubits, 19 total. The procedures could enable testing more sophisticated protected circuits in small-scale quantum devices. Our main technique is to use gadgets to protect gates against correlated faults. We also take advantage of special code symmetries, and use pieceable fault tolerance.

Figures

Tables

Table 1. Table 1: Sizes of the k 𝑘 k -qubit Clifford group and subgroups. There are | S k | = k ! subscript 𝑆 𝑘 𝑘 {\lvert S_{k}\rvert}=k! permutations of k 𝑘 k qubits. CNOT gates generate a group of size | GL ⁡ ( k , 2 ) | = ∏ j = 0 k − 1 ( 2 k − 2 j ) GL 𝑘 2 superscript subscript product 𝑗 0 𝑘 1 superscript 2 𝑘 superscript 2 𝑗 {\lvert\operatorname{\operatorname{GL}}(k,2)\rvert}=\prod_{j=0}^{k-1}(2^{k}-2^{j}) , adding Hadamard gates generates a larger group, and finally the full Clifford group, up to the | 𝒫 k | = 4 k subscript 𝒫 𝑘 superscript 4 𝑘 {\lvert\mathcal{P}_{k}\rvert}=4^{k} Paulis, has size 2 k 2 ​ ∏ j = 1 k ( 4 k − 1 ) superscript 2 superscript 𝑘 2 superscript subscript product 𝑗 1 𝑘 superscript 4 𝑘 1 2^{k^{2}}\prod_{j=1}^{k}(4^{k}-1) . The sizes are given as multiples of the previous columns, e.g., | 𝒞 2 / 𝒫 2 | = 2 × 3 × 12 × 10 = 720 subscript 𝒞 2 subscript 𝒫 2 2 3 12 10 720 {\lvert\mathcal{C}_{2}/\mathcal{P}_{2}\rvert}=2\times 3\times 12\times 10=720 .

$k$	$S_k$	$\mathrm{GL}(k,2)$	$⟨\text{CNOT},H⟩$	${𝒞}_k/{𝒫}_k$
1	1	$\times 1$	$\times 2$	$\times 3$
2	2	$\times 3$	$\times 12$	$\times 10$
3	6	$\times 28$	$\times 240$	$\times 36$
4	24	$\times 840$	$\times 17280$	$\times 136$
5	120	$\times 83328$	$\times 4700160$	$\times 528$
6	720	$\times 27998208$	$\times 4963368960$	$\times 2080$
7	5040	$\times 3.2\cdot {10}^{10}$	$\times 2.1\cdot {10}^{13}$	$\times 8256$
8	40320	$\times 1.3\cdot {10}^{14}$	$\times 3.4\cdot {10}^{17}$	$\times 32896$

Equations

$$\text{physical}\raisebox{-14.22636pt}{\includegraphics[scale={.769}]{images/cz23n}}\;\,=\;\,\text{logical}\raisebox{-8.5359pt}{\includegraphics[scale={.769}]{images/cz12}}$$

$$\begin{array}{rl}{\sigma }_1& =(1,2,3)(4,14,10)(5,12,9)(6,13,11)(7,15,8)\\ {\sigma }_2& =(1,10,5,2,12)(3,6,4,8,9)(7,14,13,11,15)\\ {\sigma }_3& =(1,10,15,3,8,13)(4,6)(5,12,11)(7,14,9)\end{array}$$

$$\begin{array}[]{r@{,\;} r@{,\;} r@{,\;} r}IIII&ZIII&XIII&YIII,\\ XIIZ&YIIZ&XIZZ&YIZZ,\\ XZIX&XZIY&XZXZ&XZYZ,\\ YZIX&YZIY&YZXZ&YZYZ\end{array}$$

$$IXII,IYII,IXIZ,IYIZ,IXIX,IXIY$$

$$\begin{array}[]{r@{,\;} r@{,\;} r@{,\;} r}IIII&ZIII\\ XIZZ&XXZZ&XYZZ&XZZZ\\ YIZZ&YXZZ&YYZZ&YZZZ\end{array}$$

$$\begin{array}{c}\{Z_1,Z_4{Z}_5,Z_8{Z}_9,Z_{12}{Z}_{13}\}\\ \{Z_2,Z_4{Z}_6,Z_8{Z}_{10},Z_{13}{Z}_{14}\}\\ \{Z_3,Z_4{Z}_7,Z_8{Z}_{11},Z_{12}{Z}_{15}\}\\ \{X_4,Y_4{Z}_5{Z}_6{Z}_7\},\{Y_4,X_4{Z}_5{Z}_6{Z}_7\}\\ \{X_8,Y_8{Z}_9{Z}_{10}{Z}_{11}\},\{Y_8,X_8{Z}_9{Z}_{10}{Z}_{11}\}\\ \{X_{12},Y_{12}{Z}_{13}{Z}_{14}{Z}_{15}\},\{Y_{12},X_{12}{Z}_{13}{Z}_{14}{Z}_{15}\}\end{array}$$

$$\begin{array}{c}{Z}_4,Z_{\{4,5\}},Z_{\{4,5,6\}},Z_{\{4,5,6,12\}},Z_{\{4,5,6,7,12\}}\sim Z_{\{13,14,15\}},\\ Z_{\{4,5,6,7,12,14\}}\sim Z_{\{13,15\}},Z_{\{4,5,6,7,12,13,14\}}\sim Z_{15},1\end{array}$$

Full text

The $15$-qubit Hamming code protects seven encoded qubits to distance three. We give fault-tolerant procedures for applying arbitrary Clifford operations on these encoded qubits, using only two extra qubits, $17$ total. In particular, individual encoded qubits within the code block can be targeted. Fault-tolerant universal computation is possible with four extra qubits, $19$ total. The procedures could enable testing more sophisticated protected circuits in small-scale quantum devices.

Our main technique is to use gadgets to protect gates against correlated faults. We also take advantage of special code symmetries, and use pieceable fault tolerance.

I Introduction

Quantum computers are faulty, but schemes to tolerate errors incur a large space overhead. For example, one qubit encodes into seven physical qubits using the Steane code Steane (1996), or into nine physical qubits using the Bacon-Shor and smallest surface codes Bacon (2006); Bombín and Martin-Delgado (2007); Horsman et al. (2012). Error correction uses additional qubits. When more than one level of encoding is required for better protection, the overhead multiplies, so that thousands of physical qubits can be required for each logical qubit Suchara et al. (2013). This overhead will compound the challenge of building large quantum computers. In the near term, it also makes it more difficult to run fault-tolerance experiments, which are important to test different schemes’ performance, validate models and learn better approaches.

Codes storing multiple qubits have higher rates Calderbank and Shor (1996), but too large codes tend to tolerate less noise since initializing codewords gets difficult Steane (2003). A key obstacle for using any code with multiple qubits per code block is that it is complicated and inefficient to address the individual encoded qubits to compute on them Gottesman (1998); Steane and Ibinson (2005). For example, to apply a CNOT gate between two logical qubits in a code block, the optimized method in Steane and Ibinson (2005) requires a full ancillary code block, with no stored data, into which the target logical qubit is transferred temporarily.

We introduce lower-overhead methods for computing fault tolerantly on multiple data qubits in codes of distance two or three.

For even $n$, the ${[\![}n,n-2,2{]\!]}$ code encodes $n-2$ logical qubits into $n$ physical qubits, protected to distance two. We show that with two more qubits, encoded CNOT and Hadamard gates can be applied fault tolerantly. For $n\geq 6$, four extra qubits suffice to fault-tolerantly apply an encoded ${\mathrm{CC}Z}$ gate, for universality. 2. 2.

For better, distance-three protection, we encode seven qubits into $15$, and give fault-tolerant circuits for the encoded Clifford group using two more qubits, and for a universal gate set with four extra qubits ($19$ total).

Combined with the two-qubit fault-tolerant error-detection and error-correction methods in Chao and Reichardt (2017), this means that substantial quantum calculations can be implemented fault tolerantly in a quantum device with fewer than $20$ physical qubits. Figure 1 summarizes our results.

In order to compute on data encoded within a single code block, we need to apply two- or three-qubit gates. The particular circuits use symmetries of the codes or a more general round-robin construction from Yoder et al. (2016). This is not fault tolerant, because a single gate failure can cause a correlated error of weight two or worse, which a distance-three code cannot correct. To fix this, we replace each gate with a gadget involving two to four more qubits. With no gate faults, the gadgets are equivalent to the ideal gates they replace. The gadgets’ purpose is to detect correlated errors, so that they can be corrected for later. The gadgets cannot prevent the gates from spreading single-qubit faults into problematic multi-qubit errors. To avoid this problem, we design the circuits carefully, and in some cases intersperse partial error correction procedures between gadgets, an idea from Knill et al. (1996) recently applied and extended by Hill et al. (2013); Yoder et al. (2016). Sometimes error correction even needs to overlap the gadgets.

For the basics of stabilizer algebra, quantum error-correcting codes and fault-tolerant quantum computation, we refer the reader to Gottesman (2010).

II Trick: Flagging a gate for correlated faults

A main trick we use is to replace ${\mathrm{C}Z}$ and ${\mathrm{CC}Z}$ gates with small gadgets that can catch correlated faults. The gadgets are reminiscent of one-ancilla-qubit fault-tolerant SWAP gate gadgets Gottesman (2000).

II.1 ${\mathrm{C}Z}$ gadget

The controlled-phase gate is a two-qubit diagonal gate ${\mathrm{C}Z}=\boldsymbol{1}-2{{|11\rangle}\!{\langle 11|}}$, represented in circuits as

[TABLE]

Observe that ${\mathrm{C}Z}$ gates commute with $Z$ errors, but copy $X$ (or $Y$) errors on one wire into $Z$ errors on the other:

[TABLE]

For fault tolerance, it suffices to study gates that fail with Pauli faults after the gate. That is, when a noisy ${\mathrm{C}Z}$ gate fails, it applies the ideal ${\mathrm{C}Z}$ gate followed by one of the $15$ nontrivial two-qubit Pauli operators.

Consider the circuit of Fig. 2(a), using one extra qubit that at the end is measured in the ${|0\rangle},{|1\rangle}$ basis ($Z$ eigenbasis). If the gates are perfect, then the measurement returns [math] and this circuit has the effect of a single ${\mathrm{C}Z}$ gate. If the ${\mathrm{C}Z}$ gate fails with an $X$ or $Y$ fault on the second qubit, however, then the measurement will return $1$. Thus certain kinds of faults can be detected. If at most one location fails and the measurement returns [math], then the output cannot have an $XX$, $XY$, $YX$ or $YY$ error.

A similar circuit can catch $Z$ faults. If all gates in Fig. 2(b) are perfect, then the $X$ basis (${|+\rangle},{|-\rangle}$) measurement will return $+$ and the effect will be of a single ${\mathrm{C}Z}$. If there is at most one fault and the measurement returns $+$, then the output cannot have a $YX$ or $ZZ$ error. (This fact can be verified by, for example, propagating $ZZI$ and $ZZX$ backward through the circuit, and observing that no single gate failure can create either.)

The gadgets to catch $X$ and $Z$ faults can be combined:

Theorem 1**.**

With no faults, the circuit of Fig. 2(c) implements a ${\mathrm{C}Z}$ gate, with the measurements outputting [math] and $+$. If there is at most one fault and the measurements return [math] and $+$, then neither $XX$, $XY$, $YX$, $YY$ nor $ZZ$ errors can occur on the output.

Thus all single faults are caught except those equivalent to a fault on the ${\mathrm{C}Z}$ output or input qubits (namely, $IX,IY,IZ,XI,YI,ZI$ and $XZ,YZ,ZX,ZY$). No ${\mathrm{C}Z}$ gadget can catch more errors than this.

The order of the gates matters. Although the last two gates in Fig. 2(b) formally commute, switching them changes the faulty circuit so that an undetected $ZZ$ error can occur due to a single gate fault. Similarly, in Fig. 2(c) it is important that the gadget for catching $Z$ faults go inside that for $X$ faults. With the other order, a single fault can lead to an undetected $XX$ error. See Fig. 3.

In practice, not every ${\mathrm{C}Z}$ gate need always be replaced with the full ${\mathrm{C}Z}$ gate gadget of Fig. 2(c). Multiple gates can sometimes be combined under single flags. We will see examples below.

II.2 ${\mathrm{CC}Z}$ gadget

The three-qubit gate ${\mathrm{CC}Z}=\boldsymbol{1}-2{{|111\rangle}\!{\langle 111|}}$ is denoted

[TABLE]

Again, it commutes with $Z$ errors. It copies an $X$ error on the input into a ${\mathrm{C}Z}=\tfrac{1}{2}(II+IZ+ZI-ZZ)$ error on the output, i.e., into a linear combination of $II$, $IZ$, $ZI$ and $ZZ$ errors:

[TABLE]

The following gadget, using four ancilla qubits, implements a ${\mathrm{CC}Z}$ on the black data qubits. Furthermore, it satisfies that provided there is at most one failed gate and the measurement results are trivial, [math] and $+$, then the error on the output is a linear combination of Paulis that could result from a one-qubit fault before or after a perfect ${\mathrm{CC}Z}$ gate, i.e., $III,ZII,XII,YII,XZI,YZI,XZZ,YZZ$ and qubit permutations thereof.

[TABLE]

That without faults the black and blue gates realize a ${\mathrm{CC}Z}$ is a special case of the following claim Yoder et al. (2016), with $r=3$, $S^{Z}_{1}=\{1\}$, $S^{Z}_{2}=\{2,3\}$, $S^{Z}_{3}=\{5,6\}$.

Claim 2**.**

Consider an $n$-qubit CSS code with $k$ encoded qubits given by $\macc@depth\char 1\relax\frozen@everymath{\macc@group}\macc@set@skewchar\macc@nested@a 111{X}_{j}=X_{S^{X}_{j}},\macc@depth\char 1\relax\frozen@everymath{\macc@group}\macc@set@skewchar\macc@nested@a 111{Z}_{j}=Z_{S^{Z}_{j}}$ for $S^{X}_{j},S^{Z}_{j}\subseteq[n]$. Let $U$ be the product of $\mathrm{C}^{(r-1)}Z=\boldsymbol{1}-2{{|1^{r}\rangle}\!{\langle 1^{r}|}}$ gates applied to every tuple of qubits in $S^{Z}_{1}\times S^{Z}_{2}\times\cdots\times S^{Z}_{r}$. (If the $S^{Z}_{j}$ sets are not disjoint, then some of the applied gates will be $\mathrm{C}^{(s-1)}Z$ for some $s<r$.)

Then $U$ is a valid logical operation. It implements logical $\mathrm{C}^{(r-1)}Z$ on the first $r$ encoded qubits.

Proof.

For the case that the sets $S^{Z}_{j}$ are disjoint, the claim is immediate in the case of singleton sets and follows in general by induction on the set size using the identity

[TABLE]

for any gate $G$, on one or more qubits, with $G^{2}=\boldsymbol{1}$. (Figure 2(b) provides one example.)

More generally, the claim follows by writing out computational basis codewords as superpositions of computational basis states, and computing the effect of $U$. For $(x,y)\in\{0,1\}^{r}\times\{0,1\}^{k-r}$, the codeword ${|\macc@depth\char 1\relax\frozen@everymath{\macc@group}\macc@set@skewchar\macc@nested@a 111{x}\rangle}$ is a uniform superposition of computational basis states:

[TABLE]

The relationships $\macc@depth\char 1\relax\frozen@everymath{\macc@group}\macc@set@skewchar\macc@nested@a 111{X}_{i}\macc@depth\char 1\relax\frozen@everymath{\macc@group}\macc@set@skewchar\macc@nested@a 111{Z}_{j}=(-1)^{\delta_{ij}}\macc@depth\char 1\relax\frozen@everymath{\macc@group}\macc@set@skewchar\macc@nested@a 111{Z}_{j}\macc@depth\char 1\relax\frozen@everymath{\macc@group}\macc@set@skewchar\macc@nested@a 111{X}_{i}$ imply that ${\lvert S^{X}_{i}\cap S^{Z}_{j}\rvert}$ is odd for $i=j$ and even otherwise; and for any stabilizer $X_{S}$, $[X_{S},\macc@depth\char 1\relax\frozen@everymath{\macc@group}\macc@set@skewchar\macc@nested@a 111{Z}_{j}]=0$ so ${\lvert S\cap S^{Z}_{j}\rvert}$ is even.

If $x\neq 1^{r}$, say $x_{j}=0$, then for every term ${|z\rangle}$ in the above sum, $z$ has an even number of $1$s in $S^{Z}_{j}$, implying that $U{|z\rangle}={|z\rangle}$. Hence $U{|\macc@depth\char 1\relax\frozen@everymath{\macc@group}\macc@set@skewchar\macc@nested@a 111{x}\rangle}={|\macc@depth\char 1\relax\frozen@everymath{\macc@group}\macc@set@skewchar\macc@nested@a 111{x}\rangle}$.

If $x=1^{r}$, then for any term ${|z\rangle}$ in ${|\macc@depth\char 1\relax\frozen@everymath{\macc@group}\macc@set@skewchar\macc@nested@a 111{x}\rangle}$, $z$ has an odd number of $1$s in each $S^{Z}_{j}$ and therefore $U{|z\rangle}=-{|z\rangle}$. Hence $U{|\macc@depth\char 1\relax\frozen@everymath{\macc@group}\macc@set@skewchar\macc@nested@a 111{x}\rangle}=-{|\macc@depth\char 1\relax\frozen@everymath{\macc@group}\macc@set@skewchar\macc@nested@a 111{x}\rangle}$. ∎

III Fault-tolerant operations for ${[\![}n,n-2,2{]\!]}$ 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$. This code, its symmetries, and methods of computing fault tolerantly on the encoded qubits were studied by Gottesman Gottesman (1998). However, his techniques require at least $2n$ extra qubits. For example, to apply a CNOT gate between two logical qubits in the same code block, he teleports them each into separate code blocks, applies transversal CNOT gates between the blocks, and then teleports them back.

We will give a fault-tolerant implementation of encoded CNOT and Hadamard gates on arbitrary logical qubits, using only two extra qubits. Two-qubit fault-tolerant procedures for state preparation, error detection and projective measurement were given in Chao and Reichardt (2017). For $n\geq 6$ (so there are at least three encoded qubits), we will give a four-qubit fault-tolerant implementation of the encoded ${\mathrm{CC}Z}$ gate, thereby completing a universal gate set.

III.1 Permutation symmetries and transversal operations

Fault tolerance for a distance-two code means that any single fault within an operation should either have no effect or lead to a detectable error. For example, of course the $4^{n-2}$ logical Pauli operators can all be applied fault tolerantly, since the operations do not couple any qubits.

All qubit permutations preserve the two stabilizers and therefore preserve the code space. They are also fault tolerant if implemented either by relabeling the qubits or by moving them past each other (and not by using two-qubit SWAP gates Gottesman (2000)). For $i,j\in[n-2]$, $i\neq j$, the qubit swap $(i+1,j+1)$ swaps the logical qubits $i$ and $j$. The qubit swap $(1,2)$ implements logical CNOTs from qubits $2$ through $n-2$ into $1$, and the qubit swap $(2,n)$ implements logical CNOTs in the opposite direction:

[TABLE]

Transversal Hadamard, $H^{\otimes n}$, followed by the qubit swap $(1,n)$, implements logical $H^{\otimes(n-2)}$.

The Clifford reflection $G=\tfrac{i}{\sqrt{2}}(X+Y)$ conjugates $X\leftrightarrow Y$ and $Z\rightarrow-Z$. Transversal $G$ is a valid logical operation (up to $Z_{n}$ to correct the $X^{\otimes n}$ syndrome if $n=2\mod 4$). It implements logical ${\mathrm{C}Z}$ gates between all encoded qubits:

[TABLE]

The operations given so far generate a group much smaller than the full $(n-2)$-qubit Clifford group. The qubit permutations generate $n!$ different logical operations (except for $n=4$, just $6$ operations). With the transversal application of the six one-qubit Clifford gates, up to Paulis, this gives $6(n!)$ different logical operations (or $36$ for $n=4$). Table 1 gives the sizes of various interesting subgroups of the Clifford group, for comparison.

We next give fault-tolerant implementations for a logical Hadamard gate on a single encoded qubit, and for a logical ${\mathrm{C}Z}$ gate between two encoded qubits. These generate a large subgroup of the Clifford group, the $\langle\text{CNOT},H\rangle$ column in Table 1.

III.2 ${\mathrm{C}Z}$ gate

By Claim 2, a logical ${\mathrm{C}Z}_{1,2}$ gate can be implemented by $Z_{n}\,{\mathrm{C}Z}_{2,3}\,{\mathrm{C}Z}_{2,n}\,{\mathrm{C}Z}_{3,n}$:

[TABLE]

However, this implementation is not fault tolerant. Some failures are detectable; for example, if the ${\mathrm{C}Z}_{2,3}$ gate fails as $XI$, then the final, detectable error is $X_{2}Z_{n}$. Others are not, e.g., if the ${\mathrm{C}Z}_{2,3}$ gate fails as $XX$, then the final $X_{2}X_{3}=\macc@depth\char 1\relax\frozen@everymath{\macc@group}\macc@set@skewchar\macc@nested@a 111{X}_{1}\macc@depth\char 1\relax\frozen@everymath{\macc@group}\macc@set@skewchar\macc@nested@a 111{X}_{2}$ error is undetectable.

The bad faults that can cause undetectable logical errors are as follows:

[TABLE]

In particular, all these bad faults are caught by the ${\mathrm{C}Z}$ gadget of Theorem 1. Therefore replacing each physical ${\mathrm{C}Z}$ gate in (3) with that gadget gives a fault-tolerant implementation of a logical ${\mathrm{C}Z}_{1,2}$ gate. The circuit uses at most two ancilla qubits at a time.

In fact, one can simplify the resulting circuit by using the same ${|0\rangle}$ ancilla to catch $X$ faults on multiple ${\mathrm{C}Z}$ gates. The following circuit is also fault tolerant:

[TABLE]

The gadgets to catch $Z$ faults can be merged, too. The following circuit is fault tolerant, and still requires at most two ancilla qubits at a time:

[TABLE]

Perhaps further simplifications are possible.

III.3 Targeted Hadamard gate

A single encoded Hadamard gate can also be implemented fault tolerantly with two extra qubits. The black portion of the circuit below, with  , implements $\macc@depth\char 1\relax\frozen@everymath{\macc@group}\macc@set@skewchar\macc@nested@a 111{H}_{1}$. The red and blue portions, analogous to Figs. 2(a) and 2(b), respectively, catch problematic faults. $X$ measurements should return $+$ and $Z$ measurements [math].

[TABLE]

The circuit’s fault tolerance can be verified by enumerating all the ways in which single gates can fail.

III.4 Four-ancilla ${\mathrm{CC}Z}$ gate

For $n\geq 6$, a ${\mathrm{CC}Z}$ gate on encoded qubits $1,2,3$ can be implemented by round-robin ${\mathrm{CC}Z}$ gates on $\{2,n\}\times\{3,n\}\times\{4,n\}$, by Claim 2:

[TABLE]

This circuit uses one $Z$, three ${\mathrm{C}Z}$ and four ${\mathrm{CC}Z}$ gates. To make it fault tolerant, use the gadget from Fig. 2(c) for each ${\mathrm{C}Z}$ gate, and replace each ${\mathrm{CC}Z}$ with the gadget of Eq. (2). Overall, this requires four ancilla qubits.

Single gate faults are either caught by the gadgets or lead to an error that could also arise from a one-qubit fault between the gates in (6). A one-qubit $X$ or $Y$ fault will be detectable at the end because it is copied only to linear combinations of $Z$s—the $X$ component of the final error will still have weight one—and a one-qubit $Z$ fault will be detectable because it commutes through the ${\mathrm{C}Z}$ and ${\mathrm{CC}Z}$ gates. Therefore the procedure is fault tolerant.

IV Fault-tolerant operations for the ${[\![}15,7,3{]\!]}$ Hamming code

The ${[\![}15,7,3{]\!]}$ Hamming code is a self-dual CSS, perfect distance-three code. Packing seven logical qubits into $15$ physical qubits, it is considerably more efficient than more commonly used ${[\![}7,1,3{]\!]}$ and ${[\![}9,1,3{]\!]}$ CSS codes, although it tolerates less noise.

We first give a presentation of the code and its symmetries following Harrington and Reichardt (2011). Then we give a two-ancilla-qubit method for fault tolerantly implementing the full Clifford group on the encoded qubits, and, to complete a universal gate set, a four-qubit fault-tolerant encoded ${\mathrm{CC}Z}$ gate.

Two-qubit fault-tolerant procedures for state preparation and error correction were given in Chao and Reichardt (2017).

IV.1 ${[\![}15,7,3{]\!]}$ Hamming code

The ${[\![}15,7,3{]\!]}$ Hamming code has four $X$ and four $Z$ stabilizers each given by the following parity-checks:

[TABLE]

Index the qubits left to right from $1$ to $15$. Observe that the columns are these numbers in binary.

As in Harrington and Reichardt (2011), we define logical operators based on the following seven weight-five strings:

[TABLE]

From the first string, $\macc@depth\char 1\relax\frozen@everymath{\macc@group}\macc@set@skewchar\macc@nested@a 111{X}_{1}=XXIXIIIXIIIIIIX$ and $\macc@depth\char 1\relax\frozen@everymath{\macc@group}\macc@set@skewchar\macc@nested@a 111{Z}_{1}=ZZIZIIIZIIIIIIZ$. The remaining strings specify the logical operators $\macc@depth\char 1\relax\frozen@everymath{\macc@group}\macc@set@skewchar\macc@nested@a 111{X}_{2},\macc@depth\char 1\relax\frozen@everymath{\macc@group}\macc@set@skewchar\macc@nested@a 111{Z}_{2}$ through $\macc@depth\char 1\relax\frozen@everymath{\macc@group}\macc@set@skewchar\macc@nested@a 111{X}_{7},\macc@depth\char 1\relax\frozen@everymath{\macc@group}\macc@set@skewchar\macc@nested@a 111{Z}_{7}$.

IV.2 Transversal operations

Transversal operations are automatically fault tolerant.

Transversal Pauli operators implement logical transversal Pauli operators. Indeed, transversal $X$, i.e., $X^{\otimes 15}$, preserves the code and implements transversal logical $X$, i.e., $X^{\otimes 7}$, on the code space, and similarly for $Y$ and $Z$.

In fact, any one-qubit Clifford operator applied transversally preserves the code space and implements the same operator transversally on the encoded qubits. For example, since the logical operators are each self-dual, applying the Hadamard gates $H^{\otimes 15}$ implements logical $H^{\otimes 7}$.

Of course, since the code is CSS, transversal CNOT gates between two code blocks implements transversal logical CNOT gates on the code spaces. Furthermore, Paetznick and Reichardt (2013) shows that on three code blocks transversal CCZ can be used to obtain a universal gate set. Here, however, we will consider only single code blocks and Clifford operations.

IV.3 Permutation symmetries

Permutations of the qubits are also fault tolerant, either by physically moving the qubits or by relabeling them.

The code’s permutation automorphism group has order $20,\!160$, and is isomorphic to $A_{8}$ and $\operatorname{\operatorname{GL}}(4,2)$ Harrington and Reichardt (2011); Grassl and Roetteler (2013). It is generated by the following three $15$-qubit permutations:

[TABLE]

These permutations fix the code space, but act nontrivially within it. The permutations $\sigma_{1}$ and $\sigma_{2}$ apply the respective permutations $(1,2,3)$ and $(3,4,5,6,7)$ to the seven logical qubits. Together, these generate the alternating group $A_{7}$ of even permutations.

The logical effect of $\sigma_{3}$ is not a permutation. It is equivalent to the following circuit of $24$ CNOT gates, in which gates with the same control wire are condensed:

[TABLE]

Thus the first logical qubit is fixed, while for $j\in\{2,\ldots,7\}$ and $P\in\{X,Y,Z\}$, $P_{j}$ is mapped to $(\prod_{j=2}^{7}P_{j})P_{j+1}$, wrapping the indices cyclically. This is a six-qubit generalization of a four-qubit operator studied in (Gottesman, 1998, Sec. 6). (Like permutations, this operation has the property of being a valid transversal operation on any stabilizer code.)

IV.4 ${\mathrm{C}Z}$ circuits based on permutation symmetries

Any permutation symmetry of the code can be turned into a ${\mathrm{C}Z}$ automorphism (Fig. 4(a)):

Claim 3**.**

For a self-dual CSS code, if $\sigma$ is a qubit permutation that fixes the code space, then the circuit with a ${\mathrm{C}Z}$ gate from $i$ to $\sigma(i)$, for all $i\neq\sigma(i)$, fixes the code space up to Pauli $Z$ corrections.

Proof.

$Z$ stabilizers commute with the ${\mathrm{C}Z}$ gates, so are preserved. An $X$ stabilizer $X_{S}=\prod_{i\in S}X_{i}$ is mapped to $\prod_{i\in S}(X_{i}Z_{\sigma(i)}Z_{\sigma^{-1}(i)})=\pm X_{S}Z_{\sigma(S)\cup\sigma^{-1}(S)}$. Up to sign, this is a stabilizer, since $Z_{\sigma(S)}Z_{\sigma^{-1}(S)}$ is a stabilizer. ∎

For example, the physical circuit in Eq. (3) comes from the cyclic permutation $(2,3,n)$ of the ${[\![}n,n-2,2{]\!]}$ code.

Applying Claim 3 to $\sigma_{3}$ of Eq. (9), the two ${\mathrm{C}Z}$ gates for the cycle $(4,6)$ cancel out, leaving the gates $({\mathrm{C}Z}_{1,10}{\mathrm{C}Z}_{10,15}\cdots{\mathrm{C}Z}_{13,1})({\mathrm{C}Z}_{5,12}{\mathrm{C}Z}_{12,11}{\mathrm{C}Z}_{11,5})\ldots$. As shown in Fig. 4(b), the effect is that of logical ${\mathrm{C}Z}$ gates following the cycle $(2,3,4,5,6,7)$.

Notice that the logical effect necessarily consists of encoded ${\mathrm{C}Z}$ gates, because logical $Z$ operators are unchanged and logical $X$ operators pick up $Z$ components. Also, the map from Claim 3 is not a homomorphism from permutations into unitary circuits.

${\mathrm{C}Z}$ gates $\{8,9\}$ to $\{10,11\}$ and $\{12,13\}$ to $\{14,15\}$

The permutation $(6,7)(8,10,9,11)(12,14,13,15)$ fixes the code, and under Claim 3 corresponds to the eight ${\mathrm{C}Z}$ gates of Fig. 5(a). Figure 5(b) gives their logical effect.

Using Magma Bosma et al. (1997), we compute that the group generated by this operation, the permutations $\sigma_{1},\sigma_{2},\sigma_{3}$, and transversal $H$ has the same size as the $\langle\text{CNOT},H\rangle$ group on six qubits (about $1.001\cdot 10^{20}$). (Adding transversal $G$ only triples the group size.) This hints that by working in a logical basis in which one qubit has $\macc@depth\char 1\relax\frozen@everymath{\macc@group}\macc@set@skewchar\macc@nested@a 111{X}=X^{\otimes 15}$ and $\macc@depth\char 1\relax\frozen@everymath{\macc@group}\macc@set@skewchar\macc@nested@a 111{Z}=Z^{\otimes 15}$ (operators fixed by the permutations and by Fig. 5(a)), perhaps arbitrary combinations of CNOT and $H$ can be applied to the other six qubits. But no, only half the $\langle\text{CNOT},H\rangle$ group can be reached.

The circuit of Fig. 5(a) is clearly not fault tolerant. (For example, an $XX$ fault after the ${\mathrm{C}Z}_{9,11}$ gate gives the error $X_{9}X_{11}$, which is indistinguishable from $X_{2}$.) We can use the gadgets from Sec. II.1 for each ${\mathrm{C}Z}$ gate to obtain the circuit of Fig. 5(c), shown with the trailing error correction. Two ancilla qubits are needed.

We claim that this compiled circuit is fault tolerant. This means that if the input lies in the code space, the compiled circuit has at most one fault (a two-qubit Pauli fault after a gate, or a one-qubit fault on a resting qubit), and the subsequent error correction is perfect; then the final outputs lie in the code space with no logical errors. To verify fault tolerance, there are two cases to check.

First, consider the case that, with at most one fault, all the gadget measurements give the trivial output ([math] for a $Z$ measurement, $+$ for $X$). Since the gadgets catch two-qubit gate faults, we need only check possible one-qubit faults between gates. Inequivalent fault locations are marked with stars in Fig. 5(c). (Faults at other locations either cause the same errors, or will be caught.) In particular, entering error correction the possible error can be $\boldsymbol{1}$, $X_{1},Z_{1},Y_{1},\ldots,X_{15},Z_{15},Y_{15}$—from the {\color[rgb]{0,0,0.5}\bigstar} locations. Or, from {\color[rgb]{1,0,0}\bigstar} locations, it can be $XIZZ,YIZZ,IXZZ,IYZZ,ZZXI,ZZYI,ZZIX$, $ZZIY$, and $IZXI,IZYI,IZIX,IZIY$ from {\color[rgb]{1,0.5,0}\bigstar} locations, on qubits $8,9,10,11$—and similarly for qubits $12$ to $15$. This give $70$ different errors total. All $70$ have distinct syndromes, and therefore can be corrected. (This fact can be verified either by computing all the syndromes, or by observing from Eq. (7) that $Z_{8}Z_{9}Z_{10}Z_{11}$, $Z_{12}Z_{13}Z_{14}Z_{15}$, $Z_{1}Z_{6}Z_{7}$, $Z_{1}Z_{8}Z_{9}$, $Z_{1}Z_{12}Z_{13}$ and $Z_{1}Z_{14}Z_{15}$ are logical operators. Thus, for example, if you observe the $Z$ syndrome $1000$, for error $X_{8}$, and the $X$ syndrome $0001$, for error $Z_{1}$, you can safely correct $X_{8}Z_{10}Z_{11}$. $Z_{1}X_{8}$ cannot occur.)

Note that the error-correction procedure needs to take into account the $X$ and $Z$ stabilizer syndromes together to decide what correction to apply. This can work because the ${[\![}15,7,3{]\!]}$ code is not a perfect stabilizer code: there are $2^{8}$ possible syndromes but only $1+15\cdot 3$ possible trivial or weight-one errors. (It is only perfect as a CSS code, i.e., the $2^{4}$ $Z$ stabilizer syndromes are exactly enough to correct the $1+15$ possible trivial or weight-one $X$ errors, and similarly for $Z$ errors.) This leaves room to correct some errors of weight more than one.

Next, consider the case that, with at most one fault in Fig. 5(c), one or more of the gadget measurements gives a nontrivial output. This case is much simpler, because the measurement results localize the fault, leaving only a few possibilities for the error entering error correction. One must verify that in all cases, these possibilities are distinguished by their syndromes.

For example, if the first $Z$ measurement returns $1$ and all other measurements are trivial, the errors from single faults that can occur are, on qubits $8,9,10,11$:

[TABLE]

These $16$ possible errors all have distinct syndromes, so are correctable.

As another example, if the last two measurements, of qubits coupled to qubit $13$, are nontrivial, then the possible errors from single faults are, on qubits $12,13,14,15$:

[TABLE]

Again, these have distinct syndromes.

Other possible measurement outcomes are similar. We have used a computer to check them all.

IV.5 Round-robin ${\mathrm{C}Z}$ circuits to complete the Clifford group

The above operations do not generate the full seven-qubit logical Clifford group, and we have not been able to find a permutation for which applying Claim 3 enlarges any further the generated logical group. Instead, we turn to the round-robin construction of Claim 2.

${\mathrm{C}Z}$ gates $4$ to $\{5,6,7\}$, $8$ to $\{9,10,11\}$, $12$ to $\{13,14,15\}$

Observe that $Z_{\{4,8,12\}}$ and $Z_{\{4,5,6,7\}}\sim Z_{\{8,9,10,11\}}\sim Z_{\{12,13,14,15\}}$ are logical operators, implementing respectively $\macc@depth\char 1\relax\frozen@everymath{\macc@group}\macc@set@skewchar\macc@nested@a 111{Z}_{\{2,5,7\}}$ and $\macc@depth\char 1\relax\frozen@everymath{\macc@group}\macc@set@skewchar\macc@nested@a 111{Z}_{\{1,2,3,4\}}$. By a minor extension of Claim 2, applying $Z_{\{4,8,12\}}$ and nine ${\mathrm{C}Z}$ gates from $4$ to each of qubits $\{5,6,7\}$, $8$ to $\{9,10,11\}$, and $12$ to $\{13,14,15\}$ preserves the code space. The logical effect is

[TABLE]

Together with permutations and transversal operations, this circuit completes the seven-qubit Clifford group, without needing the operation from Sec. IV.4. To make the operation fault tolerant, we will transform it in three steps.

First, consider the circuit below, in which we have wrapped the ${\mathrm{C}Z}$ gates leaving qubits $4$, $8$ and $12$ with overlapping gadgets to catch $X$ faults. If at most one fault occurs and one or more of the $Z$ measurements gives $1$, then the errors that can occur are distinguished by their syndromes.

[TABLE]

For example, if the orange, first $Z$ measurement off qubit $4$ gives $1$ and all others [math], then the possible errors entering error correction are, on qubits $4,5,6,7$:

[TABLE]

These errors all have distinct syndromes.

The circuit in Eq. (12) is not fault tolerant, however, because with at most one fault if all the $Z$ measurements give [math], some inequivalent errors will have the same syndrome. We can list the problematic errors. For each of the following sets, the errors within the set are all possible, but have the same syndrome:

[TABLE]

Next replace each of the blue ${\mathrm{C}Z}$ gates in Eq. (12) with the $ZZ$ fault gadget from Fig. 2(b). This gadget has the property that, with at most one failure, a $ZZ$ fault can only occur if the $X$ measurement returns $-$. These measurements thus distinguish the errors in the first three sets above.

Yet the new circuit is still not fault tolerant. The gadget measurements cannot distinguish the errors in each of the last six sets in (13). For example, consider an $X_{4}$ error before the circuit. It propagates to $X_{4}Z_{5}Z_{6}Z_{7}$. Since $Z_{4}Z_{5}Z_{6}Z_{7}$ is a logical error, $X_{4}Z_{5}Z_{6}Z_{7}$ is indistinguishable from a $Y_{4}$ error after the circuit, and no error-correction rules can correct for the possible logical error.

Gadgets cannot protect against single-qubit faults that occur just before or after the circuit. This circuit is qualitatively different from the one we considered in Sec. IV.4, and a new trick is needed to make it fault tolerant.

Consider the following circuit from Chao and Reichardt (2017), ignoring for now the orange portion at top right.

[TABLE]

This circuit fault-tolerantly extracts the syndrome of the $Z_{\{4,5,6,7,12,13,14,15\}}$ stabilizer, in the sense that:

• •

With no gate faults, the $Z$ measurement gives the syndrome, and the $X$ measurement gives $+$.

• •

With at most one fault, if the $X$ measurement gives $+$, then the data error has weight $\leq 1$.

• •

With at most one fault, if the $X$ measurement gives $-$, then the $X$ component of the data error has weight $\leq 1$. The $Z$ component can be any of

[TABLE]

and these errors all have distinct syndromes. (The order of the CNOT gates ensures this property.)

In Chao and Reichardt (2017), this circuit was used in a two-ancilla-qubit fault-tolerant error-correction procedure.

The circuit in (14) is useful for us now to detect an $X_{4}$ or $Y_{4}$ error on the input to (12). However, it is not enough to measure the $Z$ syndrome, or even to run full error correction, before applying the circuit (12), because an $X_{4}$ or $Y_{4}$ fault could happen after the syndrome measurement completes and before (12). This problem is solved by the orange portion of (14), which is meant to continue into (12), replacing the first ${|0\rangle}$ preparation and CNOT. It gives qubit $4$ temporary protection, so that an $X_{4}$ or $Y_{4}$ fault is caught by either the syndrome measurement or the orange $Z$ measurement, or both.

While the above arguments give intuition for the construction, they leave out the details. Let us now present the full fault-tolerant construction.

1. Start by applying (14) to extract the syndrome for $Z_{\{4,5,6,7,12,13,14,15\}}$. If the $Z$ or $X$ measurement is nontrivial, then decouple the orange qubit with another CNOT, apply error correction, and finish by applying unprotected ${\mathrm{C}Z}$ gates $4$ to $\{5,6,7\}$, $8$ to $\{9,10,11\}$ and $12$ to $\{13,14,15\}$. (This is safe because one fault has already been detected.)

2. Next, if the $Z$ and $X$ measurements were trivial, apply the top third of circuit (12), where the orange qubit wire continues from (14), to implement protected ${\mathrm{C}Z}$ gates $4$ to $\{5,6,7\}$. If any measurements are nontrivial, then finish by applying unprotected ${\mathrm{C}Z}$ gates $8$ to $\{9,10,11\}$ and $12$ to $\{13,14,15\}$, then error correction. We have argued already that this is fault tolerant; the extended orange “flag” is enough to catch $X_{4}$ or $Y_{4}$ faults between (14) and (12).

3. If the measurements so far were trivial, then apply a circuit analogous to (14) to extract the $Z_{\{8,9,10,11,12,13,14,15\}}$ syndrome. (Note that this is still a stabilizer, even though the ${\mathrm{C}Z}$ gates $4$ to $\{5,6,7\}$ have changed the code.) If the $Z$ syndrome or $X$ measurement is nontrivial, then apply error correction—a simple error-correction procedure is to apply ${\mathrm{C}Z}$ gates $4$ to $\{5,6,7\}$ to move back to the ${[\![}15,7,3{]\!]}$ code and correct there—before finishing with ${\mathrm{C}Z}$ gates $8$ to $\{9,10,11\}$ and $12$ to $\{13,14,15\}$. If the $Z$ and $X$ measurements were trivial, then apply the middle portion of (12), where the orange qubit wire extends from qubit $8$, to implement protected ${\mathrm{C}Z}$ gates $8$ to $\{9,10,11\}$. If any measurements are nontrivial, then finish by applying unprotected ${\mathrm{C}Z}$ gates from $12$ to $\{13,14,15\}$, then error correction.

4. If the measurements so far were trivial, then extract the $Z_{\{8,9,10,11,12,13,14,15\}}$ syndrome using (14) except with the data qubits in order $12,13,14,15,8,9,10,11$ top to bottom (so that the orange flag attaches to qubit $12$). If the $Z$ or $X$ measurement is nontrivial, then with at most one fault whatever error there is on the data can be corrected. (The easiest way is to move forward to the ${[\![}15,7,3{]\!]}$ code using ${\mathrm{C}Z}$ gates $12$ to $\{13,14,15\}$ and correct there. Note that these ${\mathrm{C}Z}$ gates turn the weight-one errors $X_{12},X_{13},X_{14},X_{15}$ into $X_{12}Z_{\{13,14,15\}},Z_{12}X_{13},Z_{12}X_{14},Z_{12}X_{15}$, respectively, but these can still be corrected; e.g., if in $X$ error correction you detect $X_{12}$, apply the correction $X_{12}Z_{\{13,14,15\}}$.) If the $Z$ and $X$ measurements were trivial, then apply the bottom portion of (12) to implement protected ${\mathrm{C}Z}$ gates from $12$ to $\{13,14,15\}$, and correct errors based on the measurement results.

Observe that this procedure requires two ancilla qubits.

IV.6 Four-qubit fault-tolerant ${\mathrm{CC}Z}$ for universality

In order to realize a universal set of operations on the seven encoded qubits, we give a four-ancilla-qubit fault-tolerant implementation for an encoded ${\mathrm{CC}Z}$ gate. The idea is to start with a circuit of round-robin ${\mathrm{CC}Z}$ gates to implement the encoded ${\mathrm{CC}Z}$ non-fault-tolerantly (Claim 2), then replace each ${\mathrm{CC}Z}$ with the gadget of Eq. (2) to catch correlated errors. Finally, we intersperse $X$ error correction procedures to catch $X$ faults before they can spread, much like the pieceable fault-tolerance constructions of Yoder et al. (2016) except on a single code block. (A similar approach can also be used to implement encoded ${\mathrm{C}Z}$ gates.)

By Claim 2, an encoded ${\mathrm{CC}Z}$ gate can be implemented by round-robin ${\mathrm{CC}Z}$ gates on qubits $\{1,4,5\}\times\{1,6,7\}\times\{1,8,9\}$ (one $Z$, six ${\mathrm{C}Z}$ and $21$ ${\mathrm{CC}Z}$ gates):

[TABLE]

To make this circuit fault tolerant, first replace each ${\mathrm{C}Z}$ gate with the gadget from Fig. 2(c), and replace each ${\mathrm{CC}Z}$ gate with the gadget from Eq. (2). After each gadget, apply $X$ error correction, and at the end apply both $X$ and $Z$ error correction. (As in Yoder et al. (2016), it might be possible to put multiple ${\mathrm{CC}Z}$ gadgets before each $X$ error correction, but we have not tried to optimize this.) Observe that $X$ error correction can be implemented even partially through the round-robin circuit because the code’s $Z$ stabilizers are preserved by ${\mathrm{CC}Z}$ gates.

There are two cases to consider to demonstrate fault tolerance: either a gadget is “triggered” with a nontrivial, $1$ or $-$, measurement outcome, or no gadgets are triggered.

A gadget is triggered.

If a gadget is triggered, then any Pauli errors can be present on its output data qubits. It is straightforward to check mechanically that for each ${\mathrm{C}Z}$ gate in (15), all four possible $X$ errors, $II$, $IX$, $XI$ and $XX$, have distinct $Z$ syndromes, and so can be corrected immediately in the subsequent $X$ error correction, before the errors can spread. By symmetry, the four possible $Z$ errors have distinct syndromes. These errors commute through (15) and are fixed by the final $Z$ error correction.

Similar considerations hold for each ${\mathrm{CC}Z}$ gate: the possible $X$ and $Z$ error components have distinct syndromes, so an error’s $X$ component can be corrected immediately and the $Z$ component corrected at the end.

No gadgets are triggered.

If there is a single failure in a ${\mathrm{C}Z}$ or ${\mathrm{CC}Z}$ gadget, but the gadget is not triggered, then the error leaving the gadget is a linear combination of the same Paulis that could result from a one-qubit $X$, $Y$ or $Z$ fault before or after the gadget.

If the error has no $X$ component, then as a weight-one $Z$ error it commutes to the end of (15), at which point $Z$ error correction fixes it.

If the error has $X$ component of weight one, then the $Z$ component can be a permutation of any of $III,IIZ,IZZ,ZZZ$ on the three involved qubits (or of $II,IZ,ZZ$ for a ${\mathrm{C}Z}$ gadget). As we have already argued, these $Z$ errors have distinct $X$ syndromes. The $X$ error correction immediately following the gadget will catch and correct the error’s $X$ component, keeping it from spreading. The final $Z$ error correction, alerted to the $X$ failure, will correct the error’s $Z$ component.

V Conclusion

Space-saving techniques for fault-tolerant quantum computation should be useful both for large-scale quantum computers and for nearer-term fault-tolerance experiments. Our techniques can likely be optimized further, and adapted to experimental model systems—but it might also be useful to relax the space optimization and allow a few more qubits. The techniques can also likely be applied to other codes, especially distance-three CSS codes. The round-robin ${\mathrm{C}Z}$ and ${\mathrm{CC}Z}$ constructions apply to some non-CSS codes, such as the ${[\![}8,3,3{]\!]}$ code, but then are more difficult to make fault tolerant.

We thank Ted Yoder for helpful comments. Research supported by NSF grant CCF-1254119 and ARO grant W911NF-12-1-0541.