Surface codes: Towards practical large-scale quantum computation

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

algorithm failing is at most R^2. For example, if R is less than 1 degree then the chance of algorithm failure will be less than 0.03%. That's an acceptable retry chance for Shor's algorithm. The QFT circuit on N qubits performs less than N^2 rotations. So, for R to be less than 1 degree, it's sufficient for each rotation's error X to be less than (1°)/N^2. Therefore the required precision only increases polynomially (like N^2) instead of exponentially (like 2^N). Note the required precision can be improved from O(1/N^2) to O(1/N) using techniques like the qubit recycling QFT [4]. Actually, even if the required precision scaled exponentially, that still wouldn't be an insurmountable problem. Quantum error correction achieves exponentially tighter tolerances from polynomially increasing resources. For example, Ross and Selinger proved that continuous rotations can be approximated to a target error of epsilon using O(log(1/epsilon)) gates from the discrete gate set Clifford+T [4]. And Clifford gates with error below epsilon can be achieved in the surface code using O(log(1/epsilon)^2) noisy qubits for O(log(1/epsilon)) time [5]. And T gates can be achieved by using those reliable Clifford gates to perform magic state distillation of log(1/epsilon)^O(1) T states [6]. Since everything scales polynomially in log(1/epsilon), making epsilon exponentially smaller adds polynomial resources. There is no part of Shor's algorithm that requires resources growing exponentially in n (the number of digits of the number being factored). The practical scaling is more like n^3: factoring a number that's twice as large can be done with ~two times as many qubits running for ~four times as long. Even if the qubits are noisy [7]. [1]: https://en.wikipedia.org/wiki/Quantum_Fourier_transform#/med... [2]: https://arxiv.org/abs/quant-ph/0306018 [3]: https://arxiv.org/abs/quant-ph/9601018 [4]: https://arxiv.org/pdf/quant-ph/9903071#page=12 [5]: https://arxiv.org/abs/1208.0928 [6]: https://arxiv.org/abs/1209.2426 [7]: https://arxiv.org/abs/1905.09749

a junction, but the accuracy is limited by the precision of the resistance. Whereas a digital classical computer will decompose the addition problem into bits and gain more precision by adding bits so that increasing precision becomes about increasing quantity instead of quality. [1]: https://www.mathstat.dal.ca/~selinger/newsynth/ [2]: https://arxiv.org/abs/1208.0928

unintended measurement. So protecting a qubit tends to require special physical properties, like the energy gap of a superconductor, or complex error correction strategies like surface codes. A surface code can easily use 1000 physical qubits to store 1 logical qubit [2], and I wanted to contrast that with the sizes of implicit repetition codes used in classical computing. 1: https://web.mit.edu/rec/www/dramfaq/DRAMFAQ.html 2: https://arxiv.org/abs/1208.0928