Why are qubits fragile, and how do we fix that?

Every operation is a small gamble. If each one succeeds 999 times in 1,000, then two in a row succeed 998 times in 1,000, a hundred in a row about 905 times, and a thousand in a row only about 368 times. The odds multiply down.

Your laptop's processor runs billions of operations a second for years, and its bits almost never flip by accident. Quantum hardware is nowhere near that. Its errors come from chapter 3's enemy, decoherence, plus slightly imprecise control: a gate that turns the arrow 179.9° instead of 180°.

The simplest trick is repetition. Store each bit three times: 000 or 111. If one copy flips, say to 010, a majority vote restores 000. Only two flips at once would fool it. Phones, satellites and hard drives use far cleverer versions of the same idea.

Three things stand in the way.

1. You can't copy a qubit. The no-cloning theorem (page 5a) forbids making a copy of an unknown quantum state. No backups.
2. You can't look. Measuring a qubit to check it destroys the very in-between state you're trying to protect (chapter 2).
3. Errors aren't just flips. A qubit's arrow can drift by any small angle, and the hidden direction can drift too (page 3b's "wobble"). There's a whole range of possible errors, not just two.

For a while some physicists thought these made quantum computers impossible to protect.

In 1995 Peter Shor found the way, and Andrew Steane found another the next year. The idea has two parts.

Spread, don't copy. Instead of copying the qubit, you entangle it with others so all of them share its information. No single qubit holds it, and no copy exists.

Ask about relationships, not values. Instead of measuring each qubit, you measure questions like "do qubits 1 and 2 agree?" These parity checks reveal whether an error happened and where, without revealing the information itself. The protected state survives.

One more piece of good luck: measuring the checks forces any small drifting error to become either "no error" or "a full flip". The infinite range of possible errors collapses into a few you can fix.

The qubits on the chip are physical qubits. The protected qubit they share is a logical qubit. A useful quantum computer runs its program on logical qubits, while the physical ones underneath constantly check and fix each other.

The best-known scheme is the surface code, proposed by Alexei Kitaev in 1997: physical qubits laid out on a grid, with check qubits between them asking parity questions over and over. Optional page 8a walks through it.

Here's the catch. The checks are themselves made of imperfect qubits. Add more qubits and you add more places for errors.

In the late 1990s several groups proved the threshold theorem: if each physical operation fails less often than a certain threshold, adding more qubits to the code makes the logical qubit better, and fast. Above the threshold, adding qubits makes it worse. For the surface code the threshold is roughly 1 error in 100 operations.

So the whole field has been racing to get physical errors below the threshold, then to grow codes big enough that logical errors become vanishingly rare.

With the surface code and today's error rates, roughly hundreds to a thousand physical qubits for each high-quality logical qubit. Newer codes (called qLDPC codes) promise to need far fewer, but need qubits that can talk across longer distances. Chapter 11 compares how each hardware type copes.

Yes, in the last few years, for the first time.

• December 2024: Google's Willow chip showed that each step up in surface-code size roughly halved the logical error rate. That's the first clear demonstration of working below threshold on a surface code.
• December 2023: a Harvard and QuEra team ran programs on 48 logical qubits made of neutral atoms.
• November 2025: Quantinuum's Helios, a trapped-ion machine, entangled 94 logical qubits with error detection and ran 48 fully error-corrected ones, each made from just two physical qubits. The same month, Harvard, MIT and QuEra showed every ingredient needed for fault tolerance working together on 448 atoms, also below threshold.
• 2026: companies are reporting logical error rates near one in a hundred thousand, so far as company claims without peer review. Check the dated list on page 8b.

As of October 2026, nobody has yet run a long, useful program on a large set of high-quality logical qubits. That's the goal of every roadmap in chapter 11. Optional page 8b keeps a dated list.

Two less famous problems:

• Decoding fast enough. An ordinary computer must read the checks and work out the fix in under a millionth of a second, round after round. UK company Riverlane, among others, builds decoders for exactly this.
• Some gates are expensive. Error-corrected machines can do most gates cheaply, but one essential kind needs special prepared states, made in "factories" that use a large share of the qubits. Chapter 13's Q-Day estimates count those costs.