Lattice Surgery and Defect Braiding

Lattice surgery is now the compilation target of essentially every serious fault-tolerant architecture. Litinski's "Game of Surface Codes" represents a whole computation as a schedule of joint Pauli measurements $\bar M_P$ on a 2D floorplan of patches, reducing gate scheduling to a tiling problem and backing the estimates that quote millions of physical qubits for factoring or chemistry — estimates dominated not by the free Cliffords but by the magic-state factories feeding in $T$ gates, so surgery and distillation are engineered as one pipeline. The hardware has caught up. In 2024 Google demonstrated below-threshold surface-code memory, logical error falling as distance grew $d=3\to5\to7$ — the exponential suppression this article assumes, made fact. Neutral-atom processors (QuEra) have run surgery-style logical operations on dozens of logical qubits via mid-circuit atom rearrangement, and trapped ions (Quantinuum) real-time decoding. The defect picture lives on as the language of twist defects — dislocations behaving as Ising-like Majorana anyons — braided for extra Cliffords, the bridge to non-Abelian computation where braiding alone is universal.

Think of a surface-code patch as a rectangle of cloth whose two logical threads run between opposite edges: $\bar X$ stitches one pair of boundaries, $\bar Z$ the other, and because the threads cross once they anticommute — that single crossing is the whole logical algebra. Lattice surgery sews two rectangles along a shared edge; the seam is a fresh row of stabilizers, and it can be sewn consistently only if it measures the combined thread $\bar X_1\bar X_2$ — the joint Pauli measurement. Unpicking the seam (the split) returns two rectangles, but the stitching injected a random $\pm$ sign you must remember. Every step is local. A merge just switches on a column of stabilizers and measures them for $\sim d$ rounds (the code distance), so faults during the operation are matched and corrected exactly as in the static memory. No quantum amplitude is transported; only the boundary — a classical record of which stabilizers are active — moves. The first figure shows the merge and the joint operator it measures, on real distance-3 patches.

Defects tell the dual story. Punch two holes and switch off the stabilizers inside them; a logical qubit now lives on the pair, with $\bar Z$ a thread joining them and $\bar X$ a loop encircling one. Dragging one hole (by measuring stabilizers along its path) in a full loop around a hole of the opposite type wraps one logical loop irreversibly through the other, forcing the two threads to be re-expressed in terms of each other — precisely the algebra of a CNOT. Microscopically it is the toric code's $e$ charge carried once around its $m$ flux, collecting the tell-tale $-1$. The second figure shows the braid and the gate it produces.

Because the surface code is CSS and both operations merely permute Paulis, everything they build lies inside the Clifford group. The expensive resource is the non-Clifford $T$: it cannot be woven or sewn, but must arrive as a distilled magic state teleported in by a surgery measurement — the seam to magic-state distillation.

The stage is the surface code: qubits on the edges of a lattice, one stabilizer per vertex and one per face. Every construction below edits this stabilizer group, and the two check types commute because a vertex and a face share an even number of edges.

where: $A_v$ — vertex (star) stabilizer, a product of $X$ on the edges meeting vertex $v$; $B_p$ — plaquette (face) stabilizer, a product of $Z$ on the edges bounding face $p$; $X_e,Z_e$ — Paulis on the qubit on edge $e$. Reading: the code space is the joint $+1$ eigenspace of every check, and any $A_v,B_p$ overlap on $0$ or $2$ edges. Logical operators are what the stabilizers cannot detect: non-contractible chains that commute with every check but not with each other. They anticommute because one runs on the lattice, the other on its dual, and the two chains cross an odd number of times.

where: $\gamma$ — a non-contractible primal path (between smooth boundaries, or wrapping the torus); $\gamma^*$ — a non-contractible dual path crossing $\gamma$ an odd number of times; $\{\cdot,\cdot\}$ — the anticommutator. Reading: a single crossing is one shared qubit on which $X,Z$ anticommute, so $\{\bar X,\bar Z\}=0$ — one logical qubit per handle. A rough merge turns on a column of star operators in the gap and measures them; their seam-product equals the joint logical $\bar X_1\bar X_2$, so the merge is a projective measurement of that observable with a random outcome.

where: $P_m$ — projector onto the $(-1)^m$ eigenspace of $\bar X_1\bar X_2$; $m\in\{0,1\}$ — the random outcome, the parity of the new gap star stabilizers; $\bar X_i$ — logical $X$ of patch $i$. Reading: the merge is not unitary — it collapses the patches onto a definite joint $X$-parity and hands you a classical bit $m$. The complementary merge runs along smooth ($Z$-type) boundaries, where the gap operators are plaquettes and the measured observable is $\bar Z_1\bar Z_2$; the boundary flavour facing the gap picks the measured Pauli.

where: $\bar Z_i$ — logical $Z$ of patch $i$; $m$ — parity of the new gap plaquette stabilizers $B_p$. Reading: $\bar M_{XX}$ and $\bar M_{ZZ}$ with single-patch Cliffords generate the full Clifford group — the joint measurement is the entangling ingredient. Splitting restores two independent patches, but re-imposing the removed stabilizers does not commute with the random gap outcomes, so a logical byproduct appears — a parity of the recorded outcomes, corrected in software.

where: $s$ — parity of the relevant gap-stabilizer outcomes; $\bar Z^{\,s}$ — the conditional logical-$Z$ byproduct applied classically (tracked, not physically). Reading: without $s$ the split is a random logical flip; with $s$ it is deterministic — the art is the bookkeeping. Defect braiding gives the same Clifford power geometrically: dragging a primal defect once around a dual defect maps the logicals by the Heisenberg action of a CNOT, primal the control, dual the target.

where: $e,m$ — primal ($Z$-cut) and dual ($X$-cut) defect qubits, control and target; $U_{\text{braid}}$ — the unitary of moving $e$'s loop fully around $m$. Reading: $\bar X_m,\bar Z_e$ are invariant, so the four maps are exactly $\mathrm{CNOT}_{e\to m}$. The braid works for one microscopic reason: carrying a toric-code charge $e$ once around a flux $m$ multiplies the state by $-1$, and this $\mathbb{Z}_2$ monodromy, lifted to logical loops, entangles the defect qubits.

where: $e$ — electric charge, a violated star $A_v=-1$; $m$ — magnetic flux, a violated plaquette $B_p=-1$. Reading: a full braid is topological — its value depends only on whether the loop encircles the other defect, not on the path's shape or speed. Finally, universality: neither surgery nor Abelian braiding can make a $T$, so it is imported as a distilled magic state and teleported into a data patch by a surgery measurement with a Clifford correction.

where: $|T\rangle$ — the distilled magic state carrying the phase $\pi/4$; $\bar M_{ZZ}$ — the joint surgery measurement teleporting the gate. Reading: this is the doorway through which the cost of universality — the magic-state factories — enters the floorplan.

The reach and cost of these primitives are set by the code distance, the boundary type, and — most sharply — the Clifford versus non-Clifford divide no amount of surgery or Abelian braiding can bridge.

1 · Code distance and qubit budget for a fault-tolerant surgery CNOT (fully worked)

A superconducting processor has physical error rate $p=10^{-3}$ and threshold $p_{\mathrm{th}}\approx10^{-2}$. Each logical CNOT must fail with probability at most $p_L=10^{-15}$. Using rotated planar patches (qubit count $2d^2-1$) and a $1\ \mu s$ syndrome round, find the code distance $d$, the physical qubits per patch, and the time of one surgery CNOT.

Step 1. Set the suppression. Below threshold $p_L\sim A\,(p/p_{\mathrm{th}})^{\lfloor d/2\rfloor}$ with $A=O(0.1)$ and $p/p_{\mathrm{th}}=0.1$. Requiring $(0.1)^{\lfloor d/2\rfloor}\lesssim10^{-15}$ gives $\lfloor d/2\rfloor\ge15$, so the smallest odd distance is $d=\mathbf{31}$ ($\lfloor31/2\rfloor=15$, giving $p_L\sim10^{-16}$, under budget).

Step 2. Qubits per patch. A rotated planar code of distance $d$ uses $2d^2-1$ physical qubits: $2(31)^2-1=\mathbf{1921}$ per logical patch. A surgery CNOT occupies control, target, and one ancilla bus patch, so $\approx3\times1921\approx\mathbf{5.8\times10^{3}}$ physical qubits are live during the gate.

Step 3. Wall-clock time. Each merge or split runs $\sim d$ rounds; a CNOT is a short merge–split sequence, so $\sim2d$ rounds end to end. At $1\ \mu s$ per round, $2d=62$ rounds is $\mathbf{62\ \mu s}$ per logical CNOT. Result: d = 31, about 1900 physical qubits per patch (≈ 5.8 thousand for the CNOT), ≈ 62 μs per gate — the arithmetic behind million-qubit surface-code resource estimates.

2 · Braiding a CNOT turns a product state into a Bell pair

Take defect qubits $e$ (control) in $|+\rangle_e$ and $m$ (target) in $|0\rangle_m$. Braid $e$ once around $m$ and identify the output state, using only the Heisenberg map of equation (6).

Step 1. The input $|+\rangle_e|0\rangle_m$ is the unique state stabilized by $\{\bar X_e,\ \bar Z_m\}$ (the $+1$ eigenstates of $\bar X_e$ and $\bar Z_m$).

Step 2. Conjugate each stabilizer by the braid: from equation (6), $\bar X_e\to\bar X_e\bar X_m$ and $\bar Z_m\to\bar Z_e\bar Z_m$, so the output is stabilized by $\{\bar X_e\bar X_m,\ \bar Z_e\bar Z_m\}$ — exactly the stabilizers of a Bell pair.

Step 3. The joint $+1$ eigenstate of $\bar X_e\bar X_m$ and $\bar Z_e\bar Z_m$ is $\tfrac{1}{\sqrt2}\big(|00\rangle+|11\rangle\big)$, so a single braid entangled two unentangled qubits. Result: braiding e around m maps $|+\rangle_e|0\rangle_m \to \tfrac{1}{\sqrt2}(|00\rangle+|11\rangle)$, the fingerprint of a CNOT on $|+\rangle|0\rangle$ — entanglement created with no two-qubit gate touching a physical qubit, only a defect walked in a circle.

Lattice surgery and defect braiding are two dialects of one language — the topological stabilizer code — and that language has a principal author. Before these gates could exist, someone had to see that a quantum memory could be built from the homology of a lattice.

Texts and papers. Horsman, Fowler, Devitt & Van Meter, "Surface code quantum computing by lattice surgery," New J. Phys. 14, 123011 (2012) · Fowler, Mariantoni, Martinis & Cleland, "Surface codes: towards practical large-scale quantum computation," Phys. Rev. A 86, 032324 (2012) · Bravyi & Kitaev, quant-ph/9811052 (1998) · Kitaev, "Fault-tolerant quantum computation by anyons," Ann. Phys. 303, 2 (2003) · Litinski, "A game of surface codes," Quantum 3, 128 (2019) · Raussendorf, Harrington & Goyal, New J. Phys. 9, 199 (2007) · Preskill, Lecture Notes on Quantum Computation, Ch. 9 · Nielsen & Chuang, Ch. 10. The threshold $p_{\mathrm{th}}\approx1\%$ and scaling $p_L\sim(p/p_{\mathrm{th}})^{\lfloor d/2\rfloor}$ are standard results, and the rotated-planar qubit count $2d^2-1$ is exact. Key checkpoints: $[A_v,B_p]=0$ and $\{\bar X,\bar Z\}=0$ follow from shared-edge counts; the telescoping product gives $\prod_v A_v\propto\bar X_1\bar X_2$ with gap stars anticommuting with $\bar Z_1,\bar Z_2$; the surgery-CNOT map is $\bar X_1\to\bar X_1\bar X_2$, $\bar Z_2\to\bar Z_1\bar Z_2$; the braiding map yields the Bell-pair output of Worked Example 2; and the worked arithmetic gives $d=31$, $2d^2-1=1921$, $\sim62\ \mu s$.

Prerequisites. Toric Code and Topological Order · Anyons and Fractional Statistics · Topological Quantum Computation · Magic State Distillation. Leads to. Magic State Distillation · Non-Abelian Braiding and Fusion Rules · Measurement-Based Quantum Computation · Fibonacci and Ising Anyons.

Ask the tutor: Want to walk the surgery CNOT stabilizer-by-stabilizer, or see how a twist defect braids to a Hadamard? Ask and we will track every Pauli and outcome through the frame.