We propose schemes capable of measuring an arbitrary set of commutative logical Pauli operators in time independent of the number of operators. The only condition is commutativity, a fundamental requirement for simultaneous measurements in quantum mechanics. Quantum low-density parity check (qLDPC) codes show great promise for realizing fault-tolerant quantum computing. They are particularly significant for early fault-tolerant technologies as they can encode many logical qubits using relatively few physical qubits. By achieving simultaneous measurements of logical operators, our approaches enable fully parallelized quantum computing, thus minimizing computation time. Our schemes are applicable to any qLDPC codes and maintain the low density of parity checks while measuring multiple logical operators simultaneously. These results enhance the feasibility of applying early fault-tolerant technologies to practical problems.
We propose schemes capable of measuring an arbitrary set of commutative logical Pauli operators in time independent of the number of operators. The only condition is commutativity, a fundamental requirement for simultaneous measurements in quantum mechanics. Quantum low-density parity check (qLDPC) codes show great promise for realizing fault-tolerant quantum computing. They are particularly significant for early fault-tolerant technologies as they can encode many logical qubits using relatively few physical qubits. By achieving simultaneous measurements of logical operators, our approaches enable fully parallelized quantum computing, thus minimizing computation time. Our schemes are applicable to any qLDPC codes and maintain the low density of parity checks while measuring multiple logical operators simultaneously. These results enhance the feasibility of applying early fault-tolerant technologies to practical problems.
We propose a fault-tolerant quantum computation scheme that is broadly applicable to quantum low-density parity-check (qLDPC) codes. The scheme achieves constant qubit overhead and a time overhead of O ( d a + o ( 1 ) ) for any [ [ n , k , d ] ] qLDPC code with constant encoding rate and distance d = Ω ( n 1 / a ) . For good qLDPC codes, the time overhead is minimized and reaches O ( d 1 + o ( 1 ) ) . In contrast, code surgery based on gauging measurement and brute-force branching requires a time overhead of O ( d w 1 + o ( 1 ) ) , where d ≤ w ≤ n . Thus, our scheme is asymptotically faster for all codes with a < 2 . This speedup is achieved by developing techniques that enable parallelized code surgery under constant qubit overhead and leverage classical locally testable codes for efficient resource state preparation. These results establish a new paradigm for accelerating fault-tolerant quantum computation on qLDPC codes, while maintaining low overhead and broad applicability.
Quantum code surgery offers a flexible, low-overhead framework for executing logical measurements within quantum error-correcting codes. It encompasses several fault-tolerant logical computation schemes, including parallel surgery, universal adapters and fast surgery, and serves as the key primitive in extractor architectures. The efficiency of these schemes crucially depends on constructing low-overhead ancilla systems for measuring arbitrary logical operators in general quantum Low-Density Parity-Check (qLDPC) codes. In this work, we introduce a method to construct an ancilla system of qubit size O(WlogW) to measure an arbitrary logical Pauli operator of weight W in any qLDPC stabilizer code. This new construction immediately reduces the asymptotic overhead across various quantum code surgery schemes.
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,≤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.
Quantum low-density parity-check (QLDPC) codes are a leading candidate for achieving low-overhead fault-tolerant quantum computing. However, the time overhead of logical operations in QLDPC codes remains a key challenge. Code surgery, a space-efficient technique for fault-tolerant logical measurements, incurs this overhead through repeated rounds of syndrome measurement. We introduce lifted surgery, a method for fast and parallel surgery on Abelian group algebra codes that maintains the low physical overhead that makes QLDPC codes attractive. Lifted surgery preserves the symmetries of the underlying code, making searches for large instances tractable and offering a natural route towards efficient hardware implementations. We utilise block decompositions and techniques from commutative algebra to characterise lifted surgery, investigate well-behaved subfamilies, and construct explicit examples. In particular, we present quantum radial codes with parameters [[90,8,10]] and [[198,8,16]] for which surgery is fast, parallel, and addressable, allowing arbitrary sets of independent logical operators of the same Pauli type to be measured in a single round of syndrome extraction. We benchmark lifted surgery under circuit-level depolarising noise and, for the [[90,8,10]] code, find logical performance comparable to standard code surgery while requiring ten times fewer rounds of syndrome measurement. By combining speed and parallelism, lifted surgery offers a practical route towards low-overhead fault-tolerant quantum computing.
Quantum low-density parity-check (qLDPC) codes offer a promising route to reducing the qubit overhead of fault tolerance, with recent ultra-high-rate constructions achieving encoding rates above one half. In this work, we develop fast and parallel logical computation methods for ultra-high-rate codes. We first utilize the group symmetries of the codes to partition the logical qubits into orbits, and then apply parallel surgery methods to implement group-invariant collections of logical Pauli-product measurements. These measurements are highly programmable, as we may arbitrarily couple logical orbits as long as each measurement is repeated across the whole orbit(s). To reduce the space and time overheads, we develop a technique called chain-map convolution, which uses the group structure to boost both the spatial and temporal distances of our protocol in a highly efficient manner. As case studies, we construct distance-preserving parallel measurement gadgets for the [[256, 68, 12]], [[576, 148, 18]] pair-partition codes, and a [[1152, 580, 12]] rate-1/2 code, with only around 2.5× space overhead and 3-4 rounds of syndrome extraction each. The same methods also enable parallel injection of cultivated magic states into high-rate codes. Finally, we extend programmability through subgroup restrictions, revealing a tradeoff between logical control and the spacetime resources required for fault tolerance and highlighting the crucial role structured parallelism plays in reducing overhead. These results provide new methods for designing qLDPC logical operations with low spacetime overhead, opening a route toward more efficient fault-tolerant quantum architectures.
Quantum low-density parity-check (qLDPC) codes can achieve high encoding rates and good code distance scaling, providing a promising route to low-overhead fault-tolerant quantum computing. However, the long-range connectivity required to implement such codes makes their physical realization challenging. Here, we propose a hardware-efficient scheme to perform fault-tolerant quantum computation with high-rate qLDPC codes on reconfigurable atom arrays, directly compatible with recently demonstrated experimental capabilities. Our approach utilizes the product structure inherent in many qLDPC codes to implement the non-local syndrome extraction circuit via atom rearrangement, resulting in effectively constant overhead in practically relevant regimes. We prove the fault tolerance of these protocols, perform circuit-level simulations of memory and logical operations with these codes, and find that our qLDPC-based architecture starts to outperform the surface code with as few as several hundred physical qubits at a realistic physical error rate of 10−3. We further find that less than 3000 physical qubits are sufficient to obtain over an order of magnitude qubit savings compared to the surface code, and quantum algorithms involving thousands of logical qubits can be performed using less than 105 physical qubits. Our work paves the way for explorations of low-overhead quantum computing with qLDPC codes at a practical scale, based on current experimental technologies.