Logical Error Rate

What Is the Logical Error Rate?

The logical error rate is the probability that an error-corrected qubit ends up wrong: the information it encodes is corrupted despite active correction. It is usually quoted per round of error correction or per logical operation, and it shows whether error correction is actually helping.

A logical qubit is encoded across many physical qubits. Quantum error correction (QEC) fails only when errors pile up in a pattern the decoder misreads, and the rate counts how often that happens. This differs from the physical error rate, the chance that a single physical qubit or gate fails (closely related to gate fidelity).

Why Code Distance and Physical Noise Matter

Error correction helps only if the physical error rate is below an error threshold, which depends on the code, the noise model and the decoder. For the surface code, the threshold is on the order of 1% under circuit-level noise models (see Fowler and colleagues, 2012).

Below threshold, a common heuristic for odd code distance \(d\) is

\[ p_L \approx A \left( \frac{p}{p_{\mathrm{th}}} \right)^{(d+1)/2} \]

where \(p_L\) is the logical error rate, \(p\) the physical error rate, \(p_{\mathrm{th}}\) the threshold, and \(A\) a constant fitted from data.

Each increase of \(d\) by 2 multiplies \(p_L\) by roughly \(p/p_{\mathrm{th}}\), so suppression is exponential in distance. Above threshold, adding qubits makes it worse. Google Quantum AI (2025) reported surface-code memories whose logical error per cycle fell by about a factor of two with each step in distance from 3 to 5 to 7, the below-threshold pattern.

What Else Impacts the Logical Error Rate

The formula assumes independent, local errors. Real devices add several other factors:

Syndrome extraction: the syndrome extraction circuits add their own gate and measurement errors.
Decoding: decoding accuracy matters, and so does speed, since a slow decoder lets errors accumulate.
Correlated errors: leakage, crosstalk and atom or qubit loss break the independence assumption and can set a floor below which more distance does not help.
Operation type: storing a qubit (memory) is easier than running logical gates, and some gates need extra resources such as magic states.

Reading Reported Numbers Carefully

The target depends on the workload. A computation of \(N\) logical operations needs a per-operation rate well below \(1/N\): about \( 10^{-6} \) for a million operations and \( 10^{-9} \) for a billion. QuEra's roadmap from megaquop to gigaquop is framed in these terms, with a megaquop described as roughly a million error-free operations.

When comparing results, ask:

Is the figure per cycle, per operation or per circuit?
Is it a memory or a logic experiment?
Were runs discarded (post-selection or error detection) or was every shot decoded?
What distance, decoder and number of rounds were used?

Beating the physical error rate (break-even) is a milestone, not the finish line for fault-tolerant computing.

Where Neutral Atoms Fit

QuEra's roadmap treats Gemini as a live testbed for the error-correction codes that Libra will run. Libra is planned as a fault-tolerant system of 256 logical qubits on more than 10,000 physical qubits, on Amazon Braket in 2028, as described in Why Fault-Tolerant Quantum Computers Need a New Approach to Software.

Atom arrays have a distinctive error: atom loss. When loss is detected it becomes an erasure, an error at a known location, which is easier to correct than one at an unknown location. Bluvstein and colleagues (2024) ran logical circuits on a reconfigurable atom array with up to 48 logical qubits and reported error-detected performance exceeding that of the underlying physical qubits. As with any platform, the logical error rate measured on hardware, not the qubit count, shows whether such systems deliver.

FAQ

How does a logical error differ from a physical error?

A physical error is a fault in one qubit or gate. A logical error is a fault in the encoded information that survives correction. Below the error threshold, logical errors become rarer than physical ones as the code grows.

What logical error rate does a useful computation need?

It depends on the algorithm: the per-operation rate must be well below the inverse of the number of logical operations. A million-operation program needs roughly \( 10^{-6} \) or better, and a billion-operation program roughly \( 10^{-9} \).

Does adding more physical qubits always lower it?

No. Larger codes help only when the physical error rate is below threshold and the decoder and hardware keep up. Above threshold, or with strong correlated errors, more qubits can raise the logical error or leave it flat.

How is it measured in an experiment?

Researchers prepare a logical state, run many rounds of syndrome extraction, decode, then measure and compare with the intended state. Repeating over many shots gives a failure fraction, often converted to an error per round.

Key Takeaways

The logical error rate is the chance that an error-corrected qubit or operation fails, unlike the physical error rate of a bare qubit or gate.
Below the error threshold, it falls exponentially as code distance grows; above it, bigger codes do not help.
Decoder quality, syndrome-extraction errors and correlated faults such as leakage or atom loss can keep real values above the idealized formula.
Always check per cycle versus per operation, memory versus gates, and whether runs were discarded before comparing results.