The Logical Qubit Era

Every scientific field has a before and an after. Chemistry before and after Mendeleev's periodic table. Biology before and after Darwin and Watson-Crick. Computing before and after the transistor. In each case, the moment is not the discovery but the first time the new tool actually worked — the first stable periodic arrangement, the first correct phylogenetic tree, the first running silicon logic gate. Everything the field builds afterward rests on that moment.

Quantum computing crossed its moment on 9 December 2024. On that date, the Google Quantum AI team reported, in Nature, that their Willow processor — 105 superconducting qubits wired as a surface-code error-correcting array — had demonstrated a logical qubit whose error rate fell as the code distance grew. Distance 3, distance 5, distance 7: each step halved the logical error. For the first time in history, a quantum computer got better at its job when you gave it more hardware. The threshold theorem, proved on paper in 1996, worked on silicon in 2024.

This chapter is about the era that moment opened. Not the protocol (that is the logical qubits in practice chapter). Not the hardware roster (that is the landscape in 2026 chapter). The era — the span of time running roughly 2024 through 2045 during which quantum computing transitions from interesting to useful. You are reading this in its dawn. Your working career, if you are a 15-year-old today in 2026, will span it.

The historical timeline — how we got here

Logical qubits did not arrive out of nowhere in December 2024. They are the culmination of nearly thirty years of theoretical and experimental progress. Here is the arc.

1982 — Feynman asks the question. In a lecture at MIT, Richard Feynman asked whether a computer made of quantum components could simulate physics that a classical computer could not. The question was philosophical; the machinery to answer it did not exist.

1994 — Shor's algorithm. Peter Shor showed that if a quantum computer existed, it could factor integers in polynomial time — breaking the RSA cryptosystem. This was the first algorithm with an exponential separation from the best known classical approach. The field acquired a reason to build real hardware.

1995-1996 — Quantum error correction and the threshold theorem. Shor, Steane, and others showed that quantum errors, though fundamentally different from classical errors (they can be continuous, not just bit-flips), could be corrected by encoding one logical qubit across many physical qubits. Kitaev, Aharonov-Ben-Or, and Knill-Laflamme-Zurek proved the threshold theorem: if the physical error rate is below a critical threshold, you can make logical error arbitrarily small by using a larger code. The theoretical scaffold for fault-tolerant quantum computing was in place.

1997 — The surface code. Alexei Kitaev introduced the toric code, later refined into the surface code — the family of two-dimensional error-correcting codes that would, decades later, become the practical standard for superconducting-qubit architectures.

2012-2015 — First QEC demonstrations. IBM, TU Delft, and Google demonstrated small quantum error-correcting codes on physical hardware. These were proof-of-principle experiments: the codes ran, they corrected some errors, but they did not yet operate below threshold in the sense that a larger code gave a lower logical error rate. The hardware was not quite good enough.

2018 — Preskill names NISQ. John Preskill coined the term Noisy Intermediate-Scale Quantum to describe the regime of 50-1000 noisy physical qubits without error correction. The word noisy was the key ingredient — it acknowledged that the current generation of hardware was useful for research demonstrations but not for fault-tolerant algorithms.

2019 — Sycamore supremacy. Google's Sycamore processor demonstrated a random-circuit-sampling benchmark that it claimed classical computers could not match. This was not an application and not a logical qubit; it was a supremacy-style benchmark on physical qubits. Classical algorithmic improvements have since reduced the gap, but the experimental result stands.

2023 — IBM Condor: 1121 physical qubits. The first four-digit superconducting-qubit chip. Condor's individual gate fidelities were too low for useful surface-code operation, but the fabrication demonstrated that 1000-qubit chips were manufacturable.

December 2024 — Willow crosses the threshold. The specific experiment: Google ran the surface code on Willow at distances d = 3, d = 5, and d = 7 (requiring 17, 49, and 97 physical qubits respectively). At each distance step, the logical error rate per cycle dropped by a factor \Lambda \approx 2.9. This is the signature of being below threshold — scaling up the code makes the logical qubit better, not worse. Published in Nature on 9 December 2024.

2024-2025 — Quantinuum colour code with gates. In parallel with Willow, Quantinuum (jointly with Microsoft) demonstrated four logical qubits on a 2D colour code with fault-tolerant Clifford gates (transversal H, S, CNOT) and a T gate via magic-state injection. Where Willow demonstrated one logical qubit that passively protects quantum information, Quantinuum demonstrated multiple logical qubits that can compute with each other at the logical level.

These are the two beachheads. Willow said: you can encode one logical qubit, and it gets better as you scale. Quantinuum said: you can make multiple encoded qubits talk to each other using fault-tolerant gates. Together they are the minimum viable product for the logical-qubit era.

The current state — 2024-2026

The Willow protocol is worth a paragraph on its own. The surface code arranges physical qubits on a 2D grid of data qubits and ancilla (measurement) qubits. Every cycle, each ancilla measures a parity check of neighbouring data qubits; the pattern of these measurements, fed to a classical decoder, identifies which physical errors have occurred and what correction to apply to the logical qubit at the end. The code distance d is the number of physical errors that can be reliably corrected; it scales with the size of the grid. Willow ran at d = 3 (requiring 17 physical qubits), d = 5 (49 qubits), and d = 7 (97 qubits), using the rest of its 105 qubits for readout, calibration, and overhead. The headline number, \Lambda \approx 2.9, means each doubling of code area cuts logical error by a factor of 2.9. If you can sustain \Lambda \ge 2 all the way out to d \sim 25, you are in the regime where fault-tolerant algorithms at the scale of Shor's-against-RSA become feasible.

The Quantinuum colour-code demonstration used the trapped-ion H2 machine's 56-64 ion register to encode four logical qubits in a 2D colour code. The colour code has a mathematical property the surface code lacks: transversal implementation of the full Clifford group. In plain language — you can do logical H, S, and CNOT by applying the corresponding physical gate to each physical qubit in the block, in parallel, with no extra ancillas. This simplifies the logical-gate budget enormously. The non-Clifford T gate still requires magic-state injection (the standard trick — see fault-tolerant gates and magic states), but the Clifford part is free.

Between them, Willow and Quantinuum cover the two halves of the fault-tolerance story: passive protection (Willow) and active computation (Quantinuum). The rest of the logical-qubit era will be about scaling both.

The near-term — 2027-2030

What does the roadmap look like for the next five years? The combined picture from all the major vendors:

IBM Starling (2029, 200 logical qubits). The most ambitious publicly declared logical-qubit target. IBM's roadmap assumes meeting the intermediate Nighthawk and Kookaburra milestones (multi-chip modular superconducting processors with dynamic-circuit capability) and a factor-of-10 improvement in dynamic-circuit performance over the 2024 Heron baseline. If Starling is hit, it will be the first multi-logical-qubit machine in commercial operation.

Google successor to Willow (~2027). Google has not published a formal roadmap with dates, but conference talks and blog posts suggest a 2026-27 successor chip with ~1000 physical qubits capable of hosting multiple logical qubits simultaneously and demonstrating logical two-qubit gates (logical CNOT, logical CZ). A small fault-tolerant algorithm on 2-4 logical qubits is a credible 2028-29 milestone.

Quantinuum H-series scaling (~2030). Quantinuum's target is to scale from 4 logical qubits (2024) to 10-20 logical qubits (late 2020s) while preserving the fault-tolerant Clifford capability. The physical-layer challenge is scaling the ion register from 64 to 256 without fidelity degradation.

IonQ, Atom Computing, QuEra, Pasqal (2027-2029). Error-correction primitives are on the roadmap for all four platforms. Neutral-atom arrays with 1000-atom capacity make larger code distances geometrically feasible; the bottleneck is mid-circuit measurement and fidelity.

PsiQuantum (early 2030s). PsiQuantum's explicit strategy skips NISQ and small-scale FTQC entirely. The declared target is a ~10^6-photonic-qubit fault-tolerant machine in the early 2030s. No logical-qubit demonstrations at intermediate scales.

Microsoft (2030s, if the physics holds). Majorana 1 was announced in February 2025 and remains scientifically contested. If topological qubits are real and scalable, Microsoft's roadmap to fault tolerance could be much shorter than the surface-code route; if they are not, Microsoft retains Azure Quantum and Quantinuum partnerships as alternative paths.

The net expectation for 2030: somewhere between 10 and 100 logical qubits on at least two platforms, with the first fault-tolerant algorithms running end-to-end. Not a thousand logical qubits, not Shor's against RSA. The first useful fault-tolerant demonstrations — not the endgame.

The beyond — 2030-2045

Past 2030, the projections get noisier because the underlying engineering problems get harder. Here is a calibrated picture, with explicit uncertainty ranges.

2030-2033 — first useful fault-tolerant chemistry. Small-molecule quantum chemistry (H_2, LiH, BeH_2, maybe H_2O and small organic fragments) requires ~10-30 logical qubits and 10^4-10^6 logical gates. This is the first genuinely useful fault-tolerant demonstration — a result that a computational chemist would prefer to buy quantum time for rather than run on a classical cluster. Expected window: 2030-2033, with some optimists pointing at 2029 and some pessimists at 2035.

2033-2035 — medium-molecule chemistry. FeMoco (the active site of nitrogenase — the enzyme that fixes atmospheric nitrogen and whose classical simulation is an unsolved grand challenge), catalyst active sites, small crystal unit cells. 100-500 logical qubits, 10^7-10^9 logical gates. If this milestone is hit, it is the first commercially consequential quantum computation — catalyst design and enzyme engineering have real industrial value.

2035-2040 — materials simulation. High-temperature superconductors, lithium-ion battery electrolytes, photovoltaic materials. 500-2000 logical qubits, 10^9-10^{10} gates. The dream application from the 1990s quantum-simulation literature. Expected window 2035-2040.

2040-2045 — Shor's against RSA-2048. Breaking 2048-bit RSA with Shor's algorithm requires approximately 8000 logical qubits and \sim 10^{10}-10^{11} logical gates. With surface-code overhead at distance d \sim 25, the physical-qubit count comes to roughly 2 \times 10^7. The best machine today is \sim 10^3 physical qubits; getting to 2 \times 10^7 is a four-order-of-magnitude engineering problem with many unsolved sub-problems (cryogenic wiring, control-electronics scaling, high-throughput real-time decoding). Expected window: 2040-2045, with credible uncertainty bands extending to 2050.

Longer-term — full quantum advantage at industrial scale. Arbitrary hard-problem speedups, full utility for combinatorial optimisation, drug discovery at industrial throughput. No credible earlier target than 2045+.

The honest summary: the logical-qubit era runs roughly 2024-2045, with genuine usefulness beginning in the 2030-2033 window and industrial maturity in the 2040s. If you are 15 in 2026, you will see most of this arc.

The Mosca threshold, revisited

Mosca's theorem — named after Michele Mosca of the Institute for Quantum Computing (Waterloo) — gives a clean framework for thinking about when to worry about the quantum threat to cryptography. State the theorem as three quantities:

• X = the number of years that you need your data to remain confidential (the security shelf-life).
• Y = the number of years it will take to migrate your systems to post-quantum cryptography.
• Z = the number of years until a quantum computer capable of breaking your current cryptography is available.

Mosca's inequality: if X + Y > Z, you have a problem. Data that needs to stay secret for X years, protected by cryptography that will take Y years to replace, is at risk if a sufficiently large quantum computer appears in Z years — because during the interval between when data is encrypted and when it can be decrypted, the attacker can simply store the ciphertext ("harvest now, decrypt later") and wait.

In 2026, with Shor's-against-RSA plausibly 2040-2045:

• Z \approx 15-20 years for RSA-2048 (credible range, not a guarantee).
• Y \approx 5-10 years for a large enterprise or government to migrate cryptography (NIST PQC standards exist since 2024; rollout is multi-year; legacy systems longer).
• X varies by sector: credit-card numbers have a shelf-life of months, driver's-license scans years, medical records decades, national-security information decades to a century.

For Aadhaar biometric data, with a shelf-life measured in decades (X \ge 50), and an NQM-coordinated migration plan that realistically takes 5-10 years to complete (Y \approx 5-10), you have X + Y \approx 55-60 years, while Z \approx 15-20 years. Mosca's inequality fails by a factor of three. Sensitive Aadhaar data encrypted with RSA-2048 today is potentially vulnerable to harvest-now-decrypt-later even under optimistic quantum timelines.

This is the reason CERT-In and MeitY have already published PQC migration guidance aligned with NIST standards (CRYSTALS-Kyber, Dilithium, SPHINCS+). The quantum threat is fifteen years away; the migration needs to happen now, because X is large.

Mosca's theorem is the single cleanest argument for why the logical-qubit era matters to policy today, not in 2040. The machines are not here yet. The migration must still begin.

What "useful" actually means

A word about useful, because it carries a lot of weight in this chapter. In the quantum-computing literature, "useful" is a higher bar than "advantage" or "supremacy":

• Supremacy (or "quantum advantage" in its narrow sense) means the hardware has performed some specific task faster than any known classical algorithm. Sycamore 2019 and Willow's circuit-sampling benchmark are supremacy results. The task does not have to be useful.
• Advantage (in its broader sense) means some computation has gone faster on quantum than on classical, with "faster" being contested as classical algorithms improve. The supremacy frontier keeps moving as classical methods catch up.
• Utility (as IBM uses the term) means quantum hardware has produced a useful output on a problem beyond brute-force classical simulation — usually at modest scale, often with classical-quantum hybrid pipelines. IBM's 2023 Ising-model result is a utility claim; whether it counts as utility is contested.
• Useful fault-tolerant means quantum hardware, running a fault-tolerant algorithm on encoded logical qubits, has produced a result that a real user in chemistry, materials science, cryptography, or optimisation would prefer to have obtained from quantum rather than classical. Nobody has demonstrated this yet. The target is 2030-2033 for the first small chemistry cases.

The logical-qubit era, by the definition this chapter uses, begins when fault-tolerant primitives are available (Willow and Quantinuum, 2024-2025) and ends when useful fault-tolerant has been demonstrated at industrial scale (2030-2045, depending on application). You are reading this roughly 12-18 months into it.

The worked examples

Common confusions

• "Willow means quantum computing has arrived." No. Willow demonstrated one logical qubit below threshold — the first concrete evidence that the threshold theorem works on real hardware. A useful fault-tolerant computation needs tens to thousands of logical qubits with gates between them. Willow is the first brick, not the building.
• "We are already in the fault-tolerant era." Not yet. We are in the dawn of the logical-qubit era — the demonstrations exist, the building blocks work, but the first useful fault-tolerant algorithm has not been run. That is the 2030-2033 milestone.
• "The roadmap numbers from IBM, Google, Quantinuum will all slip." Some will; some already have. The correct way to read roadmap targets is as upper-bound aspirations — if a vendor declares 200 logical qubits by 2029, the honest 95%-confidence band is more like "10-100 logical qubits by 2029-2031, 200 by 2032-2033." The exact timeline is noisy; the order-of-magnitude trajectory is not.
• "Post-quantum cryptography is overkill — Shor's is 2045." Mosca's theorem says otherwise. Data encrypted today has to survive until Z — the quantum threat — arrives. For Aadhaar, medical records, and strategic data, the shelf-life X is so long that the migration must start today, even though the threat is plausibly fifteen years away.
• "Topological qubits would make all of this obsolete." If Microsoft's Majorana 1 physics holds up at scale, the timeline compresses significantly — topological qubits have error rates that are intrinsically suppressed by the physics rather than by the software overhead of a surface code. As of early 2026, the physics is contested and there is no second-lab replication. The honest position is unresolved, watch this space.
• "Logical qubits are just physical qubits with more redundancy." The distinction is bigger than "just redundancy". A logical qubit is an active error-correcting system — continuous syndrome measurement, real-time decoding, and correction operations happening in a tight feedback loop between the quantum hardware, the classical decoder, and the control electronics. It is a system, not a qubit. Building that system at scale is the whole fault-tolerance project.

Going deeper

The decoder bottleneck

A less-discussed scaling problem: the classical decoder that interprets syndrome measurements and decides what correction to apply. At code distance d, the decoder must process syndrome data at the physical-gate clock rate — for superconducting qubits, roughly 1 microsecond per cycle. Decoding at distance d \ge 25 in real time is a serious classical engineering problem, requiring FPGA or ASIC-class decoders with custom algorithms (minimum-weight perfect matching, union-find decoders, machine-learning decoders). Google, Quantinuum, and IBM all have active decoder-engineering programmes. If the decoder cannot keep up, the logical error rate stops improving with d — the code is no longer below threshold in practice even if the physical errors are.

Magic-state factories

Fault-tolerant computation requires non-Clifford gates (typically T) that do not admit transversal implementation. The standard approach is magic-state distillation — consuming noisy input T-state copies to produce a small number of higher-fidelity T-state outputs, then using those to teleport a T gate into the circuit. Magic-state factories are the single largest overhead in useful fault-tolerant resource estimates; for Shor's-against-RSA, magic-state factories consume roughly half of the physical-qubit budget. Improvements in distillation protocols (Litinski 2019, Gidney-Fowler 2019, Gidney 2024) have steadily reduced the overhead by factors of 2-10 across the last five years; more improvements are expected.

LDPC codes and the qubit-count optimisation

The surface code is the workhorse for 2D-planar architectures, but it has a large overhead: \sim 2d^2 physical qubits per logical qubit, growing quadratically with code distance. Low-density parity-check (LDPC) quantum codes can reduce this overhead significantly — some LDPC constructions encode many logical qubits per code block with overhead scaling more favourably. The engineering cost is that LDPC codes require long-range connectivity, which is hard for 2D-planar superconducting arrays but natural for trapped ions (all-to-all), neutral atoms (reconfigurable tweezers), and photonics. By 2030, some fraction of the logical-qubit count on non-superconducting platforms is likely to come from LDPC codes rather than the surface code.

The decoder-parallelism question

Error correction on multiple logical qubits in a single machine requires parallel decoding — the decoder for logical qubit A must run simultaneously with the decoder for logical qubit B, and the two decoders may need to communicate to handle logical gates that act on both qubits. This is an open architectural question. Google, IBM, and Quantinuum each have internal approaches, none published in detail as of early 2026. The 2028-2030 demonstrations of multi-logical-qubit algorithms will require these parallel decoder architectures to work end-to-end.

Algorithmic co-design

Fault-tolerant algorithms are not the same as NISQ algorithms with more qubits. Algorithms in the logical-qubit era are co-designed with the error-correcting code:

• Chemistry algorithms are rewritten to minimise non-Clifford gate count (because T gates are the expensive ones).
• Shor's algorithm has been optimised from the textbook formulation of O(n^3) logical gates to \sim n^2 with significant prefactor improvements by Gidney-Ekerå and others.
• Grover's algorithm with logical qubits has overhead trade-offs (query vs time vs space) different from the physical-qubit case.

The result: 2030-era algorithms are not the 1994-era algorithms running on better hardware; they are cleaned-up versions adapted to the cost model of fault-tolerant quantum computing.

India's place in the era

India's National Quantum Mission is timed well. Phase 1 (2023-2027) targets 50-100 physical qubits — matching the timing of the global NISQ-to-FTQC transition. Phase 2 (2027-2031) targets 500-1000 physical qubits and first error-correction demonstrations — matching the global scaling window. The NQM does not currently fund a push for 2000-logical-qubit machines, which is the right decision given the global fab and cryogenics supply chain required. What India can and should do, and is doing: build sovereign 100-qubit-class hardware platforms across multiple technologies, train a thousand-strong quantum workforce at IITs and IISc, and position Indian startups (QpiAI, BosonQ PSI, QNu Labs) for the 2030s commercialisation wave.

For the next generation of Indian quantum scientists — the 15-year-old reading this wiki today — the alignment is: your undergraduate years cover 2027-2031 (Phase 2 scaling); your PhD years cover 2031-2036 (first useful fault-tolerant demonstrations); your early career covers 2036-2045 (industrial applications). You graduate straight into the decade when the field becomes useful. It is, for somebody with the right training, the right moment to enter.

Choosing a platform to learn

If you want to start programming logical qubits today, the most accessible routes in 2026:

• IBM Quantum Platform (Qiskit) — the largest collection of cloud-accessible hardware. Heron with dynamic circuits supports mid-circuit measurement and classical feedback, which is the programming model error correction uses. IBM's Qiskit error-correction module is the most mature.
• Quantinuum H-series via Azure Quantum — paid access, but the best fault-tolerant-primitive demonstrations run here. For serious research exposure to colour-code protocols.
• Google Cirq — Google publishes Willow-related code, though hardware access is restricted.
• Xanadu PennyLane — free, runs on simulators and on Xanadu's photonic hardware. The best toolchain for variational algorithms and quantum machine learning.
• Microsoft Azure Quantum — aggregator giving access to IonQ, Quantinuum, Rigetti, Pasqal. Good for platform comparison.

For a student who wants to graduate into the logical-qubit era's workforce, the single highest-leverage skill is error correction and fault-tolerance engineering — understanding how surface codes, colour codes, and LDPC codes work; how decoders operate; how magic-state factories fit in; how logical algorithms are compiled. This is the skill stack the 2028-2035 hiring wave will want.

Where this leads next

• Utility-Scale Quantum Computing — the next chapter, on IBM's definition of utility and how to distinguish it from genuine advantage.
• State of the Art 2026 — the platform-by-platform snapshot of where we are at the dawn of this era.
• The Landscape in 2026 — the ecosystem map — who is building what and who is funding it.
• Fault-Tolerant Gates and Magic States — the theoretical machinery behind Clifford + T and magic-state distillation.
• Logical Qubits in Practice — the detailed protocol Willow ran.

References

1. Google Quantum AI, Quantum error correction below the surface code threshold (2024), Nature 638 — arXiv:2408.13687.
2. Peter Shor, Polynomial-time algorithms for prime factorization and discrete logarithms (1994) — arXiv:quant-ph/9508027.
3. Michele Mosca, Cybersecurity in an era with quantum computers: will we be ready? (2018) — IEEE S&P.
4. John Preskill, Quantum Computing in the NISQ era and beyond (2018) — arXiv:1801.00862.
5. Wikipedia, Quantum error correction.
6. IBM Quantum, IBM Quantum roadmap (2024 update) — ibm.com/quantum/roadmap.