Better Logical Qubits, the Cost of Magic States, and Leaner Circuits

Quantinuum reports lower logical errors in color-code memories and Clifford circuits. A study of magic-state cultivation revises the cost of supplying non-Clifford resources. An LLM-guided search finds cheaper reversible circuits.

0. Takeaways

Quantinuum's Helios processor reaches a logical memory error rate of per correction round using a distance-7 color code. A separate distance-5 experiment reaches errors per logical two-qubit Clifford. Both results show improving protection as code distance increases.[1]

Magic state cultivation can require more quantum resources than earlier estimates assumed. In the surface-code protocol studied by Mehta et al., preserving the output state requires a larger code distance and more correction rounds during the escape stage to recover the target quality.[2]

Gu et al. combine LLM proposals with an independent evaluator to redesign reversible quantum circuits. Seven benchmark tasks reduce both Toffoli and qubit counts, with the comparison baseline specified for each task. A new reversible divsteps construction also supplies a different space-versus-gate-count choice for elliptic-curve point addition.[3]

1. Introduction

A quantum error-correction experiment can preserve a logical state more reliably while a useful algorithm remains too expensive to execute. The algorithm needs enough logical qubits, a long sequence of reliable gates, and the resources that supply those gates. Progress in any one of these quantities changes the requirements on the others.

Our July newsletter, RL-Driven Quantum Error Correction and the ECC Resource Frontier, followed improved control of Google's Willow processor and smaller logical circuits for elliptic-curve cryptanalysis. This issue follows progress in logical memory and Clifford operations, examines the cost of supplying non-Clifford resources, then considers how circuit design can reduce an algorithm's resource demand.

Quantinuum reports color-code experiments on Helios, testing whether increasing code distance improves both logical memory and encoded Clifford operations.[1] Harvard and MIT researchers examine the cost of magic-state cultivation when its output must remain available for computation.[2] The researchers from Harvard, QuEra and Anthropic study how LLM-guided search can reduce the logical resources needed by reversible circuits.[3] Their search changes how those circuits perform arithmetic and retain intermediate information.

Quantinuum measures logical error rates for memory qubits and Clifford operations on hardware. Mehta et al. estimate the cost of the non-Clifford resource states needed to complete a universal gate set. Gu et al. then ask how better circuit designs can reduce the logical gates and qubits an algorithm requires. The studies connect experimental reliability, the supply cost of non-Clifford operations and the resources demanded by an algorithm.

2. Quantinuum pushes color codes further below threshold

Larger color codes reduce logical memory errors

Quantum error correction encodes a logical qubit across several physical qubits. Auxiliary qubits measure stabilizers, producing a syndrome that gives information about errors without directly reading the protected logical state. A decoder uses that record to infer a correction. Increasing the code distance gives the code more protection, while also adding physical operations that can fail. Below threshold, the additional protection wins and the logical error rate falls.

Quantinuum implements triangular color codes at distances 3, 5 and 7 on Helios-1.[1] This code family has parameters

Here is the number of data qubits, is the number of encoded logical qubits, and is the code distance. The three codes therefore use 7, 19 and 37 data qubits. Including syndrome ancillas, one memory block occupies 13, 37 or 73 physical qubits. Color codes support transversal Clifford operations: a logical operation acts across corresponding physical qubits without spreading one fault arbitrarily within a code block. Helios's all-to-all connectivity supports these interactions and the syndrome-extraction schedule.

Each memory shot begins with one of six logical Pauli eigenstates, runs 20 rounds of syndrome extraction and ends with a logical measurement. Table 1 gives the results decoded with the Tesseract decoder.

Table 1. Color-code memory results with Tesseract decoding. Intervals are the reported one-sigma, approximately 68%, Wilson confidence intervals.[1]

The small per-round error rate is estimated by repeating the 20-round memory circuit over many shots. If of shots end in a logical failure, the authors estimate the per-round rate as , where and the half-round correction accounts for state preparation. At distance 7, three failures in 29,000 shots give per round. This estimate pools many short runs; it does not require operating a single memory for a million consecutive correction rounds.

The measured memory error decreases as code distance grows. The distance-7 block uses 37 data qubits and 73 physical qubits including ancillas.[1]

A fit across the three distances gives a suppression factor for each increase of two in code distance.[1] This fitted trend is the evidence for operation well below threshold. The limited distance-7 failure count still leaves considerable uncertainty in the lowest measured error rate.

Leakage removal makes repeated correction effective

The physical qubits are encoded in two levels of a ion. An error can move population into nearby levels outside this computational space. Such leakage can persist across rounds, interfere with later gates and spread errors to other qubits. A syndrome decoder cannot compensate indefinitely for a physical carrier that remains outside the intended qubit states.

The experiment addresses leakage at two levels. A hardware repump sequence transfers leaked population back into the computational space. Three repump cycles suppress the leakage population by .[1] At this operating point the repump overlaps cooling and transport, so it adds no circuit time. Returning population to the qubit space still leaves an error for ordinary QEC to handle.

The circuit also rotates which physical ions carry data. Fresh ancillas take over the data role, while previous data carriers move into positions that undergo measurement and reset. Three alternating syndrome-extraction schedules refresh every data position. Some SWAP operations can be implemented through software relabeling on Helios; the subsequent reset is what clears persistent leakage.

The energy-level diagram shows the repump transitions in . Circuit-level role exchange gives data carriers access to reset, and hardware repumping further reduces the logical error on top of this schedule.[1]

The results distinguish these contributions. With circuit-level leakage reduction already in place, adding hardware repump improves the logical error rate by approximately fourfold at distance 3 and eightfold at distance 5.[1] The two mechanisms address leakage before it can accumulate over repeated correction rounds.

Encoded Clifford operations improve too

A logical memory tests preservation. Computation also requires operations between encoded states. Quantinuum therefore runs randomized benchmarking on two logical qubits, each encoded in a distance-3 or distance-5 color-code block.[1] Random two-qubit Clifford sequences are followed by their inverse and a final measurement. The sequences contain 69, 139 or 209 Cliffords, with one syndrome-extraction round inserted after each group of seven gates. The fitted error rates in Table 2 show improving protection as code distance increases, consistent with the memory experiment.

Table 2. Errors per two-qubit Clifford from randomized benchmarking. Values retain the authors' reported one-sigma uncertainties; the underlying measured failure probabilities also carry error bars.[1]

Two distance-7 blocks exceed the available capacity, so the logical-gate experiment stops at distance 5.[1]

Classical decoding remains part of the implementation problem. Convolutional and transformer decoders trained on simulated Helios data also show improving memory performance with code distance. At distance 7 their average GPU processing times are approximately 0.52 ms and 0.35 ms per syndrome round on an NVIDIA H100.[1] All decoding in this experiment was performed offline. These timing measurements support future integration, while communication, controller overhead and measurement-conditioned operations still need to work in a live feedback loop.

The memory and Clifford experiments establish two components of a logical processor. Universal computation also needs non-Clifford operations, commonly supplied by preparing and consuming magic states. Their quality and preparation cost determine what it takes to extend this hardware progress to a universal gate set.

3. What a usable magic state costs

Supplying non-Clifford operations

Clifford operations alone do not provide universal quantum computation. One way to implement a non-Clifford gate is to prepare a special ancillary state, then consume it through a measurement-and-feedback circuit. An algorithm with many such operations needs a continuing supply of sufficiently accurate magic states.

Cultivation starts with a noisy resource state in a small code. Checks and postselection reject attempts with detected errors; the retained state then enters an escape stage that grows its protection.[2] Rejected attempts consume resources too. For identical complete attempts, expected cost per accepted state would be the attempt's spacetime volume divided by its acceptance probability. A multistage protocol must account for where rejected attempts stop, as well as the resources used by successful ones.

Google's experiment on Willow demonstrates cultivation and a method called kickback tomography for bounding the resulting state's fidelity.[4] The authors report a fidelity lower bound of approximately 0.9999(1), with about a 40-fold error reduction relative to injection alone. They also demonstrate transferring a cultivated state from a distance-3 color code into a distance-5 surface code.

The reported 8% retention belongs to a tomography benchmark that filters detection events across the complete preparation-and-measurement circuit.[4] It is a useful experimental statistic, but the retained shots have supplied information through measurements that need not be available when delivering an unmeasured state. Mehta et al. examine that information difference in cultivation resource estimates.[2]

The acceptance decision cannot use future readout

At the end of a benchmark, the output code block can be measured to determine the logical result and obtain further syndrome information. A resource estimate may use that record to judge which attempts should have been accepted. The simulation convention examined by Mehta et al. supplies terminal information equivalent to an ideal QEC round.[2]

During computation, the factory must decide whether to accept a state while preserving it for a later gate. That decision can use the stabilizer measurements already performed, but it cannot use a destructive output readout that has yet to occur. The authors call these two information conditions a closed and an open temporal boundary.

An open boundary still permits stabilizer measurements and ongoing error correction. It restricts which information can enter the acceptance decision while the output remains available.[2]

The missing terminal record changes how confidently a decoder can distinguish a safe attempt from a risky one. In a benchmark, some failures can be rejected using that extra record. Preserving the output removes this option. The factory may need stronger inference, stricter postselection or more quantum resources to achieve the same conditional error rate.

Better inference reduces the postselection penalty

Mehta et al. introduce Caliper, a method that estimates the logical failure risk from the syndrome available at decision time.[2] It searches over possible hidden terminal syndromes and weighs their likelihood and logical consequences. It then accepts attempts that meet the selected confidence threshold.

The study simulates cultivation as a tractable proxy for cultivation, with SD6 circuit-level depolarizing noise at .

Moving right rejects a larger fraction of escape attempts. Acceptance is one minus the plotted discard rate. Caliper improves the use of available syndrome information, but the remaining gap depends on the protocol and target error.[2]

For the color-code protocol with cultivation fault distance , Caliper reaches a logical error target at an expected spacetime cost only about 10% above the closed-boundary estimate.[2] Requiring changes the result: escape acceptance falls to 6.4%, compared with 23.7% under closed-boundary postselection. The expected cost is then about 3.7 times larger. These are escape-stage acceptance fractions, rather than the success probability of the entire factory.

The surface-code protocols are more constrained at their original escape settings. For , even full error detection on the visible syndrome leaves an error rate around , above the target. For , the studied open-boundary configuration remains around even when it accepts only a few percent of attempts.[2] Better inference helps, but the available information can still be insufficient at a fixed quantum resource budget.

More escape space and time can recover quality

The compared cultivation protocols initially use different escape resources. The surface-code protocol grows to distance 7 and uses three rounds before the acceptance decision. The corresponding color-code protocol uses a distance-15 grafted code and nine rounds, supplying a much larger syndrome record.[2] This motivates varying the escape code distance and duration together.

The heatmaps hold escape acceptance at 68%. The separate cost-optimized working point discussed below uses 50% acceptance, so it should not be read directly from this fixed-acceptance slice.[2]

Increasing only the number of rounds gives limited improvement. In the configurations the authors examine, recovering the target at minimum expected cost requires increasing the escape code to and the duration to , with 50% escape acceptance.[2] The expected spacetime volume of the whole protocol rises by roughly fivefold relative to the earlier estimate. Larger protection and longer observation both contribute to that cost.

Table 3. Selected resource changes under open-boundary postselection. Each ratio compares with the corresponding closed-boundary estimate, under the study's proxy-state and noise assumptions.[2]

Classical processing also occupies time during which the output needs continued protection. A slower acceptance decision can therefore add quantum spacetime cost, particularly on hardware with short correction cycles. The useful factory specification must connect output quality, acceptance, occupied qubits and decision latency. Mehta's study shows why the escape stage deserves the same scrutiny as cultivation itself.

These costs attach a physical resource budget to each non-Clifford operation. Reducing the number of costly operations in an algorithm can lower the total demand. Gu et al. address that part of the problem by redesigning reversible circuits.[3]

4. LLMs redesign reversible circuits

Reversibility changes the optimization problem

Many quantum algorithms repeatedly evaluate classical functions on quantum registers. Arithmetic, numerical functions and table lookups must work coherently when the inputs are in superposition. A program cannot inspect a quantum input and choose an ordinary classical branch. It implements the alternatives through controlled operations, and temporary information must eventually be removed without disturbing the output.

A small example makes the cost visible. Suppose inputs must remain unchanged while an output bit becomes . One construction computes into a clean ancilla , copies it into with a CNOT, then reverses the first computation to reset . It uses two Toffolis and four qubits. A direct Toffoli controlled by and targeting performs the same task using one Toffoli and three qubits. For the first construction, clearing matters because leaving it correlated with the data would generally disturb a superposition if it were discarded.

This teaching example illustrates why the algorithm and its cleanup must be designed together. Gu et al. apply that idea to much larger circuits, where changing the arithmetic representation or recovering intermediate information can save far more than local gate cancellation.[3]

An independent evaluator guides the search

The framework asks an LLM to write high-level Python programs that generate circuits. An independent evaluator tests the resulting operation stream, checks its functional behavior and counts its resources.[3] The search first proposes distinct algorithm families, then improves candidates within those families and shares successful ideas between them.

The evaluator checks the output, preservation of inputs, cleanup of ancillas and unwanted relative phase. Its principal resource objective is

where is the Toffoli count and is peak logical-qubit use. The paper calls this product the TQ cost; its denotes Toffolis, rather than the number of gates. Retaining candidates with different space and gate costs allows the search to explore more than one working point.

The evaluator supplies feedback to searches within several algorithm families. The diagram summarizes the discovery process; it does not imply that sampled testing proves correctness for every possible input.[3]

Efficient evaluation depends on the chosen circuit class. For a computational-basis input, the allowed operations can be tracked using a bit string and its phase, with measurement-based cleanup handled explicitly. This avoids storing a general state vector with exponentially many amplitudes. Correct action on every basis input, with the required phases and cleanup, would establish coherent action by linearity. Large input domains are tested by sampling, however, and some tasks allow a specified failure probability. The evaluator's guarantee therefore depends on the task specification and the tests used.

Share expensive arithmetic and recover branch history

One recurring design uses conditional routing to share an expensive arithmetic unit. Suppose a control bit selects either or . A direct construction contains two controlled multiply-add units. Routing instead conditionally swaps and , performs one multiply-add and swaps them back.[3]

For , , and , the two branches produce and , while restoring and . In a quantum circuit the control may itself be in superposition, so the swaps preserve coherent control. The saving comes from sharing the costly arithmetic unit.

A second design principle recovers branch history from the current arithmetic state. Reversible programs often store a bit for each decision so that they can undo the computation later. Some decisions are already encoded in the retained state and can be reconstructed when needed.[3]

For example, consider under the invariant . Bit of the updated register reveals . At , starting from gives either or . The high bit identifies whether four was added, allowing the inverse update to recover three. The invariant excludes an ambiguous predecessor. A quantum implementation extracts this information coherently, without measuring the branch.

Two principles illustrated by the paper's circuit diagrams. The numerical examples explain the controls and the invariant; they are not additional benchmark results.[3]

Several tasks improve both resources

The authors evaluate eight tasks. In seven, the selected circuits reduce both Toffolis and qubits relative to the stated baselines. Table 4 lists those seven comparisons. The eighth task, prime-field modular inversion, is evaluated through a point-addition benchmark and has a more complicated resource trade-off.[3]

Table 4. Seven circuit-design benchmarks. Resource pairs are . Values are rounded as in the paper; product improvements follow its reported figures.[3]

For Reed-Solomon decoding, the search changes the algorithm family from a synchronized Euclidean construction to Berlekamp-Massey and redesigns its reversible implementation. The full task falls from about 5.1 million to 440,000 Toffolis. HHL rotation-angle evaluation and the fixed-point Gaussian task also lower both resources, producing reported product improvements of 32× and 39×.[3]

The Hermitian comparison uses the authors' naive reversible baseline because an equivalent complete reversible compilation was unavailable in the prior literature. Its large reduction should be read with that baseline attached.

Divsteps moves the point-addition trade-off

Modular inversion finds an integer such that , for coprime to . This is the modular inverse of . For example, , so . Elliptic-curve point addition uses this operation to evaluate a slope in a finite field, making inversion an important part of its resource cost.

Divsteps replaces expensive division with conditional additions, subtractions and halving. Making the integer computation reversible is difficult because the successive branch choices must be undone. Gu et al. recover readily decodable decisions from arithmetic state and store only the harder cases.[3] Their construction uses a bounded history stack and a bounded stopping schedule. The selected parameters carry explicit probabilities of stack overflow and incomplete convergence, which belong in the accuracy budget.

The paper compares four constructions with the same affine-coordinate point-addition interface, including reversible cleanup. Its new divsteps point uses 935 logical qubits and Toffolis. Schrottenloher's construction uses 1,446 qubits and Toffolis in that comparison.[3,5] Divsteps saves about 35% of the qubits while using roughly twice the Toffolis. Its TQ product is therefore higher at these selected points.

The paper's common-interface comparison includes cleanup and excludes application-specific storage or lookup for the classical addend. The 935-qubit, four-million-Toffoli result is for point addition, not a bare inversion or the complete Shor algorithm.[3]

The same table includes Luo's packed Euclidean construction at 838 qubits and Toffolis, and a specialized Euclidean construction at 843 qubits and Toffolis.[3,6] The latter exchanges five additional qubits for a substantial gate reduction. These alternatives show how algorithm design changes the cost even within a similar space budget.

The public ECDSA.Fail challenge provides a separate, changing comparison. At our check on 27 October 2026, its best product score was 915,170,186, using 1,234 qubits and a rounded average of 741,629 executed Toffolis.[7] The submission reports approximations and a selected test packet; its failure guarantees require separate assessment before comparison at a common accuracy target. We therefore keep it outside the paper's four-point plot. None of these logical counts includes error correction, factories or the full algorithm schedule.

5. Conclusion

Quantinuum's experiments show improving color-code performance in both memory and Clifford operations.[1] Extending these results to sustained universal computation requires reliable non-Clifford operations and integrated feedback.

Mehta et al. examine the resource states that supply those non-Clifford operations.[2] Their cost depends on the information available when the factory makes its acceptance decision. Some targets remain close to earlier estimates; others require larger escape codes and longer correction sequences.

Gu et al. reduce the workload that the processor and its resource-state factories must support through changes to reversible algorithms, data routing and cleanup.[3] The divsteps example keeps the choice of objective visible: a smaller logical circuit width can come with more Toffolis and a higher product cost. Together with measured logical reliability and magic-state production costs, these circuit counts provide inputs to an architecture-specific resource estimate.

6. References

1. Lavasani, A. et al. "Quantum error correction well below the color code threshold." arXiv:2610.24077v1 (2026). Paper. Memory statistics: Table I; Clifford results: main text and Fig.5.
2. Mehta, R., Menon, V., Zhou, H., Lukin, M. D. and Bonilla Ataides, J. P. "The practical cost of magic state cultivation." arXiv:2610.06828v1 (2026). Paper.
3. Gu, A., Kemeny, A. H., Yelin, S. F. and Lukin, M. D. "Discovering state-of-the-art quantum circuits with large language models." arXiv:2610.22367v1 (2026). Paper. Benchmark summary: Table I; point-addition comparison: Supplementary Table S3.
4. Rosenfeld, E. et al. "Magic state cultivation on a superconducting quantum processor." Science. Experimental numbers and protocol details follow the author preprint, arXiv:2512.13908v1, Sections II and III.
5. Schrottenloher, A. "Optimized Point Addition Circuits for Elliptic Curve Discrete Logarithms." arXiv:2606.02235 (2026). Paper. Comparison values follow the common interface in Gu et al., Table S3.
6. Luo, H. et al. "Quantum Algorithm for Elliptic Curve Discrete Logarithms with Space-Efficient Point Addition." arXiv:2607.13816 (2026). Paper. Comparison values follow Gu et al., Table S3.
7. ECDSA.Fail, public point-addition challenge. Leaderboard, scoring and validity rules, submission commit 2120d8a. Snapshot checked on 27 October 2026 at approximately 13:16 China Standard Time. The displayed score uses 741,629 rounded Toffolis; the submission reports an average of 741,628.646 on its submitted test packet.