The cost of a logical qubit

Aug 06, 2026 · #quantum computing #error correction #fault tolerance #hardware

Qubit counts are the wrong headline. The number that decides whether a quantum computer is useful is the exchange rate between noisy physical qubits and quiet logical ones, and the hardest part of that bill is not memory but a single gate.

A quantum computing announcement almost always leads with a qubit count, because it is a single number, it goes up over time, and it fits in a headline. It is also close to uninformative. In late 2025 Quantinuum shipped a trapped ion machine with 98 physical qubits and reported running 48 of them as error corrected logical qubits. Superconducting machines with more than a thousand physical qubits report zero. Both statements are true, and only the second number in each pair says anything about what the machine can compute.

The quantity that matters is an exchange rate. How many noisy physical qubits, and how many microseconds of ordinary classical computation, do you have to spend to obtain one logical qubit quiet enough to survive a circuit a hundred million operations deep? That rate currently runs anywhere from roughly two to one to more than a thousand to one, depending on the code, the hardware and the honesty of the accounting. The spread is the story.

Why you cannot simply keep a copy

Classical error correction is triplication. Store a bit three times, and if one copy flips, majority vote restores it. None of that works here. The no-cloning theorem forbids duplicating an unknown quantum state, so there are no copies to vote among. Errors are not discrete flips but continuous rotations, so a qubit can be wrong by a tenth of a degree. And reading a qubit to check on it destroys the superposition you were trying to protect. Every instinct carried over from classical engineering is wrong.

The escape is to measure a relation rather than a value. Take two qubits and ask, without asking what either one is, whether they agree. The answer is one bit, it reveals nothing about the underlying state, and it changes if exactly one of the two has flipped. These parity checks are called stabilizers, and a code is a lattice of them arranged so that any single physical error lights up a distinctive pattern of failed checks. The picture worth holding is a room full of sealed boxes where you are never allowed to open a box, but you may ask whether any two boxes contain the same thing. Ask enough such questions, arranged cleverly enough, and you can locate an intruder without ever seeing inside.

Continuous errors fall out for free, and this is the part that surprises people. Measuring a stabilizer projects a small continuous rotation onto either no error or a full discrete flip. The measurement itself digitises the noise. That is why quantum error correction is possible at all, and it is the reason the field is an engineering problem rather than a physics one.

The surface code arranges these checks on a two dimensional grid, which is why it dominates: every check involves only nearest neighbours, and nearest neighbour wiring is what chips can actually be built with. Its code distance, written d, is the length of the shortest chain of physical errors that can corrupt the encoded information without lighting up any check. A patch of distance d costs d squared data qubits plus d squared minus one measurement qubits.

The threshold, and what it buys

The central result is the threshold theorem. If the physical error rate p sits below a critical value p_th set by the code and the noise model, the logical error rate falls off as

p_L is proportional to (p / p_th) raised to the power (d + 1) / 2

In words: below the threshold, every two steps you add to the code distance divides the logical error rate by a constant factor. Above the threshold, the same equation runs backwards, and every qubit you add makes the machine worse. There is no gentle middle ground. The physical error rate is either good enough that scale helps, or it is not, and building a bigger machine on the wrong side of that line is an expensive way to generate noise.

The lattice on the left is the smallest patch worth drawing. The plot on the right is the whole argument: the same hardware improvement that puts you below the threshold turns qubit count from a liability into leverage.

Put numbers on it. Suppose the error suppression factor per two steps of distance is about 2, which is close to what current superconducting hardware achieves. Starting from a logical error rate near one in a thousand at distance 5, reaching one in a billion, the sort of figure a long algorithm needs, takes distance 27 or so. A distance 27 patch costs 2 times 27 squared minus 1, which is 1457 physical qubits, for one logical qubit. Improve the physical error rate by a factor of a few and that suppression factor rises, the required distance drops sharply, and the bill falls to a couple of hundred. This is why hardware fidelity work is not incremental polish. It moves an exponent.

The gates that are free, and the one that is not

Here the accounting takes a turn that surprises almost everyone outside the field. Protecting a logical qubit at rest is the easy half. Computing with it is where the money goes, and the cost is not spread evenly across operations.

Quantum gates split into two classes. The Clifford group, which contains the Hadamard, the phase gate and the controlled NOT, is exactly the set that plays nicely with stabilizer codes: apply a Clifford gate to an encoded state and the parity checks transform into other parity checks, so the protection survives. Cliffords are cheap. They are also, by the Gottesman and Knill theorem, efficiently simulable on a laptop. A circuit built only from Clifford gates is not a quantum computer in any interesting sense.

Universality requires at least one gate outside that group, conventionally the T gate, a rotation by forty five degrees about the Z axis. No stabilizer code can implement it transversally, and the workaround is oblique. You prepare a special resource state, the magic state, and consume it through a Clifford circuit to enact the T gate. The state itself cannot be made cleanly, so you make many dirty ones and distil. The classic protocol takes fifteen states of error rate p and produces one of error rate roughly 35 p cubed. Cube a small number and it becomes very small: at p equal to one in a thousand, one round already reaches three in a hundred million.

The catch is what a round costs. The distillation circuit runs on logical qubits, occupies a large region of the chip for many correction cycles, and often has to be run twice. In serious layouts for algorithms like factoring, the magic state factories occupy the majority of the machine. The logical memory is the small part of the floor plan. The computer is mostly a plant for manufacturing a single awkward gate.

Fifteen in, one out. The cubic suppression is excellent and the volume cost is brutal, which is why magic state factories dominate the floor plan of any realistic fault tolerant layout.

The classical computer that has to keep up

There is a third line on the invoice, and it is not made of qubits. Every correction cycle emits a stream of syndrome bits, and something has to turn that stream into a diagnosis of which errors occurred, fast enough to keep pace. On superconducting hardware a cycle lasts roughly a microsecond, which is the entire budget for the decoder.

Miss the budget and the failure mode is not graceful. Syndromes keep arriving while the decoder is still working on the last batch, the queue grows, and because each unresolved round delays the next, the slowdown compounds. This is the backlog problem, and it turns a decoder that is merely a bit too slow into a machine that is exponentially too slow. Note that the constraint is on tail latency, not average latency: one slow decode in a million still poisons the pipeline. Real time decoding has quietly become a hardware discipline of its own, running on FPGAs and custom silicon sitting next to the cryostat.

Where this stands in 2026

Four results define the present position, and they come from four different physical platforms, which is itself informative.

Google’s Willow processor crossed the surface code threshold, published in Nature with the preprint on arXiv. Going from distance 5 to distance 7 suppressed the logical error rate by a factor of 2.14, and the distance 7 memory, 101 physical qubits, reached 0.143 per cent error per correction cycle while outliving its own best physical qubit by a factor of 2.4. That is the first clean experimental confirmation that the exponent runs the right way on a real chip. Google has since published work on dynamic surface codes that relax some of the layout constraints.

A team from QuEra, Harvard and MIT ran magic state distillation entirely on logical qubits on a neutral atom machine, using distance 3 and distance 5 colour codes and a five to one protocol, with the distilled output cleaner than any input. Distillation on encoded rather than raw qubits is the version that actually composes into a deep circuit.

Quantinuum’s trapped ion Helios system reported 94 error detected and 48 error corrected qubits from 98 physical ones, with logical gate error near one in ten thousand, better than the underlying physical rate. The company describes the code work behind that ratio in Skinny Logic, and MIT Technology Review covered the machine at launch. All to all connectivity in an ion trap permits codes that a fixed two dimensional grid cannot host, which is where that startling ratio comes from.

IBM has bet the roadmap on quantum low density parity check codes, whose bivariate bicycle family encodes twelve logical qubits into 144 data qubits, roughly a tenfold reduction against the surface code. The published plan targets about 200 logical qubits from around ten thousand physical ones by 2029.

Meanwhile the algorithmic target has moved toward the hardware. The canonical 2019 estimate for factoring a 2048 bit RSA key was twenty million noisy qubits running for eight hours. A 2025 revision cuts that to under a million qubits over about a week, a hundredfold reduction in Toffoli count achieved entirely through better algorithms and better magic state handling. Progress on paper has been outrunning progress in the fridge.

What none of this proves

A memory is not a computation. Almost every headline threshold result concerns storing a logical qubit and doing nothing to it. Logical operations, in particular lattice surgery and the injection of magic states, run at higher error rates and consume vastly more space and time. The gap between a good memory and a good computer is several years of engineering, not a footnote.

Error detected is not error corrected. Detection means you know a run was spoiled and can discard it. That yields excellent reported fidelities at the price of a success rate that falls exponentially with circuit depth. It is a legitimate technique and it is not fault tolerance, and press summaries routinely blur the two.

Reduced overhead is paid for somewhere else. Codes with better encoding ratios need long range connectivity, whether that is atom shuttling, ion transport or dedicated couplers, and those links are slower and noisier than nearest neighbour gates. The qubit count falls, the cycle time rises, and total time to solution is the figure that matters. Nobody has yet published a full stack demonstration of a qLDPC code at scale on hardware.

Noise is assumed to be nicer than it is. Threshold numbers come from models of independent, uncorrelated errors. Real devices show leakage out of the computational subspace, crosstalk, drift over hours, and in superconducting chips, cosmic ray strikes that flip large regions of the die at once. Correlated failures are exactly the ones a local code handles worst, and the honest position is that the threshold theorem gives an existence proof, not a schedule.