One more qubit = ×2 states
Adding 10 qubits multiplies the state space by 1024. Growth is multiplicative, not additive.
Exponential
Qubit vs Classical Bit Calculator
See exponential growth in action: n qubits span 2n basis states. Compare that with classical bits and estimate how much RAM a full state vector needs—or how many qubits your RAM can hold.
Exponential growth: n qubits → 2n states
Basis states
—
All orthonormal states an n-qubit register spans (2n)
State-vector size
—
Bytes if you store every amplitude
Readable RAM
—
Binary units for the state vector
Classical table of all bitstrings
—
n·2n bits to list each basis state once
State-vector RAM vs 1 TB
Classical RAM → maximum simulatable qubits
Max qubits (state vector)
—
Floor of log2(RAM / bytes per amplitude)
States at that size
—
2maxQubits basis states
State-vector footprint
—
Bytes consumed by those amplitudes
Headroom left
—
RAM not occupied by the state vector
How to read these numbers
- 2n basis states: n classical bits have 2n possible bitstrings, but a quantum register can hold a superposition over all of them at once. We show that count directly as a formatted integer.
- State-vector memory: Simulating n qubits classically means storing 2n complex amplitudes. With 16 bytes per amplitude (double-precision complex), that is 2n·16 bytes. Single precision halves it; higher precision doubles it.
- Classical table: Listing every basis bitstring once takes n·2n bits—already exponential even before amplitudes. The RAM figure ignores indexing overhead to stay conservative.
- RAM → qubits: We invert the same math: max qubits = ⌊log2(RAM / bytesPerAmplitude)⌋. If the ratio is < 1, you cannot store even one full amplitude set.
- Bar vs 1 TB: The bar compares state-vector size to 1 TB of memory. It caps at 100% for readability but the numbers stay exact.
This is a back-of-the-envelope, state-vector view. Tensor networks, sparsity, or algorithm-specific tricks can simulate some circuits with fewer bytes, but the exponential ceiling still appears for generic states.
Quick quantum vs classical facts
State-vectors get heavy fast
50 qubits at 16 bytes per amplitude need ~16 PB. 60 qubits blow past exabyte scale.
Memory wall
Measurement is classical
You only read one basis string per run. The power comes from interference before measurement.
Collapse
Simulators hit ~45–50 qubits
On a 1–2 TB workstation, full state-vector simulators top out near 45–50 qubits at double precision.
Practical limits
Structured circuits cheat the wall
Algorithms with low entanglement (e.g., certain shallow circuits) can be simulated with tensor networks beyond 50 qubits.
Low entanglement
Why compare qubits to classical bits?
Classical bits carry a single 0 or 1. n bits let you pick exactly one of 2n strings at a time. Qubits extend that space: an n-qubit register is a vector in a 2n-dimensional complex space, with an amplitude attached to every basis string. That is why the state-vector memory scales as 2n—you track a complex number for every possible classical configuration.
The RAM estimator translates the abstract 2n into hardware cost. At 30 qubits, storing the full vector is already about 16 GB in double precision. Each new qubit doubles that. By 45 qubits you are near half a petabyte; by 60 qubits the number is so large that traditional clusters struggle unless the circuit has exploitable structure. This is why quantum speedups can appear: the space being explored is too large to enumerate classically.
Keep in mind that practical quantum algorithms rarely need the full state vector printed out. The point is to manipulate amplitudes so that when you finally measure, the desired basis state is likely. These calculations simply show the gap between “I can list all classical states” and “I can hold a coherent superposition of them.”