Lattice Surgery for Quantum Error Correction: From Surface Codes to LDPC Codes and Beyond

Why Do We Need Lattice Surgery?

Let me start with a simple question: if I can protect a single logical qubit inside a surface code patch, how do I make two such logical qubits talk to each other?

In fault-tolerant quantum computing, every logical qubit lives inside its own error-correcting code block. For the surface code—arguably the most popular topological code—each logical qubit is encoded in a 2D patch of physical qubits arranged on a square lattice [1, 2]. The stabilizer measurements (those repeated \(X\)-type and \(Z\)-type parity checks) keep the quantum information safe from local noise. But here is the catch: to run any useful quantum algorithm, I need entangling gates between logical qubits, like the CNOT gate. And doing that without ruining my carefully constructed error protection is non-trivial.

The earliest approach was to use transversal gates, where you simply apply physical CNOTs between corresponding qubits of two code blocks. The problem? For the planar surface code, this requires long-range physical connections that break the beautiful nearest-neighbor 2D layout that makes the code so attractive for hardware in the first place [3].

Another approach was braiding of defects in the surface code [4]. While theoretically elegant, defect-based encodings require significantly more physical qubits per logical qubit.

Enter lattice surgery, introduced by Horsman, Fowler, Devitt, and Van Meter in 2012 [5]. The idea is beautifully simple: instead of moving information through the code, we reshape the code itself. We merge two patches into one larger patch and then split them apart again. During this process, we effectively measure a joint logical operator across both patches, which is the key primitive for implementing multi-qubit gates. And the best part? Everything stays on a 2D nearest-neighbor layout with manageable overhead.

Quick Recap: The Surface Code

Before diving into surgery, let me set the stage with a brief recap of the surface code. I will use the rotated surface code throughout this post, since it is more qubit-efficient and is the standard choice in modern architectures.

Stabilizers and Logical Operators

A distance-\(d\) rotated surface code encodes one logical qubit into \(d^2\) data qubits (plus \((d^2-1)\) syndrome qubits for measurement). The stabilizer generators come in two flavors:

• \(X\)-stabilizers (vertex operators): products of Pauli \(X\) on qubits surrounding a vertex.
• \(Z\)-stabilizers (face/plaquette operators): products of Pauli \(Z\) on qubits surrounding a face.

These stabilizers partition the boundaries of the patch into two types:

• \(X\)-boundaries (also called “smooth” or “primal”): where truncated \(X\)-stabilizers live. A chain of \(Z\) operators along this boundary is the logical \(\bar{Z}\) operator.
• \(Z\)-boundaries (also called “rough” or “dual”): where truncated \(Z\)-stabilizers live. A chain of \(X\) operators along this boundary is the logical \(\bar{X}\) operator.

The key insight is that the logical operators are topological: any connected path of \(Z\)’s (\(X\)’s) stretching between two \(X\)-boundaries (\(Z\)-boundaries) is an equivalent representative of \(\bar{Z}\) (\(\bar{X}\)). This topological equivalence is what makes the code robust—a local error cannot bridge both boundaries.

The \(\llbracket 4, 1, 2 \rrbracket\) Surface Code

The smallest non-trivial rotated surface code has distance \(d=2\). This is the \(\llbracket 4, 1, 2 \rrbracket\) code, consisting of just 4 data qubits. Despite its tiny size (it can only detect but not correct single-qubit errors), it serves as a perfect pedagogical example for understanding lattice surgery.

The \(\llbracket 4, 1, 2 \rrbracket\) rotated surface code has the following structure. Label the 4 data qubits as \(q_1, q_2, q_3, q_4\) arranged in a \(2\times 2\) grid. The stabilizer generators are:

With \(n=4\) qubits and \(m=3\) independent stabilizer generators, we encode \(k = n - m = 1\) logical qubit. The logical operators are:

You can verify that \(\bar{X}\) and \(\bar{Z}\) each commute with all stabilizers but anti-commute with each other: \(\bar{X}\bar{Z} = -\bar{Z}\bar{X}\), as required for a pair of conjugate logical operators. The code distance is \(d=2\), since the lightest non-trivial logical operator has weight 2.

The Two Primitives: Merge and Split

Lattice surgery boils down to two operations: merging and splitting surface code patches. Together, they implement a projective measurement of a joint logical Pauli operator across two patches. Let me describe each in turn.

Lattice Merging

Suppose I have two surface code patches, Patch A and Patch B, sitting next to each other with their \(X\)-boundaries facing. Between them lies a row of “bridge” qubits that are currently idle.

To measure \(X_L^{(A)} \otimes X_L^{(B)}\), the merge proceeds as follows:

1. Initialize bridge qubits in the \(\ket{0}\) state.
2. Extend the stabilizer measurements: start measuring both the \(X\)-stabilizers and \(Z\)-stabilizers that span the bridge region, effectively treating all three regions (Patch A, bridge, Patch B) as one big surface code patch.
3. Read out the joint logical measurement: the product of all the new \(X\)-stabilizer outcomes across the bridge region gives the eigenvalue of \(X_L^{(A)} \otimes X_L^{(B)}\).
4. Repeat for \(d\) rounds of syndrome extraction to ensure fault tolerance.

After the merge, the two patches have fused into a single, larger patch encoding one logical qubit (instead of two). The measurement outcome \(m \in \{+1, -1\}\) tells us the parity \(X_L^{(A)} \otimes X_L^{(B)}\).

Lattice Splitting

To undo the merge and restore two independent patches, we perform a split:

1. Measure the bridge qubits in the \(Z\) basis.
2. Retract the stabilizer measurements: stop measuring stabilizers that span the bridge region, so the two patches become independent again.
3. Track the Pauli frame: the outcomes of the \(Z\)-measurements on the bridge qubits may introduce a correction to one of the logical \(Z\) operators.

The net effect of a merge followed by a split is a projective measurement of \(X_L^{(A)} \otimes X_L^{(B)}\) (or \(Z_L^{(A)} \otimes Z_L^{(B)}\) if we merge along the \(Z\)-boundaries instead, initializing in \(\ket{+}\) and measuring in \(X\) to split) [5, 6].

Why This Is Enough for Universal Computation

Here is the punchline: if I can measure arbitrary Pauli product operators like \(X_L \otimes Z_L\), \(Z_L \otimes Z_L\), \(X_L \otimes X_L\), etc., then I can implement the full Clifford group via Pauli-based computation [6]. Add magic state injection and distillation for the \(T\)-gate, and I have a universal gate set. Lattice surgery provides exactly these Pauli product measurements through appropriate combinations of merges, splits, and patch rotations.

Worked Example: A Logical Bell Pair from Two \(\llbracket 4,1,2 \rrbracket\) Patches

Now let me walk through a concrete, minimal example. I will show how to create a logical Bell state:

between two \(\llbracket 4,1,2 \rrbracket\) surface code patches using lattice surgery.

Setup: Two Patches Side by Side

Consider two \(\llbracket 4,1,2 \rrbracket\) patches, which I will call Patch A (qubits \(a_1, a_2, a_3, a_4\)) and Patch B (qubits \(b_1, b_2, b_3, b_4\)). I arrange them so that the \(X\)-boundary of Patch A faces the \(X\)-boundary of Patch B, with two bridge qubits \(m_1, m_2\) in between.

Step 1: Initialize Both Patches in \(\ket{+_L}\)

I start by preparing both patches in the logical \(\ket{+_L}\) state, i.e., the \(+1\) eigenstate of \(\bar{X}\). This can be done by initializing all data qubits in \(\ket{+}\) and then performing a round of stabilizer measurements to project into the code space. After this step:

Step 2: Merge to Measure \(Z_L^{(A)} \otimes Z_L^{(B)}\)

To create a Bell pair, I need to measure \(Z_L^{(A)} \otimes Z_L^{(B)}\) without disturbing the \(X_L\) eigenvalues. Recall that for the \(\llbracket 4,1,2 \rrbracket\) code:

I perform a merge along the boundaries where the \(Z_L\) operators terminate (the \(X\)-boundaries). The procedure is:

1. Initialize bridge qubits: \(m_1, m_2 \to \ket{+}\).
2. Measure new \(Z\)-stabilizers across the bridge:
   \[\begin{align} S_{\text{bridge}}^{Z} &= Z_{a_2}\, Z_{m_1}\, Z_{b_1}, \\ S_{\text{bridge}}^{Z'} &= Z_{a_4}\, Z_{m_2}\, Z_{b_3}. \end{align}\]
   Also measure the new \(X\)-stabilizer spanning the bridge:
   \[S_{\text{bridge}}^{X} = X_{a_2}\, X_{a_4}\, X_{m_1}\, X_{m_2}\, X_{b_1}\, X_{b_3}.\]
3. Read the measurement outcome: The product of all \(Z\)-type stabilizer outcomes across the merged region gives us the eigenvalue of \(Z_L^{(A)} \otimes Z_L^{(B)}\).

In the merged code, the product of the original \(Z_L\) operators and the bridge \(Z\)-stabilizers yields:

The bridge stabilizers effectively “connect” the two \(Z_L\) strings through the bridge region. The measurement outcome \(m_{ZZ} \in \{+1, -1\}\) is recorded.

Step 3: Split to Restore Two Patches

After obtaining the \(Z_L \otimes Z_L\) measurement, I split the merged patch:

1. Measure \(m_1\) and \(m_2\) in the \(X\) basis.
2. Stop measuring the bridge stabilizers.
3. Update the Pauli frame: if the \(X\)-measurement outcomes on \(m_1\) or \(m_2\) indicate a sign flip, apply a software correction to \(Z_L^{(A)}\) or \(Z_L^{(B)}\).

Result: A Logical Bell Pair

After the merge-and-split, the state is:

If we get \(m_{ZZ} = -1\), we can apply a logical \(Z\) correction (tracked in software) to convert \(\ket{\Phi^-}_L\) to \(\ket{\Phi^+}_L\). Either way, we have created a logical Bell pair!

This is the essence of lattice surgery: a measurement-based entangling operation implemented through code deformation. No transversal gates, no long-range physical connections—just local stabilizer measurements on an extended patch.

Summary of the merge-and-split protocol for the \(\llbracket 4,1,2 \rrbracket\) Bell pair.

Step	Operation	Effect
1	Initialize both patches in \(\ket{+_L}\)	\(\ket{+_L}_A \ket{+_L}_B\)
2a	Init bridge qubits in \(\ket{+}\)	Prepare for \(ZZ\) merge
2b	Measure bridge stabilizers (\(d\) rounds)	Measures \(Z_L^{(A)} Z_L^{(B)} = m_{ZZ}\)
3	Measure bridge qubits in \(X\); split	Restore two patches
4	Pauli frame update (if \(m_{ZZ}=-1\))	\(\ket{\Phi^+}_L\)

Generalized Lattice Surgery for LDPC Codes

Now comes the exciting part. The surface code is great, but it has a fundamental limitation: it encodes only one logical qubit per patch, and its encoding rate \(k/n\) vanishes as the distance grows (\(k/n \sim 1/d^2\)). The Bravyi–Poulin–Terhal (BPT) bound tells us this is unavoidable for any code with geometrically local checks in 2D [7].

Quantum low-density parity-check (LDPC) codes break free from this constraint by relaxing geometric locality while keeping the check weights bounded. Codes like the hypergraph product codes [8] and bivariate bicycle codes [9] can encode many logical qubits (\(k = \Theta(n)\)) with good distance, using far fewer physical qubits than the surface code for the same level of protection.

But how do we perform surgery on these non-planar codes? The elegant geometric picture of merging two adjacent patches does not directly apply when the code is defined on a complex, non-local Tanner graph. This is where generalized lattice surgery comes in.

The CKBB Scheme: The Foundational Idea

The generalization of lattice surgery to arbitrary LDPC codes was pioneered by Cohen, Kim, Bartlett, and Brown (CKBB) in 2022 [10]. The core idea can be summarized as follows.

Suppose I want to measure a logical operator \(\bar{X}\) of a CSS code \(\mathcal{C}\) with parameters \(\llbracket n, k, d \rrbracket\). The high-level procedure is:

1. Identify the logical subgraph: Find the qubits \(V_0\) supporting \(\bar{X}\) and the \(Z\)-checks \(C_0\) neighboring \(V_0\) in the Tanner graph. This defines a subgraph \(G_{\bar{X}} = (V_0, C_0, E_0)\).
2. Build a dual subgraph: Construct \(G_{\bar{X}}^T\) by swapping the roles of variable and check nodes (variables become checks and vice versa).
3. Create the ancilla system: Stack \(r\) copies of the dual graph \(G_{\bar{X}}^T\) interleaved with \((r-1)\) copies of the primal graph \(G_{\bar{X}}\), connected layer-by-layer via identity maps. This gives us \(\mathcal{G}_{\text{anc}}\).
4. Merge: Initialize the ancilla qubits in \(\ket{0}\), then measure the stabilizers of the merged code \(\mathcal{C}_{\text{merged}}\) for \(d\) rounds. The product of all \(X\)-check outcomes in the ancilla gives \(\bar{X}\).
5. Split: Measure ancilla qubits in the \(Z\) basis and return to the original code.

The beauty of this construction is that the ancilla system is essentially the hypergraph product of \(G_{\bar{X}}\) with a repetition code of length \(r\) [10]. With \(r \geq 2d - 1\) layers, the merged code provably maintains distance \(\geq d\).

However, there is a cost: the ancilla system requires \(O(d^2)\) qubits, which for codes where \(d \sim \sqrt{n}\) means the ancilla can be larger than the code itself!

Gauge-Fixed Surgery: Reducing the Overhead

This overhead problem was dramatically improved by Cross, He, Rall, and Yoder in their 2024 work on gauge-fixed QLDPC surgery [11]. The key insight is that many layers of the CKBB construction introduce gauge qubits—degrees of freedom that carry no logical information. By “gauge-fixing” (promoting gauge operators to stabilizers), they reduce the number of required layers from \(O(d)\) to as few as \(\Theta(1)\) when the Tanner graph of the logical operator has good expansion properties.

For a logical operator of weight \(w\), the gauge-fixed ancilla requires only \(\Theta(w)\) qubits in the best case. This is a massive improvement!

The gauge-fixing procedure works as follows:

1. Compute the null space of the adjacency matrix \(F\) of the logical subgraph: find \(G\) such that \(GF = 0\).
2. Add new \(Z\)-checks \(G: U_L \to_Z C_L\) to the final layer, converting gauge qubits into stabilizer qubits.
3. The resulting merged code is a proper stabilizer code (no gauge degrees of freedom) with distance \(\geq d\).

Bridging Codes: Connecting Different Code Blocks

A crucial extension is the ability to measure joint logical operators across two different code blocks—possibly from entirely different code families! Cross et al. [11] introduced bridge qubits that connect two separate ancilla systems. This “code adapter” enables:

• Joint \(XX\) or \(ZZ\) measurements between two LDPC code blocks.
• Interfacing between surface codes and LDPC codes (useful for hybrid architectures).
• Measurements across bivariate bicycle codes and other exotic codes.

The bridge is constructed by introducing auxiliary qubits \(a[k]\) and \(Z\)-checks \(z[j]\) that link the boundary layers of two ancilla systems. With \(d\) rounds of syndrome extraction, the fault distance of the bridge construction is also \(\geq d\).

Lattice Surgery on Bivariate Bicycle Codes

Let me now focus on one of the most exciting code families in recent quantum error correction: the bivariate bicycle (BB) codes, introduced by Bravyi, Cross, Gambetta, Maslov, Rall, and Yoder in 2024 [9].

What Are Bivariate Bicycle Codes?

BB codes are quantum LDPC codes defined over the polynomial ring \(\mathbb{F}_2[x,y]/(x^\ell - 1, y^m - 1)\), corresponding to the group algebra of \(\mathbb{Z}_\ell \times \mathbb{Z}_m\). A BB code is specified by two polynomials:

The parity check matrices are constructed as:

where \(a\) and \(b\) are interpreted as \(\ell m \times \ell m\) circulant matrices (via the polynomial-to-circulant correspondence). The code has \(n = 2\ell m\) physical qubits, and each stabilizer generator has constant weight (typically 6 or 8) [9, 15].

The star of the show is the \(\llbracket 144, 12, 12 \rrbracket\) gross code (\(\ell = 12, m = 6\)), which encodes 12 logical qubits into only 144 data qubits at distance 12. For comparison, encoding 12 logical qubits at distance 12 with surface codes would require \(12 \times (12^2 + 11^2) = 3{,}420\) data qubits—roughly 24 times more [9, 11].

The Challenge: Surgery on Non-Planar Codes

The BB codes have a significant complication for surgery: they are not geometrically local in 2D. Their Tanner graph has degree 6 (each qubit participates in 6 stabilizers), and the connectivity is non-planar [13]. This means we cannot simply “place two patches next to each other” and merge along a shared boundary, as we do with surface codes.

Instead, we must use the generalized lattice surgery framework described above. The procedure for measuring a logical operator of a BB code proceeds through the same abstract steps:

1. Identify the support \(V_0\) of the target logical operator \(\bar{X}_i\) and its neighboring \(Z\)-checks \(C_0\).
2. Build the gauge-fixed ancilla system on the induced Tanner subgraph.
3. Merge, measure for \(d\) rounds, and split.

Surgery on the \(\llbracket 144, 12, 12 \rrbracket\) Gross Code

Cross et al. [11] demonstrated a remarkably efficient surgery scheme for the gross code:

• A single-layer (mono-layer, \(L=1\)) gauge-fixed ancilla system with only 103 additional qubits suffices to fault-tolerantly measure eight distinct logical Pauli operators.
• The maximum qubit degree in the merged code is 8 (only 2 qubits hit this maximum; the rest have degree \(\leq 7\)).
• With 7 rounds of merged-code syndrome extraction at physical error rate \(p = 0.001\), the logical measurement error rate is approximately \(10\times\) lower than the logical error rate.
• By combining these measurements with the code’s automorphism group (permutation symmetries that map the code to itself), they implement a total of 288 native Pauli measurements on the 12 logical qubits, which generate the 11-qubit Clifford group (with one logical qubit used as an ancilla for gate synthesis).

Comparison of surgery schemes for the \(\llbracket 144, 12, 12 \rrbracket\) gross code.

	CKBB [10]	Cowtan [12]	Gauge-fixed [11]
Ancilla qubits	1,380	180	103
Number of layers	23	5	1
Max qubit degree	7	7	8
Measurement set size	2	2	8

How Would Surgery Work Between Two BB Code Blocks?

Now, suppose I have two gross code blocks, each encoding 12 logical qubits, and I want to measure a joint logical operator like \(\bar{X}_i^{(1)} \otimes \bar{X}_j^{(2)}\) across the two blocks. This is where the bridging code construction becomes essential.

The procedure is:

1. Build two ancilla systems: For block 1, construct the gauge-fixed ancilla for \(\bar{X}_i^{(1)}\) with induced subgraph \(G_1 = (V_0^{(1)}, C_0^{(1)})\). For block 2, construct the ancilla for \(\bar{X}_j^{(2)}\) with induced subgraph \(G_2 = (V_0^{(2)}, C_0^{(2)})\).
2. Connect via bridge: Introduce bridge qubits \(\{a[k]\}\) and bridge \(Z\)-checks \(\{z[j]\}\) that link one \(X\)-check from the boundary of Ancilla 1 to one \(X\)-check from the boundary of Ancilla 2. This ensures that the product of all boundary \(X\)-checks from both ancillas gives \(\bar{X}_i^{(1)} \otimes \bar{X}_j^{(2)}\), but neither individual logical alone.
3. Merge and measure: Initialize all ancilla and bridge qubits appropriately, then measure the merged code stabilizers for \(d\) rounds.
4. Split: Measure ancilla/bridge qubits and return to the two original code blocks.

The bridge construction guarantees a fault distance of \(\min(d_1, d_2)\), where \(d_1\) and \(d_2\) are the distances of the two code blocks [11]. For two \(\llbracket 144, 12, 12 \rrbracket\) blocks, this gives a fault distance of 12.

An important subtlety with BB codes is that the logical operators are themselves non-local (supported on \(O(d)\) qubits scattered across the block, not arranged in a line). This makes the construction of the ancilla system more involved than for surface codes, but the algebraic framework handles it seamlessly. The expansion properties of the BB code’s Tanner graph (which are generally good due to its algebraic structure) help keep the ancilla size manageable.

Recent and Ongoing Developments

The field is moving fast. Let me highlight a few recent directions:

• Morphing circuits: Shaw and Terhal [13] showed how to perform logical input/output between BB codes and surface codes using “morphing” circuits, effectively performing a form of lattice surgery between different code families within a biplanar layout.
• Fast surgery: Work on performing surgery in a constant number of syndrome extraction rounds (rather than \(O(d)\) rounds) has appeared [16], using the total complex of the base code and a suitably chosen homomorphic chain complex.
• Universal generalized lattice surgery: The “gauging logical operators” approach [17] introduces a primitive for arbitrary logical Pauli measurements within and between code blocks, preparing logical magic states, and performing universal fault-tolerant computation on a fixed-connectivity architecture.
• Self-dual BB codes: Liang and Chen [15] introduced self-dual BB codes that support transversal CNOT, Hadamard, and \(S\) gates, potentially reducing the need for surgery altogether for certain gate sets.

The Big Picture: Why Lattice Surgery Matters

Let me step back and reflect on why lattice surgery is so central to the future of quantum computing.

1. It keeps things local: For surface codes, surgery preserves the 2D nearest-neighbor layout. For LDPC codes, it adds only a bounded number of connections (degree increase \(\leq 3\)).
2. It is modular: Each code block is an independent error-correcting unit. Surgery “plugs in” an ancilla, measures a logical, and “unplugs.” The code block’s protection is maintained throughout.
3. It scales: From the \(\llbracket 4,1,2 \rrbracket\) toy example to the \(\llbracket 144,12,12 \rrbracket\) gross code, the same principles apply. The generalization to LDPC codes means that as we build better codes, we can perform surgery on them too.
4. It is universal: Combined with magic state distillation, lattice surgery provides a complete set of fault-tolerant operations for universal quantum computation.

The transition from surface-code lattice surgery to generalized LDPC surgery represents one of the most important developments in fault-tolerant quantum computing in recent years. As hardware improves and we gain access to non-planar qubit connectivity (through reconfigurable atom arrays, modular superconducting architectures, or photonic networks), LDPC codes with generalized surgery will become the backbone of practical, large-scale quantum computers.

I hope this post gave you a clear sense of how lattice surgery works, from the simplest possible example to the cutting edge of the field. If you are interested in diving deeper, I highly recommend the references below as starting points. Happy coding!

References

1. A. Y. Kitaev, “Quantum computations: algorithms and error correction,” Russian Mathematical Surveys, vol. 52, no. 6, pp. 1191–1249, 1997.
2. S. B. Bravyi and A. Y. Kitaev, “Quantum codes on a lattice with boundary,” arXiv:quant-ph/9811052, 1998.
3. A. G. Fowler, M. Mariantoni, J. M. Martinis, and A. N. Cleland, “Surface codes: Towards practical large-scale quantum computation,” Phys. Rev. A, vol. 86, p. 032324, 2012. arXiv:1208.0928.
4. R. Raussendorf, J. Harrington, and K. Goyal, “Topological fault-tolerance in cluster state quantum computation,” New J. Phys., vol. 9, p. 199, 2007. arXiv:quant-ph/0703143.
5. D. Horsman, A. G. Fowler, S. Devitt, and R. Van Meter, “Surface code quantum computing by lattice surgery,” New J. Phys., vol. 14, p. 123011, 2012. arXiv:1111.4022.
6. D. Litinski, “A game of surface codes: Large-scale quantum computing with lattice surgery,” Quantum, vol. 3, p. 128, 2019. arXiv:1808.02892.
7. S. Bravyi, D. Poulin, and B. Terhal, “Tradeoffs for reliable quantum information storage in 2D systems,” Phys. Rev. Lett., vol. 104, p. 050503, 2010. arXiv:0909.4673.
8. J.-P. Tillich and G. Zémor, “Quantum LDPC codes with positive rate and minimum distance proportional to the square root of the blocklength,” IEEE Trans. Inf. Theory, vol. 60, no. 2, pp. 1193–1202, 2014. arXiv:0903.0566.
9. S. Bravyi, A. W. Cross, J. M. Gambetta, D. Maslov, P. Rall, and T. J. Yoder, “High-threshold and low-overhead fault-tolerant quantum memory,” Nature, vol. 627, pp. 778–782, 2024. arXiv:2308.07915.
10. L. Z. Cohen, I. H. Kim, S. D. Bartlett, and B. J. Brown, “Low-overhead fault-tolerant quantum computing using long-range connectivity,” Science Advances, vol. 8, p. eabn1717, 2022. arXiv:2110.10794.
11. A. W. Cross, Z. He, P. Rall, and T. J. Yoder, “Improved QLDPC surgery: Logical measurements and bridging codes,” arXiv:2407.18393, 2024.
12. A. Cowtan, “CSS code surgery as a universal construction,” Quantum, vol. 8, p. 1344, 2024.
13. M. H. Shaw and B. M. Terhal, “Lowering connectivity requirements for bivariate bicycle codes using morphing circuits,” Phys. Rev. Lett., vol. 134, p. 090602, 2025. arXiv:2407.16336.
14. A. Chatterjee, S. Das, and S. Ghosh, “Lattice surgery for dummies,” Sensors, vol. 25, no. 6, p. 1854, 2025. arXiv:2404.13202.
15. Z. Liang and Y.-A. Chen, “Self-dual bivariate bicycle codes with transversal Clifford gates,” arXiv:2510.05211, 2025.
16. “Fast surgery for quantum LDPC codes,” arXiv:2510.04521, 2025.
17. “Universal generalized lattice surgery by gauging logical operators,” 2025.
18. “Lattice surgery realized on two distance-three repetition codes,” Nature Physics, 2026.
19. K. Kottmann, “Introducing lattice surgery,” PennyLane Demos, December 2025.
20. N. de Beaudrap and D. Horsman, “The ZX calculus is a language for surface code lattice surgery,” Quantum, vol. 4, p. 218, 2020. arXiv:1704.08670.