Challenges
Datasets
Workspaces
Papers
Discussions
Leaderboard
Log inSign up
Challenges
Datasets
Workspaces
Papers
Discussions
Leaderboard
Blog
Job Board
Q3AS

© 2026 Aqora Quantum S.A.S.

TermsPrivacyLegal Notice

arXiv:2609.11723

Lifted surgery: Fast processing with QLDPC codes

Lucas Berent, Lawrence Z. Cohen, Armanda O. Quintavalle

quant-phSubmitted Sep 10, 2026• Announced Sep 11, 2026• 0 citations
arXivHTMLPDF

Abstract

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.

Comments
38 pages, 3 figures

Related papers

Efficient Logic with Ultra-High-Rate Quantum Codes

Nishad Maskara, Rohan Mehta, Zhiyang He +4 more

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\times$ 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.

quant-pharXiv:2610.06749•Oct 6, 2026•0 citations

Parallel algebraic surgery for qLDPC codes with constant shuttling depth

Tian-Gang Zhou, Boren Gu, Jens Eisert +1 more

Reconfigurable atom arrays provide a promising platform for high-rate quantum low-density parity-check codes, but their computational advantage depends on whether logical operations can be implemented without incurring prohibitive shuttling and space overheads. We introduce algebraic surgery for lifted product codes, co-designing the logical measurements, auxiliary codes, and atom shuttling to enable hardware-efficient Pauli-product measurements. These protocols provide flexible logical addressability subject to the cyclic-symmetry constraint, enabling a broad class of parallel logical measurements, including canonical logical operators with heavily overlapping physical supports and joint measurements within or between code blocks even with different lift sizes, while achieving constant shuttling depth on neutral-atom processors under explicit layout assumptions. In a representative hardware-model benchmark, a cycle supporting 33 parallel canonical logical measurements is about $2\times$ faster than the compared single-observable graph-based surgery schedules, with competitive qubit overhead. These shuttling and circuit-level simulations confirm that the algebraic structure of quantum low-density parity-check codes can be used not only to reduce space overhead, but also to simplify physical implementation and expand the set of efficiently accessible logical operations on neutral-atom processors.

quant-pharXiv:2609.39874•Oct 1, 2026•0 citations

Parsimonious Quantum Low-Density Parity-Check Code Surgery

Andrew C. Yuan, Alexander Cowtan, Zhiyang He +2 more

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(W \log W)$ 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.

quant-pharXiv:2603.05082•Mar 6, 2026•0 citations

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

Kathleen Chang, Zhiyang He, Theodore J. Yoder +2 more

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.

quant-pharXiv:2603.02157•Mar 3, 2026•0 citations

High-Rate Surgery: towards constant-overhead logical operations

Zheng Hua Guo, Liang Jiang, Qian Xu

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.

arXiv:2510.08523•Oct 9, 2025•0 citations

Logical computation with canonical lifted product codes

Han Zheng, Guo Zheng, Liang Jiang +1 more

High-rate quantum low-density parity-check (qLDPC) codes encode many logical qubits with low physical-qubit overhead, but realizing efficient fault-tolerant computation on such dense encodings remains a major challenge. Generic, code-agnostic techniques such as code surgery and gate teleportation apply broadly, but are difficult to make modular, low-overhead, and fully certifiable on complex high-rate codes whose structure is left unexploited. Here we overcome these obstacles by co-designing the code together with its logical instruction set for a broad family of canonical lifted-product (LP) codes with cyclic symmetry. We show that these codes admit a canonical logical basis, in which conjugate logical operators are organized into rows and columns of cyclic orbits inherited directly from the underlying classical codes, analogous to the structure that makes hypergraph-product codes so tractable. This canonical basis enables universal logical processing using magic-state input and a constant number of reusable seed surgery gadgets---only two (resp. four) for a $[[1122,148,\leq 20]]$ (resp. $[[4350,1224,\leq 20]]$) LP code. A fixed extractor smaller than half the data block also enables arbitrarily high-weight logical Pauli-product measurements (PPMs) while preserving the code's cyclic symmetry. These codes also enable rigorously fault-tolerant parallel logic, including PPMs across all logical qubits and magic-state injection from many surface codes into a full LP block. For example, a $[[468,36,20]]$ (resp. $[[952,112,17]]$) code supports simultaneous measurements of arbitrary logically disjoint Pauli products with an ancilla overhead of roughly three (resp. four) times the data block size. These results advance the frontier of fault-tolerant quantum computation on ultra-high-rate quantum architectures.

quant-pharXiv:2607.28605•Jul 31, 2026•0 citations
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]][[90, 8, 10]][[90,8,10]] and [[198,8,16]][[198, 8, 16 ]][[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]][[ 90, 8, 10 ]][[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/21/21/2 code, with only around 2.5×2.5\times2.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.
Reconfigurable atom arrays provide a promising platform for high-rate quantum low-density parity-check codes, but their computational advantage depends on whether logical operations can be implemented without incurring prohibitive shuttling and space overheads. We introduce algebraic surgery for lifted product codes, co-designing the logical measurements, auxiliary codes, and atom shuttling to enable hardware-efficient Pauli-product measurements. These protocols provide flexible logical addressability subject to the cyclic-symmetry constraint, enabling a broad class of parallel logical measurements, including canonical logical operators with heavily overlapping physical supports and joint measurements within or between code blocks even with different lift sizes, while achieving constant shuttling depth on neutral-atom processors under explicit layout assumptions. In a representative hardware-model benchmark, a cycle supporting 33 parallel canonical logical measurements is about 2×2\times2× faster than the compared single-observable graph-based surgery schedules, with competitive qubit overhead. These shuttling and circuit-level simulations confirm that the algebraic structure of quantum low-density parity-check codes can be used not only to reduce space overhead, but also to simplify physical implementation and expand the set of efficiently accessible logical operations on neutral-atom processors.
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(Wlog⁡W)O(W \log W)O(WlogW) to measure an arbitrary logical Pauli operator of weight WWW in any qLDPC stabilizer code. This new construction immediately reduces the asymptotic overhead across various quantum code surgery schemes.
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)O(d)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)O(1)O(1)) and near-constant space overhead (O~(1)\tilde{O}(1)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 ddd surgery operations in O(d)O(d)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.
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]][[144, 12, 12]][[144,12,12]] Gross code and new instances of qLDPC codes (e.g., [[1125,245,≤10]][[1125, 245, \leq 10]][[1125,245,≤10]]) with encoding rate up to 25%25\%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 quantum low-density parity-check (qLDPC) codes encode many logical qubits with low physical-qubit overhead, but realizing efficient fault-tolerant computation on such dense encodings remains a major challenge. Generic, code-agnostic techniques such as code surgery and gate teleportation apply broadly, but are difficult to make modular, low-overhead, and fully certifiable on complex high-rate codes whose structure is left unexploited. Here we overcome these obstacles by co-designing the code together with its logical instruction set for a broad family of canonical lifted-product (LP) codes with cyclic symmetry. We show that these codes admit a canonical logical basis, in which conjugate logical operators are organized into rows and columns of cyclic orbits inherited directly from the underlying classical codes, analogous to the structure that makes hypergraph-product codes so tractable. This canonical basis enables universal logical processing using magic-state input and a constant number of reusable seed surgery gadgets---only two (resp. four) for a [[1122,148,≤20]][[1122,148,\leq 20]][[1122,148,≤20]] (resp. [[4350,1224,≤20]][[4350,1224,\leq 20]][[4350,1224,≤20]]) LP code. A fixed extractor smaller than half the data block also enables arbitrarily high-weight logical Pauli-product measurements (PPMs) while preserving the code's cyclic symmetry. These codes also enable rigorously fault-tolerant parallel logic, including PPMs across all logical qubits and magic-state injection from many surface codes into a full LP block. For example, a [[468,36,20]][[468,36,20]][[468,36,20]] (resp. [[952,112,17]][[952,112,17]][[952,112,17]]) code supports simultaneous measurements of arbitrary logically disjoint Pauli products with an ancilla overhead of roughly three (resp. four) times the data block size. These results advance the frontier of fault-tolerant quantum computation on ultra-high-rate quantum architectures.