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:2302.04317

A lower bound on the overhead of quantum error correction in low dimensions

Nouédyn Baspin, Omar Fawzi, Ala Shayeghi

Published Feb 8, 2023• 19 citations
arXivHTMLPDF

Abstract

We show that a quantum architecture with an error correction procedure limited to geometrically local operations incurs an overhead that grows with the system size, even if arbitrary error-free classical computation is allowed. In particular, we prove that in order to operate a quantum error correcting code in 2D at a logical error rate of $δ$, a space overhead of $Ω(\sqrt{\log(1/δ)})$ is needed for any constant depolarizing noise $p > 0$.

DOI
10.48550/arxiv.2302.04317

Related papers

Topological quantum error correction and quantum algorithm simulations

David Wang

Quantum computers are machines that manipulate quantum information stored in the form of qubits, the quantum analogue to the classical bit.Unlike the bit, quantum mechanics allows a qubit to be in a linear superposition of both its basis states.Given the same number of bits and qubits, the latter stores exponentially more information.Quantum algorithms exploit these superposition states, allowing quantum computers to solve problems such as prime number factorisation and searches faster than classical computers.Realising a large-scale quantum computer is difficult because quantum information is highly susceptible to noise.Error correction may be employed to suppress the noise, so that the results of large quantum algorithms are valid.The overhead incurred from introducing error correction is neutralised if all elementary quantum operations are constructed with an error rate below some threshold error rate.Below threshold, arbitrary length quantum computation is possible.We investigate two topological quantum error correcting codes, the planar code and the 2D colour code.We find the threshold for the 2D colour code to be 0.1%, and improve the planar code threshold from 0.75% to 1.1%.Existing protocols for the transmission of quantum states are hindered by maximum communication distances and low communication rates.We adapt the planar code for use in quantum communication, and show that this allows the fault-tolerant transmission of quantum information over arbitrary distances at a rate limited only by local quantum gate speed.Error correction is an expensive investment and thus one seeks to employ as little as possible without compromising the integrity of the results.It is therefore important to study the robustness of algorithms to noise.We show that using the matrix product state representation allows one to simulate far larger instances of the quantum factoring algorithm than under the traditional amplitude formalism representation.We simulate systems with as many as 42 qubits on a single processor with 32GB RAM, comparable to amplitude formalism simulations performed on far larger computers.

•Jan 1, 2011•0 citations

Fault-tolerant quantum computation with constant overhead for general noise

Matthias Christandl, Omar Fawzi, Ashutosh Goswami

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.

quant-pharXiv:2512.02760•PRX Quantum•Dec 3, 2025•4 citations

Limited Parallelization in Gate Operations Leads to Higher Space Overhead and Lower Noise Threshold

Sai Sanjay Narayanan, Smita Bagewadi, Avhishek Chatterjee

In a modern error corrected quantum memory or circuit, parallelization of gate operations is severely restricted due to issues like cross-talk. Hence, there are enough idle qubits not undergoing gate operations either during the computation phase or during the error correction phase, which suffer further decoherence while waiting. Thus, in reality, the space overhead and the noise threshold would depend on the level of gate parallelization. In this paper, we obtain an analytical lower bound on the required space overhead in terms of the level of parallelization for an error correction framework that has more error correction capability than the existing ones. We consider two types of errors: i.i.d. erasure and depolarization. In comparison to the known lower bounds which assume full gate parallelization, our bound is provably strictly larger despite allowing more capability to the error correction framework. This shows the steep price to be paid for lack of gate parallelization. An implication of the bound is that the noise or decoherence threshold, i.e., the noise beyond which no fault-tolerant memory or circuit can be realized, vanishes if the number of parallel gate operations does not scale linearly with the number of physical qubits.

arXiv:2410.04156•Oct 5, 2024•0 citations

Quantum Memory and Autonomous Computation in Two Dimensions

Gesa Dünnweber, Georgios Styliaris, Rahul Trivedi

Quantum error correction (QEC) normally requires active maintenance using measurements, classical processing and externally controlled correction schedules. Passive QEC, by contrast, was previously established only in unphysical spatial dimensions. Here, we give an explicit scheme for autonomous quantum error correction and computation in two dimensions, formulated as a dissipative quantum cellular automaton with a fixed, local and translation-invariant update rule. The construction uses hierarchical, self-simulating control elements based on ideas from the seminal classical results of Gács (1986, 1989) together with a measurement-free concatenated quantum code. We prove the existence of a nonzero noise threshold under a local noise model. Below this threshold, logical errors on encoded initial states are suppressed exponentially with increasing system size and the memory lifetime diverges in the thermodynamic limit. As an extension, we outline how this mechanism can also be implemented in continuous time by a time-independent, translation-invariant local Lindbladian. Quantum circuits can moreover be encoded in the automaton's initial state and executed fault-tolerantly with polylogarithmic overhead under the same circuit-independent rule. Our scheme thus realizes a self-correcting quantum computer capable of universal computation.

quant-pharXiv:2601.20818•Jan 29, 2026•10 citations

Novel Methods in Quantum Error Correction

Tomas Jochym-O’Connor

Quantum error correction is the backbone of fault-tolerant quantum computation, a necessary requirement for any large scale quantum computer. The fault-tolerance threshold theorem has long been a target for experimental precision, allowing for the possibility of reducing logical error rates to arbitrarily low levels without excessive overhead. While there are many promising fault-tolerant architectures, the path towards the most practical fault-tolerant scheme is far from decided and may vary for differing physical models. This thesis proposes new schemes for universal fault-tolerant quantum computation in both the concatenated and topological code settings. \n \nThrough the concatenation of two different error correcting codes, a set of universal fault-tolerant gates can be obtained without requiring the need for magic state distillation. A lower bound of $1.28 \\times 10^{-3}$ for the fault-tolerance threshold under circuit level depolarizing noise is obtained. Additionally, stacked codes are proposed as a means to simulate the action of a 3D topological code in 2D, allowing for the application of a universal set of transversal operations. While fault-tolerant, unfortunately the scheme does not exhibit a threshold due to the decreasing pseudo-threshold with growing code distance, yet points to potential interesting avenues for fault-tolerant computation in 2D without distillation. \n \nOne of the primary avenues to constructing fault-tolerant logical operations is through transversal operations. In this thesis, the set of single qubit logical gates that can be implemented transversally are characterized and determined to all belong to the Clifford hierarchy. Moreover, any diagonal two-qubit operation that can be applied transversally must belong to the same level of the Clifford hierarchy as the set of gates that can be implemented in the single-qubit case. \n \nThe opposite to quantum error correction is privacy, where the output of a channel is disguised from its input. The two are fundamentally related through the complementary channel construction. This thesis presents a new class of private quantum channels, expanding the existing class beyond a seemingly fundamental restriction. This yields interesting insights into the structure of quantum information and the leaking of information to external environments. Additionally, the duality is only recovered when extending the complementary channel to sufficiently high environmental dimension. \n \nFinally, the error properties of bucket brigade quantum Random Access Memory (qRAM) are assessed. It is determined that using the bucket brigade qRAM architecture for the running of Grover's algorithm necessitates reducing the error rate of the individual components to exponentially small levels for an exponential sized memory. As such, fault-tolerant architectures will likely play an essential role in the construction of such computing primitives.

•Aug 24, 2016•0 citations

Lower overhead fault-tolerant building blocks for noisy quantum computers

Prithviraj Prabhu

Quantum computation holds the promise of solving certain complex problems exponentially faster than classical computers. However, the high prevalent noise in current quantum devices impedes the accurate execution of even basic algorithms. This can be remedied by protecting quantum information with a quantum error-correcting code, where the logical information of an algorithmic qubit is spread across multiple physical qubits. Individual quantum errors are then located and corrected by the fault-tolerant measurement of multi-qubit stabilizer operators (parity checks). Unfortunately, error correction and fault tolerance both impose large demands on the qubit overhead: hundreds to thousands of physical qubits per logical qubit. We reduce the spacetime cost of fault tolerance by redesigning key building blocks of an error-corrected quantum computer. First, we develop a combinatorial proof with flag fault tolerance that exponentially reduces the extra qubits needed to measure a stabilizer of any size, while tolerating one fault. We leverage these proofs to then design state preparation circuits for the Steane and Golay codes with 100% yield. Next, we improve error correction on a planar layout by showing that a distance-four code encoding six logical qubits protects information as well as the distance-five surface code, using one-tenth as many physical qubits. Finally, we optimize the time overhead of logical gates in surface code quantum computers by protecting measurement results with a classical code, cutting computation time by a factor of two to six. Our hardware-agnostic optimizations of fault tolerance overheads thus suggest new routes to advance the timeline of error-free quantum computing.

quant-pharXiv:2605.12385•May 13, 2026•0 citations
We show that a quantum architecture with an error correction procedure limited to geometrically local operations incurs an overhead that grows with the system size, even if arbitrary error-free classical computation is allowed. In particular, we prove that in order to operate a quantum error correcting code in 2D at a logical error rate of δδδ, a space overhead of Ω(log⁡(1/δ))Ω(\sqrt{\log(1/δ)})Ω(log(1/δ)​) is needed for any constant depolarizing noise p>0p > 0p>0.
Quantum computers are machines that manipulate quantum information stored in the form of qubits, the quantum analogue to the classical bit.Unlike the bit, quantum mechanics allows a qubit to be in a linear superposition of both its basis states.Given the same number of bits and qubits, the latter stores exponentially more information.Quantum algorithms exploit these superposition states, allowing quantum computers to solve problems such as prime number factorisation and searches faster than classical computers.Realising a large-scale quantum computer is difficult because quantum information is highly susceptible to noise.Error correction may be employed to suppress the noise, so that the results of large quantum algorithms are valid.The overhead incurred from introducing error correction is neutralised if all elementary quantum operations are constructed with an error rate below some threshold error rate.Below threshold, arbitrary length quantum computation is possible.We investigate two topological quantum error correcting codes, the planar code and the 2D colour code.We find the threshold for the 2D colour code to be 0.1%, and improve the planar code threshold from 0.75% to 1.1%.Existing protocols for the transmission of quantum states are hindered by maximum communication distances and low communication rates.We adapt the planar code for use in quantum communication, and show that this allows the fault-tolerant transmission of quantum information over arbitrary distances at a rate limited only by local quantum gate speed.Error correction is an expensive investment and thus one seeks to employ as little as possible without compromising the integrity of the results.It is therefore important to study the robustness of algorithms to noise.We show that using the matrix product state representation allows one to simulate far larger instances of the quantum factoring algorithm than under the traditional amplitude formalism representation.We simulate systems with as many as 42 qubits on a single processor with 32GB RAM, comparable to amplitude formalism simulations performed on far larger computers.
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.
In a modern error corrected quantum memory or circuit, parallelization of gate operations is severely restricted due to issues like cross-talk. Hence, there are enough idle qubits not undergoing gate operations either during the computation phase or during the error correction phase, which suffer further decoherence while waiting. Thus, in reality, the space overhead and the noise threshold would depend on the level of gate parallelization. In this paper, we obtain an analytical lower bound on the required space overhead in terms of the level of parallelization for an error correction framework that has more error correction capability than the existing ones. We consider two types of errors: i.i.d. erasure and depolarization. In comparison to the known lower bounds which assume full gate parallelization, our bound is provably strictly larger despite allowing more capability to the error correction framework. This shows the steep price to be paid for lack of gate parallelization. An implication of the bound is that the noise or decoherence threshold, i.e., the noise beyond which no fault-tolerant memory or circuit can be realized, vanishes if the number of parallel gate operations does not scale linearly with the number of physical qubits.
Quantum error correction (QEC) normally requires active maintenance using measurements, classical processing and externally controlled correction schedules. Passive QEC, by contrast, was previously established only in unphysical spatial dimensions. Here, we give an explicit scheme for autonomous quantum error correction and computation in two dimensions, formulated as a dissipative quantum cellular automaton with a fixed, local and translation-invariant update rule. The construction uses hierarchical, self-simulating control elements based on ideas from the seminal classical results of Gács (1986, 1989) together with a measurement-free concatenated quantum code. We prove the existence of a nonzero noise threshold under a local noise model. Below this threshold, logical errors on encoded initial states are suppressed exponentially with increasing system size and the memory lifetime diverges in the thermodynamic limit. As an extension, we outline how this mechanism can also be implemented in continuous time by a time-independent, translation-invariant local Lindbladian. Quantum circuits can moreover be encoded in the automaton's initial state and executed fault-tolerantly with polylogarithmic overhead under the same circuit-independent rule. Our scheme thus realizes a self-correcting quantum computer capable of universal computation.
Quantum error correction is the backbone of fault-tolerant quantum computation, a necessary requirement for any large scale quantum computer. The fault-tolerance threshold theorem has long been a target for experimental precision, allowing for the possibility of reducing logical error rates to arbitrarily low levels without excessive overhead. While there are many promising fault-tolerant architectures, the path towards the most practical fault-tolerant scheme is far from decided and may vary for differing physical models. This thesis proposes new schemes for universal fault-tolerant quantum computation in both the concatenated and topological code settings. \n \nThrough the concatenation of two different error correcting codes, a set of universal fault-tolerant gates can be obtained without requiring the need for magic state distillation. A lower bound of 1.28times10−31.28 \\times 10^{-3}1.28times10−3 for the fault-tolerance threshold under circuit level depolarizing noise is obtained. Additionally, stacked codes are proposed as a means to simulate the action of a 3D topological code in 2D, allowing for the application of a universal set of transversal operations. While fault-tolerant, unfortunately the scheme does not exhibit a threshold due to the decreasing pseudo-threshold with growing code distance, yet points to potential interesting avenues for fault-tolerant computation in 2D without distillation. \n \nOne of the primary avenues to constructing fault-tolerant logical operations is through transversal operations. In this thesis, the set of single qubit logical gates that can be implemented transversally are characterized and determined to all belong to the Clifford hierarchy. Moreover, any diagonal two-qubit operation that can be applied transversally must belong to the same level of the Clifford hierarchy as the set of gates that can be implemented in the single-qubit case. \n \nThe opposite to quantum error correction is privacy, where the output of a channel is disguised from its input. The two are fundamentally related through the complementary channel construction. This thesis presents a new class of private quantum channels, expanding the existing class beyond a seemingly fundamental restriction. This yields interesting insights into the structure of quantum information and the leaking of information to external environments. Additionally, the duality is only recovered when extending the complementary channel to sufficiently high environmental dimension. \n \nFinally, the error properties of bucket brigade quantum Random Access Memory (qRAM) are assessed. It is determined that using the bucket brigade qRAM architecture for the running of Grover's algorithm necessitates reducing the error rate of the individual components to exponentially small levels for an exponential sized memory. As such, fault-tolerant architectures will likely play an essential role in the construction of such computing primitives.
Quantum computation holds the promise of solving certain complex problems exponentially faster than classical computers. However, the high prevalent noise in current quantum devices impedes the accurate execution of even basic algorithms. This can be remedied by protecting quantum information with a quantum error-correcting code, where the logical information of an algorithmic qubit is spread across multiple physical qubits. Individual quantum errors are then located and corrected by the fault-tolerant measurement of multi-qubit stabilizer operators (parity checks). Unfortunately, error correction and fault tolerance both impose large demands on the qubit overhead: hundreds to thousands of physical qubits per logical qubit. We reduce the spacetime cost of fault tolerance by redesigning key building blocks of an error-corrected quantum computer. First, we develop a combinatorial proof with flag fault tolerance that exponentially reduces the extra qubits needed to measure a stabilizer of any size, while tolerating one fault. We leverage these proofs to then design state preparation circuits for the Steane and Golay codes with 100% yield. Next, we improve error correction on a planar layout by showing that a distance-four code encoding six logical qubits protects information as well as the distance-five surface code, using one-tenth as many physical qubits. Finally, we optimize the time overhead of logical gates in surface code quantum computers by protecting measurement results with a classical code, cutting computation time by a factor of two to six. Our hardware-agnostic optimizations of fault tolerance overheads thus suggest new routes to advance the timeline of error-free quantum computing.