Logo
ScienceStack
Table of Contents
Fetching ...
Sign In

High-Rate Surgery: towards constant-overhead logical operations

Guo Zheng, Liang Jiang, Qian Xu

TL;DR

This work tackles the overhead bottleneck in fault-tolerant quantum computation with dense qLDPC codes by introducing high-rate surgery, a framework for performing many addressable logical Pauli-product measurements in parallel using a shared ancilla. It develops two constructive pathways: an algebraic approach using hypergraph-product (HGP) ancilla that preserves the merged-code distance and achieves a constant information-extraction rate $r_M = \Theta(1)$ for constant-rate data codes, and a randomized ancilla algorithm that applies broadly to unstructured codes, enabling hundreds of parallel logical measurements with space-time overhead within a factor of two of memory. Numerical benchmarks on the $[[144,12,12]]$ Gross code and on spatially coupled (SC) codes—including a $[[1125,245,10]]$ instance with encoding rate up to $25\%$—demonstrate near-memory-level overhead even for large numbers of operations. Collectively, these results establish a practical route toward constant-overhead, fault-tolerant quantum computation on high-rate qLDPC codes by balancing distance, rate, and ancilla connectivity through algebraic and randomized designs.

Abstract

Scalable quantum computation requires not only quantum codes with low memory overhead but also encoded operations with low space-time overhead. High rate quantum low-density parity-check (qLDPC) codes address the former by achieving a high information-encoding rate, yet existing methods for implementing logical operations often suffer from a low information-processing rate, leading to substantial space-time costs. Here, we introduce high-rate surgery, a general scheme that can perform extensive, addressable logical Pauli-product measurements in parallel on arbitrary qLDPC codes using a shared ancilla system, attaining nearly constant space-time overhead. We develop both algebraic and randomized ancilla constructions and demonstrate, using the $[[144, 12, 12]]$ Gross code and new instances of qLDPC codes (e.g., $[[1125, 245, \leq 10]]$) with encoding rate up to $25\%$, that up to hundreds of randomly sampled logical measurements can be executed simultaneously with a total space-time overhead around a factor of two of that of memory experiments. 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.

High-Rate Surgery: towards constant-overhead logical operations

TL;DR

This work tackles the overhead bottleneck in fault-tolerant quantum computation with dense qLDPC codes by introducing high-rate surgery, a framework for performing many addressable logical Pauli-product measurements in parallel using a shared ancilla. It develops two constructive pathways: an algebraic approach using hypergraph-product (HGP) ancilla that preserves the merged-code distance and achieves a constant information-extraction rate for constant-rate data codes, and a randomized ancilla algorithm that applies broadly to unstructured codes, enabling hundreds of parallel logical measurements with space-time overhead within a factor of two of memory. Numerical benchmarks on the Gross code and on spatially coupled (SC) codes—including a instance with encoding rate up to —demonstrate near-memory-level overhead even for large numbers of operations. Collectively, these results establish a practical route toward constant-overhead, fault-tolerant quantum computation on high-rate qLDPC codes by balancing distance, rate, and ancilla connectivity through algebraic and randomized designs.

Abstract

Scalable quantum computation requires not only quantum codes with low memory overhead but also encoded operations with low space-time overhead. High rate quantum low-density parity-check (qLDPC) codes address the former by achieving a high information-encoding rate, yet existing methods for implementing logical operations often suffer from a low information-processing rate, leading to substantial space-time costs. Here, we introduce high-rate surgery, a general scheme that can perform extensive, addressable logical Pauli-product measurements in parallel on arbitrary qLDPC codes using a shared ancilla system, attaining nearly constant space-time overhead. We develop both algebraic and randomized ancilla constructions and demonstrate, using the Gross code and new instances of qLDPC codes (e.g., ) with encoding rate up to , that up to hundreds of randomly sampled logical measurements can be executed simultaneously with a total space-time overhead around a factor of two of that of memory experiments. 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.

Paper Structure

This paper contains 16 sections, 15 theorems, 90 equations, 7 figures, 2 tables, 2 algorithms.

Table of Contents

  1. Introduction
  2. Results
  3. Discussion and outlook
  4. Methods
  5. Notation and background
  6. Expansion properties
  7. General framework for code surgeries
  8. General surgery procedure
  9. Measurements through metachecks
  10. Merge code distance
  11. High-rate surgery through structured ancilla
  12. Surgery on general data code
  13. Surgery on Hypergraph Product Codes
  14. Algorithm design for randomized ancilla construction and simulation details
  15. Measurement of mixed-type logicals
  16. ...and 1 more sections

Key Result

Lemma 1

For a surgery procedure in Def. def:code_surgery, the space of all measured operators of $\mathcal{C}$ is where $S_X^C$ and $L_X^C$ denote the spaces of the $X$ checks and the $X$ logical operators of $\mathcal{C}$, respectively.

Figures (7)

  • Figure 1: Illustration of high-rate versus low-rate surgery schemes. (a) Comparison of low-rate (sequential williamson2024lowoverheadfaulttolerantquantumcomputationCohen2022LDPCSurgery and parallel Cowtan2025ParallelSurgeryGuo2025TimeEfficient) and high-rate surgery scheme (this work). The horizontal axis represent time axis. Blue circles denote ancilla systems that couple to multiple target logical operators, whose supports are shown by the green, orange, and pink circles, possibly with overlaps. (b) The space (vertical axis) and time (horizontal) costs of surgery schemes on Gross code Bravyi2024Nature, $[[144, 12, 12]]$, for measuring nine randomly chosen logicals, compared against memory. Space costs are measured in unit of physical qubits. Time costs are in units of logical cycles.
  • Figure 2: Tanner graph illustration of a general surgery scheme. Checks (resp. qubits) are represented by squares (resp. circles) williamson2024lowoverheadfaulttolerantquantumcomputation. The shown figure presents the ancilla system merged with the data system to measure X-logical operators, according to Eq. \ref{['eq:cone_code']}. At the end, the ancilla qubits are transversally measured in Z-basis. The example illustrates a transversal-type $\Gamma_1$ such that ancilla X checks and the measured operators' support (indicated by the box with a color gradient) are of similar sizes.
  • Figure 3: Illustrative of high-rate surgery on a HGP data code using another HGP ancilla code. The logicals to measure on the data code are supported on different columns and are indicated the bars in varying colors. The blue bars in the ancilla code represent a set of ancilla checks, whose stabilizer values are combined to infer the corresponding logical values in the data code. According to Eq. \ref{['eq:code_homomorphism']}, we can distince, column-wise connectivites $\{\gamma_1^i\}$, resulting in a large pattern of logical measurements on the data code.
  • Figure 4: Numerical analysis of the space-time costs of surgery schemes. The spacetime costs are normalized by memory spacetime cost. The logical basis and logicals to measure are randomly sampled. The merge code degrees are limited to the data code degree plus two. Each data point is obtained through 6 sets of samples. (a) Cost for measuring varying number of logicals on Gross code. (Inset) the maximum space cost (with only data qubits). (b) Cost for measuring logicals in a set of high-rate spatially-coupled codes $\{[[n_i, k_i, d_i]]\}$ with increasing $k_i$ and $d_i$ (the code parameters are labeled on top). For each code instance, a random sample of $\lfloor90 \%\times k_i\rfloor$ number of logicals are measured.
  • Figure 5: Memory logical error rate of the $[[144, 12, 12]]$ Gross code and its merge codes during surgery. Simulations are performeed under standard circuit-level noise, excluding idling errors. The merge codes shown are constructed through the randomized, high-rate surgery scheme for measuring 3, 7, and 11 of its logicals under a randomly chosen logical basis. The logical error rates reported are averaged per logical qubit over $3$ code cycles. BP-LSD decoder hillmann2024localized with the same decoder parameter is used to decode all cases.
  • ...and 2 more figures

Theorems & Definitions (34)

  • Definition 1: Code surgery
  • Lemma 1: Information extracted through code surgery
  • Definition 2: Information extraction rate (IER)
  • Lemma 2: Sufficient condition for preserving merged-code distance
  • Theorem 1: HGP ancilla with one expander base code is distance-preserving
  • Theorem 2: High-rate surgery with HGP ancilla achieves constant overhead
  • Lemma 3: Condition for commuting diagrams
  • proof
  • Definition 3: Reduced distance
  • Definition 4: Soundness; Campbell_2019
  • ...and 24 more