The unit the whole field switched to counting while few people were watching, and the reason "1,000 qubits!" is a number you should learn to distrust.
You'll be able to work out how many physical qubits one logical qubit costs at a given error rate.
A logical qubit is one trustworthy qubit built from many untrustworthy ones, bound together by error correction so the group catches its own mistakes. The exchange rate is brutal and set almost entirely by hardware quality: a noisy machine spends thousands of physical qubits per logical one; a clean machine, a few hundred. That gap is why a serious scoreboard counts logical qubits, not raw ones.
Two companies stand on stage. One shouts "a thousand qubits!" The other says, quietly, "fifty." Serious people lean toward the fifty. Here's why that isn't contrarian for its own sake.
A raw physical qubit is a single fragile piece of hardware. It's fast to build, and it fails constantly, roughly once every few hundred to few thousand operations on good hardware. You cannot run a real algorithm on qubits that forget what they're doing that often. So you don't use them one at a time. You gang many of them together and have them watch each other, catching and fixing errors faster than the errors pile up. That bound-together, self-correcting group behaves like a single, far more reliable qubit: a logical qubit. It's the difference between one nervous witness and a jury that cross-checks its own testimony.
The catch is the price. Turning noisy physical qubits into one dependable logical qubit can cost anywhere from a few hundred to several thousand of them, and the exact number is decided mostly by how good your hardware already is, not by how many qubits you own. A company with 1,000 sloppy qubits might field only a handful of logical ones. A company with 50 excellent qubits might field a couple, for a twentieth of the hardware. Scale up the clean machine and it runs away from the sloppy one; that is why our scoreboard tracks what a machine can do rather than what it can count.
Around 2024–25 the whole field made this switch official. Once experiments proved error correction works (the below-threshold result), the meaningful question stopped being "how many qubits do you have?" and became "how many error-corrected qubits can you keep alive?" A machine's logical-qubit count is its real size.
WorkingA surface-code logical qubit lives on a patch of ≈2d² physical qubits, where d is the code distance: bigger d, longer error chains needed to fool it, safer the logical qubit. So the whole game is: what's the smallest d that makes my logical qubit reliable enough?, because d² is what you pay.
That's set by one ratio: your physical error rate over the code's threshold, p/pth. Below threshold (ratio < 1), each step up in code distance (d→d+2, the next usable odd distance) multiplies your reliability by the same factor; the further below, the bigger that factor, and the smaller the d you need. The logical error rate goes roughly as
Read that exponent: a machine at p/pth = 1/2 barely improves per distance step and needs a huge patch; a machine at 1/20 slashes its error rate every step and needs a tiny one. That is the case for quality-first roadmaps, and the calculator below lets you feel how violently error rate beats raw qubit count.
← swipe the diagram to see all of it →
This is the exact model derived at Basics, Formal tier. Pick a hardware quality and a chip size; it solves for the smallest code distance that hits your reliability target, then divides.
Reliability target (logical error rate):
Or drop in the two machines from the Formal worked example below:
Toy model: pL ≈ (p/pth)^⌊(d+1)/2⌋; smallest odd code distance d meeting the target; surface-code patch ≈ 2d² physical qubits per logical; logical count floored. Ignores routing, magic-state factories, and per-patch overhead (which for real computation can rival or exceed the data-patch cost), so a working machine fields materially fewer. Trust the exchange-rate shape here more than the count.
Take two machines and run them to a pL ≤ 10⁻⁹ target under the surface-code model above.
Machine A: 10⁵ physical qubits at p/pth = 1/2. Need (1/2)⌊(d+1)/2⌋ ≤ 10⁻⁹ → ⌊(d+1)/2⌋ ≥ 9/log₁₀2 ≈ 29.9 → 30 → d ≥ 59. Patch ≈ 2·59² = 6,962 physical/logical → 10⁵ / 6,962 ≈ 14 logical qubits.
Machine B: 10⁴ physical qubits at p/pth = 1/20 (a tenth the hardware, but far cleaner). Need (1/20)⌊(d+1)/2⌋ ≤ 10⁻⁹ → ⌊(d+1)/2⌋ ≥ 9/log₁₀20 ≈ 6.9 → 7 → d ≥ 13. Patch ≈ 2·13² = 338 physical/logical → 10⁴ / 338 ≈ 29 logical qubits.
B wins, 29 to 14, with 10× fewer physical qubits. The exponent ⌊(d+1)/2⌋ is where the leverage lives: cleaner hardware doesn't just shave the patch, it shrinks the distance you need in the first place, and you pay for distance squared. Error rate beats scale, and it isn't close. This is the whole case for spending your next engineering dollar on fidelity (much of it bought by AI-driven calibration and decoding) rather than on more noisy qubits.
The same arithmetic is why cryptographic targets look so expensive: push the target to 10⁻¹² or below and every machine's required d jumps, the patches balloon, and the logical count collapses, which is exactly the multiplier behind the "half a million physical qubits to break a key" headline.
Check yourself
Machine A runs at p/pth = 1/2 and needs d = 59. Machine B runs at 1/20 and needs d = 13. B has ten times fewer physical qubits. Which fits more logical qubits?
A patch costs ~2d² physical qubits, and d is driven by how far below threshold you are, so error rate beats raw size, badly. B fits 29 logical qubits to A’s 14 while holding a tenth of the hardware, and the calculator above reproduces it exactly. It is also why "1,000 qubits!" is the wrong headline.
The error-correction machinery a logical qubit is built from, with a code you can break yourself.
Quantum error correction →Who's fielding the most logical qubits: the scoreboard that counts the number that matters.
Scoreboard →