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:2512.02760 · PRX Quantum

Fault-tolerant quantum computation with constant overhead for general noise

Matthias Christandl, Omar Fawzi, Ashutosh Goswami

quant-phSubmitted Dec 2, 2025• Announced Dec 3, 2025• 2 citations
arXivHTMLPDF

Abstract

Fault-tolerant quantum computation traditionally incurs substantial resource overhead, with both qubit and time overheads scaling polylogarithmically with the size of the computation. While prior work by Gottesman showed that constant qubit overhead is achievable under stochastic noise using quantum low-density parity-check (QLDPC) codes, it has remained an open question whether similar guarantees hold under more general, non-stochastic noise models. In this work, we address this question by considering a general circuit-level noise model defined via the diamond norm, which captures both stochastic and non-stochastic noise, including coherent and amplitude damping noise. We prove that constant qubit overhead fault-tolerant quantum computation is achievable in this general setting, using QLDPC codes with constant rate and linear minimum distance. To establish our result, we develop a fault-tolerant error correction scheme and a method for implementing logic gates under general circuit noise. These results extend the theoretical foundations of fault-tolerant quantum computation and offer new directions for fault-tolerant architectures under realistic noise models.

Journal reference
PRX Quantum 6, 040334, 2025
DOI
10.1103/k4cm-pp9p
Comments
This manuscript was previously the second part of the arxiv submission titled "Fault-tolerant quantum input/output " (arxiv: 2408.05260). 31 pages, 5 figures

Related papers

Fault-tolerant quantum computation with polylogarithmic time and constant space overheads

Shiro Tamiya, Masato Koashi, Hayata Yamasaki

Abstract A major challenge in fault-tolerant quantum computation is to reduce both the space overhead, that is, the large number of physical qubits per logical qubit, and the time overhead, that is, the long physical gate sequences needed to implement a logical gate. Here we prove that a protocol using non-vanishing-rate quantum low-density parity-check (QLDPC) codes, combined with concatenated Steane codes, achieves constant space overhead and polylogarithmic time overhead, even when accounting for the required classical processing. This protocol offers an improvement over existing constant-space-overhead protocols. To prove our result, we develop a technique that we call partial circuit reduction, which enables error analysis for the entire fault-tolerant circuit by examining smaller parts composed of a few gadgets. With this approach, we resolve a logical gap in the existing arguments for the threshold theorem for the constant-space-overhead protocol with QLDPC codes and complete its proof. Our work establishes that the QLDPC-code-based approach can realize fault-tolerant quantum computation with a negligibly small slowdown and a bounded overhead of physical qubits.

Nature Physics•Nov 26, 2025•0 citations

Constant-Overhead Injection into Quantum Codes

Louis Golowich, Venkatesan Guruswami

We construct the first known fault-tolerant scheme for injecting states into quantum error-correcting codes with constant space and time overhead. That is, we construct a family of constant-rate quantum error-correcting codes for which a set of bare physical qubits can be injected, i.e. fault-tolerantly encoded, into a code block. Similarly, a code state can be ejected, i.e. fault-tolerantly decoded, back into bare physical qubits. We show that these injection and ejection procedures succeed under circuit-level locally stochastic noise, while incurring just a small constant probability of corrupting each qubit, which is unavoidable for bare physical qubits. We also show how to perform fault-tolerant error correction and code-state preparation under locally stochastic noise. All of our gadgets can be implemented with constant quantum circuit depth (i.e. are single-shot), and with a number of physical qubits growing linearly with the number of logical qubits, assuming the ability to run polynomial-sized noiseless classical circuits on the side. We construct our quantum codes by taking a high-dimensional hypergraph product of classical LDPC codes, which in turn are a simplified version of Spielman's linear-time encodable codes (STOC'95). As our resulting product codes are only resilient to physical errors occurring with non-uniform probabilities across qubits, we then show how to concatenate with inner codes of various sizes to obtain fault-tolerance against uniform noise.

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

Accelerating Fault-Tolerant Quantum Computation with Good Quantum Low-Density Parity-Check Codes

Guo Zhang, Yuanye Zhu, Ying Li

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.

arXiv:2510.19442•PRX Quantum•Jun 3, 2026•0 citations

Time-Efficient Constant-Space-Overhead Fault-Tolerant Quantum Computation

Hayata Yamasaki, Masato Koashi

Abstract Scalable realization of quantum computing to attain substantial speedups over classical computing requires fault tolerance. Conventionally, protocols for fault-tolerant quantum computation (FTQC) demand excessive space overhead of physical qubits per logical qubit. A more recent protocol to achieve constant-space-overhead FTQC using quantum low-density parity-check (LDPC) codes thus attracts considerable attention but suffers from another drawback: it incurs polynomially long time overhead. To address these problems, we here introduce an alternative approach using a concatenation of multiple small-size quantum codes for the constant-space-overhead FTQC rather than a single large-size quantum LDPC code. We develop techniques for concatenating different quantum Hamming codes with growing sizes. As a result, we construct a low-overhead protocol to achieve constant space overhead and only quasi-polylogarithmic time overhead simultaneously. Our protocol accomplishes FTQC even if a decoder has non-constant runtime, unlike the existing constant-space-overhead protocol. These results establish a foundation for FTQC realizing a large class of quantum speedups within feasibly bounded space overhead yet negligibly short time overhead. This achievement opens a promising avenue for the low-overhead FTQC based on code concatenation.

arXiv:2207.08826•Nature Physics•Jan 16, 2024•54 citations

Fault-tolerant interfaces for quantum LDPC codes

Matthias Christandl, Omar Fawzi, Ashutosh Goswami

The preparation of a quantum state using a noisy quantum computer (gate noise strength $δ$) will necessarily affect an O($δ$)-fraction of the qubits, no matter which protocol is used. Here, we show that fault-tolerant quantum state preparation can be achieved with constant space overhead improving on previous constructions requiring polylogarithmic overhead. To achieve this, we add to the toolbox of fault-tolerant schemes for circuits with quantum input and output. More specifically, we construct fault-tolerant interfaces that decrease the level of protection for quantum low-density parity-check (LDPC) codes. When information is encoded in multiple code blocks, our interfaces have constant space overhead. In our decoder construction that change the level of protection by an arbitrary amount, we circumvent bottlenecks to error pileup and overhead by gradual lowering of the level of encoding at the same time as we increase the number of blocks on which decoding is carried out simultaneously.

quant-pharXiv:2602.16948•Feb 20, 2026•0 citations

Coherent error threshold for quantum LDPC codes

Zhengyi Han, Yuanchen Zhao, Yijia Xu +2 more

A key appeal of quantum low-density parity check (qLDPC) codes is their ability to suppress stochastic Pauli noise below nonzero thresholds. Coherent errors are fundamentally different: they produce superpositions of error patterns whose amplitudes can interfere even after syndrome measurement. Rigorous understanding of coherent errors remains limited. Here we show that general qLDPC codes admit a nonzero code capacity threshold against local coherent noise and more generally local channel noise. For any family of qLDPC codes with distance $d=Ω(\log n)$, we show that there is a constant noise strength below which the logical recovery error in diamond distance decays exponentially with the code distance. The result is established for optimal recovery as well as the minimum-weight decoder. The key technical ingredient is what we call a \emph{cluster resummation}: rather than bounding superposed error configurations one by one, we isolate a large connected error cluster in the channel expansion and exactly resum all errors disconnected from it before taking norms. Standard cluster counting then yields exponential suppression. This work resolves a longstanding challenge in fault tolerance theory, providing general robustness guarantees for qLDPC codes against coherent noise and laying a rigorous foundation for future studies of fault-tolerant quantum technologies.

quant-pharXiv:2609.20537•Sep 18, 2026•0 citations
Fault-tolerant quantum computation traditionally incurs substantial resource overhead, with both qubit and time overheads scaling polylogarithmically with the size of the computation. While prior work by Gottesman showed that constant qubit overhead is achievable under stochastic noise using quantum low-density parity-check (QLDPC) codes, it has remained an open question whether similar guarantees hold under more general, non-stochastic noise models. In this work, we address this question by considering a general circuit-level noise model defined via the diamond norm, which captures both stochastic and non-stochastic noise, including coherent and amplitude damping noise. We prove that constant qubit overhead fault-tolerant quantum computation is achievable in this general setting, using QLDPC codes with constant rate and linear minimum distance. To establish our result, we develop a fault-tolerant error correction scheme and a method for implementing logic gates under general circuit noise. These results extend the theoretical foundations of fault-tolerant quantum computation and offer new directions for fault-tolerant architectures under realistic noise models.
Abstract A major challenge in fault-tolerant quantum computation is to reduce both the space overhead, that is, the large number of physical qubits per logical qubit, and the time overhead, that is, the long physical gate sequences needed to implement a logical gate. Here we prove that a protocol using non-vanishing-rate quantum low-density parity-check (QLDPC) codes, combined with concatenated Steane codes, achieves constant space overhead and polylogarithmic time overhead, even when accounting for the required classical processing. This protocol offers an improvement over existing constant-space-overhead protocols. To prove our result, we develop a technique that we call partial circuit reduction, which enables error analysis for the entire fault-tolerant circuit by examining smaller parts composed of a few gadgets. With this approach, we resolve a logical gap in the existing arguments for the threshold theorem for the constant-space-overhead protocol with QLDPC codes and complete its proof. Our work establishes that the QLDPC-code-based approach can realize fault-tolerant quantum computation with a negligibly small slowdown and a bounded overhead of physical qubits.
We construct the first known fault-tolerant scheme for injecting states into quantum error-correcting codes with constant space and time overhead. That is, we construct a family of constant-rate quantum error-correcting codes for which a set of bare physical qubits can be injected, i.e. fault-tolerantly encoded, into a code block. Similarly, a code state can be ejected, i.e. fault-tolerantly decoded, back into bare physical qubits. We show that these injection and ejection procedures succeed under circuit-level locally stochastic noise, while incurring just a small constant probability of corrupting each qubit, which is unavoidable for bare physical qubits. We also show how to perform fault-tolerant error correction and code-state preparation under locally stochastic noise. All of our gadgets can be implemented with constant quantum circuit depth (i.e. are single-shot), and with a number of physical qubits growing linearly with the number of logical qubits, assuming the ability to run polynomial-sized noiseless classical circuits on the side. We construct our quantum codes by taking a high-dimensional hypergraph product of classical LDPC codes, which in turn are a simplified version of Spielman's linear-time encodable codes (STOC'95). As our resulting product codes are only resilient to physical errors occurring with non-uniform probabilities across qubits, we then show how to concatenate with inner codes of various sizes to obtain fault-tolerance against uniform noise.
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.
Abstract Scalable realization of quantum computing to attain substantial speedups over classical computing requires fault tolerance. Conventionally, protocols for fault-tolerant quantum computation (FTQC) demand excessive space overhead of physical qubits per logical qubit. A more recent protocol to achieve constant-space-overhead FTQC using quantum low-density parity-check (LDPC) codes thus attracts considerable attention but suffers from another drawback: it incurs polynomially long time overhead. To address these problems, we here introduce an alternative approach using a concatenation of multiple small-size quantum codes for the constant-space-overhead FTQC rather than a single large-size quantum LDPC code. We develop techniques for concatenating different quantum Hamming codes with growing sizes. As a result, we construct a low-overhead protocol to achieve constant space overhead and only quasi-polylogarithmic time overhead simultaneously. Our protocol accomplishes FTQC even if a decoder has non-constant runtime, unlike the existing constant-space-overhead protocol. These results establish a foundation for FTQC realizing a large class of quantum speedups within feasibly bounded space overhead yet negligibly short time overhead. This achievement opens a promising avenue for the low-overhead FTQC based on code concatenation.
The preparation of a quantum state using a noisy quantum computer (gate noise strength δδδ) will necessarily affect an O(δδδ)-fraction of the qubits, no matter which protocol is used. Here, we show that fault-tolerant quantum state preparation can be achieved with constant space overhead improving on previous constructions requiring polylogarithmic overhead. To achieve this, we add to the toolbox of fault-tolerant schemes for circuits with quantum input and output. More specifically, we construct fault-tolerant interfaces that decrease the level of protection for quantum low-density parity-check (LDPC) codes. When information is encoded in multiple code blocks, our interfaces have constant space overhead. In our decoder construction that change the level of protection by an arbitrary amount, we circumvent bottlenecks to error pileup and overhead by gradual lowering of the level of encoding at the same time as we increase the number of blocks on which decoding is carried out simultaneously.
A key appeal of quantum low-density parity check (qLDPC) codes is their ability to suppress stochastic Pauli noise below nonzero thresholds. Coherent errors are fundamentally different: they produce superpositions of error patterns whose amplitudes can interfere even after syndrome measurement. Rigorous understanding of coherent errors remains limited. Here we show that general qLDPC codes admit a nonzero code capacity threshold against local coherent noise and more generally local channel noise. For any family of qLDPC codes with distance d=Ω(log⁡n)d=Ω(\log n)d=Ω(logn), we show that there is a constant noise strength below which the logical recovery error in diamond distance decays exponentially with the code distance. The result is established for optimal recovery as well as the minimum-weight decoder. The key technical ingredient is what we call a \emph{cluster resummation}: rather than bounding superposed error configurations one by one, we isolate a large connected error cluster in the channel expansion and exactly resum all errors disconnected from it before taking norms. Standard cluster counting then yields exponential suppression. This work resolves a longstanding challenge in fault tolerance theory, providing general robustness guarantees for qLDPC codes against coherent noise and laying a rigorous foundation for future studies of fault-tolerant quantum technologies.