Code Distance on the Lattice

The protective power of a surface code is set by its distance $d$ : the minimum weight of any logical operator. Because logical operators are strings that span the patch (or wind the torus), the distance is a purely geometric quantity that grows with the linear size of the lattice. This lesson makes the relationship precise and works out the code parameters $[[n, k, d]]$ .

Distance is the shortest logical string

Recall that a logical Pauli is a homologically nontrivial string: a noncontractible loop on the torus, or a boundary-to-boundary string on the planar patch. Any such string can be deformed by multiplying with stabilizers, but its weight cannot drop below the geometric minimum needed to cross the system. Hence

d = \min_{\text{logical } \bar P} \mathrm{wt}(\bar P) = (\text{length of the shortest spanning string}).

For an $L \times L$ toric code the shortest noncontractible loop runs straight across one direction and has length $L$ , so $d = L$ . For a planar patch with $d$ qubits between the two like-type boundaries, the shortest boundary-to-boundary string has length $d$ .

The rotated surface code

The most hardware-efficient layout is the rotated surface code. To achieve distance $d$ it uses

n = d^2 \quad \text{data qubits}, \qquad k = 1 \quad \text{logical qubit},

with $d^2 - 1$ stabilizer checks (half $X$ -type, half $Z$ -type, including weight-2 checks along the boundaries). Its parameters are therefore

[[\,n, k, d\,]] = [[\,d^2,\; 1,\; d\,]].

So for distance $d = 3, 5, 7, \dots$ one needs $n = 9, 25, 49, \dots$ data qubits. Inverting, the distance recoverable from a rotated patch of $n$ data qubits is $d = \sqrt{n}$ .

How many errors does it correct?

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

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

arbitrary errors. A distance-5 patch ( $n = 25$ ) thus corrects $t = \lfloor 4/2 \rfloor = 2$ errors; a distance-3 patch corrects a single error. Increasing $d$ by 2 (the smallest step that keeps an odd, unambiguous distance) buys one more correctable error while keeping every check local.

Why this is the whole point

Every check stays weight-4 (weight-2 at boundaries) no matter how large $d$ becomes — locality is never sacrificed. Yet $d$ , and hence the protection, scales with $\sqrt{n}$ . Combined with a positive error threshold (two lessons ahead), this lets the logical error rate be suppressed exponentially in $d$ by a merely polynomial growth in qubit count. That favorable trade is the engineering case for surface codes.

Try it

For a rotated surface-code patch with $n = 25$ data qubits, recover the distance $d = \sqrt{n}$ and return the number of correctable errors $t = \lfloor (d-1)/2 \rfloor$ .

Run your code to see the quantum state.