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

• URL: http://arxiv.org/abs/2603.02157v1
• Date: Mon, 02 Mar 2026 18:21:52 GMT
• Title: Constant-Time Surgery on 2D Hypergraph Product Codes with Near-Constant Space Overhead
• Authors: Kathleen Chang, Zhiyang He, Theodore J. Yoder, Guanyu Zhu, Tomas Jochym-O'Connor,
• Abstract summary: Generalized code surgery is a versatile and low-overhead technique for performing fault-tolerant computation.<n>In this work, we construct surgery gadgets that perform parallel logical measurements on 2D hypergraph product codes in constant time overhead.
• Score: 1.7884907807711146
• License: http://creativecommons.org/licenses/by/4.0/
• Abstract: 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.

Related papers

• Accelerating Fault-Tolerant Quantum Computation with Good qLDPC Codes [4.569242390849337]
  Scheme achieves constant qubit overhead and a time overhead of $O(da+o(1))$ for any $[[n,k,d]]$ qLDPC code with constant encoding rate and distance $d = Omega(n1/a)$.<n>Results establish a new paradigm for accelerating fault-tolerant quantum computation on qLDPC codes, while maintaining low overhead and broad applicability.
  arXiv  Detail & Related papers  (2025-10-22T10:15:40Z)
• Fast and fault-tolerant logical measurements: Auxiliary hypergraphs and transversal surgery [39.98920557126034]
  Quantum code surgery is a promising technique to perform fault-tolerant computation on quantum low-density parity-check codes.<n>We present a general set of conditions that ensure fault-tolerant surgery operations can be performed with constant time overhead.<n>We further investigate surgery operations with intermediate time overhead, between $O(1)$ and $O(d)$, which apply to quantum locally testable codes.
  arXiv  Detail & Related papers  (2025-10-16T17:12:36Z)
• High-Rate Surgery: towards constant-overhead logical operations [3.085891666389647]
  We introduce high-rate surgery, a general scheme that can perform extensive, addressable logical Pauli-product measurements in parallel on arbitrary qLDPC codes.<n>Our results address a major bottleneck for performing complex, addressable logical operations on qLDPC codes in practice, advancing the prospect of scalable, constant-overhead fault-tolerant quantum computation.
  arXiv  Detail & Related papers  (2025-10-09T17:49:39Z)
• Fast surgery for quantum LDPC codes [0.0]
  We introduce a scheme for performing generalized surgery on quantum LDPC codes using a constant number of rounds of syndrome measurement.<n>Our results pave the way towards fault-tolerant quantum computing with LDPC codes with both low spatial and temporal overheads.
  arXiv  Detail & Related papers  (2025-10-06T06:29:16Z)
• Fast correlated decoding of transversal logical algorithms [67.01652927671279]
  Quantum error correction (QEC) is required for large-scale computation, but incurs a significant resource overhead.<n>Recent advances have shown that by jointly decoding logical qubits in algorithms composed of logical gates, the number of syndrome extraction rounds can be reduced.<n>Here, we reform the problem of decoding circuits by directly decoding relevant logical operator products as they propagate through the circuit.
  arXiv  Detail & Related papers  (2025-05-19T18:00:00Z)
• Demonstrating dynamic surface codes [118.67046728951689]
  We experimentally demonstrate three time-dynamic implementations of the surface code.<n>First, we embed the surface code on a hexagonal lattice, reducing the necessary couplings per qubit from four to three.<n>Second, we walk a surface code, swapping the role of data and measure qubits each round, achieving error correction with built-in removal of accumulated non-computational errors.<n>Third, we realize the surface code using iSWAP gates instead of the traditional CNOT, extending the set of viable gates for error correction without additional overhead.
  arXiv  Detail & Related papers  (2024-12-18T21:56:50Z)
• Demonstrating real-time and low-latency quantum error correction with superconducting qubits [52.08698178354922]
  We demonstrate low-latency feedback with a scalable FPGA decoder integrated into a superconducting quantum processor. We observe logical error suppression as the number of decoding rounds is increased. The decoder throughput and latency developed in this work, combined with continued device improvements, unlock the next generation of experiments.
  arXiv  Detail & Related papers  (2024-10-07T17:07:18Z)
• SSIP: automated surgery with quantum LDPC codes [55.2480439325792]
  We present Safe Surgery by Identifying Pushouts (SSIP), an open-source lightweight Python package for automating surgery between qubit CSS codes. Under the hood, it performs linear algebra over $mathbbF$ governed by universal constructions in the category of chain complexes. We show that various logical measurements can be performed cheaply by surgery without sacrificing the high code distance.
  arXiv  Detail & Related papers  (2024-07-12T16:50:01Z)
• A High Performance Compiler for Very Large Scale Surface Code Computations [38.26470870650882]
  We present the first high performance compiler for very large scale quantum error correction. It translates an arbitrary quantum circuit to surface code operations based on lattice surgery. The compiler can process millions of gates using a streaming pipeline at a speed geared towards real-time operation of a physical device.
  arXiv  Detail & Related papers  (2023-02-05T19:06:49Z)
• RSC: Accelerating Graph Neural Networks Training via Randomized Sparse Computations [56.59168541623729]
  Training graph neural networks (GNNs) is time consuming because sparse graph-based operations are hard to be accelerated by hardware. We explore trading off the computational precision to reduce the time complexity via sampling-based approximation. We propose Randomized Sparse Computation, which for the first time demonstrate the potential of training GNNs with approximated operations.
  arXiv  Detail & Related papers  (2022-10-19T17:25:33Z)

This list is automatically generated from the titles and abstracts of the papers in this site.

This site does not guarantee the quality of this site (including all information) and is not responsible for any consequences.