Code Distance and Errors

The distance $d$ of a code is the weight of its smallest logical operator — the fewest single-qubit errors that can change the encoded state without being detected. For the surface code this equals the length of the shortest string spanning the patch. Distance is the single number that summarises how robust the code is.

How many errors can it correct?

A code of distance $d$ can detect up to $d - 1$ errors and correct up to

t = \left\lfloor \frac{d - 1}{2} \right\rfloor

errors of a given type. The reasoning is the same as for classical codes: if two distinct correctable errors produced the same syndrome, they would differ by an undetectable operator of weight at most $2t$ . To keep them distinguishable we need $2t < d$ , i.e. $t \le (d-1)/2$ .

For the surface code the practical consequences are:

$d = 3$ : corrects $t = 1$ error — the smallest patch that can fix any single fault.
$d = 5$ : corrects $t = 2$ errors.
$d = 7$ : corrects $t = 3$ errors.

Only odd distances are used in practice. With even $d$ a weight- $d/2$ error and its complementary weight- $d/2$ partner are equidistant from the syndrome, leaving the decoder no majority to break the tie; odd $d$ guarantees a unique nearest correction.

Distance versus probability

Correcting "up to $t$ errors" is a worst-case statement. What actually matters operationally is that any error chain shorter than $d/2$ is matched correctly by the decoder, and only chains of weight $\ge \lceil d/2 \rceil$ can cause a logical failure. Because each additional error carries a factor of the small physical error rate $p$ , raising $d$ pushes the dominant failure mode to higher and higher order in $p$ — the exponential suppression we make precise in the threshold lesson.

Try it

Compute, for a distance- $3$ surface-code patch, how many errors of one type it can correct. Apply $t = \lfloor (d-1)/2 \rfloor$ with $d = 3$ and return the result. The grader checks that your returned value equals $1$ .

Run your code to see the quantum state.