1. The short version, what to know first, and where this fits in the series

• Read logical-qubit counts with their conditions: a logical qubit is "one low-error qubit protected by many physical qubits". But "N logical qubits" has no fixed meaning unless it says whether errors were corrected or merely detected and discarded, which code, and what logical error rate. For example, Quantinuum's 2026 experiment reports 48 error-corrected logical qubits, and up to 94 if error detection alone is counted, from 98 physical qubits Sourced [Ref. 17]
• Fault-tolerant computing needs logical gates and magic states: to compute while protected you need operations that do not break the code (logical gates). Only the T gate is especially costly, and its raw material is the magic state. The physical qubits required vary from under 1 million to tens of millions depending on assumptions Sourced [Ref. 9, 10, 11]
• New codes and plans are still work in progress: qLDPC codes promise fewer physical qubits but need links between distant qubits. IBM plans 200 logical qubits in 2029, but that is a plan Not yet confirmed [Ref. 32]

2. Physical and logical qubits — what is inside "one", and how to read the numbers

(1) An everyday example: keeping one vital document in several safes

Suppose you keep one irreplaceable document in ten separate safes and check every day only that "it agrees with the others". If one safe fails, you can rebuild it from the rest. A physical qubit is "one safe". A logical qubit is "the one document protected by all the safes together". The analogy has a limit. A qubit cannot be copied like a document. As the previous article showed, the information is spread over entangled qubits, and only the "disagreements" are measured.

As the figure shows, a physical qubit is a qubit of the real device, with about 10⁻³ error per operation [Ref. 1]. A logical qubit is a low-error qubit built on top of a code and a decoder. On top of that come logical gates (operations on logical qubits), and finally the algorithm. "N logical qubits" counts this middle layer.

(2) Three checks for reading "N logical qubits"

1. Were errors "corrected", or "detected" and discarded? An error-detecting code removes errors from the surviving results by throwing away runs where an error was found (post-selection). That is different from error correction, which fixes errors and carries on
2. Which code, what distance, what logical error rate? A distance-2 code can detect an error but cannot correct even one
3. What was the experiment? Was a logical qubit merely stored (memory), or was a computation with logical gates carried out?

Take the example in the figure. Suppose 10% of runs are flagged as suspect and discarded in each layer. After 20 layers, 0.9²⁰ ≈ 12% remain (about 12 of 100 runs; Our calculation). Post-selection is handy and effective for shallow circuits, but as the circuit deepens, the usable results fall exponentially. Deep computations need error correction that does not discard (our commentary).

(3) How many physical qubits per logical qubit?

The ratio of "physical per logical" varies enormously between codes. The table below lists examples we could confirm. Experiments, simulations and proposals are mixed, so watch the category column.

The ratio is a simple division, physical qubits ÷ logical qubits (Our calculation). Code distance, logical error rate and what was measured all differ, so a row with a smaller ratio is not thereby "better".

3. Estimates of the physical qubits needed — assumptions change the order of magnitude

(1) First, a simple calculation to get the order of magnitude

A surface-code logical qubit of distance d uses 2d²−1 physical qubits. As the previous article showed, Google estimates that a logical error of 10⁻⁶ needs distance 27, that is 1457 qubits [Ref. 1]. Now take 1000 logical qubits: 1457 × 1000 = about 1.46 million (Our calculation; a minimum estimate that leaves out magic-state factories and space for wiring and movement). So "number of logical qubits" × "physical qubits per logical qubit" quickly reaches millions.

(2) Researchers' estimates vary widely with assumptions and the "task"

In practice the number depends on the content of the computation (how many T gates, how many qubits are used at once), the physical error rate, the cycle time and the run time. The table lists the estimates we could confirm.

Values are as stated in each paper's abstract. "RSA" is used as an example workload; this article does not cover attack procedures and does not predict when encryption might be broken (migration of cryptography is covered in "Migrating to Post-Quantum Cryptography" in this series).

4. Recent experiments (as of 16 October 2026)

In the last few years, logical-qubit experiments have moved from "protecting one" to "running dozens and trying logical gates and magic states". The table lists the main papers we could confirm. The platforms, codes, ways of measuring and use of post-selection all differ, so do not line the numbers up to rank them. Preprints (not yet peer reviewed) are marked as such.

Values are as stated in each paper's abstract or text (notation as in the original). The preprints of June and September 2026 are not peer reviewed and may change. The organisation of the table is ours.

What is not yet shown: within the range we checked, we could not find an experiment that ran a deep computation including non-Clifford gates on error-corrected logical qubits, combined with real-time decoding. Most of the experiments above test the parts (memory, gates, magic states) one at a time.

5. What fault-tolerant computing needs — logical gates and magic states

(1) What "fault tolerant" means

Fault tolerant means designing so that the error-correction procedure itself may occasionally err, and so that errors do not spread as operations proceed. Preskill explains that "recovery works even if mistakes are made now and then during the recovery" and that "encoded information can be processed without serious propagation of errors" Sourced [Ref. 2]. If a single error doubled to two, then four, with each operation, correction could not keep up. Logical gates are built carefully so that this does not happen.

(2) How logical gates are built — three approaches

The grouping of approaches is our commentary (sources are the references in each cell). The experimental column corresponds to the results in the table of Section 4.

(3) Clifford gates versus the T gate

Some logical gates are easy to build and some are especially hard. Put simply, operations that turn the arrow in 90-degree steps (Hadamard, S, CNOT and so on, called Clifford gates) are easy to build in many codes, while an "in-between" rotation such as 45 degrees (the T gate) is hard.

The reason is in the figure. With Clifford gates alone, the arrow can reach only six directions: north, south, east, west, front and back. Only when a 45-degree rotation is added can combinations approach any direction. And as Eastin and Knill showed, for a code that can detect errors, transversal gates alone cannot be universal [Ref. 8]. The T gate needs another method. That Clifford gates plus the T gate allow universal computation is also explained in a review of fault-tolerant computation [Ref. 45] Sourced.

(4) Magic states — "single-use raw material" for the T gate

The standard way to do a T gate on a logical qubit is to use a special state called a magic state as a single-use part [Ref. 6]. Think of a special mould that is carefully made at another factory, shipped in, and consumed each time it is used. The analogy has a limit. A magic state is a quantum state and cannot be copied. A new one must be made every time it is used.

The problem is making magic states accurate enough. A magic state made with nearby Clifford gates is not accurate enough as it is. So a method called distillation is used. Collect many rough magic states and check them; if any check disagrees, throw the batch away; if it passes, you get one high-accuracy state (figure below). In the 15-to-1 distillation, the output error is about 35p³ (Litinski's explanation [Ref. 5]; the original scheme is by Bravyi and Kitaev [Ref. 6]).

Recently, magic state cultivation has been proposed as an alternative to distillation. It grows the size and reliability of one state step by step inside a surface-code patch. Gidney and colleagues estimate by simulation that, under uniform circuit noise of 10⁻³, reaching a logical error of 2×10⁻⁹ takes about one order of magnitude fewer qubit-rounds than earlier methods, and write that further distillation may never be needed in practice [Ref. 7] Sourced (a preprint; the authors' estimate). Gidney's 2025 estimate (Section 3) also uses this cultivation to reduce the area given to magic-state factories [Ref. 10].

(5) How far have magic-state experiments gone?

• Distillation: on neutral atoms, magic states in distance-3 and distance-5 colour codes were distilled, and the logical fidelity of the output exceeded that of the input [Ref. 19] Sourced
• Code switching: on trapped ions, a Steane-code magic state was prepared with probability 82.58% and infidelity at most 5.1(2.7)×10⁻⁴ [Ref. 20] Sourced
• Injection (superconducting): in Google's colour code, magic-state injection reached fidelity above 99% with post-selection (about 75% kept) [Ref. 30] Sourced
• Gate teleportation: a 2026 preprint realised a logical R_X(π/4) in a distance-3 surface code using magic-state injection and gate teleportation, at fidelity 0.943 (conditioned on no detected errors) [Ref. 21] Sourced

All of these are at the "a part works" stage. That magic states of the needed accuracy (say 10⁻⁹ to 10⁻¹²) can be supplied at the needed speed and volume has not yet been shown (within the range we checked).

(6) Classical processing, and time

Once a T gate is done with a magic state, its result has to be measured and used to decide the next operation. The time to read the measurement, decode it and feed it into the next instruction (the reaction time) sets how fast the computation can go. The estimates in Section 3 assume a control reaction time of 10 microseconds [Ref. 9, 10]. In Litinski's example, for a computation of T depth 10⁶ to finish in 1 second, each layer must take 1 microsecond or less (Our calculation), and that needs 330 million qubits [Ref. 4]. In other words, not only the quantum parts but also fast classical processing (decoders and control) sets the speed limit of fault-tolerant computing. The decoder discussion of the previous article connects directly to this.

6. Where qLDPC and other new codes fit

The surface code is easy to implement, but at the price of 2d²−1 physical qubits per logical qubit (previous article). So new codes that need fewer physical qubits are being studied. The best known are qLDPC codes (quantum low-density parity-check codes). Like the surface code, a qLDPC code has each check look at only a few qubits. The difference is that the checks also reach distant qubits, which may let many logical qubits be protected by few physical qubits [Ref. 25] Sourced. On the theory side, Panteleev and Kalachev showed that "asymptotically good" qLDPC codes exist (distance and rate that both grow in proportion to the number of qubits) [Ref. 44] Sourced.

(1) IBM's gross code — a proposal and its claims

Bravyi and colleagues presented a fault-tolerant memory using a family of qLDPC codes that includes the gross code [[144,12,12]]. Under the standard circuit noise model it has a threshold of 0.8%, on a par with the surface code; one syndrome-measurement round is a depth-7 circuit of nearest-neighbour CNOT gates, and the required connectivity is a degree-6 graph (which splits into two planar graphs) Sourced [Ref. 23]. In a circuit-level simulation assuming 0.1% physical error, 12 logical qubits are kept for about a million cycles using 288 physical qubits. The authors estimate that the same suppression with the surface code would take about 3000 qubits [Ref. 23]. This is a proposal and an estimate for memory, not a demonstration on a real machine.

IBM has also described a computer design built on this code, "Tour de gross", and estimates that with the same number of physical qubits it can run logical circuits about one order of magnitude larger than surface-code architectures [Ref. 24] Sourced (a preprint; the company's estimate). In November 2025 IBM also announced "Loon", an experimental chip showing the processor components qLDPC codes need (company claim) [Ref. 31]. The design uses several low-loss wiring layers for "C couplers" that link distant qubits.

(2) High-rate codes on movable atoms and ions

Neutral atoms and trapped ions can be moved to link distant qubits (near all-to-all connectivity), so they are thought to suit qLDPC codes well. Xu and colleagues proposed a way to realise the long-range couplings of qLDPC codes by rearranging atoms [Ref. 26] Sourced. A 2026 preprint by QuEra, Harvard and MIT presents ultra-high-rate codes whose rate exceeds 1/2. For [[1152,580,≤12]] (580 logical qubits in 1152 physical), a circuit-level simulation at 0.1% physical error gives 2.9×10⁻¹¹ per logical qubit per cycle [Ref. 28] Sourced (a memory simulation, not an experiment). The construction builds on a new construction by Kasai [Ref. 29]. QuEra itself writes that this is a memory result and that not all the ingredients of fault-tolerant computation are in place [Ref. 46].

Ratios are simple divisions (Our calculation). Code distance, logical error rate and what was measured all differ, so comparison has to be made at the same logical error rate (Section 2).

7. Roadmaps and third-party evaluation (not yet confirmed)

Companies have published plans toward fault-tolerant quantum computing. Everything below is a plan or target, not an achieved fact Not yet confirmed. Plans are updated. How "logical qubits" are counted (detection or correction, distance, logical error rate) often cannot be confirmed from the published material, so the numbers cannot be lined up to rank anyone.

The table above summarises the gist of the published material. DARPA's page states that QBI is "not a competition between performers", and the stages show progress in verification, not a ranking. Company plans are checked against each company's official material, and dates are as of the check date.

8. What could not be confirmed, and a summary

What could not be confirmed

• A demonstration of deep fault-tolerant computation on real hardware: within the range we checked, we could not find an experiment that ran a deep computation including non-Clifford gates on error-corrected logical qubits together with real-time decoding.
• Completion of IBM's Kookaburra: as of the check date we could not confirm any announcement that it is complete.
• A real-machine demonstration of qLDPC codes (the gross code and others): we confirmed proposals and simulations, but not a demonstration of the gross code itself on a real machine (a trapped-ion qLDPC experiment was confirmed as a preprint).
• The definition of "logical qubit" in each company's plan: we could not confirm the code, distance or logical error rate on the official pages of IonQ and others.
• The text of ISO/IEC 4879 and the publication status of IEEE P7131: the former is paid, so we confirmed only the title and status. For the latter, we could not tell from the working group's site whether it has been published.
• Peer review of the 2026 preprints: as of the check date we could not confirm peer-reviewed versions of the Quantinuum, superconducting lattice-surgery and trapped-ion qLDPC papers.

9. How to read evaluations and standards

Progress in logical qubits and fault-tolerant computing is measured by the logical error rate (how much a logical qubit is damaged per cycle or per operation), the number of logical qubits (separating detection from correction), the fidelity of logical gates, the quality of magic states and resource estimates (physical qubits and time needed). None has a meaning unless you state the code, the distance, whether post-selection was used and what was measured (memory or computation). As for standards, we could not confirm one that directly defines how to count logical qubits. Check date: 16 October 2026.

The arrangement of the table is Our calculation (organising). Numbers, titles and publication months of standards were checked on each body's page (check date 16 October 2026). Standards texts are paid, so only titles and scope are given.

Cautions in reading (for materials engineers)

• "N logical qubits" is a different number for detection, correction and post-selection: one announcement may carry both a detection count and a correction count. Always read it together with the logical error rate and the distance
• Experiments are different from simulations and plans: the purple circles in the figure (proposals and simulations) and every company roadmap are not achieved facts. Company announcements are treated as "company claims" and non-peer-reviewed preprints are marked as such
• Resource estimates are not the performance of real machines: the order of magnitude changes with assumptions such as error rate, cycle and reaction time. That an estimate fell under the same assumptions is a different thing from achieving it on hardware
• Standards are still at the terminology stage: ISO/IEC 4879 is a terminology standard and has no legal force or power to decide pass or fail on performance (in general a standard becomes binding when cited in law or a contract; our commentary). The benchmarking standard (IEEE P7131) was a draft as of the check date

10. Glossary

11. References

1. Google Quantum AI and Collaborators "Quantum error correction below the surface code threshold", Nature 638, 920–926 (2025), DOI 10.1038/s41586-024-08449-y — doi.org/10.1038/s41586-024-08449-y
2. Preskill J. "Reliable quantum computers", Proc. R. Soc. Lond. A 454, 385–410 (1998), DOI 10.1098/rspa.1998.0167 — doi.org/10.1098/rspa.1998.0167
3. Horsman D., Fowler A. G., Devitt S., Van Meter R. "Surface code quantum computing by lattice surgery", New J. Phys. 14, 123011 (2012), DOI 10.1088/1367-2630/14/12/123011 — doi.org/10.1088/1367-2630/14/12/123011
4. Litinski D. "A Game of Surface Codes: Large-Scale Quantum Computing with Lattice Surgery", Quantum 3, 128 (2019), DOI 10.22331/q-2019-03-05-128 — doi.org/10.22331/q-2019-03-05-128
5. Litinski D. "Magic State Distillation: Not as Costly as You Think", Quantum 3, 205 (2019), DOI 10.22331/q-2019-12-02-205 — doi.org/10.22331/q-2019-12-02-205
6. Bravyi S., Kitaev A. "Universal quantum computation with ideal Clifford gates and noisy ancillas", Phys. Rev. A 71, 022316 (2005), DOI 10.1103/PhysRevA.71.022316 — doi.org/10.1103/PhysRevA.71.022316
7. Gidney C., Shutty N., Jones C. "Magic state cultivation: growing T states as cheap as CNOT gates", arXiv:2409.17595 (2024) (preprint) — arxiv.org/abs/2409.17595
8. Eastin B., Knill E. "Restrictions on transversal encoded quantum gate sets", Phys. Rev. Lett. 102, 110502 (2009), DOI 10.1103/PhysRevLett.102.110502 — doi.org/10.1103/PhysRevLett.102.110502
9. Gidney C., Ekerå M. "How to factor 2048 bit RSA integers in 8 hours using 20 million noisy qubits", Quantum 5, 433 (2021), DOI 10.22331/q-2021-04-15-433 — doi.org/10.22331/q-2021-04-15-433
10. Gidney C. "How to factor 2048 bit RSA integers with less than a million noisy qubits", arXiv:2505.15917 (2025) (preprint) — arxiv.org/abs/2505.15917
11. Lee J. et al. "Even more efficient quantum computations of chemistry through tensor hypercontraction", PRX Quantum 2, 030305 (2021), DOI 10.1103/PRXQuantum.2.030305 — doi.org/10.1103/PRXQuantum.2.030305
12. Beverland M. E. et al. "Assessing requirements to scale to practical quantum advantage", arXiv:2211.07629 (2022) (preprint) — arxiv.org/abs/2211.07629
13. Bluvstein D. et al. "Logical quantum processor based on reconfigurable atom arrays", Nature 626, 58–65 (2024), DOI 10.1038/s41586-023-06927-3 — doi.org/10.1038/s41586-023-06927-3
14. Bluvstein D. et al. "A fault-tolerant neutral-atom architecture for universal quantum computation", Nature 649, 39–46 (2025), DOI 10.1038/s41586-025-09848-5 — doi.org/10.1038/s41586-025-09848-5
15. Reichardt B. W. et al. "Fault-tolerant quantum computation with a neutral atom processor", arXiv:2411.11822 (2024) (preprint) — arxiv.org/abs/2411.11822
16. Paetznick A. et al. "Improved quantum processor logical error rates via correction and detection", Nature 654, 349–355 (2026), DOI 10.1038/s41586-026-10628-y — doi.org/10.1038/s41586-026-10628-y
17. Dasu S. et al. (Quantinuum) "Computing with many encoded logical qubits beyond break-even", arXiv:2602.22211 (2026) (preprint) — arxiv.org/abs/2602.22211
18. Berthusen N. et al. (Quantinuum) "Experimental validation of a compact fault-tolerant architecture for trapped ions", arXiv:2609.03194 (2026) (preprint) — arxiv.org/abs/2609.03194
19. Sales Rodriguez P. et al. "Experimental demonstration of logical magic state distillation", Nature 645, 620–625 (2025), DOI 10.1038/s41586-025-09367-3 — doi.org/10.1038/s41586-025-09367-3
20. Daguerre L. et al. "Experimental demonstration of high-fidelity logical magic states from code switching", Phys. Rev. X 15, 041008 (2025), DOI 10.1103/dck4-x9c2 — doi.org/10.1103/dck4-x9c2
21. Wang Y. et al. "A superconducting surface-code processor with lattice-surgery logical operations", arXiv:2606.06598 (2026) (preprint) — arxiv.org/abs/2606.06598
22. Tham E. et al. "Breakeven demonstration of quantum low-density parity-check codes", arXiv:2606.06455 (2026) (preprint) — arxiv.org/abs/2606.06455
23. Bravyi S. et al. (IBM) "High-threshold and low-overhead fault-tolerant quantum memory", Nature 627, 778–782 (2024), DOI 10.1038/s41586-024-07107-7 — doi.org/10.1038/s41586-024-07107-7
24. Yoder T. J. et al. (IBM) "Tour de gross: A modular quantum computer based on bivariate bicycle codes", arXiv:2506.03094 (2025) (preprint) — arxiv.org/abs/2506.03094
25. Breuckmann N. P., Eberhardt J. N. "Quantum low-density parity-check codes", PRX Quantum 2, 040101 (2021), DOI 10.1103/PRXQuantum.2.040101 — doi.org/10.1103/PRXQuantum.2.040101
26. Xu Q. et al. "Constant-overhead fault-tolerant quantum computation with reconfigurable atom arrays", arXiv:2308.08648 (2023) (preprint) — arxiv.org/abs/2308.08648
27. Aasen D. et al. (Microsoft) "A topologically fault-tolerant quantum computer with four dimensional geometric codes", arXiv:2506.15130 (2025) (preprint) — arxiv.org/abs/2506.15130
28. Zhao C. et al. (QuEra, Harvard, MIT) "Towards ultra-high-rate quantum error correction with reconfigurable atom arrays", arXiv:2604.16209 (2026) (preprint) — arxiv.org/abs/2604.16209
29. Kasai K. "Breaking the orthogonality barrier in quantum LDPC codes", Quantum (2026), DOI 10.22331/q-2026-09-09-2205 (arXiv:2601.08824) — arxiv.org/abs/2601.08824
30. Lacroix N. et al. (Google Quantum AI) "Scaling and logic in the colour code on a superconducting quantum processor", Nature 645, 614–619 (2025), DOI 10.1038/s41586-025-09061-4 — doi.org/10.1038/s41586-025-09061-4
31. IBM "IBM Delivers New Quantum Processors, Software, and Algorithm Breakthroughs on Path to Advantage and Fault Tolerance", press release (12 November 2025) (company announcement) — newsroom.ibm.com (2025-11-12)
32. IBM "IBM Sets the Course to Build World's First Large-Scale, Fault-Tolerant Quantum Computer at New IBM Quantum Data Center", press release (10 June 2025) (company announcement) — newsroom.ibm.com (2025-06-10)
33. IBM "IBM quantum technology" (official page; checked 16 October 2026) — ibm.com/quantum/technology
34. IonQ "IonQ roadmap" (official page; checked 16 October 2026) — ionq.com/roadmap
35. Quantinuum "Technical perspective: By the end of the decade, we will deliver universal, fully fault-tolerant quantum computing", official blog (September 2024) — quantinuum.com/blog/technical-perspective…
36. Quantinuum "Skinny Logic: Quantum Codes Go on a Diet", official blog (4 March 2026) — quantinuum.com/blog/skinny-logic-quantum-codes-go-on-a-diet
37. Google Research "Dynamic surface codes open new avenues for quantum error correction", official blog — research.google/blog/dynamic-surface-codes…
38. Microsoft Quantum "From research to product: logical-qubit demonstrations shaping Microsoft's utility-scale quantum software platform", official blog (3 August 2026) — quantum.microsoft.com/…/from-research-to-product…
39. Atom Computing "Building quantum supercomputers with Microsoft" (official page) — atom-computing.com/building-quantum-supercomputers-with-microsoft/
40. DARPA "Quantum Benchmarking Initiative (QBI)" (official page; checked 16 October 2026) — darpa.mil/research/programs/quantum-benchmarking-initiative
41. ISO/IEC 4879:2024 "Information technology — Quantum computing — Vocabulary" (published May 2024). Number, title, date and "Published" status were checked on the listing page of the Institute for Standardization of Serbia (ISS) — iss.rs/en/project/show/iso:proj:80432 (the official ISO page is https://www.iso.org/standard/80432.html; it could not be fetched automatically from our environment, and was confirmed through search-result listings)
42. IEEE P7131 working group "Quantum Benchmarking Working Group P7131" (site of the working group on the draft standard for quantum computing performance metrics and benchmarking) — sagroups.ieee.org/7131
43. Putterman H. et al. (AWS) "Hardware-efficient quantum error correction via concatenated bosonic qubits", Nature 638, 927–934 (2025), DOI 10.1038/s41586-025-08642-7 — doi.org/10.1038/s41586-025-08642-7
44. Panteleev P., Kalachev G. "Asymptotically good quantum and locally testable classical LDPC codes", arXiv:2111.03654 (2021) (preprint; STOC 2022) — arxiv.org/abs/2111.03654
45. Campbell E. T., Terhal B. M., Vuillot C. "Roads towards fault-tolerant universal quantum computation", Nature 549, 172–179 (2017), DOI 10.1038/nature23460 — doi.org/10.1038/nature23460
46. QuEra Computing "Quantum Error Correction at Record Efficiency: Why Neutral Atoms Are Leading the Way", official blog (20 April 2026) — quera.com/blog-posts/quantum-error-correction-at-record-efficiency…

12. Claim-to-source audit

Last updated 16 October 2026. Sources are limited to primary material (peer-reviewed papers, arXiv papers, official pages of companies and DARPA, and ISO standard listing pages). Company plans and announcements are marked as "company claims" and "not yet confirmed". Resource estimates and numerical examples are calculations under assumptions, not results from real machines. A demonstration of deep fault-tolerant computation on real hardware, completion of IBM's Kookaburra, a real-machine demonstration of the gross code, the definition of logical qubits in each company's plan, the text of ISO/IEC 4879, the publication status of IEEE P7131 and peer review of the 2026 preprints could not be confirmed and are not stated here. All figures are explanatory concept diagrams or drawings that include our calculations; Fig. 1 and Fig. 5 are ImageGen-generated conceptual illustrations.