• Error Correction

Logical Error Rate

The probability that an error-corrected logical qubit experiences an undetectable error per round of error correction, the key metric for evaluating quantum error correction performance.

The logical error rate is the probability that a logical qubit (a qubit protected by an error correction code) suffers an uncorrectable error during a single round of error correction or a single logical gate operation. It is the ultimate performance metric for quantum error correction: the lower the logical error rate, the more reliable the computation. For useful fault-tolerant quantum computing, logical error rates of 10−1010^{-10} to 10−1510^{-15} per operation are typically required.

Relationship to physical error rate

For a distance-dd error correction code operating below its threshold, the logical error rate decreases exponentially with code distance:

pL≈A(ppth)⌊(d+1)/2⌋p_L \approx A \left(\frac{p}{p_{\text{th}}}\right)^{\lfloor(d+1)/2\rfloor}

where pp is the physical error rate, pthp_{\text{th}} is the code’s threshold error rate, and AA is a constant of order 0.1 to 1. The exponent ⌊(d+1)/2⌋\lfloor(d+1)/2\rfloor counts the minimum number of errors needed to cause a logical failure.

For the surface code with threshold pth≈1%p_{\text{th}} \approx 1\%:

Physical error rate ppp/pthp/p_{\text{th}}Distance 3Distance 7Distance 15
0.1%0.1~10−410^{-4}~10−810^{-8}~10−1610^{-16}
0.5%0.5~10−210^{-2}~10−410^{-4}~10−810^{-8}
0.9%0.9~10−1.510^{-1.5}~10−210^{-2}~10−310^{-3}

The exponential suppression only kicks in below threshold. Above threshold, increasing the code distance makes things worse.

What counts as a logical error

A logical error occurs when the physical errors during a correction cycle conspire to flip the logical state without being detected by the syndrome measurements. In the surface code, this requires a connected chain of errors spanning the entire code (from one boundary to the opposite boundary). For a distance-dd code, at least ⌊d/2⌋+1\lfloor d/2 \rfloor + 1 errors must occur along such a chain.

There are two types of logical errors, corresponding to the two logical operators:

  • Logical XX error: A chain of ZZ errors spanning the code horizontally, flipping the logical bit value
  • Logical ZZ error: A chain of XX errors spanning the code vertically, flipping the logical phase

The total logical error rate is the sum of both contributions (for a memory experiment).

Measuring logical error rates

Experimental measurement of logical error rates involves:

  1. Prepare a known logical state (∣0⟩L|0\rangle_L or ∣+⟩L|+\rangle_L)
  2. Run RR rounds of error correction (syndrome extraction cycles)
  3. Decode the syndrome history and apply corrections
  4. Measure the logical qubit and check if the result matches the prepared state
  5. Repeat many times to estimate the error probability

The logical error rate per round is then pL≈ptotal/Rp_L \approx p_{\text{total}} / R for small ptotalp_{\text{total}}.

Google’s 2023 experiment measured logical error rates for the repetition code and showed below-threshold behavior: the distance-5 code had a lower logical error rate (2.914%) than the distance-3 code (3.028%) per round. Their 2024 results extended this to the surface code, achieving a logical error rate that decreased with code distance.

Target logical error rates

The required logical error rate depends on the algorithm:

  • Simple circuits (100 logical gates): pL<10−4p_L < 10^{-4} suffices
  • Quantum chemistry (VQE, 10610^6 gates): pL<10−8p_L < 10^{-8}
  • Shor’s algorithm for RSA-2048 (101210^{12} gates): pL<10−15p_L < 10^{-15}

Each order of magnitude improvement in logical error rate requires increasing the code distance by roughly 2 (for a surface code at p=0.1%p = 0.1\%), which quadratically increases the physical qubit count.

Why it matters for learners

The logical error rate is the single number that determines whether quantum error correction is actually working. It connects physical hardware performance to algorithmic requirements, and it is the metric that all quantum computing roadmaps ultimately aim to improve. Understanding how it scales with physical error rates and code distance is essential for evaluating the feasibility of fault-tolerant quantum computing.

See also