Informopedia Explains: why the hardest problem in quantum computing isn’t building qubits — it’s keeping them honest. How error correction works, why a 99.9995% fidelity record matters, and what “fault tolerance” would unlock.
Last week, the quantum computing company Quantinuum announced a striking number: its Helios machine had held a quantum calculation together with 99.9995 percent fidelity — roughly five errors in every million operations. It was the second such record in two months, and it was achieved not by building better qubits, but by correcting the bad ones faster than they fail.
To understand why that matters, you have to understand the strange, maddening fragility of the quantum bit — and the beautiful mathematics that tames it.
The problem: qubits forget
A classical computer bit is a switch: on or off, 1 or 0, carved in silicon and essentially immortal. A qubit is something else entirely — a single atom, a loop of superconducting wire, a photon — coaxed into holding a delicate blend of 1 and 0 simultaneously. That blend is where the computational power lives. It is also spectacularly fragile.
Stray heat, a passing electromagnetic wave, a tiny vibration: any of these can nudge a qubit and corrupt the calculation. Left alone, a quantum computation degrades into noise in a fraction of a second. For thirty years this was the field’s central embarrassment — every qubit you added was another chance for the whole thing to fall apart. The machines got bigger and, in a sense, worse.
The trick: many bad qubits make one good one
Error correction flips the logic. Instead of trying to build one perfect qubit, you take a crowd of noisy, imperfect physical qubits and weave them together — using a quantum error-correcting code — into a single logical qubit that behaves far better than any of its parts.
Quantinuum’s record used up to 37 physical qubits to make one logical qubit. The result was nearly 100 times more reliable than the physical qubits it was built from. That ratio — the logical qubit beating its components — is the whole game.
But how do you fix errors in something you can’t look at? This is the deep weirdness: measuring a qubit directly destroys the very quantum state you’re trying to protect. The answer, worked out in the 1990s, is to never look at the data at all. Instead, you constantly interrogate the relationships between qubits — asking questions like “do these two agree?” — which reveals that an error happened, and what kind, without revealing the underlying data. Physicists call this syndrome extraction: checking for symptoms without examining the patient.
Two kinds of errors get caught this way. A bit flip (0 becomes 1) is the familiar kind. A phase flip is purely quantum — a corruption of the blend itself, with no classical analogue. A good code catches both, continuously, while the computation runs.
The threshold: the point where bigger means better
Here is the idea that makes the whole enterprise sane. There is a threshold — a level of physical-qubit quality — past which error correction starts gaining ground. Below it, adding qubits adds noise faster than the code can clean it. Above it, every extra layer of protection makes the logical qubit exponentially more reliable. Bigger finally means better.
Quantinuum’s October result is a demonstration of life above the threshold. Using a textbook scheme called the color code, each increase in protection level cut the remaining errors by a factor of about twelve. September’s result used a completely different, newly invented code — Helix — and also set a record. Two different codes, same machine, both working: that is what “we’ve crossed the threshold” looks like in practice.
Two roads to the same place
The industry has split into two hardware camps, and the rivalry is instructive.
Trapped ions — Quantinuum’s approach — suspend individual charged atoms (barium, in Helios’s case) in vacuum with electric fields and manipulate them with lasers. Every atom of an element is identical, so the qubits start out uniform and quiet, with long “memory” times. The tradeoff: operations are relatively slow, and scaling to millions of ions is an unsolved engineering problem.
Superconducting circuits — Google’s and IBM’s approach — etch artificial atoms onto chips cooled near absolute zero. They are fast and manufacturable with chip-industry techniques, but noisier and less uniform, so they need more physical qubits per logical one. Google’s best published logical error rate is roughly a hundred times worse than Quantinuum’s new number — though comparing across different machines and benchmarks is always fraught, and Google would surely frame it differently.
There is no consensus on which road wins. There is growing consensus that the race is now about logical performance — error-corrected reliability — rather than raw qubit counts. The industry spent a decade bragging about how many qubits its machines had. The serious conversation has moved on.
What fault tolerance unlocks
“Fault-tolerant” is the magic phrase: a machine whose error correction is good enough to run long, complex algorithms end to end. Today’s machines can run impressive demonstrations; they cannot yet run the algorithms that would actually change industries, because the errors accumulate faster than the answers emerge.
Cross into fault tolerance and three things become possible. Chemistry and materials: simulating molecules exactly as quantum mechanics describes them — designing new drugs, catalysts and battery materials from first principles instead of trial and error. Optimisation: logistics, finance and scheduling problems that defeat classical machines. And, yes, cryptography: the long-feared ability to break current encryption, which is why governments are already migrating to quantum-resistant standards.
Quantinuum says its results validate its path to Apollo, a universal fault-tolerant machine “expected to be available by 2029.” Timelines in this industry have a habit of slipping — but for the first time, the claim rests on measured, repeated, above-threshold performance rather than extrapolation.
Why this matters now
It is easy to file quantum computing under “always five years away” and stop paying attention. That would be a mistake at this particular moment. The shift from counting qubits to measuring corrected reliability is the field growing up: from physics demonstrations to engineering. The winners of the next phase won’t be the labs with the most qubits, but the ones whose error correction compounds fastest.
Five errors in a million operations is still not zero. But it is the first number in years that makes “fault-tolerant” sound like a schedule instead of a dream.
Read the news: Google’s recent breakthrough on a 20-year quantum problem. Quantinuum’s full technical write-up is published here.
