Tensor Networks Explained: How MPS Simulates 100 Qubits on a Laptop
· 4 min read · ZKSF team
Where statevector simulation records a quantum state amplitude by amplitude, tensor networks describe the same state in compressed form. For the states that real algorithms produce, the compression is substantial enough to change what is computationally possible.
The left side compares a full statevector table to a chain of small tensors, one per qubit, and shows how the bond dimension needed to represent a state grows with how entangled that state actually is: barely anything for a product state, small for a GHZ state, tens to low hundreds for a shallow structured circuit, and all the way to 2^50 for a maximally entangled 100-qubit state, the wall returning in a different form. The right side shows what happens at each two-qubit gate: a singular value decomposition sorts the contributions, keeps the largest ones, and discards a measured, known amount rather than an assumed one. The convergence check underneath is what makes an approximate result defensible: run once at a given bond dimension, run again at double that, and if the answer doesn't move, the result is converged.
The central object is the matrix product state (MPS). Instead of one table of 2^n amplitudes, an MPS stores one small tensor per qubit, chained together; the full state is recovered by multiplying the chain. Storage grows linearly in qubit count and quadratically in a single tunable parameter, the bond dimension, usually written chi.
Bond dimension measures how much entanglement the representation can carry across any cut of the qubit chain.
State Required bond dimension (chi)
Product state (no entanglement) 1
GHZ state (any qubit count) 2
Shallow structured circuit 16 to 128
Maximally entangled 100-qubit state 2^50 (wall returns)Tensor networks do not evade the exponential; they relocate it, so that cost scales with entanglement rather than qubit count. Circuits that entangle mildly, which includes a substantial share of variational algorithms, QAOA instances, and quench dynamics, become simulable at sizes that would otherwise sound implausible.
What happens during a run
Gates apply locally to the tensors they touch. Two-qubit gates grow the bond dimension; after each growth, a singular value decomposition truncates the representation, keeping the chi most significant components and discarding the rest. The discarded weight is a measurable quantity, which is what makes the method auditable: the amount of state thrown away at each step is known, not assumed.
This platform layers a convergence check on top of that mechanism: a circuit is run at bond dimension chi and again at 2*chi, and the outcome probabilities are compared. If doubling the resource leaves the answer unchanged, the compression has captured the physics, and the result is reported as converged, with the measured deviation attached. If the answer moves, that movement is reported rather than concealed.
Where the method succeeds and where it fails
The method succeeds for near-one-dimensional connectivity, bounded depth, and physically meaningful states, which describes most of the daily workload of quantum algorithm research. A representative benchmark: a 100-qubit QAOA circuit at depth 304 simulates in 5.9 seconds on a laptop CPU, fully converged.
The method fails for deep random circuits and volumetric entanglement, including two-dimensional lattices at depth, where related methods such as PEPS help only partially before paying their own exponential cost. This is precisely why quantum supremacy experiments are built from deep random circuits: they are engineered specifically to maximize the one resource tensor networks cannot compress.
The practical lesson for a researcher considering a 60-qubit circuit is to examine its entanglement structure before assuming hardware is required. A substantial fraction of such circuits can be answered today by a tensor network, at negligible cost, with a measured error bound attached.
Run your own 100-qubit circuit, with an error bar.