Quantum error correction below the surface code threshold

error each time distance is increased by 2. If you want to track progress in quantum computing, follow the gradual spinup of fault tolerance. Noise is the main thing blocking factoring of larger and larger numbers. Once the quality problem is turned into a quantity problem, then those benchmarks can start moving. [0]: https://www.youtube.com/watch?v=nJxENYdsB6c [1]: https://arxiv.org/abs/1208.0928 [2]: https://arxiv.org/abs/2505.15917 [3]: https://arxiv.org/abs/1411.7403 [4]: https://arxiv.org/abs/2408.13687

https://medium.com/asecuritysite-when-bob-met-alice/a-long-g... The missing context in the post by John is an exposition of why progress has been slow - decoherence and error rates - and what the rate of progression can be when these obstacles have been resolved. Shor's algorithm requires fault-tolerant quantum computing, which didn't exist in any form until recently. Tphysical error rate must be lower than the threshold required. Different research groups and companies, using various qubit technologies have already demonstrated techniques and elements of below-threshold error correction. https://www.nature.com/articles/s41586-024-08449-y

same error correction principles as the surface code. The repetition code acts as an advance scout for checking whether error correction will work all the way down to the near-perfect encoded error rates we’ll ultimately need. """ I'm getting the feeling that this is more about proof-of-concept, rather than near-practicality, but this is certainly one fantastic POC if true. [1]: https://arxiv.org/abs/2408.13687 [2]: https://research.google/blog/making-quantum-error-correction... Relevant quote from preprint (end of section 1, sorry for copy-paste artifacts): """ In this work, we realize surface codes operating below threshold on two superconducting processors. Using a 72-qubit processor, we implement a distance-5 surface code operating with an integrated real-time decoder. In addition, using a 105-qubit processor with similar performance, we realize a distance-7 surface code. These processors demonstrate Λ > 2 up to distance-5 and distance7, respectively. Our distance-5 quantum memories are beyond break-even, with distance-7 preserving quantum information for more than twice as long as its best constituent physical qubit. To identify possible logical error f loors, we also implement high-distance repetition codes on the 72-qubit processor, with error rates that are dominated by correlated error events occurring once an hour. These errors, whose origins are not yet understood, set a current error floor of 10−10. Finally, we show that we can maintain below-threshold operation on the 72qubit processor even when decoding in real time, meeting the strict timing requirements imposed by the processor’s fast 1.1µs cycle duration. """

August [2] and it's still not better if you take into account the error correction overhead. Challenges include scaling manufacturing, control, cooling, etc. Without fault tolerance you're into what's called NISQ (noisy intermediate scale quantum) where you just deal with errors instead of correcting them. As for now I guess we are in thousands of total gates we can apply before noise kills us. Maybe 10000 in the very very best case. Moreover the currently leading approach, superconducting qubits (Google, IBM), have fixed connectivity and applying gate on two disconnected qubits have additional overhead. Alternative approaches (Quantinuum's ion, QuEra cold atoms) don't have these limitations but have others. The killer application for NISQ, in my opinion, are quantum simulations, i.e. simulations of quantum systems with quantum computers. Our ability to simulate quantum systems are fairly limited by the exponential growth of the state space, and smarter algorithms have their limitations, and you always simplify the model significantly. There may be some insights in simulating more complicated models. One obvious use for that is chemistry, but classical chemical algorithms are very well developed and classical computers are huge compared to quantum ones. Also chemical simulations require relatively deep circuits (N^3 scaling I believe), which is the main limitation of NISQ. Simulations for physical models (say, Hubbard model) are probably easier, but using this to justify billions spent would be hard. These applications in my opinion are pretty close (a number of years) to the moment you have real advantage (i.e., solve a problem in this domain nobody can solve classically), but this is optimistic opinion. There are also applications for which the advantage may be there but we are not sure. Optimization is one example, though I think optimization on classical data will never close the vast resource gap (we have trillions of transistors in classical clusters vs hunders of qubits), even if there is advance. Optimization on quantum data probably is better on quantum computers, but again, not much pressing problems there. For the fully fault tolerant the best known example is factorization. It is definitely better complexity then any algorithm we have classically, good enough to expect realistically sized QC one day will beat any classical computer. That said, while this has clear consequences from security standpoint, breaking some cryptography schemes it not exactly the most exciting thing IMHO, and people will switch to post quantum crypto way before (there was a recent work that could break existing PQC, but there was a bug in it [3]). There is Grover's algorithm for search but I doubt practical advantages there. All in all it may sound a bit pessimistic, but I think if the technology arrives people will figure out how to use it. [1] https://www.xprize.org/prizes/qc-apps [2] https://arxiv.org/abs/2408.13687 [3] https://eprint.iacr.org/2024/555

of Λ = 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.3. We maintain 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. To probe the limits of our error-correction performance, we 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 × 109 cycles. Our results present device performance that, if scaled, could realize the operational requirements of large scale fault-tolerant quantum algorithms.

Scott mentioned, which has absolutely no chance of scaling.) You say you don't see the uranium piling up. Okay. Consider the historically reported lifetimes of classical bits stored using repetition codes on the UCSB->Google machines [1]. In 2014 the stored bit lived less than a second. In 2015 it lived less than a second. 2016? Less than a second. 2017? 2018? 2019? 2020? 2021? 2022? Yeah, less than a second. And this may not surprise you but yes, in 2023, it also lived less than a second. Then, in 2024... kaboom! It's living for hours [4]. You don't see the decreasing gate error rates [2]? The increasing capabilities [3]? The ever larger error correcting code demonstrations [4]? The front-loaded costs and exponential returns inherent to fault tolerance? TFA is absolutely correct: the time to start transitioning to PQC is now. [0]: https://www.nature.com/articles/414883a [1]: https://algassert.com/assets/2025-12-24-qec-foom/plot-half-l... (from https://algassert.com/post/2503 ) [2]: https://arxiv.org/abs/2510.17286 [3]: https://www.nature.com/articles/s41586-025-09596-6 [4]: https://www.nature.com/articles/s41586-024-08449-y

https://arxiv.org/abs/1208.0928 [1]: fig 1c of https://arxiv.org/pdf/2207.06431 [2]: fig 1b of https://arxiv.org/pdf/2408.13687 [3]: https://arxiv.org/abs/2511.05465 [4]: https://quantum.cloud.ibm.com/computers?processorType=Heron (numbers may vary as the website is not static) [5]: https://arxiv.org/abs/2304.05420

time. Maybe you'll be dead before progress exceeds the coarseness of factoring. If it takes a year instead of decade (because the cost of error correction is frontloaded) then, well, pay appropriate attention to that. [1]: https://arxiv.org/abs/1411.7403 [2]: https://arxiv.org/abs/2408.13687