Logical Qubits Explained: Why Physical and Logical Qubit Counts Don’t Compare

What a logical qubit is

A physical qubit is fragile. A stray photon, a trace of heat or a wandering field flips its state. The fix is to spread one unit of quantum information across many physical qubits and run repeated parity checks that interrogate the neighbours rather than the encoded data itself. Measuring the data directly would collapse the superposition, so the checks reveal where an error landed without revealing what the qubit holds.

That encoded unit is a logical qubit. The phrase describes a construction, not a quantity. Two logical qubits built from different codes can differ in reliability by many orders of magnitude, and the physical-qubit bill for each will differ accordingly. Reporting the count without the code is like reporting an engine’s cylinder count without its displacement.

Distance is the number that decides everything

A code’s distance, written d, is the smallest number of physical errors that can corrupt the encoded information without tripping a check. It sets exactly what the code can do. A code of distance d corrects up to (d − 1)/2 errors.

• Distance 2 detects a single error. It corrects none.
• Distance 4 corrects one error and detects more.
• Distance 7 corrects three.
• A cryptographic computation needs distances in the twenties or higher, which is why the resource estimates for breaking RSA run to thousands of physical qubits per logical one.

Distance is what you pay for. In the surface code the cost runs roughly as the square of the distance, so a distance-7 logical qubit needs about 100 physical qubits and a distance-25 one needs well over a thousand. An overhead ratio is meaningless until you say what distance it bought. Two-to-one at distance 4 and a hundred-to-one at distance 7 are not competing claims about the same product.

Detection is not correction

The second split is more consequential than the first. An error-correcting code identifies where the fault occurred and repairs it, and the computation continues. An error-detecting code only raises a flag. The standard response is to discard that run and try again, a technique called postselection.

Postselection genuinely improves the quality of the runs you keep, and the improvement is measurable. It is also not fault tolerance. The cost is the discard rate, and the discard rate compounds. If a circuit contains many checks and each has some independent chance of firing, the fraction of runs that survive falls off geometrically with circuit volume. At 100 qubits and shallow depth this is an inconvenience. At the scale a factoring circuit needs, it is fatal.

Google’s number: one logical qubit, and a scaling law

Google Quantum AI’s Willow result, published in Nature in February 2025, reported a single logical qubit. It used 101 physical qubits in a distance-7 surface code and measured 0.143 percent, plus or minus 0.003, error per correction cycle. The logical memory outlived its best individual physical qubit by a factor of 2.4, plus or minus 0.3. A distance-5 version ran with a real-time decoder at an average latency of 63 microseconds across a million cycles.

The count was never the point. The paper’s central result is Λ = 2.14 ± 0.02. That is the factor by which the logical error rate fell for every two steps of code distance. Λ greater than one means the hardware sits below the surface-code threshold: adding physical qubits removes more errors than it introduces. Every fault-tolerant machine depends on that property, and it describes scaling rather than size.

The overhead was roughly 100 physical qubits per logical qubit. Read against the numbers below, that looks terrible. It is the only one of the three that comes with a demonstrated scaling law and no postselection.

Quantinuum’s number: 48 from 98

In February 2026 Quantinuum reported computing with encoded logical qubits on Helios, its 98-qubit trapped-ion processor. The headline figures are 94 error-detected logical qubits, or 48 error-corrected ones, from those same 98 physical qubits. That is a ratio near one-to-one for detection and two-to-one for correction.

How the ratio gets that low. The iceberg code, written [[k+2, k, 2]], encodes k logical qubits into k+2 physical ones. Two extra qubits, however large the block. It is distance 2, so it detects and does not correct. Nesting two iceberg codes inside each other produces a concatenated code of distance 4, which corrects a single error while keeping a high encoding rate. Quantinuum reported logical error rates 10 to 100 times below their physical counterparts, a 94-logical-qubit GHZ state at 94.9 percent fidelity, and a three-dimensional quantum-magnetism simulation on 64 error-detected logical qubits. Simulations of this kind are where quantum hardware currently earns its keep.

Two conditions attached. The results use postselection, and the paper describes the magnetism simulation as partially fault-tolerant rather than fault-tolerant. The approach also depends on the all-to-all connectivity of a trapped-ion machine, because iceberg parity checks touch every qubit in a block. On a nearest-neighbour superconducting grid, the routing overhead would consume the advantage.

IBM’s number: 70, with the same footnote

On 30 July 2026 IBM and the University of Chicago announced a quantum-advantage demonstration built on 70 logical qubits. The circuit ran 2,415 logical two-qubit operations and 468 logical T gates, finishing in roughly 15 minutes, with an effective gate error rate about ten times lower than the underlying physical hardware.

The mechanism. The technique is called doped Clifford sampling. It embeds a classically simulable Clifford circuit inside a spacetime code, one whose detecting regions extend across both qubits and time steps. It then injects non-Clifford T gates at positions where the checks still hold. The Clifford version supplies a classically tractable fidelity baseline, and the syndrome statistics then bound the fidelity of the hard circuit.

IBM’s own description of the result states where the tenfold gain comes from: postselecting the runs that satisfy the consistency checks. This is a detection scheme, like Quantinuum’s, applied at larger circuit volume. It is a real result and a substantial one. It is not 70 fault-tolerant logical qubits.

The three results are not on one axis

Laid against each other, the comparison collapses. Google measured a memory with no postselection at distance 7 and reported a scaling factor. Quantinuum ran computation at distance 4 with postselection and reported an encoding rate. IBM ran a sampling circuit inside a spacetime detection code with postselection and reported a fidelity bound.

Five variables separate them. A headline count reports none of them.

• Code distance.
• Correction or detection only.
• Whether runs are discarded, and at what rate.
• Memory or computation.
• Whether the circuit included non-Clifford gates.

That last one matters because classical computers simulate Clifford circuits efficiently. A logical qubit that never runs a T gate has not yet done the hard part.

The number to ask for

One figure makes the comparison honest: the logical error rate per logical operation, quoted at a stated code distance, without postselection, with the discard rate given if postselection was used.

That number is what determines how long a program can run. A logical error rate of one in ten thousand permits roughly ten thousand operations before a failure is likely. The roadmaps are already stated in these terms even when the press releases are not. Quantinuum’s Sol, targeted for 2027, aims at about 100 logical qubits approaching five nines of logical fidelity. Its Apollo, targeted for 2029, aims at hundreds of logical qubits at ten nines, which is roughly ten billion operations before an error. IBM’s Starling, also targeted for 2029, aims at 200 logical qubits running 100 million gates.

Those are the useful numbers because they combine count and quality. They are also, so far, targets rather than measurements.

What is settled

Established. Surface-code memory operates below threshold on superconducting hardware, and the scaling behaves as theory predicted. High-rate codes deliver genuine overhead reductions on hardware with flexible connectivity. Encoded logical qubits now outperform their physical constituents on several platforms.

Contested. Whether concatenated iceberg codes reach the distances that matter. Whether postselection-based results tell us anything about fault-tolerant performance.

Unproven. Every roadmap target beyond 2026.

Error correction crossing the threshold was the shift that reorganised the field. What follows it is an argument about which code family wins, not about whether the idea works. That is progress, and it is also the moment when the vocabulary stops being reliable. When the next announcement quotes a logical qubit count, the count is the least informative number in it.