Logical qubits: How quantum error correction turns noisy qubits into reliable ones

A logical qubit is a single, dependable unit of quantum information that is stored across many fragile physical qubits. Extra qubits act as a watch system that spots errors and lets software correct them before they ruin a calculation. The method is called quantum error correction.

It is the main reason quantum machines with thousands of physical qubits are still described as early. Raw qubits make mistakes constantly, and useful programs need far fewer mistakes than raw hardware delivers.

Why plain qubits are too fragile to compute with

A physical qubit is a tiny quantum object, such as a superconducting circuit cooled close to absolute zero. Heat, stray electromagnetic fields and imperfect control pulses all nudge it off course. Each nudge is a small error, and a long program strings together thousands of operations.

Think of a note passed along a line of 1,000 people by whispering. Even if each person garbles only one word in a thousand, the message that reaches the end is probably wrong. Quantum programs have the same problem, which is why reliability matters more than raw qubit count.

Spreading one answer across many qubits, with a vote

The classical fix for noisy messages is repetition. Send the bit three times and take a majority vote: if one copy flips, the other two outvote it.

Quantum error correction follows the same spirit, with a twist. A qubit cannot simply be copied, and looking at it directly destroys its state. So the information is instead spread over a group of qubits in a shared pattern. Extra helper qubits repeatedly run checks that reveal only whether something changed, not what the stored value is.

Those check results are called a syndrome. A classical program called a decoder reads the syndrome every cycle, guesses which physical qubit went wrong, and applies a fix. The group of physical qubits plus this loop is the logical qubit.

The distance dial and the threshold that decides if it works

Error-correcting codes come in sizes. In the surface code, a widely studied design that arranges qubits on a grid, the size is called the distance. A larger distance uses more physical qubits and can survive more simultaneous errors.

Here is the catch. Adding qubits also adds more places for errors to start. Whether bigger helps depends on a threshold: if the physical hardware is good enough, a larger code makes the logical qubit better. If it is not, a larger code makes it worse.

That is why a result from Google Quantum AI matters. In a 2024 paper, Quantum error correction below the surface code threshold (arXiv:2408.13687), the team reported surface code memories at distance 5 and distance 7. According to the paper, going up two steps in distance cut the logical error rate by a factor of 2.14. The distance-7 code used 101 qubits and ran at 0.143% logical error per correction cycle. The authors say it lasted about 2.4 times longer than the best single physical qubit in the same device.

Where logical qubits show up in today’s news

The idea is no longer confined to physics papers. In July 2026, IBM and the University of Chicago announced a computation on 70 logical qubits, with 2,415 logical two-qubit operations and 468 logical T gates (a type of gate that is costly to run reliably). IBM said the effective logical error rates were about 10 times lower than the physical error rates, and that the run took about 15 minutes.

IBM’s release describes a “novel construction of encoded quantum circuits” and does not name the code. It also gives no physical error rates or specific classical simulation estimates. The claim of beating classical methods comes from IBM and the university, and the full paper (arXiv 2607.25941) is where outside experts can check it.

The same ideas sit behind IBM’s Chicago hardware. Our report on IBM’s Nighthawk-powered Quantum System Two in Chicago covers the machine that organizations in Illinois can now work with. IBM has also paired Nighthawk with Oak Ridge’s Umbra system to test quantum error correction, as we reported on November 5.

The cost: Overhead, speed and the decoder

Error correction is expensive. Google’s distance-7 code needed 101 qubits to hold one logical qubit, so a machine with a few hundred physical qubits can host only a handful at that quality. Useful programs may need many more logical qubits and lower error rates still.

Speed is a second limit. The decoder must keep up with the hardware. In Google’s paper, the superconducting cycle time was 1.1 microseconds, and the real-time decoder averaged 63 microseconds of latency at distance 5, on runs of up to one million cycles. Decoding that fast, over bigger codes, is an engineering problem in its own right.

Rare events add a third. The Google team found that correlated error bursts, hitting many qubits at once, occurred roughly once an hour in long repetition code runs, and these set a floor on logical performance. Codes assume errors are mostly independent, so such bursts hurt.

Logical qubits also make verification harder to judge. IBM describes its result as establishing a lower bound on how faithfully the circuit ran, rather than an exact fidelity measurement. That is a useful distinction when comparing claims.

What to watch as logical qubits scale

• Logical error rate per cycle: does it keep falling as codes grow, as the threshold theory predicts?
• Qubit overhead: how many physical qubits each logical qubit needs, and whether newer codes reduce that.
• Real-time decoding: whether classical hardware can keep pace as codes get larger, which links quantum progress to ordinary chips and data centers.
• Independent checks: whether other groups reproduce or challenge the verification claims in the IBM and University of Chicago paper.
• Public access: IBM has not said how outside users get time on the Chicago machine, so it is unclear when ordinary researchers could try error-corrected circuits.

The number to follow is not total qubits but how many logical qubits a machine can run at what error rate. That figure decides when quantum computers move from demonstrations to tools.