Handling leakage with subsystem codes

Leakage is a particularly damaging error that occurs when a qubit excites to a state outside of its two-level computational subspace [3–10]. Much work has been devoted to characterizing and reducing leakage at the experimental level in different qubit architectures, including photonics [11], quantum dots [12–17], superconductors [18–28], topological qubits [29], and ion traps [30–32]. Unlike erasure, the locations of leakage errors are unknown, and so it is far more damaging [33–35].

Leakage rates are significant for several types of qubits [31, 36], and can even be the dominant error rate in the system [11, 37]. However, even when leakage is relatively less likely than other types of noise, the havoc it wreaks at the level of error-correction can quickly make it a limiting error process [31, 38]. This is for two reasons. First, standard error-correction is not equipped to handle errors acting outside the computational subspace, and so leakage can persist until it is corrected by some other means. Second, before it is corrected, leakage can cause damaging patterns of correlated errors that depend on the specifics of a platform's gate implementations.

Leakage can also present a fundamental error when compared to other noise sources. For example, while improved controls are continually reducing the dominating effects of coherent errors in ion-trap technologies, scattering events that cause leakage are more difficult to subdue. Consequently, although lower leakage rates make it a lesser concern for certain architectures currently, handling leakage in the low-error regime is vitally important for performing long computations reliably in the future.

Fortunately, one can reduce leakage by regularly swapping or teleporting qubits to the computational subspace [38, 39], and it has been rigorously shown that a threshold exists in this model [40]. This introduces a balancing act. Eliminating leakage too frequently incurs significant qubit and gate overhead, which in turn introduces more potential circuit faults. Eliminating leakage too infrequently allows leaked qubits to interact with many other qubits, introducing higher-weight correlated errors.

In this work, we focus on leakage in geometrically local codes, which are leading candidates for implementing quantum memories. Included in this category are topological codes, which exhibit some of the highest thresholds, support minimal overhead syndrome extraction, and are naturally amenable to qubit architectures that prefer local interactions [41].

Local codes are also a natural candidate for coping with leakage, as the number of qubits that may interact with any one leakage event is limited. Consequently, previous works have focused on quantifying the performance of topological subspace codes in the presence of leakage, including the surface code [13, 23, 31, 38, 42] and [[7, 1, 3]] Steane or color code [11].

The (subspace) surface code is a particularly enticing choice as, in many respects, it is the top-performing quantum memory and a quantum analog of the repetition code [43, 44]. This analogy can be made precise, in the sense that the surface code nearly saturates the CSS zero-rate entropic bound $2H({p}_{\mathrm{thr}})\leqslant 1$ and can be realized as the hypergraph product of the repetition code with itself [45–48]. Among its desirable features is the use of a single ancilla to extract syndromes, relevant to both its high performance and square lattice locality [41, 49].

However, the surface code still suffers from significantly reduced thresholds [38] and an effective distance reduction [31, 42] in the presence of leakage. It is then natural to ask if other local code families may perform better in certain regimes of a leakage error model.

Diverging from previous works, our focus will be on subsystem codes, and in particular, subsystem surface and Bacon–Shor codes. Subsystem codes are a generalization of subspace codes in which certain logical degrees of freedom are treated as gauges, and allowed to vary freely [50, 51]. Unlike topological subspace stabilizer codes, which require at least 4-local interactions in a nearly Euclidean lattice [52], topological subsystem codes can be realized with 3- or even 2-local interactions [53–56]. If one sacrifices topological protection, then non-topological local codes like the Bacon–Shor family can still yield good error protection at reasonable error rates with only 2-local interactions and minimal overhead [57, 58].

Generally, subsystem codes come with certain intrinsic advantages. Their increased locality is even more desirable for physically local qubit architectures. They allow for simpler and parallelized syndrome extraction, which mitigates the circuit-depth required to measure higher-weight stabilizers [59]. Geometrically constrained codes can yield better encoding rates compared to their subspace cousins [44, 48, 60]. Finally, subsystem codes can yield tremendous advantages for implementing simple and universal fault-tolerant logic [61–63], bypassing the high cost of magic-state distillation [64].

However, the advantages of subsystem code locality often come at a high cost to their error-corrective performance. While gauge degrees of freedom are useful for implementation in local architectures and fault-tolerant computation, they introduce more locations for potential circuit faults without giving additional information about the errors that are occurring. This generally manifests as less reliable high-weight stabilizers and lower thresholds.

In this work, we highlight a simple and intrinsic error-corrective advantage for these gauge degrees of freedom: limiting correlated errors due to leakage. This differs from an independent depolarizing model, in which local measurements do not reduce the set of correlated errors.

To be explicit, suppose we wanted to measure a stabilizer $S={G}_{1}\ldots {G}_{{\ell }}$, where each G_i is a gauge operator. If we measure each gauge separately, then a single fault while measuring G_i will produce an error supported entirely on the support of G_i. If instead we measure the entire stabilizer directly, then a single fault could produce an error supported on the support of many G_i. However, in an independent depolarizing model, as long as we measure along the gauge operators, this error will take the form ${{EG}}_{i+1}\ldots {G}_{n}$ where E is supported entirely on the support of G_i. In particular, the set of correlated errors is the same with or without local measurements up to a symmetry of the logical subsystem. For some gate-error models with non-local interactions, it is even advantageous to measure the larger stabilizers directly [46, 65].

However, this is not true for typical leakage models, as a single leakage can produce a much richer set of correlated errors. Consequently, circuits that are fault-tolerant in a depolarizing model may no longer be fault-tolerant in a leakage model. We illustrate this difference in the single ancilla extraction of a Bacon–Shor code stabilizer with both Pauli and leakage faults in figure 1.

Zoom In Zoom Out Reset image size

We compare three code families in the presence of leakage: subspace surface codes, subsystem surface codes, and Bacon–Shor codes, while restricting to bare-ancilla syndrome extraction. We consider the first two in both standard and rotated lattice geometries, and under various leakage reduction techniques. In stark contrast to depolarizing noise, we find that subsystem surface codes actually outperform their same-distance subspace cousins at equal leakage-to-depolarizing ratios in the low-error regime. Furthermore, we observe that low to intermediate distance Bacon–Shor codes outperform subspace surface codes in per-qubit leakage protection at similar error rates. These advantages are due essentially to the subsystem codes' handling of uncontrolled 'hook' errors during syndrome extraction with leaked qubits. Finally, if one allows for larger ancilla states in a restricted leakage model, we observe that intermingling minimal leakage reduction with partial fault-tolerance in the subspace code ultimately yields the best overall low-error performance. Our central contributions are the following.

• (i)  
  We motivate a Pauli-approximated ion-trap leakage model, and demonstrate significantly improved performance compared to a worst-case stochastic leakage model. This model is similar to a photonics leakage model [11].
• (ii)  
  We show that any topological subspace stabilizer code must incur a linear reduction in effective distance when using minimal leakage reduction to correct worst-case stochastic leakage. In the case of subspace surface codes, the effective code distance is halved [31, 38, 42].
• (iii)  
  We define a rotated variant of the subsystem surface codes proposed in [53] which yields reduced qubit overhead. We argue that these codes (along with their un-rotated variant) yield better per-qubit distance protection than subspace surface codes in the presence of leakage. We give coarse upper-bounds on the error regime in which this advantage manifests, with $p\lessapprox 2.5\times {10}^{-4}$ with worst-case stochastic leakage and $p\lessapprox 0.32\times {10}^{-4}$ with ion-trap leakage.
• (iv)  
  We provide Monte Carlo simulations of both the subspace and subsystem surface codes at low error rates using no qubit overhead for leakage elimination. We find that subsystem surface codes outperform same-distance, same-geometry subspace surface codes for error rates $\lessapprox 0.75\times {10}^{-3}$ with worst-case stochastic leakage. This is increased to $\lessapprox 2.0\times {10}^{-3}$ for ion-trap leakage.
• (v)  
  We additionally compare Bacon–Shor codes with serialized syndrome extraction to subspace surface codes with ion-trap leakage. We observe that at low distances 3, 5, and 7, Bacon–Shor codes per-qubit outperform surface codes in the ${10}^{-4}\mbox{--}{10}^{-3}$ error range. This advantage persists even when the depolarizing rate is many times stronger than the leakage rate.
• (vi)  
  Finally, we compare different leakage reduction techniques in an ion-trap leakage model of the surface code while allowing for larger ancilla states. We observe that combining unverified two-qubit cat state extraction with minimal leakage reduction yields an orders-of-magnitude improvement over existing fault-tolerant proposals [38], and also begins to relatively outperform non-fault-tolerant strategies in the $\lessapprox {10}^{-3}$ error range. This advantage may extend to higher distances, but relies unavoidably on an assumption of independent leakage events.

At the heart of these results is a simple accounting of the correlated errors that may appear due to leakage of both data and ancilla qubits, and the quantification of the regime in which their effects dominate. However, it underscores an advantage of local subsystem error-correction that may extend to other non-Markovian error models, with local baths that are determined by the qubit connectivity [66]. In these cases, local checks minimize what can go wrong.

The paper proceeds as follows. In section 2, we define the two leakage models we consider, and introduce the leakage reduction techniques we will apply. In section 3, we compare the leakage robustness of subspace surface codes and subsystem surface codes by accounting for fault-paths generated by leakage. Although we focus on low-overhead leakage reduction with bare-ancilla measurements, we touch on more general leakage reduction strategies in appendix C. In section 4 we provide numerics comparing subspace and subsystem codes under various leakage reduction schemes and constraints. Finally, we conclude with some discussion and potential avenues for improvement in section 5. Additional technical details concerning the simulations and gate schedulings may also be found in appendix B.

There is some freedom in extending the dynamics of the system to interactions between leaked qubits and sealed qubits. In particular, we assume that our two-qubit gates are themselves sealed. For ${{ \mathcal H }}_{C}$ the computational Hilbert space and ${{ \mathcal H }}_{| 2\rangle }$ the leakage Hilbert space, this means that any two-qubit gate U factors as

$$\begin{eqnarray*}&&U={U}_{{{ \mathcal H }}_{C}\otimes {{ \mathcal H }}_{C}}\oplus {U}_{{{ \mathcal H }}_{C}\otimes {{ \mathcal H }}_{| 2\rangle }}\oplus {U}_{{{ \mathcal H }}_{| 2\rangle }\otimes {{ \mathcal H }}_{C}}\oplus {U}_{{{ \mathcal H }}_{| 2\rangle }\otimes {{ \mathcal H }}_{| 2\rangle }}.\end{eqnarray*}$$

This restriction is physically motivated in many architectures, including both superconductors [38, 42] and ion-traps [31]. In particular, U does not directly propagate one leaked qubit into two leaked qubits. Note that we can similarly define a sealed single-qubit gate as one that decomposes as $U={U}_{{{ \mathcal H }}_{C}}\oplus {U}_{{{ \mathcal H }}_{| 2\rangle }}$.

The two-qubit gate ${U}_{{{ \mathcal H }}_{C}\otimes {{ \mathcal H }}_{C}}$ is the computational gate and ${U}_{{{ \mathcal H }}_{| 2\rangle }\otimes {{ \mathcal H }}_{| 2\rangle }}$ can only apply a harmless phase. However, for two-qubit gates, it remains to define ${U}_{{{ \mathcal H }}_{C}\otimes {{ \mathcal H }}_{| 2\rangle }}$ and ${U}_{{{ \mathcal H }}_{| 2\rangle }\otimes {{ \mathcal H }}_{C}}$, the interactions between leaked and sealed qubits.

2.1.1. Depolarizing leakage

2.1.2. Mølmer–Sørensen leakage

The second is a more restrictive model in which a leaked qubit simply does not interact with a sealed qubit. This presents an effective gate-erasure error, which we expect may apply to several different architectures. One such example is the standard entangling operation for ion-traps: the Mølmer–Sørensen gate [67].

The two-qubit Mølmer–Sørensen interaction is mediated by the shared motional modes in an ion-trap. The underlying Hamiltonian is a state-dependent displacement, which is based on near-resonant driving of motional sidebands that correspond to removing or adding phonons of motion with excitation of the internal ion. The Hamiltonian parameters are chosen to remove any residual entanglement between the ion and motion at the end of the gate. The ion–ion entanglement arises from a second-order term due to the time-dependent displacement not commuting with itself in time.

Mølmer–Sørensen gates are often optimized in a way that is independent of the magnitude of the driving field, with the residual entanglement minimized ion by ion, and do not require a second ion to be driven. For a leaked ion, if the spacing between the motional modes is small compared to the separation between the computational energy state and the leakage energy state, then the lasers that drive the displacement are far from resonant and both to the same side of the carrier transition. The result is that the leaked ion is only very weakly displaced and therefore does not generate an entangling gate with the sealed ion, similar to a photonics model [11].

The Mølmer–Sørensen gate does not occur and the sealed ion is unaffected. For the full CNOT gate, the net effect is that different single qubit Pauli rotations are applied to the control and target qubits, see figure 2. The target undergoes an $X(-\pi /2)$-rotation along the Bloch sphere, while the control undergoes an $Z(-\pi /2)$-rotation. Whichever qubit is leaked is unaffected by the sealed single-qubit gate. In order to simulate leakage in the Pauli frame model in the same framework as [38, 42], we replace these channels with their Pauli-twirl approximations. This yields the stochastic error channels

$$\begin{eqnarray*}\begin{array}{rcl}{{ \mathcal E }}_{{\rm{bit}}}(\rho ) & = & \displaystyle \frac{1}{2}\rho +\displaystyle \frac{1}{2}X\rho X,\ \mathrm{and}\\ {{ \mathcal E }}_{{\rm{phase}}}(\rho ) & = & \displaystyle \frac{1}{2}\rho +\displaystyle \frac{1}{2}Z\rho Z,\end{array}\end{eqnarray*}$$

where ${{ \mathcal E }}_{{\rm{bit}}}$ is applied to the target when the control is leaked, and ${{ \mathcal E }}_{{\rm{phase}}}$ is applied to the control when the target is leaked. We refer to this model as Mølmer–Sørensen or MS-leakage. The twirl of this restricted model will yield significantly improved performance compared to DP-leakage, although one must be careful to weigh this against the generic benefit of twirling [68, 69]³ .

Zoom In Zoom Out Reset image size

As errors preserving the computational subspace accumulate, error-correction will periodically remove them. However, standard error-correction does nothing to remove leakage. Every leakage event will eventually relax back to the computational subspace, but these long-lived leakage errors will corrupt the surrounding qubits for several rounds of error-correction [42]. Without an active approach to remove leakage, it will completely compromise the efficacy of the code, see figure 3.

Zoom In Zoom Out Reset image size

Leakage reduction units or LRUs are circuit gadgets that are used to actively remove leakage [39, 40]. They are defined by two properties:

• (i)  
  if the quantum state is sealed, an LRU ideally acts as the identity on that state, and
• (ii)  
  if the quantum state is leaked, then an LRU ideally projects the state back to the computational subspace.

There are two popular approaches for eliminating leakage. The first is to introduce auxiliary qubits and regularly swap between them and the initial data qubits in LRUs. After the states are swapped, the initial data qubits are measured and reprepared in the computational space, removing leakage. If one relaxes the assumption that the gates are sealed, then one must teleport the initial data qubits to remove leakage, see figure 4. The frequency and placement of these LRUs will determine the code performance, which we address in section 3.

Zoom In Zoom Out Reset image size

The second approach foregoes auxiliary qubits, and instead periodically swaps the roles of data and ancilla in the code. This ensures that each physical qubit is measured in every other round [13, 31, 38]. This technique requires no qubit overhead, and may preserve the locality of the qubit lattice. For these reasons, it may be the more desirable approach. While it is more complicated to analyze the effects of longer-lived leakage faults, we study this technique numerically in section 4.

How frequently should we insert LRUs into our error-correction circuit? We focus on two minimal overhead strategies.

• (i)  
  Syndrome extraction leakage reduction (syndrome-LR) swaps each data qubit with an associated auxiliary qubit at the end of each syndrome extraction. This allows a single leakage to persist for a single syndrome extraction cycle. With some circuit delay, the ancillae may be used as the auxiliary qubits.
• (ii)  
  Swap leakage reduction (swap-LR) removes leakage by applying a swap gate between each ancilla qubit and the last data qubit it interacts with in each syndrome extraction cycle. This allows a single leakage to persist for at most two consecutive syndrome extraction cycles; see figure 10.

We first consider fault-tolerance using syndrome-LR on subspace surface codes with bare-ancilla syndrome extraction. Subspace surface codes are defined on a square lattice, with qubits placed on the edges of the lattice. To each plaquette P in the bulk of the lattice, we associate a 4-body X-type stabilizer, and to each vertex V in the lattice, we associate a 4-body Z-type stabilizer,

$$\begin{eqnarray*}&&{X}_{P}:= \displaystyle \prod _{e\in P}{X}_{e}\ \mathrm{and}\ {Z}_{V}:= \displaystyle \prod _{e\ni V}{Z}_{e}.\end{eqnarray*}$$

Then the stabilizer group is generated by all plaquette and vertex operators of this form, as well as those on the boundary. For a standard lattice these boundary stabilizers are weight-3, while for rotated lattices they are weight-2, and we refer to violated stabilizers in the lattice as excitations. Standard codes form a family with parameters $[[2{d}^{2}-2d+1,1,d]]$, while rotated codes form a family with parameters $[[{d}^{2},1,d]]$.

In the presence of DP-leakage, both the standard and rotated surface codes experience a halving of their effective distance, caused in part by uncontrolled 'hook' errors [41] during syndrome extraction [31, 38, 42]. Three such distance-damaging faults, caused by ancilla leakage, are shown in figure 5.

Zoom In Zoom Out Reset image size

However, standard subspace codes are robust to MS-leakage. Unlike depolarizing errors, a single data leakage event may cause many different configurations of measurement outcomes on incident stabilizer checks before its removal. Thus, a space-correlated error due to a data leakage may produce any one of its possible time-correlated syndrome configurations, but only over a single time-step. Given d successive syndrome measurements, this reduces the problem to considering only space-correlations in fault patterns.

In the MS-leakage model, data leakage is not too damaging: although it may generate many combinations of time-correlated syndrome configurations, it does not produce any new space-correlated errors. The reason is that data MS-leakage cannot propagate errors to ancillae that will then propagate errors to other data qubits. Thus, it suffices to only consider space-correlated errors due to ancilla leakage.

Ancilla MS-leakage may produce arbitrary configurations of errors on the support of a stabilizer that are of the same type as that stabilizer. For the subspace surface code, every such configuration is either a single-qubit or two-qubit error, up to stabilizer equivalence. In particular, in the standard lattice, there are two different configurations of excitations (up to symmetry) caused by weight-2 correlated errors. Both are contained in an ${L}^{\infty }$-ball of radius one on the ancilla qubit lattice, and so any configuration of excitations caused by $\lt d$ faults cannot traverse the lattice. As any logical operator which does not traverse the lattice must be trivial, we may conclude that the effective distance of the code is preserved. See figure 6 for a summary of these worst-case leakage events.

Zoom In Zoom Out Reset image size

As subspace surface codes are susceptible to DP-leakage, each experiences an effective distance reduction $d\mapsto \lceil \tfrac{d}{2}\rceil$ [31, 38, 42]. This is damaging to their low-error suppression, and we will show that this damage begins to manifest at low but relevant sub-threshold error rates. One might hope to construct some clever topological code and scheduling that minimizes the damage that DP-leakage inflicts on the effective code distance.

Unfortunately, a simple union bound shows that this damage is inevitable when restricting to minimal overhead leakage reduction in topological stabilizer subspace codes. However, the proof will give intuition for avoiding this damage by extending the search to topological stabilizer subsystem codes.

Proposition 1 Let $\{{C}_{d}\}$ be a family of D-dimensional topological subspace stabilizer codes parameterized by diverging distance d using bare-ancilla syndrome extraction and syndrome-LR. Let ${d}_{\mathrm{eff}}$ denote the minimum number of circuit faults that may cause a logical error in the presence of DP-leakage. Then there must be a linear effective distance reduction, i.e. there is a constant $\eta \lt 1$ such that ${d}_{\mathrm{eff}}\leqslant \eta d.$

Proof. By definition, each C_d is defined on a D-dimensional lattice of qubits with a metric. As the code family is topological, there must be some maximum diameter ξ of the support of any stabilizer generator of the code, where ξ is independent of d.

Select any weight-d logical operator

$$\begin{eqnarray*}&&L={P}_{{{\ell }}_{1}}{P}_{{{\ell }}_{2}}\ldots {P}_{{{\ell }}_{d}}\end{eqnarray*}$$

acting on qubits ${{\ell }}_{1},\,\ldots ,\,{{\ell }}_{d}$, where each $P\in \{X,Y,Z\}$. Select a maximal set R of disjoint neighborhoods ${B}_{{{\ell }}_{i}}(\xi )$ centered at qubits in the support of L. Recall that

$$\begin{eqnarray*}&&\mathrm{vol}({B}_{{{\ell }}_{i}}(\xi ))=\displaystyle \frac{{\pi }^{D/2}}{{\rm{\Gamma }}\left(\tfrac{D}{2}+1\right)}{\xi }^{D}=: {c}_{D}{\xi }^{D}.\end{eqnarray*}$$

Then there must be at least $\lfloor \tfrac{d}{{c}_{D}{\xi }^{D}}\rfloor$ such neighborhoods in this collection.

Using syndrome-LR, note that r ancilla leakage events can cause any configuration of errors on the combined support of r stabilizer generators. Furthermore, for each ${B}_{{{\ell }}_{i}}(\xi )\in R$, there is some stabilizer generator ${S}_{{{\ell }}_{i}}$ such that $\{{P}_{{{\ell }}_{i}},{S}_{{{\ell }}_{i}}\}=0$. As $[{S}_{{{\ell }}_{i}},L]=0$, there must be at least one other ${P}_{{{\ell }}_{j}}$ supported in ${B}_{{{\ell }}_{i}}(\xi )$ with $\{{P}_{{{\ell }}_{j}},{S}_{{{\ell }}_{i}}\}=0$.

In particular, each ${B}_{{{\ell }}_{i}}(\xi )\in R$ contains a stabilizer that intersects L in at least two locations, ${{\ell }}_{i}$ and ${{\ell }}_{j}$. Thus, a single ancilla leakage could produce the error ${P}_{{{\ell }}_{i}}{P}_{{{\ell }}_{j}}$, reducing the effective code distance by one.

Now suppose we have two such stabilizer generators: ${S}_{{{\ell }}_{i}}$ corresponding to ${P}_{{{\ell }}_{i}}$, and ${S}_{{{\ell }}_{i}^{\prime} }$ corresponding to ${P}_{{{\ell }}_{i}^{\prime} }$. Then ${{\ell }}_{j}$, as an element in the support of ${S}_{{{\ell }}_{i}}$ with diameter ξ, must lie in ${B}_{{{\ell }}_{i}}(\xi )$. Similarly, ${{\ell }}_{j^{\prime} }$ must lie in ${B}_{{{\ell }}_{j}^{\prime} }$. As these balls are disjoint, ${{\ell }}_{j}\ne {{\ell }}_{j^{\prime} }$.

Thus, each ball in R corresponds to an ancilla leakage which reduces the effective distance of the code by at least one, and these reductions combine so that ${d}_{\mathrm{eff}}\leqslant d-| R|$. As $| R| \geqslant \tfrac{d}{{c}_{D}{\xi }^{D}}$, we may conclude that ${d}_{\mathrm{eff}}\leqslant \eta d$, where η is given by $1-\tfrac{1}{{c}_{D}{\xi }^{D}}$.□

Practically speaking, for most popular topological codes, the effective distance is halved. Because DP-leakage is so damaging, one might expect that any code family, when restricted to minimal overhead leakage elimination, would incur a linear distance reduction. However this is not the case: if one relaxes the practical restriction of a topological generating set, then we can manage ${d}_{\mathrm{eff}}=d-1$ in the surface code by overlapping measurement supports; see appendix D.

A more plausible solution is to use subsystem codes, in which we can measure operators that anticommute with (dressed) logical operators. Such codes are natural to consider, as their increased locality may require less relative overhead to be robust in the presence of leakage. In fact, we will see that subsystem surface codes provide a subsystem counterexample to proposition 1.

3.3.1. Constructions

In this section, we construct subsystem surface codes from the perspective of ensuring robustness in the presence of leakage. On a standard lattice, these codes are equivalent to those introduced in [53], and have weight-6 stabilizers that can be expressed as the product of weight-3 gauge operators in the bulk. We extend these codes to a rotated lattice, which have the same-weight bulk stabilizers and gauge operators. Opposite the subspace surface codes, the standard lattice has weight-2 boundary operators while the rotated lattice has weight-3 boundary operators.

Begin with the square lattice defining the surface code and insert a data qubit into the center of each plaquette. This triangulates the square lattice on which the surface code was initially defined, doubling the distance of the code with respect to Z-type errors. Furthermore, measuring these newly formed triangular X-type stabilizers in the presence of leakage groups the original data qubits into 'hooks', in which leakage can only recreate the hook errors defined in [41]. Unfortunately, this asymmetry between X and Z produces higher-weight, problematic hexagonal Z-type stabilizers. Measuring these larger Z-type stabilizers directly will damage the code more than measuring the stabilizers defined on the original square lattice.

The simple fix is to symmetrize the X- and Z-type operators: make both the X-plaquettes and the Z-plaquettes hexagonal. As a result, we have ${(d-1)}^{2}$ gauge degrees of freedom that we may use to measure each hexagonal stabilizer as a product of triangular gauge operators. Intuitively, as this groups the original data qubits into hooks for both X- and Z-type measurements, it should preserve the distance of the code in the presence of DP-leakage.

The price for this locality (as with many subsystem codes) is more qubits and higher-weight stabilizers, which in turn yield higher logical error rates and lower thresholds. This can be realized by relating the code capacity threshold to a phase transition of the random-bond Ising model on the honeycomb lattice along the Nishimori line [53, 74]. The resulting threshold estimate yields $p\approx 7 \%$ [75], compared to the surface code threshold estimate on a square lattice of $p\approx 11 \%$ [76].

See figure 7 for a pictoral description of these codes with boundary, which form a subsystem code family with parameters $[[3{d}^{2}-2d,1,d]]$ and ${(d-1)}^{2}$ gauge degrees of freedom. These codes inherit several nice properties from the subspace surface codes, including defect-based logical encoding, similar transversal gates, and efficient minimum-weight perfect matching decoding. Unfortunately, these codes also have significant qubit overhead per distance. For example, the smallest error-correcting code in the family forms a [[21, 1, 3]] code.

Zoom In Zoom Out Reset image size

Fortunately, analogous to the surface code, we can rotate the lattice in order to reduce this overhead. However, unlike the rotated surface code, the boundaries are fixed by the anisotropic orientation of the stabilizers. This subsystem code family has parameters $\left[\left[\tfrac{3}{2}{d}^{2}-d+\tfrac{1}{2},1,d\right]\right]$ with $\tfrac{{(d-1)}^{2}}{2}$ gauge degrees of freedom. In particular, the smallest error-correcting code in this family forms an $[[11,1,3]]$ code with at most weight-3 check measurements, see figure 8.

Zoom In Zoom Out Reset image size

3.3.2. Ancilla leakage

Having defined the subsystem surface code families, we turn to analyzing their correlated errors in the presence of leakage. Time-correlated syndrome configurations may be treated as before, and so we may again restrict our attention to space-correlated errors. We consider ancilla leakage and data leakage separately.

Ancilla leakage is much simpler to handle in this code, as the gauge generators are all weight-3. Select any triangular X-gauge generator; by symmetry, the same analysis will apply to all other generators. Then, up to gauge transformation, any error configuration of X-type will produce an effective weight one error on the data. As data leakage in the MS-model also causes no new space-correlated error configurations, we may immediately conclude that these codes are robust to MS-leakage.

Thus, we may focus solely on DP-leakage. In particular, only Z-type error configurations occurring on X-type gauge operators (and vice versa) may produce higher-weight correlated errors. Of the three possible weight-2 configurations of Z-errors on an X-gauge operator, two are equivalent to weight one Z-errors. Thus, we need only consider two new errors in the presence of DP-leaked ancillae: the remaining weight-2 Z-error, and the weight-3 Z-error that acts on the entire triangular X-gauge operator; see figure 9.

Zoom In Zoom Out Reset image size

Note that the excitations formed from both errors in figure 9 are contained in an ${L}^{\infty }$-ball of radius one in the standard lattice, but not in the rotated lattice. Thus, neither of these errors may reduce the effective distance of the subsystem surface code in the standard lattice, while the first will halve the effective distance in the rotated lattice.

Thus, it only remains to consider data leakage. However, data leakage in the DP-model may cause error propagation between different data qubits. Furthermore, this propagation will depend on the particular gate scheduling we choose. Consequently, we relegate an accounting of data leakage and gate schedulings to appendices A and B, respectively. With proper gate timings, data leakage does not cause an effective distance reduction in these codes.

One final type of leakage reduction proposed for the surface code in several works [13, 23, 31, 38, 42] is foregoing auxiliary qubits by regularly swapping the roles of data and ancilla. The idea is to continually measure and reinitialize all qubits in the lattice to ensure that leakage can persist for no more than two rounds of syndrome extraction. The mechanism for doing so is by applying SWAP gates between data and ancilla every round, see figure 10.

Zoom In Zoom Out Reset image size

This has two competing effects. On the one hand, it minimizes circuit overhead during syndrome extraction, yielding fewer potential fault locations. On the other hand, it allows leakage to persist for longer, resulting in more correlated errors. In the case of DP-leakage, the space-correlated errors it produces are also different: an ancilla leakage upon preparation depolarizes the support of its measurement, and then acts as a data leakage for one more round. These new space-correlated errors can again be handled by careful gate scheduling, at the cost of introducing additional weight-2 errors that do not damage the effective code distance; see appendices A and B.

In the case of MS-leakage, data leakage can propagate no further space-correlated errors. Thus, in the presence of MS-leakage and without using a different gate scheduling, we expect swap-LR to scale comparably to syndrome-LR. The similarities in behavior were also reported in [38].

This is precisely what we observe numerically by comparing the behaviors of DP-leakage and MS-leakage in a standard subspace surface code using swap-LR. It appears that the longer-lived leakage errors are not much more damaging, as the full-distance scaling of the code is approximately preserved in the presence of MS-leakage within the error regime we consider, see figure 11.

Zoom In Zoom Out Reset image size

In the depolarizing error model, the extra overhead incurred by introducing additional gauge degrees of freedom degrades the performance of the subsystem surface code. Even well below threshold, this manifests as higher logical error rates; see figure 12.

Zoom In Zoom Out Reset image size

However, in the presence of leakage, the locality of the subsystem codes allow them to outperform their subspace counterparts at sufficiently low error rates. In order to probe this low-error regime, we restrict ourselves to low-distance codes; see figure 13. We observe good agreement with the expected performance of each code. Each fit takes the form ${p}_{L}\sim {p}^{{d}_{\mathrm{emp}}}$, where ${d}_{\mathrm{emp}}$ is chosen to minimize the ${\chi }^{2}$-distance. For distances 3 and 5, we observe that ${d}_{e}-0.25\lt {d}_{{\rm{emp}}}\lt {d}_{e}+0.5$, where d_e is the expected scaling based on syndrome-LR (see figure C1). For distance 7, the samples were drawn predominantly from error rates $\gt 3\times {10}^{-4}$. At higher rates, the distance-4 suppression of the Pauli errors are a significant factor when compared to the distance-2 suppression of leakage errors. Nonetheless, we observe the expected pronounced distance reduction, with $2\lt {d}_{\mathrm{emp}}\lt 3$ for those codes susceptible to leakage, and ${d}_{\mathrm{emp}}\gt 4$ for those robust to leakage.

Zoom In Zoom Out Reset image size

Most importantly, for all codes that are leakage robust, we observe that ${d}_{\mathrm{emp}}\gt {d}_{e}-0.25$, giving evidence that the longer-lived leakage errors introduced during swap-LR are significantly less damaging than the space-correlated errors shared with syndrome-LR. Furthermore, we expect that error rates would improve to ${d}_{\mathrm{emp}}\approx {d}_{e}$ in this error regime given a decoder that could better handle long-range correlations, such as those based on renormalization groups [78, 79]. It is likely that these results would smooth out at higher distances, as off-by-one errors have a significant effect on the low distance scaling.

This establishes that certain subsystem codes relatively outperform subspace codes (at low distance), in the sense that same-distance, same-geometry subsystem codes yield better performance around $p\lessapprox 2.0\times {10}^{-3}$ for MS-leakage in a rotated geometry and $p\lessapprox 0.75\times {10}^{-3}$ for DP-leakage in a standard geometry. This contrasts with a local depolarizing model, in which subsystem codes do not relatively outperform surface codes in any error regime.

It is vitally important to note that this does not account for the $1.75\times$ qubit overhead required for subsystem codes of the same geometry as subspace codes. So while the arguments of section 3 demonstrate that subsystem codes offer better per-qubit distance protection in the presence of leakage, this advantage manifests at much lower error rates. Although we are unable to probe these error regimes directly at higher distances where direct per-qubit comparisons can be made, we can give coarse upper bounds using heuristic estimates based on thresholds, see appendix E. We estimate that, at the very least, p must be $\lessapprox 2.5\times {10}^{-4}$ in the presence of DP-leakage and $\lessapprox 0.32\times {10}^{-4}$ in the presence of MS-leakage to potentially see a per-qubit benefit at sufficiently high distance.

We next consider Bacon–Shor codes for use in the MS-leakage model. Bacon–Shor codes are subsystem codes defined on a lattice of $d\times d$ data qubits. They have $2(d-1)$ stabilizer generators, with X- and Z-type generators indexed by $1\leqslant k\leqslant d-1$ and defined by

$$\begin{eqnarray*}&&{X}_{k}:= \displaystyle \prod _{i=1}^{d}{X}_{i,k}{X}_{i,k+1}\ \mathrm{and}\ {Z}_{k}:= \displaystyle \prod _{j=1}^{d}{Z}_{k,j}{Z}_{k+1,j},\end{eqnarray*}$$

where ${P}_{i,j}$ represents the operator P acting on the qubit in the ith row and jth column of the lattice. Then the stabilizer group is generated by the set of all ${X}_{k},{Z}_{k}$. As subsystem codes, a generating set for the gauge operators is given by

$$\begin{eqnarray*}&&{G}_{i,j}^{(X)}:= {X}_{i,j}{X}_{i,j+1}\ \mathrm{and}\ {G}_{i,j}^{(Z)}:= {Z}_{i,j}{Z}_{i+1,j},\end{eqnarray*}$$

where addition is performed modulo the lattice size d. With this orientation, X_L consists of X operators spanning the north–south boundaries of the lattice, while Z_L consists of Z operators spanning the east–west boundaries of the lattice. In particular, Bacon–Shor codes share the same efficient data qubit scaling as rotated surface codes, forming a family of $[[{d}^{2},1,d]]$ codes.

Although there is additional ancilla overhead, this gives us two code families to compare more closely, namely the Bacon–Shor and rotated subspace surface codes in an MS-leakage model and with bare-ancilla extraction. The former sacrifices syndrome information to perform localized checks, with weight two gauge operators ensuring that every space-correlated error due to MS-leakage has weight one. The latter sacrifices locality for additional syndrome information, increasing the number of high-weight correctable errors while introducing other damaging correlated errors in the process. The result of this tradeoff is that, at low distances, Bacon–Shor codes yield a per-qubit error-corrective advantage in the presence of MS-leakage at reasonable error rates, ranging from 10⁻⁴ to 10⁻³; see figure 14.

Zoom In Zoom Out Reset image size

At low distance, this advantage manifests at error rates as high as $p\lessapprox 1.2\times {10}^{-3}$. Even when the leakage rate is an order-of-magnitude less than the depolarizing rate, the distance 3 Bacon–Shor code begins to outperform the corresponding surface code at error rates as high as $p\lessapprox 5.0\times {10}^{-4}$. Of course, these gains are more pronounced at higher leakage-to-depolarizing ratios. At lower error rates, one can observe the damage caused by leakage as the logical error suppression tapers off.

However, as the number of stabilizer checks in Bacon–Shor codes scale sublinearly in the lattice size, the family does not exhibit a threshold. Consequently, their advantage cannot persist at higher distances, although they can yield significant error-suppression which may suffice for the desired memory time [57, 58]. Coupled with simplified preparation and potential benefits against other correlated noise sources, this gives evidence that Bacon–Shor codes might prove advantageous in near-term fault-tolerance experiments or in low to intermediate distance error protection, within certain noise models [65].

Thus far, we have focused on codes defined on square qubit lattices with bare-ancilla syndrome extraction. While this might be preferable architecturally, we may relax this requirement to consider slightly larger ancilla states. Unlike the preceding results, which can be extended straightforwardly to the presence of correlated leakage by passing to syndrome-LR, this relies unavoidably on an independent leakage model. For some platforms, such as certain quantum dot architectures, these correlated leakage events must be handled. For others, we can leverage the independence assumption to combine the locality of the Bacon–Shor code with the performance of the surface code by encoding the gauge-fix directly into the ancilla. This amounts to performing the simplest Shor-style extraction, without verification or decoding.

Typical mechanisms for fault-tolerance involve preparing and verifying entangled ancilla states [80–83] or the use of flags [84, 85]. Unfortunately, as a leakage event can manifest many Pauli errors, it can often fool such verification schemes. Although this can make typical fault-tolerant circuits more difficult to engineer [11], the circuit locality of Shor-style syndrome extraction may provide a direct benefit when leakage events occur independently; see figure 15.

Zoom In Zoom Out Reset image size

Note that without entangling the ancilla, each measurement simply corresponds to measuring the gauge generators of the Bacon–Shor code. In this sense, entangling the ancilla encodes a gauge-fix of the Bacon–Shor code to the surface code [46], while robustness to MS-leakage is unaffected by this leading operation. One must at least pass to four-qubit cat states in the presence of DP-leakage, as any pair of qubits in the stabilizer supports two qubits of a minimal distance logical operator.

Compared to the previous fault-tolerance approach of [38], in which leakage reduction is performed after each gate, we observe an orders-of-magnitude improvement in performance; see figure 16. Similar to the Bacon–Shor code, using two-qubit cat state extraction outperforms bare-ancilla extraction below error rates $\approx {10}^{-3}$. However, as this family exhibits a threshold, we would expect that this advantage is better preserved at higher distances. When compared directly to Bacon–Shor codes, two-qubit cat state extraction of the surface code performs marginally worse at distance 3, and then begins to outperform.

Zoom In Zoom Out Reset image size

However, in the presence of correlated leakage events, the preparation of an entangled ancilla state may be badly corrupted. In this case, two-qubit cat states do not preserve the effective distance, highlighting that the more damaging the error model, the more valuable the subsystem locality. The resulting comparison between cat state extraction of the surface code and bare-ancilla extraction of the Bacon–Shor code in the presence correlated leakage events roughly mirrors the comparison between bare-ancilla extraction of both codes with independent leakage events; see appendix F.

There are two properties that we want our syndrome extraction to satisfy. The first is that it is correct: its outcomes correctly reflect Pauli errors on the data in the ideal case (i.e. there is no randomization due to measuring anticommuting operators consecutively). The second property we require is that two triangular gauge operators of the same type overlapping on any qubit cannot both interact with that qubit in the second time-step after their initialization. This requirement removes bad correlated errors due to data leakage. We call a syndrome extraction scheduling satisfying this property good.

In order to avoid the pitfall of measuring anticommuting operators, the simplest syndrome extraction is to first measure all X-type gauges in parallel, then measure all Z-type gauges in parallel. In [53], a rolling syndrome extraction was defined that ensured that no qubit was idle at any time-step during the syndrome extraction of the subsystem surface code. To simplify the discussion, we perform the simplest syndrome extraction in our gate error model without idling errors. We further motivate this simplification by detailing a fully-parallelized (on data qubits) good and correct syndrome extraction scheme for subsystem surface codes using syndrome-LR in appendix B.

It remains to argue that data leakage may not cause damaging correlated errors in a good and correct syndrome extraction scheme. Note that if an ancilla interacts with a data leakage in the third time-step after initialization, then it interacts with no other data qubits after that point and cannot spread a correlated error. If an ancilla interacts with a data leakage in the first time-step after initialization, then the resulting correlated error is equivalent to an error on the leaked qubit, up to gauge transformation. Thus, two-qubit errors due to data leakage may only occur in triangular gauge operators which both interact with the leakage in the second time-step after initialization.

Furthermore, each gauge operator may only propagate Pauli errors of the same type. As error-correction is performed independently, it suffices for leakage robustness that no two gauge operators of the same type both introduce correlated errors due to a single leakage. Thus, goodness of syndrome extraction ensures that any error of either X- or Z-type caused by a single data leakage is contained in one triangular gauge operator of that type. As this falls into the ancilla leakage model, we may conclude that the effective distance of the code is preserved. See figure A1 for the damaging data leakage that might occur in a bad syndrome extraction scheduling. This completes the analysis for subsystem surface codes using syndrome-LR.

Zoom In Zoom Out Reset image size

Similar to data leakage using syndrome-LR, we must ensure that errors of either X- or Z-type produced by a single data leakage event are contained in the support of a single gauge operator. In the case of syndrome-LR, long-range correlated errors could occur when two triangular gauge operators of the same type both interact with a data leakage in time-step two. In the case of swap-LR, because an ancilla leakage swaps places with a data qubit in time-step three, long range correlated errors could occur when two triangular gauge operators interact with a data qubit in any combination of time-steps two and three.

Fortunately, figure B5 demonstrates a gate scheduling that avoids these distance-reducing correlated errors. It includes a single long-range correlated error that is not too damaging, occurring when a data qubit occupying the short-side of a hexagonal stabilizer leaks; see the left-hand side of figure B1.

We follow the simulation technique in [38]: for a code of distance-d, we simulate d time-steps of faulty syndrome extraction. Then, we run an additional round of perfect syndrome extraction, converting any remaining leakage errors to depolarizing errors in the process. As we consider the simulated round of error-correction as occurring during a longer computation, we associate a leading probability of leakage according to the lifetime of each data qubit at its initialization. Each simulation ran until at least 200 failures were recorded, and for those simulations that required less than $5\times {10}^{8}$ trials, until at least 1000 failures were recorded.

For all simulations, we use the standard minimum-weight perfect matching decoder. The edge weights are generated by iterating over all single Pauli faults, and associating a relative probability p to each edge of the decoder graph. The weight of the edge is then defined to be $-\mathrm{ln}(p)$. Boundary conditions are handled according to the techniques of [102].

Note that we do not iterate over leakage events as they may cause fault configurations that result in hyperedges. Furthermore, for codes that experience a distance reduction in the presence of leakage, we would have to insert edges lying outside a fundamental cell. Thus, these edge weights are suboptimal. However, to counteract this, we add edges corresponding to known single-time-step leakage fault configurations occurring with probabilities linear in p. We heuristically weight these as four times the maximum edge probability generated by Pauli configurations.

For the subspace surface code, we use different but standard gate schedulings depending on the lattice geometry, see figure B1. Note that the decoder graph is always populated by more edges than in the independent depolarizing model, corresponding to the additional correlated errors that may be caused by leakage.

Zoom In Zoom Out Reset image size

For the subsystem surface code, we use the trivial scheduling; see figure B2. It is straightforward to check that the syndrome extraction satisfies the goodness property. For correctness, as the X- and Z-type syndromes are extracted serially, there can be no randomization due to anticommuting operators.

Zoom In Zoom Out Reset image size

However, we demonstrate that there also exists a good and correct syndrome extraction scheme that is fully-parallelized, i.e. there are no idling data qubits in any time-step. For this, we will need a lemma from [53] giving criteria on when a syndrome extraction scheduling is correct.

Lemma B.1 A fully-parallelized schedule of CNOTs is correct if for any pair of X-type and Z-type triangular gauge operators, at least one of the following is true:

• (i)  
  the two operators are disjoint;
• (ii)  
  the two operators are measured two rounds apart;
• (iii)  
  the last gate of the operator measured first in the pair commutes with the first gate of the operator measured last in the pair.

For proof, see [53]. One can show that any scheduling which is translation invariant with respect to a single pair of overlapping hexagonal stabilizers, as shown in figure B3, cannot simultaneously satisfy lemma B.1 and satisfy goodness.

However, there exist such schedulings that are translation invariant on adjacent pairs of overlapping hexagonal stabilizers, and such a scheduling suffices for odd distance codes with boundary. See figure B3 for an example, whose goodness can be checked and which satisfies the hypotheses of lemma B.1. This example demonstrates that there exist fully-parallelized syndrome extractions that are both good and correct. Note that, although there are no idling data qubits, there will be (few) idling time-steps for the ancilla qubits as data qubits are swapped with auxiliary qubits.

Zoom In Zoom Out Reset image size

Finally, for a swap-LR scheme defined on subsystem surface codes, long-range correlated errors may occur when triangular gauge operators of the same type interact with a data qubit in any combination of time-steps two and three. This can be avoided for all but one data qubit (up to translation-symmetry), with every data qubit swapping with some ancilla in time-step three. If that one data qubit is chosen properly, these long-range correlated errors do not damage the effective distance of the code. See figure B4 for the scheduling and the left-hand side of figure B1 for the benign correlated error.

Zoom In Zoom Out Reset image size