Magic state cultivation: growing a quantum computer's expensive operations cheaply

Why it was needed: the magic state bottleneck

This article covers a core technology of quantum computing, not AI. The qubits in a quantum computer lose their state under even very small amounts of noise. So a practical quantum computer has to group several physical qubits into one 'logical qubit' and run on top of a quantum error-correcting code that finds and fixes errors when they occur. This approach is called fault-tolerant quantum computing (FTQC). The surface code, which lays qubits out like a checkerboard, and the color code are representative examples.

The problem is the type of operation. Among quantum operations, a class called Clifford operations can be performed relatively cheaply on error-correcting codes. But Clifford operations alone cannot express every computation. To have a universal gate set capable of any computation, non-Clifford operations such as the T gate are essential. The superconducting processor experiment paper paper points out that in most error-correction architectures, these operations account for a large share of the resource cost.

So a workaround called the 'magic state' is used. Instead of performing a non-Clifford operation directly, a special quantum state that carries the effect of that operation is prepared in advance. This state is then consumed using only Clifford operations to implement the T gate. The key question then becomes how cleanly and cheaply magic states can be made. Traditional magic state distillation combines several low-quality magic states to extract one cleaner state. The lattice surgery-based cultivation study paper notes that this process is a major bottleneck in fault-tolerant quantum computation.

Cultivation was developed to reduce this cost. The gauging-based cultivation study paper summarizes cultivation's results as follows: at code distance 5 (d=5) in the color code, it reaches a logical error rate of around 10^-9 while its spacetime cost (the number of qubits needed multiplied by the time taken) is far lower than that of distillation.

Core idea: grow in a small pot, then transplant

Cultivation means exactly what it says. You grow seedlings in small pots, check on them often, and if one shows signs of wilting, you discard it without hesitation and plant a new one. Only the sturdy seedlings that survive to the end are moved to the open field. Small pots are cheap, so discarding many is not a big burden, and only verified seedlings go into the field.

The lattice surgery-based cultivation study paper divides distillation into two branches. One is the traditional 'logical-level' approach, which combines several logical qubits. The other is the 'physical-level' approach, which implements the process directly with physical gates and greatly reduces cost. The study presents cultivation as the latest physical-level approach. It can be used even on a square-grid layout where each qubit connects only to its neighbors above, below, left and right, and it produces high-fidelity magic states.

The key is 'filtering out' rather than 'fixing'. Instead of finding and correcting errors, any attempt that shows even a slightly abnormal signal during a check is discarded entirely. This is called postselection. In the superconducting processor experiment paper, only 8% of attempts were kept. This is not a failure but part of the design. Discarding a lot is the price paid for raising the quality of the states that remain.

How it works: prepare, check, grow, escape

The detailed construction differs from study to study, so here we cover only the common skeleton. First, a magic state of still-rough quality is prepared inside a small color code (around code distance 3, d=3). Code distance (d) indicates how many errors a code can tolerate. A larger value is more robust but requires more qubits.

Next comes the check. According to the gauging study paper, cultivation measures the transversal Clifford operators of the color code. A transversal operation applies the same operation to every physical qubit at once. If the state is the desired magic state, this measurement must return a fixed value, so if a different value comes out, the state is assumed to contain an error and is discarded. The √T cultivation study paper calls this kind of check a 'phase kickback check' and generalizes it to other states. Quality is raised by repeating the check, growing the code to a larger distance, and checking again.

The last step is escape. The state grown in the small code is moved into the large surface code where the actual computation takes place. The originally proposed method uses a complex structure called a 'grafted code' for this step. The lattice surgery-based study paper points out that the grafted code brings large spacetime costs and makes implementation difficult. The experiment paper performed code-switching to the surface code. The √T study paper escaped using lattice surgery, which performs operations by merging and splitting the boundaries of code patches. According to the Caliper study paper, postselection also takes place during the escape step. Only states that pass every gate move on to the computation and are consumed by T gates; if an attempt is rejected along the way, it starts over from the beginning.

Progress: from experimental validation to practical costs

The question 'does it actually work?' was answered by an experiment on a superconducting quantum processor paper. The assumptions of the proposal differ in nature from memory experiments, which preserve qubit states for a long time, so they had been hard to test. The authors implemented cultivation including code-switching to the surface code. They also separately developed a fault-tolerant measurement method that bounds the fidelity (how closely the state matches the desired state) of the magic states produced. As a result, they reduced errors 40-fold and achieved a fidelity of 0.9999(1), with 8% of attempts kept.

Research to make the protocol cheaper and larger followed. The lattice surgery-based study paper removed the grafted code to reduce spatial cost. It also lowered average cost through code expansion and early rejection. With color code distance 3 and a physical error probability of 10^-3, it achieved a logical error probability of about 3×10^-6, similar to the original cultivation, while cutting spacetime cost roughly in half. The gauging study paper pointed to a different limit: the depth of the check circuits grows in proportion to code distance, making d>5 impractical. This study used gauging to build measurement circuits of constant depth. In exchange, it repeats postselection instead of error correction, gaining simplicity while giving up some scalability. The d=7 version reached a logical error rate of around 10^-12 at a physical error rate of 0.05%, and kept more than 1% of attempts even past the point corresponding to the cultivation stage. The √T study paper noted that research so far had focused on T states and extended the checking method to magic states higher in the hierarchy.

Simulation is another important branch. Clifford circuits can be simulated efficiently on ordinary computers, but once non-Clifford operations are mixed in, simulation becomes sharply harder. The ZX decomposition simulation study paper expressed the d=5 cultivation circuit as a sum of about 8 Clifford ZX diagrams (a notation for computing quantum circuits graphically) on average. The decomposition method used for comparison required 6,377,292 terms, so this is a reduction of more than 700,000-fold. The d=3 circuit was simulated at about 4 million shots per second on a laptop. That is only about 1.1 times slower than a Clifford proxy simulation that substitutes S gates.

Recently, studies examining practical costs have appeared. The Caliper study paper challenged the assumptions behind existing cost estimates. Existing estimates assumed that the output state could be measured noiselessly for postselection during the escape step, but such a measurement destroys the magic state and so cannot be done during actual computation. This study developed a postselection method that uses only mid-circuit measurement information that does not damage the state. The runtime study MagiCFirm paper focused on the lack of an open runtime layer connecting logical software and physical control. It also identified the latency of deciding whether a magic state is ready as a problem. The study co-designed a method that runs decoding (interpreting error signals) partially in advance to release high-confidence attempts early, together with a dedicated hardware path. At the same logical error rate, it reduced preparation time by up to 39.3%, and it estimated that total execution time for representative workloads would fall by about 11%.

Where things are heading

The focus of recent research is shifting from 'does it work?' to 'exactly how well, and how inside real machines?' The fault distance study paper explained recent benchmark results showing that the logical error rate of T-state cultivation is considerably higher than that of S-state cultivation. The reason is that after the final double-checking circuit, 'hook errors' spread into Clifford-type errors. As a result, the fault distance (how many errors must coincide before an undetected failure occurs) drops to 2 at d=3 and 3 at d=5. The study designed flag qubits to catch these errors, lowering the pre-escape logical error rate from Θ(p^3) to Θ(p^5). At a physical error rate of 10^-3, this is a 4.9-fold improvement, while the number of attempts needed per pass increases 1.36-fold.

On the simulation side, magna paper has appeared. Its goal is to simulate magic state factories such as distillation, cultivation and code-switching as cheaply as Clifford circuits. The tool represents the acceptance rate and the fidelity of accepted states as tensor networks, and contracts them all at once by exploiting a structural correspondence with the transversal gates of quantum codes. It also supports feedforward, where the next action changes depending on the decoder output. The authors report that its sampling time for d=5 cultivation is the fastest to date for both the color code and the RP² surface code.

Compilers have also started to account for cultivation. FlowRouter paper points out that existing lattice surgery compilers assumed magic states were always available for free. This compiler runs cultivation on every idle code patch and absorbs the irregularity caused by multi-stage postselection with delay buffers. Even under the assumption of free magic states, it reduced spacetime volume 2.3-fold compared with the best existing static compiler and compiled 10.8 times faster. In short, cultivation is changing from a standalone technique into a system component handled jointly by simulators, runtimes and compilers.

Limitations and open issues

First, supply is probabilistic. In the experiment paper, only 8% of attempts were kept, and the d=7 version from the gauging study paper keeps only a little over 1%. Since there is no fixed time when a magic state will be produced, the whole computation can end up waiting on that supply. FlowRouter's paper delay buffers and MagiCFirm's paper fast decision path address exactly this problem.

Second, the assumptions behind cost estimates are shaky. The Caliper study paper found that postselecting with only the mid-circuit measurements that are actually available gives results that vary case by case. Under some conditions it recovers the efficiency of existing estimates, but at the cost levels reported in prior studies, the logical error rate can be several orders of magnitude higher. Recovering the reported error rates required much larger codes and a longer escape step. This is why figures in papers should not be read directly as the performance of real machines.

Third, there is the problem of proxy metrics in simulation. Because T-state circuits are hard to simulate, Clifford circuits with S gates substituted have been used as proxies, as mentioned in the ZX decomposition simulation study paper. But as the fault distance study paper showed, T states can have a lower fault distance than S states. Looking only at the proxy leads to an optimistic view of performance. This is also why exact simulators keep appearing.

Fourth, there are issues of scale and generalization. The original method is hard to scale beyond d>5 because of check-circuit depth paper. Approaches that avoid this also give up some scalability in exchange for simplicity. The experimental results were obtained on a specific superconducting device, so there is not yet evidence that the same performance will hold on other hardware or in large computations.

Further study

If you are new to the topic, start with the abstract of the superconducting processor experiment paper. It shows at a glance what the authors set out to prove and what figures they obtained. Next, reading the lattice surgery-based cultivation study paper helps organize key concepts such as cultivation's position as physical-level distillation, the burden of the grafted code, and early rejection. The gauging study paper shows clearly why check-circuit depth becomes a barrier to scale.

If you want to understand the open issues, read the Caliper study paper and the fault distance study paper together. The former deals with the assumptions behind cost estimates, and the latter with the difference between T states and S states. If you are interested in simulation, start with the ZX decomposition simulation study paper and move on to magna paper. For a system design perspective, MagiCFirm paper and FlowRouter paper are good choices. The direction of extending to magic states other than T can be seen in the √T cultivation study paper.