top of page

Fault-Tolerant Quantum Computing

4 days ago
6 min read

Logical-Qubit Error Control and the Road to Quantum Chemistry

A careful reading of the evidence from IBM, Google Quantum AI and QuEra


The strongest recent results in quantum error correction are real, but their meaning is narrower than many headlines suggest. Google has shown below-threshold surface-code memory on Willow; IBM has described a route from error mitigation to modular fault tolerance; and QuEra-led teams have run substantial logical-qubit experiments on neutral atoms. These achievements improve the prospects for chemistry, yet they do not establish that commercial-grade quantum chemistry is already routine on fault-tolerant machines.


Image: IBM quantum processor packaging.

The central distinction: mitigation is not correction

Quantum processors fail for two different reasons: individual physical qubits are noisy, and long circuits give those errors time to accumulate. Error mitigation tries to estimate what a cleaner answer would have been by changing the experiment or processing many noisy results. Zero-noise extrapolation and probabilistic error cancellation are examples. They can improve an expectation value, but they do not create a protected memory and they can require substantial sampling overhead. IBM’s work on molecular simulations helped establish how far this approach can go before full fault tolerance. [1]


Quantum error correction (QEC) takes a different route. It spreads one encoded quantum state across many physical qubits, repeatedly measures error syndromes, and uses a classical decoder to infer corrections without directly measuring the protected state. The encoded object is a logical qubit. A fault-tolerant computer must keep logical errors low while it applies a universal gate set, including non-Clifford operations such as T gates. It must also decode fast enough to keep pace with the quantum hardware. [2]


Google: below-threshold memory is the clearest hardware signal

Google’s Willow result is important because the larger code performed better rather than worse. In the Nature study, a distance-7 surface code used 101 physical qubits and reached an error rate of 0.143% per correction cycle. Its logical memory lasted 2.4 times longer than its best physical qubit, while real-time decoding ran with an average latency of 63 microseconds. [3]


The key condition is the error-correction threshold. Below that threshold, adding carefully controlled physical qubits suppresses the logical error rate; above it, the extra hardware creates more opportunities for failure than protection. Google reports an error-suppression factor of about 2.14 when increasing code distance by two. That is evidence that the central scaling mechanism works, not evidence that the system is ready for chemistry programs lasting billions of operations.


Google has also reported large chemistry simulations using error-aware methods on noisy hardware. Those calculations addressed chemical reactivity and kinetics and were competitive with classical approaches for the studied cases. [4] The relevant lesson is that chemistry is already a useful test problem, while the separate logical-qubit result shows a route to much deeper algorithms. The two results should not be merged into a claim that a fault-tolerant chemistry engine is already operating.


IBM: from useful noisy circuits to a modular logical machine

IBM’s near-term chemistry work shows why mitigation remains relevant. In the company’s 2023 account of a collaboration with UC Berkeley, a 127-qubit Eagle processor ran circuits of 60 layers and produced results that agreed with trusted classical calculations for the target observables. The researchers explicitly framed the result as evidence of utility before fault tolerance, not as a general replacement for classical computing. [1]


IBM’s longer-range plan focuses on logical memory, fast decoding and modular interconnects. Its published architecture uses a bivariate-bicycle qLDPC code that encodes 12 logical qubits in 288 physical data and syndrome qubits, with a stated goal of reducing the hardware burden compared with a surface-code implementation. IBM’s roadmap describes a Starling system intended to run 100 million gates on 200 logical qubits in 2029. [2] Those are engineering targets and architecture claims, not a report of a commercially available chemistry workload.


For chemistry, the distinction is consequential. A molecular-energy calculation needs repeated state preparation, controlled evolution, measurement and classical optimization. A useful fault-tolerant implementation must preserve accuracy through the entire loop, not just one short circuit. It also needs enough logical qubits to represent the active orbitals and enough non-Clifford resources to make the chemistry model expressive.


Logical-qubit architecture reference: encoded information is protected by repeated syndrome extraction and classical decoding. Source: Google Quantum AI / IBM Quantum, as identified in the References.
Logical-qubit architecture reference: encoded information is protected by repeated syndrome extraction and classical decoding. Source: Google Quantum AI / IBM Quantum, as identified in the References.

QuEra: neutral atoms add a different scaling strategy

QuEra’s platform uses programmable arrays of neutral atoms. The architecture can rearrange atoms, provide flexible connectivity and operate many logical units in parallel. In 2023, a Harvard-led team working with QuEra, MIT and NIST/UMD reported algorithms on 48 logical qubits, with hundreds of entangling logical operations. The experiment also showed that increasing code distance reduced logical-operation error in the tested setting. [5]


In 2025, a QuEra, Harvard and MIT team reported logical-level magic-state distillation on a Gemini neutral-atom computer. Five imperfect resource states were combined into one cleaner state using distance-3 and distance-5 color-code qubits. Magic states are needed for non-Clifford gates, so this is a relevant building block for universal fault-tolerant computation. [6]


Neither demonstration is the same as a full chemistry calculation with commercial accuracy. The results show protected logical processing and a route to universal gates. They also expose remaining constraints: atom loss, decoder scalability, physical error rates, circuit depth and the resource cost of producing magic states. A 2026 Nature study on neutral-atom architecture reports that present experiments remain about a factor of two from key thresholds and estimates that further physical-error reduction is still needed for algorithmically relevant rates. [7]


Image: QuEra neutral-atom quantum system. Source: QuEra, Aquila product imagery.
Image: QuEra neutral-atom quantum system. Source: QuEra, Aquila product imagery.

What would “commercial precision” require?

In chemistry, precision is not a slogan. It is a numerical error budget tied to a scientific decision: a reaction barrier, an excitation energy, a binding energy or a material property. A quantum result must be compared with a suitable classical benchmark and its uncertainty must include sampling, calibration drift, model truncation and logical faults.


A commercially credible workflow would therefore need four things. First, a stable logical memory with an error rate low enough for the full algorithm. Second, a universal logical gate set with an affordable supply of distilled magic states. Third, a compiler and decoder that keep overhead under control. Fourth, a benchmark where the quantum answer changes a real chemistry decision or reaches a regime that classical methods cannot economically match.


The present evidence supports a more measured conclusion: error mitigation is already improving selected chemistry experiments, and logical-qubit engineering is beginning to show the scaling behavior required for fault tolerance. The bridge between those facts and a dependable industrial chemistry service has not yet been completed.


IBM Quantum roadmap image. Source: IBM Quantum, “IBM lays out clear path to fault-tolerant quantum computing.”
IBM Quantum roadmap image. Source: IBM Quantum, “IBM lays out clear path to fault-tolerant quantum computing.”

Closing Thoughts

The field is moving from asking whether quantum error correction can work to asking how much protected computation can be delivered per unit of hardware, energy and time. That is a healthier question. Google’s below-threshold result, IBM’s modular architecture and QuEra’s logical operations each solve a different part of the problem. The responsible view is optimistic about the direction and restrained about the timetable: useful quantum chemistry may arrive in stages, with hybrid workflows and carefully chosen molecules appearing before a general-purpose fault-tolerant chemistry machine.


What does this actually mean?

It means that “logical qubit” is becoming an experimentally meaningful engineering object rather than only a theoretical promise. It does not mean that physical noise has disappeared. It means researchers can encode information, detect many faults, decode in real time and, in selected experiments, make larger codes perform better than smaller ones. Chemistry benefits because deeper circuits become conceivable, but the chemistry application still needs its own accuracy and resource demonstrations.


Why does this matter?

Chemical simulation is one of the clearest reasons to build a fault-tolerant quantum computer. Molecular systems grow difficult to model as electrons interact, and some catalysts, materials and reaction mechanisms may require methods that scale poorly on classical machines. Better logical qubits could eventually make those calculations reliable enough for research and industrial decisions. The near-term value is equally important: error-mitigation techniques are teaching teams how to characterize noise, while logical experiments are revealing the hardware, software and decoding systems needed for the next generation.


Reference videos


References

  1. IBM Quantum and UC Berkeley, “A new paper from IBM and UC Berkeley shows a path toward useful quantum computing.” https://www.ibm.com/quantum/blog/utility-toward-useful-quantum

  2. IBM Quantum, “IBM lays out clear path to fault-tolerant quantum computing.” https://www.ibm.com/quantum/blog/large-scale-ftqc

  3. Google Quantum AI, “Quantum error correction below the surface code threshold,” Nature 638, 920–926 (2025). https://www.nature.com/articles/s41586-024-08449-y

  4. Google, “Using quantum computing to accurately predict chemical reactivity and kinetics.” https://blog.google/innovation-and-ai/products/google-ai-big-scientific-breakthroughs-2024/

  5. Bluvstein et al., “Logical quantum processor based on reconfigurable atom arrays,” Nature 626, 58–65 (2024). https://www.nature.com/articles/s41586-023-06927-3

  6. QuEra, Harvard and MIT, “Logical-level magic state distillation on a neutral-atom quantum computer.” https://www.quera.com/press-releases/quera-harvard-and-mit-researchers-demonstrate-logical-level-magic-state-distillation-on-a-neutral-atom-quantum-computer

  7. Bluvstein et al., “A fault-tolerant neutral-atom architecture for universal quantum computation,” Nature (2026). https://www.nature.com/articles/s41586-025-09848-5

Comments

Rated 0 out of 5 stars.
No ratings yet

Add a rating
bottom of page