⚛️ quantum physics

Infinite Distance Extrapolation: How error mitigation can enhance quantum error correction

This paper proposes a novel paradigm that integrates Quantum Error Mitigation and Quantum Error Correction by treating the code distance as a noise parameter within a Zero-Noise Extrapolation framework, effectively enabling "infinite distance extrapolation" to reduce logical errors even for non-stabilizer input states.

Original authors: George Umbrarescu, Oscar Higgott, Dan E. Browne

Published 2026-03-13

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: George Umbrarescu, Oscar Higgott, Dan E. Browne

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

The Big Idea: Fixing a Leaky Boat by Building a Bigger One

Imagine you are trying to sail a small boat (a quantum computer) across a stormy ocean. The boat has holes in it (noise/errors), and water is constantly leaking in, making it hard to reach your destination (a correct calculation).

There are two main ways people usually try to fix this:

Quantum Error Correction (QEC): You build a giant, reinforced hull around your small boat. The bigger the hull (the "code distance"), the better it is at keeping water out. But building a massive hull takes a lot of wood and time (resources).
Quantum Error Mitigation (QEM): You don't build a bigger boat. Instead, you sail the small boat in the storm, measure how much water leaked in, then sail it again in a worse storm (amplified noise), measure that, and use math to guess what the result would have been if the ocean were perfectly calm.

The Problem: Usually, these two methods are kept separate. QEC is for the future (when we have huge computers), and QEM is for today (when we have noisy, small computers).

The Paper's Solution: The authors propose a clever hybrid called Infinite Distance Extrapolation (IDE). They realized that you can use the "QEM trick" (extrapolation) inside the "QEC framework."

Instead of making the storm worse to guess the calm result, they make the boat smaller to guess the result of an infinitely big boat.

The Core Analogy: The "Zoom Out" Trick

Think of the "Code Distance" as the resolution of a photo.

Low Distance (Small $d$ ): A blurry, pixelated photo. You can see the general shape, but the details are fuzzy because of "noise" (errors).
High Distance (Large $d$ ): A high-definition, crystal-clear photo. The noise is filtered out.
Infinite Distance: A perfect, mathematical image with zero noise.

How IDE works:

Take a series of photos: You take pictures of the same scene using different zoom levels (distances $d=5, d=7, d=9$ , etc.).
Observe the blur: You notice that as the zoom level gets lower (smaller distance), the picture gets blurrier in a very predictable way.
The Math Magic: You draw a smooth curve through these blurry pictures and extend the line all the way to the right, where the zoom level is "infinite."
The Result: Even though you never actually built the "infinite zoom" camera (which would require a supercomputer), your math predicts exactly what that perfect image would look like.

Why is this cool?
Usually, to get a clearer picture, you have to build a bigger camera (more qubits). But with IDE, you can take a few smaller, cheaper cameras, snap a few photos, and use math to "fake" the result of the giant camera. You save a massive amount of resources.

The "Odd vs. Even" Quirk

The authors noticed something funny while testing this.

If you build a code with an odd distance (like 5 or 7), it works one way.
If you build a code with an even distance (like 6 or 8), it works slightly differently, almost like a different type of boat.

It's like trying to fit a square peg in a round hole. If you mix odd and even distances in your math, the curve gets wobbly. The paper shows that you have to treat odd and even distances as separate groups to get the perfect prediction.

Tackling the "Magic" States

Quantum computers need special ingredients called "Magic States" (non-stabilizer states) to do complex math. These are notoriously hard to simulate on a regular computer because they are so "weird."

The authors had to use a clever workaround. Imagine you can't bake a complex cake directly. Instead, you bake several simple vanilla and chocolate cakes, mix them together in specific ratios, and pretend that mixture is the complex cake. This allowed them to test their method on the hardest types of quantum calculations, not just the easy ones.

The Real-World Payoff: Saving Resources

The paper ran simulations to see how much this actually helps.

The Result: By using this "extrapolation" trick, they could achieve the same accuracy as a much larger computer using 3 to 10 times fewer physical parts (qubits).
The Trade-off: You have to run the experiment a few more times (to get the data for the different distances), but that is much cheaper than building a whole new, bigger quantum computer.

Summary

This paper is like finding a shortcut to the future. It says: "We don't need to wait until we have a massive, perfect quantum computer to get perfect results. We can take our current, noisy, smaller computers, run a few different-sized tests, and use a bit of math to 'extrapolate' our way to a perfect result."

It bridges the gap between the "Noisy" present and the "Fault-Tolerant" future, allowing us to do better science today with the hardware we have right now.

1. Problem Statement

Quantum Error Correction (QEC) and Quantum Error Mitigation (QEM) are traditionally treated as distinct approaches. QEC is designed for the Fault-Tolerant Quantum Computing (FTQC) era, requiring large physical resources to suppress errors below a threshold. QEM is designed for the Noisy Intermediate-Scale Quantum (NISQ) era, trading temporal resources (more circuit executions) for spatial resources to reduce bias in expectation values.

The paper addresses the Early Fault-Tolerant (EFT) era, a transitional phase where devices are improving but full fault tolerance is not yet achievable. The core problem is how to combine these two paradigms non-trivially. Specifically, the authors investigate whether QEM techniques can enhance QEC performance when the physical error rate is below the code threshold but the logical error rate (LER) is still non-negligible.

2. Methodology: Infinite Distance Extrapolation (IDE)

The authors propose Infinite Distance Extrapolation (IDE), a novel paradigm that adapts the Zero-Noise Extrapolation (ZNE) technique to the QEC setting.

Core Concept: In standard ZNE, noise is artificially amplified (e.g., by circuit folding), and results are extrapolated to the zero-noise limit ( $\lambda \to 0$ $λ \to 0$ ). In IDE, the "noise parameter" is replaced by the code distance ( $d$ ).
- Increasing the code distance (using more physical qubits) reduces the logical error rate, analogous to reducing physical noise.
- Therefore, extrapolating to infinite distance ( $d \to \infty$ ) is mathematically equivalent to extrapolating to zero noise.
The Ansatz: The authors derive an analytical ansatz for the logical error rate based on surface code theory. They model the noisy expectation value $y(d)$ as:
$y(d) = A + Be^{-Cd}$
Where $A$ is the noiseless expectation value (the target), and the exponential term represents the error contribution that vanishes as $d \to \infty$ . They also explore multi-exponential forms to account for different error mechanisms (e.g., $X$ vs. $Y$ basis errors).
Implementation:
1. Parallel Execution: Instead of running one large code, the method runs multiple instances of the same logical circuit with different code distances ( $d_1, d_2, \dots, d_k$ ) in parallel on available hardware resources.
2. Data Collection: Expectation values are measured for each distance.
3. Fitting: The data points are fitted to the ansatz function.
4. Extrapolation: The function is evaluated at $d \to \infty$ to obtain the mitigated expectation value.
Handling Non-Stabiliser States: To test non-trivial expectation values (not just $\pm 1$ $\pm 1$ ), the authors employ two methods to bypass the need for expensive non-Clifford simulations:
- Quantum Process Tomography (QPT): Characterizing the effective logical noise channel.
- Stabiliser Decomposition: Expressing non-stabiliser states (like the $|T\rangle$ state) as a quasiprobability sum of stabiliser states, allowing efficient simulation via Clifford circuits.

3. Key Contributions

Paradigm Shift: Proposes a framework where QEC acts as a subroutine within a QEM workflow, distinct from previous proposals that used QEM inside QEC decoding.
Theoretical Justification: Provides an analytical derivation linking the logical error rate scaling to an exponential decay function of the code distance, justifying the choice of ansatz.
Robustness Testing: Demonstrates the method's efficacy on the rotated surface code under realistic circuit-level noise models (SI1000) and spatially inhomogeneous noise (simulating fabrication defects).
Non-Stabiliser Validation: Successfully applies IDE to non-stabiliser input states (e.g., $|T\rangle$ and states in the XY-plane), proving the method works for general quantum computations, not just memory experiments.

4. Key Results

The authors performed numerical simulations using the Stim simulator and PyMatching decoder.

Accuracy Improvement: IDE significantly reduces the error in expectation values compared to single-distance QEC experiments.
- For stabiliser states ( $|0\rangle$ ), the method achieves near-perfect fits ( $R^2 > 0.99$ ).
- For non-stabiliser states ( $|T\rangle$ ), IDE reduces errors by up to 10 $\times$ compared to a single experiment at a much larger distance.
Effective Distance ( $d_{eff}$ ): The authors define an "effective distance" metric. They show that fitting data up to a moderate distance (e.g., $d=13$ ) yields results equivalent to running a single experiment at a much larger distance (e.g., $d \approx 30+$ ), depending on the physical error rate.
Resource Savings:
- IDE offers substantial resource savings. For a physical error rate of $p=0.4\%$ , IDE can achieve a similar logical error rate with $\approx 9\times$ fewer physical qubits compared to running a single large code.
- Space-time volume savings are estimated between 4.5 $\times$ and 30 $\times$ .
Robustness: The method remains effective even when physical qubits have varying error rates (spatial inhomogeneity), though the performance is ultimately limited by the worst-performing qubits.
Comparison: IDE outperforms traditional Richardson extrapolation (which uses a polynomial ansatz) by orders of magnitude in error reduction, particularly for non-stabiliser states.

5. Significance and Implications

Bridging the EFT Gap: IDE provides a practical pathway for the Early Fault-Tolerant era. It allows researchers to extract high-fidelity results from devices that are not yet large enough to run full fault-tolerant algorithms at the desired accuracy.
Hardware Efficiency: By leveraging the smooth scaling of logical error rates with distance, IDE allows for "virtual" infinite distance codes without the prohibitive hardware cost of physically building them.
General Applicability: While demonstrated on the surface code, the authors argue the method is applicable to other topological codes. They note that codes with non-smooth distance jumps (like LDPC or concatenated codes) might require further investigation.
Cost-Benefit: The method trades sampling overhead (running multiple circuits) for spatial overhead (building larger codes). Given that sampling is often cheaper than fabricating larger chips, IDE is a highly attractive strategy for near-term quantum advantage.

In conclusion, the paper establishes that Infinite Distance Extrapolation is a powerful technique that enhances QEC by treating code distance as a tunable noise parameter, enabling high-precision quantum computations with significantly reduced hardware requirements in the near-term.