Fast Code Surgery: Fault-Tolerant Quantum Logic

• Fast code surgery is a quantum protocol defined by fault-tolerant measurement and code deformation that enables rapid logical operations in error-correcting codes.
• It leverages advanced syndrome extraction techniques and chain complex structures to reduce time overhead to O(d) or even O(1) while maintaining LDPC properties.
• The procedure utilizes categorical and homological constructions to merge ancillas with CSS codes, ensuring robust fault tolerance and efficient resource scaling.

A fast code surgery procedure is a fault-tolerant measurement and code deformation protocol that enables logical operations—such as joint Pauli measurements and entangling gates—on quantum error-correcting codes with minimal temporal overhead. It generalizes lattice surgery beyond surface and color codes to arbitrary CSS LDPC codes and chain-complex–structured quantum codes. Such procedures are designed to achieve either $O(d)$ or, in recent work, $O(1)$ syndrome-extraction depth while maintaining code distance and LDPC properties, leveraging categorical constructions, homological algebra, expander graphs, auxiliary hypergraph complexes, or higher-form symmetry in the underlying code structure.

1. Principles of Fast Code Surgery

Fast code surgery targets the implementation of logical measurements (e.g., $Z \otimes Z$ or $X \otimes X$ between code blocks) or non-unitary logical channels (state preparation, CNOT, magic state generation) while minimizing space–time overhead. The classically dominant approach to syndrome-protected logical measurement involves performing $O(d)$ rounds (with $d$ the code distance) of repeated syndrome extraction to suppress measurement errors; code surgery schemes attempt to reduce this round complexity by leveraging structural properties of the code and appropriately designed ancilla complexes.

In the general setting, CSS codes are formalized as chain complexes over $\mathbb{F}_2$ with boundary maps encoding $X$- and $Z$-type check operators, with logical operators corresponding to nontrivial homology or cohomology classes. Surgery is represented as a specific colimit (pushout) or limit (pullback) in the category of chain complexes, physically instantiated by adding ancilla qubits, modifying stabilizer supports, and performing targeted measurement rounds on merged patches or auxiliary subsystems. The essential conditions for fault tolerance are the preservation of code distance and ensuring that ancilla-linking does not reduce logical error-detecting capability (Cowtan et al., 2023, Cowtan, 2024, Baspin et al., 6 Oct 2025).

2. Fault-Tolerance and Distance Preservation

To guarantee fault tolerance, fast code surgery must preserve (or sometimes increase) the minimum distance of the logical operators being measured. Key formal results establish that if all injective maps (branchings and glueings) are between appropriately chosen subcomplexes—corresponding to irreducible logical representatives with guaranteed gauge-fixability—then the merged code possesses a distance lower bound at least as large as the original codes; error propagation is limited by the expansion properties and local check structures. Measurement errors on ancillas are either suppressed by code design or detected by meta-checks or classical post-processing (Cowtan et al., 6 Mar 2025, Baspin et al., 6 Oct 2025, Cowtan, 2024).

For example, in the fast surgery protocol for general CSS codes, the auxiliary system is built as a chain complex $D_\bullet$ with a chain map $\gamma_\bullet: D_\bullet \to C_\bullet$ targeting the logical X or Z operators of interest. The merged code is constructed as the total complex, with stabilizer matrices augmented by the map $\gamma$ and deformed stabilizers acting jointly on data and ancilla. The logical error rate for $p$-stochastic Pauli noise then scales as $O(p^{d'})$, where $d'$ is the effective "surgery distance," typically lower bounded by the code distance or the distance of the ancilla subsystem (Baspin et al., 6 Oct 2025).

3. Constant-Time and Parallelization Techniques

A major advance in fast code surgery is achieving constant time overhead—$O(1)$ syndrome measurement depth—for a broad class of code families. This is possible either by exploiting codes with higher-form symmetries (which admit transversal Clifford gates acting on many logical qubits in parallel), or by designing expander-graph-based gauging gadgets with high Cheeger expansion.

In one scheme, every logical Pauli operator to be measured is associated with a leaf in a branching tree of ancilla patches—each leaf augmented by an expander graph enforcing boundary checks with strong expansion up to weight $d$. This construction allows all branching and measurement checks to be scheduled in $O(d)$ rounds, independent of the number of logicals (for parallel measurement) and preserves the LDPC property (Cowtan et al., 6 Mar 2025). More generally, surgery can be parallelized for collections of commuting logical operators using either parallel pushout constructions or higher-form gauging, making use of multi-layer chain complexes and generalized symmetry constraints (Williamson, 30 Jan 2026).

Protocols leveraging higher-form transversal symmetry support $O(1)$-depth logical Clifford measurements by introducing ancilla qubits on higher-dimensional cells (hyperedges of the code's chain complex), performing "Gauss-law" checks transversally across the system, and projecting directly onto simultaneous eigenstates of the logical group (Williamson, 30 Jan 2026). The resource overhead is linear in system size, and the error suppression matches that of the constituent code up to a (typically small) expansion factor.

4. Universal Categorical and Homological Constructions

Fast code surgery finds its most general and rigorous formalization in the categorical language of chain complexes and (co)limits. Any CSS surgery protocol can be described as a pair of pushouts or coequalizers in the category of finite-dimensional chain complexes over $\mathbb{F}_2$, with explicit block-matrix formulas for updating stabilizer generators and logical operators (Cowtan et al., 2023, Cowtan, 2024, Poirson et al., 2 May 2025). This universal construction ensures that the merged code is itself a legitimate (possibly still LDPC) CSS code, with all required syndrome-extraction and measurement circuits determined by matrix entries. SSIP (Safe Surgery by Identifying Pushouts) is an explicit implementation automating these procedures for arbitrary CSS codes using hypergraph isomorphism, tensor-product ancillas, and efficient linear-algebraic routines (Cowtan, 2024).

In this framework, homological algebra allows computation of the logical effect of the surgery (maps on $H_1$ and $H^1$), tracking logical operator identification, elimination, and the preservation of commutation relations. This generalizes code-surgery protocols such as lattice-surgery CNOT, block reading, and error-protected logical measurement to arbitrary code families, with exact resource and distance quantification (Poirson et al., 2 May 2025).

5. Protocols and Resource Scaling

Below is a comparative table summarizing the characteristics of representative fast code surgery protocols:

Protocol/Class	Time Overhead	Extra Qubits / Ancillas	Fault Distance
Parallel gauging(Williamson, 30 Jan 2026)	$O(1)$	$O(n)$	$\phi d / 2$
Expander-based surgery(Cowtan et al., 6 Mar 2025)	$O(d)$	$O[t \omega (\log t+\log^3 \omega)]$	$d$
Total-complex (cone)(Baspin et al., 6 Oct 2025)	$O(1)$/$O(d)$	$O(n_a)$ (ancilla code size)	$\geq d, d_{Z}(D)/\omega$
Categorical pushout(Cowtan et al., 2023)	$O(d)$	$O(m)$, $m$=logical weight	$\geq d$
SSIP(Cowtan, 2024)	$O(1)$/$O(d)$	$r|\mathrm{supp}(u)|$	Verified via QDistRnd

Typical round counts are $d$ for protocols requiring repeated syndrome extraction for error detection, and $O(1)$ for those leveraging higher-form symmetries or sufficient expansion. SSA-based protocols (e.g., deformation-based surface code, color-code surgery) achieve time overheads matching or even beating defect-braiding or conventional lattice surgery, with reduced footprint or lower qubit overhead per logical qubit (Nagayama et al., 2016, Landahl et al., 2014).

6. Applications, Implementations, and Practicalities

Fast code surgery underlies high-performance fault-tolerant quantum computing workflows. Modern compilers for surface-code–based computation, such as the LLI-based toolchain, interpret gate-level circuits into logical lattice instructions parameterizing code surgery events, routing, and resource estimation (Watkins et al., 2023). These workflows enable both simulation and control software integration, maintaining high throughput and flexibility for large-scale compiled Clifford+T or magic-state circuits.

Implementations in open-source libraries (SSIP) automate pushout-based surgery for arbitrary CSS and LDPC codes, permitting both external and internal logical merges, and explicit verification of distance scaling on representative codes such as the Gross code. Significant resource savings are demonstrated by exploiting code structure and optimized chain-complex constructions, often reducing the ancilla overhead by orders of magnitude compared to earlier brute-force proposals (Cowtan, 2024).

Codes with higher-form symmetries enable extremely rapid and parallelizable preparation of magic states, crucial for universal computation and non-Clifford gate synthesis (Williamson, 30 Jan 2026), while temporally encoded surgery (using measurement codes to compress sequential Pauli-based computation) allows for substantial runtime reduction without multiplicative qubit overhead (Chamberland et al., 2021).

7. Limitations and Open Directions

While fast code surgery now achieves constant or near-constant time overhead for a wide array of code families, certain classes of codes (notably those lacking LDPC structure or higher-form symmetry) still face scaling limitations. Extending expansion-based and hypergraph-complex methods to codes with more general logical interdependencies or to non-CSS codes remains an active area. Quantitative trade-offs between ancilla footprint, decoder complexity, and circuit locality continue to shape practical design choices.

Further, protocols achieving $O(1)$ time generally rely on strong expansion or symmetry constraints, and the threshold behavior under realistic circuit-level noise remains an area of ongoing numerical and analytic evaluation. Generalizing these techniques to heterogeneously encoded architectures, hardware-constrained layouts, and dynamically routed reconfigurable code topologies also present fertile ground for future research (Baspin et al., 6 Oct 2025, Cowtan et al., 6 Mar 2025, Williamson, 30 Jan 2026).