Eleven Orders of Magnitude
Why the road to a trillion-operation quantum computer is not a qubit-counting problem, and why nobody who tells you a date is doing physics
Abstract. Public discussion of quantum computing timelines is dominated by qubit counts, which are close to irrelevant to the question that actually matters. If a “minimum useful system” is one capable of roughly 10¹² logical gate or error opportunities while keeping total failure probability acceptably low, then the requirement is a per-operation logical error rate below about 10⁻¹⁴. The strongest published full surface-code memory result stands at 1.43 × 10⁻³ per cycle at distance 7, and the strongest end-to-end fault-tolerant algorithm demonstration reports a logical T-gate infidelity near 2.6 × 10⁻³ at distance 3, described by its own authors as near break-even. The gap is therefore approximately eleven orders of magnitude in logical reliability, not a factor of a billion in calendar time. This essay works the arithmetic explicitly: it derives the reliability requirement, extrapolates the measured suppression factor Λ = 2.14 to find the code distance implied, converts that distance into physical qubits, and then argues that the extrapolation is not merely optimistic but structurally unsound, because the same experiment that supplies Λ also reports a correlated-error floor near 10⁻¹⁰ — four orders of magnitude above the target, and intercepting the extrapolation at a distance around 50. I set out the counter-case honestly, including the strong argument that Λ is not a constant and that low-density parity-check codes may change the overhead scaling entirely. The conclusion is not that fault-tolerant quantum computing is impossible. It is that the remaining problem is a reliability problem with an unquantified floor, that calendar estimates below several decades are currently speculation rather than physics, and that the honest position is to name the falsifiable markers that would move the estimate rather than to name a year.
Keywords: quantum error correction; surface code; fault tolerance; logical error rate; code distance; magic state distillation; correlated errors; quantum computing timelines; threshold theorem; physical qubit overhead
The wrong number is on the poster
Every few months a press release announces a new record qubit count, and every few months the public conversation treats this as the relevant progress metric. It is not. A quantum computer with ten million qubits that cannot maintain a logical state through a long computation is a very expensive refrigerator.
The number that matters is the product of logical reliability and computational depth. And when you state the problem in those terms, the distance between where we are and where a useful machine would have to be turns out to be enormous, precisely quantifiable, and almost entirely absent from the public discussion.
Let me define the target. Suppose by a “10¹² minimum system” we mean a machine capable of roughly 10¹² logical gate or error opportunities while keeping total failure probability acceptably low. That is not an arbitrary figure. It is roughly the scale at which quantum algorithms start doing things classical machines cannot, and it is the regime assumed in essentially every serious resource estimate for commercially interesting problems.
The gap from today’s demonstrations at the 10³ scale to that target is not a factor of a billion in calendar time. It is a factor of roughly a billion — and rather more — in required logical reliability-depth product. Those are entirely different claims, and conflating them is the single most common error in quantum computing commentary.
The arithmetic of depth
Start with the requirement. For a computation with G logical error opportunities, each failing independently with probability p_L, the expected number of logical failures is approximately G × p_L. To first order, the probability that the whole computation survives requires
p_L ≪ ε / G
where ε is the total failure probability you are willing to tolerate.
Set G = 10¹² and demand total failure below 1%, so ε = 10⁻². Then
p_L ≪ 10⁻² / 10¹² = 10⁻¹⁴
That is the relevant order of magnitude. Not 10⁻⁶. Not 10⁻⁹. Fourteen orders of magnitude below unity, per logical operation, sustained across a trillion operations.
Note the structure of this requirement, because it is what makes quantum computing hard in a way that classical computing is not. In a classical machine, the physical error rate per gate is already somewhere below 10⁻¹⁵ through sheer energy-scale brute force — a classical bit is encoded in a very large number of electrons, and thermal noise simply does not flip it. Quantum information cannot be protected that way, because the states that carry it are fragile superpositions that no-cloning forbids you from simply copying. The entire apparatus of quantum error correction exists to manufacture, at enormous overhead, the reliability that classical hardware gets for free.
Where the hardware actually is
The strongest published full surface-code memory result comes from Google Quantum AI’s Willow processor. They report a logical error rate of 0.143% ± 0.003% per cycle of error correction, in a 101-qubit distance-7 code — that is,
p_L ≈ 1.43 × 10⁻³ per QEC cycle
and, critically, they report that this rate is suppressed by a factor of
Λ = 2.14 ± 0.02
for each increase of code distance by two. That Λ > 1 is the whole achievement: it is the experimental demonstration of operating below the surface code threshold, where adding qubits makes things better rather than worse. It is a genuine and important result and I do not want to diminish it.
But note what it is. It is a memory result. It demonstrates that a logical qubit can be stored, idle, better than its constituent physical qubits. It exceeds break-even by a factor of 2.4 ± 0.3 relative to the best physical qubit’s lifetime.
Computation is harder than memory. For that, look at the strongest end-to-end fault-tolerant algorithm demonstration: Perlin and colleagues, in March 2026, executed the Quantum Approximate Optimization Algorithm and the Harrow-Hassidim-Lloyd algorithm on Quantinuum’s H2 and Helios trapped-ion processors, using the [[7,1,3]] Steane code — that is, distance 3. The result is enabled by a fault-tolerant logical T-gate implementation with an infidelity of approximately
2.6(4) × 10⁻³
and the authors describe the achievement, accurately and admirably, as demonstrating near-break-even performance of complex error-corrected algorithmic circuits using only fault-tolerant components.
Near break-even. That is the frontier of algorithmic fault tolerance in 2026: circuits with up to 8 logical qubits and 9 logical T gates performing similarly to their unencoded equivalents.
The gap, stated plainly
Now put the numbers together. Ignoring every additional problem — logical gates, non-Clifford operations, routing, correlated noise, decoding latency, algorithmic composition — and comparing only the memory result to the requirement:
(1.43 × 10⁻³) / (10⁻¹⁴) ≈ 1.4 × 10¹¹
That is about eleven orders of magnitude in logical error rate.
Show Image
Figure 1. Measured logical error rates compared with the requirement implied by p_L ≪ ε/G for a trillion-operation computation. The gap between the best surface-code memory result and the target spans roughly eleven orders of magnitude. Sources: Google Quantum AI, Nature 638, 920 (2025); Perlin et al., arXiv:2603.04584 (2026).
And the algorithmic picture is worse than that comparison suggests, because the 1.43 × 10⁻³ figure describes an idle memory. If you take the logical T-gate infidelity of 2.6 × 10⁻³ as an illustrative operation-level error scale, then for 10¹² such opportunities the naive expected number of logical errors is
10¹² × 2.6 × 10⁻³ = 2.6 × 10⁹
You need that quantity to be much less than one. It is currently two and a half billion. The crude reliability improvement required is therefore of order
10¹¹ to 10¹²
This is the number that should be on the poster.
What the suppression factor buys you
The natural response is that error correction is exponential, and exponentials are patient. So let us take that seriously and run it.
If Λ = 2.14 remained constant all the way up — a fantastically optimistic assumption I will demolish shortly — then the number of distance-two increments n needed to take 1.43 × 10⁻³ down to 10⁻¹⁴ satisfies
2.14ⁿ ≈ 1.43 × 10¹¹
Taking logarithms,
n = ln(1.43 × 10¹¹) / ln(2.14) = 25.69 / 0.761 ≈ 33.8
so n ≈ 34. Each step raises the distance by two, so starting from d = 7:
d ≈ 7 + 2 × 34 = 75
That is an extraordinarily crude extrapolation, but it establishes the scale of the problem: an effective code distance of order 70 to 80, under the assumption that the presently measured suppression factor continues unchanged for thirty-four consecutive doublings-and-then-some of protection.
Show Image
Figure 2. Logical error per cycle extrapolated from the measured d = 7 result at Λ = 2.14, against the requirement for a trillion-operation computation. The shaded band marks the correlated-error floor of approximately 10⁻¹⁰ reported in the same experiment. Note where the extrapolation meets it.
From distance to hardware
Code distance is an abstraction. Physical qubits are a budget line.
The rotated surface code requires 2d² − 1 physical qubits per logical qubit, counting data and measure qubits. At d = 75:
2 × 75² − 1 = 11,249 physical qubits per logical qubit
You can arrive at essentially the same figure from the experimental side. Google’s d = 7 memory used 101 physical qubits. The area ratio from d = 7 to d = 75 is
(75 / 7)² ≈ 115
and therefore
101 × 115 ≈ 11,600 physical qubits
The two estimates agree to within 3%, which is reassuring for an argument this crude. Call it eleven to twelve thousand physical qubits for one strongly protected logical qubit — before adding magic-state factories, routing space, logical ancillas, spare capacity for defective qubits, and system-level overhead.
Ten such logical qubits would already put you at order 10⁵ physical qubits for the protected data alone. And ten logical qubits does not run an interesting algorithm. A serious trillion-operation computation could require far more, because non-Clifford resource production frequently dominates the machine rather than the data.
The other clock
There is a second budget that qubit counts obscure entirely, and it is worth doing the arithmetic because it closes the loop on everything above.
Surface-code operations are not instantaneous. A logical operation implemented by lattice surgery takes on the order of d rounds of syndrome extraction. Willow reports a cycle time of 1.1 μs. So at d = 75, one logical operation costs roughly
75 × 1.1 μs ≈ 82.5 μs
If a trillion logical operations were executed strictly one after another, the wall-clock time would be
10¹² × 82.5 μs = 8.25 × 10⁷ s ≈ 2.6 years
Nobody proposes to run a computation serially, of course. Quantum circuits have width as well as depth, and operations on disjoint logical qubits proceed in parallel. But this is exactly the point: the parallelism is not free, because it must be purchased in hardware. If your algorithm has a serial depth of 10⁹ layers and a width of 10³ logical operations per layer, you need roughly a thousand logical qubits simultaneously live and protected. At 11,249 physical qubits apiece, that is
10³ × 11,249 ≈ 1.1 × 10⁷ physical qubits
Eleven million. And notice where that lands. Gidney and Ekerå’s 2019 estimate for factoring a 2048-bit RSA integer — derived by an entirely different route, from actual circuit synthesis rather than my crude scaling — came out at 20 million noisy qubits. My bottom-up figure reproduces the published number to within a factor of two, which is about as much agreement as an argument this rough deserves and rather more than I expected.
There is one further timing constraint that parallelism cannot dissolve. Non-Clifford gates implemented by state injection require a measurement, a classical decision, and a conditional correction before the next dependent operation can proceed. That round trip is the control system’s reaction time, assumed at 10 microseconds in both Gidney resource estimates. Serial T-depth multiplied by reaction time is a hard floor on runtime that no amount of additional hardware removes. A computation with 10⁹ sequential T layers costs at least 10⁴ seconds — a few hours — before any other consideration.
So the picture is consistent across all three budgets. Reliability demands roughly 10⁻¹⁴. Distance demands roughly 75. Space demands roughly 10⁷ physical qubits for a genuinely useful width. Time demands hours to days even when everything works. These are not independent constraints that might each turn out to be optimistic. They are three projections of the same underlying requirement, and they agree with each other and with the published literature.
The floor that nobody quotes
Here is the part of the Willow paper that receives less attention than Λ, and which I think is the most important number in it.
To probe the limits of their error correction, the Google team ran repetition codes up to distance 29. They found that logical performance was not limited by the exponential suppression at all. It was limited by rare correlated error events occurring roughly once an hour — approximately every 3 × 10⁹ cycles — whose origins, in the authors’ own words, are not yet understood. These events set a current error floor of
10⁻¹⁰ in the repetition code
Sit with that. The target is 10⁻¹⁴. The observed floor is 10⁻¹⁰. The floor is four orders of magnitude above the requirement, and it is not a floor that more distance fixes, because it arises from a mechanism that correlates errors across the code and thereby defeats the assumption on which distance-based suppression rests.
Now overlay this on the extrapolation. The curve from 1.43 × 10⁻³ at Λ = 2.14 reaches 10⁻¹⁰ at
d = 7 + 2 × ln(1.43 × 10⁷)/ln(2.14) ≈ 7 + 2 × 21.7 ≈ 50
So on the experiment’s own numbers, the extrapolation runs into the observed floor at a distance around 50, well before the distance around 75 that the target requires. The comfortable exponential does not carry you to the destination. It carries you into a wall of unexplained physics at roughly two-thirds of the way there.
This is not a reason to despair. Repetition codes are not surface codes, and floors observed in one setting need not transfer. Cosmic rays and other correlated mechanisms are areas of active mitigation research. But it is decisive against the claim that we can simply extrapolate. The single most important open question in the field is not how to add qubits. It is what that floor is made of, and whether it can be removed.
What memory does not buy you
Even setting the floor aside, the distance-75 figure addresses only memory-like logical failure. Real computation requires considerably more, and none of it is free.
Logical entangling gates. Two-qubit logical operations, whether by lattice surgery or transversal gates, consume space and time and introduce their own error channels. The demonstrated gate fidelities lag memory fidelities.
Non-Clifford operations. This is the deep one. The Eastin-Knill theorem forbids a transversal universal gate set, so the surface code cannot implement T gates directly. You must produce magic states through distillation or cultivation, and magic-state factories historically dominate the footprint of resource estimates. A machine’s qubit budget is often mostly factory.
Decoding. Syndrome data must be processed faster than it accumulates, or the decoder falls behind and the backlog grows without bound. Google reports an average decoder latency of 63 μs at distance 5 against a cycle time of 1.1 μs — a workable ratio at that scale, achieved with real effort. Decoding complexity grows with distance, and at distance 75 the real-time decoding problem is a serious open engineering question in its own right.
Routing, ancillas, leakage, and fabrication yield. Each is a multiplier. None is captured in 2d² − 1.
Current algorithm experiments are nowhere near demonstrating that these preserve comparable suppression at scale. The Steane-code work operates at distance 3 with nine logical T gates. Between that and a fault-tolerant machine executing 10¹² operations there is not a gap in degree. There is a gap in kind.
The honest counter-case
I have made the pessimistic argument as strongly as the evidence supports. Intellectual honesty requires making the other case at least as carefully, because there are five real objections and one of them is very strong indeed.
One: Λ is not a constant, and this is the serious objection. Surface-code theory gives the logical error rate as roughly p_L ≈ A(p/p_th)^⌊(d+1)/2⌋, where p is the physical error rate and p_th the threshold. The suppression factor Λ is approximately p_th/p. Willow’s Λ = 2.14 therefore reflects operating at roughly half the threshold error rate. Improve physical fidelities by a factor of two relative to threshold and Λ roughly doubles — and because Λ enters the exponent, the effect on required distance is dramatic:
Λdistance-two steps to reach 10⁻¹⁴implied distance dphysical qubits (2d² − 1)2.14 (measured)347511,249324556,049419454,049516393,041
Getting Λ from 2.14 to 4 — which requires roughly halving physical error rates, an aggressive but not fantastical target — reduces the per-logical-qubit footprint by a factor of nearly three. Anyone quoting my distance-75 figure as a fixed prediction has misunderstood it. It is a statement about today’s suppression factor, and the strongest reason for optimism in the field is that this factor is itself a moving target.
Two: the surface code may not be the right code. Bravyi and colleagues demonstrated high-threshold, low-overhead quantum LDPC memory codes achieving comparable protection with dramatically fewer physical qubits than the surface code requires. If qLDPC architectures become practical, the 2d² − 1 scaling I have used is simply the wrong cost model, and the overhead figures fall substantially.
Three: resource estimates have been falling fast. In 2019 Gidney and Ekerå estimated that factoring a 2048-bit RSA integer would take eight hours on a machine with 20 million noisy qubits. In 2025 Gidney revised this to under a week with fewer than one million noisy qubits — a twentyfold reduction in six years, achieved through algorithmic improvement and better magic-state handling, not better hardware. Algorithmic overhead is not a constant of nature, and the trend has consistently been downward.
Four: G may be smaller than 10¹². The trillion-operation figure is a reasonable benchmark for cryptographically relevant computation, but useful quantum advantage in chemistry or materials simulation might arrive at considerably lower depth. Every order of magnitude off G is an order of magnitude off the reliability requirement.
Five: my error model is deliberately crude. Treating failures as independent and taking the union bound is conservative. Correlated decoding and algorithm-specific error structure can do better than G × p_L.
Take those together and the pessimistic case weakens considerably in overhead terms. What it does not weaken in is the reliability dimension, which is the point of this essay. Every one of those five objections changes the constant, the code, or the exponent. None of them removes the requirement that per-operation logical failure land somewhere near 10⁻¹⁴, and none of them explains the correlated-error floor.
Why calendar estimates are not physics
There is no scientifically defensible linear extrapolation from these results to a date, and I want to be precise about why.
Quantum error correction progress is not an annual Moore’s-law quantity. Moore’s law described a manufacturing process with a stable economic feedback loop and a well-understood scaling parameter. Below-threshold operation at distance 7 was crossed recently; algorithmic work remains at distance 3 and near break-even. There is no established cadence to extrapolate.
If you nevertheless force a crude extrapolation on the observed distance progression, the answer is not “a few years.” Going from demonstrated distance-7 memory to something resembling effective distance-75 computational protection requires roughly 34 additional successful distance-two scaling steps, while simultaneously solving logical gates, decoding at scale, correlated noise, leakage, fabrication yield and non-Clifford resource production.
At an implausibly aggressive rate of one genuinely validated distance-two improvement per year, that is about three decades. At one step every two years, roughly seven decades.
And those figures assume the suppression factor does not deteriorate, that physical error rates improve sufficiently, that correlated-error floors do not intervene, and that logical gates scale as cleanly as memory does. The Willow repetition-code result shows precisely why simple exponential extrapolation eventually encounters new error mechanisms — mechanisms that were invisible until the experiment got good enough to see them, and which will presumably be joined by others as it gets better still.
I want to be careful here. I am not predicting three decades, or seven. I am saying that the extrapolation which produces those numbers is the only quantitative one available, that it rests on assumptions I have just spent a section dismantling, and that anyone offering a shorter figure is either using a different definition of the target or is not showing their arithmetic. Given the Λ sensitivity in the table above, a substantially faster path exists if physical fidelities improve faster than expected. That is a real possibility. It is not a forecast.
What would change my mind
An argument that cannot be falsified is not worth making. Here are the markers I would watch, in rough order of significance:
The floor is explained and removed. If the correlated error events limiting repetition codes at 10⁻¹⁰ are identified and mitigated, the single largest unquantified risk in the extrapolation disappears. This is the one to watch.
Λ improves materially above 3. Demonstrated suppression factors well above the current 2.14, sustained at higher distances, would compress the distance requirement and the qubit budget substantially, as the table shows.
Logical gate fidelities track memory fidelities at increasing distance. Presently they do not. If two-qubit logical gates and non-Clifford operations show the same exponential suppression with distance that memory does, the gap becomes a scaling problem rather than a research problem.
Magic-state production stops dominating. Magic-state cultivation and similar techniques are already reducing this overhead. If factories cease to be the majority of the machine, resource estimates fall again.
qLDPC codes reach hardware maturity. A demonstrated low-overhead code operating below threshold on real hardware at competitive distances would invalidate the 2d² − 1 cost model entirely.
Any two of these would move my estimate by a decade. None of them has happened yet.
Conclusion
For a genuine 10¹²-operation logical system, the defensible position is this. We are not getting from 10³ to 10¹² by making the current experiment bigger. We need roughly eleven additional orders of magnitude of algorithm-level logical reliability. Under an optimistic continuation of today’s best measured suppression, that corresponds to an effective code distance of order 70 to 80, something like ten thousand physical qubits per strongly protected logical qubit, and several engineering layers that have not been demonstrated at anything approaching that scale.
The extrapolation that produces those numbers is also, on the experiment’s own evidence, intercepted by an unexplained error floor at around two-thirds of the required distance.
None of this says fault-tolerant quantum computing will not happen. Below-threshold operation is a real threshold crossed, in the strict sense that the exponential now runs in the right direction. That is the hard part of the physics, and it is done. What remains is the enormous part of the engineering, plus at least one piece of unfinished physics in the form of the correlated-error floor.
What it does say is that qubit counts are the wrong metric, that the interesting quantity is reliability-depth, and that a calendar estimate below several decades is presently speculation rather than physics. If someone gives you a date, ask them for their value of Λ, their target G, their assumed logical error rate, and their explanation of the floor. If they cannot supply all four, they are not making a technical claim. They are making a marketing one.
References and further reading
Google Quantum AI and Collaborators (2025). Quantum error correction below the surface code threshold. Nature 638(8052), 920–926. — The distance-7 below-threshold memory result, Λ = 2.14, and the repetition-code correlated-error floor. arXiv:2408.13687 · Nature
Perlin, M. A., He, Z., Alexiades Armenakas, A., Andres-Martinez, P., Hao, T., Herman, D., Jin, Y., Mayer, K., Self, C., Amaro, D., Ryan-Anderson, C., & Shaydulin, R. (2026). Fault-tolerant execution of error-corrected quantum algorithms. — QAOA and HHL executed with only fault-tolerant components on the [[7,1,3]] Steane code; logical T-gate infidelity ≈ 2.6(4) × 10⁻³. arXiv:2603.04584
Bravyi, S., Cross, A. W., Gambetta, J. M., Maslov, D., Rall, P., & Yoder, T. J. (2024). High-threshold and low-overhead fault-tolerant quantum memory. Nature 627(8005), 778–782. — The qLDPC alternative to surface-code overhead scaling. arXiv:2308.07915
Gidney, C. (2025). How to factor 2048 bit RSA integers with less than a million noisy qubits. — The twentyfold reduction in estimated resources for RSA-2048. arXiv:2505.15917
Gidney, C., & Ekerå, M. (2021). How to factor 2048 bit RSA integers in 8 hours using 20 million noisy qubits. Quantum 5, 433. — The earlier benchmark estimate. arXiv:1905.09749
Fowler, A. G., Mariantoni, M., Martinis, J. M., & Cleland, A. N. (2012). Surface codes: Towards practical large-scale quantum computation. Physical Review A 86, 032324. — The standard reference for surface-code scaling and the 2d² − 1 overhead. arXiv:1208.0928
Bravyi, S., & Kitaev, A. (2005). Universal quantum computation with ideal Clifford gates and noisy ancillas. Physical Review A 71, 022316. — The origin of magic-state distillation. arXiv:quant-ph/0403025
Google Quantum AI (2023). Suppressing quantum errors by scaling a surface code logical qubit. Nature 614(7949), 676–681. — The predecessor result, for the progression from distance 3 to distance 5. arXiv:2207.06431