Leakage: When a Qubit Stops Being a Qubit

Error correction is built to catch a qubit that flips between 0 and 1. Leakage is the error where the qubit slips out of 0 and 1 altogether, and it breaks an assumption the whole method rests on.

Two levels borrowed from many

Nature does not make two-level objects. A qubit is two states picked out of a physical system that has more, and we agree to call them 0 and 1. In a superconducting circuit, the step from 1 up to the next level, usually called 2, is nearly the same size as the step from 0 to 1, so ordinary gates and even measurements can push the qubit into it.³ A trapped-ion qubit uses two levels that lie close in energy to six others it can fall into.⁴

That escape has a name. Trapped ions, quantum dots and superconducting qubits all suffer from it, among other systems.²

Quantum error correction never reads the data. It runs repeated checks on small groups of qubits, and a decoder turns the resulting alarms into a diagnosis. All of that is designed for errors inside the 0-and-1 space. As one foundational analysis put it, error correction is not designed to deal with leakage directly.¹

So what does a leaked qubit do to the checks? In one simulation model, each neighboring check that touches it gets scrambled, and measuring the leaked qubit gives a random answer with no sign that anything left.² The result is alarms that come and go at random, round after round.

Worse, leakage lingers and spreads. In one superconducting experiment, a single deliberately leaked qubit stayed leaked for many rounds of checks and passed leakage to its neighbors; in that small code it reached every qubit.³ In a trapped-ion experiment, gates involving a leaked qubit spread errors to others, so one leakage event could trigger a cascade ending in a logical error.⁴

This is the deeper problem. Error correction assumes errors are roughly independent in space and time.³ One leaked qubit produces a burst of related errors that looks like many independent ones, and that can fool the decoder.

Leakage in two runs of the same error-correcting code. Left, an energy ladder: two blue levels, 0 and 1, bracketed as qubit, and a red level 2 above them labeled leaked, with a red arrow from 1 up to 2; beneath, a star equals alarm, pushed up by gates or measurement. Middle, labeled no leakage removal: a row of seven qubits drawn over four rounds, with time running down. The fourth qubit is a red circle marked L in every round, and from the third round the fifth qubit is too; blue alarm stars appear next to the leaked qubits in every round, at shifting places, labeled random alarms, spreading, can fool the decoder. Right, labeled removed every round: the same row, where the fourth qubit is leaked only in the first round with one alarm on each side, and every later round is clean, labeled like one ordinary error, the code can handle it. — Figure 1: Same leak, two outcomes. Left to itself, a leaked qubit keeps setting off random alarms and spreads to its neighbor. Removed every round, it leaves at most one ordinary error, which the code can handle.

The fix: make it an ordinary error again

The standard strategy is to convert leakage back into an ordinary error the code already knows how to fix.¹ One way is physical: in the trapped-ion experiment, light pumped leaked ions back into the qubit levels, each cycle returning nearly half of what remained.⁴ Another is built into the circuit: rotate the roles of data qubits and helper qubits, so every qubit is regularly measured and reset.⁴

In the superconducting experiment, removing leakage from every qubit in every round cut the steady leakage on the data qubits tenfold, to below 1 in 1,000 averaged over the device.³ Alarm rates stopped climbing over time, and deliberately injected leakage then hurt the code about as much as ordinary errors.³ Removal is not perfect, though: some leaked qubits stay leaked, so decoders that can reason about leakage may still help.⁴

The caveat in the fine print

There is a shortcut: detect leakage and throw away the runs where it happened. Discarding leaked runs has made important early experiments possible.³ It is a fair way to study everything else, but it answers a narrower question: how well does the code work on the runs leakage spared? When a result says runs with detected leakage were discarded, read that as a condition on the number, not a footnote.

Why it matters

Leakage is a reminder that an error rate is not one number. The kind of error matters, and leakage is the kind that error correction cannot absorb unless the hardware and circuit are designed for it. Keeping leakage from building up, round after round, is a requirement for scaling a logical qubit toward fault tolerance.³ Recent experiments show it can be managed; doing it on large machines, for long computations, is still ahead.

Sources

P. Aliferis and B. M. Terhal, “Fault-tolerant quantum computation for local leakage faults,” Quantum Information and Computation 7, 139 (2007). arXiv:quant-ph/0511065. (Error correction is not designed to deal with leakage faults directly; leakage must be converted to regular faults, by detection and replacement or by leakage-reduction units.) ↩
A. G. Fowler, “Coping with qubit leakage in topological codes,” Physical Review A 88, 042308 (2013). DOI: 10.1103/PhysRevA.88.042308; arXiv:1308.6642. (Leakage in trapped ions, quantum dots, superconducting qubits and other systems; threshold proofs typically assume no leakage; in the paper’s model, a leaked qubit scrambles qubits it interacts with and its measurement gives a random result with no indication of leakage; one leakage event can cause a logical error in a small code; a threshold survives but performance is significantly degraded without removal circuitry.) ↩
K. C. Miao, M. McEwen, J. Atalaya, et al. (Google Quantum AI), “Overcoming leakage in quantum error correction,” Nature Physics 19, 1780 (2023). DOI: 10.1038/s41567-023-02226-w; arXiv:2211.04728. (Transmon levels closely spaced, so gates and measurement populate leakage states; QEC assumes errors uncorrelated in space and time; leakage persists for many cycles and spreads, reaching every qubit in a distance-3 code; post-selecting out leakage events enabled earlier experiments; removal from all qubits every cycle gives a tenfold reduction in steady-state data-qubit leakage and below 1 × 10⁻³ average leakage; detection probability stabilizes; with removal, injected leakage affects logical performance like injected Pauli errors; stable leakage populations are a requirement for scalable QEC.) ↩
A. Lavasani, A. P. Reed, J. M. Dreiling, et al. (Quantinuum), “Quantum error correction well below the color code threshold,” preprint, arXiv:2610.24077 (October 16, 2026). (Trapped-ion qubit levels close in energy to six leakage levels; gates involving leaked qubits spread errors and a single leakage event can trigger a cascade causing a logical error; mid-circuit optical repump returns nearly half the remaining leaked population per cycle, 6.5-fold after three cycles; SWAP-based leakage-reduction unit that swaps data qubits with measured-and-reset helpers; repump converts leakage into errors standard QEC handles; repump is imperfect and leakage-aware decoders may help.) ↩