What is quantum error correction?

Someone reads you a long account number over a bad phone line, and you miss a digit. So you ask them to say the number again, twice more. Then you take whichever digit came up most often in each position.

That is error correction. You send extra copies, you compare them, and you fix what does not match. Every hard drive, every phone call and every scanned barcode uses some version of it.

Quantum error correction does the same job for qubits. However, it is much harder, for one blunt reason. With a qubit, listening to the digits destroys them.

Why does a quantum computer need this?

Qubits are delicate, because heat, stray fields and small knocks push them off course. A qubit can also drift slowly, so a state that was right at the start of a run is slightly wrong by the end.

Normal computers barely have this problem, because a bit is a strong electrical signal, well clear of the noise. The hardware fixes the rare slip without telling anyone.

A useful quantum program may need millions of steps in a row. If each step carries even a small chance of going wrong, the run is ruined long before the end. Therefore errors have to be found and fixed while the program is still running. Read our guide to qubits for why they are so easily disturbed.

What kinds of error can a qubit have?

Two, at heart.

The first is a bit flip, and a 0 turns into a 1, or the other way round. This is the same error an ordinary computer can suffer.

The second is a phase flip, and an ordinary computer has no twin for it. Remember that a qubit carries a timing as well as a value. A phase flip leaves the values alone and reverses that timing. It sounds harmless. It is not, because timing is what makes right answers add up and wrong ones cancel.

Any other error can be treated as a blend of those two. Therefore a code that catches both catches everything.

Why the phone line trick does not work

The obvious fix is to copy the qubit three times and take the majority. Two rules block it.

First, you cannot copy an unknown quantum state. That is a proven result of physics, and better tools will not get around it.

Second, you cannot look. Measuring a qubit forces it to settle on 0 or 1 and throws the mix away. So the moment you check your copies, you have destroyed the very thing you were trying to protect.

The way around it: ask about relationships

Here is the idea that makes the whole field work.

You do not have to ask what each qubit holds, and you can instead ask whether two qubits agree. “Are these two the same?” has a yes or no answer, and it can be answered without revealing what either qubit actually is.

So spread one piece of information across many qubits. Then keep asking those agreement questions, over and over, between neighbours. The pattern of yes and no answers tells you where an error struck and what kind it was. That pattern has a name, and it is called the syndrome.

Think of a market stall weighing sacks of maize. You never open the sacks, and you put them on a balance in pairs and watch which side tips. That tells you which sack is wrong without ever looking inside one.

What is a logical qubit?

A logical qubit is the steady qubit you actually compute with. It is spread across a block of physical qubits, and the agreement checks keep it honest.

The best known family of codes lays the qubits out on a flat grid. Some of them carry the data, and the rest sit between them and ask the agreement questions. This layout is called a surface code, and it is popular for a very practical reason. This is because each qubit only has to talk to its neighbours, and that is what real chips can do.

The price is size. Estimates vary with the design and with how good the hardware is, and one logical qubit can take hundreds or thousands of physical ones. Our guide to qubits explains why headline qubit counts are usually the physical kind.

What is the threshold, and why does it matter?

This is the most important idea on the page, so read it twice.

Adding more qubits also adds more places for errors to appear. So a bigger code is not always a better code, and whether it helps depends on how good your physical qubits already are.

There is a break-even point, and it is called the threshold. If your hardware error rate sits above it, making the code bigger makes things worse. However, if the error rate sits below it, making the code bigger makes the logical qubit better. In that case you can push the error rate as low as you like by adding more hardware.

Therefore the whole race comes down to two moves. Get the hardware below the threshold. Then scale up.

Where has this got to?

The theory has been settled for a long time, but the hardware is the slow part.

By the middle of the 2020s several groups had passed a real milestone. They built a bigger code, ran it, and showed that it beat a smaller version of itself. In other words, adding qubits made the logical qubit better rather than worse. That is the sign that hardware has crossed the threshold for that code.

The next step is running many logical qubits together, for a long time. Decoding matters here. A separate ordinary computer has to read the stream of agreement checks and work out the errors faster than fresh ones arrive. If the decoder falls behind, the machine stalls.

What to watch, and what to do

When you read a claim about a quantum machine, look for four things.

• The error rate for each operation, and whether it sits below the threshold for the code being used.
• Whether a bigger code beat a smaller one in the same experiment.
• How many logical qubits ran at once, rather than how many physical qubits exist.
• Whether the decoder kept up in real time.

Then check one thing closer to home. Error correction is what will eventually make quantum computing useful, and one of its first uses is breaking today’s encryption. If you hold data that must stay private for ten years, start reading about post-quantum cryptography now.

Just Out Tech explains new research in plain language. This article was drafted with AI assistance and checked by a human against the original source.