Chapter 19: Surface Codes and Topological Protection

19.1 The Toric Code: Error Correction on a Lattice

Kitaev's toric code is defined on a square lattice drawn on a torus (a surface with periodic boundary conditions in both directions). Qubits live on the edges of the lattice. For an $L \times L$ lattice on a torus, there are $2L^2$ edges, hence $2L^2$ physical qubits.

Vertex and Plaquette Operators

The stabilizer generators come in two types:

• Vertex operators $A_v$: for each vertex $v$, define $A_v$ as the product of $X$ operators on all edges touching $v$. On a square lattice, each vertex has four edges, so $A_v = X_{e_1} X_{e_2} X_{e_3} X_{e_4}$.
• Plaquette operators $B_p$: for each face (plaquette) $p$, define $B_p$ as the product of $Z$ operators on all edges bounding $p$. Each plaquette has four edges, so $B_p = Z_{e_1} Z_{e_2} Z_{e_3} Z_{e_4}$.

Every vertex operator commutes with every plaquette operator. To see why: a vertex $v$ and a plaquette $p$ share either 0 or 2 edges (by the geometry of the lattice). If they share 0 edges, $A_v$ and $B_p$ act on disjoint qubits and trivially commute. If they share 2 edges, the two $X$ operators from $A_v$ anticommute with the two $Z$ operators from $B_p$ on those edges, but two anticommutations yield an overall commutation (the $(-1)^2 = +1$ rule from Section 18.1).

Code Parameters

For an $L \times L$ toric code:

• Physical qubits: $n = 2L^2$ (one per edge)
• Vertex operators: $L^2$, but their product is the identity ($\prod_v A_v = I$), giving $L^2 - 1$ independent generators
• Plaquette operators: $L^2$, with $\prod_p B_p = I$, giving $L^2 - 1$ independent generators
• Total independent stabilizer generators: $2(L^2 - 1) = 2L^2 - 2$
• Logical qubits: $k = n - (n - k) = 2L^2 - (2L^2 - 2) = 2$
• Code distance: $d = L$ (the shortest non-contractible loop on the torus)

The toric code is a $[[2L^2, 2, L]]$ code. It encodes two logical qubits because the torus has two independent non-contractible cycles (one going "around" the torus and one going "through" the hole).

Anyonic Excitations and Error Chains

Errors create excitations at the endpoints of error chains. A $Z$ error on an edge flips the two vertex operators sharing that edge, creating a pair of $A_v = -1$ excitations called $e$-anyons (or electric charges). An $X$ error on an edge flips the two plaquette operators sharing that edge, creating a pair of $B_p = -1$ excitations called $m$-anyons (or magnetic vortices).

A chain of $Z$ errors along a path creates $e$-anyons only at the two endpoints of the path - the intermediate excitations cancel in pairs. Error correction amounts to pairing up the observed anyons and connecting each pair with a correction chain. As long as the correction chain and the error chain together form a contractible loop (one that can be continuously shrunk to a point on the torus), the correction succeeds. If they form a non-contractible loop, a logical error occurs.

This topological picture - errors as anyon pairs, correction as matching, failure as non-contractible loops - is the essence of topological quantum error correction.

Logical Operators on the Torus

The toric code encodes two logical qubits, corresponding to the two topologically distinct non-contractible loops on the torus. For the first logical qubit:

• $\bar{X}_1$: a product of $X$ operators along a non-contractible loop in one direction (e.g., a vertical loop wrapping around the torus).
• $\bar{Z}_1$: a product of $Z$ operators along a non-contractible loop in the perpendicular direction.

Similarly for the second logical qubit, with the roles of the two directions swapped. These logical operators commute with all stabilizers (they correspond to non-contractible loops, which cannot be written as products of local stabilizer generators) but anticommute with each other in the appropriate pairs.

The minimum weight of any logical operator is the minimum length of a non-contractible loop on the lattice, which is $L$ for an $L \times L$ torus. This gives the code distance $d = L$. An error creates a logical fault only if it spans the entire width of the lattice - a highly unlikely event when the physical error rate is low and $L$ is large.

Why "Topological"?

The toric code is called topological because its code properties depend on the topology (global shape) of the surface, not on the local geometry. Deforming the lattice, stretching edges, or moving vertices does not change the code distance or the number of logical qubits. All that matters is whether loops are contractible or non-contractible - a purely topological distinction. This provides a natural robustness: local perturbations (which correspond to contractible loops) cannot cause logical errors.

19.2 The Surface Code: The Leading Candidate

The toric code is elegant but impractical: building a torus in hardware requires periodic boundary conditions that are impossible on a planar chip. The surface code (also called the planar code) solves this by cutting the torus open and introducing boundaries.

Lattice Structure

The standard surface code is defined on a planar square lattice. In the "rotated" layout (the most hardware-efficient version), data qubits sit at the vertices of a tilted square grid, and ancilla qubits for syndrome measurement sit at the centers of each face. For a distance-$d$ code:

• Data qubits: $d^2$
• $X$-type stabilizers (measuring $Z$ errors): $(d^2 - 1)/2$ plaquettes
• $Z$-type stabilizers (measuring $X$ errors): $(d^2 - 1)/2$ plaquettes
• Ancilla qubits: $d^2 - 1$ (one per stabilizer)
• Total qubits: $2d^2 - 1$

The surface code encodes $k = 1$ logical qubit with distance $d$, giving parameters $[[d^2, 1, d]]$ (in the rotated layout). The boundaries are of two types: rough (where $X$-type stabilizers are truncated) and smooth (where $Z$-type stabilizers are truncated). Alternating rough and smooth boundaries around the perimeter creates a code that encodes exactly one logical qubit.

The ~1% Error Threshold

The surface code's claim to fame is its exceptionally high error threshold: approximately 1% per physical gate operation under a standard depolarizing noise model, and approximately 0.3% under a more realistic circuit-level noise model that accounts for faulty syndrome measurements. This means that if each physical operation has an error rate below the threshold, increasing the code distance $d$ exponentially suppresses the logical error rate:

Syndrome Measurement Cycles

In a real implementation, syndrome measurement is not instantaneous and is itself noisy. Each syndrome extraction round involves a sequence of CNOT gates between data qubits and ancilla qubits, followed by measurement of the ancillas. Because measurements can err, the syndrome must be extracted repeatedly - typically $d$ rounds per error correction cycle - building up a three-dimensional syndrome history (two spatial dimensions plus time).

Decoding this 3D syndrome data is the job of the decoder. The minimum-weight perfect matching (MWPM) decoder, originally proposed by Dennis, Kitaev, Landahl, and Preskill (2002), treats syndrome defects as nodes in a graph and finds the minimum-weight matching. Modern implementations achieve near-optimal performance with sub-microsecond latency.

Sandbox: Distance-3 Surface Code Syndrome

The smallest interesting surface code has distance $d = 3$, using 9 data qubits and 8 ancilla qubits (17 total). In the sandbox below we prepare all data qubits in $|0\rangle$, introduce a single $X$ error, and extract one round of $Z$-type syndromes. The syndrome pattern reveals the error location.

With an $X$ error on the center qubit (q[4]), all four $Z$-type stabilizers that include qubit 4 should flag, since $X$ anticommutes with $Z$. The ancilla qubits q[9] through q[12] should all read 1, uniquely identifying the center qubit as the error location. Try moving the error to a corner qubit like q[0] to see how the syndrome pattern changes.

Interactive: Stabilizer Syndrome Extraction

The sandbox above lets you write circuits manually, but the stabilizer formalism gives us a more direct view of syndrome extraction. The Clifford simulation below prepares a 3-qubit repetition code (encoding logical $|0\rangle$ as $|000\rangle$) and extracts two stabilizer syndromes ($Z_0 Z_1$ via ancilla $q_3$ and $Z_1 Z_2$ via ancilla $q_4$). Use the error selector to inject a bit-flip on different data qubits and observe how the syndrome pattern and stabilizer generators change. With no error, both syndrome bits read 0. A single-qubit error produces a unique two-bit syndrome that identifies the faulty qubit.

The syndrome outcomes map directly to the error location: syndrome $00$ means no error, $10$ identifies qubit 0, $11$ identifies qubit 1, and $01$ identifies qubit 2. This is exactly the principle behind surface code syndrome extraction, scaled up to a 2D lattice with many more stabilizers.

Interactive: Stabilizer Evolution in Syndrome Extraction

Step through the gates of a syndrome extraction circuit and watch how the stabilizer generators transform at each step. The circuit below encodes a 3-qubit repetition code and then extracts the $Z_0 Z_1$ stabilizer using an ancilla qubit and a Hadamard-CNOT pattern. Notice how each CNOT propagates Pauli operators between data and ancilla qubits, building up the multi-qubit stabilizer correlations that enable error detection.

After the encoding CNOTs, the stabilizers reflect the entangled code state. The Hadamard-CNOT-CNOT-Hadamard sequence on the ancilla qubit $q_3$ effectively measures the $X_0 X_1$ parity without disturbing the encoded information (the ancilla acts as control, propagating X operators to the data qubits). To measure $Z_0 Z_1$ instead, one would use the data qubits as controls with the ancilla as target (as in the sandbox above). This is the indirect measurement technique used in all stabilizer codes: the ancilla mediates the stabilizer measurement, and measuring the ancilla in the computational basis yields the syndrome bit. In the full surface code, this pattern is repeated for every stabilizer generator in every syndrome extraction round.

Logical Operators on the Planar Surface Code

Unlike the toric code (which encodes 2 logical qubits), the planar surface code encodes exactly 1 logical qubit. The logical operators are chains of Paulis stretching from one boundary to the opposite boundary:

• $\bar{Z}$: a chain of $Z$ operators connecting the two rough boundaries (e.g., top to bottom across the lattice).
• $\bar{X}$: a chain of $X$ operators connecting the two smooth boundaries (e.g., left to right across the lattice).

These two chains necessarily cross at least once (by the geometry of the boundaries), ensuring that $\bar{X}$ and $\bar{Z}$ anticommute as required for a logical qubit. The minimum length of either chain is $d$ (the code distance), ensuring that a logical error requires at least $d$ physical errors.

The Surface Code as a Quantum Memory

Before we use the surface code for computation, it serves as a quantum memory: encode a logical qubit, run syndrome extraction cycles continuously, decode and correct errors, and the logical information persists far longer than it would on a bare physical qubit. The logical lifetime grows exponentially with code distance (assuming sub-threshold physical error rates), making the surface code an excellent quantum memory even before any logical gates are performed.

This quantum memory capability is what Google's Willow chip demonstrated in December 2024: increasing the code distance from 3 to 5 to 7 each time roughly doubled the logical lifetime, confirming exponential error suppression below threshold (see Chapter 20 for details).

19.3 Logical Gates on the Surface Code

Encoding information in the surface code protects it from noise, but we also need to compute on the encoded information. Performing logical gates on surface-code qubits without breaking the error protection is one of the central challenges of fault-tolerant quantum computing.

Transversal Gates

A transversal gate applies a physical gate independently to each qubit in the code block (or pairs of corresponding qubits across two code blocks). Transversal gates are automatically fault-tolerant because an error on one physical qubit cannot spread to others within the same block.

For the surface code, the only transversal Clifford gate is the logical identity and (with two code blocks) the logical CNOT. This is a consequence of the Eastin-Knill theorem: no quantum error-correcting code can implement a universal gate set entirely through transversal gates. We must find other methods.

Lattice Surgery

Lattice surgery, introduced by Horsman, Fowler, Devitt, and Van Meter (2012), is the dominant approach for performing logical operations on surface codes. Instead of moving or braiding encoded information, lattice surgery merges and splits code patches by temporarily modifying the lattice boundaries.

The key operation is the lattice merge: take two adjacent surface-code patches and measure new stabilizers along their shared boundary, effectively joining them into a single larger code that encodes one fewer logical qubit. This performs a logical measurement - for example, measuring the joint parity $\bar{Z}\bar{Z}$ of two logical qubits.

Combined with single-patch operations and classical feed-forward, lattice surgery can implement:

• Logical CNOT: via merge and split operations that measure $\bar{X}\bar{X}$ or $\bar{Z}\bar{Z}$
• Logical Hadamard: by physically rotating the code patch (swapping rough and smooth boundaries)
• Logical $S$ gate: using ancilla patches prepared in specific states
• Logical $T$ gate: via magic state injection (Chapter 20)

Merge and Split in Detail

The lattice merge operation works in three steps:

1. Prepare the boundary. The two surface-code patches are placed side by side with a gap of one column between them. New ancilla qubits in this gap will mediate the merge.
2. Measure merged stabilizers. For $d$ rounds, measure new stabilizer generators that span the boundary between the two patches. For a $\bar{Z}\bar{Z}$ measurement, these are $Z$-type stabilizers connecting data qubits from both patches. The merged stabilizer measurements project the two logical qubits onto a joint eigenstate of $\bar{Z}\bar{Z}$, yielding the eigenvalue $\pm 1$.
3. Split. Stop measuring the boundary stabilizers and resume measuring the original stabilizers of each separate patch. The patches return to being independent code blocks, but the logical information has been updated by the $\bar{Z}\bar{Z}$ measurement.

A single merge-and-split cycle takes $O(d)$ syndrome extraction rounds (to build up sufficient confidence in the boundary measurement outcomes), making it the time-limiting step of logical operations.

The Overhead Question

Lattice surgery comes with significant qubit overhead. Each logical qubit requires a $d \times d$ patch of physical qubits, plus routing space between patches for merge/split operations. For a distance-17 surface code (needed for many practical applications), each logical qubit requires roughly 600 physical qubits just for the data and syndrome qubits, plus additional routing overhead. A fault-tolerant quantum computer running a useful algorithm might need millions of physical qubits to support a few thousand logical qubits.

The routing overhead is substantial because lattice surgery requires patches to be adjacent for merge operations. A quantum computation involving many logical qubits must schedule and route merge operations, analogous to routing wires in a classical chip. This scheduling problem is itself computationally challenging and has spawned an active research area in quantum compilation and layout optimization.

19.4 The Color Code

The color code, introduced by Bombin and Martin-Delgado (2006), is an alternative topological code defined on a trivalent, three-colorable lattice (a lattice where each face can be colored with one of three colors such that no two adjacent faces share a color). Qubits live on vertices, and stabilizers are associated with faces.

Structure and Stabilizers

For each face $f$ of the lattice, define two stabilizers:

Both the $X$-type and $Z$-type stabilizer for a face act on the same set of qubits (all vertices of that face). This is different from the surface code, where $X$- and $Z$-type stabilizers act on different sets of qubits. The three-colorability ensures that all stabilizers commute.

Advantages of the Color Code

The color code has several advantages over the surface code:

• Transversal Clifford gates. The full Clifford group ($H$, $S$, CNOT) can be implemented transversally. On the surface code, only CNOT is transversal. The transversal $H$ gate maps the color code to itself (it swaps $X$- and $Z$-stabilizers, but the lattice structure is preserved). The transversal $S$ gate works because $Y$-type stabilizers are also in the stabilizer group.
• Higher encoding rate. For comparable code distances, color codes use somewhat fewer qubits than surface codes.

Disadvantages

However, the color code also has drawbacks:

• Lower threshold. The error threshold for the color code (~0.1% under circuit-level noise) is lower than the surface code's ~0.3%. This means physical qubits must be significantly better to benefit from color codes.
• More complex stabilizers. The stabilizer weight (number of qubits per stabilizer) is 6 on the standard hexagonal lattice, compared to 4 for the surface code. Higher-weight stabilizers are harder to measure and more error-prone.

19.5 Beyond Surface Codes: qLDPC Codes

The surface code's greatest strength - geometric locality on a 2D lattice - is also its greatest limitation. A $[[d^2, 1, d]]$ code requires $d^2$ physical qubits to encode a single logical qubit, giving a rate $k/n = 1/d^2$ that vanishes as the code distance grows. Can we do better?

Quantum LDPC Codes

Quantum low-density parity-check (qLDPC) codes are the quantum analogs of the classical LDPC codes that underpin modern wireless communications (Wi-Fi, 5G). In a qLDPC code, each stabilizer acts on at most $w$ qubits and each qubit is involved in at most $w$ stabilizers, where $w$ is a constant independent of the code size. The surface code is a qLDPC code with $w = 4$.

The breakthrough question is: can qLDPC codes achieve constant rate $k/n = \Theta(1)$ and growing distance $d = \Theta(n^\alpha)$ for some $\alpha > 0$, while keeping $w$ constant? In 2021, Pavel Panteleev and Gleb Kalachev showed the answer is yes: they constructed asymptotically good qLDPC codes with $k = \Theta(n)$ and $d = \Theta(n)$, meaning the rate and relative distance are both constant. This was a landmark result in quantum coding theory.

Notable qLDPC Code Families

• Hypergraph product codes (Tillich and Zemor, 2014): constructed from two classical LDPC codes, achieving $d = \Theta(\sqrt{n})$ with constant rate $k/n$. These are among the simplest qLDPC codes to analyze and decode.
• Fiber bundle codes (Hastings, Haah, and O'Donnell, 2021): achieve $d = \Theta(n^{3/5} / \text{polylog}(n))$, breaking the $\sqrt{n}$ distance barrier of hypergraph products.
• Quantum Tanner codes (Leverrier and Zemor, 2022): the first explicit construction of asymptotically good codes ($k = \Theta(n)$, $d = \Theta(n)$), based on Tanner's classical construction applied to high-dimensional expanders.
• Bivariate bicycle codes (Bravyi, Cross, Gambetta, Maslov, Rall, and Yoder, 2024): a practical family with $w = 6$ that offers substantially better encoding rates than the surface code while maintaining reasonable connectivity. IBM has proposed using these for near-term fault-tolerant demonstrations.

The Connectivity Challenge

The fundamental trade-off for qLDPC codes is between encoding efficiency and hardware connectivity. The surface code's $w = 4$ stabilizers require only nearest-neighbor interactions on a 2D grid - the natural geometry of superconducting qubit chips. qLDPC codes with better parameters require non-local interactions, which must be mediated by physical connections (long wires, flying qubits, or reconfigurable atom arrays) or by routing protocols that introduce overhead.

Neutral atom platforms, where individual atoms can be physically rearranged using optical tweezers, are especially promising for qLDPC codes. The ability to reconfigure connectivity dynamically could make high-rate qLDPC codes practical, potentially reducing the total qubit count for fault-tolerant computation by orders of magnitude compared to surface codes.