Overhead and Scalability

Protection has a price

The threshold theorem promises that overhead grows only polylogarithmically in the target accuracy — but the constants matter enormously in practice. Fault tolerance buys reliability by spending physical qubits, and an honest architecture must count them. The dominant cost in surface-code machines is the number of physical qubits per logical qubit, which is set by the code distance $d$.

Physical qubits per logical qubit

The rotated planar surface code encodes one logical qubit in a $d \times d$ array of data qubits, so it uses $d^2$ data qubits. Syndrome extraction needs one measurement ancilla in each plaquette of the dual lattices; counting them gives $d^2 - 1$ ancillas. The total footprint of one logical patch is therefore

The distance $d$ must be chosen large enough that the logical error rate per round meets the target. A standard fit to numerics for the surface code below threshold is

with $A \sim 0.1$ and $p_{\text{th}} \sim 1\%$. Each step of $d$ by $2$ raises the suppression power by one, so reaching a very small $p_L$ takes a $d$ of a few tens — and because the cost is $\sim 2d^2$, the per-logical-qubit overhead lands in the hundreds to low thousands of physical qubits.

A worked estimate

Suppose a target algorithm needs a logical error rate small enough that distance $d = 11$ suffices (a typical figure for $p/p_{\text{th}} \approx 0.1$ and moderate circuit depth). Then one logical qubit costs

physical qubits. Multiply by the number of logical qubits in the algorithm — and by the extra patches devoted to magic-state factories, which often dominate the area because non-Clifford gates are the expensive ones — and the totals climb to the millions for cryptographically relevant problems. The well-known resource estimate for factoring a $2048$-bit RSA modulus, for instance, lands near twenty million physical qubits at $p \sim 10^{-3}$.

The scalability picture

Because $d$ grows only logarithmically in $1/\varepsilon$, the asymptotic overhead is benign — this is the threshold theorem at work. What makes fault tolerance hard in practice is the large prefactor: hundreds of physical qubits per logical qubit, plus distillation, plus the requirement that $p$ sit comfortably below $p_{\text{th}}$ so the suppression base $p/p_{\text{th}}$ is small enough that a modest $d$ does the job. Improving hardware $p$ pays off twice — it both lowers the required $d$ and shrinks every factory.

Try it

Estimate the footprint of one logical qubit. For the rotated surface code at distance $d = 11$, compute the number of physical qubits $n_{\text{phys}} = 2d^2 - 1$. Return it as a plain number. (Compute from $d$; do not hardcode the answer.)

Sign in on the full site to ask questions and join the discussion.