Surface Code

The leading quantum error correction code, using a 2D grid of qubits with local measurements.

The surface code is the most promising error correction code for near-term fault-tolerant quantum computers. It has high error thresholds and requires only nearest-neighbor interactions.

Structure

Qubits arranged in a 2D grid:

    ●───○───●───○───●
    │   │   │   │   │
    ○───●───○───●───○
    │   │   │   │   │
    ●───○───●───○───●
    │   │   │   │   │
    ○───●───○───●───○

● = Data qubit
○ = Ancilla (measurement) qubit

Two types of measurements:

• X stabilizers: Detect Z errors (measure X on 4 neighbors)
• Z stabilizers: Detect X errors (measure Z on 4 neighbors)

Logical Qubit

A surface code “patch” encodes one logical qubit:

• Size: $d\times d$ data qubits ($d$ = code distance)
• Logical $|0{⟩}_L$, $|1{⟩}_L$: Defined by boundary conditions
• Logical X, Z: Chains of operators across the patch

Error Correction

Errors create pairs of “defects” in syndrome measurements:

    0   0   0   0       0   0   0   0
      0   0   0   0  →    1   0   0   0   (error here)
    0   0   0   0       0   1   0   0

Decoder matches defects to identify errors. Most likely error pattern is corrected.

Code Distance

Distance $d$ = minimum number of errors to cause logical error.

Higher distance → better protection (but more qubits).

Error Threshold

The surface code has threshold $p_{th}\approx 1\%$.

If physical error rate $p<p_{th}$: $$p_L\approx {\left(\frac{p}{p_{th}}\right)}^{(d+1)/2}$$

Logical error rate decreases exponentially with distance!

Logical Operations

Non-Clifford gates (T) are expensive and require “magic states.”

Lattice Surgery

Merge and split surface code patches to perform logical operations:

Patch A ──[merge]── Patch B
        ──[measure]──
        ──[split]──

This implements logical CNOT between patches.

Advantages

Challenges

Current Status

• Google, IBM, Quantinuum demonstrating surface code
• Error rates approaching threshold
• Full fault-tolerant computation still requires significant scaling

See also: Quantum Error Correction, Logical Qubit, Fault Tolerance