Quantum Error Correction: When More Qubits Produce Fewer Errors
Understand how surface codes detect errors without reading quantum data directly, what below threshold means, and why one protected memory is not yet a useful computer.
Reviewed October 12, 2026.
Understand how surface codes detect errors without reading quantum data directly, what below threshold means, and why one protected memory is not yet a useful computer.
| Concept | What it means | Important limit |
|---|---|---|
| Physical qubit | A hardware degree of freedom carrying quantum state | Individual operations remain noisy |
| Logical qubit | Information encoded across many physical qubits | Large overhead is required |
| Code distance | Minimum error chain able to cause logical failure | Higher distance helps only below threshold |
| Decoder | Classical inference from syndrome measurements | Latency and model mismatch can limit performance |
1. Quantum information is fragile in several different ways
A physical qubit can lose energy, lose phase coherence, suffer an imperfect gate, or be measured incorrectly. Errors are continuous at the hardware level, yet quantum algorithms require sequences of operations whose total failure probability stays extremely small. Simply copying an unknown quantum state is prohibited by the no-cloning theorem, and measuring the state directly would disturb it. Quantum error correction therefore encodes information nonlocally across many qubits and measures carefully chosen parity relationships instead of asking for the protected logical value itself.
2. A logical qubit is a pattern distributed across hardware
In a surface code, data qubits sit on a two-dimensional layout while neighboring measurement qubits repeatedly probe stabilizer checks. The encoded logical state is not located in one privileged device. Local faults change the pattern of check outcomes, called the syndrome. Repeating checks through time distinguishes persistent data errors from measurement errors. This redundancy is expensive, but it creates a route to infer likely faults while preserving the superposition that computation needs. The code protects information; it does not make the underlying components perfect.
3. Error correction detects symptoms before assigning causes
A changed stabilizer result indicates that something in a neighborhood may have gone wrong, but it does not uniquely identify the fault. Multiple error chains can create the same syndrome. A classical decoder receives the stream of outcomes and estimates a correction or updates a software-tracked frame. Its assumptions about error rates and correlations affect performance. Fast decoding matters because information keeps evolving while the classical system works. A quantum processor therefore depends on a tightly coupled classical measurement, inference, and control pipeline.
4. Code distance measures protection against extended faults
The distance of a code is related to the smallest undetectable error chain that can change the logical state. Increasing distance adds physical qubits and stabilizer checks, making a logical failure require a longer, less likely pattern when errors are sufficiently sparse and weakly correlated. Distance is not a simple qubit count: layout, boundaries, repeated cycles, leakage, crosstalk, and decoder behavior matter. Comparing two distances on the same hardware is valuable because it tests whether added redundancy actually suppresses logical error rather than adding more failure locations.
5. Below threshold is a scaling statement
A fault-tolerance threshold separates two regimes. Below it, increasing code distance should suppress logical error; above it, extra hardware can make performance worse because new fault opportunities outweigh redundancy. The 2025 Nature result reported distance-5 and distance-7 surface-code memories with logical error suppression as distance increased, including real-time decoding for one configuration. That is a major experimental milestone. It does not mean every gate, algorithm, and system component is already below threshold, or that arbitrary scaling is guaranteed.
6. Correlated faults can defeat an independence story
Textbook estimates often begin with simple, independent error models. Real processors have leakage outside the computational states, common control errors, crosstalk, radiation events, calibration drift, and fabrication variation. A rare correlated event can cross a code faster than many independent faults. Experiments therefore run long sequences, inspect spatial and temporal correlations, and compare data with detailed simulations. The relevant question is not only the average physical error rate, but whether the tail of the fault distribution is compatible with the code and decoder.
7. Memory is necessary but computation adds new demands
Protecting an idle logical qubit demonstrates repeated syndrome extraction and decoding. A useful fault-tolerant machine must also initialize states, perform logical gates, move or connect information, measure outcomes, and supply special resource states for non-Clifford operations. Each procedure needs an error budget. Factories that distill high-fidelity resource states may dominate hardware overhead for demanding algorithms. A headline logical-qubit lifetime should therefore be separated from end-to-end logical circuit performance and from a credible resource estimate for a specific task.
8. Evaluate progress with matched quantities
Check whether a reported rate is per physical gate, per error-correction cycle, per logical operation, or for an entire circuit. Ask what code distance, number of cycles, decoder latency, and confidence interval were used. Look for comparisons against the best physical qubit and against smaller code distances. Note whether postselection removed difficult runs. Most importantly, ask which failure modes were included in the benchmark. A lower logical error is meaningful only when its unit, operating conditions, and scaling evidence are clear.
Conclusion
Quantum error correction converts fragile components into a more reliable encoded object by combining quantum redundancy with repeated measurement and classical inference. Crossing below threshold shows that larger codes can help on a particular platform. Building a practical computer still requires the same scaling behavior across logical operations, long runtimes, manufacturing variation, and the full control stack.