Error Correction and Logical Qubits

This is the most important lesson in the module, because the physical against logical distinction is the one that lets you read announcements correctly.

Why the classical approach fails

Classical error correction is straightforward in principle. Store each bit three times. If one copy flips, majority voting recovers the original.

Both halves of that are unavailable.

You cannot copy. The no-cloning theorem from Module 1 forbids duplicating an unknown quantum state.

You cannot look. Checking a qubit's value means measuring it, which collapses the superposition and destroys the computation you were protecting.

There is a further problem. A classical bit has one way to fail: it flips. A qubit has a continuum of possible errors, since its amplitudes can be disturbed by any amount in any direction, including phase errors with no classical counterpart at all.

For some years it was unclear whether quantum error correction was possible at all. That it is possible is a genuinely surprising theoretical result.

How it actually works

The trick is to measure something carefully chosen: information about whether an error occurred, without learning anything about the data.

Spread the information of one qubit across many physical qubits in an entangled arrangement. Then measure certain combined properties, called syndromes, such as whether two particular qubits agree with each other. Crucially, whether they agree is independent of what value they hold. You learn that an error has occurred and where, without learning the data, so the superposition survives.

Knowing which error occurred, you correct it. The continuum of possible errors turns out to be manageable too: measuring the syndrome forces any continuous error into one of a discrete set, which can then be handled.

The cost is the qubits. One protected logical qubit is built from many physical qubits working together.

The overhead, and why headlines mislead

Here is the number that matters.

Depending on the code and the underlying error rate, a single logical qubit may require anywhere from hundreds to thousands of physical qubits.

So consider two announcements.

• A processor with 1,000 physical qubits. Impressive engineering. Under surface code assumptions it might yield a small handful of logical qubits, perhaps very few indeed.
• A machine with 1,000 logical qubits. A completely different object, implying perhaps a million or more physical qubits, and capable of running substantial algorithms.

Headlines almost never distinguish these. When you read a qubit count, the first question is always which kind, and the honest answer for most current hardware is physical.

Estimates for breaking RSA-2048 typically call for thousands of logical qubits sustained over billions of operations, which under current schemes translates into millions of physical qubits. Set against a few hundred noisy physical qubits today, that is the gap.

Below threshold

There is a threshold theorem stating that if the physical error rate is below a certain value, then adding more physical qubits per logical qubit makes the logical error rate fall exponentially. Above that threshold, adding qubits makes things worse, because the correction machinery introduces more errors than it fixes.

Everything depends on which side of the line you are on. Below it, scaling works and fault tolerance is an engineering problem. Above it, no amount of scale helps.

In December 2024, Google reported with its Willow processor that increasing the code distance suppressed the logical error rate, and that the protected logical memory outlived the best individual physical qubit. That is the experimental demonstration of being below threshold, and it is the most significant hardware result in the field's recent history.

It is worth being precise about what it does and does not show. It demonstrates that the error correction principle works in practice on real hardware, which was not previously established at that quality. It does not deliver a useful machine, and the demonstration concerned a quantum memory rather than a full computation.

The correct reading is that a crucial question has been answered favourably and a very large engineering programme now follows. Several groups have since reported growing numbers of logical qubits using various approaches, and the leaderboard changes frequently enough that specific counts date quickly.

There is also active work on reducing the overhead itself. IBM has pursued qLDPC codes, which promise roughly an order of magnitude fewer physical qubits per logical qubit than the surface code. If such approaches hold up at scale, the timeline compresses substantially, which is why this is worth watching more closely than raw qubit counts.