# Quantum Error Correction, Cycle by Cycle

Laplace’s Mini World · Plate F58 · Chips & Information · Quantum

> Every 1.1 µs the chip checks parities and notes what changed; a decoder pairs the changes into errors, and must keep up.

- Interactive model: https://world.lapla.si/en/qec/
- Embed: https://world.lapla.si/embed/en/qec/
- 中文: https://world.lapla.si/zh/qec/
- Updated: 2026-10-28

## 01 Round after Round

On Google’s Willow chip, a logical qubit is checked once every 1.1 µs: dozens of measure qubits read the parities of their neighbouring data qubits all at once. Round after round the checks go on, and an error leaves a trace as soon as it appears.

On the stand, a model of that: a chip in an opened sample box, and above it glass sheets, one for each round, the newest rising from below. Red beads are checks whose result changed in that round; red threads are the pairs the decoder has made.

In 2024 Google Quantum AI ran surface codes of distance 3, 5 and 7 this way: each step of 2 in distance divided the logical error per cycle by about 2.14, to 0.143 % at distance 7 (for how a bigger code gets better, see the plate “Superconducting Qubits and Error Correction”).

*A round every 1.1 µs · a glass sheet per round · Willow, distance 7: 0.143 % per cycle, Λ = 2.14*

## 02 Microseconds Against Hours

A single qubit on Willow lived 85 µs (median), the best 119 µs. Useful quantum algorithms run for hours: at 1.1 µs a cycle, an hour is about 3 × 10⁹ cycles.

Many applications need each operation to fail less than once in ten billion (10⁻¹⁰); the best two-qubit gates on many-qubit chips have only just reached about one error in a thousand. And a quantum state can’t be copied or looked at directly (see the plate “Superconducting Qubits and Error Correction”). So error correction is not one check but a check every cycle, on and on.

Willow’s distance-⁠7 logical qubit lived 291 µs, 2.4 times as long as the best single qubit in it: checked cycle after cycle, the memory already beats one qubit.

*Single qubits: 85 µs median, 119 µs best · an hour is about 3 × 10⁹ cycles · logical qubit: 291 µs*

## 03 One Cycle: Parities Only

The data qubits, which hold the logical qubit, sit in a d × d square; measure qubits sit between them. Each measure qubit runs four two-qubit gates (CZ) in turn with the data qubits around it, which moves their parity onto it; then it is read out and reset.

All it reads is a parity: whether those qubits’ values add up to odd or even, not what any one of them is, so the stored information is left alone. Half the measure qubits check Z parities and catch bit flips; half check X parities and catch phase flips. Every check runs at once.

On the 2023 Sycamore chip a cycle took 921 ns: 34 ns two-qubit gates, a 500 ns readout and a 160 ns reset, readout and reset taking most of it. On Willow a cycle takes 1.1 µs.

*Four CZs → readout → reset · Sycamore (2023): 921 ns a cycle · Willow: 1.1 µs*

## 04 Only Changes Count

With no errors, a check gives the same result every cycle. The decoder looks not at the result itself but at whether it changed since the cycle before: each change is a detection event.

A data qubit flips, and the checks on both sides of it change in the same cycle: a pair in space. A check is misread, and it changes in that cycle and again in the next: a pair in time. A gate fails part-way, and the two are apart in both: a pair in space-time.

On the stand each cycle’s results rise as a sheet of glass, the newest at the bottom; red beads are detection events. On Willow a four-qubit check changed in 7.7 % (distance 3) to 8.7 % (distance 7) of cycles.

*Pair in space: two neighbouring checks, one cycle · pair in time: one check, two cycles · Willow: 7.7⁠–⁠8.7 % per check per cycle*

## 05 Pairing the Points

The decoder sees only where these points are in space and time, and has to infer which errors most likely happened. A string of errors leaves points only at its two ends, or at one end and the code’s edge, so the points are paired off. When every error is equally likely, the likeliest pairing is the one with the shortest total length: a minimum-weight perfect matching.

Then the data qubits along each pair’s path are corrected; a pair in time was a misread and needs nothing. In fact nothing has to be flipped: the correction is noted and applied when the result is read.

Willow’s team used two offline decoders. A neural network: 0.143 % per cycle at distance 7, Λ = 2.14. An ensemble of matching decoders (Libra): 0.171 %, Λ = 2.04. The red threads on the stand are the pairs.

*Each pair: a likeliest string of errors · distance 7 per cycle: neural network 0.143 %, matching (Libra) 0.171 %*

## 06 When the Points Crowd In

Pairing works because errors are sparse: two points are usually joined by only a short string of errors. With more errors the points crowd together, the decoder pairs them wrongly, and a chain may run right across the code: the logical qubit flips. A bigger code takes longer strings of errors, but it has more points too.

So there is a dividing line. Below a threshold error rate p\_thr, each step of 2 in distance divides the logical error per cycle by about Λ ≈ p\_thr / p, with ε\_d ∝ (p / p\_thr)^((d+1)/2); above it, the bigger the code, the worse. Willow’s team added errors on purpose, raising the detection probability: the lines for distances 3, 5 and 7 cross near a detection probability of 20 %.

The model on the stand has only bit flips and misreads, each with the same chance per cycle. Computed, its three lines cross near a detection probability of 21 %; at Willow’s detection probability of about 8.5 %, its Λ is about 2.4. The stand’s code steps through distances 3, 5 and 7.

*ε\_d ∝ (p / p\_thr)^((d+1)/2) · Λ = ε\_d / ε\_(d+2) · the lines cross near 20 % detection probability (Willow, injected errors)*

## 07 Leaking to a Third Level

A superconducting qubit has more than two levels, and now and then gets pushed up to a third, |2⟩: leakage. A leaked qubit upsets the checks around it cycle after cycle, leaving points that run together in space and time, the kind that pairing handles worst.

After every cycle of checks, Willow moves leakage on the data qubits over to neighbouring qubits (data qubit leakage removal, DQLR), and the measure qubits clear theirs with a multilevel reset. For this the distance-⁠7 code uses 4 more qubits at its edge.

Compared on a 72-⁠qubit chip: with leakage removal on, distance 3 barely changes and Λ at distance 5 rises 35 %. In the paper’s error budget, leakage and stray interactions between qubits together make up about 17 %.

*Distance 7 = 49 data + 48 measure + 4 leakage-removal qubits = 101 · leakage removal: Λ at distance 5 +35 %*

## 08 Cut Open: Chip and Sample Box

The chip is a piece of silicon whose aluminium film works once cooled until it superconducts. Each qubit is a cross-shaped island of aluminium; between each measure qubit and each data qubit around it sits a tunable coupler, which switches the interaction between the two on for a two-qubit gate and off the rest of the time. Each qubit also has its own readout resonator.

Willow has 105 qubits on a square grid; the 2023 Sycamore had 72 qubits and 121 tunable couplers.

The chip on the stand sits in an opened sample box: a circuit board in its floor, fine aluminium wires from the chip’s pads to the board, then connectors and coaxial lines out. The box mounts on the coldest plate of a dilution refrigerator (see the plate “The Dilution Refrigerator”). This is a model of the principle, not Willow’s layout or package.

*Willow: 105 qubits · Sycamore (2023): 72 qubits, 121 tunable couplers*

## 09 Keeping Up

Error correction has to keep running, and decoding has to keep up: every cycle’s data must be dealt with in time, or a backlog builds and the computation time grows exponentially. Some logical operations must wait for the decoder’s answer to decide what comes next.

Willow’s team decoded in real time on a 72-⁠qubit chip: the readout results go over Ethernet to a workstation, are cut into ten-cycle blocks for several threads to match, and are stitched together. At distance 5, up to a million cycles (1.1 s), the answer came on average 63 µs after the last cycle’s data arrived, however long the run.

Decoded in real time, the error per cycle was 0.35 %, Λ = 2.0; the same data decoded offline by the neural network gave 0.269 %, Λ = 2.18, but the network needs 24 µs a cycle, too slow for a cycle every 1.1 µs.

*1.1 µs a cycle · latency 63 µs (distance 5, up to 10⁶ cycles) · error per cycle: real time 0.35 %, offline 0.269 %*

## 10 Once an Hour

The surface code’s error rate is still too high to show rare errors. A repetition code guards against one kind of error only, and can be made very long: on the 72-⁠qubit chip, distance 29, 2 × 10¹⁰ cycles in all, 5.5 hours of processor time.

Between distances 5 and 11, each step of 2 divided the error by 8.4; from distance 15 up it stopped falling, at about 10⁻¹⁰. The cause: six bursts of errors, each over about 30 qubits, about once an hour, dying away with a time constant of about 400 µs. Where they come from is not yet known.

The 2023 experiment had bursts too, from high-energy impacts, about once every 10 s, holding the floor near 10⁻⁶. The paper credits Josephson junctions with an engineered gap for keeping those down.

*Repetition code, distance 29 · distances 5⁠–⁠11: Λ = 8.4 · floor near 10⁻¹⁰ · bursts about once an hour*

## 11 Bigger Codes, More to Decode

Willow’s logical qubit only held a state; it did no operations between logical qubits. In a computation, some steps must wait for the decoder’s answer to decide what comes next.

Extrapolating, the paper puts an error of 10⁻⁶ per cycle at distance 27 with today’s Λ: 1,457 physical qubits for one logical qubit, and 728 check results to decode every cycle, about 15 times as many as at distance 7. With component errors halved, simulations predict Λ of about 4.5 and distance 13, 337 qubits.

The paper notes that the check results per cycle grow as the square of the distance, making real-time decoding harder; and the source of the bursts the repetition code found is still unknown.

*10⁻⁶ per cycle: distance 27, 1,457 qubits, 728 check results a cycle (today’s Λ) · components twice as good: distance 13, 337 qubits (simulated)*

## 12 Taken Apart

The model comes apart in layers: the glass record, the rack, the chip, the circuit board, the sample box, the connectors and coaxial lines, the cold plate.

The part under the pointer lifts out alone and is named; left alone, the parts lift out in turn.

*Glass record · rack · chip · circuit board · sample box · coaxial lines · cold plate*

## 13 The Decoding Bench

This page’s model: each cycle, every data qubit flips with probability p and every check is misread with the same probability. A run is 20 cycles; then the data qubits are read directly, the points are paired by minimum-weight perfect matching, and the logical qubit has either flipped or not. Each press of Run starts afresh.

Readings: runs so far, logical flips, and this run’s detection events. The three lines are the logical error per cycle for the same model, computed with PyMatching; the upright line marks the present p.

*Readings: runs · logical flips · detection events · logical error per cycle (this model)*

**Try this**: With a 1.5 % chance of error per cycle, going from distance 5 to 7 cuts the logical error by what factor? And at 4.5 %?

## What the Model Leaves Out

The chip, the sample box and the cold plate on the stand are a model of the principle, not Willow’s layout or package. The chip’s 101 qubits are exactly those the distance-⁠7 experiment used (49 + 48 + 4); where the 4 leakage-removal qubits sit is drawn, not taken from Willow. The couplers, resonators and pads follow the usual planar chips; a real chip’s wiring runs in several layers. Distances 3 and 5 are drawn in the middle; Willow averaged 9 and 4 sub-grids. The glass records only the Z checks’ changes (bit flips); the X checks are read every cycle just the same. The bench’s noise is only bit flips and misreads at one rate, with no gate errors, no leakage and no bursts, and its decoder weighs every edge the same. Its numbers show the trend; they are not Willow’s. Each cycle is slowed to about a second on the stand.

## Easily Misread

“Below threshold” means the logical error falls exponentially with distance, not that errors vanish. Nor is the threshold one fixed number: it depends on the noise and the decoder, and small codes cross elsewhere than large ones; for this page’s kind of noise, very large codes have a threshold of about 2.93 % (Wang, Harrington, Preskill 2003). 0.143 % is the error of one cycle of storage (1.1 µs), not of one operation. The logical qubit outliving the best physical qubit 2.4 times is about storage; operations on logical qubits have not got that far. 10⁻¹⁰ is the repetition code’s floor; a repetition code guards against one kind of error only, and the same events may affect a surface code differently. The glass sheets and red threads on the stand are this page’s model; Willow’s decoder works on blocks of ten cycles.

## Common questions

### How often does a surface code check its qubits?

On Google’s Willow chip, a logical qubit is checked once every 1.1 µs: dozens of measure qubits read the parities of their neighbouring data qubits all at once.

See: [01 Round after Round](https://world.lapla.si/en/qec/#now)

### What is a detection event?

The decoder looks not at the result itself but at whether it changed since the cycle before: each change is a detection event.

See: [04 Only Changes Count](https://world.lapla.si/en/qec/#detect)

### What does a surface-code decoder do?

The decoder sees only where these points are in space and time, and has to infer which errors most likely happened.

See: [05 Pairing the Points](https://world.lapla.si/en/qec/#decode)

### What does “below threshold” mean?

Below a threshold error rate p\_thr, each step of 2 in distance divides the logical error per cycle by about Λ ≈ p\_thr / p, with ε\_d ∝ (p / p\_thr)^((d+1)/2); above it, the bigger the code, the worse.

See: [06 When the Points Crowd In](https://world.lapla.si/en/qec/#threshold)

### Why must decoding keep up in real time?

Error correction has to keep running, and decoding has to keep up: every cycle’s data must be dealt with in time, or a backlog builds and the computation time grows exponentially.

See: [09 Keeping Up](https://world.lapla.si/en/qec/#realtime)

## Sources

1. [Google Quantum AI and collaborators (2025): Quantum error correction below the surface code threshold, Nature 638, 920⁠–⁠926 (distances 3/5/7, 101 qubits, 0.143 %, Λ = 2.14, lifetime 291 µs against 119 µs, real-time decoding 63 µs, 1.1 µs cycles, a distance-⁠29 repetition code, 10⁻¹⁰, the distance-⁠27 extrapolation)](https://doi.org/10.1038/s41586-024-08449-y)
2. [The same paper on arXiv (2408.13687) with its supplementary information (Table S1: errors per cycle by distance and decoder; gate durations; the distance-⁠13, 337-⁠qubit forecast)](https://arxiv.org/abs/2408.13687)
3. [The same paper’s correction (2026): Fig. 3a’s axis label and legend only](https://doi.org/10.1038/s41586-026-10559-8)
4. [Google Quantum AI (2023): Suppressing quantum errors by scaling a surface code logical qubit, Nature 614, 676⁠–⁠681 (distance 5 against 3: 2.914 % against 3.028 % per cycle; a 921 ns cycle; detection events and the three kinds of pairs; a distance-⁠25 repetition code at 1.7 × 10⁻⁶)](https://doi.org/10.1038/s41586-022-05434-1)
5. [C. Wang, J. Harrington, J. Preskill (2003): Confinement-Higgs transition in a disordered gauge theory and the accuracy threshold for quantum memory, Annals of Physics 303, 31 (with bit flips and misreads at one rate, matching’s threshold is 2.93 %)](https://arxiv.org/abs/quant-ph/0207088)
6. [A. G. Fowler et al. (2012): Surface codes: Towards practical large-scale quantum computation, PRA 86, 032324](https://doi.org/10.1103/PhysRevA.86.032324)
7. [W. K. Wootters, W. H. Zurek (1982): A single quantum cannot be cloned, Nature 299, 802](https://doi.org/10.1038/299802a0)
8. [K. C. Miao et al. (2023): Overcoming leakage in quantum error correction, Nature Physics 19, 1780](https://doi.org/10.1038/s41567-023-02226-w)
9. [O. Higgott, C. Gidney (2025): Sparse Blossom: correcting a million errors per core second with minimum-weight matching, Quantum 9, 1600 (PyMatching; this page’s curves)](https://doi.org/10.22331/q-2025-01-20-1600)

## Data

The measured figures are from Google Quantum AI and collaborators, “Quantum error correction below the surface code threshold” (Nature 638, 920⁠–⁠926, 2025; arXiv 2408.13687, with its supplementary information) and Google Quantum AI, “Suppressing quantum errors by scaling a surface code logical qubit” (Nature 614, 676⁠–⁠681, 2023). The bench is this page’s own model (bit flips and misread checks, each with the same probability per cycle; 20 cycles a run; minimum-weight perfect matching), run in the browser; its curves were computed for the same model with PyMatching (O. Higgott, C. Gidney). It is not a simulation of Willow. The chip, the sample box and the cold plate are a model of the principle, not Google’s layout or package. Material presets, parts and the softbox studio of the site’s model kit are ported from AirsupHQ/machine-skill (MIT, © 2026 Air Supply Technologies Inc.).

## Licence CC BY-NC 4.0

The text, pictures and models on this page are licensed CC BY-NC 4.0: free to use and adapt for teaching and other non-commercial purposes, with credit to world.lapla.si. Third-party material listed above keeps its own licence.

https://creativecommons.org/licenses/by-nc/4.0/deed.en

## Cite this plate

Laplace’s Mini World, Plate F58, “Quantum Error Correction, Cycle by Cycle”, https://world.lapla.si/en/qec/, CC BY-NC 4.0, updated 2026-10-28.