To design, verify, and debug quantum algorithms, researchers rely heavily on simulating quantum mechanics on classical hardware. However, these simulations quickly run into a fundamental physical barrier known as the memory wall. Unlike classical systems, where adding a bit increases the state space linearly, adding a qubit to a quantum system doubles the size of its state space due to quantum superposition. This exponential growth transforms classical quantum simulation primarily into a challenge of memory capacity rather than raw processing power.
The Exponential Scaling of Quantum States
The most direct way to simulate a quantum circuit is through state vector simulation, which tracks the exact probability amplitude of every possible configuration. For a system of $n$ qubits, this requires storing $2^n$ complex numbers.
As highlighted by Eliot Fried et al. in qTorch: The quantum tensor contraction handler, this exponential scaling typically limits full state-vector simulations on a single classical compute node to approximately 45 qubits before exhausting available supercomputing memory. The problem becomes even more severe when simulating open quantum systems or noisy environments that require density matrices. Because a density matrix tracks mixed states across a $2^n \times 2^n$ space, the memory footprint scales as $2^{2n}$. Elloá B. Guedes et al. observe in Simulação da Transformada Quântica de Fourier that this rapid state explosion establishes a clear hardware ceiling where RAM capacity, rather than CPU clock speed, dictates the limits of classical emulation.
Even when advanced software techniques are applied, the fundamental constraint remains. As Gerhard Stenzel et al. demonstrate in Qandle: Accelerating State Vector Simulation Using Gate-Matrix Caching and Circuit Splitting, strategies like caching gate matrices and splitting circuits can optimize performance, but deep quantum circuits eventually cause memory exhaustion as the underlying unitary operations scale up.
The Hardware Ceiling: From Cache to Distributed Memory
The memory wall is not just a macro-level problem of running out of system RAM; it degrades performance at every layer of the classical hardware memory hierarchy.
On modern hardware accelerators like GPUs, simulation speed depends heavily on keeping data close to the processors in high-speed cache. In State of practice: Evaluating GPU performance of state vector and tensor network methods, Marzio Vallero et al. show that state-vector simulators hit a severe performance bottleneck the moment the state vector exceeds the GPU's cache memory. For typical modern hardware, this threshold occurs at just 13 to 14 qubits, beyond which execution times increase exponentially due to cache misses.
To simulate larger systems, researchers must distribute the state vector across multiple memory pools. Jonathan Mei et al. address this in TorchQuantumDistributed by sharding the massive state vector across distributed GPU clusters. While this multi-node communication bypasses the physical memory limits of a single device, the authors note that exact simulation remains fundamentally bounded, making it impossible to scale to 100 or more qubits using exact probability amplitudes.
Tensor Networks and the Entanglement Barrier
To avoid storing the full state vector explicitly, an alternative approach reframes simulation using tensor networks, such as Matrix Product States (MPS). Instead of a single massive array, the quantum state is represented as a chain of smaller, interconnected tensors.
The memory required to store a tensor network depends on its bond dimension, which measures the amount of quantum entanglement between different parts of the circuit. If a circuit has low entanglement, it can be represented compactly, bypassing the state-vector memory wall.
However, tensor networks encounter their own version of the memory wall when simulating deep or highly interactive circuits. As explained by Honghui Shang et al. in Large-Scale Simulation of Quantum Computational Chemistry on a New Sunway Supercomputer, when a circuit exhibits high entanglement, the bond dimension must increase exponentially to maintain simulation accuracy. This growth quickly exhausts system memory, imposing a computational ceiling on tensor-network methods for complex quantum systems.
Algorithmic Compressions and Space-Time Trade-offs
Faced with these rigid physical constraints, contemporary research focuses on algorithmic workarounds that trade processing time for memory space, or compress the state representation.
One strategy is direct data compression. In Full-state quantum circuit simulation by using data compression, Yuri Alexeev demonstrates that combining lossless techniques with adaptive lossy compression can significantly lower the memory footprint of full-state simulators, extending the qubit limit on existing hardware.
Another approach is to intentionally manipulate the bottleneck through space-time trade-offs. For certain sampling tasks, the classical simulation bottleneck can be shifted from processing time to memory capacity. As Bujiao Wu shows in Speedup in Classical Simulation of Gaussian Boson Sampling, utilizing exponential memory to store intermediate mathematical results allows for a significant reduction in the time complexity of the simulation.
Ultimately, these diverse strategies illustrate that the memory wall is the defining characteristic of classical quantum simulation. Whether a simulator tracks explicit amplitudes, contracts tensors, or shards data across supercomputers, its scalability is governed by how cleverly it navigates the exponential growth of the quantum state space within the finite memory structures of classical machines.
Key Foundational Work
Improved Simulation of Stabilizer Circuits (2004) — contributed 1 concept elements to this direction.
Quantum-implementable selective reconstruction of high-resolution images (2004) — contributed 1 concept elements to this direction.