Lattice Surgery

Why transversal CNOT is awkward on the surface code

The surface code is the leading architecture because it needs only nearest-neighbor couplings on a 2D grid and tolerates a high (~1%) circuit-level error rate. But a transversal logical CNOT between two surface-code patches would require pairing up the $i$ -th physical qubit of one patch with the $i$ -th of another — long-range connections that defeat the whole point of a planar layout. Lattice surgery is the alternative: it realizes logical two-qubit operations using only the same local stabilizer measurements the code already runs, by temporarily merging and splitting code patches along a shared boundary.

Boundaries, merges, and splits

A planar surface-code patch has two kinds of boundary, conventionally called rough ( $X$ -type) and smooth ( $Z$ -type). The logical operators $\overline{X}$ and $\overline{Z}$ run as strings between opposite boundaries. Lattice surgery manipulates patches through two primitive operations:

Merge. Bring two patches adjacent along a shared boundary and turn on the stabilizer checks that straddle the seam. Merging along smooth boundaries measures the joint operator $\overline{Z}_1 \overline{Z}_2$ ; merging along rough boundaries measures $\overline{X}_1 \overline{X}_2$ . The two patches become one larger code whose new stabilizers fix the joint parity.
Split. Stop measuring the seam stabilizers and resume the original per-patch checks, cutting one patch back into two. A split projects onto a definite logical state and produces a Pauli-frame byproduct determined by the measured stabilizer values.

A merge therefore performs a non-destructive measurement of a two-qubit logical Pauli operator — exactly the primitive needed to build entangling gates.

Building a logical CNOT

A merge gives a parity measurement, and parity measurements plus single-qubit logical operations and an ancilla generate a CNOT. The standard recipe uses an intermediary logical ancilla initialized in $|\bar 0\rangle$ (or $|\bar +\rangle$ ) and a sequence of one $ZZ$ -merge and one $XX$ -merge:

\overline{\mathrm{CNOT}}_{c\to t} \;=\; (\text{measure } \overline{Z}_c \overline{Z}_a)\;\circ\;(\text{measure } \overline{X}_a \overline{X}_t)\;\circ\;(\text{prepare } |\bar0\rangle_a, \text{ Pauli corrections}).

The measured parities determine Pauli byproduct operators, which are tracked in software (the Pauli frame) rather than physically applied. The net effect on the logical data is precisely a CNOT, built from nothing but local stabilizer measurements, prep, and classical bookkeeping.

Why it is fault-tolerant and cheap

Every step is a round of the same weight-four stabilizer measurements the surface code already performs, so it inherits the code's threshold and its tolerance to faulty syndrome extraction (merges are repeated $\sim d$ times so that a single measurement error cannot corrupt the inferred parity). Crucially, the spatial cost is modest: gates are done by bringing patches side by side on the chip and adjusting which checks are active, rather than by adding long-range wiring. This makes lattice surgery the standard way to compile logical circuits — including the Clifford glue around magic-state injection — onto a realistic 2D superconducting or neutral-atom array.

What to remember

Lattice surgery turns two-qubit logical gates into merge (measure a joint $\overline{Z}\, \overline{Z}$ or $\overline{X}\,\overline{X}$ ) and split operations on neighboring code patches, realized entirely with local stabilizer measurements and Pauli-frame tracking. It is how a planar surface-code machine performs entangling logic without ever needing a transversal, long-range gate.