Flag at origin: a modular fault-tolerant preparation for CSS codes

Abstract

Fault-tolerant (FT) preparation of diverse logical stabilizer states in quantum error-correcting (QEC) codes is essential for FT computation. Existing constructions of these FT circuits are often constrained by classical computational resources or result in unnecessarily large quantum circuits. This work introduces a modular construction for FT preparation circuits in CSS codes of arbitrary distance, yielding significantly more resource-efficient circuits than previous approaches, especially for the largest codes studied. The key insight is that in bipartite CX circuits used to prepare CSS states, $X$ errors propagate in one direction across the qubit partition, while $Z$ errors propagate in the opposite direction. By appending $X$-detecting flag gadgets to the first partition and $Z$-detecting flag gadgets to the second, the circuit becomes FT. To manage the associated overhead, we propose an algorithm that discovers optimal (or near-optimal) flag gadgets at any distance. These gadgets are reusable across different QEC codes and FT subroutines, such as flag-based QEC. We estimate the logical state preparation error using subset-sampling Monte Carlo simulations at the circuit level, combined with approximate maximum-likelihood look-up table decoding. On Quantinuum's H2-1 device, preparation of the $\lvert\bar{0}\rangle$ state in the [[23,1,7]] Golay code achieves a logical SPAM error rate of $3.3_{-2.4}^{+8.6} \times 10^{-4}$ with an acceptance rate of $47.23(86)\%$. This surpasses (within $95\%$ confidence intervals) the minimum SPAM error rate of $6.0(1.6) \times 10^{-4}$ for a physical $\lvert 0\rangle$, as well as the best previously demonstrated logical state preparations.

Figures (5)

• Figure 1: Flag-at-origin construction of a CSS state, i.e., a stabilizer state whose stabilizer generators are either a tensor product of Pauli-$X$ operators or a tensor product of Pauli-$Z$ operators. $(a)$ Such a state can be prepared non-fault-tolerantly by a bipartite CX circuit, where CX gates control only control qubits initialized in $\ket{+}$ and target only target qubits initialized in $\ket{0}$. The key observation is that Pauli-$X$ errors propagate only from control to target qubits, while Pauli-$Z$ errors propagate only from target to control qubits. $(b)$ An $X$-detecting flag gadget appended to a control qubit can detect any hook $X$ error occurring on it before it propagates. $(c)$ A $Z$-detecting flag gadget appended to a target qubit can detect any hook $Z$ error occurring on it before it propagates. $(d)$ Appending $X$-detecting flag gadgets to all control qubits and $Z$-detecting flag gadgets to all target qubits results in a fault-tolerant (FT) preparation circuit.
• Figure 2: Algorithm to discover flag gadgets. $(a)$ The inputs are the number $t = \lfloor d/2 \rfloor$ (equal to 2 in this figure), representing the number of correctable faults for a distance-$d$ code; the number of target qubits (5 in this figure); and the number of flags believed to be sufficient (2 in this figure). The algorithm constructs the gadget from right to left by iteratively adding new gates from a pool of available gates and testing for fault tolerance. $(b)$ The first attempted gate does not achieve fault tolerance because a single fault can propagate into two faults. $(c)$ Adding flag qubit $f_1$ makes the gadget FT (fault-tolerant) because no single fault propagates to an undetected error of weight greater than 1. $(d)$ Re-adding the first attempted gate now preserves fault tolerance because even two faults (including a faulty measurement) do not propagate to an undetected error of weight greater than 2. $(e)$ However, adding the next CX gate from $c$ to $t_2$ is not FT because two faults propagate to an undetected weight-3 error. $(f)$ The next CX in the pool controls $f_1$ instead. This is possible because at this point $f_1$ shares a GHZ-like entanglement with the control qubit, but this attempt is still not FT. $(g)$ Adding a new flag $f_2$ makes the gadget FT. $(h)$ After several successful steps, adding the last CX from $c$ to $t_4$ is not FT because two faults propagate undetected to a weight-3 error. $(i)$ Moving the control of the previous attempted gate to $f_2$ and disentangling $f_1$ makes the gadget FT despite two faults propagating to weight 4. This is because this error reduces to weight 2 up to the weight-6 stabilizer operator created by the circuit for the CSS code. $(j)$ The algorithm outputs the FT flag gadget.
• Figure 3: Numerical logical error rate (top) and discard rate (bottom) as a function of the physical error rate $p$ for various CSS codes. Dashed lines visually indicate the expected $\mathcal{O}(p^{t+1})$ scaling with the code distance $d$, where $t = \lfloor d/2 \rfloor$ is the number of correctable faults. The subplot below shows the post-discard rate of the [[20,2,6]] code during decoding, reflecting its even distance. Error bars indicate $95\%$ confidence intervals.
• Figure 4: Numerical logical error rate, with and without (indicated by NSt in the legend) a Steane-QEC gadget, as a function of the physical error rate $p$ for various CSS codes. Dashed lines indicate the expected $\mathcal{O}(p^{t+1})$ scaling with code distance $d$, where $t=\lfloor d/2 \rfloor$ is the number of non-problematic faults. Error bars represent $95\%$ confidence intervals.
• Figure 5: Numerical logical error rate versus physical error rate $p$ for a Steane-QEC gadget in which the resource state $\ket{\overline{0}}$ is prepared either with or without FT protection against $Z$ errors. The light dashed line shows the expected $\mathcal{O}(p^3)$ scaling for a distance-$d=5$ code, while the dark dashed line shows the $\mathcal{O}(p^2)$ scaling expected for an effective distance-$d=3$ code. Error bars indicate $95\%$ confidence intervals.