The Threshold Theorem (Applied)

Building a bigger code only helps if adding qubits actually drives the error rate down. The threshold theorem is the guarantee that it does — provided the hardware is good enough. For the surface code it takes a strikingly practical form.

The threshold condition

There exists a critical physical error rate $p_{\text{th}}$ , the threshold, such that:

If the per-operation physical error rate $p$ is below $p_{\text{th}}$ , increasing the code distance $d$ makes the logical error rate fall exponentially.
If $p$ is above $p_{\text{th}}$ , increasing $d$ makes things worse — larger codes have more places to fail and the code cannot keep up.

Below threshold, the logical error rate per round scales approximately as

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

where $A$ is an $O(1)$ prefactor. The exponent grows with $d$ , so each step up in distance suppresses errors by a roughly constant factor as long as $p < p_{\text{th}}$ .

Why a threshold exists at all

A logical error requires a chain of about $d/2$ physical errors that the decoder mismatches. The number of such low-weight failing configurations grows combinatorially with $d$ , but the probability of each one shrinks like $p^{d/2}$ . When $p$ is small enough, the shrinking probability wins over the growing count, and the net logical error rate decreases with $d$ . The threshold is precisely the value of $p$ where these two effects balance.

The surface code's selling point

What makes the surface code so attractive is the value of its threshold. With realistic circuit-level noise and a matching decoder, the surface-code threshold sits near $p_{\text{th}} \approx 1\%$ — far more forgiving than most other codes, whose thresholds are often an order of magnitude lower. A $1\%$ threshold is within reach of today's best superconducting and trapped-ion hardware, which is why the surface code dominates fault-tolerance roadmaps.

Reading the scaling in practice

The exponential suppression is what lets engineers quote a target. To reach a logical error rate of, say, $10^{-12}$ from a physical rate of $p \approx 10^{-3}$ , one solves the scaling relation for $d$ — typically landing in the range $d \approx 20$ – $30$ . The next lesson turns that distance into a concrete qubit budget, making the cost of fault tolerance explicit.