5 errors in a million: a memory you can't look at that catches its own mistakes

Here's a number that sounds like a boast: 5 in a million.

It's how often a quantum memory, built by the company Quantinuum, got its one stored qubit wrong: about 5 times in every million rounds of checking.

That raises questions. What is a qubit, and why does it go wrong at all? Why not just keep spare copies, the way ordinary computers do? And what can "checking" mean, when looking at a qubit changes it?

By the end you'll know, and you'll see why a bigger code can be better or worse, depending on which side of one line it sits. 🧭

Chapter 1

Five in a million

In October 2026 Quantinuum reported a record on Helios, its quantum computer of 98 qubits. Each qubit is a single barium ion, an atom with an electric charge.

Helios stored one qubit's worth of information spread over 37 of its qubits, with 36 more asking them questions: 73 in all. A pattern like this, of qubits that hold the information and qubits that question them, is called a code.

One round of checking asks every question once. Each run was a separate test: set up the stored qubit, run 20 rounds, and see whether it came back as it went in.

Out of 29,000 runs, 580,000 rounds in all, it came back wrong three times. Worked out per round, that's about 5 errors in a million rounds, or 99.9995% right each round.

Some small print travels with that number.

Per roundIt's per round of checking a stored qubit, not per step of a calculation.
Three failuresIt rests on just three failures, so the true rate could easily be anywhere from about 3 to 9 in a million.
AfterwardsThe errors were worked out afterwards, by software.
Not yet in a journalAnd the paper hasn't yet been checked by other scientists in a journal.

The comparison that has been checked is Google's Willow chip. In December 2024 its biggest code went wrong about 1.4 times in 1,000 rounds, and each step up in size more than halved the errors; with a learning program tuning it, a 2026 journal paper got that down to about 8 in 10,000. Willow's rounds are far quicker, though, and that matters (chapter 11).

Both results rest on one idea, and this story builds it up.

check 01logged3 failures in 29,000 runs: about 5 in a million per round

Chapter 2

Why qubits break

An ordinary bit is 0 or 1. A qubit can be partly 0 and partly 1 at once, a blend called a superposition. Measure it and you get a plain 0 or 1, with odds set by the blend.

There's also a "phase", a kind of timing between its 0 part and its 1 part, and quantum computers run on it.

That makes qubits fragile. Anything that bumps one (a stray speck of light, a vibration, a nudge) leaves a trace of its state in the surroundings. The surroundings have kept a record, and the in-between is lost. That's decoherence, the story Nº 10 tells.

On the Willow chip Google used for error correction, a qubit in its upper energy level lasts about 68 millionths of a second on average before dropping to the lower one.

Worse, a qubit doesn't just flip. A bit can only go wrong by turning into its opposite. A qubit can drift by any amount, however small: a little more 1 here, a slightly shifted phase there.

Tracking endless tiny drifts sounds hopeless. Chapter 4 shows why it isn't, but first come two rules that made the whole idea look impossible.

check 02hazarda qubit doesn't just flip: it can drift by any amount

Chapter 3

No spare copies

Ordinary computers fight errors with spares: keep three copies of a bit and take a vote. Cleverer schemes add check bits that record whether a group of bits holds an even or an odd number of 1s. Richard Hamming's codes of 1950 use a few to find and fix any single wrong bit.

In 1956 John von Neumann showed that reliable logic can be built from unreliable parts, if each part's error stays below a fixed level (chapter 5 returns to that).

Two rules of quantum physics block the old recipe.

Rule 1 · no copies

You can't copy a qubit you don't know. This is the no-cloning rule, best known from two papers of 1982, though James Park had proved it in 1970. A machine that copies 0 and 1 correctly turns a blend into one state shared by two qubits, not two copies. (A known state can be made twice; it's copying an unknown one that's impossible.)

Rule 2 · no peeking

Looking generally changes a qubit. Read it and you get a 0 or a 1. You can't peek at the blend and put it back.

So comparing the stored value with its copies is out twice over. The way out, found in 1995, keeps the spares idea but changes the question.

check 03blockedno spare copies, and no peeking

Chapter 4

"Do you two agree?"

Peter Shor's answer, in 1995, was to spread the information instead of copying it.

The simplest version uses three qubits. The stored blend becomes "all three are 0" blended with "all three are 1": one qubit's information shared by three, not three copies.

Then the code asks two questions, and never what any qubit holds: do qubits 1 and 2 agree? Do 2 and 3? Both halves of the blend give the same answers, so the stored information survives the asking.

But the answers point at the culprit. "No, yes" means qubit 1 flipped; "no, no", qubit 2; "yes, no", qubit 3. Two flips at once fool it, and the stored qubit silently turns over.

Asking also tames the drifting: it snaps a small drift into either nothing or a whole flip, which can be undone. Phase errors need a second kind of question, and a real code asks both: Shor's own code used nine qubits, and in 1996 Andrew Steane built a seven-qubit one from Hamming's codes. A code that asks only one kind is a repetition code.

Two questions give four possible answers: two bits (as Nº 2 counts them), all about the errors and none about the stored qubit.

Try it with ordinary bits. Flip a bit or two and press Decode, or tap a lamp to make it lie 👇

With 5 bits, each with a 1-in-10 chance of flipping, the vote goes wrong about 9 times in 1,000, against 100 for a single bit: about 12 times better.

It's like three friends outvoting the one who misheard a phone number, except that a qubit can't be copied into three friends, and asking one would wipe the answer. The checks only ask whether two heard the same thing.

check 04foundask only whether neighbours agree, never what they hold

Chapter 5

The line between better and worse

Real checks can misread too. Go back to the figure's "lamps that lie" controls. Now each code is checked as many times as it has bits, so a bigger code is also checked for longer.

With flips and lies each at 5 in 100 a round, bigger codes fail less often.

Guess first

Now make flips and lies each 15 in 100 a round, each code checked as many times as it has bits. Codes of 3, 5 and 7 bits: which fails least?

See the answer

3 bits. At 15 in 100 each, checked as many times as they have bits, the bigger codes fail more often: bigger is worse.

At 15 in 100 each, codes of 3, 5 and 7 bits fail about 25, 30 and 34 times in 100: bigger is worse. (Checked for the same seven rounds, they would still improve with size.)

That's a threshold. Between 1996 and 1998 three groups proved one for quantum computers: Dorit Aharonov and Michael Ben-Or; Emanuel Knill, Raymond Laflamme and Wojciech Zurek; and Alexei Kitaev. If every part fails less often than some fixed level, and errors are mostly independent, a computation of any length can be made as reliable as you like.

Above the line, the same machinery makes things worse.

The first estimates put the line at about one fault in a million. Better codes have raised it about ten-thousandfold, to around one in a hundred for the next chapter's code. In the figure's game it sits at a coin flip when the lamps never lie, and about 1 in 10 when they lie as often as the bits flip: maths, not hardware.

One catch: the proof assumes errors mostly strike separately, not many at once from one cause. A cosmic-ray burst that hits many qubits at once is exactly what local checks aren't built for (chapter 9).

check 05founda threshold: below the line, bigger is better

Chapter 6

A chessboard of checkers

Chips lay their qubits out like a chessboard. It grew from Alexei Kitaev's 1997 "toric code", on a grid wrapped round a doughnut, which two teams cut open in 1998 into a flat patch: the surface code.

Data qubits, which hold the information, sit at the corners of the squares. A checker qubit sits in every square, asking the four around it (two, on an edge) whether they agree. Half look for bit flips, half for phase flips.

A line of broken qubits lights only the checkers at its two ends. The decoder, a computer, sees only those alarms and guesses the shortest explanation. If its guess and the real errors together make a line right across the board, the stored qubit has flipped, and no alarm rings.

The board's size, its distance, is the length of the shortest such line. A board of distance 5 always fixes any two broken qubits; three in a bad place can fool it. Break some and see 👇

Chessboard · Willow

Willow's distance-7 board used 101 qubits: 49 for data, 48 checkers and 4 more to clear out leaks, qubits slipped out of their two working levels.

Honeycomb · Helios

Helios used a honeycomb cousin, the colour code of 2006. Each hexagon checks for both kinds of error, and at distance 7 it needs 73 qubits, against the chessboard's 97. It also lets a whole family of basic operations be done qubit by qubit.

Its six-sided checks take more steps, and on superconducting chips (tiny circuits cooled until their metal carries electricity with no resistance) it has so far done worse; Helios, which can bring any two ions together, suits it better.

check 06founda board of distance 5 always fixes any two broken qubits

Chapter 7

Bigger, then better

How fast do errors fall below the line? In 2012 Austin Fowler and colleagues fitted big simulations of the chessboard code to a simple rule: each step up in size, from distance 3 to 5 to 7, divides the errors by the same factor, lambda (Λ).

Above 1, bigger is better; below 1, bigger is worse.

It isn't a fall to zero: the errors keep dropping until some other kind of error, like chapter 5's bursts, takes over. And the line isn't one number. For the chessboard it's about 10 in 100 with perfect checkers, about 3 in 100 if they misreport as often, and about 0.6 to 1 in 100 per operation when every step, the checking included, can fail.

Lambda turns into a bill of qubits. If each operation fails 1 time in 1,000, lambda is 5.7, and a board of 241 qubits would reach 1 error in a million rounds; one in a trillion would take 1,457 (this page's arithmetic). From Willow's lambda of 2.14, Google projected 1,457 qubits for one in a million: a projection, not a result (the same count by coincidence). Set the error rate 👇

Helios's lambda was about 12, but don't read its parts off this line: its code has a line of its own.

Think of a thicker wall: each layer divides what seeps through by the same factor. That holds only below the line, and no thickness stops a flood that hits the whole wall at once.

check 07foundeach step up in size divides the errors by lambda

Chapter 8

Thirty years of trying

The idea is from 1995. Getting it onto chips took three decades, and each step measured something slightly different.

In 2014 a Santa Barbara team's superconducting chip ran gates, the basic steps a quantum computer does to its qubits, good enough to reach the chessboard code's threshold: a statement about the parts. In 2016 a Yale memory outlasted its best unprotected part, by about 10%: "break-even". In 2021 Google's rows of up to 21 qubits cut errors more than a hundredfold as they grew, but against one kind of error only.

In 2023 Google's distance-5 chessboard beat its distance-3 ones, by about 4%. Over 2023 and 2024 other teams reported big gains, mostly by throwing away the runs in which an error was flagged.

Then came Willow, in December 2024: the first clear case of a chessboard code, a full quantum code, getting much better as it grew. 2025 added cat qubits (Nº 10) and neutral atoms. So far in 2026 the lowest errors per round have come from trapped ions, though superconducting chips improved too.

Errors per round are the closest thing to a common yardstick, and even they differ by code and machine. Step through the years 👇

From 2022 to 2026 the plotted errors fell about 6,000-fold, from about 3 in 100 to about 5 in a million, across different codes, machines and ways of counting. The last two dots aren't yet checked in a journal; of those that are, the best is Google's 2026 Willow result, about 8 in 10,000 per round.

check 08loggedDecember 2024, Willow: the first clear case for a chessboard code

Chapter 9

Willow

Willow is Google's chip of 105 superconducting qubits. One round of checking on it takes about a millionth of a second (1.1 microseconds).

Google ran boards of distance 3, 5 and 7, the biggest on 101 qubits. They went wrong about 6.5, 3.0 and 1.4 times in 1,000 rounds. Each step divided the errors by 2.14, more than halving them twice over, and the biggest board outlived the chip's best single qubit by a factor of 2.4.

The headline errors were worked out afterwards, by a neural network, a program that learns from examples. Working them out live was shown on a 72-qubit sister chip, at distance 5. There, Google's accounting puts about 60% of the trouble on the gates that link two qubits.

Rare bursts still set a floor. On the sister chip, simpler rows of qubits, helped by a redesign of the qubits, got past an earlier floor set by cosmic rays. Then they seemed to hit a lower one, near 1 error in 10 billion rounds, from bursts about once an hour that hit many qubits at once. Nobody yet knows their cause.

Google's own words are careful: before Willow, it says, no quantum processor had "definitively" shown it was below the line. Bigger codes had done better before (chapter 8). Willow was the first clear case for a chessboard code, a full quantum code: each step more than halved the errors.

check 09loggedWillow: each step divided the errors by 2.14

Chapter 10

Three failures

Helios keeps each qubit in one barium ion, and moves the ions around so that any two can meet. Its gates that link two qubits go wrong about 8 times in 10,000, on average. It ran memories of three sizes:

13 qubits: 178 failures in 15,840 runs, about 5.5 errors in 10,000 rounds.
37 qubits: 17 failures in 21,600 runs, about 3.8 in 100,000.
73 qubits: 3 failures in 29,000 runs, about 5 in a million.

So the errors fell about twelvefold a step, by the paper's fit across all three sizes. Step by step it was about 15-fold, then about 8-fold (this page's arithmetic). Other decoding programs give 7 to 11.

Three is a tiny count. The true rate could easily be anywhere from about 3 to 9 in a million, and at the stricter 95% level scientists often use, about 1 to 15 (this page's arithmetic). Re-run the experiment and watch the count jump 👇

At a true rate of 5 in a million, about 87 re-runs in 100 see one to five failures, and about 22 see exactly three (this page's model). Three was a fairly typical result.

The paper describes no thrown-away runs (this page's reading). And a rate isn't a lifetime: one failure in about 200,000 rounds is an average, and no run went past 20 rounds.

check 10loggedHelios: about twelvefold a step, by the paper's fit

Chapter 11

The small print

Quantinuum's own blog words the result as errors per operation, though the same blog also says, correctly, that it's per round of checking a stored qubit. A memory is not yet a computer.

The checks ran live, but the errors were worked out afterwards. In a memory that gives the same answer; a computation needs the decoder to keep up. For a growing code below the line, only Google has shown that so far, at distance 5, as far as we can find.

One round of the whole code failed about 170 times less often than one gate linking two qubits (this page's arithmetic). With about 200 such gates a round, a gate goes wrong every six rounds or so, against one failure of the stored qubit in about 200,000 rounds (this page's estimate).

Quantinuum says its result is 100 times lower than the best on any other kind of machine, and ten times lower than its own September record: the company's comparisons, both resting on numbers that could be well off.

Counted per second (this page's estimate), the Helios memory still goes wrong far less often. But each of its rounds takes a few tenths of a second (this page's estimate; the paper gives no round time), a couple of hundred thousand times longer than Willow's, so a long computation would run far faster on Google's chip.

check 11cautionper round of checking a stored qubit, not per operation

Chapter 12

Not a computer yet

Storing a qubit is step one; a computer also needs operations on stored qubits. Helios has run them between protected qubits only in its smaller codes: two 73-qubit codes wouldn't fit on a 98-qubit machine.

Some operations need a hard extra ingredient, "magic" states. In October 2026 Google reported making them with an error of at most about 1 in 10,000, keeping only 8% of its attempts. Such states have not yet been used inside a long protected computation, and Quantinuum's own blog adds that nobody has yet shown magic-state making improve with code size below the line.

If Helios's trend held, roughly 660 to 800 qubits would reach about one error in a trillion rounds (this page's arithmetic; the low end's code distance, 21, from the twelvefold step, is also Quantinuum's projection): a big if, seven or eight steps beyond the data, from three failures.

The best-known goal is breaking RSA, a widely used kind of encryption. Estimates have fallen from 20 million noisy qubits (2019) to under a million (2025), and two 2026 papers claim fewer than 100,000, or as few as 10,000 atoms with much longer runs. As of 25 October 2026 none of the three newer ones has been checked in a journal. Today's best machines have about a hundred good qubits (Willow 105, Helios 98).

Qubits: what there is, what's wanted

today's best machines, good qubitsabout a hundred
if Helios's trend held, for one error in a trillion roundsroughly 660 to 800
breaking RSA, a 2026 claim*, with much longer runsas few as 10,000 atoms
breaking RSA, a 2026 claim*fewer than 100,000
breaking RSA, 2025*under a million
breaking RSA, 201920 million noisy

Bar lengths on a log scale. * Not yet checked in a journal. The 660 to 800 is this page's arithmetic.

check 12cautiona memory is not yet a computer

Chapter 13

Faster than they pile up

Every piece is now in place: no copies and no peeking; questions that learn the error and nothing else; a line below which bigger is better; and lambda, to say how far below it a machine sits, about 2 on Willow and about 12 on Helios.

Think of firefighters. Below the line, the crew puts out sparks faster than they spread. Above it, more firefighters means more people tripping over hoses.

The picture breaks in one place. In both headline experiments the sparks weren't put out on the spot: the checks ran every round, the errors were logged, and the books were balanced afterwards in software. "Catches", not "fixes", is the honest word.

check 13donecaught, not fixed: errors logged, the books balanced afterwards

Let's add it all up. 🖨️

Errors, itemised

Helios, distance 7October 2026, not yet checked in a journalabout 5 in a million per round

Failures actually seenin 29,000 runs of 20 rounds3

Rounds in all29,000 × 20580,000

Each bigger Helios codeerrors divided byabout 12

Qubits in that code37 hold the data73

One gate linking two qubitsHelios, benchmarked for this workabout 8 in 10,000

Willow, distance 7December 2024, in Nature1.4 in 1,000 per round

Each bigger Willow codeerrors divided by2.14

Caught faster than they pile up?below the thresholdyes

ask only if neighbours agree ✦ below the line, bigger is better ✦ a memory is not yet a computer

Single ions of barium waited, each one a qubit.

Round after round, checker ions asked small groups of neighbours the same quiet question: do you agree?

Until the very end, nobody asked them what they held.

Afterwards, a computer read the alarms and guessed what had gone wrong.

Three times in 29,000 tries, the guess was wrong.

You can't copy a qubit, and looking at it changes it. You can ask its neighbours whether they agree, and below the threshold, that is enough.

Part IA memory you cannot copy

Chapter 1Five in a million, per round

On 19 October 2026 Quantinuum announced a set of quantum-memory experiments on Helios, its trapped-ion quantum computer.¹ The paper behind the announcement, by A. Lavasani, A. P. Reed, J. M. Dreiling and twenty colleagues, was submitted to arXiv on 16 October and made public there on the evening of 19 October, US Eastern time (arXiv's listing dates it 20 October).² As of 25 October 2026 it is a preprint: it has not been through peer review. Helios holds 98 qubits, each stored in the internal state of a single trapped barium-137 ion, and its two-qubit gates fail on average about 7.9 times in 10,000 (the average infidelity given in its refereed hardware paper).³

The experiments stored one logical qubit, one qubit's worth of information spread across many physical qubits, in a triangular colour code (Chapter 6) at three sizes, or distances: d = 3, 5 and 7, using 13, 37 and 73 ions. At distance 7, the data sat in 37 ions and 36 more measured the checks, the questions the code asks about its qubits (Chapter 4). Each round of error correction measured every check once, and each run was a separate experiment: prepare the logical qubit, run 20 rounds, read it out, and see whether it came back as it went in.

At distance 7 the memory failed three times in 29,000 runs, 580,000 rounds in all.² The paper turns those counts into a logical error per round:

ε₇ = (f/n) / (r + ½) = (3/29,000) / 20.5 ≈ 5 × 10⁻⁶ per roundf failures in n runs of r rounds each. The paper prints 5 (+4/−2) × 10⁻⁶, with a one-sigma Wilson interval (an error bar suited to small counts, expected to contain the true value about two times in three); the central value is 5.05 × 10⁻⁶ (this page's arithmetic from the paper's counts), a fidelity of 99.9995% per round.

In words: about one run in 10,000 came back wrong, and the estimator divides that by the run's 20 rounds plus a half, which allows for errors in preparing the state. Six conditions travel with that number. It is a memory: a qubit being stored, not computed with. It is a rate per round of error correction, not per operation. It is an average over runs of 20 rounds; no stored qubit was kept longer than that. It rests on three failures, so its error bars are wide and lopsided: about 3 to 9 in a million at one sigma. The decoding, which turns the checks' answers into a verdict, was done afterwards in software. And it is a preprint.

The refereed comparison sits beside it. In December 2024 Google Quantum AI reported in Nature surface-code memories on Willow, a 105-qubit superconducting chip.⁴ Its distance-7 code failed 0.143% per round (1.43 × 10⁻³), and each step up in size, from distance 3 to 5 to 7, divided the error by a factor Λ (lambda) of 2.14 ± 0.02. Helios's codes improved faster, by Λ = 12 (+3/−2) a step, to a rate per round about 280 times lower than Willow's (this page's arithmetic: 1.43 × 10⁻³ ÷ 5.05 × 10⁻⁶ ≈ 283). Google's best refereed distance-7 rate since, 7.72 × 10⁻⁴ on Willow with reinforcement-learning control (Nature, July 2026), is about 150 times Helios's (this page's arithmetic: 7.72 × 10⁻⁴ ÷ 5.05 × 10⁻⁶ ≈ 153). But a Willow round takes 1.1 microseconds, and a Helios round, by this page's estimate, a few tenths of a second; Chapter 11 shows why that matters.

The rest of the page builds up the idea behind both numbers. A qubit cannot be copied, and looking at it disturbs it, yet it can be protected: spread one qubit's information across many, and keep asking only whether neighbours agree. If every part is good enough, below what is called the threshold, each step up in size divides the error by a fixed factor.

Chapter 2Why qubits break

A classical bit is 0 or 1. A qubit can be in a superposition, written a|0⟩ + b|1⟩, a blend of its two basis states, |0⟩ and |1⟩, where a and b are complex numbers with |a|² + |b|² = 1. Measured, it gives 0 with probability |a|² and 1 with probability |b|², but the state carries more than those two probabilities: the relative phase between a and b matters too. Quantum algorithms run on that phase, through interference.⁵

That makes a qubit fragile in a way a bit is not. Any stray interaction that leaves a trace of the qubit's state in its surroundings (a scattered photon, a vibration, a nudged charge) turns the superposition into a mixture, a plain either-or: the environment has kept a record, and the phase is lost. This is decoherence, the story Nº 10 tells. On a superconducting chip one of the simplest losses is energy relaxation: a transmon qubit in its upper level decays to its lower one, with a mean energy lifetime T₁ of 68 microseconds on the Willow chip used for error correction.⁴

Worse, a qubit's errors are not just flips. A bit can only go wrong by becoming its opposite. A qubit can drift by any amount, however small: a|0⟩ + b|1⟩ can become slightly more |1⟩, or its phase can creep. Two named errors are the building blocks. A bit flip, written X, swaps |0⟩ and |1⟩. A phase flip, Z, changes the sign of b. Both at once is called a Y error. Any small drift of one qubit is a blend of "nothing happened" with a little of X, Y and Z, so protecting a qubit looks as if it would mean tracking a continuum of errors.

It does not, and the reason is the first surprise of quantum error correction. Peter Shor's 1995 paper already argued it for his own code, and Emanuel Knill and Raymond Laflamme proved it in general (published 1997): a code able to correct X, Y and Z on a qubit corrects every error on that qubit, small drifts included. Measuring the code's checks forces any drift into one of four definite cases (none, X, Z or Y), and fixing those fixes everything on that qubit.⁶ Chapter 4 shows how. First come the two obstacles that made quantum error correction look impossible.

Chapter 3The oldest trick is forbidden

Classical machines handle errors by redundancy. The simplest scheme keeps three copies of each bit and takes a majority vote; better ones add parity bits, each recording whether a group of bits holds an even or an odd number of 1s. Richard Hamming's codes of 1950 use a few such parity checks to locate and correct any single wrong bit in a block.⁷ In 1956 John von Neumann went further and showed that reliable logic can be built from unreliable gates, provided each gate's error stays below a fixed level.⁸ That was the first threshold argument, the ancestor of Part II.

Two facts stop the classical recipe from carrying over. The first is the no-cloning theorem: no physical process can take an unknown state |ψ⟩ to two copies, |ψ⟩|ψ⟩, for every possible |ψ⟩. It is best known from two papers of 1982, by William Wootters and Wojciech Zurek and, independently, by Dennis Dieks.^9,10 James Park had proved it in 1970, in a paper that went largely unnoticed until historians pointed to it.^11,12 The argument fits in a line. Suppose a machine U copies the two basis states, so that U|0⟩|0⟩ = |0⟩|0⟩ and U|1⟩|0⟩ = |1⟩|1⟩. Quantum evolution is linear: it acts on each part of a superposition separately, so it must give

U (a|0⟩ + b|1⟩) |0⟩ = a|00⟩ + b|11⟩ ≠ (a|0⟩ + b|1⟩)(a|0⟩ + b|1⟩)The two sides agree only if a or b is zero. A machine that copies |0⟩ and |1⟩ correctly cannot copy their superpositions. A known state can be prepared twice; what is impossible is copying a state you do not know.

The second fact is that measurement disturbs. Reading a qubit in the 0/1 basis returns one bit and leaves the qubit in |0⟩ or |1⟩. The numbers a and b, the amplitudes, cannot be read off a single copy and written back.⁵ Not every look destroys a qubit, but looking generally changes it.

So comparing the stored value with its copies is out twice over: there are no copies, and checking the value spoils it. Add the continuous errors of Chapter 2, and quantum error correction looks impossible. The way out, found in 1995, keeps redundancy and changes what is measured.

Chapter 4Ask whether neighbours agree

Peter Shor's answer, in 1995, was to spread the information instead of copying it.¹³ The simplest version, the three-qubit bit-flip code, stores the qubit a|0⟩ + b|1⟩ as an entangled state of three:

a|0⟩ + b|1⟩ → a|000⟩ + b|111⟩One qubit's information shared by three, not three copies, which no-cloning forbids. No single qubit holds a or b; the information sits in the correlations.

Suppose one qubit flips, say the second, so that the state becomes a|010⟩ + b|101⟩. Instead of measuring any qubit, the code measures two checks, the parities Z₁Z₂ and Z₂Z₃: "do qubits 1 and 2 agree?" and "do qubits 2 and 3 agree?". Both branches of the superposition give the same answers, so the measurement learns nothing about a or b and leaves them intact. The answers, together called the syndrome, point at the culprit:

Do 1 and 2 agree?	Do 2 and 3 agree?	Diagnosis	Fix
yes	yes	no flip	nothing
no	yes	qubit 1 flipped	X on qubit 1
no	no	qubit 2 flipped	X on qubit 2
yes	no	qubit 3 flipped	X on qubit 3

Two flips at once fool it: they give the syndrome of the remaining qubit flipping, the "fix" completes the set, and a|000⟩ + b|111⟩ becomes a|111⟩ + b|000⟩. That is a logical error, which no check can see. If each qubit flips independently with probability p, the code fails with probability 3p² − 2p³, the chance of two or three flips, which is smaller than p whenever p is below one half.

The syndrome is information, and it can be counted the way Nº 2 counts it. N − 1 checks on N qubits have 2^N−1 possible answers, so naming one takes N − 1 bits, every one of them about the errors and none about the stored state. A classical checksum is the nearest relative, with one difference: a classical bit can also be read freely, while quantum checks must be designed so that nothing else leaks out.

The checks also dispose of the continuum of Chapter 2. A small rotation of the second qubit, by an angle θ, makes the state a blend of the intact code state and the flipped one:

e^−iθX₂ (a|000⟩ + b|111⟩) = cos θ (a|000⟩ + b|111⟩) − i sin θ (a|010⟩ + b|101⟩)Measuring the checks gives "no flip" with probability cos²θ, leaving the stored state exactly as it was, or "qubit 2 flipped" with probability sin²θ, leaving exactly the flipped state, which one X undoes.

Asking the question turns a smooth drift into one of a few definite errors, which can then be undone.⁶ Phase drifts need a second kind of check, in a rotated basis, and a real code needs both. Shor's 1995 code nests bit-flip codes inside a phase-flip code and uses nine qubits to correct any single-qubit error.¹³ Andrew Steane's seven-qubit code of 1996 builds both kinds of check from Hamming's classical code,¹⁴ a construction that Robert Calderbank and Shor generalised the same year into the "CSS" codes, named after Calderbank, Shor and Steane.¹⁵ Five qubits are the fewest that can correct any single-qubit error.¹⁶ A code with one kind of check, like the three-qubit one, is a repetition code: it protects against only one kind of error, and most qubits suffer both, so the 2015 and 2021 repetition-code experiments of Chapter 8 are not full quantum memories.

Figure 1 is a classical repetition code to break by hand. Each lamp between two bits lights when they disagree. Flip a bit or two and press Decode: the decoder applies the fewest flips that explain the lamps, a majority vote. Tap a lamp to make it lie, and watch one false check make the decoder damage healthy bits.

Figure 1🤝 Try it

Ask whether neighbours agree

Flip bits, then decode

Chance each bit flips per round

Set near the mean two-qubit gate error of Willow's error-correction chip, 0.33% (Google's spec sheet, randomised benchmarking, all gates running), and Helios's 7.9 × 10⁻⁴ (average infidelity, refereed hardware paper). Here p is a flip chance per round, not a gate error.Set near the error of one two-qubit step on Willow (about 3 in 1,000) and on Helios (about 8 in 10,000). Here it's a chance per round of checking, not the error of one such step.

Chapter 5: faulty checksNext chapter: lamps that lie

Chance a check is misread

Unprotected bit failsOne bit alone goes wrong

Code of N fails, P_LN bits with checks go wrong

ImprovementHow much better

P_L at N = 3 · 5 · 7With 3, 5, 7 bits

Syndrome patterns 2^N−1Alarm patterns

A classical repetition code: N bits hold one bit; N − 1 checks report only whether neighbours agree. Perfect checks (q = 0): each bit flips once with probability p and a majority vote decodes, P_L = Σ_k>N/2 C(N, k) p^k (1 − p)^N−k, threshold ½. Misread checks (q > 0): N rounds of accumulating flips and checks misread with probability q, then a perfect readout; each code is checked for as many rounds as it has bits, the usual way to test for a threshold, so bigger codes also run longer (for the same number of rounds, these small codes still improve with size); the decoder finds the most likely error history (exact matching), and P_L comes from 20,000 seeded runs per size, ± one standard error, against a lone bit left as long. Presets are illustrative flip chances near each machine's two-qubit gate error. The qubit version stores a|00…0⟩ + b|11…1⟩, not copies, and guards against one kind of error. This page's model and simulation.Each disc is a bit; a lamp lights when two neighbours disagree. Tap bits, then press Decode: the code outvotes the odd one out, but if most have flipped, it "fixes" the wrong way. Below the line more bits help; above it, bigger codes, each checked as many times as it has bits, do worse. Quantum codes share one qubit, never copy it.

The default setting makes the point. Five bits, each flipped with probability 10%, with perfect checks, fail with probability 0.0086, against 0.10 for one unprotected bit: about twelve times better. Three, five and seven bits fail with probability 0.028, 0.0086 and 0.0027 (this page's arithmetic from the binomial sum in the caption). With perfect checks the vote helps for any flip chance below one half, the code's threshold.

The witness analogy is tempting: three friends remember a phone number and outvote the one who misheard. It breaks exactly where quantum mechanics bites. A qubit cannot be copied into three witnesses, and asking a witness what they saw would destroy the answer; the checks ask only whether two of them saw the same thing. Real checks are also imperfect, being made of qubits and gates too.

Part IIBelow the threshold

Chapter 5The threshold theorem

Go back to Figure 1's last controls, "Chapter 5: faulty checks", and set the chance that a lamp is misread above zero. Each code is now checked for as many rounds as it has bits, flips pile up, any lamp can lie, and the decoder looks for the most likely history of flips and misreads. The trio of failure rates for three, five and seven bits then tells you which side of a line you are on.

That line is the subject of the threshold theorem, proved independently by several groups between 1996 and 1998: Dorit Aharonov and Michael Ben-Or; Emanuel Knill, Raymond Laflamme and Wojciech Zurek; and Alexei Kitaev.^17,18,19 If every physical component fails less often than a fixed threshold p_th, and errors are local and not too strongly correlated, a computation of any length can be made as reliable as you like, at a cost that grows only slowly (polylogarithmically) with its size. It does not promise a working quantum computer; it says what is possible if the parts are good enough. Aharonov and Ben-Or's own estimate of the threshold was about 10⁻⁶, one fault in a million operations.¹⁷ Better codes and better analysis have since raised it by about four orders of magnitude, to around one in a hundred for the surface code of the next chapter.

The theorem has a second half that matters as much as the first. Above the threshold the same machinery makes things worse: a bigger code adds more chances to fail than its extra checks can catch, and its logical error rises with size.²⁰ Figure 1 shows the reversal. With flips and misreads each at 5% a round, the codes of three, five and seven bits fail about 4.6%, 2.7% and 1.4% of their runs: bigger is better. At 10% each the three are equal within the simulation's noise. At 15% each they fail about 25%, 30% and 34%: bigger is worse (this page's simulation).

Two numbers set the scale. With perfect checks the repetition code's threshold is one half: below a 50% flip chance a majority vote over more bits always helps, and at one half it never does. That is mathematics, not hardware. With checks that are misread as often as bits flip, the crossing falls to about 10%, close to the 10.3% that Chenyang Wang, Jim Harrington and John Preskill computed for the surface code with perfect checks; the two cases turn out to be the same mathematical problem.²¹ With other misread rates the crossing moves: to a flip chance of about 5% when checks are misread 20% of the time, and about 14% when they are misread 5% of the time (this page's simulation).

Checking for as many rounds as bits, Figure 1's convention, is the usual way to locate a threshold in simulations, and it means the reversal comes from growing the code and its checking time together, not from the extra bits alone. Checked for the same seven rounds, these small codes still improve with size even at 15%: about 42%, 38% and 34% (this page's simulation). And at every setting discussed here each code still does better than one bare bit left alone for as long, though the margin vanishes where both fail about half the time.

The theorem assumes something real hardware does not quite deliver: that errors are mostly independent. Aharonov, Kitaev and Preskill extended it in 2006 to some kinds of long-range correlated noise, provided the correlations fall off fast enough.²² But a burst that hits many qubits at once, from a cosmic ray or a radioactive decay, is exactly what local checks are not built for. Google's team observed such bursts in detail across large arrays of superconducting qubits in a paper published in December 2021,²³ and Chapter 9 returns to the floor that rare correlated bursts still set.

Chapter 6A chessboard of checkers

The surface code is how chips try to meet the theorem. It descends from Kitaev's toric code, posted in 1997 and published in 2003: qubits on a grid wrapped round a doughnut-shaped torus, checks of four qubits each, and information stored in loops that wind round the torus.²⁴ In late 1998 Sergey Bravyi and Kitaev, and independently Michael Freedman and David Meyer, cut the torus open into a flat patch with edges, the version a chip can hold.^25,26

The layout used on today's chips, the rotated surface code, is a chessboard. A distance-d patch has d × d data qubits, which hold the information, at the corners of the squares. Its d² − 1 measure qubits, which ask the questions, sit one in each square, with a few more along the edges. Inside the patch each check touches four data qubits; on the edges, two. Half the checks are Z-type, looking for bit flips, and half X-type, looking for phase flips: the two kinds a real code needs (Chapter 4). Every check involves only neighbouring qubits, which suits a chip.²⁰ In all, a patch needs

n = d² + (d² − 1) = 2d² − 1 (17, 49 and 97 qubits for d = 3, 5 and 7)Data qubits plus measure qubits. Willow's distance-7 code used 101: 49 data, 48 measure and 4 for removing leakage.

A single X error on a data qubit inside the patch lights the two Z checks that include that qubit. A chain of X errors lights only the checks at its two ends, because each check along the middle sees two flips, an even number, and reports agreement. The decoder sees only the lit checks, called detection events, and guesses the shortest chains that explain them, pairing lit checks with each other or with the edge (minimum-weight matching).²⁷ If the guess is right, or differs from the truth only by a closed loop of flips, which leaves the stored qubit untouched, the correction undoes the error. If guess and truth together make a chain across the board, from one edge to the opposite one, the stored qubit has been flipped unseen: a logical error.

The distance d is the length of the shortest crossing chain, so a code of distance d corrects any ⌊(d − 1)/2⌋ errors wherever they fall: one at distance 3, two at 5, three at 7. It can be fooled by ⌈d/2⌉ errors in a bad place (three at distance 5: Figure 2's "Half a line"), and a whole line of d errors sets off no check at all. Picture neighbours comparing notes, with one twist: a guess that closes a chain across the board flips the stored qubit silently.

Figure 2 is such a board. Place errors, watch which checks light, and press Decode for the shortest explanation and its verdict. The toggle switches to the colour code that Helios used.

Figure 2♟️ Try it

A chessboard of checkers

Break a qubit, then decode

Chance each qubit breaks

Data + measure qubitsData qubits + checkers

Lit checksAlarms on

Errors placedBroken qubits

Corrects anyAlways fixes up to

OutcomeResult

A distance-d code with independent errors and perfect checks. Surface code: d × d data qubits (circles) and d² − 1 checks (squares; X-type pale, Z-type dark), weight 4 inside and 2 on the edges; X errors light the neighbouring Z checks, Z errors the X checks. Colour code: the 6.6.6 triangle with (3d² + 1)/4 data qubits and faces of weight 4 and 6, each both an X and a Z check. Decode finds a minimum-weight correction (matching for the surface code, exact search for the colour code) and reports whether what remains is a logical operator. Real hardware adds measurement errors, leakage and correlated faults, and decodes many rounds at once. This page's model.Each circle is a qubit; each square or hexagon is a checker that asks its neighbours whether they agree. Tap a qubit to break it and watch the alarms. Press Decode: the computer guesses the shortest explanation. Try "Half a line" and "A full line" (on the honeycomb, "Half an edge" and "A full edge") to see how a code can be fooled. The colour code is the honeycomb version Helios used. Here each qubit breaks on its own and the checkers never misread; real machines also have misreads, leaks and bursts that hit many qubits at once.

Helios uses a cousin, the colour code, introduced by Héctor Bombin and Miguel Ángel Martin-Delgado in 2006.²⁸ Its data qubits sit at the corners of a honeycomb of hexagons cut into a triangle, and each face, six-sided inside the triangle and four-sided along its edges, checks the qubits around it for both X and Z errors. A triangular colour code of distance d has (3d² + 1)/4 data qubits: 7, 19 and 37 for d = 3, 5 and 7. With two measure qubits for each face (the paper calls them syndrome qubits), Helios's memories used 13, 37 and 73 qubits in all.² At distance 7 that is 73 against the surface code's 97. Its other attraction is that every Clifford gate (the family that includes the Hadamard and the CNOT, the two-qubit gate that flips one qubit when the other is 1) can be applied transversally, qubit by qubit, so that a fault on one qubit cannot spread within a block.

Its price is in the checks. A check that touches six qubits needs more gates than one that touches four, and on superconducting chips the colour code has so far done worse than the surface code: Google's 2025 colour code divided its error by only 1.56 from distance 3 to 5.²⁹ Helios can pair any of its ions with any other,³ which suits heavier checks. Thresholds differ between codes, so Λs are not strictly comparable across them; the fair comparison is the logical error per round, with the code named.

Chapter 7Each step divides by Λ

Below the threshold, how fast does the error fall? For the surface code, Austin Fowler, Matteo Mariantoni, John Martinis and Andrew Cleland fitted the results of large simulations to a simple law in 2012,²⁰ and Google writes it in the same form:⁴

ε_d ≈ A (p/p_th)^(d+1)/2, Λ = ε_d/ε_d+2 ≈ p_th/pε_d: logical error per round at distance d; p: physical error per operation. Fowler et al.'s circuit model gives A ≈ 0.03 and p_th ≈ 0.57%. A fitted law, valid near and below threshold.

The exponent (d + 1)/2 is the number of errors it takes to fool a distance-d code, and the law says that each step up in distance, from d to d + 2, multiplies the error by the same factor p/p_th: it divides it by Λ. So Λ is the experiments' own measure of how far below threshold the hardware sits: above 1, bigger is better; below 1, bigger is worse. The fall is by a fixed factor at each step, until another kind of error, such as the correlated bursts of Chapter 5, takes over; it is not a fall to zero.

The threshold itself is not one number. It depends on the code, the noise model and the decoder. For the surface code with a matching decoder it is about 10.3% if only the data qubits err and the checks are perfect, and 2.93% if every check result is also misread as often as a qubit errs.²¹ With every gate, preparation and measurement in the circuit allowed to fail, estimates run from about 0.57% to about 1% per operation.^20,30,31

The law turns Λ into a bill of qubits. A target error per round needs the smallest odd distance whose ε_d reaches it, and a surface code of distance d uses 2d² − 1 qubits. At p = 0.1% per operation, the gate error assumed in the factoring estimates of Chapter 12, the law gives Λ = 5.7 and reaches one error in a million rounds at distance 11, with 241 qubits. One in a billion takes distance 19 and 721 qubits; one in a trillion, distance 27 and 1,457 qubits (this page's arithmetic from the fitted law).

An experiment's own Λ can be extrapolated the same way, as long as it is called an extrapolation. From Willow's 1.43 × 10⁻³ at distance 7 and its Λ = 2.14, Google projected that one error in a million rounds would need distance 27 and 1,457 physical qubits.⁴ This page's arithmetic reproduces it: a fall by a factor of 1,430, from 1.43 × 10⁻³ to 10⁻⁶, takes ln 1,430/ln 2.14 = 9.5 steps of two in distance, so d ≈ 7 + 2 × 9.5 ≈ 26, and the next odd distance is 27. The same distance and qubit count appeared above for one in a trillion: a coincidence of two different starting points.

Figure 3 draws the law. Set the physical error rate and read off Λ, the regime and the size a target needs; lay the experiments' points and their own trends over the line; or switch to "Against noise" to see the curves cross at the threshold.

Figure 3➗ Try it

Each step divides by Λ

Set the error rate

Physical error per operation, pHow often each part fails

Λ = p_th/pEach step divides errors by

RegimeWhich side of the line

Distance for 10⁻⁶Size for 1 in a million

Qubits (surface code, 2d² − 1)Qubits neededtoday's highest-fidelity machines: about a hundred (Willow 105, Helios 98)today's best machines: about a hundred good qubits (Willow 105, Helios 98)

Its own trendIf its trend held

Lines: the fitted surface-code law ε_d = 0.03 (p/p_th)^(d+1)/2 with p_th = 0.57% per operation (Fowler et al. 2012), valid near and below threshold; plotted values are capped at 0.5, a coin flip. "Against size" (the default) draws ε against d at the slider's p; "Against noise" draws ε against p for d = 3 to 15: the curves cross at p_th. Markers: measured logical error per round, by code; colour-code and repetition-code points do not share the surface code's threshold, so the line is a guide, not a fit to them. Dashed: each experiment's own trend at its measured Λ, an extrapolation. Qubit counts include measure qubits. Targets of 10⁻⁶ and 10⁻¹² are usually quoted per operation. This page's model and arithmetic; data as of October 2026.The line shows how often a code goes wrong as it grows. Below the threshold it falls (better); past it, it climbs (worse). Pick an experiment to see its real results and where its own trend would lead. The line is a formula, not data.

The figure needs a caution. The line is the surface code's, in Fowler's circuit model. To match Helios's Λ = 12 on it, p would have to be about 0.05% (this page's arithmetic). Helios's two-qubit gates fail about 0.08% of the time, but Helios runs a different code, with its own threshold (Chapter 6). No experiment's physical error rate should be read off this line.

Think of a thicker wall: each added layer divides the leak by the same factor. The picture holds only below the threshold and only for independent leaks; a burst that floods the whole wall is not stopped by thickness.

Part IIIThe record and its fine print

Chapter 8Three decades from paper to chip

The road from the theorem to Willow and Helios ran through many experiments, each measuring something slightly different: a gate fidelity, a lifetime, an error per round, sometimes after discarding the runs that went wrong.

In April 2014 John Martinis's group at the University of California, Santa Barbara, reported superconducting gates "at the surface code threshold", with two-qubit fidelities up to 99.4%:³² a statement about the parts, not yet about error correction. The same group's nine-qubit repetition code of 2015 preserved a classical state by repeated error detection.³³ In 2016 a Yale cat-code memory in a superconducting circuit became the first to outlast its best uncorrected part, by about 10%, using real-time feedback: the milestone called break-even.³⁴

In July 2021 Google's repetition codes, from 5 to 21 qubits, cut the logical error per round more than 100-fold, stable over 50 rounds.³⁵ The same year two trapped-ion groups ran fault-tolerant logical qubits. At Duke and Maryland a Bacon–Shor logical qubit on 13 ions ran fault-tolerant preparation, gates and stabiliser measurement, decoded afterwards from the final measurement because the system could not yet measure qubits mid-circuit.³⁶ At Honeywell, now Quantinuum, repeated rounds of Steane-code correction were decoded in real time.³⁷

Surface codes followed. ETH Zurich ran repeated correction in a distance-3 surface code in 2022 and reported about 3% error per cycle, counting only runs in which no leakage was detected.³⁸ In February 2023 Google's distance-5 surface code beat its distance-3 codes: 2.914% per cycle against an average of 3.028%, a margin of about 4% (Λ ≈ 1.04), which Google called "the first experimental demonstration where quantum error correction begins to improve performance with increasing qubit number".³⁹ A month later Yale's GKP code beat break-even by a factor of 2.27 ± 0.07, with real-time correction.⁴⁰

Then came scale, with caveats. Harvard, MIT and QuEra ran up to 48 logical qubits on neutral atoms in December 2023, mostly with error detection and post-selection: runs in which an error was flagged were discarded rather than corrected.⁴¹ In April 2024 Microsoft and Quantinuum reported, in a preprint, logical error rates 4.7 to 800 times below the physical ones, depending on code and circuit, with what the authors call "judicious use of post-selection". Their refereed paper (Nature, June 2026) reports 11 to 800 times, again with post-selection.⁴² Willow followed in December 2024 (Chapter 9).

In 2025 the field broadened. Amazon Web Services' Ocelot chip ran a repetition code of five cat qubits, the memory Nº 10 describes: the cat qubits hold off bit flips by themselves and the repetition code corrects phase flips, so it is a full logical memory, at 1.75% per cycle for distance 3 and 1.65% for distance 5.⁴³ Google's colour code reached 1.71% and 1.10% per cycle for distances 3 and 5 (Λ = 1.56).²⁹ On neutral atoms, a surface code from Harvard, MIT and QuEra reached 0.62% per round at distance 5, 2.14 times lower than at distance 3, over four rounds and without post-selection.⁴⁴ Google posted a preprint in November 2025 on reinforcement-learning control of error correction on Willow; it was published in Nature in July 2026.⁴⁵ In December 2025 a team at the University of Science and Technology of China reported in Physical Review Letters a distance-7 surface code below threshold, with all-microwave leakage suppression; this page could not check its numbers.⁴⁶

So far in 2026 the lowest per-round memory errors have come from trapped ions, though superconducting chips improved too: Google's reinforcement-learning paper (Nature, July 2026; its distance-7 result first posted in a March 2026 revision of the preprint) reached 7.72 × 10⁻⁴ per round in a distance-7 surface code. In September Quantinuum's Helix code, [[20,2,6]] (2 logical qubits in 20 data qubits, at distance 6), reached about 4.6 × 10⁻⁵ per logical qubit per round on Helios (a preprint),⁴⁷ and in October the colour-code memory of Chapter 1 reached 5 × 10⁻⁶ per round, from three failures, also in a preprint.²

Figure 4 plots the results that have a per-round number and marks the rest as dated events.

Figure 4📉 Try it

From threshold gates to five in a million

Step through the years

Milestone

SelectedPicked

Logical error per roundErrors per round

Code and distanceCode

StatusChecked?

Logical error per round of error correction, where a paper gives one, against date. Filled markers refereed, open markers preprints; shape gives the code, as in Figure 3, and the label the platform. Codes and definitions differ (surface, colour and repetition codes; one point is per logical qubit of a two-qubit block; the 2022 point counts only runs without detected leakage), so the points are milestones, not a trend or a forecast. Ticks below the axis are results without a comparable per-round number. Horizontal lines: the physical two-qubit gate errors of Willow (the mean randomised-benchmarking CZ error with all gates running, from Google's spec sheet) and Helios (the average infidelity, from its refereed hardware paper), two different definitions, and the megaquop and teraquop scales. As of 25 October 2026.Each dot is an error-corrected memory, placed by when it was reported and how often it went wrong per round (lower is better). Hollow dots are not yet checked in a journal. Step through the years or press Play. The dots use different codes and machines, so this is a list of milestones, not a straight line into the future. Marks under the axis have no per-round number. Flat lines: how often one gate fails on Willow and on Helios, and 1 in a million and 1 in a trillion.

From 2022 to 2026 the plotted error per round fell by nearly four orders of magnitude, from about 3 × 10⁻² to 5 × 10⁻⁶, but across different codes, machines and definitions, and the last two points are preprints. Among the refereed results plotted the best is Google's 7.72 × 10⁻⁴ (Willow, Nature, July 2026).

Chapter 9Willow: definitively below threshold

Willow is a 105-qubit superconducting chip whose qubits are transmons, and Google's spec sheet describes two such chips. On the one used for error correction, one round of the surface code takes 1.1 microseconds (µs).⁴ The spec sheet gives that chip's mean two-qubit (CZ) gate error as 0.33%, measured by randomised benchmarking (long random gate sequences, whose result fades with length at a rate set by the average error per gate) with all gates running at once and reported as an "average error".⁴⁸

On it Google ran surface-code memories at distances 3, 5 and 7, the last on 101 qubits. With a neural-network decoder the logical error per cycle was (6.50 ± 0.06) × 10⁻³ at distance 3, (3.03 ± 0.03) × 10⁻³ at distance 5 and (1.43 ± 0.03) × 10⁻³ at distance 7.⁴ Fitted over up to 250 cycles and averaged over the X and Z bases, that is Λ = 2.14 ± 0.02: each step more than halved the error.

The distance-7 logical qubit also outlived the chip's best physical qubit: 291 ± 6 µs against 119 ± 13 µs, a factor of 2.4 ± 0.3 beyond break-even.⁴ Both are Google's effective lifetimes, averaged uniformly over every state the qubit could be prepared in. They are not the mean time between logical errors, the round time divided by the error per round, which for Willow is 1.1 µs ÷ 1.43 × 10⁻³ = 0.77 ms (this page's arithmetic). One comparison should use one measure.

The headline was decoded offline, by the neural network at about 24 µs per cycle. Real-time decoding was shown on a 72-qubit sister chip at distance 5: 0.35% per cycle, Λ = 2.0 ± 0.1, an average decoder latency of 63 µs and runs of up to a million cycles.⁴ Google's error budget for that chip, not for Willow itself, shares out 1/Λ, which by Chapter 7's law is about p/p_th, among the sources of error. Its CZ gates, whose error there is about 2.8 × 10⁻³, account for about 60% of it: 41% from the gates' own errors, 11% from crosstalk (operations disturbing qubits they are not meant to touch) and 5% from leakage. Two-qubit gates are the main source of trouble.

The same paper, on the 72-qubit sister chip, pushed repetition codes to distance 29, with Λ = 8.4 ± 0.1, and found an apparent floor near 10⁻¹⁰ per cycle, set by rare correlated bursts about once an hour, whose origin is not yet understood. A redesign of the qubits' junctions ("gap engineering"), the paper says, had already broken through the earlier floor near 10⁻⁶ set by the cosmic-ray bursts of Chapter 5.⁴ Such a floor marks where the theorem's assumption of independent errors stops holding; it is an open problem.

Google's own framing is careful. Before Willow, the paper says, "no quantum processor has definitively shown below-threshold performance".⁴ Bigger codes had done better before: repetition codes, which guard against one kind of error, had improved with size since 2021, and Google's own 2023 surface code had beaten its smaller siblings by about 4% (Chapter 8). Willow was the first clear demonstration for a surface code, a full quantum code, with Λ above 2 over two steps.

Chapter 10Three failures in 29,000 runs

Helios's 98 qubits are each held in two hyperfine "clock" states of a barium-137 ion, and the machine moves ions about so that any two can be brought together. Its refereed hardware paper gives average infidelities of 2.5 × 10⁻⁵ for one-qubit gates, 7.9 × 10⁻⁴ for two-qubit gates and 3.3 × 10⁻⁴ for state preparation and measurement (its arXiv version gave 4.8 × 10⁻⁴ for the last).³ For the colour-code work the two-qubit gate was measured again, by randomised benchmarking, at 9.1 × 10⁻⁴ without a leakage repump and 8.4 × 10⁻⁴ with one. That was a separate benchmark, not a measurement made inside the memory runs.²

Each pass of the machine ran several memories side by side: six distance-3 codes, two distance-5 codes or one distance-7 code. The checks used a variant of the "superdense" syndrome circuit, with two measure qubits for each face and a CNOT depth of 7 (seven successive layers of CNOT gates). With Tesseract, a search-based decoder from Google Quantum AI and the first of four the paper compares, the results per round were these:²

Distance	Qubits	Runs of 20 rounds	Failures	Logical error per round
3	13	15,840	178	5.5 (± 0.4) × 10⁻⁴
5	37	21,600	17	3.8 (+1/−0.8) × 10⁻⁵
7	73	29,000	3	5 (+4/−2) × 10⁻⁶

From the paper's Table 1, a preprint. All six logical Pauli states are pooled; the uncertainties are one-sigma Wilson intervals.

The fitted Λ is 12 (+3/−2), from a straight-line fit of the logarithm of the error against distance. The step-by-step ratios are 14.5 from distance 3 to 5 and 7.6 from 5 to 7 (this page's arithmetic), consistent with the fit. The decoder matters: the paper's other three decoders give Λ of 7 to 11, and at distance 7 two of them also see three failures, while the third sees five, 8 × 10⁻⁶ per round.²

Three failures make a wide, lopsided interval. The paper's one-sigma Wilson interval runs from about 2.9 to 8.9 × 10⁻⁶ per round. An exact Poisson interval for three events at the same confidence gives about 2.3 to 10 × 10⁻⁶, and at 95% confidence the data allow about 1 to 15 in a million (this page's arithmetic). Figure 5 reruns the campaign at any true error rate you choose, to show how far the count of failures wanders by chance.

Figure 5🎲 Try it

Three failures in 29,000

Run the experiment again

True error per round (in a million)

Failures, fRuns that failed

Estimate ε̂ = f/(20.5 n)How often it goes wrong

One-sigma range (Wilson)Could easily be

Rounds observed, 20 nRounds in all

Campaigns runTimes you re-ran it

Per second (this page's estimate, at the headline's 5.05 × 10⁻⁶ per round, whatever is set above)

Helios round time (this page's estimate)

Outside this page's estimate of 0.2 to 0.4 s per round.

Willow: mean time between logical errors

Helios: mean time between logical errors

Logical errors per second

A Helios round takes longer by

Each cell is one run of 20 rounds of error correction on a stored logical qubit; filled cells are runs that ended wrong. Each run fails with probability (20 + ½)ε, the inverse of the paper's estimator ε̂ = (f/n)/20.5, and runs are independent. The range is the one-sigma Wilson interval, as in the paper; at 95% confidence the d = 7 data allow about 1 to 15 in a million (this page's Poisson arithmetic). Real campaigns can differ in ways this model ignores, such as drifting calibration or the mid-campaign software fix that the paper says did not significantly affect the result. Where in the sequence the real failures fell is not published: their places here are illustrative. The per-second panel rests on this page's estimate of the Helios round time. Data: arXiv:2610.24077, a preprint, as of October 2026. This page's model.Each tiny square is one 20-round run of the Helios memory; the lit ones failed. Press "Run the campaign again" to replay it with the same machine: the count of failures jumps around just by chance. That's why 3 failures give a wide range, and why the smaller codes, with many more, give sharper numbers. The paper, not yet checked in a journal, gives only how many runs failed, so where the lit squares sit is made up.

Run 100 campaigns at a true 5 in a million and about 87% of them see between one and five failures, and about 22% see exactly three (this page's model). Three was a fairly typical result.

A close reading of the paper adds three points. It describes no discarded runs: its Table 1 totals account for all 66,440 hardware records, and it never uses the words "post-selection" or "postselect", so "no post-selection" is this page's inference. The paper pools runs taken before and after a mid-campaign fix to the software that tracks the qubits' phases, and says the extra phase errors in the earlier runs "did not significantly affect the LER", the logical error rate, so pooling, if anything, makes the headline conservative. And the paper's error budget, from its emulator, shares out 1/Λ as Google's does (Chapter 9): two-qubit gates 43%, memory errors (mostly from moving the ions) 36%, crosstalk from mid-circuit measurement and reset 13%. Leakage is not a fourth share: it runs through those channels and accounts for 41% of the total.²

A rate is not a duration. One failure in about 200,000 rounds (1/ε, this page's arithmetic) is an average; every run stopped at 20 rounds. In the standard logical-flip model (Google's, used to define its error per round; the Helios paper uses only the estimator of Chapter 1), a second logical flip undoes the first, so the chance of a wrong readout after n rounds is

P(n) = ½ [1 − (1 − 2ε)ⁿ]It never exceeds one half. At n = ln 2/ε ≈ 140,000 rounds, half the stored qubits would have suffered at least one logical flip, but only 37.5% would read out wrong, since some would have flipped an even number of times (this page's arithmetic, an extrapolation far beyond the 20-round runs).

Chapter 11What the number is, and is not

Quantinuum's own words need care. Its technical blog of 19 October says Helios "achieved a logical memory fidelity of 99.9995%" and calls that "just five uncorrectable errors per million operations"; the same blog also states that the figure is "99.9995% per syndrome-extraction cycle".¹ The second is right: the number is per round on a stored logical qubit, not per operation. A blog of 21 October calls the result "the fidelity of the logical computation"; that framing is Quantinuum's, and a memory is not yet a computer.

Decoding was offline: the paper says that "all decoding in this work has been done offline". Its neural decoders, at 0.22 to 0.52 ms of GPU time per round, are fast enough for real time, the paper says, but were timed offline rather than run in the loop, and corrections were tracked in software (a Pauli frame), not applied as pulses.² Quantinuum has decoded in real time since 2021, on its H1 machine (Chapter 8).³⁷ In a memory, decoding afterwards gives the same answer as decoding live; in a computation the decoder must keep up to decide the next operation. For a below-threshold code that grows in distance, real-time decoding has so far been shown only by Google, at distance 5 on its 72-qubit chip, as far as we can find.⁴

One round of the whole distance-7 memory (5 × 10⁻⁶, from three failures, in a preprint) failed about 170 times less often than one physical two-qubit gate (8.4 × 10⁻⁴ ÷ 5 × 10⁻⁶; this page's arithmetic). These are different things: the code's 18 faces need about 180 to 220 two-qubit gates a round, which at 8.4 × 10⁻⁴ each is about 0.15 to 0.18 gate faults per round, or one physical fault every six rounds or so, against one logical failure per 200,000 rounds on average (this page's estimate).

The headline multipliers are Quantinuum's own. Its press release calls the error rate "100 times lower than the best published result across all other hardware modalities" and "10x lower than Quantinuum's own September 2026 record".¹ The blog and its footnotes give the company's comparisons with Google's results: the refereed 0.143% is 286 times Helios's rounded 5 × 10⁻⁶, and the 0.0772% of Google's reinforcement-learning paper (Nature, July 2026) 154 times.^4,45 The September record was Helix's (Chapter 8). Against it the central values give a ratio of 9.1, but both numbers have wide error bars, so the ratio could lie anywhere from about 2 to about 40 (this page's arithmetic). The two also measure slightly different things: one logical qubit of a two-qubit block against a single logical qubit.⁴⁷ The release also quotes Robin Blume-Kohout of Sandia National Laboratories, who was not involved in the study, on "a logical qubit nearly 100x better than its component physical qubits": a third "100", different from the comparison with other hardware and from this page's 170.

Per second is the last measure, and it needs a round time, which the colour-code paper does not give. The Helios hardware paper gives an average of 55 ms per gate layer for random circuits on all 98 qubits, transport, sorting and cooling included.³ A distance-7 round's 180 to 220 gates fill five to seven circuit layers (73 ions allow at most 36 pairs a layer, which Helios runs in batches across its eight operation zones), about 0.3 s at 55 ms a layer (a CNOT depth of 7 gives 0.39 s). Layers on fewer ions may be faster, so this page puts a Helios round at a few tenths of a second, about 0.2 to 0.4 s (this page's estimate). Quantinuum's blog calls its decoders' "sub-millisecond latency" "10-100x faster than needed", and the paper's abstract says they can decode "an order of magnitude faster than the syndrome extraction rate"; both would imply shorter rounds, which this page cannot reconcile with the hardware paper's layer time, so every number below is good only to an order of magnitude.

mean time between logical errors = t_round / εWillow: 1.1 µs ÷ 1.43 × 10⁻³ = 0.77 ms. Helios: (0.2 to 0.4 s) ÷ 5.05 × 10⁻⁶ (the central value from the preprint's three failures) ≈ 40,000 to 80,000 s, about 11 to 22 hours. This page's arithmetic; the Helios figure rests on this page's round-time estimate and extrapolates from runs of 20 rounds.

Per second, then, the ion memory is also ahead: roughly half a day to a day between logical errors, against under a millisecond (the panel under Figure 5 varies the round time). But a round takes a couple of hundred thousand times longer on Helios (a few tenths of a second against 1.1 µs; this page's estimate), so a computation that needs many rounds would run far faster on the superconducting chip. Google's 291 µs is a different measure, an all-states lifetime, on which Helios would come out at about half its mean time between errors, 5.5 to 11 hours, since its rate is pooled over all six starting states (this page's estimate).

Chapter 12From a memory to a computer

Storing a qubit is step one; a computer needs logical gates. Helios has run logical two-qubit Clifford gates, characterised by randomised benchmarking, at distances 3 and 5 only: about 7 × 10⁻⁴ per gate at distance 3 and 7 (± 3) × 10⁻⁵ at distance 5, a factor the paper gives as about 9, with wide error bars. Two distance-7 blocks of 73 qubits each would not fit on the 98-qubit machine.²

Clifford gates alone cannot run every quantum algorithm. The missing non-Clifford ingredient is usually supplied by consuming special resource states, magic states. On 15 October 2026 Google reported in Science "magic state cultivation" on a superconducting processor, which "reduces the error by a factor of 40, with a state fidelity of at least 0.9999(1) (retaining 8% of attempts)": an error of at most about one in 10,000, with 92% of attempts discarded.⁴⁹ A 2025 Quantinuum preprint made magic states at 7 × 10⁻⁵ infidelity on its 20-qubit H1-1 machine, in an error-detecting code, discarding 14.8% of attempts.⁵⁰ A 2026 JPMorganChase–Quantinuum paper, accepted by Physical Review X in October 2026, ran whole algorithms using only fault-tolerant components; its logical T gate, benchmarked on its own on the H2 machine, had an infidelity of 2.6 × 10⁻³ (the figure in its arXiv version), post-selected on successful magic-state preparation.⁵¹ None of these is a non-Clifford operation inside a long below-threshold computation, and Quantinuum's own blog of 19 October adds that "nobody has yet demonstrated below threshold scaling for magic state preparation".¹

Two more things must hold as codes grow: decoding must keep up in real time at these error rates, so far shown for a growing code only at distance 5 (Chapter 11), and floors set by correlated errors must stay below the target. If Helios's trend held, distance 21 to 23, roughly 660 to 800 qubits in its colour-code layout, would reach about one error in a trillion rounds: distance 21 with the fitted Λ = 12, which is Quantinuum's projection, or 23 if each step gave only the last measured factor of 7.6 (this page's arithmetic). That is an extrapolation over seven or eight steps in distance, starting from three failures.

The targets have names. John Preskill's "megaquop machine" can run about a million quantum operations, which needs logical errors of order 10⁻⁶ per operation;⁵² the "teraquop" regime, a trillion operations, needs about 10⁻¹².⁵³ Both are per operation, so a memory's per-round number is only a step towards them.

The best-known goal is factoring. Craig Gidney and Martin Ekerå estimated in 2019 (published 2021) that breaking 2048-bit RSA, a widely used public-key encryption scheme, would take 20 million noisy qubits running for 8 hours. Gidney's preprint of May 2025 cut that to under a million noisy qubits for under a week, partly by using magic-state cultivation; both assume 0.1% gate errors and a 1 µs cycle.⁵⁴ Two 2026 preprints using other codes or hardware claim far fewer: the Pinnacle architecture, built on quantum LDPC codes (next paragraph), fewer than 100,000 physical qubits at the same error rate and cycle;⁵⁵ and Cain, Preskill, Bluvstein and colleagues, "as few as 10,000 reconfigurable atomic qubits" for Shor's factoring algorithm, with much longer runtimes.⁵⁶ None of the three newer estimates is refereed as of 25 October 2026. Today's highest-fidelity machines have about a hundred qubits (Willow 105, Helios 98). Larger arrays exist (Cain and colleagues cite neutral-atom arrays of more than 6,000 coherent qubits; IBM announced its 1,121-qubit Condor in December 2023),⁵⁷ but none runs error-corrected algorithms at that scale.

Other codes promise fewer qubits per logical qubit. In quantum LDPC (low-density parity-check) codes each check touches only a few qubits, which need not be neighbours. IBM's bivariate-bicycle "gross" code, one of them, stores 12 logical qubits in 288 physical qubits with a threshold near 0.7%, in simulation.⁵⁸

Chapter 13Faster than they pile up

Every piece is now in place: no copies and no peeking (Chapter 3), checks that learn the error and nothing else (Chapter 4), a threshold below which size helps (Chapter 5), and Λ to measure how far below it a machine sits (Chapter 7). Together they say that a qubit cannot be copied, and looking at it disturbs it, yet it can be protected: spread one qubit's information across many, and keep asking only whether neighbours agree. If every part is good enough, below the threshold, each step up in size divides the error by a fixed factor: about 2 on Willow, about 12 on Helios. In October 2026 a trapped-ion memory failed about 5 times per million rounds of checking, three failures in 29,000 runs of 20 rounds each, in a preprint.

Firefighters make a fair picture. Below the threshold the crew puts out sparks faster than they spread; above it, more firefighters means more people tripping over hoses. The picture breaks in one place: in both headline experiments the sparks were not put out on the spot. The checks were measured every round, the errors logged, and the books balanced afterwards in software. "Catches", not "fixes", is the accurate verb.

The credit line is long. Peter Shor (1995) and Andrew Steane (1996) found the first quantum codes; Aharonov and Ben-Or, Kitaev, and Knill, Laflamme and Zurek (1996–98) proved the threshold theorem; Kitaev (1997) invented the toric code, the ancestor of the surface code, and Bravyi and Kitaev, and Freedman and Meyer (1998), gave it edges, the flat version that chips use; Google Quantum AI (December 2024) showed it working below threshold; Quantinuum (October 2026, preprint) pushed a colour-code memory to about 5 × 10⁻⁶ per round.

Below the threshold, the mistakes are caught faster than they pile up.

Glossary

Qubit, physical and logical: A physical qubit is one two-level system, such as an ion or a transmon; a logical qubit is one qubit's information spread by a code across many.
Fidelity, infidelity: How close a state or operation comes to the intended one; infidelity is one minus fidelity.
Bit flip (X), phase flip (Z), Y error: The three basic qubit errors: swapping |0⟩ and |1⟩, changing the sign between them, or both. Measuring checks reduces every error to these.
Check (stabiliser), parity: A measurement that asks whether a group of qubits agree, even or odd, without revealing the information they store.
Syndrome: The pattern of check results in a round. It locates errors and says nothing about the stored state.
Decoder: The software that turns syndromes into a correction, for example by minimum-weight matching: the shortest set of errors that explains the lit checks.
Round (cycle): One measurement of every check in a code.
Logical error per round, ε_d: The chance that one round of a distance-d code ends with the stored qubit wrong after decoding.
Code distance, d: The fewest physical errors that can change the stored qubit unseen. A distance-d code corrects any ⌊(d − 1)/2⌋ errors.
Threshold, p_th: The physical error rate below which bigger codes fail less and above which they fail more. It depends on the code, the noise and the decoder.
Λ (lambda): The factor by which the logical error falls with each step from distance d to d + 2; about p_th/p. Above 1, bigger is better.
Repetition, surface and colour codes: A repetition code guards against one kind of error; the surface code (a square lattice) and the colour code (a honeycomb) guard against both.
Clifford and non-Clifford gates: Clifford gates, such as the CNOT and the Hadamard, are the easier family; a universal computer also needs a non-Clifford gate, such as the T gate.
Magic state: A resource state that, consumed in a circuit, supplies a non-Clifford gate.
Post-selection: Keeping only the runs in which no error was flagged, and discarding the rest.
Break-even: A logical qubit outliving the best physical part it is made from.
Fault-tolerant: Built so that one fault, in a gate, a check or a measurement, cannot spread into more errors than the code can correct.
Leakage: A qubit escaping its two working levels into another state.
Offline and real-time decoding: Decoding after the experiment, or fast enough during it to decide the next operation.
T₁, transmon: T₁ is a qubit's energy lifetime. A transmon is a superconducting circuit with two working energy levels, controlled with microwaves.
Preprint: A paper posted publicly, usually on arXiv, before peer review. As of 25 October 2026 the Helios colour-code paper is one.

Sources

Quantinuum, "Quantinuum Breaks Error-Correction World Record by 10x, Validating its Leading Path to Fault-Tolerant Quantum Computing by 2029" (press release, 19 October 2026), quantinuum.com/press-releases (wire copy at kyodonewsprwire.jp); "Quantinuum closes in on one million error-free operations" (technical blog, 19 October 2026), quantinuum.com/blog; D. Hayes, "Quantinuum and Google: Two Fault-Tolerance Results, Two Different Measures of Progress" (blog, 21 October 2026), quantinuum.com/blog. Company announcements, read 24 October 2026.
A. Lavasani, A. P. Reed, J. M. Dreiling et al., "Quantum error correction well below the color code threshold" (submitted 16 October 2026, preprint), arXiv:2610.24077.
A. Ransford et al., "A 98-qubit trapped-ion quantum computer with all-to-all connectivity," Nature 655, 81 (2026), doi:10.1038/s41586-026-10676-4, arXiv:2511.05465.
Google Quantum AI and Collaborators, "Quantum error correction below the surface code threshold," Nature 638, 920 (2025), doi:10.1038/s41586-024-08449-y, arXiv:2408.13687.
M. A. Nielsen and I. L. Chuang, Quantum Computation and Quantum Information, 10th anniversary edition (Cambridge University Press, 2010).
E. Knill and R. Laflamme, "Theory of quantum error-correcting codes," Phys. Rev. A 55, 900 (1997), doi:10.1103/PhysRevA.55.900.
R. W. Hamming, "Error detecting and error correcting codes," Bell Syst. Tech. J. 29, 147 (1950), doi:10.1002/j.1538-7305.1950.tb00463.x.
J. von Neumann, "Probabilistic logics and the synthesis of reliable organisms from unreliable components," in Automata Studies, Ann. Math. Stud. 34, 43 (Princeton University Press, 1956).
W. K. Wootters and W. H. Zurek, "A single quantum cannot be cloned," Nature 299, 802 (1982), doi:10.1038/299802a0.
D. Dieks, "Communication by EPR devices," Phys. Lett. A 92, 271 (1982), doi:10.1016/0375-9601(82)90084-6.
J. L. Park, "The concept of transition in quantum mechanics," Found. Phys. 1, 23 (1970), doi:10.1007/BF00708652.
J. Ortigoso, "Twelve years before the quantum no-cloning theorem," Am. J. Phys. 86, 201 (2018), doi:10.1119/1.5021356.
P. W. Shor, "Scheme for reducing decoherence in quantum computer memory," Phys. Rev. A 52, R2493 (1995), doi:10.1103/PhysRevA.52.R2493.
A. M. Steane, "Error correcting codes in quantum theory," Phys. Rev. Lett. 77, 793 (1996), doi:10.1103/PhysRevLett.77.793.
A. R. Calderbank and P. W. Shor, "Good quantum error-correcting codes exist," Phys. Rev. A 54, 1098 (1996), doi:10.1103/PhysRevA.54.1098.
R. Laflamme, C. Miquel, J. P. Paz and W. H. Zurek, "Perfect quantum error correcting code," Phys. Rev. Lett. 77, 198 (1996), doi:10.1103/PhysRevLett.77.198.
D. Aharonov and M. Ben-Or, "Fault-tolerant quantum computation with constant error rate," SIAM J. Comput. 38, 1207 (2008), doi:10.1137/S0097539799359385, arXiv:quant-ph/9611025 (1996).
E. Knill, R. Laflamme and W. H. Zurek, "Resilient quantum computation," Science 279, 342 (1998), doi:10.1126/science.279.5349.342.
A. Yu. Kitaev, "Quantum computations: algorithms and error correction," Russ. Math. Surv. 52, 1191 (1997), doi:10.1070/RM1997v052n06ABEH002155.
A. G. Fowler, M. Mariantoni, J. M. Martinis and A. N. Cleland, "Surface codes: towards practical large-scale quantum computation," Phys. Rev. A 86, 032324 (2012), doi:10.1103/PhysRevA.86.032324, arXiv:1208.0928.
C. Wang, J. Harrington and J. Preskill, "Confinement-Higgs transition in a disordered gauge theory and the accuracy threshold for quantum memory," Ann. Phys. 303, 31 (2003), doi:10.1016/S0003-4916(02)00019-2, arXiv:quant-ph/0207088.
D. Aharonov, A. Kitaev and J. Preskill, "Fault-tolerant quantum computation with long-range correlated noise," Phys. Rev. Lett. 96, 050504 (2006), doi:10.1103/PhysRevLett.96.050504.
M. McEwen et al., "Resolving catastrophic error bursts from cosmic rays in large arrays of superconducting qubits," Nat. Phys. 18, 107 (2022), doi:10.1038/s41567-021-01432-8.
A. Yu. Kitaev, "Fault-tolerant quantum computation by anyons," Ann. Phys. 303, 2 (2003), doi:10.1016/S0003-4916(02)00018-0, arXiv:quant-ph/9707021 (1997).
S. B. Bravyi and A. Yu. Kitaev, "Quantum codes on a lattice with boundary" (20 November 1998, preprint), arXiv:quant-ph/9811052.
M. H. Freedman and D. A. Meyer, "Projective plane and planar quantum codes," Found. Comput. Math. 1, 325 (2001), doi:10.1007/s102080010013, arXiv:quant-ph/9810055 (1998).
E. Dennis, A. Kitaev, A. Landahl and J. Preskill, "Topological quantum memory," J. Math. Phys. 43, 4452 (2002), doi:10.1063/1.1499754.
H. Bombin and M. A. Martin-Delgado, "Topological quantum distillation," Phys. Rev. Lett. 97, 180501 (2006), doi:10.1103/PhysRevLett.97.180501.
N. Lacroix et al., "Scaling and logic in the colour code on a superconducting quantum processor," Nature 645, 614 (2025), doi:10.1038/s41586-025-09061-4, arXiv:2412.14256.
R. Raussendorf and J. Harrington, "Fault-tolerant quantum computation with high threshold in two dimensions," Phys. Rev. Lett. 98, 190504 (2007), doi:10.1103/PhysRevLett.98.190504.
D. S. Wang, A. G. Fowler and L. C. L. Hollenberg, "Surface code quantum computing with error rates over 1%," Phys. Rev. A 83, 020302 (2011), doi:10.1103/PhysRevA.83.020302.
R. Barends et al., "Superconducting quantum circuits at the surface code threshold for fault tolerance," Nature 508, 500 (2014), doi:10.1038/nature13171.
J. Kelly et al., "State preservation by repetitive error detection in a superconducting quantum circuit," Nature 519, 66 (2015), doi:10.1038/nature14270.
N. Ofek et al., "Extending the lifetime of a quantum bit with error correction in superconducting circuits," Nature 536, 441 (2016), doi:10.1038/nature18949.
Google Quantum AI, "Exponential suppression of bit or phase errors with cyclic error correction," Nature 595, 383 (2021), doi:10.1038/s41586-021-03588-y.
L. Egan et al., "Fault-tolerant control of an error-corrected qubit," Nature 598, 281 (2021), doi:10.1038/s41586-021-03928-y.
C. Ryan-Anderson et al., "Realization of real-time fault-tolerant quantum error correction," Phys. Rev. X 11, 041058 (2021), doi:10.1103/PhysRevX.11.041058.
S. Krinner et al., "Realizing repeated quantum error correction in a distance-three surface code," Nature 605, 669 (2022), doi:10.1038/s41586-022-04566-8.
Google Quantum AI, "Suppressing quantum errors by scaling a surface code logical qubit," Nature 614, 676 (2023), doi:10.1038/s41586-022-05434-1, arXiv:2207.06431.
V. V. Sivak et al., "Real-time quantum error correction beyond break-even," Nature 616, 50 (2023), doi:10.1038/s41586-023-05782-6.
D. Bluvstein et al., "Logical quantum processor based on reconfigurable atom arrays," Nature 626, 58 (2024), doi:10.1038/s41586-023-06927-3.
A. Paetznick et al., "Demonstration of logical qubits and repeated error correction with better-than-physical error rates" (2024, preprint), arXiv:2404.02280; refereed successor: A. Paetznick et al., "Improved quantum processor logical error rates via correction and detection," Nature 654, 349 (2026), doi:10.1038/s41586-026-10628-y.
H. Putterman et al., "Hardware-efficient quantum error correction via concatenated bosonic qubits," Nature 638, 927 (2025), doi:10.1038/s41586-025-08642-7, arXiv:2409.13025.
D. Bluvstein et al., "A fault-tolerant neutral-atom architecture for universal quantum computation," Nature 649, 39 (2026), doi:10.1038/s41586-025-09848-5, arXiv:2506.20661.
V. Sivak et al., "Reinforcement learning control of quantum error correction," Nature 655, 879 (2026), doi:10.1038/s41586-026-10759-2, arXiv:2511.08493 (November 2025; distance-7 result first in v3, March 2026).
T. He et al., "Experimental quantum error correction below the surface code threshold via all-microwave leakage suppression," Phys. Rev. Lett. 135, 260601 (2025), doi:10.1103/rqkg-dw31.
N. Berthusen, A. Lavasani, A. Benhemou et al., "Experimental validation of a compact fault-tolerant architecture for trapped ions" (2026, preprint), arXiv:2609.03194.
Google Quantum AI, "Willow Spec Sheet" (company document, 9 December 2024, read 24 October 2026), quantumai.google.
E. Rosenfeld, C. Gidney, G. Roberts et al. (Google Quantum AI), "Magic state cultivation on a superconducting quantum processor," Science (published online 15 October 2026), doi:10.1126/science.aee7961.
S. Dasu et al., "Breaking even with magic: demonstration of a high-fidelity logical non-Clifford gate" (2025, preprint), arXiv:2506.14688.
M. A. Perlin et al. (JPMorganChase and Quantinuum), "Fault-tolerant execution of error-corrected quantum algorithms," Phys. Rev. X (accepted 9 October 2026), doi:10.1103/gnq3-c2df, arXiv:2603.04584.
J. Preskill, "Beyond NISQ: the megaquop machine," ACM Trans. Quantum Comput. 6(3), 1 (2025), doi:10.1145/3723153, arXiv:2502.17368.
C. Gidney, M. Newman, A. Fowler and M. Broughton, "A fault-tolerant honeycomb memory," Quantum 5, 605 (2021), doi:10.22331/q-2021-12-20-605.
C. Gidney and M. Ekerå, "How to factor 2048 bit RSA integers in 8 hours using 20 million noisy qubits," Quantum 5, 433 (2021), doi:10.22331/q-2021-04-15-433; C. Gidney, "How to factor 2048 bit RSA integers with less than a million noisy qubits" (2025, preprint), arXiv:2505.15917.
P. Webster, L. Berent, O. Chandra et al., "The Pinnacle Architecture: Reducing the cost of breaking RSA-2048 to 100 000 physical qubits using quantum LDPC codes" (2026, preprint), arXiv:2602.11457.
M. Cain, Q. Xu, R. King, L. R. B. Picard, H. Levine, M. Endres, J. Preskill, H.-Y. Huang and D. Bluvstein, "Shor's algorithm is possible with as few as 10,000 reconfigurable atomic qubits" (2026, preprint), arXiv:2603.28627.
J. Gambetta, "The hardware and software for the era of quantum utility is here" (IBM Quantum blog, 4 December 2023; company announcement), ibm.com/quantum/blog.
S. Bravyi et al., "High-threshold and low-overhead fault-tolerant quantum memory," Nature 627, 778 (2024), doi:10.1038/s41586-024-07107-7.