Why a 1,000-Qubit Computer Has Zero Usable Qubits

Two numbers get quoted in the same breath and they are not in the same units. A chip is announced with a thousand qubits. An algorithm is said to need four thousand. It sounds like we are one generation away.

We are not, and the reason is an exchange rate that almost never appears next to either figure. At the error rates hardware currently achieves, one usable qubit costs about 1,681 of the physical kind. A thousand-qubit machine therefore holds zero of them.

Two currencies, one word

A physical qubit is a thing on a chip. It is noisy: it drifts, it flips, it loses its state within a fraction of a second. Left alone it is useless for a calculation of any length.

A logical qubit is an abstraction built out of many physical ones, arranged so that errors in the parts can be detected and corrected faster than they accumulate. Algorithms are written in logical qubits. Press releases count physical ones. The word is the same and the quantity is not, which is how the two figures end up side by side in the same paragraph.

The dominant scheme for building one from the other is the surface code, and its arithmetic is simple enough to put on one line. At code distance d, one logical qubit costs 2d² − 1 physical qubits, and the logical error rate falls roughly as the physical error rate divided by a threshold, raised to the power (d+1)/2.

That formula is a published model, not something we measured. What we did is turn the handle on it.

Turning the handle

Given a physical error rate the hardware can plausibly hit and a logical error rate the calculation needs, you can solve for the smallest code distance that gets you there and read off what it costs.

The last row is the hopeful one and it is worth dwelling on. Improving the hardware by a factor of ten — from one error in a thousand operations to one in ten thousand — cuts the cost of a logical qubit from 1,681 physical qubits to 449. Nearly a four-fold saving, from a ten-fold improvement.

The leverage in this field is error rate rather than headcount. A chip with ten times fewer errors buys roughly what a chip with four times more qubits would, and only one of those two numbers tends to get announced.

What a headline number actually buys

Running the same arithmetic backwards makes the press releases legible. Take a machine of a given physical size and ask how many logical qubits it holds, at the error rate hardware currently reaches.

At a demanding error target, a machine of 1,000 physical qubits holds 0 logical qubits. Five thousand holds 2. A hundred thousand holds 59. A million holds 594.

Set that against the requirement for breaking RSA-2048, which published estimates put at millions of physical qubits — the figure we quote in our guide on what Shor's algorithm actually breaks. The gap between announced machines and that requirement is not one generation. It is several orders of magnitude, and the arithmetic above is why.

The threshold, and why more qubits can make things worse

A number buried in that formula, the threshold, is the reason error correction works at all-or fails entirely.

The expression compares the physical error rate to a threshold, roughly 1% for the surface code. If the hardware is below the threshold, raising the code distance drives the logical error rate down, and it does so fast: every two steps of distance buys another factor of improvement. Spend more qubits, get a better qubit.

If the hardware is above the threshold, the sign flips. The correction machinery introduces errors faster than it removes them, and raising the code distance makes the logical qubit worse. Spending more physical qubits actively harms you.

So there is no smooth trade-off between hardware quality and hardware quantity. Below the line, quantity substitutes for quality at a punishing but workable rate. Above it, no quantity is enough. That is why "how many qubits" is such a poor summary of a machine, and why the error rate — a number that rarely makes a headline — is the one that decides whether a device is on the useful side of a cliff.

Three honest caveats

This is a model, and it has edges. Three of them matter.

The threshold and the prefactor we used — a 1% threshold and a prefactor of 0.1 — are standard but approximate. Change them and every number on this page moves. That is exactly why we swept two physical error rates instead of publishing one column and calling it the answer.

The surface code is the most studied scheme, not the only one. Codes with better rates exist on paper, and if one of them becomes practical the exchange rate improves, possibly a great deal. Nothing here says 1,681 is a law of nature; it is what today's leading approach costs under today's assumptions.

And the count of qubits is not the whole cost. A real calculation also needs time, and the operations that surface codes find expensive are not evenly distributed across an algorithm. A machine with enough logical qubits can still be too slow. Our figures bound the size question only, which is the one that gets misreported most.

Doing the arithmetic yourself

None of this needs specialist tooling. The cost is a squaring and a subtraction — a code distance of 29 gives 2 × 29² − 1 = 1,681 on any scientific calculator — while running it backwards, from a target error rate to the distance it demands, is a job for logarithms.

Comparing two announcements honestly means dividing rather than subtracting: 1,681 physical qubits per logical one down to 449 is a 73% reduction, which describes progress far better than a raw qubit count.

If the underlying idea of what these qubits are is still hazy, the companion guide on what a qubit really is builds one from four numbers and no jargon.

This guide applies published error-correction models to illustrate scale. It is educational and is not procurement or engineering advice.