The 34-Qubit Wall: Why Free Quantum Simulators Stop, and How to Go Past It

Every free quantum simulation tier caps at close to the same number: 34 qubits. This is not a coordinated product decision, nor a commercial one. It is arithmetic, and the arithmetic admits no engineering response.

The calculation

A statevector simulator stores one complex amplitude per basis state, and n qubits have 2^n basis states. In double precision each amplitude is two 8-byte floats, so the register costs exactly 16 x 2^n bytes. Nothing about the circuit changes this; it is the cost of the representation, paid before a single gate is applied.

Qubits   Statevector memory   Fits on
    30              16 GiB   a large workstation
    32              64 GiB   an 80 GB datacentre GPU
    34             256 GiB   a dedicated memory node
    35             512 GiB   a very large memory node
    40              16 TiB   a cluster, at considerable cost
    45             512 TiB   nothing you will rent
    50              16 PiB   nothing that exists

Two properties of this table deserve attention. The first is that the step between rows is a factor of two per qubit, so the distance between a circuit that runs comfortably and one that is impossible is roughly four qubits. The second is that the exponent is in the requirement, not in the supply. Available memory per machine grows roughly linearly with time; the requirement grows exponentially with qubit count. The gap widens permanently. No hardware roadmap closes it for an arbitrary circuit, and any claim to have done so is a claim to have found structure in the circuit rather than memory in the machine.

It is worth stating the consequence plainly, because it is often softened. Exact simulation of a generic 50-qubit circuit is not difficult, or expensive, or a matter for future hardware. It is impossible, and will remain so.

Why the wall is largely irrelevant in practice

The wall applies to arbitrary circuits. Circuits that arise in actual research are not arbitrary. They are built from repeated layers, restricted gate sets, local interactions and bounded entanglement, and each of those properties is a structure that some method exploits.

This reframes the question. Asking how many qubits a platform supports is asking about the worst case, which is rarely the case at hand. The useful question is which structural property a given circuit possesses, because that determines which method applies and therefore what the circuit costs.

Route one: Clifford structure

Circuits built entirely from Clifford gates (H, S, CNOT, CZ, the Paulis, measurement) are simulable in polynomial time by the Gottesman-Knill theorem. A stabilizer simulator tracks n generators of about 2n bits each rather than 2^n amplitudes, so storage is quadratic and a 5,000-qubit state occupies roughly 6 MB.

The result is exact, not approximate. On this platform a 5,000-qubit GHZ circuit with 5,000 layers of depth completes in 0.56 seconds. The restriction is absolute: one T gate or one arbitrary-angle rotation removes the guarantee and returns the circuit to exponential cost. The method is developed in Clifford circuits and Stim.

This route matters disproportionately because quantum error correction is built almost entirely from Clifford operations, so the subfield with the largest qubit counts is also the one classical simulation handles best.

Route two: bounded entanglement

A matrix product state represents the register as a chain of tensors linked by bonds, where the bond dimension across a cut is set by the entanglement across that cut. A product state needs bond dimension 1. A maximally entangled state needs bond dimension exponential in the width, at which point nothing has been gained. Most circuits sit far closer to the first case than their width suggests.

The reason is that entanglement takes time to build. A circuit of depth d on a line spreads correlations over roughly d sites, so a shallow circuit on 100 qubits has entanglement characteristic of a much smaller system. QAOA instances, hardware-efficient ansatze and Trotterised dynamics all fall into this regime. A 100-qubit depth-304 QAOA circuit runs in 5.9 seconds on a laptop CPU.

The cost is that truncating the bond dimension discards weight, making the method approximate. The compensation is that the discarded weight epsilon is known during the run and bounds the error on any outcome probability by sqrt(2 x epsilon). The approximation is therefore quantified rather than hoped for, which is what distinguishes it from a heuristic.

Route three: shallow circuits and expectation values

Many questions do not require the full output distribution. A variational algorithm needs the expectation value of a Hamiltonian; a dynamics study needs a correlator. Pauli propagation answers these directly by evolving the observable backward through the circuit rather than the state forward, working in the Heisenberg picture.

Because the initial state is typically all-zeros, its expectation against any Pauli string is read off by inspection, and the entire computation moves into transforming the observable. Clifford gates map one Pauli string to one Pauli string at no cost; non-Clifford rotations split one into two, so the term count grows with the number of rotations rather than with the qubit count. Truncating terms below a cutoff bounds the count, and the discarded coefficient mass bounds the error.

This is the method that reproduced IBM's 127-qubit utility experiment on classical hardware within weeks of publication. It reaches hundreds of qubits for shallow circuits and is examined in Pauli strings, channels and propagation.

Comparing the routes

Method         Exploits            Reaches     Error       Fails when
Statevector    nothing             ~32q        none        n > 32
Stabilizer     Clifford gate set   1000s+      none        any T gate
Tensor net     low entanglement    100-1000    sqrt(2eps)  deep, non-local
Pauli prop.    shallow depth       100s        coeff mass  many rotations

The columns that matter are the last two. A method with no error column is exact within its domain and useless outside it. A method with a computable error column can be pushed past its comfortable regime and will report how far the answer might be from the truth, which is a different and more useful failure mode than silence or a wrong number.

What accuracy requires

Every approximate method needs a stated bound, and the bound needs to be derived rather than asserted. Two independent checks are worth insisting on.

The first is the analytic bound: sqrt(2 x epsilon) for matrix product states, discarded coefficient mass for Pauli propagation. Both are computed from quantities the algorithm already tracks, so they cost nothing.

The second is a convergence check: re-run at double the bond dimension and compare. If the outcome probabilities do not move, the compression captured the state. If they move, the first run was under-resourced and the answer should not be used. This is a stronger test than the analytic bound in practice, because it detects errors the bound was not designed to catch.

A platform that returns an approximate number without either check is reporting a quantity of unknown reliability. The distinction is the subject of How we certify simulation error.

Circuits that pass through no door

Some circuits defeat all three routes at once: deep, wide, non-local and highly entangled, with many non-Clifford rotations. Random circuit sampling instances are constructed specifically to have this property, which is why they were chosen for supremacy demonstrations rather than because they are useful.

For these, no classical method succeeds, and this should be stated without hedging. It is not a platform limitation. It is the frontier of classical computation, and a vendor claiming otherwise is either exploiting structure they have not disclosed or reporting an unbounded approximation.

It is worth noting that such circuits are also close to the limit of what current hardware produces meaningfully, since depth and noise trade against each other. The regime that is hard to simulate is largely the regime that is hard to execute.

The practical conclusion

The 34-qubit figure on a pricing page describes one method under one memory budget. It does not describe a circuit, and it is the wrong number to plan against.

The questions worth asking are whether the circuit is Clifford or nearly so, how much entanglement it generates relative to its width, whether the quantity of interest is an expectation value rather than a full distribution, and what error bound the answer will carry. When the answers are favourable, 100 qubits and beyond costs a fraction of a cent. When they are not, no simulation tier will help, and the honest response is to say so.