Scalable dissipative quantum error correction for qubit codes

Abstract

Dissipative quantum error correction (QEC) autonomously protects quantum information using engineered dissipation and offers a promising alternative to error correction via measurement and feedback. However, scalability remains a challenge, as correcting high-weight errors typically requires increasing dissipation rates and exponentially many correction operators. Here, we present a scalable dissipative QEC protocol for discrete-variable codes, correcting multi-qubit errors via a trickle-down mechanism that sequentially reduces errors weight. Our construction exploits redundancy in the Knill-Laflamme conditions to design correction operators that act on multiple error subspaces simultaneously, thereby reducing the overhead from exponential to polynomial in the number of required operators. We illustrate our approach with repetition codes under biased noise, showing a fourfold improvement in the exponential suppression factor at realistic physical error rates. Our approach connects autonomous QEC for discrete-variable codes with demonstrated dissipative protocols for bosonic codes and opens up new avenues for traditional measurement-feedback QEC and fault-tolerant quantum operations.

Figures (5)

• Figure 1: Number of correction operators vs. code size. Schematic comparison of the number of jump operators required to correct an $n$-qubit code $\mathsf{C}$ using lookup-table (red), trickle-down (black), and approximate decoder (dashed) schemes. Lookup tables assign one operator per error subspace, scaling as $\mathcal{O}(2^n)$. The trickle-down approach groups subspaces by error weight and use operators that reduce the weight of many subspaces simultaneously, yielding polynomial scaling. Approximate decoders offer an intermediate solution.
• Figure 2: Trickle-down vs. lookup-table QEC. (a) Logical error rate $p_L$ as a function of the physical error rate $\Gamma_\mathrm{e}$ for lookup-table (left) and trickle-down (right) dissipative QEC of $n$-qubit repetition codes under bit-flip noise. Vertical lines indicate the threshold values $\sim0.2$ and $\sim0.44$ for both solutions, respectively. (b) Exponential suppression factor $\Lambda=\Gamma_\mathrm{c}/\Gamma_\mathrm{e}^*$ as a function of $\Gamma_\mathrm{e}$ for the lookup-table (red) and trickle-down (black) approaches. Data points correspond to $(p_{L,i}(\Gamma_\mathrm{e})/p_{L,i+k}(\Gamma_\mathrm{e}))^{1/k}$, with $p_{L,i}(\Gamma_\mathrm{e})$ the logical error rate for an $i$-qubit code at fixed $\Gamma_\mathrm{e}$. Shaded markers show individual data points; solid markers show their averages. Solid lines are fits to inverse scaling, yielding $\Gamma_\mathrm{e}^* \approx 0.04$ and $\Gamma_\mathrm{e}^* \approx 0.2$ for lookup-table and trickle-down schemes, respectively. (c) Code sizes required to achieve specific $p_L$ values at a fixed physical error rate $\Gamma_\mathrm{e} = 10^{-2} \Gamma_\mathrm{c}$. Dashed lines show extrapolations based on $\Gamma_\mathrm{e}^*$.
• Figure S1: Trickle-down QEC. (a) Schematic of the trickle-down dissipative error correction scheme. Error subspaces $\mathsf{P}_i^{(j)}$ are grouped by their error weight $j$, with each horizontal block $\mathbb{P}_j$ representing all subspaces at weight $j$. The number of subspaces per level increases with the number of fundamental noise processes. Error weights range up to $\ell$, the maximum correctable weight. Arrows indicate the action of trickle-down jump operators, where identical arrow styles denote transitions implemented by the same operator. The Knill--Laflamme condition in Eq. \ref{['eq:KL_error_subspaces']} determines which subspace pairs can be corrected by a common operator. (b) Logical infidelity over time for a 13-qubit repetition code initialized in $\ket{\psi_\mathrm{L}} \propto \ket{0_\mathrm{L}} + i\ket{1_\mathrm{L}}$, subject to bit-flip noise (with error rate $\Gamma_\mathrm{e}=10^{-2}\Gamma_\mathrm{c}$) and dissipative QEC. We compare the performance of the lookup-table approach and the trickle-down scheme, the latter is performed up to different error-weight levels.
• Figure S2: Trapped-ion implementation. (a) Schematic of a trapped-ion setup for implementing trickle-down correction of a repetition code. Each of the $n$ qubits is encoded in two electronic levels of a single ion. The correction mechanism uses two additional electronic levels $\ket{e}$ and $\ket{f}$, two global motional modes $a$ and $b$, and a local mode $c$ that is sympathetically cooled to remove entropy. The process is driven by two global laser beams implementing the interactions in Eqs. \ref{['eq:hamilton1']} and \ref{['eq:hamilton2']}, and local beams implementing Eq. \ref{['eq:hamilton3']}. (b) Effective rates of the jump operators from Eq. (6) for a $21$-qubit repetition code, shown as a function of the error weight of the target subspaces. Desired processes reduce the error weight via $j \rightarrow j-1$ transitions, while undesired ones increase it via $j \rightarrow j+1$. Shaded regions correspond to processes beyond the correctable error weight $\ell = 10$, which are inactive but included to highlight the symmetry of the Lorentzian profiles.
• Figure S3: Approximate decoders. Example of a decoder graph for a surface code. Nodes represent syndrome bits $\vec{s}_i$, and edges represent possible error paths (or equivalently, corrections). The decoder's goal is to connect each pair of flagged vertices (i.e., $\vec{s}_i = 1$, marked with stars) via paths of minimal total weight, ideally matching the actual error. The original error is omitted. The decoder outputs a correction path $\tilde{U}_i^\dagger$ for each pair. Due to the topological nature of surface codes, any path differing by a stabilizer (e.g., $P_{i,1}$, $P_{i,2}$, $P_{i,3}$, $P_{i,4}$) is also a valid correction, as such loops are undetectable via stabilizer measurements and do not affect the logical state.