How to Read a Logical Qubit Claim

IBM’s bivariate bicycle code encodes 12 logical qubits on paper. Microsoft and Quantinuum reported 4 in a trapped-ion demonstration. Google reported 1, and treated it as a landmark, correctly. All three numbers are accurate, and none of them, standing alone, tells you what the machine can compute.

The word doing the work in each headline is logical, and it isn’t a unit the way a gigabyte is a unit. Two vendors can use it precisely, in good faith, and mean objects that differ in reliability by six orders of magnitude and in cost by a factor of 100. What varies underneath the number is the code distance, whether errors were corrected or only spotted, whether the encoded qubits computed anything or merely sat still, and how much hardware each one consumed.

This piece covers the mechanism first, then the five properties that make one claim comparable to another. We teach this material because engineers and program managers are increasingly asked to turn vendor announcements into planning inputs, and the announcement almost never contains the properties that would let them.

The arithmetic that forces the abstraction

A physical qubit is the hardware object: a superconducting circuit on a chip, an ion held in an electromagnetic trap, a neutral atom pinned by laser light, an electron spin in silicon. It holds a superposition of 0 and 1, and it holds it badly. On the best commercial hardware today, a two-qubit gate fails at a rate somewhere around one operation in 1,000, and the qubit loses coherence, meaning its quantum state decays into classical noise, within tens to hundreds of microseconds.

Now count the operations in something worth running. A quantum chemistry simulation of an industrially interesting molecule, or an attack on a 2048-bit RSA key, calls for billions of gates. At one failure per 1,000 operations, a billion-gate circuit accumulates roughly a million errors. A single uncorrected error is usually enough to make the output meaningless. To finish a billion-gate circuit with a decent chance of a correct answer, you need a per-operation failure rate near one in 10 billion, which is about seven orders of magnitude better than any physical qubit any laboratory has ever built.

Nobody expects to close that gap with better materials. The gap gets closed with encoding, which is the same move classical computing made decades ago. Server memory stores 72 bits for every 64 bits of your data, and a memory controller uses the extra eight to detect and repair single-bit flips before the operating system ever sees them. The application programmer works with an abstraction of perfect bits, because the redundancy underneath is doing the repair work invisibly.

The quantum version can’t borrow the classical mechanism directly, for two reasons that shape everything that follows. Quantum states cannot be copied, so triplicate-and-vote is unavailable. And measuring a qubit destroys its superposition, so you can’t inspect the data to see whether it is intact. Quantum error correction (QEC) exists to work around both constraints: it spreads one qubit of information across many physical qubits in an entangled state, then measures a carefully chosen set of relationships between those qubits, relationships that reveal where an error struck while revealing nothing about the encoded value.

A logical qubit is the result: one qubit of quantum information, encoded across a group of physical qubits, protected by a repeating cycle of checks and corrections. That is the whole idea. Everything else is engineering.

Watching a code work, 3 qubits at a time

The smallest useful example is the 3-qubit repetition code, which handles one kind of error only. It isn’t a code anyone would deploy, and it makes the machinery visible in a way the surface code does not.

Take a qubit in an arbitrary state, some mixture of 0 and 1. Encode it across 3 physical qubits so that the 0 component becomes 000 and the 1 component becomes 111. The 3 qubits are now entangled, and no single one of them holds the answer. Reading any one qubit tells you nothing about the mixture you started with.

Add 2 more qubits, called ancillas, which are helper qubits used for measurement and then thrown away. Wire the first ancilla to compare qubits one and two, and the second to compare qubits two and three. Each comparison asks one question: are these two qubits the same, yes or no. It returns a single bit. It doesn’t ask what either qubit is.

Those two bits are the syndrome, and there are four possible values. Two zeros means the 3 data qubits agree and nothing has gone wrong. One-then-zero means qubits one and two disagree while two and three agree, so qubit one flipped. One-then-one localizes the error to qubit two. Zero-then-one localizes it to qubit three. Apply the flip in reverse and the encoded state is restored, and at no point during the procedure did anyone learn the value being protected.

Three pieces are now on the table, and every code in production use has the same three. Redundancy, meaning several physical qubits per logical one. Syndrome extraction, the repeating measurement cycle that reports where errors landed without reading the data. And a decoder, the classical process that takes a history of syndrome bits and works out which correction to apply.

Two definitions follow from the example. Code distance is the smallest number of physical errors that can corrupt the encoded state without producing a syndrome. The 3-qubit repetition code has distance 3 against bit flips, and a distance-d code corrects up to (d−1)/2 errors. And weight, informally, is how many qubits a single check touches, which is why some codes are easy to wire on a chip and others aren’t.

The repetition code catches bit flips and is completely blind to phase flips, the other way a qubit can go wrong. Peter Shor’s original 9-qubit code from 1995 solved that by nesting one repetition code inside another, one for each error type. Andrew Steane’s 7-qubit code did the same job more efficiently. The surface code, which dominates today’s roadmaps, arranges data qubits and ancillas alternately on a two-dimensional grid so that both check types are measured by nearest neighbours only, which is exactly what a chip can be fabricated to support.

Five properties that make a claim comparable

Once the mechanism is clear, the ambiguity in a headline number has a specific shape. Here are the five things worth extracting from any announcement before it enters a planning document.

Code distance

A logical qubit at distance 3 corrects one error per cycle. At distance 7 it corrects three. The difference in reliability between them isn’t a factor of three, it is exponential, and the difference in hardware cost is quadratic: a surface-code patch of distance d consumes 2d² − 1 physical qubits, so 17 at distance 3, 49 at distance 5, and 97 at distance 7.

A count of logical qubits with no distance attached is unpriced. 48 distance-3 logical qubits and 12 distance-12 logical qubits are different products, and the first number being larger says nothing about which machine is closer to running an algorithm.

Correction, or only detection

Some codes locate the error and repair it. Others only announce that an error occurred, without enough information to say where. Those are error-detecting codes, and the standard way to use one is postselection: run the circuit many times, throw away every run that raised a flag, and report statistics over the survivors.

Postselection is a legitimate research technique and it produces real physics. It doesn’t scale to long algorithms, because the fraction of runs that survive falls off exponentially with circuit depth. A computation deep enough to be useful would discard essentially every shot.

When Microsoft and Quantinuum reported 4 logical qubits built from 30 trapped ions in April 2024, with an error rate the two companies put at roughly 800 times better than the underlying physical qubits, the result was genuine and the method leaned on detection and discarded runs rather than full real-time correction. That distinction changes what the number predicts about a later, deeper circuit, which is the only reason to read a benchmark at all.

Break-even, and against which baseline

Break-even is the moment an encoded qubit outperforms the physical qubits it is made from. It sounds like a single threshold and it is actually a family of them, because the comparison needs a baseline and vendors choose different ones.

The demanding version compares the logical qubit against the best single physical qubit on the same device, under the same conditions, over the same duration. A weaker version compares against the device average, which is flattered by the calibration of the worst qubits. A weaker one still compares against a physical qubit measured on a different chip or on a different day.

Google’s Willow results, reported in Nature in December 2024 under the title “Quantum error correction below the surface code threshold”, used the demanding version. A distance-7 surface code patch, occupying most of the 105-qubit chip, held its encoded state longer than the best individual qubit on that chip by roughly a factor of two, on the paper’s own measurement. That’s a modest-sounding margin and it is the first time the field has had it at a code distance large enough to extrapolate from.

The suppression factor, not the single data point

The number to extract from a QEC result is not the logical error rate. It is the slope: how much the error rate improves when the code grows. Google labels this quantity lambda, defined as the factor by which logical error drops when code distance increases by two. Lambda above one means the code is below threshold, and errors are being removed faster than the extra hardware introduces them. Lambda below one means adding qubits makes things worse, which is what every experiment before roughly 2023 found.

The Nature paper reports a logical error of about 0.14% per correction round at distance 7, with lambda near 2.1.

Apologies in advance, this next part is arithmetic, and it is the arithmetic that decides how big these machines have to be.

Suppose lambda stays near 2.1 as the patch grows, which is an assumption rather than a measurement. Getting from 0.14% per round down to one error in a billion rounds means dividing by about 1.4 million. At lambda 2.1, that takes 19 doublings of protection, and each doubling costs two steps of distance, so distance rises by 38 to land near 45. A distance-45 patch takes just over 4,000 physical qubits, and that buys exactly one logical qubit.

Now improve the hardware so lambda reaches 3. The same target needs about 13 doublings, distance 33, and roughly 2,200 physical qubits. Halving the overhead didn’t come from a clever code. It came from better physical gates, because physical fidelity doesn’t reduce overhead linearly, it moves the exponent. This is why hardware teams keep grinding on gate error rates that already look impressive, and it is why a roadmap that improves lambda is more informative than one that adds qubits.

Memory, or computation

Most published logical qubit results are memory experiments. The encoded state is prepared, held through many rounds of correction, and measured. Holding a state is necessary and it isn’t computing.

Computing requires logical gates, and the codes make some easy and others expensive. A transversal gate applies the same simple operation to every physical qubit in a patch and produces the corresponding operation on the logical qubit, which is cheap and inherently fault-tolerant. Lattice surgery merges two surface-code patches along an edge and splits them again, which is how a logical CNOT is usually built on a 2D grid. Neither technique gives you the full gate set. Surface codes can’t perform the non-Clifford T gate, roughly speaking the operation that lets a quantum computer do anything a classical one cannot simulate efficiently, by any transversal route.

The standard workaround is magic state distillation: prepare many low-quality copies of a special resource state, run error detection across them, and consume the batch to yield a smaller number of high-quality copies. In full resource estimates for algorithms like Shor’s, the distillation factories consume the majority of the physical qubits and a large share of the runtime. Color codes, a related family of two-dimensional topological codes, allow more direct access to the T gate and pay for it with a lower error threshold, meaning they demand cleaner physical hardware before they work at all.

One more thing belongs in this bucket. Ask whether the decoder ran in real time. Syndrome rounds on superconducting hardware complete about once per microsecond, and if classical decoding is slower than syndrome generation, the backlog grows without bound and the machine can’t make a decision that depends on a measurement result. Real-time decoding at scale is an open engineering problem with dedicated hardware being built for it.

Why the physical-to-logical ratio varies by a factor of 100

Two vendors quoting 1,000 physical qubits per logical qubit and 25 physical qubits per logical qubit can both be telling the truth, because they aren’t building the same object. The families differ in what they trade away.

Surface codes need only nearest-neighbour interactions on a flat grid, and they tolerate physical error rates up to around 1%, the highest threshold of any practical code. That combination is why they anchor most roadmaps: the connectivity requirement matches what chip fabrication naturally produces, and the threshold matches what the best hardware already achieves. The cost is the 2d² − 1 scaling, which becomes brutal at the distances real algorithms need.

Concatenated codes encode a qubit inside a code, then treat that as a qubit and encode it again. Each layer multiplies protection and multiplies qubit count. They need long-range interactions to extract syndromes, which suits trapped-ion systems where any pair of ions can be made to interact, and suits fixed 2D chips badly.

qLDPC codes, meaning quantum low-density parity-check codes, keep checks sparse while abandoning strict planarity. IBM’s bivariate bicycle construction, published in 2024, encodes 12 logical qubits at distance 12 into 288 physical qubits, about 24 physical qubits per logical qubit. A surface code reaching distance 12 would need roughly 287 physical qubits for a single logical qubit, so the saving is close to a factor of 10. The price is connectivity: each qubit needs six couplers, several of them reaching beyond its immediate neighbours, and performing logical gates inside these codes is harder than lattice surgery.

Bosonic codes take a different route entirely, encoding a qubit in the many energy levels of a single oscillator such as a microwave cavity, rather than across many two-level systems. Cat codes store information in superpositions of coherent light states and suppress bit flips so strongly that the remaining errors are almost all of one type, which a simple outer code can then handle. The GKP code, named for Daniel Gottesman, Alexei Kitaev and John Preskill, encodes a qubit in a grid pattern in the oscillator’s phase space and corrects the small drifts that dominate real cavities. A Yale team pushed a GKP qubit past break-even in 2023, and AWS’s Ocelot chip in 2025 stacked a repetition code on top of cat qubits and showed the larger code narrowly beating the smaller. Bosonic approaches can be dramatically more hardware-efficient per logical qubit, and they demand exceptional cavity quality plus a workable way to entangle one encoded qubit with another.

So the ratio describes which trade the team made, not the team’s engineering skill, and comparing ratios across families without naming the family produces nonsense.

What the numbers do to a planning horizon

The clearest illustration of why physical qubit counts are unstable planning inputs comes from cryptanalysis estimates. In 2019 Craig Gidney and Martin Ekerå estimated that factoring a 2048-bit RSA key would take about 20 million noisy physical qubits running for eight hours. In 2025 Gidney published a revised estimate: fewer than one million noisy qubits, running for under a week.

Nothing about that 20-fold reduction came from hardware. It came from better algorithms, better error-correction layouts, and cheaper magic state production. The target didn’t move and the requirement did, in the direction that shortens timelines.

Against that, current hardware sits at 105 qubits on Willow and 1,121 on IBM’s Condor, and the gap to a million is the reason nobody is factoring anything. IBM has said its Starling machine, targeted for 2029, will carry 200 logical qubits and execute 100 million logical gates. Treat any such date as a statement of intent rather than a schedule, and treat the shape of the roadmap as the useful part: which code family, what lambda, what gate set, what decoder.

For anyone planning cryptographic migration, the operational conclusion is unglamorous. The hardware forecast is not a stable input, and it has revised in one direction for six consecutive years. Migration sequencing should be driven by how long your data must stay confidential and by the compliance deadlines already published, not by a qubit count that changes every time somebody improves a distillation factory.

A roadmap quoted purely in physical qubit counts is a marketing document; one quoting code distance, suppression factor, logical gate support and decoder latency is an engineering document. The second kind is rarer and it is the only kind worth putting in a board pack.

Reading the next announcement

The next logical qubit result will arrive with a large number in the headline. Five questions turn it into something you can compare against the last one.

• What is the code distance, and what is the code family? Without both, the physical qubit cost is unknown and the reliability is unknown.
• Were errors corrected, or detected and discarded? Postselected results don’t extrapolate to deep circuits.
• Break-even against what baseline? Best physical qubit on the same device, same conditions, same duration, or something softer.
• What is the suppression factor across at least two distances? One data point is a demonstration. Two are a trend, and the trend is the thing that predicts the machine.
• Did the logical qubits compute, and did the decoder keep up? Memory results and gate results are different milestones.

None of these require a physics degree to ask, and each one is a routine question in any other engineering discipline. We ask them because the field has now produced enough genuine results that separating them from the packaging is a working skill rather than a hobby.

Where to go deeper

Error correction is the material that separates people who can read a quantum roadmap from people who can only repeat one. Quantum Academy’s certification program for quantum technology professionals covers this in a dedicated module, working through stabilizer measurement, code distance and the overhead arithmetic with exercises rather than diagrams, and then applying the same five criteria to real published results. Program details and enrollment are at quantumacademy.com/.

For deeper background on the cryptographic side of all this, and on what a working quantum computer would mean for deployed encryption, PostQuantum.com carries longer treatments. For the migration side of the question, where the answer depends on your data retention obligations rather than on anyone’s qubit count, the methodology at pqcframework.org is the better starting point.