There is a sentence that shows up every time the subject comes out: “a quantum computer tries every solution at once.” It is false, and understanding why it is false explains the real problem with this technology. A qubit tries nothing: while nobody measures it, it holds a superposition of two complex amplitudes — α|0⟩ + β|1⟩ — which turns into a result only when it is measured, and is destroyed the moment it is. Both the power and the fragility of quantum computing fit inside that contradiction.
What a qubit actually holds
A classical bit lives in two states and nothing else. A qubit lives on a sphere: the Bloch sphere. Its state is described by two numbers, α and β, which are probability amplitudes — and therefore complex numbers — with the condition that |α|² + |β|² = 1. The probability of reading 0 is |α|² and that of reading 1 is |β|². The power does not come from being “in both at once” in the colloquial sense, but from the fact that amplitudes can add and subtract from each other: they interfere. A quantum algorithm is, at bottom, a design of interferences that makes wrong answers cancel out and right ones reinforce, so that the final measurement reveals only the latter.
Entanglement is added on top of that: two qubits can end up in a joint state that cannot be written as the state of one plus the state of the other. It cannot send information faster than light, but it can spread a task across many pieces so that the result depends on all of them at once. And here the first uncomfortable rule appears: the no-cloning theorem. There is no physical way to copy an unknown quantum state. You do not even have the classical option of keeping three copies and voting by majority.
A quantum error does not look like a flipped bit
When a classical bit fails, it flips: it goes from 0 to 1. The error is discrete, and it is fixed by storing the information three times and going with the majority. A qubit fails differently: any tiny rotation of α and β is an error. There is no specific “wrong state,” just a continuous drift away from where it should be. Noise does not choose between 0 and 1; it nudges the vector, bit by bit.
Behind that nudge lies decoherence, the process by which the qubit becomes entangled with its environment and loses the information it carried. It is measured with two constants: T1, the relaxation time (the qubit falls from |1⟩ to |0⟩), and T2, the dephasing time (the amplitudes lose their relative phase). In a state-of-the-art superconducting processor, the qubits are transmons — oscillators built from Josephson junctions, a sandwich of two superconductors with an insulator between them — sitting in a dilution refrigerator at about 10 millikelvin, colder than deep space, and driven by microwave pulses. Their coherence times run in the tens to hundreds of microseconds: in practice, a few thousand operations before the thread is lost. Each two-qubit gate, on top of that, fails roughly once every thousand attempts.
Correcting without copying: syndromes and the surface code
If you cannot copy the state, how do you protect it? Not by repeating the data, but by spreading the information across many entangled qubits so that it is no longer in any one of them on its own, and measuring only parities between neighbours. Those measurements are called syndromes or stabilizer measurements: they do not say what the logical qubit holds, only whether two neighbours have stopped agreeing. It is like checking whether a row of light bulbs are all on or an even number are off, without looking at which ones. With enough parities, the pattern of discrepancies locates the error, and a classical program — the decoder — works out where it was and corrects it.
The most studied scheme is the surface code: a square lattice with data qubits and measure qubits alternating. Its strength is measured by the distance d, the number of errors it can correct, and its cost is steep: one logical qubit needs 2d² − 1 physical qubits. At d = 7 that is 101 qubits, a figure that in 2026 is still cutting-edge.
The threshold, lambda, and a memory that now outlives its parts
Here is the idea the whole field rests on: the threshold theorem. If the physical error rate sits below a critical threshold, adding qubits lowers the error instead of raising it, and every time you increase the distance by two steps the logical error is divided by a factor Λ. If you are above the threshold, adding qubits makes things worse: the machine sinks on its own.
In December 2024, Google showed with its Willow processor — 105 superconducting qubits — that you can be on the right side: a distance-7 surface code using 101 qubits reached 0.143% logical error per correction cycle, with Λ = 2.14. The decisive part is not the number, but that its logical memory survived 291 microseconds against the 119 of its best physical qubit: for the first time, correcting paid off, a milestone known as breaking the break-even point. The correction cycle lasted 1.1 microseconds and the decoder ran in real time in 63 microseconds, a margin that demands very fast algorithms — graph matching, and increasingly, neural networks trained to guess the error pattern.
Other codes, ions, and the October record
The surface code is not the only road. Color codes use triangular lattices with more complex checks, and qLDPC codes seek the same protection at a far lower qubit cost. On 19 October 2026, Quantinuum announced that its Helios machine — 98 trapped barium ions, not superconductors — had chained color codes of distances 3, 5 and 7 with a factor Λ = 12, well above Google’s 2.14, reaching 5 × 10⁻⁶ logical error per round, that is, 99.9995% fidelity.
The comparison demands care: these are different machines, with different codes and definitions of a “round” that do not match, and in trapped ions the main enemy is leakage — an ion falling into a neighbouring energy level and stopping behaving as a qubit, dragging its partners into correlated errors the code cannot read. What is comparable, and what the industry watches, is Λ and the logical gate error rate, not the qubit count that makes the headlines.
Magic states: the bottleneck almost nobody explains
Correcting errors is not enough to compute. Quantum gates come in two families: Clifford gates, which are implemented almost directly and with relatively simple error correction, and non-Clifford gates such as the T gate, which are essential for a quantum algorithm to be universal but have no transversal implementation. The fix is to manufacture a resource separately — a “magic state” — of very high quality, and consume it in the gate. It is the part that turns a reliable memory into a computer that computes, and until recently it was a bottleneck.
In October 2026, in the journal Science, Google presented magic-state cultivation on Willow: by injecting a T state into a distance-3 code and measuring carefully, they cut its error from 4.4 × 10⁻³ to between 10⁻⁴ and 2 × 10⁻⁴, about forty times less, at the cost of discarding roughly 92% of the attempts that fail the checks. The faulty state is not repaired: it is rejected and the attempt repeated. It works, but it is expensive, and nobody has yet chained several of these states inside a full algorithm.
How many qubits are really needed
With those numbers you can now do the arithmetic that matters. In 2025 a Google researcher, Craig Gidney, estimated that factoring a 2048-bit RSA key — the standard protecting much of the internet — would take about five days on a machine of fewer than a million noisy physical qubits, using distance-25 codes. In March 2026, Google itself lowered to fewer than 500,000 physical qubits the estimate for attacking 256-bit elliptic curves in about nine minutes. Those are big numbers, but they are no longer astronomical, and that is exactly why the industry is deploying post-quantum cryptography today rather than in 2040.
Public plans point to the same decade: Quantinuum promises about a hundred logical qubits by 2027 and hundreds in 2029; IBM, two hundred logical qubits running a hundred million gates that same year. The honest metric for following the race is not how many qubits get announced, but three boring numbers: what Λ is worth in the latest scaled code, what the logical gate error is, and whether there are magic states good enough to build complete algorithms. The day all three line up, “it does not exist yet” will have stopped being true without almost anyone noticing.
