⚛️ quantum physics

Scalable quantum simulation of continuous-time generative models via tensor networks

This paper presents the first numerical study of scalable quantum simulation for continuous-time generative models using tensor networks, demonstrating that representing time-dependent potentials and states as tensor networks drastically reduces storage and computation costs while enabling efficient preparation of coherent amplitude encodings for quantum advantage in rare-event sampling.

Original authors: Nathan X. Kodama, L. Andrew Wray, Sam Cochran, Chad Rigetti, Shravan Veerapaneni, Michael J. Keiser

Published 2026-08-25

📖 6 min read🧠 Deep dive

CC BY 4.0

Original authors: Nathan X. Kodama, L. Andrew Wray, Sam Cochran, Chad Rigetti, Shravan Veerapaneni, Michael J. Keiser

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

In the modern world of artificial intelligence, computers have become remarkably good at learning the shape of complex data. Whether mapping the folds of a protein, generating realistic images, or predicting the next word in a sentence, these systems often rely on continuous-time models. These models work by imagining a slow, smooth journey that transforms a simple, random starting point into a specific, complicated target. Think of it as a river that begins as a wide, featureless sheet of water and gradually narrows and twists until it fits perfectly into a complex canyon. For years, scientists have used these models to generate new data, but a significant bottleneck has emerged: once the model is trained, it is incredibly expensive and slow to extract useful information from it. To find a specific, rare outcome within the model's output, traditional methods require taking millions of random samples and checking them one by one, a process that becomes hopelessly inefficient as the data grows more complex.

A new theoretical idea proposed a way to bypass this slowness by treating the data generation process not just as a flow of probability, but as the evolution of a wave, similar to how light or sound waves move through space. In this view, the computer does not just track where a particle might be; it tracks a wave of possibilities that carries information about all outcomes at once. If this wave could be prepared correctly, quantum computers could theoretically extract rare events with a massive speed advantage, finding a needle in a haystack in a fraction of the time it takes classical methods. However, for a long time, this remained a purely mathematical concept. No one could test it on a computer because the amount of memory required to simulate such a wave on a standard machine explodes exponentially as the number of variables increases. Simulating a system with just eight variables would require more memory than exists on any current supercomputer, rendering the idea untestable in practice.

Researchers at Sygaldry Technologies and the University of Michigan have now broken this barrier. They developed a new way to simulate these wave-based models on ordinary computers by using a technique that compresses the wave's information, much like how a zip file reduces the size of a document without losing its content. Instead of trying to store every single point of the wave on a massive grid, they represented the wave using a chain of interconnected blocks, a structure known in physics as a tensor network. This approach allowed them to simulate the wave's journey through time with high precision, even in dimensions where the old methods would have failed completely. In their simulations, they successfully modeled systems with eight dimensions, reducing the memory required by a factor of ten million compared to the traditional approach. They also found that the time it took to run the simulation dropped by more than a thousand times.

The team validated their method by testing it on several different types of data, including a twisted, ribbon-like shape and a mixture of distinct clusters. In every case, the compressed simulation produced results that were nearly identical to the perfect, uncompressed version, proving that the compression did not destroy the essential details of the wave. Crucially, they demonstrated that the rare, hard-to-find parts of the data—the "needles in the haystack"—survived the compression process intact. This is a vital finding because these rare events are often the most valuable in scientific and financial modeling. When they applied a technique called amplitude amplification to these compressed waves, the simulation showed that it could find these rare events with far fewer attempts than standard methods. Specifically, the new method required roughly two and a half times fewer attempts to find a rare event at a certain level of rarity, and the advantage grew even larger as the events became rarer.

This work does not yet run on a quantum computer, nor does it claim to have solved the problem of quantum advantage on its own. Instead, it provides the first concrete proof that the wave-based approach is mathematically sound and computationally feasible on classical hardware. By showing that these complex waves can be compressed and simulated efficiently, the researchers have created a bridge between current technology and future quantum applications. The compressed states they generated serve as a blueprint that could eventually be loaded onto a quantum processor, where the theoretical speedup could be fully realized. The study confirms that the rare events, which are often lost in other compression methods, remain accessible, validating the entire pipeline from the initial training of the model to the final extraction of rare data.

The researchers also explored a more advanced version of their method where the model itself was trained to be a compressed object from the start. In this setup, the computer learned the rules of the wave's movement directly as a compressed structure, eliminating the need for a separate compression step during the simulation. This allowed them to scale their experiments to thirty-two dimensions, a feat that would have been impossible with previous techniques. In these high-dimensional tests, the system remained stable and accurate, with the internal complexity of the simulation staying well within manageable limits. This suggests that the method is not just a temporary fix for small problems but a robust framework capable of handling the high-dimensional data that characterizes real-world applications.

Ultimately, this paper establishes a practical numerical framework for a field that was previously stuck in theory. It demonstrates that the exponential cost of simulating these wave flows can be converted into a manageable, polynomial growth by using smart compression techniques. The work shows that the "needle" in the haystack is not only preserved but can be found more efficiently, offering a clear path forward for both classical simulations and future quantum algorithms. By proving that these complex flows can be tamed and simulated on standard hardware, the researchers have turned a theoretical promise into a working tool, opening the door to more efficient modeling of everything from protein folding to financial risk.

Technical Summary: Scalable Quantum Simulation of Continuous-Time Generative Models via Tensor Networks

Problem Statement
Continuous-time generative models, such as flow matching and score-based diffusion, are widely used for modeling complex probability distributions. However, extracting statistical properties from these models after training is computationally expensive; achieving higher precision requires a quadratic increase in sample counts (Monte Carlo sampling). Wavefunction flows offer a theoretical solution by recasting the classical continuity equation transport as a unitary evolution of a wavefunction. The final state provides a coherent amplitude encoding (a "qsample") of the target distribution, enabling quantum algorithms like amplitude estimation and amplification to achieve quadratic speedups over classical sampling.

Despite this promise, wavefunction flows have remained purely theoretical. Direct numerical simulation is obstructed by the exponential cost of representing the wavefunction on a dense grid. For a spatial dimension $d$ and grid resolution $N$ per axis, the state requires $N^d$ amplitudes. For example, at $d=6$ and $N=32$ , the wavefunction comprises $\sim 10^9$ amplitudes. The dominant computational bottleneck is the "potential step" ( $e^{i\beta V_t}$ ), where the exponentiation and storage of the potential $V_t$ scale exponentially with dimension, rendering classical simulation intractable for $d > 5$ .

Methodology
The authors propose a classical tensor network framework to simulate wavefunction flows, compressing the wavefunction and the potential operator to overcome the exponential scaling barrier.

Tensor Network Representation: The evolving wavefunction $\Psi_t$ is represented as a Matrix Product State (MPS). Instead of a dense grid of $N^d$ points, the state is stored as $d$ cores with a bond dimension $D$ , reducing memory complexity from $O(N^d)$ to $O(dND^2)$ .
Hamiltonian and Trotterization: The system evolves under a continuity Hamiltonian $\hat{H}^c_t = i[\hat{K}, V_t]$ $\hat{H}_{t}^{c} = i [\hat{K}, V_{t}]$ , where $\hat{K}$ $\hat{K}$ is the kinetic term (diagonal in Fourier space) and $V_t$ $V_{t}$ is the learned scalar potential. The evolution is Trotterized into alternating kinetic and potential steps.
- The Kinetic Step is applied via 1D Fourier transforms on each MPS site, which is efficient and rank-preserving.
- The Potential Step ( $e^{i\beta V_t}$ ) is the primary challenge. The authors avoid explicitly constructing the high-rank unitary operator. Instead, they utilize Tensor Cross Interpolation (TCI) to construct a low-rank Matrix Product Operator (MPO) representation of the generator $V_t$ itself (not its exponential).
Time-Dependent Variational Principle (TDVP): The potential step is applied implicitly using TDVP integrators. The algorithm evolves the MPS manifold under the generator $V_t$ $V_{t}$ , effectively applying $e^{i\beta V_t}$ $e^{i β V_{t}}$ without ever forming the full operator. Two integrators are benchmarked:
- 1TDVP: Updates one site at a time with a fixed bond dimension.
- 2TDVP: Updates two adjacent sites jointly, allowing adaptive bond dimension growth via SVD truncation.
- 1TDVP+SE: A variant that adds subspace expansion to 1TDVP to capture necessary entanglement without full two-site sweeps.
Trained MPS Potential: In a second pipeline, the velocity potential $V_t$ is pre-trained directly as a real-valued MPS. This eliminates the need for runtime TCI construction at every Trotter step, as the MPS cores of $V_t$ are fed directly into the TDVP evolution.

Key Contributions

First Numerical Study: This work presents the first numerical implementation of wavefunction flows, moving the concept from mathematical analysis to a practical classical simulation framework.
Scalability via Compression: The authors demonstrate that representing the wavefunction and potential as tensor networks compresses the dominant cost of simulation. At $d=8$ , the method achieves a memory reduction of $\sim 10^7\times$ and a wall-clock time reduction of $\gtrsim 10^3\times$ compared to an extrapolated dense-grid baseline.
End-to-End Pipeline with Trained Potentials: The paper introduces a pipeline where the velocity potential is trained as an MPS and consumed directly by the evolution step, enabling simulations up to $d=32$ for orthogonal Gaussian mixtures.
Rare-Event Sampling Validation: The pipeline is validated by reproducing the $O(1/\sqrt{p_{rare}})$ scaling of rare-event sampling via amplitude amplification, demonstrating that the "rare" mass in the tails of the distribution survives the tensor network compression.

Results

Accuracy: On orthogonal Gaussian mixtures (dimensions $d=2$ to $8$), the tensor network methods (TCI+1TDVP and TCI+2TDVP) match the sample quality (measured by Sliced Wasserstein distance and Maximum Mean Discrepancy) of dense-grid simulations and classical Joint Action Matching (JAM) baselines. The error remains stable as dimension increases, with no upward drift.
Performance: The dense-grid baseline becomes intractable above $d \approx 5$ . The tensor network methods remain feasible and efficient up to $d=8$ (and $d=32$ with the trained potential). At $d=8$ , the tensor network approach uses seven orders of magnitude less memory and three orders of magnitude less time than the extrapolated dense-grid cost.
Rare-Event Sampling: For a target with rare events defined as points $>4\sigma$ from the modes, the prepared wavefunction state retains the necessary tail mass. When subjected to idealized amplitude amplification, the method requires 2.5 $\times$ fewer state preparations per accepted rare sample compared to classical rejection sampling, validating the $O(1/\sqrt{p_{rare}})$ scaling.
Integrator Comparison: The 2TDVP integrator generally achieves lower deviation from the probability flow but at a higher computational cost. The 1TDVP+SE variant offers a competitive trade-off, particularly when the bond dimension is demand-driven.

Significance and Claims
The paper establishes tensor networks as a practical numerical framework for simulating wavefunction flows, identifying a "low-rank regime" where these flows are classically simulable. The authors claim that:

The compressed MPS states serve as valid classical precursors to quantum circuits, potentially initializing parametrized quantum circuits to mitigate barren plateaus.
The method successfully bridges the gap between classical generative modeling and quantum simulation by compressing the exponential cost of the potential step.
The survival of rare-event mass through the tensor network evolution validates the fidelity of the compression for tasks requiring tail sampling.

Modesty and Limitations
The authors explicitly note that their results are currently limited to "dequantizable" regimes where the target distributions (orthogonal Gaussian mixtures) are low-rank by construction. They do not claim a gate-level quantum speedup or a dequantization-resistant advantage on this specific benchmark, as the prepared states and observables are efficiently contractible classically. The work does not yet produce a compiled unitary circuit for coherent state preparation on quantum hardware; rather, it provides the state and generator representations that such a compilation procedure would consume. The demonstration of amplitude amplification is idealized, modeling the exact Grover statistics rather than executing a compiled circuit. Future work is required to stress-test the method on high-dimensional targets with rich correlations.

Technical Summary: Scalable Quantum Simulation of Continuous-Time Generative Models via Tensor Networks

More like this