Error Thresholds

The single most important number for a fault-tolerant code is its error threshold $p_{\text{th}}$ : the physical error rate below which increasing the code distance decreases the logical error rate. Above threshold, adding qubits makes things worse; below it, the code works arbitrarily well in the large- $d$ limit. The surface code's threshold is famously high, which is why it dominates hardware roadmaps. This lesson states the threshold and the sub-threshold scaling law you use to size a code.

The competition that defines a threshold

Two effects fight as the distance $d$ grows:

More room to fail. A larger patch has more qubits, hence more places for a fault chain to start.
Longer fault chains required. A logical error now needs a string of length $\sim d/2$ , and long coordinated chains are exponentially suppressed when single errors are rare.

The second effect wins iff the physical error rate is below the threshold $p_{\text{th}}$ . The threshold is exactly the crossing point where curves of logical error rate versus $p$ — taken at different distances — all intersect.

The surface-code threshold

Under an idealized independent-error model the surface-code threshold maps onto the phase transition of the 2D random-bond Ising model along the Nishimori line, giving

p_{\text{th}} \approx 10.9\% .

With realistic circuit-level noise (faulty gates, faulty and repeated measurements), the threshold drops to the often-quoted

p_{\text{th}} \approx 0.5\text{--}1\% .

That $\sim 1\%$ tolerance is generous compared with competing codes and within reach of current hardware — the surface code's headline selling point.

The sub-threshold scaling law

For $p < p_{\text{th}}$ , the logical error rate per error-correction round follows the empirical law

P_L(d) \;\approx\; A\left(\frac{p}{p_{\text{th}}}\right)^{\!\lfloor (d+1)/2 \rfloor},

with an $\mathcal{O}(1)$ prefactor $A$ . The exponent $\lfloor (d+1)/2 \rfloor$ is the number of physical faults needed to overwhelm a distance- $d$ code. The structure is the key insight:

Because $p/p_{\text{th}} < 1$ , raising the exponent drives $P_L$ down.
The exponent grows linearly in $d$ , so $P_L$ falls exponentially in $d$ .
Meanwhile the qubit cost grows only polynomially, $n \sim d^2$ .

A worked estimate

Take $A = 0.1$ , threshold $p_{\text{th}} = 1\%$ , physical rate $p = 0.1\%$ , and distance $d = 5$ . Then $p/p_{\text{th}} = 0.1$ and the exponent is $(5+1)/2 = 3$ , giving

P_L = 0.1 \times (0.1)^3 = 10^{-4}.

A tenfold safety margin in $p$ and a modest distance-5 patch already yield a logical error of $10^{-4}$ per round. Pushing to $d = 7$ would give $0.1 \times (0.1)^4 = 10^{-5}$ , and so on — the engineering knob is simply $d$ .

Try it

Implement the scaling law $P_L = A\,(p/p_{\text{th}})^{(d+1)/2}$ for odd $d$ . With $A = 0.1$ , $p_{\text{th}} = 0.01$ , $p = 0.001$ , and $d = 5$ , return $P_L$ .

Run your code to see the quantum state.