Quantum Computing's Error Correction Milestones

In 1995, a reasonable physicist could have argued that quantum computing was a beautiful idea that would never work. Peter Shor had just shown that a quantum computer could factor large numbers efficiently, and almost immediately the skeptics, Rolf Landauer and William Unruh prominent among them, pointed out the obvious problem. Quantum states are fragile. Every stray interaction with the environment nudges them, and the no-cloning theorem forbids the classical trick of making backup copies. An analog machine that drifts continuously, they argued, can't be corrected.

Shor answered the objection himself. Within months he published a nine-qubit code that protected a single logical qubit against an arbitrary error on any one of its physical qubits. Andrew Steane followed with a seven-qubit code. The key insight was that you don't need to look at the quantum information to fix it. You measure carefully chosen parity checks, called stabilizers, that reveal which error occurred without revealing the encoded state. Measurement also discretizes the errors, so a continuous drift collapses into a small set of correctable events.

Within a few years, several groups had proved versions of the threshold theorem: if physical error rates sit below some constant, you can make logical errors arbitrarily small by adding more qubits. Everything that has happened since, including the results that made headlines over the past three years, is an attempt to cash that theorem in on real hardware.

Why error correction is the barrier, not qubit count

Popular coverage still treats qubit count as the scoreboard. I think that's the single most misleading habit in how this field gets reported, and it leaks into grant panels and hiring committees more than it should.

The algorithms people actually care about, such as factoring, quantum chemistry at industrially relevant scale, and certain materials simulations, need on the order of billions of reliable operations. Today's best physical two-qubit gates fail somewhere around one time in a few hundred to one in a few thousand, depending on platform. Even at one in ten thousand, you'd expect an error long before a serious algorithm finished. No plausible improvement in raw hardware closes a gap of that size alone.

Error correction closes it by redundancy. For the surface code, the workhorse proposal since Kitaev's toric code and the planar variant developed by Bravyi, Kitaev, Dennis and colleagues, the logical error rate falls exponentially with code distance once physical errors are below a threshold of roughly one percent. The cost is overhead. Depending on how far below threshold you operate, a single good logical qubit can need hundreds to over a thousand physical qubits.

So the useful questions are these: are you below threshold, how far below, and how many physical qubits does each logical qubit cost? A 1,000-qubit chip above threshold is less interesting than a 100-qubit chip comfortably below it.

A note on how I'm weighing the evidence

Physics doesn't have meta-analyses and randomized trials, but it does have a hierarchy of confidence, and it's worth being explicit about it. I sort results roughly like this:

This is roughly the analog of the trials-versus-observational-versus-preclinical ladder biomedical readers will know. The failure mode is the same too. A striking single-lab result gets treated as settled because it arrived with a press release.

What's established

The theory holds

The threshold theorem, stabilizer formalism, and the scaling behavior of topological codes like the surface code are mathematically secure under their stated noise assumptions. Nobody serious disputes them. The open questions concern whether real noise matches those assumptions, which I'll come to.

Below-threshold scaling has been observed

The most important experimental fact of the last few years is that logical error rates have been shown to fall as code distance grows. That is the defining signature of operating below threshold, and it had never been cleanly demonstrated before.

Google Quantum AI took the first step in 2023, reporting that a distance-5 surface code slightly outperformed a distance-3 code. The improvement was modest, and the authors were careful about it. The stronger result came in late 2024 with the Willow processor. Running distance-3, -5 and -7 surface code memories, the team reported that each step up in distance roughly halved the logical error rate, with a suppression factor of about 2.1. The distance-7 logical qubit, built from 101 physical qubits, had an error rate of around 0.14 percent per correction cycle and outlived the best physical qubit on the chip. You can find the relevant papers through a PubMed search for surface code threshold experiments.

I'd call the qualitative finding established. Below-threshold operation is possible in superconducting hardware, and the exponential scaling the theory predicts shows up in practice. Other groups have reported logical qubits beating their physical constituents on different platforms, so the broad claim no longer rests on one lab.

Logical qubits can beat physical ones on several platforms

"Break-even," meaning an encoded qubit that lasts longer than the best unencoded component, has now been crossed in more than one architecture. Bosonic approaches at Yale, which encode information in the states of a microwave cavity rather than across many two-level qubits, reported real-time correction beyond break-even in 2023 (see this PubMed search on break-even error correction). Trapped-ion and neutral-atom groups have reported logical operations with error rates below those of their physical gates.

Break-even is a necessary milestone, but it isn't a sufficient one. A logical qubit that is somewhat better than a physical qubit is still far from the logical error rates that long algorithms require.

What's demonstrated but not yet general

Many logical qubits at once

Memory experiments protect one logical qubit sitting still. Computation needs many logical qubits interacting. The standout result here came from the Harvard, MIT and QuEra collaboration in late 2023. Using reconfigurable arrays of neutral atoms moved around with optical tweezers, they ran circuits on up to 48 logical qubits. Some of the encoded circuits outperformed their unencoded equivalents. The ability to physically shuttle atoms makes non-local connectivity much cheaper than on a fixed superconducting chip, which matters for the codes discussed below. A PubMed search on logical processors in atom arrays will pull up the paper and its follow-ups.

My caution with this one is the error-detection step. Several of the most impressive logical-circuit results rely partly on detecting errors and discarding bad runs (post-selection), rather than correcting errors in real time. That's legitimate and clearly reported, but it doesn't scale to long algorithms, where you can't throw away almost every run.

Real-time decoding

A decoder is the classical algorithm that reads the stabilizer measurements and infers which errors occurred. It has to keep up with the hardware. On superconducting devices, that means processing a round of syndrome data in about a microsecond. Otherwise the backlog grows without bound. Real-time decoding at modest code distances has been shown, but keeping up at the distances and logical-qubit counts needed for useful computation is an engineering problem that remains unsolved. I think it's underrated as a bottleneck.

What's emerging

Cheaper codes: qLDPC

The surface code is popular because it needs only nearest-neighbor connections on a 2D grid and tolerates fairly high error rates. Its weakness is that it's wasteful, since each logical qubit costs a lot of physical qubits. Quantum low-density parity-check (qLDPC) codes can encode many logical qubits in a block with far lower overhead, at the price of needing longer-range connections.

IBM's 2024 work on bivariate bicycle codes is the best-known example. Their "gross code" encodes 12 logical qubits in 144 data qubits, with simulated performance competitive with a surface code that would use many times more qubits. That's a genuine theoretical and design advance. Experimentally, it's early. The connectivity these codes require is hard to fabricate, and logical operations on qLDPC codes are less mature than on the surface code. I'd treat the overhead savings as a strong hypothesis rather than a result.

Biased-noise and bosonic qubits

Cat qubits, pursued by Alice & Bob and by AWS in its Ocelot chip announced in 2025, engineer hardware so that one type of error (bit flips) is exponentially suppressed. The code then only has to handle the other type. If that bias survives through gates at scale, the overhead savings could be substantial. The reported results are encouraging but young, and the key question is whether the bias is preserved during the operations a full computation needs.

Topological qubits

Microsoft's Majorana-based approach aims to build qubits that are intrinsically protected. Its 2025 announcement drew significant pushback from physicists who argued that the published data did not yet establish topological behavior. I'd put this firmly in the "unresolved" column. It may yet work, but it isn't evidence that fault tolerance is close.

Shrinking resource estimates

On the algorithm side, estimates of what it takes to do something useful have fallen sharply. In 2019, Craig Gidney and Martin Ekerå estimated that breaking RSA-2048 would need about 20 million noisy qubits. In 2025, Gidney revised that to under a million, running for under a week, under similar hardware assumptions. Those are estimates, not demonstrations, and they assume error rates and decoding speeds no one has yet shown at scale. Still, the direction of travel matters. It's one reason standards bodies have not waited, and NIST's post-quantum cryptography program has already finalized its first standards.

Limitations and open debates

Correlated errors. The threshold theorem assumes errors are roughly independent and local. Real devices have cosmic-ray events, leakage out of the computational subspace, and crosstalk, all of which can hit many qubits at once. Google's Willow work reported rare correlated error bursts that set a floor on logical performance. How to suppress or correct these at scale is an active and unsettled question.

Memory isn't computation. Most below-threshold results protect a stored qubit. Universal fault-tolerant computation needs logical gates, including non-Clifford gates, typically supplied via magic-state distillation or cultivation, which add their own large overhead. Fewer experiments have tested this.

Metrics aren't standardized. Groups report logical error per cycle, per gate, per shot with post-selection, or relative to the best physical qubit. These aren't interchangeable. I'd argue that's the main reason press coverage of competing platforms is so confusing, and it's worth being skeptical whenever two headline numbers are compared directly.

Industrial reporting. Much of this research happens inside companies. The Nature papers are rigorous, but roadmaps and launch announcements are not peer-reviewed, and some claims arrive months before the data. I don't think that's sinister. It does mean the "single-platform" tier is crowded with results that no outside group can easily replicate.

What this means if you're not a quantum physicist

For computational chemists, materials scientists and anyone whose field has been promised a quantum speedup, my honest read is this: the physics of fault tolerance now looks real, and the engineering looks very hard. Machines that run long, useful algorithms with full error correction are plausibly years away, not decades. They are also not imminent, and claims of near-term "quantum advantage" on practical problems deserve close reading. Most of those claims concern sampling tasks or uncorrected devices.

Data with a long confidentiality horizon is the exception, and that includes some clinical and genomic data. If it's encrypted with RSA or elliptic-curve schemes today, the "harvest now, decrypt later" risk is a reason to take post-quantum migration seriously now, whatever the exact timeline.

What I'll be watching next

• Logical gates below threshold. Not just memory. I want to see two-qubit logical operations whose error rates also fall with distance.

• Independent replication of below-threshold scaling at comparable distances on a second platform, ideally with matching metrics.

• qLDPC codes in hardware. I'm looking for a real device running a high-rate code with real-time decoding, not just simulations.

• Decoders at scale. Watch for evidence that classical control can keep pace with many logical qubits at once.

• Correlated-error mitigation. Credible solutions to radiation and leakage events would remove the floor that currently caps logical performance.

• Demonstrated magic-state production with overheads close to those assumed in the shrinking resource estimates.

Most of the important work lands first on arXiv, often a year before formal publication, and the preprint versions sometimes differ meaningfully from what is finally published. If you're tracking this field from the outside, following preprints alongside peer-reviewed papers is worth the effort. So is keeping notes on which metric each group reports. I keep a running collection of the key papers in PACR, the AI-native research workspace we built, so I can search across new preprints and compare reported numbers side by side without losing track of which figure came from which experimental setup.

The skeptics in 1995 were right that quantum information is fragile. They were wrong that it can't be protected. The next few years will tell us how expensive that protection turns out to be, and that number will determine what quantum computers are ultimately for. If you want to follow the field the same way, you can set up a PACR workspace and start with the three PubMed searches linked above.