Quantum Error Correction Explained: Physical Qubits, Logical Qubits and Thresholds

Quantum error correction is the set of techniques that lets a quantum computer keep information intact even though every physical qubit is noisy. Instead of trusting one fragile qubit, the machine spreads a single logical qubit across many physical ones and repeatedly runs parity-style checks, called syndrome measurements, that reveal where an error probably struck without revealing the data itself. In 2024, Google showed that making such a code bigger actually made it more reliable. What follows explains how that works, what a threshold is, and what remains unsolved.

Why a qubit is harder to protect than a bit

A classical bit is easy to defend. Copy it three times, and if one copy flips, the majority still tells you the truth. Claude Shannon's 1948 work on information theory (see our profile of Claude Shannon) showed that this kind of redundancy can make communication over a noisy channel as reliable as you like, provided the noise is below a limit. Hard drives, satellite links, and the memory in your laptop all lean on that idea.

Quantum information breaks every step of that recipe. The first problem is that a qubit's error is not a clean flip. A qubit holds amplitudes (numbers that set the probabilities of reading zero or one) and a relative phase between them, and noise can nudge those continuous values by any small amount. The second problem is the no-cloning theorem, proved by William Wootters and Wojciech Zurek and independently by Dennis Dieks in 1982: no operation can make an independent, identical copy of an arbitrary unknown quantum state (Wikipedia summary of the proof and its history). The third problem is that measuring a qubit to check it collapses the superposition you wanted to protect.

So the classical playbook of copy, compare, and vote is off the table. Quantum error correction has to find errors without copying and without looking, which sounds contradictory until you see the trick.

Qubits are fragile in several different ways

Real hardware loses information through energy relaxation (a qubit decays from one to zero), dephasing (the phase relationship drifts), imperfect control pulses, readout mistakes, and leakage, where a qubit wanders out of the two levels that represent zero and one. Each process shows up differently in a circuit, and a good code has to handle all of them, along with the errors that error correction itself introduces through its own gates and measurements.

If you want the physics behind why superconducting circuits make decent but imperfect qubits, our explainer on superconductivity covers the material side. The relevant point here is simpler: the environment is always listening, and a computation that needs billions of operations has billions of chances to be overheard.

The trick: check relationships, not values

Imagine two copies of a legal contract. A proofreader can confirm that the copies match without reading a single word of either. If they disagree, the proofreader learns that something went wrong and roughly where, but still has no idea what the contract says. Syndrome measurement works the same way: it asks "do these qubits agree?" rather than "what value does this qubit hold?"

That distinction is the whole game. A syndrome is a classical bit of information about the pattern of errors, extracted so that it carries no information about the encoded amplitudes. The encoded state is preserved because the measurement never distinguishes the logical zero from the logical one.

Errors become discrete once you check for them

Here is the part that surprises most readers. Even though physical noise is continuous, measuring a syndrome forces the system to commit: either a given check detects a flip or it does not. After the measurement, what remains is, in effect, a bit-flip error, a phase-flip error, or both, which is why a code that handles those two cases can handle an arbitrary error on a single qubit (Wikipedia: Shor code). A tiny rotation of a qubit becomes, after checking, either "nothing happened" or "a full flip happened," each with some probability. The decoder only ever has to fix the discrete version.

A worked example: the three-qubit repetition code

The simplest quantum code, usually credited to Asher Peres in 1985, protects against bit flips only. It encodes the logical states as |000> and |111>. A general qubit state, with amplitudes a and b, becomes a|000> + b|111>. That is an entangled state, not three copies, so it does not violate no-cloning.

To check it, you measure two parities: whether qubits 1 and 2 agree, and whether qubits 2 and 3 agree. Those two measurements are done using helper qubits (ancillas) and entangling gates, so the data qubits themselves are never read out. The four possible results point to four situations.

Parity 1-2	Parity 2-3	Most likely situation	Correction
agree	agree	No error	None
disagree	agree	Qubit 1 flipped	Flip qubit 1
disagree	disagree	Qubit 2 flipped	Flip qubit 2
agree	disagree	Qubit 3 flipped	Flip qubit 3

The code fails only when two or more qubits flip in the same round, because then the majority vote points the wrong way. If each qubit flips with probability p, the logical failure probability is 3p² − 2p³, and the code helps whenever p is below one half (Wikipedia: three-qubit bit-flip code). The arithmetic is worth seeing.

Physical flip probability p	Logical failure probability 3p² − 2p³	Improvement
0.1 (10%)	0.028 (2.8%)	about 3.6 times better
0.01 (1%)	0.000298 (0.03%)	about 34 times better
0.001 (0.1%)	0.000003 (0.0003%)	about 330 times better

Notice the pattern. The better the underlying hardware, the more dramatic the payoff, because the failure probability scales with p squared while the raw error scales with p. That squared dependence is the seed of the threshold idea we will reach in a moment.

Why this toy code is not enough

The three-qubit code ignores phase flips entirely. A phase flip changes the sign between the zero and one components, and the three-qubit code cannot see it. You can build a second repetition code in the rotated basis (the one in which phase flips look like bit flips), and combining the two protections is what the next section is about. The toy code also assumes that the parity checks themselves are perfect, which real hardware cannot promise. Every real code must tolerate faulty checks.

Shor's nine-qubit code and the early years

In 1995, Peter Shor published the first quantum error-correcting code, which encodes one logical qubit in nine physical qubits and corrects an arbitrary error on any single qubit (Shor, Physical Review A 52, R2493; the nine-qubit structure is described in the Wikipedia article on quantum error correction). It nests three bit-flip blocks of three qubits inside a phase-flip layer. The construction is more of a proof of principle than a practical design, but it settled a question that many physicists had thought might be a dead end: error correction is possible for quantum information.

The following years produced a burst of ideas, summarized in the table below.

Year	Milestone	Why it mattered
1982	No-cloning theorem (Wootters and Zurek; Dieks)	Showed that quantum states cannot be copied, which seemed to rule out redundancy
1985	Three-qubit bit-flip code (Peres)	Showed the basic parity-check idea
1995	Nine-qubit code (Shor)	First code that corrects arbitrary single-qubit errors
1996	Steane code and five-qubit code (Steane; Laflamme and colleagues)	Smaller or more structured codes
1996	Fault-tolerant computation (Shor)	Showed how to compute on encoded data without errors spreading uncontrollably
1997	Anyon-based and toric-code ideas (Kitaev); stabilizer formalism (Gottesman)	Laid the groundwork for surface codes and for a unified way to describe codes
1998	Threshold results (Knill, Laflamme, and Zurek)	Argued that arbitrarily long computation is possible below a noise level

Sources for the table: Shor's fault-tolerance paper, Kitaev's 1997 anyon paper, Gottesman's stabilizer-code paper, and the dates and names compiled in the Wikipedia articles on quantum error correction and the quantum threshold theorem.

Physical qubits versus logical qubits

A physical qubit is a piece of hardware: a superconducting circuit, a trapped ion, a neutral atom held by laser light. It has its own error rate, its own connectivity to neighbors, and its own readout. A logical qubit is an encoded degree of freedom spread across many physical qubits and refreshed by repeated syndrome rounds. It exists only as long as the error-correction cycle keeps running.

This distinction explains why headline qubit counts mislead. A chip with 1,000 physical qubits is not a computer with 1,000 usable qubits. Depending on the code and the noise, one logical qubit may cost dozens, hundreds, or thousands of physical qubits, and the ratio is itself a research question.

Think of a choir, not a soloist

One analogy: a solo singer who drifts off pitch has nobody to correct them. A choir of fifty singers who all listen to each other can hold a note much longer, and a conductor who spots a wavering section can nudge it back. The note you hear is the logical qubit; the singers are physical qubits; the conductor is the decoder. The cost is real, since you now need fifty singers and a conductor to carry one note. The benefit is that a note held by a choir survives a cough.

Stabilizers: the grammar of modern codes

Most codes in use today belong to the stabilizer family, which Daniel Gottesman described in a 1997 paper (Stabilizer Codes and Quantum Error Correction). A stabilizer is an operator, a specific multi-qubit measurement, that gives a known answer (plus one, say) whenever the system sits inside the protected code space. If an error pushes the state out of that space, some stabilizers flip to minus one. The pattern of flipped stabilizers is the syndrome.

The three-qubit code above is a tiny stabilizer code: its two parity checks are the stabilizers. Larger codes simply use more checks, arranged so that different errors produce different syndrome patterns. The design question is how many qubits you need, how local the checks can be, and how well a decoder can interpret the results.

Surface codes: a two-dimensional fabric of checks

The surface code is the leading candidate for superconducting hardware because it uses only nearest-neighbor interactions on a flat grid. Its lineage runs back to Alexei Kitaev's toric code, introduced in 1997, which lives on a donut-shaped lattice; the planar version replaces the donut with a flat patch with boundaries, which is much easier to build on a chip (Wikipedia: toric code). A comprehensive treatment by Austin Fowler, Matteo Mariantoni, John Martinis, and Andrew Cleland, published in Physical Review A in 2012, set out how a large surface-code computer could be assembled and sized (Surface codes: Towards practical large-scale quantum computation).

In the rotated planar layout, a code of distance d uses d² data qubits and d² − 1 stabilizer checks, each measured by a helper qubit. The distance is the number of errors needed in a row to flip the logical value without being noticed. Bigger distance means more protection and more qubits.

How a decoder reads a surface-code syndrome

Picture a grid of check-lights. A single flipped data qubit lights up the two neighboring checks that touch it. A chain of flipped qubits lights up only the two ends of the chain, because the interior checks each see two flips and cancel. The decoder sees the lit ends and has to guess the chain that connects them, usually by assuming the shortest chain is the most likely.

A logical error happens when the true chain and the decoder's guess together form a path that spans the whole patch. For odd d, fooling the decoder needs roughly (d + 1)/2 or more errors lining up, which is why increasing d suppresses logical errors so quickly when physical errors are rare and independent. Idealized analyses, where only bit and phase errors occur independently, put the surface code's threshold near 10 percent, about 10.5 percent with a minimum-weight matching decoder (Wikipedia: toric code). Realistic circuit-level noise, where gates and measurements themselves are faulty, brings the figure down to order 1 percent (Wikipedia: quantum threshold theorem).

The threshold, explained with a leaky boat

The threshold theorem is the quantum analogue of a result by John von Neumann in 1956 about reliable classical computers built from unreliable parts. Several groups proved versions of it for different noise models: Dorit Aharonov and Michael Ben-Or, Emanuel Knill, Raymond Laflamme and Wojciech Zurek, and Alexei Kitaev (Wikipedia: quantum threshold theorem). In simplified form it says that if the error rate per operation is below a threshold, you can make a computation as long as you like by adding more qubits, at a cost that grows only slowly (polylogarithmically) with the size of the computation.

Think of bailing a leaky boat. If water comes in slower than you can bail, a bigger crew keeps the boat afloat indefinitely. If water arrives faster than your crew can bail, adding more people just means more people standing in a sinking boat. Below threshold, extra qubits help. Above threshold, every added gate and measurement injects more errors than the code removes, so a larger code is worse.

Why there is no single threshold number

The threshold depends on the code, the decoder, the noise model, the gate set, the connectivity, and the measurement quality. Leakage and correlated errors can push the real threshold well below the idealized one. When you see a threshold quoted, ask which noise model produced it. IBM's 2024 Nature paper on high-rate codes, for example, reports a threshold of 0.8 percent under the standard circuit-based noise model, which the authors describe as on par with the surface code (Bravyi et al., arXiv:2308.07915).

What Google measured below threshold

The cleanest experimental test of the threshold idea is to build codes of increasing distance on the same chip and see whether logical error falls. Google Quantum AI reported this in two stages.

In the first, a 2022 preprint later published in Nature in 2023, the team compared a distance-3 and a distance-5 surface code. The distance-5 logical qubit had a logical error per cycle of 2.914 percent, against 3.028 percent for the distance-3 average (Acharya et al., arXiv:2207.06431). That is a modest improvement, but it was an early sign that scaling up could help rather than hurt.

The second stage was far clearer. A paper first posted in August 2024 and published in Nature in 2025 reported distance-5 and distance-7 surface-code memories on a newer chip (Acharya et al., "Quantum error correction below the surface code threshold," arXiv:2408.13687). The headline numbers follow.

Quantity	Reported value
Logical error suppression per distance step of two (Λ)	2.14 ± 0.02
Qubits in the distance-7 memory	101
Distance-7 logical error rate	0.143% ± 0.003% per cycle
Logical memory lifetime versus best physical qubit	2.4 ± 0.3 times longer
Error-correction cycle time	1.1 microseconds
Average decoder latency at distance 5	63 microseconds, up to a million cycles

Each time the code distance rose by two, the logical error rate shrank by a factor of about 2.14. A logical qubit that outlives its best physical qubit is said to be beyond break-even, and this memory cleared that bar by roughly a factor of 2.4.

A back-of-envelope extrapolation, with caveats

Suppose, purely as an illustration, that the factor of 2.14 held at every larger distance. Starting from 0.143 percent at distance 7, the logical error per cycle would be about 0.067 percent at distance 9, 0.031 percent at distance 11, 0.015 percent at distance 13, and 0.007 percent at distance 15. To reach one error in a million cycles you would need about ten more steps, which lands near distance 27, or roughly 1,457 qubits per logical qubit (2d² − 1 for a rotated surface code).

Treat that as a thought experiment, not a forecast. The authors do not claim Λ stays constant, and their own data show why caution is warranted: repetition codes up to distance 29 revealed that logical performance was limited by rare correlated error events, occurring roughly once per hour, or about 3 × 10⁹ cycles (Acharya et al.). Those events set an error floor that more distance alone does not remove.

Decoders: the classical half of a quantum computer

Every syndrome round produces a stream of classical bits, and a decoder has to turn the stream into a correction fast enough to keep up. The Google result is notable partly because the distance-5 code ran with a real-time decoder, at an average latency of 63 microseconds, for up to a million cycles against a cycle time of 1.1 microseconds.

Latency matters for a logical reason. If the decoder takes longer per round than the hardware takes to produce syndromes, a backlog builds, and the logical operations that depend on decoded results have to wait. That is the same problem as a checkout queue with one cashier and customers arriving faster than they can be served.

Decoders range from graph-matching algorithms to lookup tables to neural networks to custom chips. They also have to cope with measurement errors, which create false syndrome events, so they read a history of rounds rather than a single snapshot. In many designs the correction is not applied physically at all. The software simply tracks it (a "Pauli frame") and accounts for it when the logical qubit is finally measured.

Leakage and correlated faults

Standard analyses assume errors strike independently. Real chips violate that assumption in several ways. Leakage moves a qubit into a state outside the computational pair, where it can scramble neighbors and escape ordinary syndrome logic, so hardware uses extra reset or leakage-removal steps. Cosmic rays, stray radiation, shared control lines, and crosstalk can hit many qubits at once. A code built for sparse independent errors can behave quite differently when errors arrive in clusters.

This is why average gate fidelity is an incomplete scorecard. A rare event that corrupts a whole region can dominate a long computation even when typical gates look excellent, and the once-per-hour events in the Google data are exactly that kind of problem.

Beyond the surface code: fewer qubits per logical qubit

The surface code is robust but expensive. Researchers are exploring codes that pack more logical qubits into fewer physical ones, at the price of more demanding connectivity.

IBM's team proposed a family of high-rate quantum low-density parity-check (qLDPC) codes, in which each check touches only a few qubits and each qubit joins only a few checks. In their example, 12 logical qubits could be preserved for nearly one million syndrome cycles using 288 physical qubits in total, assuming a physical error rate of 0.1 percent. The authors estimate that the surface code would need nearly 3,000 physical qubits for the same job (Bravyi et al., arXiv:2308.07915). The catch is connectivity: the code needs a degree-6 connection graph, which is harder to wire than a flat grid.

IBM's published roadmap builds on this approach. It lists a fault-tolerant system called Starling, targeted for 2029 at its Poughkeepsie, New York site, with 200 logical qubits able to run circuits of 100 million gates, along with intermediate processors named Loon (2025), Kookaburra (2026), and Cockatoo (2027) (IBM Quantum blog). These are company targets, not delivered results, and schedules in this field have moved before.

Neutral atoms and many small codes

A different strategy appeared in a December 2023 Harvard-led paper using reconfigurable arrays of neutral atoms: up to 280 physical qubits, with circuits on up to 48 logical qubits built from small error-detecting code blocks (Bluvstein et al., arXiv:2312.03982). Those blocks have distance two, which means they can detect a single error but cannot, on their own, correct one. The work showed that logical encoding could outperform bare physical qubits on certain benchmarks and demonstrated large-scale logical circuits, but it is a different milestone from the sustained below-threshold memory Google reported.

From memory to computation

A memory only stores. A computer has to act on the stored information, and every logical operation has to be performed without spreading errors from one block to another. Fault-tolerant designs use a few standard moves. In lattice surgery, two patches of surface code are merged and split by changing which checks are measured, which implements entangling logic between logical qubits. In code deformation, a patch is stretched or reshaped to move a logical qubit around.

Some gates come cheaply, but at least one family, the non-Clifford gates, does not. The usual fix is magic-state distillation: prepare many noisy copies of a special resource state and consume them in a protocol that outputs fewer, cleaner ones. Distillation can dominate the cost of a large algorithm, which is why resource estimates depend heavily on how the algorithm uses those gates.

The best-known resource estimate

Craig Gidney's 2025 paper estimated that a 2,048-bit RSA integer could be factored in under a week with fewer than one million noisy qubits, assuming a square grid with nearest-neighbor connections, a uniform gate error of 0.1 percent, a surface-code cycle time of 1 microsecond, and a control reaction time of 10 microseconds. His 2019 estimate with Martin Ekerå required about 20 million noisy qubits (though it ran in roughly eight hours). Most of the savings came from approximate residue arithmetic, from storing idle logical qubits in denser "yoked" surface codes, and from a technique called magic-state cultivation that needs less space than distillation (Gidney, arXiv:2505.15917).

The lesson is not that a machine like that exists. It does not. The lesson is that resource estimates move by factors of 10 or more when algorithms and codes improve, so any single qubit-count prediction deserves skepticism.

Error correction versus error mitigation

The two phrases sound alike and mean different things.

Feature	Error correction	Error mitigation
Core idea	Encode information redundantly and fix errors during the run	Run many noisy circuits and statistically estimate what a clean one would give
Extra qubits needed	Many, per logical qubit	Few or none
Cost grows with	Code size and syndrome rounds	Number of repeated runs, often rapidly with circuit depth
Protects stored states	Yes	No, it corrects averaged outputs
Scales to deep circuits	In principle, below threshold	Generally limited

Mitigation is useful for today's small experiments. It cannot substitute for correction once circuits get deep, because its sampling cost tends to rise steeply with the number of noisy operations.

What people get wrong about quantum error correction

"A below-threshold result means fault-tolerant computing has arrived." It does not. A memory that gets better with size is a necessary ingredient. A useful computer also needs logical gates, state preparation, measurement, decoders that keep up at scale, and algorithms that fit the error budget.

"More physical qubits always means a better computer." Only when each added qubit is good enough and correlated errors are controlled. Above threshold, more qubits make things worse.

"Error correction copies the qubit." It cannot, by the no-cloning theorem. It entangles the logical state across many qubits and checks relationships among them.

"Syndrome measurement destroys the state." Done correctly, the syndrome carries no information about the logical amplitudes, so it leaves the superposition intact. Mistakes in implementing the measurement can still introduce errors, which is why the checks must themselves be fault tolerant.

"The threshold is one number." It depends on the whole stack, from the code to the decoder to the noise model.

For readers who want the foundations behind these ideas, our guides to quantum entanglement, Heisenberg's uncertainty principle, and quantum mechanics cover the physics, and how quantum computers actually work places error correction in the wider machine.

What to ask when you read a quantum headline

Because the field mixes real milestones with promotional claims, a few questions sort most announcements.

• What was encoded: a memory, a gate, or a full algorithm?
• For how many correction cycles, and at what code distance?
• What was the logical error per cycle, and how does it compare with the best physical qubit?
• Was decoding done in real time or offline after the experiment?
• Were rare correlated events observed, and how were they handled?
• Who produced the numbers, and are they in a peer-reviewed paper?

A result that answers these clearly is easy to place on the road map. One that avoids them probably belongs in the "interesting, not yet decisive" pile.

Frequently asked questions

Q: What is quantum error correction? A: It is a method for protecting quantum information by encoding one logical qubit across many physical qubits and measuring error syndromes that locate faults without revealing the encoded state. A classical decoder interprets the syndromes and the system applies or tracks corrections.

Q: What is the difference between a physical qubit and a logical qubit? A: A physical qubit is a hardware element such as a superconducting circuit, trapped ion, or neutral atom. A logical qubit is an encoded qubit spread across many physical qubits and kept alive by repeated syndrome rounds. Its quality depends on the code, the hardware, and the decoder.

Q: Why can't a quantum state simply be copied for redundancy? A: The no-cloning theorem, proved in 1982, forbids making an independent identical copy of an unknown quantum state. Codes get around this by entangling the logical state across several qubits rather than duplicating it.

Q: What does "below threshold" mean? A: It means physical error rates are low enough that making a code larger reduces the logical error rate instead of raising it. Google's 2024 experiment measured a suppression factor of 2.14 for each increase of two in surface-code distance, and a distance-7 memory that outlasted its best physical qubit by about 2.4 times.

Q: How many physical qubits does one logical qubit need? A: There is no fixed number. It depends on the code, the physical error rate, and the target logical error rate. A rotated surface code of distance d uses about 2d² − 1 qubits including checks, and IBM's qLDPC proposal estimates 288 physical qubits for 12 logical qubits, compared with nearly 3,000 for a surface code.

Q: Does a quantum computer need error correction for every task? A: No. Small experiments can run with error mitigation or no protection at all. Long, deep algorithms such as factoring a 2,048-bit number are estimated to need error correction, with resource estimates that depend on the algorithm and assumptions.

Q: Is error mitigation the same as error correction? A: No. Mitigation estimates what a noise-free result would be by running many noisy circuits and processing the outputs. Correction encodes information redundantly and fixes errors during the computation. Mitigation does not protect a stored quantum state.

The takeaway

Quantum error correction works by turning a hopeless-sounding problem, fixing information you cannot copy or read, into a manageable one: check how qubits relate to each other, and let a classical decoder infer which fault most likely occurred. The threshold makes the economics clear. Below it, bigger codes win; above it, they lose. Google's 2024 experiment is the clearest evidence so far that hardware can sit on the winning side, with a distance-7 memory that beat its best physical qubit.

What remains is the hard engineering around that core: logical gates, magic states, decoders that keep pace, wiring, cooling, and defenses against rare correlated events that distance alone does not remove. Treat any claim about a date for large-scale quantum computing as a hypothesis about those engineering problems, and judge it by the logical error per cycle, the code distance, and the decoder behind it.

---

Sources

• Acharya et al., "Quantum error correction below the surface code threshold" (Nature, 2025): arXiv:2408.13687
• Acharya et al., "Suppressing quantum errors by scaling a surface code logical qubit" (Nature, 2023): arXiv:2207.06431
• Bravyi et al., "High-threshold and low-overhead fault-tolerant quantum memory" (Nature, 2024): arXiv:2308.07915
• Bluvstein et al., "Logical quantum processor based on reconfigurable atom arrays" (Nature, 2023): arXiv:2312.03982
• Gidney, "How to factor 2048 bit RSA integers with less than a million noisy qubits" (2025): arXiv:2505.15917
• Shor, "Scheme for reducing decoherence in quantum computer memory" (Physical Review A, 1995): APS abstract
• Shor, "Fault-tolerant quantum computation" (1996): arXiv:quant-ph/9605011
• Gottesman, "Stabilizer Codes and Quantum Error Correction": arXiv:quant-ph/9705052
• Kitaev, "Fault-tolerant quantum computation by anyons": arXiv:quant-ph/9707021
• Fowler, Mariantoni, Martinis, Cleland, "Surface codes: Towards practical large-scale quantum computation" (Physical Review A, 2012): arXiv:1208.0928
• IBM Quantum, large-scale fault-tolerant roadmap: ibm.com/quantum/blog/large-scale-ftqc
• Background reading: Quantum error correction, Toric code, Quantum threshold theorem, and No-cloning theorem (Wikipedia)

This article is educational and does not forecast the arrival or commercial value of fault-tolerant quantum computing.

---

Read next:

• Quantum Machine Learning Explained: Hype, Promise, and Reality
• What Is Quantum AI and Why Experts Say It Changes Everything
• Quantum Mechanics Foundations Explained