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:2410.02213 · Nature Physics

Low-overhead fault-tolerant quantum computation by gauging logical operators

Dominic J. Williamson, Theodore J. Yoder

Published Apr 1, 2026• 6 citations
arXivHTMLPDF

Abstract

Quantum computation must be performed in a fault-tolerant manner to be useful in practice. Recent progress has established quantum error-correcting codes with sparse connectivity requirements and constant qubit overhead suitable for quantum memory. However, existing schemes that include fault-tolerant logical measurement on such quantum memories do not always achieve low qubit overhead. Here we present a low-overhead method to implement fault-tolerant logical measurement on a quantum error-correcting code by treating the logical operator as a physical symmetry and gauging it so that it is enforced by a product of local symmetries. The gauging measurement procedure introduces a high degree of flexibility that can be exploited to achieve a qubit overhead that is linear in the weight of the operator being measured up to a polylogarithmic factor. This flexibility also allows the procedure to be adapted to arbitrary quantum codes. Our results provide a more efficient approach to performing fault-tolerant quantum computation, making it more tractable for near-term implementation. Combining quantum error correction with gauge theory concepts from many-body physics enables the design of codes with improved resource requirements for fault-tolerant quantum computation.

DOI
10.1038/s41567-026-03220-8

Related papers

Low-overhead fault-tolerant quantum computing using long-range connectivity

Lawrence Z. Cohen, Isaac H. Kim, Stephen D. Bartlett +1 more

Vast numbers of qubits will be needed for large-scale quantum computing because of the overheads associated with error correction. We present a scheme for low-overhead fault-tolerant quantum computation based on quantum low-density parity-check (LDPC) codes, where long-range interactions enable many logical qubits to be encoded with a modest number of physical qubits. In our approach, logic gates operate via logical Pauli measurements that preserve both the protection of the LDPC codes and the low overheads in terms of the required number of additional qubits. Compared with surface codes with the same code distance, we estimate order-of-magnitude improvements in the overheads for processing around 100 logical qubits using this approach. Given the high thresholds demonstrated by LDPC codes, our estimates suggest that fault-tolerant quantum computation at this scale may be achievable with a few thousand physical qubits at comparable error rates to what is needed for current approaches.

arXiv:2110.10794•Science Advances•May 20, 2022•98 citations

Fast magic state preparation by gauging higher-form transversal gates in parallel

Dominic J. Williamson

Magic states are a foundational resource for universal quantum computation. To survive in a realistic noisy environment, magic states must be prepared fault-tolerantly and protected by a quantum error-correcting code. The recent discovery of highly efficient quantum low-density parity-check codes, together with efficient logic gates, lays the groundwork for low-overhead fault-tolerant quantum computation. This motivates the search for fast and parallel protocols for logical magic state preparation to enable universal quantum computation. Here, we introduce a fast code surgery procedure that performs a fault-tolerant measurement of many transversal logic gates in parallel. This is achieved by performing a generalized gauging measurement on a quantum code that supports a higher-form transversal gate. The time overhead of our procedure is constant, and the qubit overhead is linear. The procedure inherits fault-tolerance properties from the base code and the structure of the higher-form transversal gate. When applied to codes that support higher-form Clifford gates our procedure achieves fast and fault-tolerant preparation of many magic states in parallel. This motivates the search for good quantum low-density parity-check codes that support higher-form Clifford gates.

quant-pharXiv:2601.22939•Feb 2, 2026•0 citations

High-threshold and low-overhead fault-tolerant quantum memory

Sergey B. Bravyi, Andrew W. Cross, Jay Gambetta +3 more

Abstract The accumulation of physical errors 1–3 prevents the execution of large-scale algorithms in current quantum computers. Quantum error correction 4 promises a solution by encoding k logical qubits onto a larger number n of physical qubits, such that the physical errors are suppressed enough to allow running a desired computation with tolerable fidelity. Quantum error correction becomes practically realizable once the physical error rate is below a threshold value that depends on the choice of quantum code, syndrome measurement circuit and decoding algorithm 5 . We present an end-to-end quantum error correction protocol that implements fault-tolerant memory on the basis of a family of low-density parity-check codes 6 . Our approach achieves an error threshold of 0.7% for the standard circuit-based noise model, on par with the surface code 7–10 that for 20 years was the leading code in terms of error threshold. The syndrome measurement cycle for a length- n code in our family requires n ancillary qubits and a depth-8 circuit with CNOT gates, qubit initializations and measurements. The required qubit connectivity is a degree-6 graph composed of two edge-disjoint planar subgraphs. In particular, we show that 12 logical qubits can be preserved for nearly 1 million syndrome cycles using 288 physical qubits in total, assuming the physical error rate of 0.1%, whereas the surface code would require nearly 3,000 physical qubits to achieve said performance. Our findings bring demonstrations of a low-overhead fault-tolerant quantum memory within the reach of near-term quantum processors.

arXiv:2308.07915•Nature•Mar 27, 2024•456 citations

Fault Tolerant Quantum Computing with Lower Overhead

Benjamin Anker

Quantum computation promises asymptotic speedups over classical algorithms, but realizing these advantages requires overcoming the noisiness of quantum hardware. Although fault-tolerant error correction can allow for reliable quantum computation even using unreliable components, the resource overheads required can substantially erode the asymptotic performance gains. This dissertation focuses on constructing and optimizing fault-tolerant procedures with lower overhead than previous methods were capable of. We present new frameworks for fault-tolerant syndrome extraction using flag gadgets with exponentially reduced ancilla requirements, explicit measurement schedules that achieve asymptotically fewer measurements than stabilizer generators, and a general method for making arbitrary Clifford circuits fault tolerant. In addition, we optimize surface code measurement schedules in the presence of constraints imposed by fabrication defects to reduce logical error rate. Together, these results advance low-overhead fault tolerance and improve performance in resource-constrained and near-term quantum computing settings.

•May 16, 2026•0 citations

A framework for low-overhead quantum fault tolerance via spacetime lifting

Yijia Xu, Yixu Wang, Zi-Wen Liu

Fault-tolerant quantum computation is inherently a spacetime problem, requiring not merely good static quantum error-correcting codes but also low-overhead protocols for protecting and manipulating encoded quantum information over time. Fault complexes provide a homological formalism for treating such protocols as single spacetime objects. Here we initiate the study of low-overhead fault complexes by introducing \emph{spacetime lifting}, a method that constructs fault complexes from symmetry-reduced product structures beyond standard foliation. We show that spacetime lifting yields fault complexes and in particular memory experiments with almost-linear fault distance in the total spacetime cost, which substantially outperforms existing constructions. We further endow fault complexes with the operational interpretation of measurement-based cluster state protocols and identify general conditions under which they realize fault-tolerant logical teleportation, showing that spacetime-lifted constructions combine favorable parameter scaling with operational realizations. Our work establishes a systematic route towards more efficient quantum fault tolerance through general complex constructions.

quant-pharXiv:2606.06365•Jun 5, 2026•0 citations

Weakly fault-tolerant computation in a quantum error-detecting code

Christopher Gerhard, Todd A. Brun

Many current quantum error-correcting codes that achieve full fault tolerance suffer from having low ratios of logical to physical qubits and significant overhead. This makes them difficult to implement on current noisy intermediate-scale quantum (NISQ) computers and results in the inability to perform quantum algorithms at useful scales with near-term quantum processors. As a result, calculations are generally done without encoding. We propose a middle ground between these two approaches: constructions in the $[[n,n-2,2]]$ quantum error-detecting code that can detect any error from a single faulty gate by measuring the stabilizer generators of the code and additional ancillas at the end of the computation. This achieves weak fault tolerance. As we show, this yields a significant improvement over no error correction for small computations with low enough physical error probabilities and requires much less overhead than codes that achieve full fault tolerance. We give constructions for a set of gates that achieve universal quantum computation in this error-detecting code, while satisfying weak fault tolerance up to analog imprecision on the physical rotation gate.

arXiv:2408.14828•Physical Review A•May 28, 2026•1 citation
Quantum computation must be performed in a fault-tolerant manner to be useful in practice. Recent progress has established quantum error-correcting codes with sparse connectivity requirements and constant qubit overhead suitable for quantum memory. However, existing schemes that include fault-tolerant logical measurement on such quantum memories do not always achieve low qubit overhead. Here we present a low-overhead method to implement fault-tolerant logical measurement on a quantum error-correcting code by treating the logical operator as a physical symmetry and gauging it so that it is enforced by a product of local symmetries. The gauging measurement procedure introduces a high degree of flexibility that can be exploited to achieve a qubit overhead that is linear in the weight of the operator being measured up to a polylogarithmic factor. This flexibility also allows the procedure to be adapted to arbitrary quantum codes. Our results provide a more efficient approach to performing fault-tolerant quantum computation, making it more tractable for near-term implementation. Combining quantum error correction with gauge theory concepts from many-body physics enables the design of codes with improved resource requirements for fault-tolerant quantum computation.
Vast numbers of qubits will be needed for large-scale quantum computing because of the overheads associated with error correction. We present a scheme for low-overhead fault-tolerant quantum computation based on quantum low-density parity-check (LDPC) codes, where long-range interactions enable many logical qubits to be encoded with a modest number of physical qubits. In our approach, logic gates operate via logical Pauli measurements that preserve both the protection of the LDPC codes and the low overheads in terms of the required number of additional qubits. Compared with surface codes with the same code distance, we estimate order-of-magnitude improvements in the overheads for processing around 100 logical qubits using this approach. Given the high thresholds demonstrated by LDPC codes, our estimates suggest that fault-tolerant quantum computation at this scale may be achievable with a few thousand physical qubits at comparable error rates to what is needed for current approaches.
Magic states are a foundational resource for universal quantum computation. To survive in a realistic noisy environment, magic states must be prepared fault-tolerantly and protected by a quantum error-correcting code. The recent discovery of highly efficient quantum low-density parity-check codes, together with efficient logic gates, lays the groundwork for low-overhead fault-tolerant quantum computation. This motivates the search for fast and parallel protocols for logical magic state preparation to enable universal quantum computation. Here, we introduce a fast code surgery procedure that performs a fault-tolerant measurement of many transversal logic gates in parallel. This is achieved by performing a generalized gauging measurement on a quantum code that supports a higher-form transversal gate. The time overhead of our procedure is constant, and the qubit overhead is linear. The procedure inherits fault-tolerance properties from the base code and the structure of the higher-form transversal gate. When applied to codes that support higher-form Clifford gates our procedure achieves fast and fault-tolerant preparation of many magic states in parallel. This motivates the search for good quantum low-density parity-check codes that support higher-form Clifford gates.
Abstract The accumulation of physical errors 1–3 prevents the execution of large-scale algorithms in current quantum computers. Quantum error correction 4 promises a solution by encoding k logical qubits onto a larger number n of physical qubits, such that the physical errors are suppressed enough to allow running a desired computation with tolerable fidelity. Quantum error correction becomes practically realizable once the physical error rate is below a threshold value that depends on the choice of quantum code, syndrome measurement circuit and decoding algorithm 5 . We present an end-to-end quantum error correction protocol that implements fault-tolerant memory on the basis of a family of low-density parity-check codes 6 . Our approach achieves an error threshold of 0.7% for the standard circuit-based noise model, on par with the surface code 7–10 that for 20 years was the leading code in terms of error threshold. The syndrome measurement cycle for a length- n code in our family requires n ancillary qubits and a depth-8 circuit with CNOT gates, qubit initializations and measurements. The required qubit connectivity is a degree-6 graph composed of two edge-disjoint planar subgraphs. In particular, we show that 12 logical qubits can be preserved for nearly 1 million syndrome cycles using 288 physical qubits in total, assuming the physical error rate of 0.1%, whereas the surface code would require nearly 3,000 physical qubits to achieve said performance. Our findings bring demonstrations of a low-overhead fault-tolerant quantum memory within the reach of near-term quantum processors.
Quantum computation promises asymptotic speedups over classical algorithms, but realizing these advantages requires overcoming the noisiness of quantum hardware. Although fault-tolerant error correction can allow for reliable quantum computation even using unreliable components, the resource overheads required can substantially erode the asymptotic performance gains. This dissertation focuses on constructing and optimizing fault-tolerant procedures with lower overhead than previous methods were capable of. We present new frameworks for fault-tolerant syndrome extraction using flag gadgets with exponentially reduced ancilla requirements, explicit measurement schedules that achieve asymptotically fewer measurements than stabilizer generators, and a general method for making arbitrary Clifford circuits fault tolerant. In addition, we optimize surface code measurement schedules in the presence of constraints imposed by fabrication defects to reduce logical error rate. Together, these results advance low-overhead fault tolerance and improve performance in resource-constrained and near-term quantum computing settings.
Fault-tolerant quantum computation is inherently a spacetime problem, requiring not merely good static quantum error-correcting codes but also low-overhead protocols for protecting and manipulating encoded quantum information over time. Fault complexes provide a homological formalism for treating such protocols as single spacetime objects. Here we initiate the study of low-overhead fault complexes by introducing \emph{spacetime lifting}, a method that constructs fault complexes from symmetry-reduced product structures beyond standard foliation. We show that spacetime lifting yields fault complexes and in particular memory experiments with almost-linear fault distance in the total spacetime cost, which substantially outperforms existing constructions. We further endow fault complexes with the operational interpretation of measurement-based cluster state protocols and identify general conditions under which they realize fault-tolerant logical teleportation, showing that spacetime-lifted constructions combine favorable parameter scaling with operational realizations. Our work establishes a systematic route towards more efficient quantum fault tolerance through general complex constructions.
Many current quantum error-correcting codes that achieve full fault tolerance suffer from having low ratios of logical to physical qubits and significant overhead. This makes them difficult to implement on current noisy intermediate-scale quantum (NISQ) computers and results in the inability to perform quantum algorithms at useful scales with near-term quantum processors. As a result, calculations are generally done without encoding. We propose a middle ground between these two approaches: constructions in the [[n,n−2,2]][[n,n-2,2]][[n,n−2,2]] quantum error-detecting code that can detect any error from a single faulty gate by measuring the stabilizer generators of the code and additional ancillas at the end of the computation. This achieves weak fault tolerance. As we show, this yields a significant improvement over no error correction for small computations with low enough physical error probabilities and requires much less overhead than codes that achieve full fault tolerance. We give constructions for a set of gates that achieve universal quantum computation in this error-detecting code, while satisfying weak fault tolerance up to analog imprecision on the physical rotation gate.