⚛️ quantum physics

Exact logical error rates for magic state cultivation

This paper presents exact analytical calculations of acceptance and logical error rates for distance-3 and distance-5 magic state cultivation circuits using Pauli propagation and binary tensor contraction, revealing that their effective fault distances are lower than their nominal distances and explaining observed performance degradation.

Original authors: Kwok Ho Wan, Ainhoa Zapirain

Published 2026-09-17

📖 4 min read🧠 Deep dive

CC BY 4.0

Original authors: Kwok Ho Wan, Ainhoa Zapirain

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

In the quest to build a computer that can solve problems impossible for today's machines, scientists are racing to create a version that does not break down when the slightest disturbance occurs. This is the promise of fault-tolerant quantum computing. The core challenge is that the basic building blocks of these computers, known as qubits, are incredibly fragile. To protect them, researchers use a method called error correction, which spreads information across many physical particles so that if one fails, the others can pick up the slack. However, this protection comes at a steep price: the computer must constantly perform a specific, difficult operation to keep the information safe. This operation is like a high-wire act that requires a special resource, often called a "magic state," to be prepared with extreme precision. If this preparation is flawed, the entire calculation collapses.

For years, scientists have relied on computer simulations to estimate how often these magic states fail. Because the failures are so rare—happening perhaps once in a billion attempts—simulating them directly is like trying to find a single specific grain of sand on a beach by picking up one grain at a time. It would take too long to be useful. Instead, researchers have used a shortcut, a simplified model that acts as a stand-in for the real, complex process. This shortcut was assumed to be accurate enough to guide the design of future machines. But without a way to calculate the exact failure rate, no one knew for sure if this shortcut was hiding a dangerous flaw that could make the computer far less reliable than expected.

A team of researchers has now removed the guesswork. By developing a new way to track the behavior of these systems, they have calculated the exact probability of failure for the circuits used to create these magic states. They did not rely on sampling or shortcuts. Instead, they mapped out every possible way the system could go wrong, from the smallest single error to complex chains of mistakes, and added up the results to find the true answer. Their work focused on two specific designs, one involving seven particles and another involving nineteen, which are currently the standard for building these circuits.

The results revealed a significant surprise. The researchers found that the simplified shortcut used for years actually underestimates the failure rate. In the larger nineteen-particle design, the real chance of a logical error for the actual T-state circuit is approximately 9.6 times higher than the shortcut suggested. This means that previous estimates of how much computing power would be needed to run these machines were likely too optimistic. The circuits are not as robust as the simplified models implied.

Furthermore, the team discovered that the reason for this discrepancy lies in the fundamental structure of the circuits themselves. They showed that these designs have a lower "fault distance" than previously believed. In simple terms, this means that a very small number of errors—just two in the smaller design and three in the larger one—are enough to cause a catastrophic failure that slips past the safety checks. The original designs were thought to require many more errors to cause such a failure. This finding explains why the circuits behave the way they do and clarifies why the shortcut model failed to predict the true risk.

To achieve this level of precision, the researchers used a method that treats the circuit as a vast network of interconnected probabilities. They tracked how errors move through the system, grouping similar mistakes together to keep the calculations manageable. They then used a mathematical technique to combine all these possibilities, effectively summing up the entire landscape of potential failures at once. This allowed them to produce exact numbers for the failure rates at different levels of noise, rather than just an average estimate. They verified their results by comparing them against previous simulations, and their exact numbers fell perfectly within the ranges those simulations had suggested, but with a precision that the simulations could never reach on their own.

The study provides a clear, exact map of the risks involved in creating these essential resources for quantum computing. It confirms that while the circuits work, they are more fragile than the simplified models indicated. This does not mean the technology is unworkable, but it does mean that engineers must account for these higher failure rates when planning future machines. The work serves as a definitive reference, replacing estimates with exact fractions and ensuring that the path toward a reliable quantum computer is built on a foundation of known, rather than guessed, probabilities.

Technical Summary: Exact Logical Error Rates for Magic State Cultivation

Problem Statement
Magic state cultivation is a critical procedure for fault-tolerant quantum computing, designed to generate high-fidelity logical magic states ( $|T^\dagger\rangle$ ) with logical error rates (LER) as low as $10^{-6}$ to $10^{-9}$ . At these low error rates, direct Monte Carlo sampling becomes computationally prohibitive because the vast majority of circuit executions are rejected by post-selection, and accepted logical errors are exceedingly rare. Furthermore, previous estimates often relied on an "S-gate proxy" to approximate the behavior of actual T-gate circuits, leaving uncertainty regarding whether the proxy accurately reproduces the error rates of the true T-state cultivation circuits. Additionally, the precise fault distances of these circuits under standard circuit-level noise models were not analytically established, leading to potential misestimations of resource costs.

Methodology
The authors employ a hybrid approach combining Pauli propagation and binary tensor contraction to compute exact logical error rates without sampling. The methodology proceeds in three main stages:

Pauli Propagation and Response Tables:
The cultivation circuit is divided into stages, notably two non-Clifford "double-checking" stages separated by a Clifford code growth stage. The authors use Pauli propagation to track the transformation of observables backwards through the circuit. For each incoming Pauli error $E$ at the entrance of a double-checking stage, they calculate two probabilities:
- $F_A(E; p)$ : The probability of passing post-selection (all trivial detectors).
- $F_B(E; p)$ : The probability of passing post-selection with a logical error.
  To manage the exponential number of Pauli strings, errors are grouped by their syndrome and logical frame labels ( $\alpha, \beta$ ). This reduces the response space from $4^N$ strings to manageable tables (256 entries for $d=3$ , $10^6$ for $d=5$ ).
Tensor Network Contraction:
The gates, noise channels, and post-selection conditions are encoded as a tensor network. The network contracts the response tables of the double-checking stages with the noise distributions of the intermediate Clifford growth stage.
- Exact Fractions: To compute the LER at a fixed noise strength $p$ , the tensor network is evaluated using modular arithmetic over several certified prime fields. The results are reconstructed as exact rational numbers using the Chinese Remainder Theorem (CRT), avoiding floating-point rounding errors inherent in signed sums of large magnitudes.
- Series Expansion: To obtain the LER as a function of noise, the network is evaluated with polynomial entries in the variable $x = p/(1-p)$ , truncated at order 10. This yields exact rational coefficients for the series expansion of the acceptance rate $A(p)$ and the accepted-error rate $B(p)$ .
Handling Growth Noise:
A key challenge is the "growth" stage between the $d=3$ and $d=5$ checks, where faults can combine via XOR to cancel syndromes. The authors treat the growth stage as a sum over fault configurations using a tree-based contraction order. They utilize Fourier slicing (summing over characters) to reduce the dimensionality of the label space, allowing exact summation without enumerating all $2^{908}$ fault patterns.

Key Contributions and Results

Exact Rational LERs: The paper provides exact rational values for the logical error rate $P_L(p) = B(p)/A(p)$ at specific noise strengths (e.g., $p=10^{-3}$ ) and as a series expansion up to order $x^{10}$ .
- For $d=5$ at $p=10^{-3}$ , the exact LER is calculated as $3.32842537\dots \times 10^{-9}$ .
- For $d=3$ at $p=10^{-3}$ , the exact LER is $8.982790954\dots \times 10^{-7}$ .
- These values recover the numerical results from previous works (Clifft and SOFT) within their sampling uncertainty intervals.
Revelation of Reduced Fault Distances:
The series expansion coefficients reveal that the leading-order terms of the LER scale as $p^2$ for the $d=3$ circuit and $p^3$ for the $d=5$ circuit. This indicates that the effective fault distances are $d_{fault}=2$ and $d_{fault}=3$ , respectively, rather than the code distances of 3 and 5.
- The authors explicitly construct minimal fault patterns (2 faults for $d=3$ , 3 faults for $d=5$ ) that pass post-selection and result in a logical error, confirming these reduced distances analytically.
- This explains the "distance degrading" effects observed in companion codes and suggests that the $d=5$ circuit offers less protection against logical errors than the code distance implies.
Comparison with S-Gate Proxy:
The study compares the exact T-state cultivation results with the S-gate proxy used in previous literature. At $p=10^{-3}$ , the proxy underestimates the logical error rate by a factor of approximately 9.6. This demonstrates that using the S-gate proxy leads to over-optimistic resource estimates for quantum algorithms relying on T-gates.
Computational Feasibility:
The authors demonstrate that these exact calculations can be performed on standard consumer hardware (an Apple MacBook M4), requiring less than 11 worker core-hours per data point for the full $d=5$ circuit, making exact verification accessible without massive supercomputing resources.

Significance
The paper claims significance primarily in providing a "source of truth" for magic state cultivation error rates. By replacing expensive sampling and potentially inaccurate proxies with exact arithmetic, the work:

Validates existing numerical simulations (Clifft, SOFT) with exact rational numbers.
Corrects the understanding of fault distances for these specific circuits, showing they are lower than the code distance.
Highlights the risk of using S-gate proxies, which can significantly underestimate the resource costs of fault-tolerant quantum computation.
Establishes a scalable methodology (Pauli propagation + tensor contraction) for exactly simulating non-Clifford circuits with post-selection, applicable to other fault-tolerant protocols.

The authors remain modest, noting that the escape, grafting, and decoding stages of the full cultivation protocol are outside the scope of this work, and the current results apply specifically to the circuits analyzed (Clifft/SOFT variants with unitary injection).

Technical Summary: Exact Logical Error Rates for Magic State Cultivation

More like this