Quantum error correction: logical qubits, the threshold, and how far hardware has come
Quantum error correction stores one logical qubit in many physical qubits and measures parity checks on them over and over, so that errors can be found and undone without reading the stored information. It pays off only when the physical error rate is below a threshold: then every step up in code size divides the logical error rate by a constant factor, and a computation of any length becomes possible in principle. Google's Willow chip, a superconducting chip at USTC, Harvard and QuEra's neutral atoms and Quantinuum's trapped ions have all shown logical errors that fall as the code grows, the clearest progress in the field. None has yet run a long computation on many logical qubits, which is what factoring, chemistry and the quadratic speed-ups in finance need.
Updated
At a glance
- What it is
- One logical qubit spread over many physical qubits, parity checks measured on them every cycle, and a classical decoder that works out from the check results which errors happened
- The threshold
- A physical error rate below which a bigger code gives a better logical qubit. For IBM's qLDPC codes under a standard circuit noise model it is 0.8%[18], on par with the surface code
- Below threshold, in one number
- , the factor by which the logical error rate falls each time the code distance grows by two. means the hardware is below threshold, and the larger it is, the fewer qubits a target error rate costs
- Best surface-code memory
- Google's Willow chip at distance 7: 0.143% error per cycle[5] and [5], with a decoder that kept up in real time at distance 5
- Lowest logical error per cycle we found
- Quantinuum's Helios with a distance-7 colour code: per cycle[15] and [15], in a preprint, decoded after the run
- What applications need
- Error rates below [5] per operation for many algorithms, and thousands of logical qubits in published estimates such as derivative pricing, at 8k logical qubits[30]
- Not shown yet
- A long algorithm on many logical qubits with a universal gate set, every run kept and the decoder keeping pace. That is what fault-tolerant quantum computing means, and no machine does it today
Why physical qubits need error correction
Every gate on a physical qubit fails now and then. On Quantinuum's Helios, a trapped-ion machine with 98 qubits[12], a two-qubit gate fails with probability [12] on average, about one in a thousand. Google's team puts the gap plainly: the best many-qubit platforms only recently reached 99.9%[5] fidelity for entangling gates, far from the error rates below [5] that many applications need. A computation with operations needs an error per operation well below to finish without a fault, and the field's stated aim is computations of more than 100 million operations[10]. Better hardware alone will not close a gap of six or more orders of magnitude.
Classical computers protect bits by copying them and taking a majority vote. A qubit cannot be copied, and measuring it to check it destroys the superposition it holds. Its errors are also continuous: a qubit can drift by a small angle, not only flip. Quantum error correction gets around all three. It entangles the information of one logical qubit across many physical qubits, then measures only parities of small groups of them (in the jargon, stabilizers). A parity says whether neighbours agree, not what any of them holds, so the logical state survives the check. And the measurement itself forces a small continuous error to become either no error or a full bit flip or phase flip, which can be corrected.
The parity results of each round, the syndrome, go to a decoder: a classical algorithm that looks at the history of syndromes and infers the most likely set of errors. The correction is often applied in software, by reinterpreting later measurements, rather than by pulsing the qubits. The surface code, the most studied code, needs only parity checks between nearest neighbours on a square grid, which suits chips whose qubits cannot reach far[3][4].
The threshold theorem, and what below threshold means
The threshold theorem is the reason anyone builds quantum computers at all. Aharonov and Ben-Or, and independently Knill, Laflamme and Zurek, proved that an arbitrarily long quantum computation can be made arbitrarily reliable if the error per operation is below a constant threshold, by encoding qubits in codes, encoding those codes again, and doing every step in a way that keeps one fault from spreading into many[1][2]. The overhead grows only slowly with the length of the computation. Above the threshold, adding qubits adds more errors than it removes and the encoded qubit gets worse.
The threshold is not one number. It depends on the code, on the circuit that measures the checks and on the decoder[18]. For the surface code, the logical error per cycle of a code of distance follows approximately[5]
where is the physical error rate and the threshold. The ratio of logical errors at two neighbouring distances is the suppression factor . Below threshold means : each step up in distance divides the logical error by , so the error falls exponentially in while the qubit count grows only as . The size of decides the cost. With , cutting the logical error by a factor of takes about thirty steps of distance; with , nine.
Physical qubits, logical qubits and the words around them
| Term | What it means |
|---|---|
| Physical qubit | One hardware qubit: a superconducting circuit, a trapped ion or a neutral atom. Its error rate is set by the device; how the types compare is on the qubit types page. |
| Logical qubit | One qubit of information stored in a code across many physical qubits. Its error rate is set by the physical error rate, the code size and the decoder. |
| Code distance | The smallest number of physical errors that can change the logical state without the checks noticing. A code of distance corrects any errors. |
| Surface code | Data qubits on a square grid with measure qubits between them. A distance- patch uses physical qubits; Google's distance-7 memory had 49 data qubits and 48 measure qubits[5], plus four for removing leakage. |
| Logical error per cycle | The probability that the logical qubit is wrong after one round of checks and decoding. Memory experiments quote it; an algorithm cares about the error per logical gate as well. |
| Break-even | A logical qubit or operation that beats the physical one it is made of. Papers differ on which physical baseline they compare with. |
| Error detection | A code of distance 2 can notice an error but not fix it. The run is thrown away, which is post-selection. Useful for tests, but the discarded share grows with the circuit. |
| qLDPC code | A code whose checks touch few qubits but reach across the chip, so one block holds many logical qubits. IBM's gross code keeps 12 logical qubits in 288 physical qubits[18]; the surface code would need nearly 3000[18] for the same protection. |
| Magic state | Clifford gates are easy to make fault-tolerant in most codes; the T gate, needed for a universal gate set, is not. It is made by consuming a specially prepared magic state, purified by distillation or cultivation. |
| Real-time decoding | Decoding each round as fast as rounds arrive, so that the computer can act on the result. Decoding a stored record after the run is enough for a memory test, not for a computation. |
The milestones, in order
Each row is one paper, with the hardware it ran on and the caveat its own authors give or that its design implies. Preprints are marked in the sources.
| Year | Team and hardware | What was shown | Caveat |
|---|---|---|---|
| 2024 | Harvard, MIT and QuEra; neutral atoms in reconfigurable arrays, up to 280 physical qubits[8] | A logical gate that improved as the surface code grew from distance 3 to 7[8]; sampling circuits on 48 logical qubits[8] that beat their unencoded versions | The larger circuits used an error-detecting code and kept only runs with no detected error. |
| 2024 | Microsoft and Quantinuum; trapped ions | Entangled logical qubits with error rates up to 800 times lower[10] than the physical ones, and repeated rounds of correction | The largest factors depend on post-selection, as the authors say. |
| 2024 | Microsoft and Atom Computing; 256 ytterbium atoms[11] | 24 logical qubits[11] entangled while lost atoms were caught and corrected; an algorithm on 28 logical qubits[11] better than unencoded | Small codes and shallow circuits; a preprint. |
| 2025 | Google Quantum AI; Willow, a 105-qubit[5] superconducting chip | Surface-code memory below threshold: [5], 0.143% error per cycle[5] at distance 7, a logical lifetime 2.4 times[5] the best physical qubit's, real-time decoding at distance 5 | One logical qubit, storing, not computing. Rare correlated error bursts, about once an hour[5], set a floor that larger codes will meet. |
| 2025 | Google Quantum AI; superconducting chip, colour code | [6]; transversal Clifford gates adding 0.0027[6] error; magic states above 99%[6] fidelity; logical teleportation by lattice surgery | Only two distances; the magic states kept about 75%[6] of runs. |
| 2025 | USTC (Zhu, Pan and colleagues); superconducting chip | Distance-7 surface-code memory at [7], with leakage removed by microwave pulses alone | Below threshold, but with less margin than Willow. |
| 2026 | Harvard, MIT and QuEra; up to 448 neutral atoms[9] | Surface code 2.14 times[9] below threshold; transversal gates, lattice surgery and teleportation into [9] codes for a universal gate set; deep circuits with dozens of logical qubits | The below-threshold figure comes from a four-round test circuit, with a machine-learning decoder that uses detected atom loss. |
| 2026 | Quantinuum; Helios, 98[12] barium-ion qubits | Benchmarks with between 48 and 94 logical qubits[13] in high-rate error-detecting and error-correcting codes, beyond break-even | Relies on post-selection at what the authors call reasonable rates; a preprint. |
| 2026 | Google Quantum AI; Willow | Magic state cultivation: error cut by a factor of 40[17] to a state fidelity of 0.9999(1)[17], and a cultivated state moved into a distance-5 surface code | Cultivation discards by design: 8% of attempts[17] were kept. The smallest version of the protocol. |
| 2026 | Quantinuum; Helios, Helix architecture | [14] error per logical qubit per cycle and [14] per two-qubit logical Clifford gate, both better than the physical baselines with no post-selection | One code size, so no ; a preprint. |
| 2026 | Quantinuum; Helios, colour codes | Distances 3, 5 and 7 below threshold at [15], down to [15] per cycle; [15] per logical two-qubit Clifford at distance 5 | Decoded after the run, not in real time. The distance-7 figure rests on 3 failures in 29,000 shots[15], so its error bar is wide; a preprint. |
Years are those of the source. The Microsoft results and the three Helios papers are preprints; the rest are peer reviewed.
Superconducting qubits: Google's memory below threshold
The result that changed the field's mood is Google's Willow memory. The team ran surface codes of distance 3, 5 and 7 on one chip and watched the logical error fall by [5] per step, ending at 0.143% per cycle[5] on 101 physical qubits[5]. The distance-7 logical qubit outlived the chip's best physical qubit by a factor of 2.4[5]. A distance-5 version ran with a real-time decoder at an average latency of 63 microseconds[5] over up to a million cycles of 1.1 microseconds[5], and stayed below threshold. It was the first surface-code memory to get better at the rate the threshold theorem predicts as the code grew.
The same paper names the limit. Repetition codes up to distance 29[5] hit rare correlated error events about once an hour, or every cycles[5], which no code of fixed size removes. A team at USTC then showed a distance-7 surface code below threshold on its own chip, at [7], using only microwave control to return leaked qubits to their two working levels. Google's colour-code experiment added logic: transversal Clifford gates, injected magic states and teleportation between logical qubits by lattice surgery, with suppression of 1.56[6] from distance 3 to 5.
Neutral atoms: many logical qubits, moved around
Atoms held in optical tweezers can be moved mid-circuit, so any qubit can meet any other, and a gate can be applied to every qubit of a code block at once. Harvard, MIT and QuEra used this to build a processor that ran algorithms on logical qubits, with up to 280 physical qubits[8], 48 logical qubits[8] in error-detecting codes and 48 logical CCZ gates[8] in one sampling circuit. Error detection here means runs with a flagged error were dropped, which is honest for a demonstration and does not scale to long circuits.
The follow-up, with up to 448 atoms[9], assembled the elements of a universal fault-tolerant architecture: surface codes 2.14 times[9] below threshold over a short test circuit, logical entanglement by transversal gates and lattice surgery, universal logic through teleportation with [9] codes, and reuse of qubits mid-circuit that raised the experiment's cycle rate by two orders of magnitude[9]. Microsoft and Atom Computing took a different route on ytterbium atoms, converting the main errors into atom loss that a camera can see, and entangled 24 logical qubits in 48 atoms[11].
Trapped ions: the lowest logical error rates
Trapped ions have some of the most accurate physical gates and all-to-all connectivity, at the price of slower operations than superconducting chips. Their logical results have climbed fast. Microsoft and Quantinuum reported entangled logical qubits with error rates 4.7 to 800 times lower[10] than physical ones, the range set by how much post-selection was used. On Helios, Quantinuum ran benchmarks with 48 to 94 logical qubits[13] in high-rate codes that spend only two extra qubits per block, again with post-selection.
Two later preprints carry the strongest numbers. With a compact code that holds two logical qubits in a block of 20 data qubits[14], Helios kept memory at [14] error per logical qubit per cycle and ran the full two-qubit Clifford group at [14] per gate, both better than the physical baselines, with no runs thrown away. With colour codes of distance 3, 5 and 7, the logical error per cycle fell from [15] to [15] to [15], a suppression factor of 12[15]. That is far above any superconducting result, and it means a target error rate needs a much smaller code. The caveats are in the paper: all decoding was done after the run, the distance-7 point rests on a handful of failures, and the experiment stored a logical qubit for 20 rounds[15] rather than computing with it.
IBM and qLDPC codes: fewer physical qubits per logical qubit
The surface code spends one patch of about qubits on every logical qubit. IBM's bet is a family of quantum low-density parity-check codes, the bivariate bicycle codes. The best known, the gross code, stores 12 logical qubits in 288 physical qubits[18] for nearly a million cycles[18] at a physical error rate of 0.1%[18] in simulation, where the surface code would need nearly 3000[18]. The catch is connectivity: each qubit talks to six others[18], some far across the chip. IBM's architecture paper builds a full instruction set on these codes and estimates that an order of magnitude larger[19] logical circuits fit in a given number of physical qubits than with the surface code.
The hardware is the part still to come. IBM's Loon chip carries the long-range couplers the codes need and, in IBM's words, demonstrated all the key processor components[21] for fault tolerance. On decoding, an FPGA prototype of IBM's Relay-BP decoder reaches a belief-propagation iteration in 24 ns[20], fast enough for an average decoding time under 1 microsecond per cycle[20] on the gross code if physical errors stay below [20], and IBM reports real-time decoding in less than 480 nanoseconds[21]. We found no published hardware memory experiment with the gross code by this page's date; the roadmap below places it next.
Beyond memory: logical gates, magic states and real-time decoding
A memory is the easy half. A computer also needs logical gates, and a universal set needs one gate outside the Clifford group, usually the T gate, which most codes cannot apply directly. It is made by preparing a magic state and teleporting it into the circuit. Distillation, the classic recipe, takes large factories of qubits. Cultivation, proposed by Gidney, Shutty and Jones, grows one magic state inside a surface-code patch at roughly the cost of a logical CNOT, and in simulation reaches [16] at [16] circuit noise. Google then ran it on Willow: the error fell by a factor of 40[17] to a fidelity of 0.9999(1)[17], keeping 8%[17] of attempts, which is how cultivation is meant to work. Harvard and QuEra reached universality another way, by teleportation through codes with a transversal T gate[9].
Decoding must keep pace too. A superconducting surface code produces a new syndrome every 1.1 microseconds[5], and a computation that waits on a slow decoder stalls. Google's real-time decoder kept up at distance 5 with a 63-microsecond[5] average latency. Quantinuum's colour-code paper tested neural-network decoders that run an order of magnitude faster[15] than its syndrome rounds, though its published numbers came from offline decoding. IBM's FPGA work aims at the same goal for qLDPC codes[20].
What error correction means for applications
The algorithms with the strongest case for a quantum speed-up all assume a fault-tolerant machine. Factoring is the clearest benchmark of how fast the requirements are falling. Gidney and Ekerå estimated in 2019 that factoring a 2048-bit RSA key would take 20 million noisy qubits[26] for eight hours[26]. Gidney's update cut that to less than a million noisy qubits[26] running for less than a week[26], under the same assumptions, thanks to better arithmetic, denser storage of idle logical qubits and magic state cultivation. Later preprints with other codes and hardware go lower still; the table lists them with what they assume.
Finance is further away. Amplitude estimation needs quadratically fewer queries than Monte Carlo, but the most complete estimate for a derivative a bank would price needs 8k logical qubits[30] and a T-depth of 54 million[30], with T gates at 10 MHz[30] against logical clock rates of about 10 kHz[30] in the estimates it cites. Babbush and colleagues argue that quadratic speed-ups like this one will not pay on early fault-tolerant machines, because error correction makes each logical step so slow[31]. The amplitude estimation versus Monte Carlo comparison measures the query gap on a simulator, the option pricing page follows these estimates further, and the HHL page shows the same pattern for linear systems.
The gap is still wide. The experiments above hold at most a few dozen error-corrected logical qubits, or store one logical qubit at the error rates quoted, or run a few logical gates. The estimates need hundreds to thousands of logical qubits with far lower error, running nonstop for hours or days with real-time decoding. What has changed is that the shape of the path is now measured, not only predicted: on several platforms, a bigger code gives a better qubit. For chemistry, the first calculation on error-corrected qubits and the estimates for molecules such as FeMoco are on the quantum computing for chemistry page.
Resource estimates that need fault tolerance
Each estimate assumes hardware that does not exist yet; the assumptions matter as much as the totals. Cat qubits suppress bit flips in hardware, so they are not counted on the same footing as the others.
| Workload | Estimate | What it assumes | Source |
|---|---|---|---|
| Factoring RSA-2048, surface code | less than a million noisy qubits[26], less than a week[26] | Square grid, nearest neighbours, 0.1%[26] gate error, 1 microsecond[26] cycle, 10 microseconds[26] reaction time | Gidney, preprint[26] |
| Factoring RSA-2048, qLDPC codes | fewer than one hundred thousand physical qubits[27] | The same error rate, cycle and reaction time, with the long-range connectivity qLDPC codes need | Webster et al., preprint[27] |
| Shor's algorithm on neutral atoms | as few as 10,000 reconfigurable atomic qubits[28]; P-256 discrete logarithms in a few days[28] with 26,000[28] | High-rate codes on movable atoms; RSA-2048 runs one to two orders of magnitude longer[28] than P-256 | Cain et al., preprint[28] |
| Factoring RSA-2048, cat qubits | about 23 000 cat qubits[29], 3.14 days[29] | No bit flips (a bit-flip time of about 100 years[29]), phase-flip probability [29]; about 45 000[29] qubits if bit flips come about hourly | Pappalardo et al., ePrint[29] |
| Pricing an autocallable derivative | 8k logical qubits[30], T-depth 54 million[30] | A price in about 1 second[30] to beat Monte Carlo, so T gates at 10 MHz[30] | Chakrabarti et al.[30] |
Roadmaps: what vendors plan to build
These are plans, not results, quoted as the companies state them. IBM plans Starling for 2029[23]: 100 million gates on 200 logical qubits[22], built in Poughkeepsie from qLDPC modules. On the way, Kookaburra, scheduled for 2026[22], is to be the first module that stores information in a qLDPC memory and processes it with an attached logical processing unit, and Blue Jay, from 2033[23], is to run 1 billion gates on up to 2000 qubits[23].
Quantinuum targets hundreds of logical qubits at about logical error by 2029[24], in a machine it calls Apollo, its planned universal fault-tolerant quantum computer[25]. A roadmap is worth what the company's record of hitting its earlier milestones is worth; check the dated steps along the way, not only the end point.
How to read an error-correction claim
Press releases on error correction compress a paper into one record number. Eight questions put the context back.
Memory or computation?
Most records store a logical qubit and read it back. Logical gates, especially the non-Clifford ones, and circuits that use many logical qubits together are harder and come later. A memory record says little about the error of an algorithm.
Corrected, or detected and discarded?
An error-detecting code throws away every run with a flagged error. The result can look excellent while most runs are dropped, and the share dropped grows with the circuit. Ask what fraction was kept: the Microsoft and Quantinuum experiment above reported 4.7 to 800 times[10] improvements depending on how much post-selection was allowed.
Per what?
Per cycle, per gate, per shot, per logical qubit or per code block: the same experiment gives different numbers on each basis. Compare like with like, and check how many cycles the experiment ran.
Does it scale?
A single code size proves break-even at most. Below threshold is shown by a logical error that falls as the distance grows, ideally over three or more distances, with the suppression factor quoted with its uncertainty.
Decoded in real time?
Decoding a stored record afterwards, with an algorithm that may be too slow for live use, is standard for memory tests. A computer must decode as fast as syndromes arrive. Look for the decoder's latency against the cycle time.
Better than what?
Break-even against the best physical qubit, the average one or a physical gate are different claims. Read which baseline the paper uses.
How fast is a cycle?
The run time of an algorithm scales with the cycle time. Resource estimates such as Gidney's assume a 1-microsecond[26] cycle; check whether the platform behind a claim can come close.
Paper, preprint or press release?
Several of the strongest results on this page are preprints. Use the figures in the paper with its own error bars, and treat a number that appears only in a press release as unchecked.
Questions
What is quantum error correction?
It is a way to store quantum information in many physical qubits so that errors on a few of them can be found and undone. The computer repeatedly measures parities of small groups of qubits, which reveal where errors happened without revealing the stored state, and a classical decoder works out the correction.
What does below threshold mean in quantum error correction?
It means the physical error rate is low enough that making the code bigger makes the logical qubit better. Below threshold, each step up in code distance divides the logical error rate by a constant factor, so errors fall exponentially while the qubit count grows only polynomially. Above threshold, a bigger code is worse.
What is the difference between a physical qubit and a logical qubit?
A physical qubit is one piece of hardware, such as a superconducting circuit, an ion or an atom. A logical qubit is one qubit of information encoded across many physical qubits by an error-correcting code. Its error rate can be far lower than that of the physical qubits it is made of, if the hardware is below threshold.
How many physical qubits does a logical qubit need?
It depends on the code and on how far the hardware is below threshold. A surface code of distance d uses about twice d squared physical qubits, and Google's distance-7 memory used 101. High-rate codes store several logical qubits per block: IBM's gross code keeps 12 logical qubits in 288 physical ones. The lower the physical error, the smaller the code needed for a given logical error.
Has anyone built a fault-tolerant quantum computer?
Not yet. Several groups have shown logical qubits that improve as the code grows, logical gates better than physical ones, and magic states for a universal gate set. No machine has yet run a long algorithm on many logical qubits with real-time decoding and every run kept. IBM and Quantinuum both plan such machines for 2029, which are targets, not results.
When will error-corrected quantum computers break RSA?
No one can give a date. Published estimates for RSA-2048 have fallen from millions of noisy qubits to under a million with the surface code, and preprints with other codes and hardware go lower, but each assumes error rates, speeds and qubit counts no machine has reached. The largest experiments so far hold at most a few dozen error-corrected logical qubits.
Sources
- D. Aharonov, M. Ben-Or. Fault-tolerant quantum computation with constant error rate. SIAM Journal on Computing 38, 1207–1282, 2008. arXiv:quant-ph/9906129.
- E. Knill, R. Laflamme, W. H. Zurek. Resilient quantum computation: error models and thresholds. Proceedings of the Royal Society A 454, 365–384, 1998. arXiv:quant-ph/9702058.
- E. Dennis, A. Kitaev, A. Landahl, J. Preskill. Topological quantum memory. Journal of Mathematical Physics 43, 4452–4505, 2002. arXiv:quant-ph/0110143.
- A. G. Fowler, M. Mariantoni, J. M. Martinis, A. N. Cleland. Surface codes: towards practical large-scale quantum computation. Physical Review A 86, 032324, 2012. arXiv:1208.0928.
- R. Acharya et al. (Google Quantum AI and collaborators). Quantum error correction below the surface code threshold. Nature 638, 920–926, 2025. arXiv:2408.13687.
- N. Lacroix et al. (Google Quantum AI and collaborators). Scaling and logic in the colour code on a superconducting quantum processor. Nature 645, 614–619, 2025. arXiv:2412.14256.
- T. He, W. Lin, R. Wang, Y. Li et al., X.-B. Zhu, J.-W. Pan. Experimental quantum error correction below the surface code threshold via all-microwave leakage suppression. Physical Review Letters 135, 260601, 2025.
- D. Bluvstein, S. J. Evered, A. A. Geim, S. H. Li, H. Zhou, T. Manovitz et al., M. D. Lukin. Logical quantum processor based on reconfigurable atom arrays. Nature 626, 58–65, 2024. arXiv:2312.03982.
- D. Bluvstein, A. A. Geim, S. H. Li, S. J. Evered, J. P. Bonilla Ataides et al., M. D. Lukin. A fault-tolerant neutral-atom architecture for universal quantum computation. Nature 649, 39–46, 2026. arXiv:2506.20661.
- A. Paetznick, M. P. da Silva, C. Ryan-Anderson, J. M. Bello-Rivas et al., K. M. Svore. Demonstration of logical qubits and repeated error correction with better-than-physical error rates. arXiv preprint, 2024. arXiv:2404.02280.
- B. W. Reichardt, A. Paetznick, D. Aasen, I. Basov et al., B. J. Bloom. Fault-tolerant quantum computation with a neutral atom processor. arXiv preprint, 2024. arXiv:2411.11822.
- A. Ransford, M. S. Allman, J. Arkinstall, J. P. Campora et al., J. G. Bohnet. A 98-qubit trapped-ion quantum computer with all-to-all connectivity. Nature 655, 81–86, 2026. arXiv:2511.05465.
- S. Dasu, M. DeCross, A. Y. Guo, A. Lavasani et al., D. Amaro. Computing with many encoded logical qubits beyond break-even. arXiv preprint, 2026. arXiv:2602.22211.
- N. Berthusen, A. Lavasani, A. Benhemou, M. S. Allman et al., A. C. Potter. Experimental validation of a compact fault-tolerant architecture for trapped ions. arXiv preprint, 2026. arXiv:2609.03194.
- A. Lavasani, A. P. Reed, J. M. Dreiling, A. J. Park et al., A. C. Potter. Quantum error correction well below the color code threshold. arXiv preprint, 2026. arXiv:2610.24077.
- C. Gidney, N. Shutty, C. Jones. Magic state cultivation: growing T states as cheap as CNOT gates. arXiv preprint, 2024. arXiv:2409.17595.
- E. Rosenfeld, C. Gidney, G. Roberts, A. Morvan et al., K. J. Satzinger. Magic state cultivation on a superconducting quantum processor. Science, eaee7961, 2026. arXiv:2512.13908.
- S. Bravyi, A. W. Cross, J. M. Gambetta, D. Maslov, P. Rall, T. J. Yoder. High-threshold and low-overhead fault-tolerant quantum memory. Nature 627, 778–782, 2024. arXiv:2308.07915.
- T. J. Yoder, E. Schoute, P. Rall, E. Pritchett, J. M. Gambetta, A. W. Cross, M. Carroll, M. E. Beverland. Tour de gross: a modular quantum computer based on bivariate bicycle codes. arXiv preprint, 2025. arXiv:2506.03094.
- T. Maurer, M. Bühler, M. Kröner, F. Haverkamp, T. Müller, D. Vandeth, B. R. Johnson. Real-time decoding of the gross code memory with FPGAs. arXiv preprint, 2025. arXiv:2510.21600.
- IBM. IBM delivers new quantum processors, software, and algorithm breakthroughs on path to advantage and fault tolerance. IBM Newsroom (press release), 2025.
- R. Mandelbaum, J. Gambetta, J. Chow, T. Mittal, T. J. Yoder, A. Cross, M. Steffen. How IBM will build the world's first large-scale, fault-tolerant quantum computer. IBM Quantum blog, 2025.
- IBM. IBM Quantum roadmap: deliver large-scale fault-tolerant quantum computers. IBM roadmap page, 2026.
- Quantinuum. From memory to logic. Quantinuum blog, 2025.
- Quantinuum. Fidelity first in the quantum race. Quantinuum blog, 2026.
- C. Gidney. How to factor 2048 bit RSA integers with less than a million noisy qubits. arXiv preprint, 2025. arXiv:2505.15917.
- P. Webster, L. Berent, O. Chandra, E. T. Hockings, N. Baspin, F. Thomsen, S. C. Smith, L. Z. Cohen. The Pinnacle Architecture: reducing the cost of breaking RSA-2048 to 100 000 physical qubits using quantum LDPC codes. arXiv preprint, 2026. arXiv:2602.11457.
- M. Cain, Q. Xu, R. King, L. R. B. Picard, H. Levine, M. Endres, J. Preskill, H.-Y. Huang, D. Bluvstein. Shor's algorithm is possible with as few as 10,000 reconfigurable atomic qubits. arXiv preprint, 2026. arXiv:2603.28627.
- A. Pappalardo, D. Goudarzi, V. Hertz, H. Jacinto, L. Kroell, A. Schrottenloher, P. Shanahan, É. Gouzien, R. de La Vieuville, V. Londe. Shor's algorithm compiled on cat qubits: 22 593 qubits for RSA-2048 in 3.14 days. Cryptology ePrint Archive, Paper 2026/2665 (preprint), 2026.
- S. Chakrabarti, R. Krishnakumar, G. Mazzola, N. Stamatopoulos, S. Woerner, W. J. Zeng. A threshold for quantum advantage in derivative pricing. Quantum 5, 463, 2021. arXiv:2012.03819.
- R. Babbush, J. R. McClean, M. Newman, C. Gidney, S. Boixo, H. Neven. Focus beyond quadratic speedups for error-corrected quantum advantage. PRX Quantum 2, 010103, 2021. arXiv:2011.04149.
Run it yourself with eigenkit
eigenkit is EigenOrbit's open-source Python library: write a circuit once, run it on any simulator or QPU, and test it against a classical baseline on your own data before you invest in it or rule it out.
$ pip install eigenkit