Logical vs Physical Qubits: Why One Needs Many

When a company says its chip has 1,000 qubits, it almost always means physical qubits. When experts talk about what it takes to run big, useful programs, they mean logical qubits. The two numbers can be very far apart.

If you mix them up, you will badly misread the news. A headline about 1,000 qubits does not mean 1,000 reliable qubits. This page explains the difference in plain words, and shows why one logical qubit costs so many physical ones.

A physical qubit is one real object that holds a qubit. It might be one tiny loop of metal on a chip. It might be one atom held by a laser. It might be one charged atom in a trap. You can see how each kind is built in types of quantum computers.

Physical qubits are noisy. Every gate has a small chance to go wrong. Qubits also slowly forget their state. For example, IonQ reports a two-qubit gate fidelity of 99.6% for Forte. That sounds great. But it means about 4 failures in every 1,000 gates.

Now think about a long program. Useful programs, like breaking big codes, need billions of gates. With 4 failures per 1,000, a program that long would be full of errors. No amount of luck saves it. You need a way to catch and fix errors as you go.

A logical qubit is one qubit you can trust. It is not one object. It is a team of physical qubits working together to hold one qubit's worth of information.

Here is an everyday picture. Say you need to send one important word over a bad phone line. You do not say it once. You say it three times: "yes, yes, yes". If the other person hears "yes, no, yes", they can guess you meant "yes". The three words together act as one reliable word.

A logical qubit works in a similar way. The three words are like three physical qubits. The one word they carry is like the logical qubit. The listener's guess is like the error correction step.

But the picture has a limit. Unlike words, you cannot just copy a qubit. A rule of quantum physics called no-cloning forbids it. You also cannot look at a qubit without changing it. So error correction must be cleverer. It checks whether qubits agree with each other, without ever reading their values. The chapter on the no-cloning obstacle shows how this is possible.

The circuit stores one logical 1 as three physical 1s: 111. Then it flips the middle qubit on purpose, to act like an error. So the qubits now read 101.

A note on reading bitstrings: the leftmost digit is qubit 2 and the rightmost is qubit 0. So 101 means qubit 2 is 1, qubit 1 is 0, and qubit 0 is 1. The middle one is the one that broke.

Count the votes. Two qubits say 1 and one says 0. The majority wins, so the logical value is still 1. One error was not enough to fool the team.

This is called a repetition code. It is the simplest code. It only guards against one kind of error, the bit flip. Real qubits also suffer phase flips, which change the sign of an amplitude. A full code must catch both. You can build this code step by step in the chapter on the bit-flip code.

Three qubits can survive one error. But what if two errors hit at once? Then the vote goes the wrong way. To survive two errors, you need a bigger team. To survive three, bigger still.

Experts describe this with a number called the distance of a code. A code of distance d can fix up to (d − 1) ÷ 2 errors at once. Distance 3 fixes 1 error. Distance 5 fixes 2. Distance 7 fixes 3.

The most studied code is the surface code. It lays qubits out on a flat grid. A surface-code patch of distance d uses about 2 × d × d physical qubits. Work the numbers:

• Distance 3: 2 × 3 × 3 = 18, so about 17 or 18 qubits.
• Distance 7: 2 × 7 × 7 = 98, so about 97 or 98 qubits.
• Distance 25: 2 × 25 × 25 = 1,250 qubits.

This is plain arithmetic about the code, not a figure from any vendor. How much distance you need depends on how good your physical qubits are and how long your program is. Better qubits need less distance. That is why vendors work so hard on fidelity.

And the bill does not stop at qubits. Error correction also costs time, because the checks run over and over. It costs a fast normal computer too, which must read the checks and decide what went wrong in real time. The chapter on logical qubits and overhead works through the full bill.

No. There is no single exchange rate. It depends on four things:

1. The code you pick.
2. The distance you run it at.
3. The error rate of your physical qubits.
4. How reliable you need the answer to be.

Some claims use very different ratios. Quantinuum reports 48 error-corrected logical qubits at a 2:1 encoding rate on Helios. That means two physical qubits for each logical one. That is a very different code from a large surface-code patch. The two protect in different ways, so you cannot judge them by the ratio alone.

So when you see a logical-qubit number, ask: which code, what distance, and how many errors can it fix?

This one catches many readers out.

• Error detection can tell that something went wrong. Then you throw that run away and try again.
• Error correction can tell what went wrong and fix it, so the run keeps going.

Think of a smoke alarm and a sprinkler. The alarm tells you there is a fire. The sprinkler puts it out. Detection is useful, but it does not scale to very long programs. If you throw away every run with an error, long programs almost never finish.

Some claims are for detection only. Quantinuum reports 94 logical qubits fully entangled with error detection on Helios. Infleqtion lists 8+ logical qubits with error detection on Sqale. Those are real results. But they are not the same as 94 or 8 fully corrected qubits.

Here is what our records show. All of it is vendor-reported.

• Google Willow ran surface codes at distances 3, 5 and 7. Each step up in distance cut the logical error rate by a factor of 2.14. This number is called Λ (lambda). A Λ above 1 means a bigger patch really does protect better. That is the key test error correction must pass.
• Quantinuum Helios: 48 error-corrected logical qubits at a 2:1 rate, and 94 with error detection.
• Atom Computing, with Microsoft: 24 logical qubits entangled, and an algorithm run with 28 logical qubits.

Now the other side. Big useful programs need many more. Breaking RSA-2048 is estimated to need roughly a million physical qubits running error correction for days. See can quantum break RSA-2048? Machines with hundreds of logical qubits are still roadmap targets for around 2029 to 2030, as our fault tolerance page records.

So the honest summary is this. The idea works on real hardware. The scale is still far away.

• If it does not say "logical", assume it means physical.
• If it says logical, look for the code, the distance, and whether it is detection or correction.
• Check whether it is a result or a roadmap plan.
• Never compare a physical count from one machine with a logical count from another.

To go deeper, take the Errors, Noise and Quantum Error Correction course. It lets you encode, break and fix qubits yourself. The course chapter on physical vs logical qubits is a good short start.