The Surface-Code Lattice

The surface code is the leading candidate for building a fault-tolerant quantum computer on hardware with only nearest-neighbour connectivity. Unlike the small codes of the previous module — the three-qubit, Steane, and Shor codes — the surface code is defined on a two-dimensional lattice that can be grown to arbitrary size, and every check it measures involves only a handful of physically adjacent qubits.

Two species of qubit

A surface-code patch is a checkerboard of qubits that come in two roles:

Data qubits hold the encoded quantum information. A single logical qubit is spread across many of them; no individual data qubit by itself carries the logical state.
Ancilla qubits (also called measure or syndrome qubits) never store logical information. Each one is repeatedly entangled with its neighbouring data qubits and then measured to report a parity check.

In the common rotated layout, the qubits sit on the vertices of a square grid, and the data and ancilla qubits alternate so that every ancilla has data qubits as its immediate neighbours. A patch encoding one logical qubit at distance $d$ uses

n_{\text{data}} = d^2, \qquad n_{\text{ancilla}} = d^2 - 1,

for a total of $2d^2 - 1$ physical qubits. The smallest useful patch, $d = 3$ , therefore needs $9$ data qubits and $8$ ancilla qubits — $17$ in all.

Why two dimensions

The defining feature of the surface code is locality. Every check the code performs reads only the qubits touching one ancilla — typically four data qubits in the bulk and two at the boundary. Nothing requires a qubit on the left edge to interact directly with one on the right. This matches real superconducting and neutral-atom hardware, where two qubits can only be coupled if they are physically close.

Compare this to the Steane or Shor codes, whose stabilizer generators can span qubits that are far apart on a chip. Those codes are excellent for understanding the principles of error correction, but their long-range checks are awkward to implement at scale. The surface code trades a higher qubit count for the priceless property that every operation is local and identical, so the same control hardware tiles across the whole lattice.

Reading the checkerboard

It helps to picture the lattice as coloured tiles between the data qubits:

One colour of tile hosts a $Z$ -type check (it measures the joint parity of the data qubits around it in the computational basis).
The other colour hosts an $X$ -type check (the same idea in the conjugate basis).

Every data qubit in the bulk touches two $Z$ -tiles and two $X$ -tiles. Detecting an error becomes a question of which tiles light up when their parity changes — a picture we will turn into running code over the next several lessons.

What comes next

With the lattice and its two qubit species in hand, the next lesson makes the checks concrete: we will write down the $X$ -type and $Z$ -type stabilizer operators that each tile measures, and see why they all commute — the property that lets us measure them together without disturbing the logical state.