Lattice Surgery in Quantum Computation

• Lattice surgery is a method for fault-tolerant quantum computation that uses merge and split operations on topological-code patches to perform joint logical measurements.
• It enables universal computation by coupling 2D topological codes, reducing qubit overhead and simplifying logical operations as shown by resource analyses and experimental realizations.
• Generalizations extend its framework to color, qudit, and modular architectures, integrating with quantum compilers and optimized decoder strategies for enhanced performance.

Searching arXiv for core papers on lattice surgery and related extensions. Lattice surgery is a measurement-based method for fault-tolerant quantum computation in which logical operations are implemented by temporarily merging and splitting neighboring topological-code patches so that newly measured stabilizers reveal joint logical Pauli observables. Introduced for planar surface codes as a way to preserve strictly two-dimensional nearest-neighbor structure without transversal inter-patch gates or defect braiding, it has since become a general framework spanning rotated and rectangular surface codes, color codes, qudit codes, measurement-based realizations on the Raussendorf lattice, modular architectures, and heterogeneous-code interfaces (Horsman et al., 2011, Cowtan, 2022).

1. Origins and architectural role

The original surface-code formulation defined lattice surgery as a way to couple planar code patches by “cutting” and “stitching” their boundaries, thereby enabling universal quantum computation, including magic state injection, while maintaining a strictly 2D nearest-neighbor design. In that formulation, merge and split operations replaced braided logic, and a rotated lattice further reduced qubit count. The paper also showed that an encoded CNOT between two distance 3 logical states is possible with 53 physical qubits, half of that required in any other known construction in 2D (Horsman et al., 2011).

Subsequent compiler-oriented work reframed lattice surgery as a translation target for inverse-ICM circuits. In that picture, smooth splits create the entangled resource structure associated with multi-target CNOTs, rough merges reconcile repeated logical wires, and measurement-time state injection supplies the non-Clifford basis changes. This made lattice surgery a patch-based compilation model rather than a small collection of ad hoc logical gadgets (Herr et al., 2016).

Resource analyses later argued that the patch-based picture is not only locality-preserving but also materially cheaper than defect-and-braid approaches. One study estimated that rotated-patch storage requires about $3d^2$ physical qubits per logical qubit, compared with about $12.5d^2$ for double-defect storage, and that an algorithm with $10^8$ $T$ gates and 100 logical qubits at physical error rate $p\sim 10^{-3}$ could be reduced from about $1.8\times 10^6$ to about $3.7\times 10^5$ physical qubits while keeping runtime in the same ballpark (Fowler et al., 2018).

2. Primitive operations and logical semantics

At the primitive level, lattice surgery is not a conventional gate model. Rough and smooth merges are non-unitary logical parity measurements, and rough and smooth splits are non-unitary embeddings that change the number of encoded qubits. In the original surface-code construction, rough merge measures $X_LX_L$, smooth merge measures $Z_LZ_L$, smooth split maps

$$\alpha \lvert 0\rangle_L + \beta \lvert 1\rangle_L \longrightarrow \alpha \lvert 00\rangle_L + \beta \lvert 11\rangle_L,$$

and rough split maps

$12.5d^2$0

These transformations explain why lattice surgery naturally generates Bell and GHZ states and why merge operations are better interpreted as parity projections than as encoded unitaries (Horsman et al., 2011).

A recurring misconception is that lattice surgery is merely a surface-code way to implement CNOT. A more exact statement is that CNOT is one derived construction built from the deeper primitives of merge and split. The ZX-calculus formalization made this explicit: rough operations correspond to red spiders, smooth operations to green spiders, positive branches correspond to plain spiders, and negative branches correspond to spiders with byproduct $12.5d^2$1-phase nodes. In that formulation, the lattice-surgery primitives satisfy the axioms of a dagger special commutative associative Frobenius algebra, and branch-dependent corrections are represented natively by ensembles of diagrams rather than by forcing the process into standard circuit notation (Beaudrap et al., 2017).

This semantic viewpoint matters operationally. It explains why lattice surgery composes naturally with measurement-based computation, Pauli-frame updates, and teleportation-based non-Clifford primitives, and why the right intermediate representation is often a parity-measurement network rather than a gate list.

3. Generalizations beyond homogeneous surface-code patches

Although surface codes dominate the practical literature, lattice surgery is not confined to homogeneous qubit patches. In triangular 4.8.8 color codes, lattice surgery realizes the universal set

$12.5d^2$2

with transversal $12.5d^2$3 and $12.5d^2$4 in a single step, and with per-code-distance qubit cost approximately half that of surface-code lattice surgery. The same work also improved existing surface-code lattice-surgery methods for CNOT, $12.5d^2$5, and $12.5d^2$6 (Landahl et al., 2014).

Qudit lattice surgery extends the framework from qubits to arbitrary finite-dimensional $12.5d^2$7 surface codes built on the group algebra $12.5d^2$8. In that setting, one logical patch encodes a $12.5d^2$9-dimensional qudit, smooth split satisfies

$10^8$0

rough split satisfies

$10^8$1

and merge outcomes become $10^8$2-valued additive charges rather than binary parities. The formalism remains closely tied to the qudit ZX-calculus and still requires magic state injection for universality (Cowtan, 2022).

In the measurement-based Raussendorf lattice, the same ideas appear as operations on 3D cluster-state “boxes.” Interior qubits are measured in the $10^8$3 basis, exterior qubits in the $10^8$4 basis, and the time slice on which a region is turned on determines its logical initialization: switching from $10^8$5 to $10^8$6 on an even slice yields $10^8$7, while switching on an odd slice yields $10^8$8. Rough and smooth merges become time-scheduled basis changes on boundaries between boxes (Herr et al., 2017).

A further extension couples different CSS codes. Generalized lattice surgery has been used to connect a surface code hosting the main computation to a 3D color code supporting transversal non-Clifford gates. In the explicit construction, interface ancillas are added, boundary $10^8$9-checks are enlarged, and new $T$0-checks are introduced so that their product equals the desired inter-code logical operator $T$1. This enables “magic teleportation,” in which a non-Clifford gate prepared transversally in one code is teleported into another through a joint logical measurement, with an overhead model written additively rather than multiplicatively (Wang et al., 25 Mar 2025).

4. Surface-code protocol engineering, decoding, and $T$2-type measurements

Practical lattice surgery requires more than the abstract merge–split picture. One line of work introduced a decoder that corrects both spacelike and timelike errors during lattice-surgery protocols under a biased circuit-level noise model, proposed a twist-free method for arbitrary Pauli measurements that avoids bulk twist defects, and added temporally encoded lattice surgery to reduce both runtime and total space-time cost. In that framework, the runtime of a Pauli-based computation was written as $T$3, emphasizing that lattice-surgery runtime is set jointly by measurement distance and the number of adaptive Pauli measurements (Chamberland et al., 2021).

The most detailed surface-code engineering treatment of $T$4-containing measurements took the opposite route and made twist defects explicit. It showed that the most general surface-code lattice-surgery operations require twist defects for direct fault-tolerant measurement of mixed Pauli observables involving $T$5, supplied a concrete circuit-level protocol with a minimal degree-8 connectivity extension, and introduced ancilla-assisted circuits for weight-five twist checks and elongated stabilizers that fit into a four two-qubit-gate time-step schedule. It also proved, via gauge fixing, a direct $T$6-boundary measurement scheme that bypasses the extension stage used in earlier proposals, and reported that the threshold for timelike logical failures is slightly decreased relative to twist-free bulk surgery but that, for CNOT infidelities below $T$7, the performance degradation is mild and preferable over the paper’s proposed twist-free alternative (Chamberland et al., 2022).

Taken together, these results clarify an important point. For direct measurement of generic $T$8-containing observables in standard surface-code geometry, twist defects are the natural construction; however, distinct twist-free and temporally encoded protocols can reproduce the same computational power while trading circuit depth, routing, scheduling complexity, and decoder structure in different ways. A plausible implication is that “whether lattice surgery needs twists” is not a yes-or-no question but an architectural choice tied to hardware connectivity, bias regime, and the form of the target Pauli measurements.

5. Modular architectures and experimental realizations

In modular surface-code architectures, the boundary stabilizers needed for lattice surgery become inter-module operations. A Bell-measurement-based protocol recast modular lattice surgery so that all non-local operations are Bell measurements, reducing the standard entanglement consumption from $T$9 Bell pairs per syndrome round to $p\sim 10^{-3}$0, confining interface noise to the interface, and mitigating distance-reducing hook errors by alternating between two valid syndrome-extraction schedules. Circuit-level simulations for logical Bell-state preparation reported a typical $p\sim 10^{-3}$1 entanglement-rate saving at fixed logical error rate (Haug et al., 15 Oct 2025).

The first direct hardware realization of lattice surgery between topologically encoded logical qubits used a 10-qubit trapped-ion processor implementing two 4-qubit surface-code logical qubits. That experiment demonstrated rough and smooth surgery, generated a logical Bell state with fidelity $p\sim 10^{-3}$2 raw and $p\sim 10^{-3}$3 post-selected, and used the same parity-measurement primitive for logical teleportation, achieving teleported-state fidelities up to $p\sim 10^{-3}$4 raw and $p\sim 10^{-3}$5 post-selected for $p\sim 10^{-3}$6 (Erhard et al., 2020).

A later planar superconducting processor realized lattice-surgery operations between two distance-three surface-code logical qubits during repeated syndrome extraction. After leakage rejection, the logical qubits exhibited per-cycle error rates $p\sim 10^{-3}$7 and $p\sim 10^{-3}$8. Joint initialization and lattice splitting were used to prepare a logical Bell state with decoded fidelity lower bound $p\sim 10^{-3}$9 and post-selected fidelity lower bound $1.8\times 10^6$0, and magic-state injection plus gate teleportation implemented continuous non-Clifford rotations about the logical $1.8\times 10^6$1 axis, including a post-selected logical $1.8\times 10^6$2 fidelity of $1.8\times 10^6$3 conditioned on no detected errors (Wang et al., 4 Jun 2026).

A complementary superconducting-architecture study of logical teleportation between two planar patches compared fully modular and depleted schedules, found that the depleted distance-three protocol improves logical teleportation infidelity by about a factor of $1.8\times 10^6$4, concluded that the optimal interface is a single column of data qubits, and estimated an effective threshold of $1.8\times 10^6$5 relative to its reference error model. The same work argued that adaptive in-sequence decision logic is beneficial only if control latency is on the few-hundred-nanosecond scale and that the depleted schedule is not a scalable replacement for modular protocols at larger distance (Bödeker et al., 13 Jun 2026).

6. Compilation, routing, and verification

Once lattice surgery is treated as a compilation target, its geometry becomes a constrained optimization problem. The decision problem of determining whether a lattice-surgery translation can achieve its theoretical optimum area is NP-complete, and the corresponding optimization problem is NP-hard via reduction from 3-partition. In the formal abstraction used for that proof, multi-target CNOT columns become vertical patch chains, repeated qubit labels enforce horizontal adjacency constraints, and exact optimization reduces to minimizing the bounding box of the planar patch layout (Herr et al., 2017).

Scheduling many surgeries over time adds a second layer of complexity. A later study reduced two-body lattice-surgery scheduling with instruction decomposition to embedding paths in a 3D voxel lattice, where valid paths must satisfy a kink-parity condition. Its Dijkstra-projection heuristic searches only in 2D while lifting paths into 3D, has path-search complexity $1.8\times 10^6$6, and on a SELECT benchmark derived from qubitization-based quantum phase estimation improved throughput by $1.8\times 10^6$7 over look-ahead BFS (Hamada et al., 2024).

At the program-analysis level, lattice surgery can be modeled as dynamic graph connectivity. In $1.8\times 10^6$8, a logical qubit at location $1.8\times 10^6$9 has type $3.7\times 10^5$0, multi-qubit measurements become path-existence obligations on an architecture graph $3.7\times 10^5$1, and a static type system extracts a command sequence of allocations, deallocations, and merge constraints. The resulting soundness theorem states that a well-typed program will not get stuck because a required surgery path is unavailable, and type checking is reduced to offline dynamic connectivity (Wakizaka et al., 2024).

These results make clear that lattice surgery is not only a code-deformation technique but also a software problem. Placement, routing, timing, and static correctness are all first-class concerns. A common high-level description—“measure a joint parity by merging two patches”—suppresses the fact that scalable use of lattice surgery requires nontrivial compiler heuristics, formal verification, and architecture-specific routing policies.