A press release announces a 100-qubit or 1,000-qubit chip, and the number reads like a spec sheet entry, similar to a CPU's core count. Qubits don't add up the way classical bits do. Each one you add doubles the size of the space needed to describe the system, and this single fact explains why quantum computers are hard to simulate classically, and why a qubit count on its own tells you less than most headlines suggest.
Why n qubits means 2ⁿ, not n
A classical bit holds one of two values, so n bits describe one of 2ⁿ possible states, and a classical computer only ever tracks the single state currently occupied. A quantum register of n qubits holds a superposition across all 2ⁿ basis states at once, each with its own complex amplitude. Describing this register fully, on paper or inside a classical simulator, requires all 2ⁿ amplitudes, not one.
There's the entire source of the exponential wall. Ten qubits need 2¹⁰ = 1,024 amplitudes. Add ten more and you don't get 2,048, you get 2²⁰ = 1,048,576. Every added qubit roughly doubles the memory a classical simulator needs to represent the same system.
Turning this into memory, concretely
A full statevector simulation stores one complex number per amplitude, typically 16 bytes (two 8-byte doubles, real and imaginary). The memory required for n qubits works out to 2ⁿ × 16 bytes.
def statevector_bytes(n_qubits: int) -> int:
amplitudes = 2 ** n_qubits
return amplitudes * 16 # complex128: 16 bytes per amplitude
for n in [20, 30, 40, 50, 60]:
gb = statevector_bytes(n) / 1024 ** 3
print(f"{n} qubits: {gb:,.2f} GB")
Run this and the crossover point stops being abstract:
- 20 qubits: about 16 MB. Runs on a phone.
- 30 qubits: about 16 GB. A strong workstation, the kind our simulators comparison covers.
- 40 qubits: about 16 TB. Needs a small cluster.
- 50 qubits: about 16 PB, at the edge of what the largest supercomputers hold in memory today. This is why 50 qubits sits roughly where full statevector simulation stops being practical, even with world-class hardware.
- 60 qubits: about 16 exabytes. No existing machine holds this much memory.
A 100-qubit register needs 2¹⁰⁰ × 16 bytes, a number with over 30 digits. Global data storage capacity, across every server, drive, and device on the planet, sits in the tens of zettabytes (roughly 10²³ bytes). A full statevector for 100 qubits would need storage many orders of magnitude beyond this total. Nobody simulates a genuine 100-qubit circuit through brute-force statevector methods for this reason, and claims of quantum advantage rest on exactly this gap.
Alternatives to brute force, and their limits
Full statevector simulation isn't the only option. Tensor network methods represent lightly entangled states far more compactly and handle far more than 50 qubits when a circuit's entanglement structure stays simple. Our Quantum Volume piece covers why circuit depth and connectivity, not qubit count alone, determine how hard a circuit is to simulate or to run. Stabilizer simulators handle a separate special case (Clifford circuits) with full accuracy and speed regardless of qubit count, because those circuits stay classically tractable by construction. None of these methods rescue the general case: an arbitrary, highly entangled circuit on 100 or more qubits has no known classical shortcut. This is the real claim behind quantum advantage, not qubit count by itself.
Why qubit count alone overstates real power
The exponential argument above measures how hard a circuit is to simulate classically, not how much useful computation a quantum chip delivers. These are different questions, and headline qubit counts routinely blur them.
Current hardware is noisy. Every gate introduces error, and this error compounds with circuit depth. A 100-qubit NISQ chip runs nowhere near a deep enough circuit to exploit its full 2¹⁰⁰ state space before noise erases the signal. Our logical qubits and fault tolerance explainer covers why researchers now separate physical qubits from logical qubits: a "1,000-qubit" chip built from noisy physical qubits might yield only a handful of error-corrected logical qubits once redundancy gets accounted for. This lower number predicts what the device runs in practice.
This is also why Quantum Volume exists as a metric, folding qubit count together with connectivity and gate fidelity into one figure, precisely because qubit count by itself predicts device performance poorly. A device with fewer, cleaner qubits regularly outperforms one with more, noisier ones on real workloads.
What the number is good for
Qubit count still matters. The number sets the ceiling on how large a problem might, in principle, exceed classical simulation, and marks the point where brute-force classical verification stops working at all. What the number doesn't tell you is whether a given chip runs a useful algorithm today. For a real read, check the glossary entry on NISQ, read the fidelity and coherence numbers a vendor publishes alongside the qubit count, and treat the headline figure as an upper bound on possibility, not a measure of delivered performance.