Reliable channel-adapted error correction: Bacon-Shor code recovery from amplitude damping

TL;DR

This paper presents two efficient, fault-tolerant error correction schemes tailored for amplitude damping noise in Bacon-Shor codes, reducing qubit requirements and enhancing robustness using Clifford operations.

Contribution

Introduction of two novel, resource-efficient error correction schemes for amplitude damping noise in Bacon-Shor codes, compatible with fault-tolerance methods.

Findings

One scheme uses one-qubit teleportation and requires 25% of the qubits of standard methods.

The second scheme employs stabilizer measurements, needing only half as many qubits.

Both schemes are compatible with existing fault-tolerance techniques.

Abstract

We construct two simple error correction schemes adapted to amplitude damping noise for Bacon-Shor codes and investigate their prospects for fault-tolerant implementation. Both consist solely of Clifford gates and require far fewer qubits, relative to the standard method, to achieve correction to a desired order in the damping rate. The first, employing one-bit teleportation and single-qubit measurements, needs only one fourth as many physical qubits, while the second, using just stabilizer measurements and Pauli corrections, needs only half. We show that existing fault-tolerance methods can be employed for the latter, while the former can be made to avoid potential catastrophic errors and can easily cope with damping faults in ancilla qubits.

Equations

$$A_0$$

$$=(1-\frac{\gamma }{4})\mathtt{I}+\frac{\gamma }{4}\mathtt{Z}+O({\gamma }^2).$$

$${\mathcal{N}}_{\gamma }^{\text{Pauli}}(\rho )=\frac{1}{4}\sum _{k=0}^3{\sigma }_k^{†}{\mathcal{N}}_{\gamma }({\sigma }_k\rho {\sigma }_k^{†}){\sigma }_k,$$

$$|\bar{\phi }⟩=|\text{@text@baccent0}⟩\otimes |{\bar{\phi }}^{\prime }⟩+|\text{@text@baccent1}⟩\otimes {\bar{\mathtt{X}}}^{\prime }|{\bar{\phi }}^{\prime }⟩.$$

$$\Qcircuit@C=1.3em@R=1em{&\lstick{|\varphi\rangle_{A}}\multigate{2}{\mathcal{M}_{{\mathtt{Z}}{\mathtt{Z}}}}\gate{\mathcal{M}_{{\mathtt{X}}}}\cctrl{2}\\ \pureghost{\mathcal{M}_{{\mathtt{Z}}{\mathtt{Z}}}}\cctrl{1}\\ \lstick{|+\rangle_{B}}\ghost{\mathcal{M}_{{\mathtt{Z}}{\mathtt{Z}}}}\gate{{\mathtt{X}}}\gate{{\mathtt{Z}}}\rstick{|\varphi\rangle_{B}}\qw}$$

Full text

\ddt

Reliable channel-adapted error correction: Bacon-Shor code recovery from amplitude damping

Álvaro Piedrafita1,2 and Joseph M. Renes1

1Institute for Theoretical Physics, ETH Zürich, Switzerland

2Qusoft and CWI, Amsterdam, The Netherlands AP completed most of this work while at ETH Zürich.

We construct two simple error correction schemes adapted to amplitude damping noise for Bacon-Shor codes and investigate their prospects for fault-tolerant implementation. Both consist solely of Clifford gates and require far fewer qubits, relative to the standard method, to achieve correction to a desired order in the damping rate. The first, employing one-bit teleportation and single-qubit measurements, needs only one fourth as many physical qubits, while the second, using just stabilizer measurements and Pauli corrections, needs only half. We show that existing fault-tolerance methods can be employed for the latter, while the former can be made to avoid potential catastrophic errors and can easily cope with damping faults in ancilla qubits.

Introduction

The performance of quantum error correction over a given channel can be substantially improved by adapting the decoding algorithm to the channel. For the amplitude damping channel, which describes the effects of energy relaxation, Leung et al. illustrate this quite dramatically with a four qubit code capable of correcting single damping errors [1], one qubit fewer than the minimum number needed to recover from an arbitrary single-qubit error [2, 3]. However, there is no guarantee that the performance available to a given code and channel can be realized by simple correction circuits. For instance, although the Shor code [4] can in principle correct two amplitude damping errors [5], standard recovery based on stabilizer measurement and Pauli recovery operations will correct only one. And the problem of finding simple high-performance decoders is compounded when requiring the decoder to tolerate noise during its implementation. Nonetheless, reducing the qubit overhead needed for error correction would be tremendously useful in near term efforts to construct quantum information processors.

In this paper we investigate the performance of simple decoding schemes for the Bacon-Shor code family [6] adapted to amplitude damping noise. The $(n,m)$ Bacon-Shor code combines two classical repetition codes, a length-$n$ code for phase flips and a length-$m$ code for bit flips, and by standard stabilizer recovery can correct up to $\min(\lfloor(n-1)/2\rfloor,\lfloor(m-1)/2\rfloor)$ arbitrary single-qubit errors. Duan et al. observe that for amplitude damping noise the $(t+1,t+1)$ code exactly satisfies the error-correcting conditions to order $t$ in the damping probability $\gamma$ [7], meaning Bacon-Shor codes can in principle correct twice as many damping errors as arbitrary single-qubit errors. Here we present an error correcting procedure using only Clifford operations that achieves this performance, as well as a syndrome-based procedure (requiring only stabilizer measurements) which perfectly recovers $(t+1,2t+1)$ codewords to order $t$.

Furthermore, we also investigate the prospects for fault-tolerant implementation of the two correction schemes. Our syndrome correction method also corrects the Pauli twirl [2] of the amplitude damping channel, which makes it amenable to the use of standard fault-tolerant gadgets. The Clifford correction does not, however, complicating the analysis. Nevertheless, we find that while single, ill-timed damping events can be catastrophic for direct implementation of the correction procedure, this problem can be avoided by suitable alterations. Additionally, we show that damping errors in ancillas used for error correction propagate into the data as phase errors, and are therefore correctable by subsequent correction cycles. This would seem to require the use of the $(2t+1,2t+1)$ code for syndrome correction, wiping out all qubit savings relative to standard decoding. But the $(2t+1,t+1)$ code would suffice for Clifford correction, meaning it could reliably recover from combined amplitude damping and dephasing noise (often characterized as $T_{1}$ and $T_{2}$ decay times, respectively [8]) using half as many qubits as the standard method.

Channel adapted error correction has been studied by several authors. Fletcher et al. consider the problem of finding structured decoders in [9] and [10]. The latter, which is specifically focused on amplitude damping, extends the construction of Leung et al. to higher rates and gives a stabilizer-based recovery, but does not consider fault-tolerance. They do describe a stabilizer-based decoder for the Shor code which outperforms standard decoding, but it does not correct all errors to second order. Several further codes adapted to the amplitude damping channel have been found in [7, 11, 12, 13]. Indeed, Duan et al. observe that the $(t+1,t+1)$ code can correct damping to order $t$, but do not give an explicit error correction scheme. A comparison of various short codes subject to generalized amplitude damping is given in [14]. Meanwhile, fault-tolerance of Bacon-Shor codes has been analyzed for different noise models. Ralph et al. considered protection of optically-encoded quantum information against photon loss (erasure) [15], and this approach was recently analyzed for constructing a quantum repeater [16]. The effectiveness of concatenated and plain Bacon-Shor codes against Pauli noise is considered in [17, 18] and [19, 20], respectively.

We have structured the presentation of our results as follows. The next section details the amplitude damping channel and Bacon-Shor codes. We describe the two correction methods in §3 and prospects for fault-tolerant implementation in §4.

Setup

Amplitude damping channel

The amplitude damping channel describes the process of energy relaxation of a system from an excited state to its ground state. Supposing that the probability for decay is $\gamma$ and we are only interested in the two-dimensional space of the excited and ground states, the action of the channel $\mathcal{N}_{\gamma}$ is given by the following two Kraus operators

[TABLE]

An arbitrary state $\rho$ is transformed into $\mathcal{N}_{\gamma}(\rho)=A_{0}\rho A_{0}^{\dagger}+A_{1}\rho A_{1}^{\dagger}$.

Unlike a Pauli channel, neither of the Kraus operators has trivial effect on the input state. Damping, the action of $A_{1}$, is of course linear in the probability $\gamma$ (acting on the density operator, not state vector). Meanwhile, the nondamping operator can be expressed as a superposition of identity $\mathtt{I}$ and phase flip ${\mathtt{Z}}=\sigma_{z}$,

[TABLE]

Thus, by the usual discretization argument [4, 21], phase error correction is sufficient to reverse the action of $A_{0}$ to second order in $\gamma$.

It will also be useful to consider the Pauli twirl of $\mathcal{N}_{\gamma}$ [2], the Pauli channel resulting from randomizing the orientation of the input and output in the following manner:

[TABLE]

where we have used the usual notation for the Pauli operators for convenience, including $\sigma_{0}={\mathtt{I}}$. Amplitude damping is of course already covariant with respect to rotations about the $z$ axis, so only the ${\mathtt{X}}=\sigma_{x}$ randomization has any effect here. It is easy to work out that the probabilities of the various Pauli operators in $\mathcal{N}^{\text{Pauli}}_{\gamma}$ are just $\tfrac{1}{4}\gamma$ for both ${\mathtt{X}}$ and ${\mathtt{Y}}$ and $\tfrac{1}{4}(2-\gamma\pm 2\sqrt{1-\gamma})$ for ${\mathtt{I}}$ and ${\mathtt{Z}}$, respectively. Expanding the latter to second order, we have $1-\tfrac{1}{2}\gamma-\tfrac{1}{16}\gamma^{2}$ for ${\mathtt{I}}$ and $\tfrac{1}{16}\gamma^{2}$ for ${\mathtt{Z}}$, corresponding to the contribution of phase errors by $A_{0}$ at second order.

Bacon-Shor codes

Bacon-Shor codes are stabilizer-based subsystem codes built from two classical repetition codes [6]. The $(n,m)$ code encodes a single qubit into $nm$ physical qubits, which can be thought of as arranged on a rectangular $n\times m$ lattice. The stabilizer generators of the code are then given by the products of ${\mathtt{X}}$ operators on all qubits in any two neighboring rows and the products of ${\mathtt{Z}}$ operators on all qubits in two neigboring columns. Additional operators are needed to fix the “gauge” of the code. For our purposes we will be interested in the ${\mathtt{Z}}$ gauge, where the gauge operators are ${\mathtt{Z}}$ operators on pairs of qubits anywhere in a row. Note that the ${\mathtt{Z}}$-type stabilizers are products of these ${\mathtt{Z}}{\mathtt{Z}}$ gauge operators. In the complementary ${\mathtt{X}}$ gauge, the additional stabilizers are ${\mathtt{X}}$ operators on pairs of neighboring qubits anywhere in a column; these similarly subsume the ${\mathtt{X}}$-type stabilizers. Our convention is that the logical operators $\bar{\mathtt{X}}$ and $\bar{\mathtt{Z}}$ of the code are just the row of ${\mathtt{X}}$ operators along the top and the column of ${\mathtt{Z}}$ operators along the left, respectively. Let us denote these operators by ${\mathtt{X}}^{\text{T}}$ and ${\mathtt{Z}}^{\text{L}}$, respectively.

Unsurprisingly, the Shor code is indeed the $(3,3)$ ${\mathtt{Z}}$-gauge code (with logical ${\mathtt{X}}$ and ${\mathtt{Z}}$ swapped) and it happens that the Leung et al. code is the $(2,2)$ ${\mathtt{Z}}$-gauge code. By using the stabilizers to separately perform standard correction of the repetition code for bit flips and phase flips, the $(n,m)$ code can protect its single encoded qubit from $\lfloor(n-1)/2\rfloor$ ${\mathtt{Z}}$ errors and $\lfloor(m-1)/2\rfloor$ ${\mathtt{X}}$ errors, irrespective of gauge. We refer to this procedure as standard correction.

The ${\mathtt{Z}}$ gauge codewords can be simply described as follows. The ${\mathtt{Z}}{\mathtt{Z}}$ gauge operators enforce the parity checks of the (${\mathtt{Z}}$-basis) $m$-fold repetition code in each row, so that the codewords must be spanned by |\text{\@text@baccent{0}}\rangle=|0\rangle\otimes\cdots\otimes|0\rangle or |\text{\@text@baccent{1}}\rangle=|1\rangle\otimes\cdots\otimes|1\rangle, where each |\text{\@text@baccent{i}}\rangle consists of $m$ qubits. Now it is easy to build up the codewords recursively by adding rows. For $|{\bar{i}^{\prime}}\rangle$ a logical ${\mathtt{Z}}$ codeword of the $(n-1,m)$ code, the codewords of the $(n,m)$ code are just |{\bar{0}}\rangle=|{\text{\@text@baccent{0}}}\rangle\otimes|{\bar{0}^{\prime}}\rangle+|\text{\@text@baccent{1}}\rangle\otimes|\bar{1}^{\prime}\rangle and |{\bar{1}}\rangle=|\text{\@text@baccent{0}}\rangle\otimes|{\bar{1}^{\prime}}\rangle+|\text{\@text@baccent{1}}\rangle\otimes|\bar{0}^{\prime}\rangle. This can be more succinctly expressed by writing the $(n,m)$ encoded state $|\bar{\varphi}\rangle$ in terms of the same state $|\bar{\varphi}^{\prime}\rangle$ encoded in the $(n-1,m)$ code and its logical ${\mathtt{X}}$ operator as

[TABLE]

Error correction

Damping of Bacon-Shor codewords

Duan et al. observed that the $(t+1,t+1)$ code satisfies the error-correcting conditions to order $t$ [7]. It is important to note that this only holds in ${\mathtt{Z}}$ gauge. Consider the $(2,2)$ code in ${\mathtt{X}}$ gauge, whose codewords are $|\hat{0}\rangle=|0000\rangle+|0101\rangle+|1010\rangle+|1111\rangle$ and $|\hat{1}\rangle=|0011\rangle+|0110\rangle+|1001\rangle+|1100\rangle$. It is easy to see that the error-correcting conditions are not satisfied for single jumps. If the first qubit is damped, the state resulting from $|\hat{1}\rangle$ will contain a term $|0001\rangle$, but this term will also be present in the result of damping the second qubit of $|\hat{0}\rangle$.

Before proceeding to the details of our two correction schemes, let us first consider which error operators are relevant to order $t$. Each qubit is afflicted with either Kraus operator $A_{0}$ or $A_{1}$, and since damping is linear in $\gamma$ we need only consider products of Kraus operators with at most $t$ factors of $A_{1}$. As $A_{0}$ effectively contributes phase errors starting at second order in $\gamma$, error operators with $k\leq t$ factors of $A_{1}$ can be regarded as $k$ damping errors on the corresponding qubits and no more than $\lfloor(t-k)/2\rfloor$ phase flips on the remaining qubits. For any given $A_{0}$ factor we are really only concerned with the first term in the expansion given in (2), since using the higher order terms only reduces the number of possible phase errors on other qubits.

It is also useful to examine the effect of damping errors on ${\mathtt{Z}}$-gauge Bacon-Shor codewords. Consider the effect of damping on a particular row. Since the codewords are constructed from |\text{\@text@baccent{0}}\rangle and |\text{\@text@baccent{1}}\rangle, by symmetry it suffices to consider damping of the first $k$ qubits by the error operator $E_{k}=A_{1}^{\otimes k}\otimes A_{0}^{\otimes{m-k}}$, for some $0<k\leq m$. From (4) we have $E_{k}|\bar{\varphi}\rangle=|0\rangle^{\otimes k}\otimes A_{0}^{\otimes{m-k}}|1\rangle^{\otimes m-k}\otimes\bar{\mathtt{X}}^{\prime}|\bar{\varphi}^{\prime}\rangle$. Thus, damping decouples the given row from the codeword and maps its logical information to the Bacon-Shor code with one fewer row, applying a logical bit flip along the way. Moreover, it manifests itself by altering at least one of the parity checks in the row. Logical ${\mathtt{Z}}$ is now $-{\mathtt{Z}}^{\text{L}}_{(n-1,m)}$, the left column of ${\mathtt{Z}}$ operators in the $(n-1,m)$ code, and the logical ${\mathtt{X}}$ is just ${\mathtt{X}}^{\text{T}}_{(n-1,m)}$. Damping of further rows moves the quantum information into fewer and fewer rows, applying a logical bit flip each time.

Clifford decoder

In light of the above, the following procedure will recover the quantum information encoded in the $(n,m)$ code to order $\min(n-1,m-1)$ in $\gamma$. This is an explicit scheme enabling the $(t+1,t+1)$ code to be perfectly recovered to order $t$. First, the ${\mathtt{Z}}{\mathtt{Z}}$ gauge operators are measured to identify rows afflicted with damping errors. Next the remaining $n^{\prime}$ undamped rows are treated as an $(n^{\prime},m)$ codeword, and its ${\mathtt{X}}$ stabilizers measured. After performing standard phase error correction, a logical ${\mathtt{X}}$ is applied if $n-n^{\prime}$ is odd. The original encoded information can then be obtained by reversing the $(n^{\prime},m)$ encoding circuit.

To verify the error correcting capability of this scheme, first observe that $E_{k}$ will produce a state with nontrivial syndrome unless $k=m$, i.e. unless all qubits in a row are damped. We therefore require $m\geq t+1$ in order to avoid this possibility at order $t$. Similarly, as the encoded information is lost if at least one qubit in each row is damped, we also require $n\geq t+1$. Given that $n^{\prime}$ undamped rows remain, to reverse the action of $A_{0}$ on each qubit to order $t$, by the usual discretization argument [4, 21] it is sufficient to correct at most $\lfloor(t-n+n^{\prime})/2\rfloor$ phase errors. Standard phase error correction achieves this for any $n^{\prime}\leq n$ since we have already chosen $n\geq t+1$. Finally, the last step reverses the logical bit flip acquired from each damped row.

Recovery to order $\min(n-1,m-1)$ is precisely the same performance the code has against erasures [5]. The reason this works for amplitude damping is that we need only detect damping events, not determine precisely which qubits were damped. Hence, the bit-flip error-detecting properties of the code suffice. Phase errors, meanwhile, are handled using error correction, but there are essentially only half as many phase errors to correct. Note that neither this nor any procedure can recover $(t+1,t+1)$ codewords to order $t$ from the twirled channel $\mathcal{N}_{\gamma}^{\text{Pauli}}$. Doing so would require correcting $t$ bit flips in a single row, which is impossible for the $(t+1)$-bit repetition code.

Clifford codeword correction

Combining the above decoder with one-bit teleportation [22] yields a simple Clifford correction circuit which restores the input codeword without completely decoding and re-encoding it. This is more amenable to fault-tolerant implementation. The action of the one-bit teleportation circuit at the logical level is depicted in Figure 1, while for encoded states we interchange the order of error correction and teleportation steps as follows.

First prepare $|\bar{+}\rangle_{B}$ in the new block $B$. Then measure $\tilde{\mathtt{Z}}$, the product of ${\mathtt{Z}}$ on qubits in the first column of $A$ and the first column of $B$. Next measure the ${\mathtt{Z}}{\mathtt{Z}}$ gauge operators on $A$. Depending on the result, measure all qubits in undamped rows in the ${\mathtt{X}}$ basis or the first qubit in damped rows in the ${\mathtt{Z}}$ basis. Finally, the necessary Pauli correction operators are determined from the measurement results. The value of $\bar{\mathtt{Z}}_{A}\bar{\mathtt{Z}}_{B}$ is given by $\bar{\mathtt{Z}}_{A}\bar{\mathtt{Z}}_{B}=(-1)^{\ell}\tilde{\mathtt{Z}}$, where $\ell$ is the number of rows in which the first qubit is found to be in state $|0\rangle$. Meanwhile, the value of $\bar{\mathtt{X}}_{A}$ is found by multiplying the individual ${\mathtt{X}}$ measurement results in each undamped row (treating them as $\pm 1$) and then taking the majority.

To see that this procedure indeed restores the original codeword, first note that the output is certainly a valid codeword, since measurement of $\tilde{\mathtt{Z}}$ commutes with the ${\mathtt{Z}}{\mathtt{Z}}$ gauge operators and ${\mathtt{X}}$ stabilizers in block $B$. Thus, we need only insure that the logical information is properly extracted. The logical $\bar{\mathtt{X}}_{A}$ operator is determined in the usual way from individual ${\mathtt{X}}$ measurements and standard error correction. Matters are more subtle for logical $\bar{\mathtt{Z}}_{A}$. Unlike the description above, here it makes sense to express $\bar{\mathtt{Z}}$ in terms of ${\mathtt{Z}}^{\text{L}}_{(n,m)}$ and not in terms of the logical operator of the subcode of undamped rows. This is easily done. Suppose one row is damped, so that, as above, $\bar{\mathtt{Z}}=-{\mathtt{Z}}^{\text{L}}_{(n-1,m)}$. If the first qubit in the damped row is damped, then it is necessarily in the ${\mathtt{Z}}=+1$ eigenstate $|0\rangle$, meaning $\bar{\mathtt{Z}}=-{\mathtt{Z}}\otimes{\mathtt{Z}}^{\text{L}}_{(n-1,m)}=-{\mathtt{Z}}^{\text{L}}_{(n,m)}$. On the other hand, if the first qubit was not damped, it is left in the state $|1\rangle$ by virtue of being in a damped row, and we have $\bar{\mathtt{Z}}={\mathtt{Z}}^{\text{L}}_{(n,m)}$. A similar argument applies to any number of damped rows, and shows that the procedure above extracts the correct value of $\bar{\mathtt{Z}}_{A}\bar{\mathtt{Z}}_{B}$ from the measurement of $\tilde{Z}$.

Syndrome correction

A simpler, purely syndrome-based correction scheme is also possible, one where the only quantum operations needed are stabilizer measurements and Pauli corrections. This method has less noise tolerance, but is capable of correcting $\mathcal{N}_{\gamma}^{\text{Pauli}}$ as well as $\mathcal{N}_{\gamma}$. The basic idea is to use the ${\mathtt{Z}}{\mathtt{Z}}$ gauge operators to identify the position of damped qubits, i.e. to use the ${\mathtt{Z}}{\mathtt{Z}}$ guage operators for error correction and not just detection. Correlations between bit and phase errors in $\mathcal{N}_{\gamma}^{\text{Pauli}}$ can be utilized to enable recovery to order $\min(n-1,\lfloor(m-1)/2\rfloor)$, meaning $(t+1,2t+1)$ codewords can be perfectly restored to order $t$.

The scheme is as follows. First, the ${\mathtt{Z}}{\mathtt{Z}}$ gauge and ${\mathtt{X}}$-type stabilizer operators are measured. The measurement results of the former are then used to perform standard bit-flip error correction in each damaged row. Next, standard phase-flip error correction is performed on the $(n^{\prime},m)$ code consisting of the undamaged rows; the necessary ${\mathtt{X}}$-type syndromes are computed from the ${\mathtt{X}}$ stabilizer measurement results. Finally, any suitable pattern of ${\mathtt{I}}$ and ${\mathtt{Z}}$ is applied to the first qubits of damaged rows to ensure all remaining ${\mathtt{X}}$ syndromes are reset to $+1$.

The ${\mathtt{Z}}{\mathtt{Z}}$ syndromes enable the decoder to identify and undo the actual bit-flip error pattern as usual, and thererfore recovery to order $t$ requires a code of at least $2t+1$ columns. Correction of phase errors, however, does not proceed by attempting to identify the precise phase error pattern. Note that in ${\mathtt{Z}}$ gauge we may as well regard any (odd number of) phase flips in a row as a phase flip on the first qubit, and so phase error correction can be reduced to recovery from the usual one-dimensional repetition code. But, and here is the distinction to the usual correction scheme, the error model does not just assume independent noise. Instead, rows containing bit-flipped qubits are as likely as not to be afflicted by phase flips, while phase flips occur at a lower rate in undamaged rows. Hence the damaged rows should simply be excluded in majority-vote decoding. Therefore, we can recover the quantum codeword by performing error correction on the undamaged rows and then resetting the ${\mathtt{X}}$ stabilizers involving the remaining rows by action on the damaged rows as needed. Following the calculation in §3.2, this requires at least $t+1$ rows to recover from order $t$ error events.

Fault-tolerant implementation

Now we turn to the question of whether the qubit savings afforded by either of the two correction schemes can be realized when damping noise also afflicts the correction operations themselves. There are two immediate issues to confront. One is the potential for catastrophic error propagation in the correction implementation itself, excluding ancillas. The other is how damping noise on ancilla systems and its subsequent propagation affects correctability in future correction cycles. We do not attempt a complete analysis of fault-tolerant implementation. Rather, our goal is to show that neither of these issues is immediately fatal to the proposed correction schemes, so there is indeed hope for realizing the savings offered by adapting the correction to the noise model.

First, though, it is important to note that it is not possible to reach arbitrarily low logical noise rates by choosing large enough $n$ and $m$. As with Pauli noise [19], Bacon-Shor codes have no nontrival noise threshold against amplitude damping even for ideal error correction. Consider the event in which every row has at least one damped qubit. This occurs with probability $(1-(1-\gamma)^{m})^{n}$ for the $(n,m)$ code, since the probability of any qubit in a row being damped is $1-(1-\gamma)^{m}$. Taking $m=n$, we even have $\lim_{n\to\infty}(1-(1-\gamma)^{n})^{n}=1$, which is easily seen by employing l’Hôpital’s rule on the logarithm of the probability. The increased error correcting power of larger codes is outstripped by the number of likely errors needing correction, and so code concatenation or some combination with another coding scheme is thus required to have a noise threshold. Nonetheless, encoding into small codes will result in a lower logical error rate than no encoding at all, just as observed for Pauli noise in [19, 20]. We leave finding the optimal code size for a given damping rate $\gamma$ as an open question.

Catastrophic errors

Catastrophic errors are not particularly an issue for syndrome correction, as it can be understood in the usual Pauli error framework. Indeed, this fact means that we can appeal to standard fault-tolerant methods such as Steane or Knill error correction and passive implementation of Pauli corrections by tracking the “Pauli frame” [23, 24, 21]. Nonetheless, these methods do not guarantee recovery of a $(t+1,2t+1)$ code to order $t$, as a proper accounting of the contributions from the various possible faults is still needed. This issue is investigated in the next section.

For the Clifford decoder and teleportation correction, however, catastrophic errors are a major concern. Indeed, damping of even a single qubit of an arbitrarily-sized codeword can cause a logical bit flip error in the Clifford decoder if it occurs between the ${\mathtt{Z}}{\mathtt{Z}}$ gauge and ${\mathtt{X}}$ stabilizer measurements. Take the $(2,2)$ code, for instance, and imagine that one of the first two qubits is damped after the ${\mathtt{Z}}{\mathtt{Z}}$ operators are found to both have the value $+1$. The stabilizer are now $-{\mathtt{Z}}{\mathtt{Z}}{\mathtt{I}}{\mathtt{I}}$, ${\mathtt{I}}{\mathtt{I}}{\mathtt{Z}}{\mathtt{Z}}$, and $(-1)^{j}{\mathtt{Z}}{\mathtt{I}}{\mathtt{I}}{\mathtt{I}}$, where $j\in\{0,1\}$ indicates which qubit was damped, while the logical operators can be expressed as ${\mathtt{I}}{\mathtt{I}}{\mathtt{X}}{\mathtt{X}}$ and $-(-1)^{j}{\mathtt{Z}}{\mathtt{I}}{\mathtt{Z}}{\mathtt{I}}$. Measurement of ${\mathtt{X}}{\mathtt{X}}{\mathtt{X}}{\mathtt{X}}$ will remove $(-1)^{j}{\mathtt{Z}}{\mathtt{I}}{\mathtt{I}}{\mathtt{I}}$ as a stabilizer, leaving us with no access to the value of $j$, and so error-correction fails. The difficulty is that the location of damping determines whether the encoded bit value is flipped or not, and the ${\mathtt{X}}$ stabilizer measurement destroys this information, also in codes of arbitrary size. Note that that the syndrome decoder avoids this problem by using the ${\mathtt{Z}}{\mathtt{Z}}$ checks to determine where damping occurred.

A similar problem plagues teleportation correction. One source of trouble is damping occurring between then $\tilde{\mathtt{Z}}$ and ${\mathtt{Z}}{\mathtt{Z}}$ measurements. We can think of the $\tilde{\mathtt{Z}}$ measurement as transferring the value of ${\mathtt{Z}}^{\text{L}}_{A}$ to the second block, and this value will be either $\pm\bar{\mathtt{Z}}$ depending on whether any first qubits are damped before or after the $\tilde{\mathtt{Z}}$ measurement itself. But in the scheme we have no way of knowing which is the case. This problem can be avoided by measuring $\tilde{\mathtt{Z}}$ in all the columns and making use of the fact that the logical operator could be defined using any column, not just the first. (This will not unduly disturb $\bar{\mathtt{X}}_{B}$ since the product of $\tilde{\mathtt{Z}}$ in two columns is a ${\mathtt{Z}}$-type stabilizer.) After the remaining measurements of the correction cycle, we can determine which column is unaffected by damping and take it as the value of $\bar{\mathtt{Z}}_{A}\bar{\mathtt{Z}}_{B}$. To order $t$ there will definitely be at least one good column, since there are $t+1$ in total.

Another issue is damping subsequent to the ${\mathtt{Z}}{\mathtt{Z}}$ checks. This will lead to a random value of the computed ${\mathtt{X}}$ value of the affected row, and thus behaves as a phase error. Hence phase errors now essentially occur at order $\gamma$, not just $\gamma^{2}$, which implies that a $(2t+1,t+1)$ code will be needed to recover to order $t$. Though note that this should be understood as a lower bound on the code size, since we have not considered the effects of multiple damping events distributed over the different stages of the correction procedure. We will see in the next section that the additional rows will anyway be needed to combat phase errors arising from damping of ancilla qubits.

Error propagation

The second issue is whether subsequent error correction cycles can deal with the effects of damping noise in the ancillas needed for correction in earlier cycles. Let us examine this effect for single-qubit ancilla schemes for measuring the ${\mathtt{Z}}{\mathtt{Z}}$ check operators, since this possibility is indeed one appeal of Bacon-Shor codes in the first place.

The most straightforward measurement setup is to prepare a qubit in the $|0\rangle$ state, sequentially apply cnot gates from the two data qubits to the ancilla, and then measure the ancilla in the standard basis. However, it is not difficult to work out that damping of the qubit after the first cnot will project the data qubit onto the $|1\rangle$ state. The Kraus operator for this case is simply $(\mathbbm{1}\otimes A_{1})U_{\textsc{cnot}}(\mathbbm{1}\otimes|0\rangle)=\sqrt{\gamma}|1\rangle\langle 1|\otimes|0\rangle$, where the first qubit is the control and the second the target. This effectively introduces a phase error in the data block, since an otherwise undamaged codeword $|\bar{\varphi}\rangle$ will be transformed into |\text{\@text@baccent{1}}\rangle\otimes\bar{\mathtt{X}}^{\prime}|\bar{\varphi}^{\prime}\rangle. Logical $\bar{\mathtt{Z}}$ is unaffected, but both ${\mathtt{X}}$ stabilizers involving the damaged row will be flipped with probability one half, just as with a phase error. Moreover, the output state is such that phase error correction will catch this error and recover.

This same effect occurs in the Pauli noise model, since a damping event is now a bit flip, which is accompanied by a phase error that will propagate into the data block. And the same conclusion holds for a measurement setup using a single ancilla qubit in the $|+\rangle$ state and cphase gates.

Ultimately, in any of these cases, phase errors effectively occur in the data block at order $\gamma$, reducing the error-resilience of the code. For the syndrome decoder, this would imply that a $(2t+1,2t+1)$ code is needed, wiping out any advantage over the standard syndrome decoder. Perhaps this issue can be avoided by using Steane error correction. The one-bit teleportation scheme still retains an advantage over the standard decoder, as only a $(2t+1,t+1)$ code is needed.

Conclusions

We have shown that Bacon-Shor codes offer the possibility of considerably reduced qubit overhead for error correction against amplitude damping noise. From a theoretical point of view, it is interesting that the error correcting conditions can be met by a Clifford circuit, since neither is the channel a Pauli channel, nor does the circuit correct its Pauli twirl. From a more applied point of view our work invites a more detailed analysis of fault-tolerant implementation to determine if the qubit savings could be realized in a more realistic setting, such as combined amplitude damping and dephasing noise. Moreover, as adapting to the amplitude damping channel is relatively simple, this raises the question of whether similar gains can be found for other codes, e.g. surface codes. In their investigation of optimal decoding of small surface codes [25], Darmawan and Poulin recently observed that non-square lattices with effectively half as many qubits performed better than full square lattices. It seems plausible that significant overhead reductions are also possible for simple correction algorithms.

Acknowledgments. This work was supported by the Swiss National Science Foundation (SNSF) via the National Centre of Competence in Research “QSIT”, and by the European Commission via the project “RAQUEL”. AP thanks the NWO WISE grant the La Caixa Foundation for support.