Quantum Error Detection

What Is Quantum Error Detection?

Quantum error detection is the use of a quantum code to learn that an error has occurred, without learning the encoded data and without fixing the error. When the check flags a problem, the run is marked as faulty and is usually discarded or repeated.

It sits between doing nothing and full quantum error correction. Both encode information redundantly across several physical qubits and both rely on parity checks. The difference is what happens after the alarm: correction applies a fix and continues, while detection throws the shot away.

This is also distinct from error suppression, which tries to prevent errors from occurring in the first place. QuEra's overview of quantum error suppression explains why reducing error rates matters before any code can help.

How Detection Works: Parity Checks and Syndromes

An error-detecting code is usually a stabilizer code. Instead of measuring the data qubits directly, which would destroy a superposition, the code measures joint parities of several qubits. The list of outcomes is the syndrome. A syndrome of all zeros means no detectable error occurred, and any other syndrome flags one.

Extracting the syndrome (see syndrome extraction) typically uses ancilla qubits and mid-circuit measurement, so the logical information is never read out.

The standard small example is the \([[4,2,2]]\) code: four physical qubits encode two logical qubits with distance 2. Its two stabilizers are \(XXXX\) and \(ZZZZ\). Any single-qubit \(X\) or \(Z\) error anticommutes with one of them and changes its outcome, so the error is caught. The syndrome does not say which qubit was hit, so the code cannot correct it. A related code with three logical qubits is the [[8,3,2]] code, covered in [The [[8,3,2]] Code](https://www.quera.com/glossary/the-8-3-2-code).

Distance: What a Code Can Detect Versus Correct

A code's distance \(d\) is the smallest number of physical errors that can change the logical state without being noticed. A code of distance \(d\) detects any error on up to \(d-1\) qubits, but corrects only up to \(\lfloor (d-1)/2 \rfloor\):

\[ t_{\text{detect}} = d - 1, \qquad t_{\text{correct}} = \left\lfloor \frac{d-1}{2} \right\rfloor \]

Distance \(d\)	Errors detected	Errors corrected
2	1	0
3	2	1
5	4	2

Correction needs distinct syndromes for distinct errors, so it spends more distance on the same task. Detection needs less distance than correction to handle the same number of errors (d = t+1 versus 2t+1), but it only flags them and discards runs. Distance-2 codes are attractive for early experiments because they are small and need shallow check circuits.

The Cost: Postselection and Its Limits

Detection only works by postselection: keeping the runs where no flag was raised. The undetected logical error rate drops, since a failure now needs at least \(d\) errors in the same run, but the fraction of runs that survive also drops as the physical error rate or circuit size grows.

That has practical consequences:

It suits short circuits and sampling-type experiments, where discarding some shots is affordable.
It does not scale to long algorithms, because the chance that a run survives falls exponentially with the number of operations.
The checks must be designed so a fault in the check circuit does not silently corrupt the data. Linke and colleagues (2017) demonstrated fault-tolerant error detection on trapped ions with a small code.

Error detection is also different from quantum error mitigation, which reduces the effect of noise on estimated results, typically by running modified or extra circuits and post-processing the data, without encoding into a code. For sustained computation, detection is a stepping stone toward correction on logical qubits.

Where Neutral Atoms Come In

Small error-detecting codes need few qubits, shallow check circuits and flexible connectivity, which makes them natural early tests on neutral atoms. Atoms held in optical tweezers can be rearranged between operations, so the same array can host different code layouts. Experiments on reconfigurable atom arrays (Bluvstein et al., Nature, 2024) used small codes with error detection alongside larger ones.

Classical control matters too, since flagged runs must be identified quickly. In 2024, Japan's AIST selected QuEra to deliver a neutral-atom system to be installed on-premises alongside the ABCI-Q supercomputer, a setting where classical and quantum processing sit side by side.

FAQ

Is quantum error detection the same as quantum error correction?

No. Detection tells you that an error occurred and usually discards the run. Correction identifies the error from the syndrome and applies a fix so the computation can continue. Detection needs less code distance than correction for the same protection level, but it costs discarded runs.

Why can't you just measure the qubits to check for errors?

Measuring the data qubits collapses the superposition and destroys the information. Error-detecting codes measure only joint parities, such as whether an even or odd number of qubits are in state 1. Those parities reveal that something changed without revealing the encoded values.

What is the smallest useful error-detecting code?

The \([[4,2,2]]\) code is the standard example. It uses four physical qubits to hold two logical qubits and detects any single-qubit error. It cannot correct that error, because the syndrome does not say which qubit was affected.

Can error detection run a long quantum algorithm?

Not on its own. Every flagged run is discarded, and the fraction of runs that survive falls quickly as circuits get longer. Long algorithms need error correction, with detection serving as a tool for short circuits and for early tests of code hardware.

Key Takeaways

Quantum error detection flags errors with parity checks but does not fix them; flagged runs are discarded or repeated.
A code of distance \(d\) detects up to \(d-1\) errors but corrects only \(\lfloor (d-1)/2 \rfloor\), so detecting a given number of errors requires less code distance than correcting the same number, at the price of discarding flagged runs.
Postselection overhead grows with circuit size, so detection suits short circuits and experiments, not long algorithms.
Small codes such as \([[4,2,2]]\) make detection a practical early step toward error correction on atom arrays and other platforms.