Deep Dives
Why One Good Qubit Takes a Thousand Bad Ones
Quantum error correction spreads one qubit across many, and since Google's Willow it has been shown to improve with size. What is left is the price: how many physical qubits one reliable logical qubit costs.
Gabriele Masetti ·
Why a Quantum Computer Cannot Simply Copy Its Data
Classical machines protect bits by repetition. Store a bit three times, and if one copy flips, a majority vote restores it. Quantum mechanics forbids the obvious quantum analogue: an unknown quantum state cannot be cloned. Errors are also richer than flips, since a qubit can be wrong in its value, in its phase, or in any blend of the two.
It is possible, and the trick is to spread one qubit's information across many. A logical qubit is a pattern of entanglement over several physical qubits. Extra "ancilla" qubits are measured over and over to extract a syndrome, a record of which check failed, without ever reading the encoded data itself. A classical program called a decoder reads the syndrome stream and infers the most likely error. Most of the cost of a quantum computer, in qubits and in engineering, goes into this loop.
Error correction is no longer a question of whether it works. Since 2024 it has been shown to improve as it grows, and what remains open is price: how many physical qubits one dependable logical qubit costs, and how fast that price is falling. The famous "thousand" is an order of magnitude that hardware quality, code choice and algorithm design are all pushing down.
The Threshold Theorem and Why Size Can Help
The reason scale can help rather than hurt is the threshold theorem. In its standard statement, if the physical error rate of every component sits below a constant threshold, error correction can push the logical error rate as low as needed, with only polylogarithmic overhead in the size of the computation. The result was established independently by Aharonov and Ben-Or, by Knill, Laflamme and Zurek, and by Kitaev, building on Peter Shor's weaker 1996 result. It is the quantum counterpart of John von Neumann's 1956 threshold theorem for classical computing.
The theorem is a statement about a race. Adding qubits to a code gives more chances for something to go wrong, but also more redundancy to catch it. Below threshold redundancy wins, and each added layer of protection suppresses errors further. Above threshold the extra qubits only add noise, and a larger code is worse than a small one. Everything in the field, from chip design to funding decisions, is organised around which side of that line a machine is on.
Where the line sits depends on the code and the noise model. For the surface code, current estimates place the threshold on the order of 1 percent, though the figure varies with assumptions and is hard to compute. That is why gate fidelities of 99.9 percent matter so much. A machine well under threshold needs far fewer qubits per logical qubit than a machine barely under it.
Surface Codes, Colour Codes and Code Distance
The surface code arranges data qubits and measurement qubits on a square lattice, with each check touching only its neighbours. Locality makes it a natural fit for superconducting chips, where qubits sit on a plane and talk to adjacent ones. Its key parameter is the code distance d, the number of errors needed to flip the logical state undetected. A distance-3 patch tolerates one error, a distance-5 patch two, a distance-7 patch three.
The colour code is the main rival. It uses a triangular layout and, according to Google Quantum AI, needs fewer physical qubits than a surface code of the same distance because the patch covers less area. Many logical operations that take the surface code a long series of cycles can be done in a single step. Google reported that a logical Hadamard gate is expected to take about 20 ns in the colour code, whereas it can take 1,000 times longer on a surface code on the same device.
The price is performance on the memory itself. In the same Google experiment, going from distance 3 to distance 5 in the colour code suppressed the logical error rate by a factor of 1.56, against the 2.31 Google says it had previously achieved with surface codes. That gap is why the surface code remains the default for memory. The two codes trade qubit count, gate speed and decoding difficulty against each other.
Λ, the Number That Measures Scaling
Because the logical error rate falls by a roughly fixed factor each time the distance grows by two, one number summarises a whole experiment. Researchers call it Λ (lambda). Λ above 1 means the machine is below threshold in practice, and larger Λ means each step of extra qubits buys more protection.
ε_d ≈ C / Λ^((d+1)/2)
Here ε_d is the logical error per cycle at distance d, and C is a constant set by the hardware. The formula makes the economics visible: with Λ near 2, every two units of distance halve the error but roughly double the qubit count, and with Λ near 10 the same step cuts errors tenfold. Raising Λ, through cleaner gates or better decoding, is the most direct way to shrink the machine.
What Google's Willow Result Showed
Google Quantum AI posted the decisive experiment as a preprint on 24 August 2024 and announced the Willow chip on 9 December 2024, alongside the Nature paper. On a 105-qubit chip, the team ran surface codes of distance 3, 5 and 7. The distance-7 memory, built from 101 physical qubits, reached a logical error of 0.143 percent per cycle, with Λ = 2.14 ± 0.02. Google's own summary: the error rate was cut in half with each step up.
Two further numbers matter. The distance-7 logical memory outlasted its best physical qubit by a factor of 2.4 ± 0.3, passing the "break-even" point where encoding finally beats not encoding. And a distance-5 code ran with a real-time decoder, averaging about 63 microseconds of latency over up to a million cycles on a 1.1 microsecond cycle. Google's post calls Willow the first system below threshold, which it describes as "the most convincing prototype for a scalable logical qubit built to date."
The result has limits that the authors state. In repetition codes run up to distance 29, rare correlated error events, about one per hour or roughly three billion cycles, set a floor on the logical error. And Willow was a quantum memory: it stored a logical qubit and ran no logical gates below threshold. A useful algorithm needs error rates many orders of magnitude lower than 0.143 percent.
The 2024–26 Logical-Qubit Results
Other platforms have since reported logical qubits of their own, built on very different hardware. In November 2024 Microsoft and Atom Computing reported 24 logical qubits entangled in a cat state and computation on 28 logical qubits made from 112 physical neutral atoms, a four-to-one ratio. Microsoft's own post gave a logical error of 10.2 percent against a 42 percent physical baseline when errors and losses were detected. Atom Computing's chief executive Ben Bloom framed the result commercially:
By coupling our state-of-the-art neutral-atom qubits with Microsoft’s qubit-virtualization system, we are now able to offer reliable logical qubits on a commercial quantum machine. — Ben Bloom, Founder and CEO, Atom Computing
The Harvard, MIT and QuEra collaboration, published in Nature in November 2025, used reconfigurable arrays of up to 448 rubidium atoms. Its surface-code runs, using atom-loss detection and machine-learning decoding, showed 2.14-fold below-threshold performance in a four-round circuit. The paper also studied entangling logical qubits through transversal gates and lattice surgery. The matching 2.14 is a coincidence between two different experiments.
Quantinuum's Helios, announced on 5 November 2025, has 98 trapped-ion qubits. The company reported 94 logical qubits using the Iceberg code, which detects errors but does not correct them, and 48 fully error-corrected logical qubits at a 2:1 encoding rate through code concatenation, with state-preparation and measurement fidelity of 99.99 percent. The two counts come from different codes and cannot be compared directly. Quantinuum says a comparable earlier demonstration would have needed about 4,800 physical qubits for 48 logical ones.
Why Overhead Estimates Disagree
The headline question, how many physical qubits per logical qubit, has no single answer because the estimate is a function of several inputs. The first is the physical error rate: the lower it sits below threshold, the smaller the distance needed.
A published overview puts the surface code at roughly 1,000 to 10,000 physical qubits per logical data qubit at a 0.1 percent error rate, and warns that other error types could change the figure substantially. Helios's 2:1 ratio and Atom's 4:1 sit far below that range because they use small codes, which protect against few errors, in short experiments.
The second input is the code. Colour codes, concatenated codes and the high-rate codes used by the Harvard group trade qubit count against connectivity and decoding difficulty. The third is the target. A memory that survives a few cycles needs a modest distance; an algorithm with billions of operations needs a logical error rate that only a much larger distance delivers. The fourth is everything around the memory: magic-state factories for non-Clifford gates, routing between logical qubits, and a decoder fast enough to keep up.
Algorithm design moves the number as much as hardware does. Craig Gidney's 21 May 2025 preprint estimates that RSA-2048 could be factored with fewer than a million noisy qubits in less than a week, down from his 2019 estimate with Martin Ekerå of 20 million qubits and eight hours. The saving comes from approximate residue arithmetic, yoked surface codes for idle logical qubits and magic-state cultivation, under unchanged assumptions of 0.1 percent gate error and a 1 microsecond cycle, so the same hardware model needs twenty times fewer qubits.
Three Quantities and a Checklist for New Claims
The pattern across these results is that the field has moved from proving the principle to measuring costs. Three quantities will decide how quickly the thousand-to-one ratio falls. The first is Λ: a Λ of 2.14 is a proof of principle, and a Λ several times higher would change the arithmetic of every roadmap. The second is operations rather than memory, because logical gates below threshold are the missing demonstration. The third is decoding speed and cost, since the classical computer must keep pace with the quantum one.
Readers should apply a short checklist to any new logical-qubit claim. Ask whether the qubits are error-corrected or only error-detected. Ask the encoding ratio, the code distance and the logical error per cycle. Ask whether logical gates ran, or only a stored state. Ask whether the figure is an experiment or a simulation, and whether the result is peer-reviewed.
One good qubit takes a thousand bad ones today, and the evidence of 2024–26 is that the exchange rate is improving on three independent fronts: better hardware, better codes and better algorithms. Which front pays most, and how soon, is still unmeasured.