Physical vs Logical Qubits

A physical qubit is one actual device you can point at: a superconducting circuit, a trapped ion, an atom, a photon path. When a spec sheet says "433 qubits", it almost always means physical qubits.

Physical qubits are noisy. Every operation has an error rate — the probability it does the wrong thing — and on current machines a two-qubit operation typically goes wrong somewhere between 1 time in 1,000 and 1 time in 100. A classical transistor, for comparison, errs so rarely that engineers usually ignore the possibility entirely.

A logical qubit is one qubit's worth of information stored redundantly across many physical qubits, arranged so that errors can be detected and corrected while the computation is still running. The recipe for spreading the information is called an error-correcting code.

The two counts answer different questions. Physical count: "how much hardware exists?". Logical count: "how much reliable computation can it do?". Comparing one vendor's physical count against another's logical count is a category error.

Start with the classical version. Store one bit three times and read it back with a majority vote: whatever value at least two of the three copies show, wins.

Say each copy flips with probability p = 0.1 (10%). The vote fails only if two or three copies flip. Work it out: the chance exactly two flip is 3 × 0.1² × 0.9 = 3 × 0.01 × 0.9 = 0.027 — the factor 3 counts the three possible ways of choosing which two of the three copies flipped — the factor 3 counts the three possible ways of choosing which two of the three copies flipped. The chance all three flip is 0.1³ = 0.001. Total failure: 0.027 + 0.001 = 0.028, i.e. 2.8% — down from 10%.

Now repeat with better parts, p = 0.01: failure is 3 × 0.0001 × 0.99 + 0.000001 ≈ 0.0003, i.e. 0.03% — a 33-fold improvement rather than 3.6-fold. Redundancy pays off more the better the raw parts already are, and below some quality threshold it stops helping at all. That threshold idea carries over to quantum codes.

Two quantum complications. First, qubits suffer two kinds of error, not one: bit flips (0 and 1 swap) and phase flips (the sign between the two amplitudes flips) — a plain repetition scheme catches only one kind, so real codes such as the surface code interleave two protections and cost more qubits. Second, an unknown quantum state cannot be copied (a result called the no-cloning theorem), so the code entangles qubits rather than photocopying them. The circuit below shows that entangling version for a definite input, where it behaves just like copying.

Step through it. The X on q0 sets the data bit to 1. The two CX gates spread that value onto q1 and q2 (CX flips its target exactly when its control is 1), so the value 1 is now encoded across three physical qubits. The final X on q1 deliberately injects one bit-flip error — the kind of fault real hardware produces at random.

Readout gives q0 = 1, q1 = 0, q2 = 1 on every shot. A decoder takes the majority: two votes for 1 beat one vote for 0, so the logical value 1 is recovered despite the error.

This toy code has distance 3: distance is the number of single-qubit errors needed to convert one valid encoded state into a different valid one. A distance-d code corrects up to (d − 1) / 2 errors — as long as fewer than half the distance has been crossed, the damaged state is still closer to the original valid state than to any other, so the vote points the right way — meaning distance 3 corrects exactly one. Which sets up the obvious question: what happens with two?

There is no universal ratio — only formulas with parameters you must be told. Take the surface code, the leading candidate for superconducting hardware. At distance d it uses roughly 2d² − 1 physical qubits per logical qubit.

Worked numbers: at d = 5, that is 2 × 25 − 1 = 49 physical qubits for one logical qubit. At d = 11, it is 2 × 121 − 1 = 241. A machine offering 100 logical qubits at distance 11 therefore needs about 100 × 241 = 24,100 physical qubits — before counting anything else the system needs.

And the right distance is not fixed either: it depends on how good the raw hardware is relative to the code's threshold and on how reliable the logical qubit must be for your algorithm. Push the target logical error rate down, and d — and the qubit bill — goes up.

So an honest logical-qubit claim states at least: the code family, the distance, the measured physical error rates, the target logical error rate, and the date of the evidence. One more distinction worth keeping sharp: small logical qubits that outperform their physical components have been demonstrated in experiments; machines with hundreds of logical qubits remain projections. Both statements can be true at once — they describe different things.

Almost every headline number you will meet on /hardware/qpus is a physical count. For judging near-term usefulness, the two-qubit error rate usually matters more than the qubit count — see the two-qubit fidelity metric — because it sets how much redundancy any future code will need. When comparing devices at /hardware/compare, check which kind of count each column reports before drawing conclusions.