Below Threshold: What Google's Willow Chip Actually Proved
Abstract
In December 2024, Google published a Nature paper announcing that their Willow chip demonstrated quantum error correction below the threshold — the point at which larger codes become more reliable, not less. The headline about “10^25 years of classical computation” was technically defensible and mostly a distraction. The real result is more important and less flashy: for the first time, a surface code, which must correct both bit flips and phase flips, showed its logical error rate falling exponentially as the code grew. This is what scalable quantum computing looks like at its first credible step.
Contents
On December 9, 2024, Google published a paper in Nature announcing results from their 105-qubit Willow chip [[1]]. The announcement that went with it carried a second number, and that one spread across every technology news outlet on the planet: a benchmark computation that would take one of today’s fastest classical supercomputers $10^{25}$ years [[2]]. For reference, the age of the universe is roughly $1.4 \times 10^{10}$ years, which makes the claimed classical runtime about $10^{15}$ times longer than the universe has existed.
Impressive. Also: almost entirely a distraction from what actually matters.
The real result is the paper itself. It requires knowing what the threshold theorem says to appreciate, and it generated a fraction of the press coverage. Google’s Willow chip demonstrated a surface code operating below threshold, something no quantum processor had definitively shown before. This is the result that will matter in twenty years. The $10^{25}$-year number will have been forgotten by then — or quietly revised as classical simulation algorithms improve.
Let me explain why the threshold result is the one worth understanding.
Why quantum errors are a fundamental obstacle
When I first encountered quantum error correction as a student, my reaction was something like: surely you just copy the qubit a few times and take a majority vote, the way classical error correction works. This is wrong, and the reason it is wrong is elegant.
Quantum computation depends on superposition and entanglement. A quantum state like
$$|\psi\rangle = \alpha|0\rangle + \beta|1\rangle$$encodes information in the complex amplitudes $\alpha$ and $\beta$. But real physical systems do not exist in isolation. They interact with their environment — thermal fluctuations, stray electromagnetic fields, unwanted couplings to neighbouring systems. This coupling causes decoherence: the quantum state entangles with environmental degrees of freedom, and the superposition is effectively destroyed as the relative phase between $|0\rangle$ and $|1\rangle$ becomes random. For superconducting qubits of the type used in Willow, coherence times are on the order of microseconds to hundreds of microseconds. Every gate operation takes tens to hundreds of nanoseconds. After a few hundred gate operations, the accumulated decoherence and gate errors have corrupted the quantum state beyond use.
The classical remedy — store each bit three times and take the majority vote — fails for a fundamental reason. The no-cloning theorem states that there is no unitary operation $U$ such that
$$U(|\psi\rangle \otimes |0\rangle) = |\psi\rangle \otimes |\psi\rangle$$for all states $|\psi\rangle$. The proof is a one-liner: unitarity is linear, so if $U$ correctly copies $|0\rangle$ and $|1\rangle$, it maps $\frac{1}{\sqrt{2}}(|0\rangle + |1\rangle)|0\rangle$ to $\frac{1}{\sqrt{2}}(|00\rangle + |11\rangle)$, which is an entangled state, not $(|0\rangle + |1\rangle)^{\otimes 2}/2$. You cannot copy an arbitrary quantum state. Classical redundancy, applied naively, is forbidden by the linearity of quantum mechanics.
So quantum error correction requires a genuinely different idea.
The key insight: measure the error, not the state
The idea that unlocks quantum error correction is this: you can extract information about which error occurred without learning anything about the logical state the qubit is encoding.
Peter Shor showed in 1995 [[3]] that one logical qubit can be protected using 9 physical qubits. The construction is worth understanding in some detail because it reveals the structure that all subsequent codes share.
Bit-flip protection
First, consider only bit-flip errors: physical processes that flip $|0\rangle \leftrightarrow |1\rangle$ with probability $p$. Encode:
$$|0\rangle_L = |000\rangle, \quad |1\rangle_L = |111\rangle$$A logical superposition $\alpha|0\rangle_L + \beta|1\rangle_L = \alpha|000\rangle + \beta|111\rangle$ is an entangled state — it cannot be factored — but it is not a copy of $|\psi\rangle$; it is a different encoding.
If qubit 1 flips, the state becomes $\alpha|100\rangle + \beta|011\rangle$. We detect this by measuring the syndrome operators $Z_1 Z_2$ and $Z_2 Z_3$ — products of Pauli-Z operators. The eigenvalue of $Z_1 Z_2$ is $+1$ if qubits 1 and 2 have the same value, $-1$ if they differ. Crucially, measuring $Z_1 Z_2$ does not collapse the logical state: $|000\rangle$ and $|111\rangle$ have the same eigenvalue, and so do $|100\rangle$ and $|011\rangle$, so the outcome is fixed by the error alone and reveals nothing about $\alpha$ or $\beta$. This is the central trick of quantum error correction.
The syndrome outcome $(Z_1 Z_2, Z_2 Z_3) = (-1, +1)$ tells you qubit 1 flipped; apply $X_1$ to fix it. The logical state is restored.
Phase-flip protection
Phase errors flip the relative sign: $|+\rangle \leftrightarrow |-\rangle$ where $|\pm\rangle = (|0\rangle \pm |1\rangle)/\sqrt{2}$. Apply a Hadamard to rotate to the X basis, where phase flips look like bit flips, and apply the same three-qubit code.
Concatenation: the Shor 9-qubit code
Protect each of the three qubits in the phase-flip code with its own bit-flip code. The result: 9 physical qubits per logical qubit, protected against any single-qubit error. If the physical error rate is $p$, the logical error rate for the 9-qubit code scales as $p^2$ (you need at least two errors to fool the code), rather than $p$. Already an improvement.
The threshold theorem
Shor’s code is a proof of principle. The threshold theorem, established independently by Aharonov and Ben-Or (1997) [[4]] and Knill, Laflamme, and Zurek (1998) [[5]], shows something much stronger. For a level-$k$ concatenated code — a code of codes of codes, $k$ levels deep — the logical error rate scales as
$$p_L \approx p_{\text{th}} \left(\frac{p}{p_{\text{th}}}\right)^{2^k}$$where $p_{\text{th}}$ is the threshold: a critical physical error rate that depends on the code family. The form follows from one level of encoding, which turns an error rate $p$ into about $c\,p^2$, with $c$ counting the pairs of faults that can fool the code. Iterating $k$ times gives $(cp)^{2^k}/c$, so $p_{\text{th}} = 1/c$. Below threshold ($p < p_{\text{th}}$), adding more code levels exponentially suppresses logical errors. Above threshold ($p > p_{\text{th}}$), more qubits make things worse — each additional physical qubit introduces more errors than the code can correct.
The threshold is not a continuous improvement. It is a phase transition, literally so for the surface code [[6]]. Below it, the system is in the error-correctable regime; above it, it is not. Getting a physical quantum processor into the sub-threshold regime is a necessary condition for scalable fault-tolerant quantum computing.
Surface codes: the practical path
Concatenated codes require encoding at multiple levels, which multiplies overhead rapidly. Surface codes, which grew out of Kitaev’s toric code (1997) [[7]] and were analysed comprehensively by Dennis, Kitaev, Landahl, and Preskill (2002) [[6]], offer a more practical architecture and have become the leading candidate for fault-tolerant quantum computing.
The geometry
A distance-$d$ surface code arranges $d^2$ physical data qubits on the vertices of a $d \times d$ grid, interleaved with $(d^2 - 1)$ measure qubits (ancillas) used for syndrome measurement (Fig. 1). In the bulk, the stabilisers are products of $Z$ operators on the four data qubits around each face of one checkerboard colour (detecting bit-flip errors) and products of $X$ operators on the four data qubits around each face of the other colour (detecting phase-flip errors); at the boundary they act on two. Measuring these stabilisers without disturbing the logical qubit is the workhorse operation of the code.
The code distance $d$ is the minimum number of physical errors required to produce an undetectable logical error. An error chain of length $d$ connecting opposite boundaries of the code is the smallest error pattern that corrupts the logical qubit without triggering a syndrome. Larger $d$: longer chains required, lower logical error rates. A decoder that assumes the fewest errors fails when $(d+1)/2$ errors along such a chain are mistaken for the complementary $(d-1)/2$ [[8]]; hence the exponent below.
The scaling
The logical error rate per error-correction round for a surface code is approximately [[8]]:
$$p_L \approx A \left(\frac{p}{p_{\text{th}}}\right)^{\lfloor (d+1)/2 \rfloor} \tag{1}$$where thresholds near 1% occur in representative circuit-level surface-code noise models, $p$ is an effective physical-noise parameter for the model, $A$ is a code- and decoder-specific prefactor, and $\lfloor (d+1)/2 \rfloor$ is the exponent that grows with code size. In Fowler et al.’s simulations, with every gate, preparation and measurement failing with probability $p$, $A \approx 0.03$ and $p_{\text{th}} = 0.57\%$ [[8]].
This is the critical expression. For fixed physical error rate $p < p_{\text{th}}$:
- Increasing $d$ by 2 (one step in the code distance ladder) increases the exponent by 1 — a multiplicative suppression of $p/p_{\text{th}}$.
- In an idealised model with $p/p_{\text{th}} = 0.18$, each distance step would multiply the logical error rate by roughly 0.18. This is an illustration of the scaling law, not an estimate for Willow’s multi-component noise.
The inverse of that factor, $\Lambda = p_L(d)/p_L(d+2) \approx p_{\text{th}}/p$, is the suppression factor that experiments report.
For $p > p_{\text{th}}$: increasing $d$ makes $p_L$ worse. The code spends more effort chasing more errors than it eliminates.
The behaviour below versus above threshold is qualitatively different. Exponential suppression versus growth towards a coin toss. The dividing line is $p = p_{\text{th}}$.
What Willow demonstrated
Google’s Willow chip [[1]] is a 105-qubit superconducting processor.
The experiment is direct. Implement surface codes at distances $d = 3$, $d = 5$, and $d = 7$, corresponding to 9, 25, and 49 physical data qubits per logical qubit (plus measure qubits). Measure the logical error rate per error correction cycle for each code size.
With the neural-network decoder, the logical error per cycle was $6.50 \times 10^{-3}$, $3.03 \times 10^{-3}$ and $(1.43 \pm 0.03) \times 10^{-3}$ at $d = 3$, 5 and 7, and the fitted suppression factor was $\Lambda = 2.14 \pm 0.02$ for each increase of two in code distance [[1]]. The distance-7 memory used 49 data qubits, 48 measure qubits, and four additional leakage-removal qubits. Each distance step therefore reduced the logical error by a little more than half. With Fowler et al.’s $A = 0.03$ and $p/p_{\text{th}} = 1/\Lambda \approx 0.47$, Eq. (1) matches all three points to about 1%, comparable to their own 1–2% uncertainties (Fig. 2). That the prefactor fits too is a coincidence, not a prediction.
It is tempting to derive $\Lambda$ from one quoted component-gate error and a generic 1% threshold. That would be spurious precision. Willow has a circuit-level noise process containing gate, measurement, idle, leakage, and correlated errors; the paper uses measured logical scaling, detection probabilities, and a detailed noise model. Its $\Lambda$ is an experimental quantity, not the ratio of a single two-qubit gate error to a universal threshold.
The distance-7 logical qubit also lived $2.4 \pm 0.3$ times as long as its best physical qubit: beyond break-even [[1]].
This is the first time a quantum processor has convincingly demonstrated a surface code below threshold, with the exponential scaling the theorem predicts. Previous experiments showed that quantum error correction works in principle — syndromes can be measured, errors can be corrected. Google’s repetition codes had suppressed one kind of error at a time exponentially in 2021 [[9]], and its 2023 distance-5 surface code beat distance 3 by about 4% [[10]]. What had not been demonstrated was clear exponential suppression with code size in a code that corrects both kinds of error. Without that scaling, error correction merely shifts the error rate; it cannot drive it to arbitrarily small values by increasing code size. With it, the path to fault tolerance is open in principle.
I want to be precise about what “for the first time” means here, because the claims in quantum computing tend to sprawl. I previously wrote that earlier work had shown below-threshold error correction in other qubit modalities. The paper’s survey does not bear that out: “many platforms have demonstrated different features of quantum error correction”, but “no quantum processor has definitively shown below-threshold performance” [[1]]. What Willow adds is the combination: three distinct code distances, clean exponential scaling, and a physical qubit count sufficient to demonstrate $d=7$ without other dominant error sources overwhelming the measurement. The data is convincing.
The random circuit sampling result and its limits
Now the $10^{25}$ years.
Random circuit sampling (RCS) is a computational task defined as follows: apply a sequence of randomly chosen quantum gates to a collection of qubits and sample from the resulting output distribution. The output distribution of a deep random circuit over $n$ qubits is believed to be classically hard to simulate: the best known classical algorithms scale exponentially in $n$. A second Willow chip sampled 103-qubit random circuits of depth 40 in under five minutes [[11]]. The $10^{25}$-year figure is Google’s estimate for the same task on the Frontier supercomputer, granting it “full access to secondary storage, i.e., hard drives, without any bandwidth overhead”, which Google calls “a generous and unrealistic allowance” [[2]]. It is a cost model, not a measured runtime.
I will not contest the $10^{25}$-year number specifically — the estimate is defensible given current knowledge of classical simulation algorithms. But several things should be said about what the benchmark means.
RCS has no known practical application. It is not a step towards factoring integers, simulating molecules, or solving optimisation problems. It is a task designed to be hard for classical computers while being easy for quantum ones — a benchmark of quantum hardness, not quantum usefulness.
Classical simulation of random circuits is an active research area. The best classical algorithms for this task have improved substantially over the past five years. A result that seems to require $10^{25}$ years today may require $10^{10}$ years after a better classical algorithm is published. This has happened before: Google’s 2019 “quantum supremacy” claim was significantly eroded by subsequent classical simulation improvements, and Google expects classical computers “to keep improving on this benchmark” [[2]]. I expect the same here, to some degree.
Extrapolation is hard. Nobody has run the classical simulation; the $10^{25}$ years are a projected cost at a size where it cannot be checked. The uncertainty in the estimate is correspondingly large.
None of this makes the RCS result fraudulent or uninteresting. It is a genuine demonstration that a quantum processor can perform a specific task at a scale that classical computers plausibly cannot match. But calling this “quantum advantage” in the sense that matters — useful computation performed faster than any classical alternative — overstates it considerably.
The threshold result, by contrast, does not depend on classical simulation hardness arguments. It depends on measuring $p_L$ at $d = 3, 5, 7$ and checking whether the sequence is decreasing and consistent with the theoretical prediction. The data are directly interpretable without extrapolation. That is why I find the threshold result more significant.
Where we actually are — and the gap
The Willow chip has 105 physical qubits. The threshold result was demonstrated at $d = 7$, using 101 physical qubits for one logical qubit (including measure and leakage-removal qubits). In other words: Willow demonstrated roughly one logical qubit operating below threshold.
A cryptographically relevant quantum computer — one capable of breaking RSA-2048 using Shor’s algorithm — requires approximately the following in Gidney and Ekerå’s estimate [[12]], which assumes a planar grid with nearest-neighbour connectivity, a physical gate error of $10^{-3}$, a 1 µs surface-code cycle, a 10 µs reaction time, and a tenfold suppression of logical errors for each increase of the code distance by two:
- $\sim 6{,}200$ logical qubits for the factoring computation itself, from the $3n + 0.002\,n\lg n$ count for $n = 2048$ (with optimised circuits)
- a board of $226 \times 63$ distance-27 patches including magic-state factories, each patch $2(d+1)^2 = 1{,}568$ physical qubits (the bare $2d^2 - 1 = 1{,}457$ plus the spacing lattice surgery needs), about 23 million qubits in the paper’s simplified count
- Total: roughly 20 million physical qubits from the paper’s full cost model, running for about eight hours, some 25 billion error-correction cycles
The gap between “one logical qubit at $d=7$, 105 physical qubits” and “20 million physical qubits, tens of billions of coherent error-correction cycles” is not a gap of ten per cent or a factor of two. It is a factor of about 190,000 in qubit count alone, a little over five orders of magnitude, and the engineering challenges of maintaining coherence, connectivity, and calibration across millions of physical qubits are qualitatively different from maintaining them across 105.
In May 2025, Gidney cut the count to under a million qubits running for less than a week, under the same hardware assumptions [[13]]. That narrows the qubit gap to about four orders of magnitude. A second gap remains: both estimates need about $10^{-15}$ logical error per qubit per cycle, which their error models reach at distance 25 to 27, while my naive extrapolation of Willow’s line, with no error floor, needs $d \approx 81$.
We are on the right curve. We are not close to the destination.
Forecasts for cryptographically relevant quantum computing vary widely and are not an experimental consequence of Willow. The qualitative picture is firmer: Willow demonstrates a required scaling behaviour for a small quantum memory; the engineering challenge of scaling it to useful logical computation remains immense.
NIST post-quantum cryptography standards
Here is where I become impatient with the framing that says “don’t worry, quantum computers are decades away.”
In August 2024, NIST released three finalised post-quantum cryptographic standards [[14]]:
- FIPS 203 (ML-KEM, formerly CRYSTALS-Kyber): key encapsulation based on Module Learning With Errors (Module-LWE), a lattice problem
- FIPS 204 (ML-DSA, formerly CRYSTALS-Dilithium): module-lattice-based digital signatures
- FIPS 205 (SLH-DSA, formerly SPHINCS+): stateless hash-based digital signatures, with larger signatures than ML-DSA
These standards exist because the cryptographic community understands something that the “decades away” framing obscures: the relevant date is not only when a cryptographically capable quantum computer exists, but how long today’s data must remain secret. The attack is called “Harvest Now, Decrypt Later.” State-level adversaries — and I do not think it is paranoid to assume that multiple state intelligence agencies are collecting encrypted internet traffic today — can archive encrypted data with the intention of decrypting it once cryptographically relevant quantum computing becomes available.
For data encrypted today with RSA or elliptic curve cryptography, the protection window is however long it takes for a cryptographically relevant quantum computer to be built. If that is fifteen years, data encrypted with RSA-2048 today and collected by a patient adversary is vulnerable within fifteen years. For most data, fifteen-year confidentiality is adequate — a credit card number from 2025 is not sensitive in 2040. But for state secrets, medical records, long-term financial instruments, and critical infrastructure keys, fifteen-year confidentiality is not even close to adequate.
The migration to post-quantum cryptography should be happening now. In many places, it is not.
ML-KEM and ML-DSA rely on structured module-lattice problems; SLH-DSA relies on hash-function security. Shor’s algorithm attacks the integer-factorisation and discrete-logarithm structures behind RSA and elliptic-curve cryptography, not these constructions. That does not prove the standards immune to future cryptanalysis or implementation failures, which is why migration guidance and continued review matter.
Whether post-quantum cryptographic standards will still look secure in twenty years is an empirical question that the cryptanalytic community will continue to probe. But the alternative — remaining on RSA while a sufficiently patient adversary harvests encrypted traffic — is worse.
The existence of Willow is not an argument that RSA is broken. It is an argument that the threshold for “good enough to be a real threat” has moved from “theoretical possibility” to “demonstrated at small scale with correct exponential scaling.” The curve is real. Act accordingly. (And if you are responsible for cryptographic infrastructure at an institution and have not yet read the public money, public code argument for open, auditable cryptographic implementations — it applies doubly here.)
The cat qubit alternative
I have written elsewhere about bosonic cat qubits as an alternative approach to error correction. It is worth briefly noting the contrast with the surface code philosophy.
Willow’s surface codes take a universal approach to errors: both bit-flip and phase-flip errors are corrected by the same 2D stabiliser code, requiring large 2D arrays of physical qubits with nearest-neighbour connectivity. The code distance $d$ drives both error types down together.
The cat qubit approach, exemplified by Alice & Bob’s recent result [[15]], encodes a logical qubit in a superposition of coherent states $|\pm\alpha\rangle$ in a harmonic oscillator. The engineered two-photon dissipation of the resonator suppresses bit-flip errors exponentially in $|\alpha|^2$ — the mean photon number — at the hardware level. Phase-flip errors remain, but they are the only dominant error mode, and they can be corrected with a simpler one-dimensional outer code rather than a full 2D surface code.
The overhead reduction could be substantial. If bit-flip errors are already exponentially suppressed by the hardware, you do not need a 2D code with overhead scaling as $d^2$ physical qubits per logical qubit. A 1D repetition code over cat qubits might achieve the same logical error rate with far fewer physical qubits. Alice & Bob have demonstrated cat qubits with bit-flip times exceeding ten seconds — many orders of magnitude longer than the phase-flip time, which was above 490 ns. The gamble is that this asymmetry persists as the system scales and that the phase-flip outer code is tractable.
Surface codes and cat qubits are different bets on the same fundamental problem: how do you make the overhead of fault-tolerant quantum computing manageable? Surface codes are the more conservative bet — they work with any qubit that meets the error rate threshold, regardless of error anisotropy. Cat qubits are the more speculative bet — they require maintaining a specific nonlinear oscillator regime at scale, but the payoff in overhead reduction could be decisive. Both approaches are credible. Neither has been demonstrated at the scale where the comparison becomes definitive.
What the threshold result actually means
Let me close by saying precisely what I think the Willow result establishes and what it does not.
It establishes that below-threshold quantum error correction exists outside of theory. The threshold theorem says that below $p_{\text{th}}$, logical error rates decrease exponentially as code size grows. Willow demonstrates this behaviour at $d = 3, 5, 7$ in a superconducting processor. The theoretical prediction and the experimental observation are consistent. This is not a small thing. The threshold theorem has been the theoretical backbone of fault-tolerant quantum computing since the late 1990s; it is genuinely satisfying to see its core prediction — exponential scaling — confirmed experimentally.
It establishes below-threshold operation for the measured Willow surface-code memory under its full circuit-level noise. The observed suppression factor was $\Lambda = 2.14 \pm 0.02$ per two-unit increase in distance. Extrapolating that curve to useful logical error rates assumes that new correlated-error floors do not dominate as the processor grows; the paper’s repetition-code experiments show why that assumption must be tested rather than granted: up to distance 29 they hit an apparent floor near $10^{-10}$ per cycle, set by correlated error bursts about once an hour [[1]].
It does not establish that a cryptographically relevant quantum computer is imminent, near-term, or easy to build. The gap from one below-threshold logical qubit to the 20 million physical qubits of the 2021 estimate, or the million of the 2025 one, is real and large. The engineering challenges of superconducting quantum computers at scale — refrigeration, wiring, control electronics, cross-talk, calibration drift — are not solved by demonstrating $d=7$.
And the $10^{25}$-year benchmark is technically defensible and strategically irrelevant. Classical simulation of random circuits is an interesting research problem. It is not the problem that quantum computers are being built to solve.
The result that matters is the curve: as code distance grows, logical error rates fall exponentially. We are on that curve. We have not arrived anywhere yet. But for the first time in a code that corrects both kinds of error, the evidence says we are moving in the right direction with the right scaling. That is, genuinely, a significant step.
Start migrating your cryptographic infrastructure.
References
Literature and standards checked through 2026-10-24.
[1] Google Quantum AI and Collaborators. (2025; published online 2024). Quantum error correction below the surface code threshold. Nature, 638, 920–926. DOI: 10.1038/s41586-024-08449-y. Per-distance values: Table S1 of arXiv:2408.13687. See also the 2026 author correction, DOI: 10.1038/s41586-026-10559-8, which corrects labels in the repetition-code figure and does not change the surface-code results discussed here.
[2] Neven, H. (2024, December 9). Meet Willow, our state-of-the-art quantum chip. Google blog. https://blog.google/technology/research/google-willow-quantum-chip/
[3] Shor, P. W. (1995). Scheme for reducing decoherence in quantum computer memory. Physical Review A, 52(4), R2493–R2496. DOI: 10.1103/PhysRevA.52.R2493
[4] Aharonov, D., & Ben-Or, M. (1997). Fault-tolerant quantum computation with constant error. In Proceedings of the 29th Annual ACM Symposium on Theory of Computing (pp. 176–188). DOI: 10.1145/258533.258579
[5] Knill, E., Laflamme, R., & Zurek, W. H. (1998). Resilient quantum computation: Error models and thresholds. Proceedings of the Royal Society A, 454(1969), 365–384. DOI: 10.1098/rspa.1998.0166
[6] Dennis, E., Kitaev, A., Landahl, A., & Preskill, J. (2002). Topological quantum memory. Journal of Mathematical Physics, 43(9), 4452–4505. DOI: 10.1063/1.1499754
[7] Kitaev, A. Yu. (2003; preprint 1997). Fault-tolerant quantum computation by anyons. Annals of Physics, 303(1), 2–30. DOI: 10.1016/S0003-4916(02)00018-0. Preprint: arXiv:quant-ph/9707021
[8] Fowler, A. G., Mariantoni, M., Martinis, J. M., & Cleland, A. N. (2012). Surface codes: Towards practical large-scale quantum computation. Physical Review A, 86(3), 032324. DOI: 10.1103/PhysRevA.86.032324
[9] Google Quantum AI. (2021). Exponential suppression of bit or phase errors with cyclic error correction. Nature, 595, 383–387. DOI: 10.1038/s41586-021-03588-y
[10] Google Quantum AI. (2023). Suppressing quantum errors by scaling a surface code logical qubit. Nature, 614, 676–681. DOI: 10.1038/s41586-022-05434-1
[11] Google Quantum AI. (2024, December 9). Willow spec sheet. https://quantumai.google/static/site-assets/downloads/willow-spec-sheet.pdf
[12] Gidney, C., & Ekerå, M. (2021). How to factor 2048 bit RSA integers in 8 hours using 20 million noisy qubits. Quantum, 5, 433. DOI: 10.22331/q-2021-04-15-433
[13] Gidney, C. (2025). How to factor 2048 bit RSA integers with less than a million noisy qubits. Preprint, arXiv:2505.15917.
[14] National Institute of Standards and Technology. (2024). NIST Releases First 3 Finalized Post-Quantum Encryption Standards (FIPS 203, 204, 205). Retrieved from https://www.nist.gov/news-events/news/2024/08/nist-releases-first-3-finalized-post-quantum-encryption-standards
[15] Réglade, U., et al. (2024). Quantum control of a cat qubit with bit-flip times exceeding ten seconds. Nature, 629, 778–783. DOI: 10.1038/s41586-024-07294-3
Changelog
2026-07-11: Updated the Willow journal record and 2026 correction; replaced a reversed logical-error table and an invalid gate-error/threshold comparison with the paper’s measured $\Lambda$ and distance-7 result; corrected the no-cloning normalisation; and separated NIST’s migration policy from forecasts based on Willow.
2026-02-17: Updated the Fowler et al. (2012) author list to “Fowler, A. G., Mariantoni, M., Martinis, J. M., & Cleland, A. N.” — the previous list had been mixed with a different 2012 Fowler paper.
2026-02-17: Updated the closing section to “20 million physical qubits,” matching the Gidney & Ekerå (2021) figure cited earlier in the article.
2026-10-03: Corrected the surface-code stabiliser geometry (with data qubits on a grid, the $Z$ and $X$ checks sit on faces of alternating colour, not on faces and vertices); corrected the Gidney & Ekerå logical-qubit count from about 2048 to about 6,200 ($3n + 0.002\,n\lg n$ at $n = 2048$); replaced “Kerr nonlinearity” with engineered two-photon dissipation as the cat-qubit bit-flip protection mechanism (Réglade et al.); changed “all-to-neighbour” to “nearest-neighbour”.
2026-10-24: Corrected the concatenated-code scaling to $p_L \approx p_{\text{th}}(p/p_{\text{th}})^{2^k}$; the qubit gap from “four to five” to about five orders of magnitude; the RSA run from “millions” to about 25 billion cycles, with Gidney & Ekerå’s assumptions and Gidney’s 2025 update; the random-circuit run from 105 to 103 qubits, with the $10^{25}$ years a cost model, not an extrapolation; “exponential growth” above threshold to growth towards a coin toss; Kitaev “analysed in detail” to the toric code; the $Z_1Z_2$ argument to eigenvalues. Withdrew the claims that Google led with the $10^{25}$ years and that other platforms had shown below-threshold error correction (the Willow paper says none had), and narrowed the summary and ending to match.