Quantum error correction at ultra-low overhead

The paper in detail

Quantum LDPC codes can protect many logical qubits per block, but their long-range checks are hard to wire on fixed hardware. Neutral atoms can be moved, so the question becomes: which codes have checks that atom motion carries out cheaply? Cornucopia codes answer with checks built from coordinate permutations of a \(3\times q\) torus, \((x,y)\in\mathbb Z_3\times\mathbb Z_q\) with \(\gcd(q,3)=1\).

There are twelve data blocks \(L_0,\dots,L_5,R_0,\dots,R_5\) and six check blocks \(X_0,X_1,X_2,Z_0,Z_1,Z_2\), each holding \(3q\) atoms. This gives \(n=36q\) data qubits and \(18q=n/2\) check qubits. With \(3q\times3q\) permutation matrices \(A_k,B_k\) (\(k\in\mathbb Z_6\)), \[H_X=[\mathbf A\mid\mathbf B],\qquad H_Z=[\tilde{\mathbf B}\mid\tilde{\mathbf A}],\] \[(\mathbf A)_{ij}=A_{j-i},\quad(\mathbf B)_{ij}=B_{j-i},\quad(\tilde{\mathbf B})_{ij}=B_{i-j}^{-1},\quad(\tilde{\mathbf A})_{ij}=A_{i-j}^{-1},\] for \(i\in\{0,1,2\}\) and \(j\in\mathbb Z_6\). Each permutation is one of three moves. \(A_1,B_3\) reverse the rows, \((x,y)\mapsto(2x+2,y+s)\). \(A_0,B_2\) cycle the rows, \((x,y)\mapsto(x+1,y+s)\). The rest only shift columns, \((x,y)\mapsto(x,y+s)\). The twelve shifts \(s\) are free and are optimized numerically. Every check has weight 12.

Each of \(H_X,H_Z\) has \(9q\) rows, so \(k\ge n-18q=n/2\). Reported instances run from \([[252,130,6]]\) to \([[2844,1426,18]]\), all with rate \(k/n\) slightly above \(1/2\). Counting check qubits, the largest code uses \(2844+1422=4266\) atoms for 1426 logical qubits, about 3 atoms per logical qubit. The authors compare this with bivariate bicycle codes: \([[288,12,18]]\) would need \(\lceil1426/12\rceil=119\) blocks of 576 qubits, about 68,544 atoms.

The noise model is circuit-level depolarizing noise of strength \(p\): two-qubit Pauli errors after each CNOT with probability \(p/15\) each, preparation and measurement faults with probability \(p\), and no idling noise. Decoding uses relay-BP with a BP-OSD fallback. Every simulated code exceeds a pseudo-threshold of 0.4%, the point where the logical error rate per logical qubit per cycle equals \(p\). Values at \(p=10^{-3}\) and \(10^{-4}\) come from fitting \(p_L=p^{d/2}\exp(c_0+c_1p+c_2p^2)\) and extrapolating; one example is \(2.6\times10^{-16}\) at \(d=18\), \(p=10^{-3}\). The modelled cycle takes 10.4 ms at \(d=6\) and 16.2 ms at \(d=18\), well inside the coherence time of about 10 s assumed for neutral atoms.

Transferable methods

1. Design the code and its circuit together

   The permutations that define the checks are also the moves the atoms make. Each of the twelve CNOT layers couples whole check blocks to whole data blocks through one permutation, so a layer is one rigid rearrangement followed by one global gate pulse.

   Why do the checks commute? Permutation matrices satisfy \(P^{-1}=P^{\mathsf T}\), so \((\tilde{\mathbf B}^{\mathsf T})_{jk}=B_{k-j}\) and \((\tilde{\mathbf A}^{\mathsf T})_{jk}=A_{k-j}\). Then \[(H_XH_Z^{\mathsf T})_{ik}=\sum_{j\in\mathbb Z_6}\bigl(A_{j-i}B_{k-j}+B_{j-i}A_{k-j}\bigr).\] Substituting \(j\mapsto i+k-j\) in the second sum turns \(B_{j-i}A_{k-j}\) into \(B_{k-j}A_{j-i}\). Each \(j\) then contributes \(A_{j-i}B_{k-j}+B_{k-j}A_{j-i}\), which vanishes mod 2 whenever the two permutations commute.

   When do they fail to commute? Translations in \(y\) always commute, and the \(x\)-parts are \(x\mapsto x\), \(x\mapsto x+1\) and \(x\mapsto2x+2\) on \(\mathbb Z_3\). Only a row cycle and a row reversal fail to commute: \((x+1)\circ(2x+2)=2x\), but \((2x+2)\circ(x+1)=2x+1\). Among pairs \((A_a,B_b)\), the non-commuting ones are \((A_1,B_2)\) and \((A_0,B_3)\), both with \(a+b=3\). In the sum above, \(a+b=k-i\in\{-2,\dots,2\}\), which is never \(3\bmod6\). Hence \(H_XH_Z^{\mathsf T}=0\). (Editorial expansion of the paper’s argument.)

   Why is the circuit cheap? Each permutation means “reorder three rows, then shift all columns by \(s\)”, a motion that crossed acousto-optic deflectors apply to a whole block at once. The time cost is set by kinematics. Moving a distance \(D\) at maximum acceleration \(a_{\max}\), accelerating for half the trip and braking for the other half, gives \(D/2=\tfrac12a_{\max}(t/2)^2\), so \(t_{\mathrm{fly}}(D)=2\sqrt{D/a_{\max}}\). Column shifts grow in length with \(q\), so ancilla motion per cycle grows as \(O(\sqrt q)\) in time. The data-block moves take about 6.07 ms per cycle, independent of code size.

   How to reuse it

   Start from the moves the hardware performs cheaply, here the affine maps of \(\mathbb Z_3\times\mathbb Z_q\), and build checks from them. Then verify \(H_XH_Z^{\mathsf T}=0\) algebraically by tracking which generators commute and which index sums can occur. The same bookkeeping applies to any quasi-cyclic or group-algebra code: commuting block entries make the CSS condition automatic. The cost model must include motion time, which grows as \(\sqrt{\text{distance}}\), not only gate counts.

2. Certify distance and count resources consistently

   The paper certifies distance from both sides, uses the code’s symmetries to make the search feasible, and reports error rates per logical qubit per cycle. Its tabulated rate counts data qubits only.

   For a CSS code, \(d=\min(d_X,d_Z)\) with \[d_Z=\min\{|v|:H_Xv=0,\ v\notin\operatorname{rowspace}H_Z\},\] and \(d_X\) defined symmetrically. Certification has two halves. An exhaustive search shows that no logical operator has weight below \(d\) (the lower bound), and an explicit logical operator of weight \(d\) gives the upper bound. Lemma 1 shows \(d_X=d_Z\) through a weight-preserving map \(\mathcal T\) with \(H_Z\mathcal T=\mathcal JH_X\) for an invertible \(\mathcal J\). The map carries one type of logical operator onto the other, so only one Pauli basis needs searching.

   Structure prunes the search. Each data qubit meets exactly one check per check block, because each block of \(H_X\) is a permutation matrix. Zero-syndrome candidates therefore decompose row by row, and the \(q\)-fold column symmetry reduces the starting configurations to 198 orbit representatives. Parity gives another cut. The all-ones vector lies in the stabilizer group, and any \(v\) commuting with it satisfies \(\mathbf 1\cdot v=|v|\equiv0\pmod2\). All logical weights are therefore even, consistent with the even distances in Table 1.

   Error rates are reported per logical qubit per cycle, \[p_L=1-(1-P_{\mathrm{fail}})^{1/(kN_c)},\] which converts the probability that a block of \(k\) logical qubits fails over \(N_c\) cycles into an equivalent independent rate. The fit \(p_L\propto p^{d/2}\) encodes the expectation that about \(d/2\) faults are needed to cause a logical error. A circuit distance below \(d\) (at most 11 for the \(d=12\) code) can lower the effective exponent. Counting the \(n/2\) check qubits, the physical cost is \((n+n/2)/k\approx3\) atoms per logical qubit, rather than the \(n/k\approx2\) that the rate alone suggests.

   How to reuse it

   Back any distance claim with both halves: an exclusion search for the lower bound and an explicit witness for the upper bound. Use symmetries (automorphisms, stabilizer parity) to cut the search. When comparing codes, state physical atoms per logical qubit including ancillas, the per-cycle error per logical qubit, and whether low-noise values were simulated or extrapolated. Exhaustive certification grows quickly with distance, and extrapolated rates depend on the noise model.

Source: Figure 1 and Table 1: construction, circuit scheduling, and distance certification. Based on the linked paper version. Derivations marked as editorial, and suggested uses in other problems, are editorial guidance rather than results of the paper.

Context & limitations

Why it matters. A candidate route to reducing the physical-qubit cost of fault tolerance.

Limitations. Idle errors are neglected, and logical gates and real-time decoding are left open. The smallest logical error rates are extrapolations from a fitted ansatz. This is not a hardware demonstration.

Description based on the full text of the linked arXiv version, read 2026-10-19; equations follow the paper’s notation.