PaperlayerView exact revision on arXiv

Source-linked AI summary

Constant-Time Surgery on 2D Hypergraph Product Codes with Near-Constant Space Overhead

Kathleen Chang, Zhiyang He, Theodore J. Yoder, Guanyu Zhu, Tomas Jochym-O'Connor

arXiv:2603.02157v1quant-ph

TL;DR

Fault-tolerant computation on qLDPC codes seeks lower space and time overhead, but generic surgery requires O(d) noisy measurement rounds. This work constructs constant-time surgery gadgets for 2D hypergraph product codes, with flexible parallel logical measurements and near-constant spacetime overhead; the protocol has fault distance d under stated conditions.

  • Problem

    Generic surgery requires O(d) rounds of measurement in the presence of noise, motivating methods that reduce this time overhead while retaining fault tolerance.

  • Method

    The work constructs constant-time surgery gadgets for arbitrary 2D hypergraph product codes that enable flexible, parallel logical Pauli measurements using O~(n) ancilla qubits per gadget.

  • Results

    The surgery protocol has fault distance d when the stated conditions on the surgery operations and chain maps hold.

  • Takeaways & Limitations

    The gadgets combine flexible logical measurements with near-constant spacetime overhead, which the authors expect to be a small constant in practice.

  • Takeaways & Limitations

    The gadgets face an alignment issue: X-basis measurements act on columns of logical qubits while Z-basis measurements act on rows, preventing direct batching of both bases in the same encoding.

Abstract

from arXiv · show

Generalized code surgery is a versatile and low-overhead technique for performing fault-tolerant computation on quantum low-density parity-check (qLDPC) codes. In many settings, surgery exhibits practical space overheads, while its time overhead remains a bottleneck at $O(d)$ syndrome rounds per operation. In this work, we construct surgery gadgets that perform parallel logical measurements on 2D hypergraph product codes in constant time overhead ($O(1)$) and near-constant space overhead ($\tilde{O}(1)$). The reduced time overhead is a result of amortization, as we show, following the formulation by Cowtan et al. (arXiv:2510.14895), that performing $d$ surgery operations in $O(d)$ time is fault tolerant. Our gadgets combine the strengths of different approaches to fault-tolerant logical operations: they partially retain the flexibility of surgery while achieving overheads comparable to transversal gates. Consequently, they are well-suited for near-term experimental realization and demonstrate new possibilities in the design of gadgets for fast logical computation.

I. INTRODUCTION

Code surgery enables fault-tolerant logical Pauli measurements on qLDPC codes, but conventional protocols require O(d) syndrome rounds per operation. This work introduces constant-time surgery for arbitrary 2D HGP codes by amortizing t ≥ d measurements across O(t) rounds while retaining flexible parallel logical measurements.

  • qLDPC codes can reduce the space overhead of fault-tolerant quantum memory, motivating low-overhead methods for logical computation.
  • Code surgery measures logical Pauli operators and supports universal Pauli-based computation with magic-state assistance.
  • O(d) syndrome rounds are normally required to infer stabilizer values reliably under noise, creating the central time-overhead bottleneck.
  • The gadgets apply to arbitrary 2D HGP codes, support flexible parallel logical Pauli measurements, and use ˜O(n) ancilla qubits per gadget with multiplicative spacetime overhead ˜O(1).
  • Unlike higher-dimensional HGP codes, generic 2D HGP codes lack redundant checks for single-shot preparation, yet the construction retains surgery’s addressability at roughly transversal-gate asymptotic cost.
  • Formulations of Fast Code Surgery: Single-shot surgery uses one round around deformation but is limited to codes with single-shot state preparation; otherwise ancilla removal can induce an uncorrectable frame error.
  • Formulations of Fast Code Surgery: Constant-time surgery performs t ≥ O(d) operations in O(t) rounds, with O(1) rounds per operation amortized between O(d) base-code syndrome rounds.
  • Overview of Construction: The construction attaches ancilla gadgets to a classical factor, forms cone(g) ⊗ D, and sequences different cones to measure corresponding logical operators in parallel.

B. CSS Code Surgery as Mapping Cones

Code surgery attaches an ancilla system to a CSS code and uses a mapping cone to create a deformed code whose stabilizers reveal logical measurements. The construction preserves distance, avoids new logical qubits, controls check weights, and bounds ancilla overhead.

  • Mapping-cone construction: Code surgery attaches an ancilla system and chain map to a CSS code, then forms a mapping cone as the deformed code.The cone is itself a CSS code whose vector spaces organize Z-checks, qubits, and X-checks.
  • Logical measurement: The ancilla is designed so a target logical operator becomes a product of newly introduced stabilizers in the deformed code.Repeated measurement of those deformed checks lets the logical measurement be inferred.
  • Overhead and fault tolerance: The deformed code has X- and Z-distances at least those of the base code, supporting fault distance d for the code-switching protocol.Fault distance counts the minimum physical-qubit and stabilizer-measurement errors that corrupt logical information undetected.
  • Overhead and fault tolerance: The construction has no ancilla logical qubits, constant-bounded check-map sparsity, and ancilla size O(|L| log^3(|L|)).These properties respectively prevent extra gauge logicals, control stabilizer weights, and bound space overhead.
  • Extensions: The framework can also support mixed-type logical Pauli measurements and parallel measurements of multiple commuting operators.The broader gauging-measurement formulation applies beyond CSS codes, while prior surgery work studies parallel measurements.

C. Fast Code Surgery

Fast surgery amortizes syndrome extraction across a sequence of operations and analyzes all attached ancillas through a compacted code. Under distance, meta-check, and support-disjointness conditions, the protocol achieves fault distance d.

  • Meta-check structure: Meta-checks are represented as an additional chain-complex term and can be incorporated into a four-term deformed code.The resulting spaces assign meta-checks, Z-checks, qubits, and X-checks to A2, A1 ⊕ C2, A0 ⊕ C1, and A−1 ⊕ C0.
  • Amortized protocol: Fast surgery performs a sequence of operations in O(d) time rather than repeating O(d) rounds for each individual operation.The protocol uses buffered syndrome information across the sequence, so a single operation need not be fault tolerant in isolation.
  • Compacted-code analysis: The compacted code is the mapping cone formed by attaching all ancilla systems to the base code simultaneously as a proof construct.It need not be explicitly built during the surgery protocol.
  • Fault-tolerance conditions: Fault distance d follows when the compacted code and each ancilla have the required systolic or cosystolic distances and ancilla supports are disjoint.These conditions respectively control space-like errors, time-like measurement errors, and error propagation.

D. Hypergraph Product Codes

A hypergraph product code is built by tensoring two classical-code chain complexes into a CSS code. Its logical structure, physical size, and distance follow from the component complexes and their homology.

  • Construction: Hypergraph product codes are CSS codes obtained by tensoring two length-1 classical-code chain complexes.The resulting code has Z-checks, qubits, and X-checks in C1 ⊗ D1, (C1 ⊗ D0) ⊕ (C0 ⊗ D1), and C0 ⊗ D0.
  • Chain-complex structure: The tensor-product boundary map combines the component boundaries on each tensor factor, with the sign simplified over F2.Each term lands in the corresponding graded subspace of the tensor-product complex.
  • Homology and logicals: The Künneth formula relates the homology of the product complex to tensor products of the component homology spaces.This relationship supports analysis of the product code’s logical operators.
  • Code parameters: The hypergraph product has n = nC mD + mC nD physical qubits, k = kC kD⊤ + kC⊤ kD logical qubits, and d = min(dC, dD, dC⊤, dD⊤).These parameters are determined by the classical codes and their transpose codes.
  • Homology and logicals: Canonical logical representatives have row-and-column support patterns on the two physical-qubit grids.Restricted grids can arrange logical representatives so each physical qubit belongs to a single canonical logical pair.

III. CONSTANT SPACETIME SURGERY ON HYPERGRAPH PRODUCT CODES

The construction tensors single-operator surgery complexes with an untouched classical complex, producing parallel row and column measurements on 2D hypergraph product codes. Its logical action follows from homology, while direct addressability through modified complexes remains open.

  • Parallel logical measurements: The gadget (G[i] ⊗ D)• measures a row of Z logical operators in parallel, each formed from canonical Z basis operators.Tensoring a surgery complex for C• with D• simultaneously measures operators ci ⊗ h for h ∈ H0(D•).
  • Parallel logical measurements: Tensoring surgery systems for D• with C• analogously produces parallel column measurements.Rows arise from modifying the C factor; columns arise from modifying the D factor.
  • Construction: The ancilla sequence is A[i]• = (G[i] ⊗ D)•, with chain-map validity inherited from g[i] and the identity on D.The tensor-product construction preserves the required chain-map structure.
  • Logical action: The cone removes the selected class ci from H1 while preserving H0, establishing the homological effect of each surgery operation.The result is H1(cone(g[i])) ∼= H1(C•)/{ci} and H0(cone(g[i])) ∼= H0(C•).
  • Logical action: For each selected ci, the deformed code places the logical classes {ci} ⊗ H0(D•) in the image of the cone boundary, making them products of new Z-stabilizers.This is the homological reason the corresponding logical operators are measured simultaneously.
  • Scope and limitation: Addressable fast surgery using a modified D′ is left for future work because the central tensor-product lemma no longer applies and new proofs are required.Puncturing or augmenting D• is suggested as a possible route.
  • Relation to prior work: Unlike related homomorphic-measurement gadgets, the construction ensures that the compacted code retains high distance, enabling constant-time surgery.The related compacted code can have distance lower than d in general.

C. Compacted Code Distance

The compacted code is constructed as a mapping cone combining ancillary complexes and chain maps across t sequential fast measurements. Its 1-systolic and 1-cosystolic distances are both at least d.

  • Construction: The compacted code is defined as the mapping cone of the sum of extended chain maps over t surgeries.The construction acts nontrivially on each ancillary complex A[i] through its corresponding map f[i].
  • Construction: The mapping-cone construction factors as CC• = cone(¯g ⊗ idD) = (cone(¯g) ⊗ D)•.This factorization reduces the distance analysis to the complexes cone(¯g) and D.
  • Distance bounds: d0(cone(¯g)) ≥ d.The proof uses the vanishing of H0 for the ancillary complexes and the base-code distance condition.
  • Distance bounds: d1(cone(¯g)) ≥ d, while also d1(cone(¯g)) ≥ 1.An expansion argument shows that adding support from the extended boundary cannot reduce the weight of a logical operator below d.
  • Distance bounds: The compacted code has 1-systolic and 1-cosystolic distances at least d.Applying the distance composition formulas gives lower bounds min(1 × d, d × 1) = d for both quantities.

D. Meta-check Distance

The paper establishes fast surgery on 2D hypergraph product codes through ancillary complexes with strong distance properties, enabling parallel logical measurements with constant amortized time and near-constant spacetime overhead.

  • Main result: O(1) amortized time and ˜O(n) ancilla qubits per complex yield ˜O(1) overall spacetime overhead.Theorem 1 applies the ancillary complexes to parallel measurements of rows or columns of logical Pauli operators.
  • Applications: The gadgets can measure rows or columns of logical operators in parallel, and can entangle logical qubits across non-identical HGP codes sharing a classical component.The latter extension uses a modular one-dimensional surgery system and a shared base code constraint.
  • Construction: The construction lifts one-dimensional surgery ancillas into two-dimensional systems through the homological product.This recipe is presented as broadly applicable and extensible to other surgery gadgets.
  • Limitations: Parallel measurements of several codewords remain an open direction because constructing low-space-overhead hypergraphs for them is unresolved.The current construction is restricted to one logical operator or codeword in each one-dimensional surgery gadget.
  • Extensions: The gadgets generalize to higher-dimensional homological product and hypergraph product codes, where they can measure lines or planes of logical operators.The three-code hypergraph product is described as an example of the higher-dimensional extension.

V. INTUITIVE EXAMPLE: CONSTANT SPACETIME OVERHEAD AND ADDRESSABLE TORIC CODE MEASUREMENTS

The toric-code example measures a selected logical operator by adding ancilla checks whose products realize its representatives, while meta-checks detect measurement errors. This construction achieves constant spacetime overhead and preserves distance while supporting parallel, addressable measurements.

  • Logical measurement: The gadget measures the logical Z̄1 by adding ancilla checks whose product equals each minimum-weight Z̄1 representative.The added checks lie in G[i]1 ⊗ D0, while ancilla and base-code qubits occupy distinct chain-complex spaces.
  • Fault tolerance: Horizontal checks in G[i]0 ⊗ D1 couple ancilla and base-code qubits, producing constant-sized meta-checks that detect individual check-measurement errors.Without these checks, parallel representative measurements would accumulate errors and yield only a pseudo-threshold asymptotically.
  • Logical measurement: Z̄2 remains in the filled torus’s homology, so the deformation measures Z̄1 without measuring Z̄2.The construction therefore targets a selected logical operator rather than all logical operators supported by the base code.
  • Fault tolerance: A single check error flips adjacent meta-checks, while an undetected logical-measurement error requires a string extending around the decoding graph.The meta-check matrix is M_Z = (id_G ⊗ ∂_D) ⊕ (∂_G[i],1 ⊗ id_D).
  • Overhead and addressability: The ancilla system has O(d^2) space overhead, matching the O(d^2) space of the base toric code.Thus the space overhead is constant relative to the base code, and the example gives asymptotically constant space-time overhead per logical measurement.
  • Overhead and addressability: The construction measures logical operators along rows or columns in parallel by taking a hypergraph product of a measurement graph with an original classical code.This provides addressable and parallel logical measurements for hypergraph product codes.

Appendix A: Omitted Proofs From Constant-Time Surgery on HGP Codes

The appendix establishes algebraic identities for mapping cones and homological products, then uses them to prove distance lower bounds for coned codes. The proof tracks how logical chains deform under added ancilla complexes.

  • Chain-complex identities: The boundary map of cone(f) ⊗ D equals the boundary map obtained from cone(f ⊗ id_D), making the two complexes isomorphic.Both evaluations produce the same graded-vector-space map after expanding the mapping-cone and homological-product boundaries.
  • Distance proof: Proposition 4 establishes d1(cone(ḡ)) ≥ d for the coned complex under the stated ancillary-complex conditions.The proof analyzes deformations of logical chains by elements of the newly added G[i]1 spaces.
  • Distance proof: The distance argument uses expansion of ∂G[i],1, sparsity of g[i]1, and lower bounds on the weight of resulting logical operators.The proof combines boundary-weight cases, triangle inequalities, and the fact that nontrivial logicals of the base code have weight at least d.
  • Distance proof: The appendix concludes that d1(cone(ḡ)) ≥ d after combining the intermediate inequalities.This is the claimed distance preservation for the coned construction.

1. Relaxation to Relative Expansion

The appendix relaxes ordinary expansion requirements by using relative expansion of the ancillary complexes. Under this weaker condition, the same distance argument preserves d1 at least d.

  • Relative-expansion condition: The proof replaces full expansion with relative expansion, a weaker notion applied to the ancillary maps ∂G[i],1.Relative expansion is introduced as the condition used to relax Proposition 4’s assumptions.
  • Relative-expansion condition: If each ancillary complex satisfies β_d(G[i]i, P_i) ≥ 1, the coned code retains the required distance bound.P_i indexes G[i]1 elements connected one-to-one to c_i by ∂G[i],1.
  • Distance argument: The proof follows the earlier chain-deformation argument, analyzing arbitrary elements of the added ⊕i∈[t]G[i]1 spaces.The same logical-chain basis and boundary-map decomposition are used under the relative-expansion assumption.
  • Distance argument: The resulting inequalities imply d1(cone(ḡ)) ≥ d under the relative-expansion hypothesis.The argument again combines boundary-weight cases, triangle inequalities, and logical-weight lower bounds.
  • Distance argument: The appendix explicitly concludes that the relaxed proof still establishes d1(cone(ḡ)) ≥ d.Thus relative expansion suffices for the stated coned-code distance guarantee.

Appendix B: Constant spacetime overhead surgery for the toric code

The toric-code construction adapts the general coned-code method to constant-time surgery on products of cyclic repetition codes. It preserves logical action and distance while allowing measurements across multiple toric codes and compacted constructions.

  • Distance and logical action: The toric-code gadgets retain the logical action and d1 distance of the main construction despite relaxing the ancillary expansion condition.The appendix states that the relaxed condition does not affect the relevant lemmas, propositions, or logical action.
  • Toric-code setup: Toric codes are treated as hypergraph products of cyclic repetition codes, with qubits and logical operators represented in the corresponding chain-complex spaces.The construction assumes equal code lengths and distance d for the cyclic factors and their duals.
  • Parallel and entangling measurements: The construction supports constant-time measurements of products of Z logicals across multiple toric codes.A product operator is represented by combining basis vectors that select the toric-code copies participating in the measurement.
  • Measurement construction: The deformed code cone(g[i]) mediates measurement of a selected Z logical, with the measured operator encoded by the support vector b.The operator acts on specified toric-code copies, and the coned code is built from cone(g[i]) ⊗ D.
  • Distance and logical action: Original toric-code Z logicals not targeted by the deformation remain undeformed because no new ancilla X checks act on the base-code spaces.Their trivial extensions therefore remain homologically equivalent logicals of the coned code.
  • Distance and logical action: The coned code has at least d distance because conjugate logical operators can be chosen in d disjoint representatives, forcing any anticommuting logical to intersect all of them.This argument is stated for the relevant Z and X logical pairs in the toric-code construction.
  • Compacted code: Propositions 8 and 9 imply d1(cone(f[i])) ≥ d, and iterating surgeries yields d1(cone(f̄)) ≥ d for the compacted code.The iterative construction extends logical operators across additional ancilla systems while preserving the distance argument.
  • Parallel and entangling measurements: The appendix states that the gadgets may perform entangling measurements across copies of multiple toric codes while preserving the compacted-code distance argument.The compacted code is built by accumulating the chain maps for multiple surgeries.
Loading 2603.02157v1…