Quantum error correction is a way to protect fragile quantum information by encoding one logical qubit across several physical qubits. It does not make the hardware error-free. Instead, it repeatedly gathers clues about errors, uses a classical decoder to interpret those clues and applies the result without directly reading the protected quantum state.

That distinction matters. A processor can have hundreds or thousands of physical qubits and still provide very few useful logical qubits. The cost of protection, the speed of the decoder and the quality of the hardware all determine whether an error-corrected machine can run a long computation.

Why quantum computers need error correction

A classical bit is built to stay in one of two states. A qubit is a controlled quantum system, and its state can be disturbed by imperfect gates, faulty measurements, heat, stray fields and interactions with its surroundings. If you need a refresher on the basic unit, start with what a qubit is.

Ordinary redundancy is not enough. You cannot simply inspect an unknown quantum state, copy it several times and take a majority vote. Measurement changes the state, and the no-cloning theorem prevents an arbitrary unknown state from being copied perfectly.

Quantum error-correcting codes work around those limits by spreading information across an entangled group of physical qubits. Carefully chosen measurements reveal an error pattern without revealing the logical value itself.

Physical qubits and logical qubits

A physical qubit is a controllable hardware element: for example, a superconducting circuit, trapped ion, neutral atom or photon. A logical qubit is encoded information protected by an error-correcting code.

IBM describes a quantum code using three parameters: [[n, k, d]]. Here, n is the number of physical data qubits, k is the number of logical qubits and d is the code distance. Distance describes how many errors are required to turn one valid encoded state into another without being detected.

A code of distance d can, in the ideal coding model, correct up to (d − 1) / 2 errors. Increasing distance can provide stronger protection, but only if the hardware is good enough. More physical qubits also create more places where something can go wrong.

This is why a raw qubit count does not tell you how capable a quantum computer is. The relevant questions include how many logical qubits the system supports, their logical error rate, how long they remain useful and which logical operations can be performed.

How the correction cycle works

The exact circuit depends on the code and hardware, but the working loop has four parts.

  1. Encode the state. The information of one or more logical qubits is distributed across a larger group of physical data qubits.
  2. Measure checks. Additional measurements test relationships among nearby qubits. These checks are often called stabilizer measurements.
  3. Build a syndrome. Changes in the check results create an error syndrome: evidence about where and when a fault may have happened.
  4. Decode and respond. Classical software compares the syndrome history with a noise model and chooses the most likely correction. A controller may update how later results are interpreted rather than immediately applying a physical gate.

The checks do not ask, “Is the logical qubit zero or one?” They ask whether the encoded state still obeys the relationships defined by the code. That is how the system can detect faults without collapsing the information it is trying to protect.

The loop must run again and again. A one-time correction is not enough for a computation made of many operations.

Bit flips, phase flips and harder error types

A simple classical repetition code can correct a flipped bit. Quantum errors include an analogue of that bit flip, usually represented by the X operation, but also phase flips, represented by Z, and combinations of both.

There are also correlated faults, leakage outside the intended two-state system, measurement errors and mistakes introduced by the correction circuit itself. Good code design therefore has to protect against multiple error types and keep the checking process from spreading damage.

One useful result is that continuous physical disturbances can be diagnosed through discrete syndrome outcomes. The decoder does not need a perfect analogue description of every disturbance. It needs enough measurement evidence to identify a likely error class and preserve the logical state.

What is a surface code?

A surface code lays out physical qubits on a two-dimensional grid and uses local checks between neighbours. It is attractive because many hardware platforms can connect nearby qubits more easily than distant ones.

A patch of surface code can encode a logical qubit. Its size is described by its distance. A larger distance lets the code tolerate more faults, but it uses more physical qubits and adds more syndrome data for the decoder to process.

The important condition is the error-correction threshold. If physical error rates are above the threshold, adding more qubits makes the logical result worse. If they are below it, increasing code distance should reduce the logical error rate.

Google Quantum AI reported a below-threshold surface-code memory on its Willow processor in a paper published on December 9, 2024. The experiment compared distance-3, distance-5 and distance-7 grids. The Nature paper reports that increasing distance by two reduced the logical error rate by a factor of 2.14 ± 0.02, with a 101-qubit distance-7 memory reaching 0.143% ± 0.003% error per correction cycle.

That result showed scaling in the right direction for a quantum memory. It did not deliver a general-purpose fault-tolerant computer. The experiment protected a logical memory; useful machines also need reliable logical gates, state preparation, measurements and control over long programs.

The decoder is part of the computer

Syndrome measurements are only clues. A decoder has to turn a stream of noisy checks into a practical correction decision.

That makes quantum error correction a hybrid workload. The quantum processor generates syndrome data, while classical processors perform inference fast enough to keep up with repeated correction cycles. If the decoder falls behind, the machine accumulates a backlog while the quantum state continues to evolve.

In the Willow experiment, the Nature paper reports an average decoder latency of 63 microseconds for a distance-5 code, while the correction cycle took 1.1 microseconds. The experiment used pipelining so real-time decoding could continue for as many as one million cycles. Those figures describe that implementation, not a universal decoder speed.

Hardware, code and decoder cannot be judged independently. A better noise model can improve decoding. Faster measurement can create a tougher latency requirement. A denser code can reduce qubit overhead but demand different connectivity or more complicated checks.

Why error correction uses so many qubits

Protection costs hardware. A surface-code logical qubit can require hundreds of physical qubits at practical code sizes, and a full computation needs many logical qubits plus space and time for logical operations.

Researchers are therefore exploring alternatives. IBM has highlighted quantum low-density parity-check, or qLDPC, codes designed to reduce overhead. In one published construction, IBM describes a [[144,12,12]] code using 144 data qubits plus 144 check qubits to protect 12 logical qubits. The company estimates that a comparable surface-code memory task would require close to 3,000 qubits.

That comparison is a proposal based on a particular code and task, not a claim that qLDPC has replaced the surface code on production hardware. Lower-overhead codes may require non-local connections, different decoders or more complex fault-tolerant operations. Surface codes remain valuable partly because their local grid maps cleanly to several hardware designs.

Error correction is not the same as fault tolerance

Quantum error correction protects encoded information. Fault tolerance is the broader requirement that the whole computation remains reliable even when faults occur during encoding, checking, gates, measurement and control.

A fault-tolerant system needs more than one long-lived logical qubit. It needs operations that do not let a small physical fault cascade into an uncorrectable logical error. It also needs sufficiently accurate logical gates, stable calibration, fast classical control and a way to prepare special resource states for some operations.

A useful checklist for a new claim is:

  • Was the result a memory experiment or a computation?
  • Did a larger code reduce the logical error rate?
  • How many physical qubits produced how many logical qubits?
  • Was decoding performed in real time?
  • Which logical gates were demonstrated?
  • How long did the experiment run, and what stopped further improvement?
  • Were correlated faults and leakage measured?
  • Is the result peer-reviewed, and are the methods available?

A milestone in one row does not answer the others.

What quantum error correction changes—and what it does not

Below-threshold performance is important because it turns scaling from a liability into a potential advantage. Once physical operations are good enough, a larger code can suppress logical errors instead of multiplying them.

The remaining gap is still large. Google’s 2024 research blog contrasts today’s roughly one-in-a-thousand physical-operation failure rate with the far lower logical error rates required for long algorithms. The same post reports an error floor in a large repetition-code experiment, caused by rare correlated events that were still under investigation.

So quantum error correction is best understood as an engineering stack, not a single switch. It combines better qubits, an encoding scheme, repeated syndrome measurements, a decoder and fault-tolerant operations. Progress requires all of them to improve together.

Sources