Tensor Networks Explained: How MPS Simulates 100 Qubits on a Laptop

Where statevector simulation records a quantum state amplitude by amplitude, tensor networks describe the same state in compressed form. For the states real algorithms produce, the compression is substantial enough to change what is computationally possible, moving the ceiling from roughly 32 qubits to several hundred.

The compression is not a heuristic. It rests on a structural fact about physical states, and the cases where it fails are as well characterised as the cases where it succeeds.

The central object

The object is the matrix product state, or MPS. Instead of one table of 2^n amplitudes, an MPS stores one small tensor per qubit, chained in sequence; the amplitude of any basis state is recovered by multiplying the corresponding matrices along the chain. Storage grows linearly in qubit count and quadratically in one tunable parameter, the bond dimension, conventionally written chi.

The memory cost is roughly n x chi^2 x 2 complex numbers, against 2^n for a statevector. At n = 100 and chi = 128 that is about 3 million numbers rather than 2^100.

Bond dimension is not an arbitrary knob. It measures how much entanglement the representation can carry across a cut of the chain. Specifically, the number of non-zero Schmidt coefficients across a bipartition is exactly the bond dimension required to represent the state there, so chi is a direct measure of entanglement rather than a proxy for it.

State                                Required bond dimension (chi)
Product state (no entanglement)                                  1
GHZ state (any qubit count)                                      2
W state (any qubit count)                                        2
Shallow structured circuit                                 16 to 128
Maximally entangled 100-qubit state                           2^50

The GHZ row is worth pausing on, because it contradicts the common intuition that entanglement and simulation cost are the same thing. A 1,000-qubit GHZ state is globally entangled and requires bond dimension 2. What matters is not whether a state is entangled but how the entanglement is distributed across cuts.

Why physical states compress

The reason the method works on real problems is the area law. Ground states of gapped local Hamiltonians have entanglement entropy across a boundary that scales with the size of the boundary rather than with the volume of the region. In one dimension the boundary of any interval is two points, so the entropy is bounded by a constant, and a constant entropy implies a bounded bond dimension.

This is why MPS underpins DMRG, which has been the dominant numerical method in one-dimensional condensed matter physics since 1992. Quantum circuit simulation inherited a mature technology rather than inventing one.

Circuits produce a related effect through depth rather than through a Hamiltonian. Entanglement takes time to build: a circuit of depth d on a line spreads correlations over roughly d sites, so entanglement entropy grows at most linearly in depth and the required bond dimension grows exponentially in it. Shallow circuits on many qubits are therefore cheap, and the operative variable is depth rather than width.

What happens during a run

Single-qubit gates act on one tensor and leave the bond dimensions unchanged. Two-qubit gates are where the work happens: the two adjacent tensors are contracted into one, the gate is applied, and the result is split back into two tensors by a singular value decomposition.

That decomposition is the point of control. The singular values are the Schmidt coefficients across the cut, ordered by magnitude, and retaining the largest chi of them while discarding the rest is provably the best possible approximation at that bond dimension in the 2-norm. This is not an ad hoc truncation; it is optimal by the Eckart-Young theorem.

The discarded weight, epsilon, is the sum of squares of the dropped singular values, and it is known exactly at every step because the algorithm computes it. Accumulated across the circuit it yields a rigorous bound: the error on any outcome probability is at most sqrt(2 x epsilon). The method therefore returns an approximation together with a certificate of how wrong it can be, which is what separates it from a heuristic compression.

The two independent accuracy checks

This platform reports both the analytic bound and an empirical convergence check, because they fail in different ways.

The analytic bound is rigorous but can be loose, since it accounts for worst-case accumulation. The convergence check runs the circuit at chi and again at 2 x chi and compares the outcome probabilities. If doubling the resource does not move the answer, the representation had captured the state; if it moves, the first run was under-resourced and the result should not be used. A run reported as converged with deviation 0.0 has passed this test, and the deviation is published rather than described.

When the analytic bound is wide enough to admit any answer, the job is refused rather than returned. The reasoning behind that policy is in How we certify simulation error, and the mechanics of the refusal in Why your circuit was rejected.

Where the method succeeds

Near-one-dimensional connectivity, bounded depth and physically meaningful states, which describes a large share of the daily workload of quantum algorithm research. QAOA instances, hardware-efficient ansatze, Trotterised dynamics and quench experiments all sit in this regime.

A representative benchmark from this platform: a 100-qubit QAOA circuit at depth 304 simulates in 5.9 seconds on a laptop CPU, fully converged with deviation 0.0. An 80-qubit layered ansatz completes in 4.3 seconds under the same conditions.

Where the method fails, and why that is informative

The method fails for deep random circuits and for volumetric entanglement, where entropy scales with region volume rather than boundary area. Two-dimensional lattices at depth are the standard hard case: the boundary of a region in 2D grows with its linear size, so the required bond dimension grows exponentially in the width of the system. Projected entangled pair states, or PEPS, generalise MPS to two dimensions and help materially, but contracting a PEPS network is itself exponentially hard in general, so the difficulty is relocated rather than removed.

This is precisely why quantum supremacy demonstrations are built from deep random circuits on two-dimensional lattices. They are engineered to maximise the one resource tensor networks cannot compress, which is also why they compute nothing of independent interest. The history is in Quantum supremacy claims that fell to classical simulation.

Circuit property            Effect on cost
More qubits, same depth     linear
More depth                  exponential in depth
1D or near-1D connectivity  favourable
2D lattice at depth         exponential in width
Global but simple entangl.  negligible (GHZ, W)

The practical instruction

For a researcher holding a 60-qubit or 100-qubit circuit, the question to ask before assuming hardware is required is not how many qubits it has but how much entanglement it generates and along what geometry. A substantial fraction of such circuits are answerable today by a tensor network at negligible cost with a measured error bound attached.

The check is cheap: run at a modest bond dimension, read the reported deviation and analytic bound, and increase chi if either is unsatisfactory. If the bound remains wide at large chi, the circuit is genuinely beyond tensor-network reach, which is a useful result in itself and one that costs a fraction of a cent to establish.