Errors in the correction itself
In the previous rung you met quantum error correction: spread the information of one logical qubit across many physical qubits, measure cleverly chosen parities, and you can detect and fix an error *without* directly measuring (and thus destroying) the protected state. That sounds like the whole problem solved. It isn't — and the reason is uncomfortably simple.
The correction machinery is built from the same noisy parts it is trying to protect. The extra qubits used to detect errors are themselves imperfect. The gates you apply to compute the parities have a chance of failing. Even the measurements that read out the parity can give the wrong answer. So every time you run an error-correction round, you are *also* injecting fresh errors with the very circuit meant to remove them.
This is the danger of an error cascade: a single fault in the wrong place can spread to corrupt many qubits at once, and a sloppy correction circuit can turn one error into several. Fault tolerance is the engineering discipline that keeps this from happening — designing every operation so that a single component failure stays contained and the round, on balance, removes more error than it adds.
The threshold theorem
Here is the result that turns quantum computing from a fantasy into an engineering roadmap. The [[threshold-theorem|threshold theorem]] says: *if* the error rate of your physical components is below some critical value — the threshold — then by adding more layers of error correction you can push the logical error rate arbitrarily low, and the overhead to do so grows only modestly (polylogarithmically) in how low you want to go.
Think of it as a race between two effects. Adding more physical qubits to a code makes each correction round *better* at catching errors — but it also adds *more* faulty parts that can themselves fail. The threshold is the break-even point of that race. Below threshold, bigger codes win: every step up in code size buys you a net reduction in logical error. Above threshold, bigger codes lose: you are adding noise faster than you are removing it, and piling on more qubits only makes things worse.
For the leading practical code, the surface code, the threshold sits around 1% physical error per operation under realistic noise assumptions. That number is famous precisely because it is *reachable* — today's best superconducting and trapped-ion hardware has nudged its two-qubit gate fidelities to roughly that neighborhood. The threshold is not a wall we can never climb; it's a bar we are just beginning to clear.
Below threshold = scalable
The magic of being below threshold is that improvement compounds. Suppose each round of correction at a given code size multiplies your logical error rate by some factor less than one. Make the code a little bigger and that factor shrinks again. Chain these together and the logical error rate falls roughly *exponentially* in the size of the code — even though the number of physical qubits you spend grows only polynomially. A small, steady advantage per round, repeated, becomes an enormous advantage overall.
This is why people sometimes say a fault-tolerant machine could run as long as you like with as little logical error as you like. That phrasing is fair *only* if you are below threshold and willing to pay the qubit overhead. It is not a claim about speed or about computing many answers at once — it is purely a statement about reliability: you can make the logical qubits behave as if they almost never fail.
To make this concrete, here is a tiny sketch of why redundancy can help at all. We don't 'fault-tolerantly' encode here — this is just the intuition that majority logic beats a single fragile bit. A real surface-code round is far more elaborate, but the spirit is the same: spread information out, then vote.
from qiskit import QuantumCircuit # A 3-qubit *bit-flip* code: protect one logical bit # against a single X (bit-flip) error. (Toy intuition, # NOT a fault-tolerant surface-code round.) qc = QuantumCircuit(3, 3) # Encode: copy the logical value across 3 qubits qc.cx(0, 1) qc.cx(0, 2) # ... time passes, noise may flip ONE qubit ... # Decode by majority vote: the two CNOTs + Toffoli # restore qubit 0 if at most one qubit was flipped qc.cx(0, 1) qc.cx(0, 2) qc.ccx(2, 1, 0) # Toffoli = the 'majority' correction qc.measure(range(3), range(3)) print(qc.draw())
The physical-qubit price tag
Exponential reliability sounds free until you read the bill. To run a genuinely useful algorithm — say, Shor's algorithm factoring a cryptographically relevant RSA number — you need logical qubits with error rates around one-in-a-billion or better. Hitting that with a surface code at ~1% physical error means encoding each logical qubit in thousands of physical qubits: a code 'distance' large enough that hundreds or thousands of physical qubits stand in for one reliable logical one.
Multiply that out. A serious Shor-scale computation needs thousands of logical qubits *and* a long sequence of operations — and many of those operations require resource-hungry helper states (so-called magic states) churned out by dedicated 'factories' of yet more qubits. Recent careful estimates land in the range of roughly a million physical qubits, give or take, to break RSA-2048 in a day or so. Earlier estimates were even higher; better codes and protocols keep chipping the number down, but it remains enormous.
Put bluntly: the fault-tolerant machine that worries cryptographers does not exist yet, and won't for some time. The threshold theorem guarantees it is *possible*; it says nothing about it being *cheap* or *soon*. The gap between 'mathematically scalable' and 'physically built' is measured in millions of high-quality qubits we do not have.
How far we are
So where does that leave us in 2026? Squarely in the [[nisq|NISQ era]] — Noisy Intermediate-Scale Quantum. We have devices with hundreds to a few thousand physical qubits, two-qubit gate fidelities hovering right around the surface-code threshold, and coherence times (the T1/T2 windows before a qubit forgets its state) measured in microseconds to milliseconds. These machines are real and improving, but they are noisy and not fault-tolerant.
The encouraging news is that the field has crossed from theory into demonstration. Several groups have now shown a *single* logical qubit whose error rate drops as the code gets bigger — the first experimental signature of operating below threshold. That is a genuine milestone: it confirms the threshold theorem isn't just chalkboard math. But going from one below-threshold logical qubit to the thousands needed for Shor-scale work is a leap of many years and many engineering breakthroughs, not a press cycle.
Hold both truths at once. Honest optimism: the physics permits arbitrarily reliable quantum computers, and we have, for the first time, watched error correction *help* instead of hurt. Honest realism: we are hundreds-to-thousands of noisy qubits away from the millions a useful fault-tolerant machine demands, and no shortcut around the overhead is currently known. Anyone promising a cryptography-breaking quantum computer next year is selling hype, not physics.