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:2408.13687 · Nature

Quantum error correction below the surface code threshold

Google Quantum AI and Collaborators, Rajeev Acharya, Dmitry A. Abanin, Laleh Aghababaie Beni, I. L. Aleǐner, Trond I. Andersen, M. Ansmann, Frank Arute, Kunal Arya, Abraham T. Asfaw, Nikita Astrakhantsev, Juan Atalaya, Ryan Babbush, Dave Bacon, Brian Ballard, Joseph C. Bardin, Johannes Bausch, Andreas Bengtsson, Alexander Bilmes, Sam Blackwell, Sergio Boixo, Gina Bortoli, Alexandre Bourassa, Jenna Bovaird, Leon Brill, Michael Broughton, David A. Browne, Brett Buchea, Bob B. Buckley, David A. Buell, Tim Burger, Brian Burkett, Nicholas Bushnell, Anthony Cabrera, Juan Campero, Hung-Shen Chang, Yu Chen, Zijun Chen, B. Chiaro, Desmond Chik, Charina Chou, Jahan Claes, Agnetta Y. Cleland, J. G. Cogan, Roberto Collins, Paul W. Conner, William Courtney, Alexander L. Crook, Ben Curtin, Sayan Das, Alex Davies, Laura De Lorenzo, Dripto M. Debroy, Sean Demura, Michel Devoret, Agustín Di Paolo, Paul Donohoe, Ilya Drozdov, A. Dunsworth, Clint Earle, Thomas Edlich, Alec Eickbusch, Aviv Moshe Elbag, Mahmoud Elzouka, Catherine Erickson, Lara Faoro, Edward Farhi, Vinicius S. Ferreira, Leslie Flores Burgos, Ebrahim Forati, Austin G. Fowler, Brooks Foxen, Suhas Ganjam, Gonzalo Garcia, Robert Gasca, Élie Genois, William Giang, Craig Gidney, Dar Gilboa, Raja Gosula, Alejandro Grajales Dau, Dietrich Graumann, Alex Greene, Jonathan A. Gross, Steve Habegger, John A. Hall, Michael C. Hamilton, Monica A. Hansen, Matthew P. Harrigan, Sean David Harrington, Francisco J. H. Heras, Stephen Heslin, Paula Heu, Oscar Higgott, Gordon Hill, Jeremy Hilton, George Holland, Sabrina Hong, Hsin-Yuan Huang, Ashley Huff

Published Dec 9, 2024• 1,314 citations
arXivHTMLPDF

Abstract

Quantum error correction [1, 2, 3, 4] provides a path to reach practical quantum computing by combining multiple physical qubits into a logical qubit, where the logical error rate is suppressed exponentially as more qubits are added. However, this exponential suppression only occurs if the physical error rate is below a critical threshold. Here, we present two below-threshold surface code memories on our newest generation of superconducting processors, Willow: a distance-7 code, and a distance-5 code integrated with a real-time decoder. The logical error rate of our larger quantum memory is suppressed by a factor of $$\varLambda \mathrm{=2.14}\pm 0.02$$ when increasing the code distance by two, culminating in a 101-qubit distance-7 code with 0.143% ± 0.003% error per cycle of error correction. This logical memory is also beyond break-even, exceeding its best physical qubit’s lifetime by a factor of $$2.4\pm 0.3$$ . Our system maintains below-threshold performance when decoding in real time, achieving an average decoder latency of 63 μs at distance-5 up to a million cycles, with a cycle time of 1.1 μs. We also run repetition codes up to distance-29 and find that logical performance is limited by rare correlated error events occurring approximately once every hour, or $$3$$ $$\times $$ $${10}^{9}$$ cycles. Our results present device performance that, if scaled, could realize the operational requirements of large scale fault-tolerant quantum algorithms.

DOI
10.1038/s41586-024-08449-y

Related papers

Quantum error correction well below the color code threshold

Ali Lavasani, Adam P. Reed, Joan M. Dreiling +20 more

Quantum error correction enables scalable fault-tolerant quantum computation by suppressing logical errors exponentially with code distance once physical error rates fall below a critical threshold. Here we demonstrate below-threshold operation of triangular color codes with distances $d=3,5,$ and $7$ on Quantinuum's Helios trapped-ion quantum processor. Leveraging both circuit- and hardware- level leakage reduction schemes, we achieve logical error rates as low as $5_{-2}^{+4}\times 10^{-6}$, and demonstrate error suppression by over an order of magnitude, $Λ=12_{-2}^{+3}$, with each successive increase in code distance. Moreover, we demonstrate below threshold scaling of error rates for Clifford two-qubit randomized benchmarking circuits when encoded in $d=3,5$ color codes, achieving logical error rate of $7^{+3}_{-3}\times 10^{-5}$ per logical two-qubit Clifford at distance $5$ with a suppression factor of $Λ=9_{-3}^{+8}$. We compare logical performance for existing near-optimal algorithmic decoders, and both convolutional neural network and transformer-based neural network decoders capable of real-time decoding an order of magnitude faster than the syndrome extraction rate. These results approach the logical error rates required for megaquop-scale quantum computation and indicate that scaled trapped-ion processors could reach application-relevant performance with substantially smaller code blocks than indicated by previous results in other qubit modalities.

quant-pharXiv:2610.24077•Oct 20, 2026•5 citations

Suppressing quantum errors by scaling a surface code logical qubit

Google Quantum AI, Rajeev Acharya, I. L. Aleǐner +97 more

Abstract Practical quantum computing will require error rates well below those achievable with physical qubits. Quantum error correction 1,2 offers a path to algorithmically relevant error rates by encoding logical qubits within many physical qubits, for which increasing the number of physical qubits enhances protection against physical errors. However, introducing more qubits also increases the number of error sources, so the density of errors must be sufficiently low for logical performance to improve with increasing code size. Here we report the measurement of logical qubit performance scaling across several code sizes, and demonstrate that our system of superconducting qubits has sufficient performance to overcome the additional errors from increasing qubit number. We find that our distance-5 surface code logical qubit modestly outperforms an ensemble of distance-3 logical qubits on average, in terms of both logical error probability over 25 cycles and logical error per cycle ((2.914 ± 0.016)% compared to (3.028 ± 0.023)%). To investigate damaging, low-probability error sources, we run a distance-25 repetition code and observe a 1.7 × 10 −6 logical error per cycle floor set by a single high-energy event (1.6 × 10 −7 excluding this event). We accurately model our experiment, extracting error budgets that highlight the biggest challenges for future systems. These results mark an experimental demonstration in which quantum error correction begins to improve performance with increasing qubit number, illuminating the path to reaching the logical error rates required for computation.

arXiv:2207.06431•Nature•Feb 22, 2023•1,354 citations

Demonstration of Logical Error Suppression in a Surface Code Memory on a Cloud-Accessible IBM Superconducting Processor

Shuwen Kan, Aaron Hoyt, Sean Garner +8 more

Quantum error correction can suppress logical errors exponentially with code distance when physical noise is below threshold. Realizing this on hardware requires tight coordination among quantum gates, mid-circuit measurements, and qubit coherence. Device variation, noise asymmetry, and correlations across space and time complicate the translation of these capabilities into logical error suppression. Here, we study rotated surface-code memory on an IBM Nighthawk r2 processor. Performance varies across tested processor placements, which we attribute to differences in qubit quality. We optimize the code by combining short readout, fused measurement and reset, and an XX echo on data qubits during ancilla readout. Compared with standard readout without reset or echo, the optimized syndrome extraction circuit reduces the median per-round logical error rate by factors of 3.8 in the X basis and 1.4 in the Z basis. In memory experiments of up to 150 rounds, the distance advantage weakens, alongside long-lived correlations that may reflect a persistent error component. Under our optimization recipe, increasing the protected distance from 3 to 6 while holding the other distance fixed reduces the per-round logical error rate from 0.53% to 0.24% in Z memory and from 0.52% to 0.22% in X memory. The corresponding error-suppression factors under maximum-likelihood decoding are 1.68 and 1.85. These results connect circuit compilation and optimization to surface-code memory performance and limitations, and motivate QPU and QEC circuit codesign for fault-tolerant quantum computing primitives on current cloud hardware.

quant-pharXiv:2610.23840•Oct 19, 2026•2 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•722 citations

Logical-Error Suppression in the Willow Surface-Code Memory: A Lambda Budget Extrapolated to Algorithmic Error Targets

William Alexander Aldred

The December 2024 report of the Willow processor presented the first superconducting surface-code memory in which enlarging the code reduced the logical error rate: each step from distance three to five to seven divided the error per cycle by a suppression factor Lambda of 2.14, reaching 1.43e-3 per cycle at distance seven. A single measured suppression factor invites extrapolation, and extrapolation deserves an audit. This paper takes the published Lambda and the published distance-seven rate as fixed inputs and computes what they imply for the distances and qubit counts that algorithmic error targets demand. Holding Lambda constant, a per-cycle logical error rate of 1.00e-9 requires distance 45 and 4049 physical qubits in one rotated patch, while 1.00e-12 requires distance 63 and 7937 qubits. The mean waiting time between logical failures at distance seven is only 699 cycles, which at a microsecond-scale cycle time is well under a millisecond, so the demonstrated patch is a physics milestone rather than a computational memory. The budget also exposes the sensitivity of every projection to Lambda: because distance grows logarithmically in the target but the qubit count grows with the square of distance, a ten per cent erosion of Lambda inflates the largest patches by roughly a quarter. Suppression factors, not raw physical error rates, are therefore the currency in which fault-tolerant overhead should be quoted.

•Nov 15, 2026•0 citations

Beyond Qubit Count: A Comparative Review of Quantum Chip Architectures, Error Correction, and the Path to Fault-Tolerant Computing

Mr. Sairaj Dalvi, Mr. Suyog Salvi, Mr. Tanmay Patil +1 more

Quantum processors are often compared by the number of physical qubits they contain. That number, however, does not by itself indicate whether a processor can execute a useful computation reliably. Qubit coherence, gate and measurement fidelity, connectivity, control infrastructure, fabrication yield, and the overhead of quantum error correction all influence practical capability. This paper presents a structured comparative review of six major quantum-computing modalities: superconducting circuits, trapped ions, photonic systems, silicon-spin qubits, neutral atoms, and topological approaches. It examines their physical implementations, operational strengths, engineering constraints, and prospects for scaling. Particular attention is given to surface-code error correction and the 105-qubit Willow processor result reported by Google Quantum AI, which demonstrated below-threshold surface-code memory and a logical-error suppression factor of 2.14 ± 0.02 when code distance increased by two. The paper also considers cryogenic control, wiring, modular interconnects, fabrication variability, real-time decoding, and the Indian National Quantum Mission. The review finds that progress towards fault tolerance is best assessed through logical performance and system-level engineering rather than physical-qubit count alone. No modality currently removes the need to address scaling overhead, reliable operations, and application-level advantage

International Journal for Research in Applied Science and Engineering Technology•Nov 11, 2026•0 citations
Quantum error correction [1, 2, 3, 4] provides a path to reach practical quantum computing by combining multiple physical qubits into a logical qubit, where the logical error rate is suppressed exponentially as more qubits are added. However, this exponential suppression only occurs if the physical error rate is below a critical threshold. Here, we present two below-threshold surface code memories on our newest generation of superconducting processors, Willow: a distance-7 code, and a distance-5 code integrated with a real-time decoder. The logical error rate of our larger quantum memory is suppressed by a factor of Λ=2.14±0.02\varLambda \mathrm{=2.14}\pm 0.02Λ=2.14±0.02 when increasing the code distance by two, culminating in a 101-qubit distance-7 code with 0.143% ± 0.003% error per cycle of error correction. This logical memory is also beyond break-even, exceeding its best physical qubit’s lifetime by a factor of 2.4±0.32.4\pm 0.32.4±0.3 . Our system maintains below-threshold performance when decoding in real time, achieving an average decoder latency of 63 μs at distance-5 up to a million cycles, with a cycle time of 1.1 μs. We also run repetition codes up to distance-29 and find that logical performance is limited by rare correlated error events occurring approximately once every hour, or 333 ×\times × 109{10}^{9}109 cycles. Our results present device performance that, if scaled, could realize the operational requirements of large scale fault-tolerant quantum algorithms.
Quantum error correction enables scalable fault-tolerant quantum computation by suppressing logical errors exponentially with code distance once physical error rates fall below a critical threshold. Here we demonstrate below-threshold operation of triangular color codes with distances d=3,5,d=3,5,d=3,5, and 777 on Quantinuum's Helios trapped-ion quantum processor. Leveraging both circuit- and hardware- level leakage reduction schemes, we achieve logical error rates as low as 5−2+4×10−65_{-2}^{+4}\times 10^{-6}5−2+4​×10−6, and demonstrate error suppression by over an order of magnitude, Λ=12−2+3Λ=12_{-2}^{+3}Λ=12−2+3​, with each successive increase in code distance. Moreover, we demonstrate below threshold scaling of error rates for Clifford two-qubit randomized benchmarking circuits when encoded in d=3,5d=3,5d=3,5 color codes, achieving logical error rate of 7−3+3×10−57^{+3}_{-3}\times 10^{-5}7−3+3​×10−5 per logical two-qubit Clifford at distance 555 with a suppression factor of Λ=9−3+8Λ=9_{-3}^{+8}Λ=9−3+8​. We compare logical performance for existing near-optimal algorithmic decoders, and both convolutional neural network and transformer-based neural network decoders capable of real-time decoding an order of magnitude faster than the syndrome extraction rate. These results approach the logical error rates required for megaquop-scale quantum computation and indicate that scaled trapped-ion processors could reach application-relevant performance with substantially smaller code blocks than indicated by previous results in other qubit modalities.
Abstract Practical quantum computing will require error rates well below those achievable with physical qubits. Quantum error correction 1,2 offers a path to algorithmically relevant error rates by encoding logical qubits within many physical qubits, for which increasing the number of physical qubits enhances protection against physical errors. However, introducing more qubits also increases the number of error sources, so the density of errors must be sufficiently low for logical performance to improve with increasing code size. Here we report the measurement of logical qubit performance scaling across several code sizes, and demonstrate that our system of superconducting qubits has sufficient performance to overcome the additional errors from increasing qubit number. We find that our distance-5 surface code logical qubit modestly outperforms an ensemble of distance-3 logical qubits on average, in terms of both logical error probability over 25 cycles and logical error per cycle ((2.914 ± 0.016)% compared to (3.028 ± 0.023)%). To investigate damaging, low-probability error sources, we run a distance-25 repetition code and observe a 1.7 × 10 −6 logical error per cycle floor set by a single high-energy event (1.6 × 10 −7 excluding this event). We accurately model our experiment, extracting error budgets that highlight the biggest challenges for future systems. These results mark an experimental demonstration in which quantum error correction begins to improve performance with increasing qubit number, illuminating the path to reaching the logical error rates required for computation.
Quantum error correction can suppress logical errors exponentially with code distance when physical noise is below threshold. Realizing this on hardware requires tight coordination among quantum gates, mid-circuit measurements, and qubit coherence. Device variation, noise asymmetry, and correlations across space and time complicate the translation of these capabilities into logical error suppression. Here, we study rotated surface-code memory on an IBM Nighthawk r2 processor. Performance varies across tested processor placements, which we attribute to differences in qubit quality. We optimize the code by combining short readout, fused measurement and reset, and an XX echo on data qubits during ancilla readout. Compared with standard readout without reset or echo, the optimized syndrome extraction circuit reduces the median per-round logical error rate by factors of 3.8 in the X basis and 1.4 in the Z basis. In memory experiments of up to 150 rounds, the distance advantage weakens, alongside long-lived correlations that may reflect a persistent error component. Under our optimization recipe, increasing the protected distance from 3 to 6 while holding the other distance fixed reduces the per-round logical error rate from 0.53% to 0.24% in Z memory and from 0.52% to 0.22% in X memory. The corresponding error-suppression factors under maximum-likelihood decoding are 1.68 and 1.85. These results connect circuit compilation and optimization to surface-code memory performance and limitations, and motivate QPU and QEC circuit codesign for fault-tolerant quantum computing primitives on current cloud hardware.
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.
The December 2024 report of the Willow processor presented the first superconducting surface-code memory in which enlarging the code reduced the logical error rate: each step from distance three to five to seven divided the error per cycle by a suppression factor Lambda of 2.14, reaching 1.43e-3 per cycle at distance seven. A single measured suppression factor invites extrapolation, and extrapolation deserves an audit. This paper takes the published Lambda and the published distance-seven rate as fixed inputs and computes what they imply for the distances and qubit counts that algorithmic error targets demand. Holding Lambda constant, a per-cycle logical error rate of 1.00e-9 requires distance 45 and 4049 physical qubits in one rotated patch, while 1.00e-12 requires distance 63 and 7937 qubits. The mean waiting time between logical failures at distance seven is only 699 cycles, which at a microsecond-scale cycle time is well under a millisecond, so the demonstrated patch is a physics milestone rather than a computational memory. The budget also exposes the sensitivity of every projection to Lambda: because distance grows logarithmically in the target but the qubit count grows with the square of distance, a ten per cent erosion of Lambda inflates the largest patches by roughly a quarter. Suppression factors, not raw physical error rates, are therefore the currency in which fault-tolerant overhead should be quoted.
Quantum processors are often compared by the number of physical qubits they contain. That number, however, does not by itself indicate whether a processor can execute a useful computation reliably. Qubit coherence, gate and measurement fidelity, connectivity, control infrastructure, fabrication yield, and the overhead of quantum error correction all influence practical capability. This paper presents a structured comparative review of six major quantum-computing modalities: superconducting circuits, trapped ions, photonic systems, silicon-spin qubits, neutral atoms, and topological approaches. It examines their physical implementations, operational strengths, engineering constraints, and prospects for scaling. Particular attention is given to surface-code error correction and the 105-qubit Willow processor result reported by Google Quantum AI, which demonstrated below-threshold surface-code memory and a logical-error suppression factor of 2.14 ± 0.02 when code distance increased by two. The paper also considers cryogenic control, wiring, modular interconnects, fabrication variability, real-time decoding, and the Indian National Quantum Mission. The review finds that progress towards fault tolerance is best assessed through logical performance and system-level engineering rather than physical-qubit count alone. No modality currently removes the need to address scaling overhead, reliable operations, and application-level advantage