Surface Codes

Stabilizer Codes and Decoding gave you the full machinery for a 3-qubit code: physical qubits, stabilizer checks, syndromes, and a decoder that infers a correction. Nothing about that machinery was specific to three qubits.

Physical qubits

↓

Stabilizer checks

↓

Syndrome

↓

Decoder

What happens when we arrange these same checks across many physical qubits, laid out on a two-dimensional grid? That's a surface code — a structured arrangement of physical qubits and local stabilizer checks across a 2D lattice.

Note

Surface codes are not a fundamentally new error-correction mechanism. They're the same stabilizer-based machinery you already understand, scaled across a larger, structured system.

Meet the Surface-Code Patch

Here's a small patch (distance 3 — more on what that means shortly):

Data qubit — holds a piece of the encoded information Check qubit (× = X-type, + = Z-type)

Two kinds of physical qubit, doing two different jobs:

• Data qubits — participate in storing the encoded quantum information.
• Measurement / check (ancilla) qubits — obtain information from local stabilizer checks. They don't store logical information themselves.

Where is the logical qubit? It is not stored in any one physical qubit. The logical information is encoded collectively across the whole patch — the same idea as Physical vs Logical Qubits, just spread over more qubits in two dimensions instead of three in a row.

X-Type and Z-Type Checks

You've already met \(X\) and \(Z\) errors, and the fact that a Z-type check (like \(S_1=Z_1Z_2\) in the repetition code) catches X errors while staying blind to Z errors. Surface codes use both kinds of check side by side, precisely so nothing slips through:

• X-type checks (marked ×) help reveal information about Z-type (phase-flip) errors.
• Z-type checks (marked +) help reveal information about X-type (bit-flip) errors.

Physical error

↓

Conflicts with particular local checks

↓

Those check outcomes change

No stabilizer algebra needed yet — try it directly below.

Main Interactive — Create an Error on the Surface

Click a data qubit, choose an error type, and watch the neighboring checks respond.

Apply X here Apply Z here Reset

Click any data qubit (the gray circles) to select it.

The syndrome list above is deliberately separate from the lattice picture: the system never "sees" the microscopic error directly — it only sees which checks fired. That's the same distinction from Encoding & Syndrome Measurement, now playing out on a grid instead of a line of three.

From One Error to an Error Chain

A single error lights up its neighboring checks. What happens with several errors in a row — an error chain?

Reset Chain

Click the three highlighted qubits in the middle row, in any order, to build a chain.

The syndrome does not necessarily reveal every physical error along the path — only where the chain's effect fails to cancel out.

Explanation A Explanation B

If several possible error chains could explain what we measured, how do we know which one occurred? We may not need to reconstruct the exact physical history — the decoder just needs to choose a recovery that preserves the logical information, exactly as in Decoding.

Code Distance and Scaling

Code distance describes the minimum size of an undetectable logical error — the shortest error pattern that can change the encoded logical information without tripping any check along the way.

Distance 3 Distance 5 Distance 7

Data qubits – Checks – Corrects up to –

Preview: t = (d − 1) / 2

For an idealized distance-\(d\) code, the number of errors it can correct is \(t = \lfloor (d-1)/2 \rfloor\) under the relevant assumptions. We won't derive this here — the visual above (more distance → more checks → more resources) is what matters at this level.

Code distance, more precisely

An error pattern that trips no check but still changes the encoded information is a logical operator: it commutes with every stabilizer check, yet it is not itself a product of checks. Its weight is the number of qubits it acts on. The code distance is the smallest weight of any such operator:

\[ d = \min \{\, |L| : L \text{ is a nontrivial logical operator} \,\} \]

In the square patch used here, a logical X error is a chain of X errors running from one boundary of the patch to the opposite boundary, and a logical Z error is a chain of Z errors across the other pair of boundaries. Each such chain involves at least \(d\) qubits, so both distances equal \(d\).

Why \(t = \lfloor (d-1)/2 \rfloor\). Suppose at most \(t\) errors occurred, and a decoder proposes the smallest correction consistent with the syndrome, so the correction also involves at most \(t\) qubits. The actual error and the correction together act on at most \(2t \le d-1\) qubits, and together they trip no checks. An operator that trips no checks and acts on fewer than \(d\) qubits cannot be a nontrivial logical operator, so it is a product of checks and leaves the logical information unchanged. The error is therefore corrected.

This argument assumes errors only on data qubits, perfect syndrome measurement, and minimum-weight decoding. Real devices relax each of these, which is part of what Hardware-Aware QEC is about. The patch drawn above also shows only its interior checks; a complete patch has checks along its boundaries too, which is why boundaries matter at this level.

Bigger distance means better protection, but it isn't free:

Larger distance

↓

Larger patch, more physical resources

↓

More syndrome information

↓

Harder decoding problem

More physical qubits doesn't automatically mean better real performance, either — real hardware has its own error rates and connectivity limits, which is exactly the subject of Hardware-Aware QEC.

Physical Errors vs. Logical Errors

• Physical error — an error affecting one or more physical qubits. It can often be detected and corrected without ever touching the encoded logical information.
• Logical error — a physical error pattern (plus whatever recovery was applied) that ends up changing the encoded logical information.

A physical error is not automatically a logical error. Compare a short, local error against one that spans the whole patch:

Short chain Full-span chain

From Surface Codes to Decoding at Scale

3-qubit repetition code

Few qubits

↓

Few checks

↓

Small syndrome table

↓

Simple decoding

Surface code

Many physical qubits

↓

Many local checks

↓

Many possible error chains

↓

Complex syndrome patterns

↓

Efficient decoding required

Which error chain is the best explanation for a given syndrome? A decoder needs an efficient way to compare possible explanations and choose a good recovery — without exhaustively listing every possibility the way we could for three qubits.

Takeaway

Logical information

↓

Encoded across a surface-code patch

↓

Physical data qubits + local stabilizer checks

↓

Physical errors occur

↓

Check outcomes change → syndrome

↓

Decoder interprets the evidence

↓

Logical information protected

A surface code scales the stabilizer-based QEC machinery across a structured lattice of physical qubits. Local checks provide evidence about physical errors, while a decoder must interpret that evidence to protect the encoded logical information.

Many different error chains may explain the same detection information. How can a decoder efficiently choose a good recovery?

Next: Minimum-Weight Perfect Matching →