Generalized Code Surgery Overview

• Generalized code surgery is a fault-tolerant method that deforms stabilizer or CSS codes using ancilla systems to gauge logical Pauli operators, extending lattice surgery to arbitrary codes.
• It employs chain complexes, chain maps, and pushouts to formalize code deformation, ensuring LDPC properties and preserving code distance through rigorous algebraic structures.
• Ancilla design via graph and cone constructions enables efficient parallel logical measurements, rapid syndrome extraction, and enhanced interoperability between different quantum error-correcting codes.

Generalized code surgery is a fault-tolerant method for performing logical measurements by temporarily deforming a stabilizer or CSS code with an ancilla system so that a desired logical Pauli operator becomes a stabilizer of a larger deformed code. In the chain-complex language used in several recent formulations, one starts with a CSS code $C_\bullet$ and a chain map $f:A_\bullet\to C_\bullet$, forms the mapping cone $cone(f)$, and uses the deformed code to “gauge” the logical operator into the stabilizer group; this generalizes lattice surgery beyond surface-code geometry to arbitrary CSS and qLDPC codes, and can be arranged to measure multiple commuting logical Paulis in parallel (Chang et al., 2 Mar 2026).

1. Foundational formulations

Generalized code surgery extends the familiar merge-and-split picture of lattice surgery into an algebraic framework for logical measurement. In the stabilizer description, code surgery is the process of temporarily deforming a base code by attaching an ancilla system so that a chosen logical operator becomes a product of newly introduced stabilizers; measuring those stabilizers reveals the logical outcome. In the CSS setting, this deformation is naturally expressed through chain complexes and chain maps rather than through a specific planar geometry (Chang et al., 2 Mar 2026).

A major formalization treats CSS code surgery as a universal construction in the category of chain complexes. In that approach, a CSS code is encoded by a length-2 chain complex, code maps are chain or cochain maps, and surgery is the pushout, equivalently the coequaliser, of a span of chain complexes. The pushout identifies shared substructure degreewise, yielding a merged code whose induced map on homology specifies the logical action. The same framework proves that merges and splits on LDPC codes yield codes which are themselves LDPC, provided the stated technical conditions concerning gauge fixing and code distance are satisfied (Cowtan et al., 2023).

A second formal line recasts code deformation and lattice surgery as gauge fixing. In that picture, an old code $C_{\rm old}$ and a new code $C_{\rm new}$ define a joint subsystem code with gauge group generated by both stabilizer groups, and the deformation step is a transition between two Abelian gauge choices inside the same subsystem structure. This identifies a simple fault-tolerance test: the relevant quantity is the distance of the underlying subsystem code, together with decoding on the common stabilizer group during the transition (Vuillot et al., 2018).

A further refinement replaces pushout language by quotients by subcodes. In this framework, a surgery protocol is specified by a $Z$-subcode or $X$-subcode included as a subcomplex of the direct sum of the participating codes, and the merged code is obtained as the corresponding quotient complex. The logical effect is then extracted from the long exact sequence associated to the short exact sequence $0\to V_\bullet\to E_\bullet\to Q_\bullet\to 0$. This formulation is explicitly basis-independent at the level of logical operator spaces and is used to compile a logical CNOT between arbitrary logical qubits of any CSS code (Poirson et al., 2 May 2025).

2. Ancilla systems and measurement constructions

The central engineering problem in generalized code surgery is ancilla design. For a logical operator to become measurable as a stabilizer of the deformed code, the ancilla must encode the intended logical relation while avoiding unwanted logical degrees of freedom and preserving bounded check weights. In graph-based constructions, the ancilla is modeled by a graph whose vertices correspond to one Pauli type of checks, edges correspond to physical qubits, and cycles correspond to the opposite-type checks; ports mark the support of the logical operator being measured (Zhou et al., 20 May 2026).

A general-purpose ancilla construction for arbitrary qLDPC stabilizer codes is given by the parsimonious-cone method. For a logical Pauli of weight $W$, earlier general constructions based on decongestion and thickening used ancilla size $\mathcal{O}(W\log^3 W)$, while the parsimonious construction achieves $f:A_\bullet\to C_\bullet$0. The construction starts from the measurement graph of the logical operator, builds a bounded-degree cell complex whose cycles are generated by face boundaries, and then attaches the resulting cone to the data code so that the chosen logical becomes a stabilizer of the deformed code. This immediately reduces asymptotic overheads in universal adapters, parallel logical measurement, extractor architectures, single-shot surgery, and constant-time surgery (Yuan et al., 5 Mar 2026).

Software frameworks expose the same ancilla logic from a categorical direction. SSIP, an open-source lightweight Python package for automating surgery between qubit CSS codes, performs both external surgery between codeblocks and internal surgery within a single codeblock by linear algebra over $f:A_\bullet\to C_\bullet$1 governed by pushouts and coequalisers in the category of chain complexes. Its ancilla toolbox includes path-complex gadgets and tensor-product constructions, and the package is demonstrated on lift-connected surface codes, generalized bicycle codes, and bivariate bicycle codes (Cowtan, 2024).

Resource-aware synthesis now treats ancilla construction as a compiler problem. GeneCS models surgery ancillas as graphs, then applies structure-aware optimizations that reuse path-matching connectivity, dynamically balance expansion and congestion, and enforce degree constraints during cycle partitioning and cellulation. This shifts generalized code surgery from a proof-oriented construction into a synthesized logical-measurement primitive for arbitrary stabilizer codes and cross-code communication (Zhou et al., 20 May 2026).

3. Distance preservation, LDPC structure, and fault-tolerance criteria

Distance preservation is not automatic in generalized code surgery. In the universal-construction framework, surgery along a shared logical operator requires separation and gauge fixing conditions so that the chosen logical support does not contain smaller logical operators and negative measurement outcomes can be corrected without corrupting the encoded information. The merged code must also have distance bounded below, because surgery can otherwise create new low-weight logical operators even when the initial codes are well behaved (Cowtan et al., 2023).

The gauge-fixing formulation sharpens the operational criterion. During deformation, error correction is performed against the common stabilizer group of the old and new codes, while gauge-fixing corrections are restricted to gauge operators. This separates physical-error correction from the algebraic act of choosing a gauge, and it explains why deformation protocols can fail when intermediate steps are skipped: the relevant failure mode is a drop in the distance of the underlying subsystem code rather than a problem with the endpoint codes alone (Vuillot et al., 2018).

These principles extend to parallel measurement. For any CSS quantum LDPC code, logically disjoint Pauli product measurements supported on $f:A_\bullet\to C_\bullet$2 logical qubits can be measured in parallel with ancilla cost $f:A_\bullet\to C_\bullet$3, where $f:A_\bullet\to C_\bullet$4 is the maximum weight of the single logical Pauli representatives involved, in time $f:A_\bullet\to C_\bullet$5 independent of $f:A_\bullet\to C_\bullet$6. The scheme preserves both the LDPC property and the fault-distance of the original code, and avoids ancillary logical codeblocks for the core protocol (Cowtan et al., 6 Mar 2025).

The compatibility of surgery with asymptotically good qLDPC codes has also been framed abstractly. One result states that the good quantum LDPC codes of Panteleev and Kalachev allow surgery using any logical qubits, albeit incurring an asymptotic penalty which lowers the rate and distance scaling; it also states that 3 of the 4 conditions for performing surgery can be satisfied without incurring an asymptotic penalty, and that if the last condition is also satisfied then one can perform code surgery while maintaining $f:A_\bullet\to C_\bullet$7 (Cowtan, 2023).

4. Temporal overhead and the move toward fast surgery

A persistent limitation of generalized code surgery has been time overhead. For generic qLDPC codes, the stabilizer outcomes of the deformed code are noisy and cannot be trusted from a single round, so one normally needs $f:A_\bullet\to C_\bullet$8 repeated syndrome-measurement rounds before the logical measurement can be decoded reliably. This bottleneck is especially acute for 2D hypergraph product codes, because generic 2D HGP codes do not have the redundancy needed for single-shot state preparation (Chang et al., 2 Mar 2026).

Recent work separates the question of fast surgery from the question of single-shot memory. A general constant-time framework shows that the decisive object is the auxiliary measurement complex: fast surgery requires an ancilla with sufficient connectivity and measurability structure, and in the most general setting this auxiliary structure is naturally described by a hypergraph rather than a graph. The same work introduces block reading, studies an intermediate regime between $f:A_\bullet\to C_\bullet$9 and $cone(f)$0 time overhead for quantum locally testable codes, and proves a circuit equivalence between homomorphic measurement and hypergraph surgery (Cowtan et al., 16 Oct 2025).

A distinct route to fast surgery constructs the merged code as the total complex of a base code and a suitably chosen homomorphic ancilla complex. In that scheme, the image of the ancilla homology becomes stabilizer data of the merged code, and one round of syndrome extraction suffices for fault tolerance under explicit boundedness and systolic-expansion conditions. On a $cone(f)$1 Abelian multi-cycle code, the merged code has parameters $cone(f)$2, the merged code distance remains $cone(f)$3, and the surgery fault distance is $cone(f)$4; under a phenomenological noise model, the one-round fast scheme performs comparably to a standard three-round generalized-surgery scheme (Baspin et al., 6 Oct 2025).

The most explicit constant-time construction for 2D qLDPC memory is the 2D HGP result. For a $cone(f)$5 HGP code $cone(f)$6, a sequence of ancilla complexes $cone(f)$7 is built so that each surgery operation takes $cone(f)$8 syndrome rounds in amortization and each gadget uses only $cone(f)$9 ancilla qubits, giving overall multiplicative spacetime overhead $C_{\rm old}$0. The construction lifts a 1D surgery gadget $C_{\rm old}$1 on one classical component by tensoring with the untouched code $C_{\rm old}$2, so that one logical measurement on the classical side becomes a parallel measurement of an entire row or column of quantum logicals in the product code. The fault-tolerance claim is explicitly amortized rather than one-shot: following Cowtan et al., performing $C_{\rm old}$3 surgery operations in $C_{\rm old}$4 time is fault tolerant provided the compacted code and each ancilla satisfy distance and non-overlap conditions (Chang et al., 2 Mar 2026).

5. Automation, compilers, and practical synthesis

Generalized code surgery is now supported by explicit software tooling. SSIP automates surgery between qubit CSS codes, including both external and internal surgery, and demonstrates that logical measurements can be performed cheaply on qLDPC families without sacrificing high code distance. For the $C_{\rm old}$5 gross code, the abstract reports that half of the single-qubit logical measurements in the $C_{\rm old}$6 or $C_{\rm old}$7 basis require only 30 total additional qubits each, assuming the upper bound on distance given by QDistRnd is tight, compared with an additional qubit count of 1380 initially predicted by Bravyi et al. The package is explicit about its scope: it automates code manipulations and distance estimates, but does not construct syndrome-measurement circuits, analyze noise thresholds, provide decoders, or impose geometric constraints (Cowtan, 2024).

Compiler-based optimization pushes the same agenda further. GeneCS synthesizes surgery protocols for arbitrary stabilizer codes by eliminating redundancy in graph construction, dynamically balancing expansion and congestion, and incorporating code degree constraints. Its reported experimental results show an average reduction of over $C_{\rm old}$8 in ancillary qubits and checks for both single-code and cross-code logical operations while preserving logical error rates, and the compiler scales to codes with more than $C_{\rm old}$9 qubits with an amortized compilation time of about one second per instance (Zhou et al., 20 May 2026).

Taken together, these developments suggest an emerging division of labor within the field. Universal constructions establish correctness and LDPC preservation, graph- and complex-based ancilla designs reduce asymptotic overhead, and software compilers translate those constructions into code-specific protocols. A plausible implication is that generalized code surgery is becoming less a hand-crafted family of gadgets and more a compiled layer for heterogeneous fault-tolerant architectures.

6. Logical operations, code interoperability, and architectural significance

Logical measurement is the primitive from which larger operations are assembled. A recent CSS-surgery framework uses subcodes and homological algebra to implement a logical CNOT gate between any two logical qubits of any CSS code, without assumptions on irreducibility or on a preferred logical-operator basis. The protocol composes a $C_{\rm new}$0-merge/$C_{\rm new}$1-split with an $C_{\rm new}$2-merge/$C_{\rm new}$3-split and a final auxiliary measurement, and the induced logical action is read directly from the maps on homology and cohomology (Poirson et al., 2 May 2025).

Generalized surgery also enables cross-code communication. In magic teleportation with generalized lattice surgery, non-Clifford gates are executed transversally on one QEC code and then teleported to the main circuit via a logical-level joint measurement that connects two distinct QEC codes. The proposed scaling change is structural: instead of the multiplicative overhead $C_{\rm new}$4, the architecture uses $C_{\rm new}$5, with an explicit example based on a 3D color code interfaced with a surface code of the same code distance (Wang et al., 25 Mar 2025).

The same interoperability theme appears in hybrid lattice surgery. There, rough merge and rough split are generalized to operations between different topological codes, including Abelian and non-Abelian quantum double models, with the interface described as gauging and ungauging a subgroup on the boundary. This produces either a magic-state preparation protocol or a non-Clifford gate teleportation protocol in the standard surface code, and the construction is further generalized to all finite levels of the Clifford hierarchy, gates beyond the hierarchy, and qutrit protocols (Huang et al., 23 Oct 2025).

Several common misconceptions are corrected by these results. Generalized code surgery is not confined to surface-code patch merging; it includes pushout, quotient, mapping-cone, gauge-fixing, and compiler-based formulations for arbitrary CSS and stabilizer codes. Fast surgery is not equivalent to single-shot memory; recent work states that the achievable measurement time overhead is controlled chiefly by the connectivity between a code and its measurement ancilla system (Cowtan et al., 16 Oct 2025). Constant-time claims also require care: in 2D HGP codes, the fast logical-measurement primitive is explicitly amortized, with $C_{\rm new}$6 syndrome rounds per operation inside a block that is buffered by $C_{\rm new}$7 rounds before and after (Chang et al., 2 Mar 2026).

In this sense, generalized code surgery has become a unifying framework for logical measurement, code deformation, and cross-code interfacing. It combines the flexibility of surgery with overheads that, in several recent constructions, are comparable to transversal gates or substantially below earlier ancilla estimates, while opening routes to batched computation, parallel logical processing, and heterogeneous qLDPC architectures (Chang et al., 2 Mar 2026, Yuan et al., 5 Mar 2026).