Quantum computing · Experiment
Magic state cultivation with lattice-surgery escape on superconducting hardware
arXiv:2611.22035v1 ↗PDF ↗Submitted 17 November 2026
- Question
- Magic state cultivation prepares the \(T\) states that fault-tolerant computers consume for non-Clifford gates, by projecting a noisy state in a small code and then letting it escape into a larger code that can be decoded in real time. The only previous experiment, on Google's Willow processor, grafted the state into a code that cannot be decoded by matching. Can the escape instead teleport the state directly into a surface code, and how does that compare with grafting on the same hardware?
- Result
- On a publicly available IBM Nighthawk processor, ibm_phoenix, Q-CTRL researchers cultivated a \(T\) state in the seven-qubit Steane code with a kickback-tomography logical error of \(2.0\times10^{-5}\) (6 errors in 300,462 retained shots) at 25% retainment, nearly ten times lower than on Willow at about three times the retainment. They then performed the first lattice-surgery escape into a distance-5 surface code, using 66 qubits. With complementary-gap postselection it keeps fidelity above 0.99 at up to 15.8% retainment just after escape and 0.991(2) at 4.6% retainment after ten stabilizer rounds, and reaches a logical error per round of about 0.14% at about 11% retainment. Grafting with a switch to a matchable code falls below 0.95 after ten rounds.
The paper in detail
Fault-tolerant computers perform Clifford gates cheaply in the surface code but need a supply of magic states, such as the \(T\) state, for the non-Clifford gates that make them universal. Magic-state factories dominate the resource estimates of many algorithms. Distillation purifies many noisy states through layers of logical gates; cultivation instead injects one noisy state into a small code, checks it by measuring a logical operator of which the target is an eigenstate, discards any shot that shows an error, and then moves the survivor into a larger code. The last step, the escape, has been the expensive one, and Google's 2025 experiment left its final switch to a matchable code unimplemented.
Here the state is cultivated in the \([[7,1,3]]\) Steane code, whose transversal Hadamard lets one check the eigenvalue of \(H_{\mathrm L}=H^{\otimes7}\) for the state \(\ket{T}=T_y\ket{0}\). The circuit uses a 23-gate encoder, superdense stabilizer extraction with Bell-paired ancillas, a double check and flags, so it rejects both injection errors and faults during the check; the accepted state has error of order \(p^3\). To preserve that suppression the escape code needs distance at least 5. Lattice surgery prepares a distance-5 rotated surface code in \(\ket{+_{\mathrm L}}\) next to the Steane patch, measures \(Z_{\mathrm L}Z_{\mathrm L}\) through three merging stabilizers repeated for three rounds, and then reads out the Steane qubits destructively in the \(X\) basis, which teleports the state into the surface code. Grafting instead grows the Steane code in place into a 26-qubit code with weight-six stabilizers; the authors add a switch, dropping three stabilizers and adding three two-body ones, to make it matchable.
The cultivated state alone reached a kickback-tomography error of \(2.0\times10^{-5}\) at the \(T\) angle and \(3.2(3)\times10^{-5}\) averaged over eleven injection angles, 41 times below injection without cultivation. All three escapes then ran in one batch, with 500,000 shots per tomography basis for each number of rounds from 2 to 10. Immediately after escape, plain grafting has the best fidelity at a given retainment, because its single extension cycle is shallower and postselects on fewer detectors, but it ends in a code that needs Tesseract. In memory, lattice surgery wins: its logical error per round reaches about 0.14% with postselection while grafting levels off near 0.22%, and at ten rounds only lattice surgery stays above 0.99, peaking at 0.994(3) at 3.8% retainment against 0.986(5) at 1.2% for grafting.
The comparison carries a general lesson for code deformation: the switched grafting ends in a matchable code yet stays the worst at every round count, because errors from its non-matchable intermediate cycles have already accumulated and those cycles still need the slow decoder. The next steps are an escape into a larger surface code, which needs a bigger device, real-time decoding with feed-forward so that the state can actually be consumed in a \(T\) gate, and better noise models, since calibrated Pauli simulations reproduce the ranking of the protocols but underestimate their absolute error rates.
Transferable methods
Cultivation by a postselected transversal Hadamard check
A magic state is the eigenstate of a Clifford operator, so checking that eigenvalue and discarding the wrong outcome removes injection errors. In a self-dual code such as Steane's, the logical Hadamard is transversal and the check is cheap; adding flags and a double check makes the check itself fault tolerant, so the surviving state's error falls as a higher power of the physical error rate.
The Steane code's \(X\) and \(Z\) stabilizers share the supports \(g_u=\{0,2,4,6\}\), \(g_v=\{1,2,5,6\}\) and \(g_w=\{0,1,3,6\}\), all overlapping evenly, and its logical operators act on all seven qubits. A computational input \(\ket{a}\) is encoded as \[\ket{a_{\mathrm L}}=2^{-3/2}\sum_{s\in S}\ket{a\ell\oplus s},\] with \(S\) the span of the supports and \(\ell=1111111\). Because the code is self-dual, \(H^{\otimes7}\) exchanges the \(X\) and \(Z\) stabilizers and acts as the logical Hadamard.
The target is \(\ket{T}=T_y\ket{0}\) with \(T_y=e^{-i\pi Y/8}\), the \(+1\) eigenstate of \(H=(X+Z)/\sqrt2\). Since \(T_y^\dagger XT_y=H\) on each qubit, \[\frac{I+H_{\mathrm L}}{2}=T_y^{\dagger\otimes7}\,\frac{I+X^{\otimes7}}{2}\,T_y^{\otimes7},\] so the logical Hadamard check becomes a non-destructive \(X^{\otimes7}\) measurement between layers of single-qubit rotations, implemented by folding the parity onto an ancilla root.
With fault distance three, a logical error needs three faults, so the postselected error is \(O(p^3)\); decoding a distance-\(d\) code leaves \(O(p^{\lceil d/2\rceil})\) per round, which is why the escape code needs \(d\ge5\). The fidelity with \(\ket{T}\) follows from the logical Pauli expectations, \[F=\tfrac12\Bigl[1+\tfrac{1}{\sqrt2}\bigl(\langle X_{\mathrm L}\rangle+\langle Z_{\mathrm L}\rangle\bigr)\Bigr],\] since the Bloch vector of \(\ket{T}\) is \((1/\sqrt2,0,1/\sqrt2)\). Editorial check: the stabilizer, projector and fidelity identities were verified numerically.
How to reuse it
Any state that is the eigenstate of a transversal Clifford in some small code can be cultivated the same way, so the choice of seed code is set by which magic state is needed. The fault-distance bookkeeping, error order from the number of undetected faults and escape distance from the decoding order, carries over directly.
Escape by lattice-surgery teleportation into a matchable code
Instead of deforming the small code into a large one, which passes through codes that matching cannot decode, lattice surgery measures a joint logical parity between the small code and a fresh surface-code patch and then measures out the small code. This is one-bit teleportation at the logical level, and it ends in a code that matching decodes quickly.
Editorial derivation: with the source in \(\alpha\ket{0}+\beta\ket{1}\) and the target in \(\ket{+}\), a \(Z\otimes Z\) measurement with outcome \((-1)^m\) leaves \(\alpha\ket{0,m}+\beta\ket{1,m\oplus1}\). An \(X\) measurement of the source with outcome \((-1)^s\) leaves the target in \[Z^{s}X^{m}\bigl(\alpha\ket0+\beta\ket1\bigr),\] so the corrections are Pauli and can be tracked in software, as the experiment does.
The logical \(Z_{\mathrm L}Z_{\mathrm L}\) is the product of three merging stabilizers, \(Z_{1a}\), \(Z_{35bc}\) and \(Z_{de}\), joining Steane data 1, 3 and 5 to the surface code's boundary qubits. One measurement error would flip that product undetected, so it is repeated over three rounds while both codes keep measuring the stabilizers that commute with it. The destructive \(X\) readout also rebuilds the Steane \(X\) stabilizers, so it checks itself. An exhaustive search over all single faults and pairs of faults confirms that the minimal set of Steane checks kept during the merge preserves fault distance three.
Matching requires that every single error flip at most two detectors. The grafted code fails this, because a qubit in the relocated corner lies in three stabilizers of one type. Its logical operators are Steane logicals times stabilizers of the fresh qubits, for example \[X'_{\mathrm L}=X_{0,9,19}\,X_{3,9,17,19}\,X_{7,25}=X_{0,3,7,17,25},\] and the switch replaces three plaquettes by two-body \(Z\) checks whose products recover the dropped ones. Editorial check: the products in Eq. (1) were recomputed.
How to reuse it
When moving encoded information between codes, compare routes by the decoder each intermediate code requires, not only by the final code. Teleporting through a joint logical measurement keeps every stage inside codes the production decoder already handles.
Context & limitations
Why it matters. Lattice surgery ends the protocol in an ordinary surface code, so the state can be decoded by matching, which here ran more than three orders of magnitude faster than the Tesseract decoder that grafting requires. This is the highest reported fidelity for a magic state in a surface code, and the head-to-head comparison shows that a code deformation must be judged along its whole path: grafting with a switch ends in a matchable code but pays for the intermediate non-matchable cycles.
Limitations. High fidelities come with heavy postselection, from 25% retainment in cultivation to a few percent after ten rounds. Kickback tomography bounds the cultivated infidelity using further postselected projections. Fault distances were established on a Clifford proxy with an \(S\) state, which may overestimate the fault distance of the true circuit. The demonstration stops at distance 5, not the distance-11 target of the full protocol, decoding was offline without feed-forward, and calibrated-noise simulations underestimate the measured error rates, pointing to unmodelled leakage, crosstalk or coherent errors. The authors attribute much of the improvement over Willow to newer hardware, and the two escape protocols ran on different qubits with unequal error rates. The paper contains no statement about AI use.