Surface Code Decoding

A quantum memory spreads information across several physical qubits because each qubit is fragile. Repeated parity checks reveal patterns associated with errors without directly reading the stored logical information. A decoder interprets those patterns to decide whether the final logical answer has flipped.

The clues are ambiguous. A detection event is a change in a check, not a picture of the faulty qubit. Several hidden chains of faults can produce the same endpoints but have different logical consequences. The interactive strip shows why joining the nearest clues is not always the whole problem.

A real public hardware input

Inside one independent AlphaQubit specialist

An independently trained model reads how error clues evolve over time

1. Read the observationsCombine detection events with the locations of checks
2. Embed each checkRepresent what each check observed and where it sits
3. Update the memoryConnect current spatial clues with information remembered from earlier rounds
4. Read the terminal stateCombine the final evidence to estimate whether the logical answer flipped
5. Make a decisionPredict a flip when its probability is at least one half

The recurrence carries information between rounds; attention combines spatial evidence within a round. The hidden physical fault history is never supplied. Training teaches the model which histories are associated with logical errors.

Why balancing changes the answer

Illustrative calculator: choose the mean failure after averaging each distance’s durations and geometry/basis groups. These sliders do not run a decoder.

d3 mean failure

20.0%

d5 mean failure

30.0%

Official balanced P0.75000

Clipped reward0.74673

Pooled accuracy (not the score)0.78000

Equal weighting gives both distances half the score; pooling would give d3 four times the influence.

P = 1 − (d3 failure + d5 failure) / 2. Reward rescales P between the two reference decoders, with values limited to 0–1. Try reducing only d5 error: the equal-distance score rewards that improvement more than pooled accuracy does.

The task uses Sycamore experiments with two surface-code sizes, called distances three and five. They have nine and twenty-five data qubits respectively. Larger distance adds redundancy, but also introduces more noisy operations; better protection must be measured rather than assumed.

Examples contain detection events across one to twenty-five measurement rounds, along with circuit geometry. About 2.6 million shots train the model and 666,000 support validation. A shot is one complete memory experiment. The decoder predicts a flip probability; it does not receive the hidden fault history.

The historical test uses separate shots, but is publicly available upstream. Models must learn from the allowed data rather than recover released answers. Simulation noise models use development check measurements, including validation measurements, but not validation logical labels or test shots.

The primary score is one minus the logical failure rate, averaged across durations and geometry groups and then equally across the two code distances. Equal weighting prevents the more numerous distance-three conditions from dominating.

If the two distances have failure rates 20% and 30%, the balanced accuracy is 75%. Pooling all shots would instead give 78% because there are four times as many distance-three conditions. A normalized reward rescales balanced accuracy between matching and tensor-network reference decoders; reward one does not mean error-free memory.

The AlphaQubit-inspired reference maintains a learned state for each check. At every round it combines new events with its memory of earlier rounds. Attention lets it connect spatially separated clues, while recurrent memory tracks their evolution through time.

The final state produces a probability that the logical observable flipped. Ten specialists cover different geometries and memory bases. This is an independent reconstruction of the published approach, not released Google code or weights.

Only discrete detection events and ideal geometry are available here. Richer analogue readouts and information about leakage outside the intended qubit states are excluded, so the task is narrower than the original paper’s full setting.

Simulations cheaply generate many labeled fault histories. They teach a model recurring patterns before adaptation to real hardware examples. Hardware adaptation can then address behavior the simulator misses.

Training rewards probabilities that agree with the logical labels, and adds a smaller task of predicting later check measurements. That auxiliary task encourages the internal memory to carry useful temporal information. It is a plausible mechanism, not proof that a particular noise process explains the measured improvement.

The independent trained model reaches about 75.6% balanced accuracy, compared with 71.6% for the matching reference and 76.2% for released tensor-network predictions on the same shots. These comparisons locate performance within this dataset, not the full literature.

A separate reference run has fitted error rates of about 3.0% per round at distance three and 3.2% at distance five. The larger code does not improve this diagnostic. An aggregate accuracy can therefore conceal the central question of whether adding qubits actually improves protection.

These runs do not establish robustness across training seeds or changing hardware noise. The published Nature results also use different folds and ensembles, so comparable headline numbers would not establish equivalent performance.

Break down errors by experiment duration, geometry and code size. Improvements confined to short histories may leave long-lived memory unchanged. Better simulation, longer-memory models or hybrid neural and matching methods could help; each should be tested for both accuracy and the time needed to update after one new round.