What Is Quantum Circuit Simulation? A Practical Guide for 2026

Quantum circuit simulation is the use of a classical computer to compute what a quantum computer would output for a given program. Before a circuit reaches quantum hardware it is almost always run on a simulator first, and for most published research it is never run on hardware at all. Simulation is therefore not a preliminary step in quantum computing. For the majority of working researchers it is where the computing happens.

What a quantum circuit is

A quantum circuit is the standard model of quantum computation, analogous to a Boolean circuit in classical computing. It consists of a register of qubits, a sequence of gates applied to them, and measurements that extract classical bits.

A single qubit's state is a unit vector in a two-dimensional complex space, written as a combination of the basis states |0> and |1> with complex coefficients called amplitudes. An n-qubit register lives in the tensor product of n such spaces, which has 2^n dimensions. This is the origin of both quantum computing's power and the cost of simulating it: describing the state of 50 qubits requires 2^50 complex numbers, whereas describing 50 classical bits requires 50 bits.

Gates are unitary matrices acting on this state. The standard set includes single-qubit rotations (X, Y, Z, H, S, T, and parameterised rotations Rx, Ry, Rz) and two-qubit entangling gates (CNOT, CZ, SWAP). Unitarity means gates are reversible and preserve total probability, which is a constraint classical logic does not obey: a classical AND gate destroys information, and no quantum gate can.

Measurement is where the model stops being linear algebra. Measuring a qubit in the computational basis returns 0 or 1 with probabilities given by the squared magnitudes of the amplitudes, and collapses the state to the observed outcome. A circuit is therefore run many times, and the output is a distribution over bitstrings rather than a single answer. Each repetition is called a shot.

How simulation works

The most direct method, statevector simulation, stores the full amplitude vector and applies each gate as a matrix-vector product. It is exact up to floating-point precision and imposes no restriction on the circuit. Its cost is the problem.

In double precision each amplitude occupies 16 bytes, so an n-qubit register costs exactly 16 x 2^n bytes:

Qubits   Statevector memory   Practical status
    10             16 KiB     trivial
    20             16 MiB     trivial
    30             16 GiB     a large workstation
    32             64 GiB     an 80 GB datacentre GPU
    34            256 GiB     a dedicated memory node
    40             16 TiB     no single machine you will rent
    50             16 PiB     nothing that exists

Each additional qubit doubles the requirement, so the distance between comfortable and impossible is about four qubits. This is why simulation tiers commonly stop near 32 to 34: it is a memory constraint, not a commercial one. The consequences are examined in The 34-qubit wall.

Why simulation is preferred within its range

Where a simulator can hold the circuit, it is not merely cheaper than hardware but scientifically preferable, for four reasons.

• The answer is exact. Two-qubit gate error rates span roughly 0.01 percent on the best trapped-ion and silicon-spin devices to about 1 percent on widely available superconducting ones, and at the weaker end they corrupt deep circuits beyond recovery. A simulator returns the mathematically correct distribution regardless.
• The full state is visible. A simulator can report amplitudes mid-circuit, which physics forbids on hardware, where measurement collapses the state. Debugging a quantum algorithm without this is substantially harder.
• Iteration is immediate. Results return in milliseconds with no queue. Hardware queues run from minutes to hours, which matters when an algorithm is debugged over hundreds of runs.
• The cost difference is three orders of magnitude, examined in What does it cost to rent a quantum computer?.

The methods that go beyond brute force

The 2^n wall applies to exact simulation of arbitrary circuits. Circuits arising in research are not arbitrary, and each of the following methods trades generality for a specific structural assumption.

Stabilizer simulation handles circuits built only from Clifford gates (H, S, CNOT, CZ, Paulis, measurement). Rather than 2^n amplitudes it tracks n stabilizer generators, each about 2n bits, so storage is quadratic. The Gottesman-Knill theorem makes this exact, not approximate. A 5,000-qubit Clifford circuit simulates in 0.56 seconds. A single T gate voids the guarantee.

Tensor-network methods, principally matrix product states, represent the state as a chain of tensors whose size is governed by the entanglement across each cut. Circuits with bounded entanglement compress enormously; the bond dimension is the resource, and truncating it produces an error bound of sqrt(2 x epsilon) from the discarded weight epsilon. A 100-qubit depth-304 QAOA instance runs in 5.9 seconds on a laptop CPU.

Pauli propagation evolves the observable backward through the circuit instead of the state forward, in the Heisenberg picture. The initial state is usually trivial, so the work moves into transforming the observable, and truncating small terms bounds the error by the discarded coefficient mass. This reaches expectation values on hundreds of qubits for shallow circuits, and reproduced IBM's 127-qubit utility experiment on classical hardware within weeks of publication. The three uses of the word Pauli are distinguished in Pauli strings, channels and propagation.

Density-matrix simulation models noise explicitly by tracking a 2^n x 2^n matrix. The cost is the square of statevector simulation, so the ceiling arrives near 15 to 16 qubits, but it answers a question the exact methods cannot: how the circuit behaves on a real device.

Method              Scales with           Reaches      Exact?
Statevector         2^n amplitudes        ~32 qubits   yes
Stabilizer          Clifford gates only   1000s        yes
Tensor network      Entanglement          100-1000     bounded
Pauli propagation   Circuit depth         100s         bounded
Density matrix      (2^n)^2               ~16 qubits   yes, with noise

A platform that combines these routes each circuit to whichever method can answer it. The correct question about a circuit is not how many qubits it has but which structural property it possesses.

The requirement that makes results usable

Three of the five methods above are approximate. An approximate result without a stated error bound is an assertion rather than a measurement, and cannot support a scientific claim.

The bounds are computable rather than estimated. A matrix-product-state truncation that discards weight epsilon admits an error of at most sqrt(2 x epsilon) on any outcome probability, and the discarded weight is known during the run. Pauli propagation's bound is the discarded coefficient mass. A responsible platform computes and publishes these, and refuses to return a result when the bound is wide enough to admit any answer.

The reasoning behind that discipline is set out in How we certify simulation error, and the circumstances under which a job is refused rather than answered are enumerated in Why your circuit was rejected.

Where to start

The practical path is to write circuits in a standard framework such as Qiskit, run them exactly at small sizes to build intuition about superposition, entanglement and interference, then move to structured methods as width grows. Verify each algorithm's logic exactly at a size where exactness is affordable, then scale.

Hardware enters the workflow when the question is specifically about physical behaviour: noise characterisation, error correction, or circuits demonstrably beyond classical reach. For everything else, in 2026, the simulator is the instrument.