Quantum Dynamics via Score Matching on Bohmian Trajectories
Listen
Radio episode about this paper
Transcript
Introduction to the show: ident: Quantum Radio. Generated commentary on the latest quantum physics and condensed matter papers.
Kai: We're looking at the paper: "Quantum Dynamics via Score Matching on Bohmian Trajectories".
Mira: Here's the gist of the paper. Quantum Dynamics via Score Matching on Bohmian Trajectories solves the time-dependent Schrödinger equation by learning the score function on Bohmian trajectories The zero-loss minimizer of this self-consistent objective recovers Schr¨odinger dynamics for nodeless wave functions <ref:2604.25137#pg2> By recasting real-time quantum dynamics as a self-consistent score-driven normalizing flow, this framework opens the time-dependent Schr¨odinger equation to the rapidly advancing toolkit of modern generative modeling <ref:2604.25137#pg3> Theoretical Foundation The trajectory framework originates from the Madelung decomposition which writes the wave function as Ψ = √ρ eiS/ħ and recasts Eq.
Kai: (1) as two coupled Eulerian field equations <ref:2604.25137#pg2> The quantum potential Q = −(ħ2/2m) ∇2√ρ/√ρ encodes all non-classical effects <ref:2604.25137#pg2> The score function s is defined as s ≡ ∇ ln ρ, in terms of which the quantum potential takes the form Q = −ħ2/4m ∇·s + 1/2 s2 <ref:2604.25137#pg3> The Bohmian trajectory equations are given by dx/dt = v, m dv/dt = −∇(V + Q) <ref:2604.25137#pg3> This is formally identical to classical mechanics with effective potential V +Q, except that v = ∇S/m is a singlevalued field on (x, t) rather than an independent degree of freedom <ref:2604.25137#pg3> Training Mechanism The central idea is to train the score network by minimizing the mismatch between sθ and the score of its own implied density <ref:2604.25137#pg3> The training objective is the Fisher divergence L
sθ: = ∫0t dt ∫Rd dx ρ sθ − ∇ ln ρ2, where T is the time horizon over which the wave function is propagated <ref:2604.25137#pg3> Both integrals are estimated on the trajectory itself: the spatial integral becomes the per-time expectation Ex∼ρ(·,t) sθ − ∇ ln ρ2 on the particle ensemble, and the time integral becomes a sum over trajectory checkpoints <ref:2604.25137#pg3> Since L ≥ 0 with equality iff sθ = ∇ ln ρ, minimizing L drives the system toward self-consistency <ref:2604.25137#pg3> Implementation Details The score function is parametrized as sθ(x, t) = ∇xφθ(x, t), the gradient of the scalar function φθ, ensuring sθ is a gradient field by construction <ref:2604.25137#pg4> The loss (6) depends on θ through the score sθ, the flow Jacobian F, and the sampling distribution ρ0 <ref:2604.25137#pg3> Gradients dL/dθ propagate end-to-end through the trajectory ordinary differential equation (ODE) via backpropagation through time (BPTT) <ref:2604.25137#pg4> The full gradient dL/dθ is computed by backpropagation through time (BPTT) along the discretized leapfrog trajectory, with gradient checkpointing
19: to manage memory <ref:2604.25137#pg4> Application and Results The method was applied to a chain of d coupled Morse oscillators V = Pi D(1 − e−βxi)2 + λ Pi xixi+1 <ref:2604.25137#pg5> Training uses M = 5000 particles, T = π, dt = 0.01 (314 leapfrog steps) <ref:2604.25137#pg5> The Fisher loss
panel (a): drops by four orders of magnitude, from ∼ 10 at initialization to ∼ 10−3 <ref:2604.25137#pg6> Panel (b) reports the mean-energy error ⟨E⟩ − Eexact vs.
Mira: epoch <ref:2604.25137#pg6> The energy error decreases from ∼ 0.2 to a median of ∼ 4×10−3 at convergence, about 0.2% relative to Eexact = 2.3236 obtained from a 4D split-operator FFT reference <ref:2604.25137#pg6> The network reproduces both effects in phase and amplitude across all four modes <ref:2604.25137#pg5> The KL remains near the interpolation floor throughout the trajectory (∼ 10−2 nats at t = 0 and t = π), confirming that the learned density matches the Schr¨odinger solution at the full density level <ref:2604.25137#pg5> The parallel between generative modeling and quantum mechanics extends from deterministic trajectories to stochastic ones <ref:2604.25137#pg6> The Bohmian ODE is precisely the probability-flow ODE of Nelson’s SDE <ref:2604.25137#pg6> Discussion and Extensions Bohm’s theory was famously regarded as a conceptual framework to interpret quantum mechanics
8, 9: <ref:2604.25137#pg3> The link between score matching and quantum mechanics in fact predates that machinery itself <ref:2604.25137#pg3> What modern generative modeling contributes is a flexible neural parametrization of the score, automatic differentiation through long trajectories, and a globally enforced self-consistent objective over the entire time horizon <ref:2604.25137#pg3> The broader toolkit of modern generative modeling, including denoising score matching and flow matching
28–30: , may extend naturally to quantum dynamics <ref:2604.25137#pg3> Fermionic wave functions generically have nodes which violate the ρθ > 0 hypothesis of the present analysis <ref:2604.25137#pg6> A possible route that resolves both issues is to employ the fermion flow architecture
41–43: <ref:2604.25137#pg6> The code and trained model weights that reproduce the results of this Letter are publicly available at //github.com/wanglei/BohmianFlow <ref:2604.25137#pg6> The author acknowledges discussions with Tao Wang, Yuan Wan, Kai Zhou, Han Wang, Linfeng Zhang, Zongyue Liu, and Mar´ın Bukov <ref:2604.
Title and authors: Kai: So this paper we're looking at is titled "Quantum Dynamics via Score Matching on Bohmian Trajectories," and it tackles solving the time-dependent Schrödinger equation by learning something called the score function on Bohmian trajectories.
Mira: That sounds like they’re using ideas from Bohmian mechanics, which gives us those deterministic particle paths guided by a quantum potential, and then they pair that with score matching to train a neural network on that trajectory.
Lev: What I want to focus on is how this connects to what we actually build in hardware. If we are trying to simulate something complex, training a neural network on the trajectory itself means the whole system has to be consistent across time steps, which sounds like it would put serious overhead on running it on real hardware.
Kai: Exactly, and the paper says they recast real-time quantum dynamics as a self-consistent score-driven normalizing flow. This suggests we could open up the Schrödinger equation to using modern generative modeling tools for time evolution instead of just fixed grid methods or parameterizing the wave function directly.
Mira: The core idea here is that they minimize a self-consistent Fisher divergence between the neural network and the actual score of its own implied density, which means any zero-loss minimizer of this objective recovers Schrödinger dynamics for nodeless wave functions.
Lev: That zero-loss condition is a big deal because it enforces physical consistency across the entire time horizon, which is something we always worry about when trying to simulate anything with noise or approximations.
Kai: And they show they demonstrated this approach on a chain of five hundred coupled Morse oscillators, where the initial Fisher loss drops by four orders of magnitude, from around ten at initialization down to about ten to the power of negative three after training <ref:2604.25137#pg2>.
Mira: That drop in loss is impressive, but we have to look at the results on energy error too. Panel (b) shows that the mean energy error compared to the exact energy falls from about zero point two at initialization down to a median of about four times ten to the negative three at convergence.
Title and authors: Lev: Four times ten to the negative three is still quite large when we think about running this on actual hardware, but it's a step in the right direction if we can manage that error. How do they handle the training itself?
Kai: They parametrize the score with a neural network as s theta of x and t, which is defined as the gradient of some scalar function phi theta of x and t, ensuring that s theta is a gradient field by construction.
Mira: The loss function depends on that parameter theta through the score s theta, the flow Jacobian F, and the initial sampling distribution rho zero. And they compute gradients by propagating them end to end through the trajectory ordinary differential equation via backpropagation through time or BPTT.
Lev: Propagating gradients along a discretized leapfrog trajectory sounds computationally intensive; we’re talking about chaining five spatial-derivative orders of phi theta plus the parameter gradient v, which suggests a lot of computation for every single time step in the training loop.
Kai: They used gradient checkpointing to manage that memory issue during BPTT along the trajectory, but they also mention that this method is formally identical to classical mechanics with an effective potential V plus Q, except that the velocity v is a single valued field on x and t rather than an independent degree of freedom.
Mira: That connection to classical mechanics is interesting because it suggests a certain structure we can leverage when trying to understand the underlying physics, even if the full quantum complexity isn't immediately captured.
Lev: It’s good that they established this formal link, but for us, what matters is how much overhead this self-consistent objective adds compared to other methods we might use for error correction or simulation.
Kai: They applied this method to a double-well potential and anharmonic vibrations of a Morse chain, and the network reproduces both effects in phase and amplitude across all four modes being studied.
Mira: The paper also states that the KL divergence remains near the interpolation floor throughout the trajectory, around ten to the negative two nats at both zero time and pi time, which confirms that the learned density matches Schrödinger solution at its full density level.
Title and authors: Lev: Matching it near the interpolation floor is a nice sign for convergence, but we still need to know if this consistency holds when we introduce real noise or when we try to move beyond nodeless wave functions.
Kai: The paper itself notes that fermionic wave functions generically have nodes which violate the zero probability hypothesis of the present analysis, so they suggest employing a fermion flow architecture for systems with those features.
Mira: That points toward a possible route to extending this framework to more realistic many-body systems, where we might need permutation equivariant normalizing flows from a Slater determinant.
Lev: If we go that route, it sounds like the computational cost of running the flow would be dictated by how complex those permutation symmetries are, which is another layer of overhead for real hardware execution.
Kai: They made their code and the trained model weights publicly available at github dot com wanglei bohmiantflow, so we can look at what was built and run with.
Mira: It's interesting that they link this score matching idea back to earlier work predating the machinery itself, suggesting that modern generative modeling contributes a flexible neural parametrization of the score and automatic differentiation through long trajectories.
Lev: So, to summarize, they’ve got a framework where you minimize a self-consistent divergence between your network and the true score of its own implied density to recover Schrödinger dynamics for nodeless functions on time-dependent potentials like Morse chains.
Kai: That's the main thing to take away from this paper on Quantum Dynamics via Score Matching on Bohmian Trajectories.
Mira: It shows how we can use score matching and normalizing flows, which are tools from generative modeling, to handle the time evolution of quantum systems by enforcing a self-consistent physical constraint across the entire trajectory.
Lev: For us, it’s a demonstration of what’s possible in terms of consistency enforcement on complex systems, even if we have to deal with the computational cost of propagating those gradients end to end through time.
Kai: That's it for this paper; we have a lot to think about now as we look toward applying these ideas elsewhere.
The paper's summary: Kai: So, to recap, this paper says they used score matching on Bohmian trajectories to solve the time-dependent Schrödinger equation by training a neural network on those particle paths.
Mira: Right. The authors are basically showing how you can take these deterministic particle paths and guide them with a neural network trained to match the actual quantum probability flow, which is what we call the score function.
Kai: It’s about turning this into something useful for AI, because they frame it as a way to use modern generative modeling tools for time evolution instead of sticking to older fixed grid methods.
Mira: They're emphasizing that by minimizing a self-consistent loss—a Fisher divergence—the network learns the physical dynamics itself, and when that loss is zero, it recovers the exact Schrödinger dynamics for wave functions without nodes.
Kai: That’s a big claim because it suggests this isn't just an approximation; it claims to recover the exact physics if you keep the density positive.
Mira: And they showed this on a chain of Morse oscillators, where the loss dropped by four orders of magnitude, from about ten at the start down to maybe one thousandths after training.
Kai: But that’s just a small potential compared to running this on real hardware. Lev, how much overhead are we really looking at when you have to propagate gradients along those leapfrog steps?
Lev: Well, Kai, propagating gradients through time via backpropagation through time means the computation scales with the number of time steps multiplied by the complexity of each step—the spatial gradient calculation and then the parameter update. It’s a lot of work for a single trajectory, especially when you’re dealing with high-dimensional systems like those Morse chains.
Mira: That leads into another point about efficiency; they claim this method automatically allocates training effort where the density actually has support, which is better than some other methods that waste computation in regions where the probability is very low.
Kai: So, it’s smarter sampling for the AI training, but Lev, if we move to fermionic systems—the paper hints at that—what happens with those nodes?
Lev: That's where things get tricky. Fermionic wave functions have nodes, which means they violate the zero probability hypothesis that underpins this specific analysis. So, to handle those real many-body cases, the authors suggest using a fermion flow architecture, which is a different kind of normalizing flow that’s permutation equivariant from a Slater determinant.
Mira: That sounds like a promising direction because it addresses the nodal structure issue directly by using something designed for fermionic systems.
Kai: If we can get that right, it opens up the door to simulating many-body quantum dynamics in real time, which is something we’ve always struggled with on our current hardware setups.
Lev: Yeah, but that also means the complexity of those permutation symmetries will dictate how much overhead we have to deal with when running a simulation on actual hardware.
Mira: It's interesting because this work shows that the connection between score matching and quantum mechanics isn't new; it just gives us a flexible neural parametrization of the score and automatic differentiation through long trajectories that we haven't seen before.
Kai: So, what this means for us as experimentalists is that we have a new way to build models for time evolution, not just static states. We need to see how this self-consistent objective handles noise in our actual qubit measurements.
The paper's improvements: Kai: So, we just talked about the main idea: using score matching on Bohmian paths to solve time evolution, and we covered how they trained this on Morse oscillators and the initial loss drop of four orders of magnitude.
Mira: Right. We also touched on how that self-consistent loss drives the system toward recovering Schrödinger dynamics for nodeless functions when it hits zero.
Kai: Now let's look at what they suggest to make it better, because a few improvements are actually pretty significant for how we use this stuff in practice.
Mira: One big improvement is automatic density support allocation. They say the loss concentrates where the physical density is actually present, which should make training much more efficient than methods that try to learn everywhere equally.
Lev: That makes sense from an engineering standpoint; wasting computation on regions where there's no wave function at all is a waste of time and resources when you’re building hardware.
Kai: They also talk about recovering the full complex phase S if the loss is zero and the density stays positive, meaning you can reconstruct the actual wave function, not just its magnitude.
Mira: And then there's this idea for fermions; they suggest using a fermion flow architecture to handle those nodes that are generic in fermionic systems, which opens up real-time dynamics for many-electron stuff.
Lev: Handling those nodes means we’re moving toward permutation equivariant normalizing flows from a Slater determinant, which is computationally much heavier than what we can run now, but it’s the path forward if you want to model those complex quantum states.
Kai: So they're essentially suggesting a pipeline: score matching for dynamics, automatic allocation for efficiency, and specialized flow architectures for fermionic systems.
Mira: It feels like they are trying to build a toolkit that is flexible enough to handle everything from simple nodeless potentials to complex many-body physics with nodes.
Kai: What this means for us is that we can use the generative modeling toolkit, not just for static images or text, but for simulating how quantum states evolve over time.
Lev: It really changes the landscape of what’s possible in terms of real-time simulation; if we can manage the computational overhead of those flow architectures, it could be a way to get closer to simulating complex quantum systems directly on hardware.
Conclusion: Kai: So, to wrap up this discussion on "Quantum Dynamics via Score Matching on Bohmian Trajectories," we've seen how they used score matching on Bohmian paths to solve the Schrödinger equation by training a neural network to learn that score function.
Mira: It really boils down to using generative modeling tools for time evolution by enforcing a self-consistent physical constraint across the entire trajectory, which is pretty neat.
Lev: From an error correction standpoint, it shows a way to model dynamics that is inherently guided by the physics of the system itself, instead of relying on fixed grid approximations that might introduce artifacts.
Kai: The results on those Morse oscillators showed a significant drop in loss and a reasonable reduction in energy error down to about four times ten to the negative three after training.
Mira: That's good because it proves the concept works for a specific type of system, and they even showed that at zero loss, you get back the exact Schrödinger dynamics for nodeless wave functions.
Lev: But we have to keep in mind that running this on real hardware means we’re looking at a lot of computation if we try to scale it up, especially when you consider those gradients propagating through the trajectory.
Kai: Exactly, and they did flag that fermionic systems will need a different flow architecture because of those inherent nodes, which suggests the future direction for this kind of work.
Mira: It’s a solid framework for connecting deterministic particle paths to modern generative modeling techniques, showing that the link between Bohmian mechanics and score matching is still very relevant.
Lev: Ultimately, it provides a theoretical blueprint for how we might construct more robust simulators if we can solve the overhead of those complex flow architectures.
Lei Wang
Beijing National Laboratory for Condensed Matter Physics and Institute of Physics, Chinese Academy of Sciences
quant-ph, cs.LG, physics.chem-ph, physics.comp-ph
Submitted: 2026-04-28
Updated: 2026-04-28
Comments: 8 pages, 5 figues, code at https://github.com/wangleiphy/BohmianFlow
Journal ref: APS Open Sci. 1, 000209 (2026)
DOI: 10.1103/lmhf-ws7v
Code: https://github.com/wangleiphy/BohmianFlow
License: http://creativecommons.org/licenses/by/4.0/
Importance score: 83/100
The gist: Quantum Dynamics via Score Matching on Bohmian Trajectories solves the time-dependent Schrödinger equation by learning the score function on Bohmian trajectories The zero-loss minimizer of this…
Key concepts
- Bohmian Trajectories
- These are paths for particles guided by a potential derived from the wave function. They are treated as classical trajectories governed by an effective potential, which simplifies the quantum evolution into a set of coupled differential equations.
- Score Function
- The score function is defined as the gradient of the logarithm of the probability density ($ abla ext{ln } ho$). It acts as a guide for particles and is central to this method because minimizing its mismatch with the true score recovers quantum dynamics.
- Self-Consistent Objective
- The training objective forces the neural network's learned score function ($s_ heta$) to match the true score of its own implied density ($ abla ext{ln } ho$). This self-consistency ensures that the resulting model accurately reproduces Schrödinger dynamics for nodeless wave functions.
Terminology
Summary
Quantum Dynamics via Score Matching on Bohmian Trajectories solves the time-dependent Schrödinger equation by learning the score function on Bohmian trajectories The zero-loss minimizer of this self-consistent objective recovers Schr¨odinger dynamics for nodeless wave functions <ref:2604. p. 0 We parametrize the score
with a neural network and minimize a self-consistent Fisher divergence between the network and the
score of the resulting density. We prove that the zero-loss minimizer of this self-consistent objective
recovers Schr¨odinger dynamics for nodeless wave functions, a condition naturally met in quantum
vibrations of atoms. We demonstrate the approach on wavepacket splitting in a double-well potential and anharmonic vibrations of a Morse chain. By recasting real-time quantum dynamics as a
self-consistent score-driven normalizing flow, this framework opens the time-dependent Schr¨odinger
equation to the rapidly advancing toolkit of modern generative modeling.Where the paper says it
Where the paper says it
Theoretical Foundation
The trajectory framework originates from the Madelung decomposition which writes the wave function as Ψ = √ρ eiS/ħ and recasts Eq. (1) as two coupled Eulerian field equations <ref:2604. p. 0 The trajectory framework originates from the
Madelung decomposition [6], which writes the wave
function as Ψ = √ρ eiS/ℏ and recasts Eq. (1) as
two coupled Eulerian field equations: a continuity
equation for the probability density ρ and a quantum
Hamilton–Jacobi equation for the phase S,
∂ρ
∂t + ∇·ρ
∇S
m
= 0, (2)
∂S
∂t +
|∇S|
2
2m
+ V + Q = 0, (3)
where the quantum potential Q = −(ℏ
2/2m) ∇2√ρ/√ρ
encodes all non-classical effects. The trajectory framework originates from the
Madelung decomposition [6], which writes the wave
function as Ψ = √ρ eiS/ℏ and recasts Eq. (1) as
two coupled Eulerian field equations: a continuity
equation for the probability density ρ and a quantum
Hamilton–Jacobi equation for the phase S,
∂ρ
∂t + ∇·ρ
∇S
m
= 0, (2)
∂S
∂t +
|∇S|
2
2m
+ V + Q = 0, (3)
where the quantum potential Q = −(ℏ
2/2m) ∇2√ρ/√ρ
encodes all non-classical effects. In this Letter, we turn Bohmian mechanics from an
interpretive framework into a practical computational
tool for quantum dynamics by revealing its connection
to modern machinery in generative modeling including
continuous normalizing flows [10, 11] and score matching [12, 13]. To begin, we define the score function s ≡ ∇ ln ρ, in
terms of which the quantum potential takes the form:
Q = −
ℏ
2
4m
∇·s +
1
2
|s|
2
. Figure 1 illustrates
this flow for a wavepacket splitting in a one-dimensional
double-well: the unimodal initial density (the base distribution of the normalizing flow) is deformed into multimodal densities, and non-crossing Bohmian trajectories
launched from random samples of the initial density trace
the full density evolution in between. arXiv:2604. To follow individual particles in the Lagrangian frame,
we apply the material derivative d/dt = ∂/∂t + v·∇ to
the Madelung system, obtaining the Bohmian trajectory
equations [8, 9]:
dx
dt = v, m
dv
dt = −∇(V + Q). (5)
This is formally identical to classical mechanics with effective potential V +Q, except that v = ∇S/m is a singlevalued field on (x, t) rather than an independent degree
of freedom.Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Training Mechanism
The central idea is to train the score network by minimizing the mismatch between sθ and the score of its own implied density <ref:2604.25137#pg3> The training objective is the Fisher divergence L[sθ] = ∫0t dt ∫Rd dx ρ sθ − ∇ ln ρ2, where T is the time horizon over which the wave function is propagated <ref:2604. p. 1 Theory— The central idea is to train the score network by minimizing the mismatch between sθ and the
score of its own implied density. The training objective
is the Fisher divergence:
L[sθ] = Z T
0
dt Z
Rd
dx ρθ |sθ − ∇ ln ρθ|
2
, (6)
where T is the time horizon over which the wave function
is propagated. The training objective
is the Fisher divergence:
L[sθ] = Z T
0
dt Z
Rd
dx ρθ |sθ − ∇ ln ρθ|
2
, (6)
where T is the time horizon over which the wave function
is propagated. Both integrals are estimated on the trajectory itself: the spatial integral becomes the per-time
expectation Ex∼ρθ(·,t)
|sθ − ∇ ln ρθ|
2
on the particle ensemble, and the time integral becomes a sum over trajectory checkpoints. Crucially, ρθ itself depends on sθ: the
score drives the trajectories that determine the density. Since L ≥ 0 with equality iff sθ = ∇ ln ρθ, minimizing L
drives the system toward self-consistency.Where the paper says it
Where the paper says it
Where the paper says it
Implementation Details
The score function is parametrized as sθ(x, t) = ∇xφθ(x, t), the gradient of the scalar function φθ, ensuring sθ is a gradient field by construction <ref:2604.25137#pg4> The loss (6) depends on θ through the score sθ, the flow Jacobian F, and the sampling distribution ρ0 <ref:2604. p. 2 The loss (6) depends on θ through the score sθ, the flow
Jacobian F, and the sampling distribution ρθ. Since initial positions xi(0) ∼ ρ0 are fixed, gradients flow endto-end through the trajectory ordinary differential equation (ODE) via the chain rule. Since initial positions xi(0) ∼ ρ0 are fixed, gradients flow endto-end through the trajectory ordinary differential equation (ODE) via the chain rule. The full gradient dL/dθ
is computed by backpropagation through time (BPTT)
along the discretized leapfrog trajectory, with gradient
checkpointing [19] to manage memory. Since initial positions xi(0) ∼ ρ0 are fixed, gradients flow endto-end through the trajectory ordinary differential equation (ODE) via the chain rule. The full gradient dL/dθ
is computed by backpropagation through time (BPTT)
along the discretized leapfrog trajectory, with gradient
checkpointing [19] to manage memory.Where the paper says it
Where the paper says it
Where the paper says it
Application and Results
The method was applied to a chain of d coupled Morse oscillators V = Pi D(1 − e−βxi)2 + λ Pi xixi+1 <ref:2604.25137#pg5> Training uses M = 5000 particles, T = π, dt = 0. p. 2 The correction φθ is a
multi-layer perceptron (MLP) with Feature-wise Linear
Modulation (FiLM) [20] time conditioning, which modulates each hidden layer by a learned scale and shift that
depend on t. Training uses M = 5000 particles, T = π,
dt = 0. Training uses M = 5000 particles, T = π,
dt = 0. 01 (314 leapfrog steps). The system self-heals within
tens of epochs: the learned Q strengthens, |det F| recovers, and both the loss and energy error return to baseline. The Fisher loss [panel (a)] drops by four orders of magnitude, from ∼ 10 at initialization to ∼ 10−3
. The Fisher loss [panel (a)] drops by four orders of magnitude, from ∼ 10 at initialization to ∼ 10−3
. Panel (b)
reports the mean-energy error |⟨E⟩ − Eexact|, where the
per-particle energy 1
2m|vi
|
2+V (xi)+Q(xi
, t) is averaged
over all ensemble particles and over the trajectory interval [0, T]. Figure 1 illustrates
this flow for a wavepacket splitting in a one-dimensional
double-well: the unimodal initial density (the base distribution of the normalizing flow) is deformed into multimodal densities, and non-crossing Bohmian trajectories
launched from random samples of the initial density trace
the full density evolution in between. arXiv:2604. For the exact Bohmian flow, ⟨E⟩ at each time
equals the conserved expectation value, so a single scalar
averaged over [0, T] simultaneously probes accuracy (bias
relative to Eexact) and energy conservation (drift across
the interval). The energy error decreases from ∼ 0. The energy error decreases from ∼ 0. 2 to
a median of ∼ 4×10−3 at convergence, about 0. Panel (b)
reports the mean-energy error |⟨E⟩ − Eexact|, where the
per-particle energy 1
2m|vi
|
2+V (xi)+Q(xi
, t) is averaged
over all ensemble particles and over the trajectory interval [0, T]. For the exact Bohmian flow, ⟨E⟩ at each time
equals the conserved expectation value, so a single scalar
averaged over [0, T] simultaneously probes accuracy (bias
relative to Eexact) and energy conservation (drift across
the interval). ⟨E⟩ is averaged over the M = 5000 particles and the trajectory time [0, T], and Eexact = 2. 3236 is obtained from a 4D
split-operator FFT reference. amplitude-dependent, so each marginal is squeezed and
stretched as it samples regions of varying curvature, with
i = 0 breathing most strongly because of its larger excursion and the others inheriting weaker breathing through
their coupled motion. The network reproduces both effects in phase and amplitude across all four modes. As a direct densitylevel check, we evaluate the reverse Kullback–Leibler
divergence KL(ρθ∥ρexact)(t) ≈ M−1 P
i
[ln ρθ(xi(t), t) −
ln ρexact(xi(t), t)] as a per-particle Monte-Carlo average,
using ln ρθ(xi(t), t) = ln ρ0(xi(0))−ln |det Fi(t)| from the
change of variables and ρexact = |Ψ|
2 multilinearly interpolated from the 4D FFT reference. At M = 20,000 the
KL remains near the interpolation floor throughout the
trajectory (∼ 10−2 nats at t = 0 and t = π), confirming
that the learned density matches the Schr¨odinger solution
at the full density level, not only in low-order moments. What modern generative modeling contributes—
which we leverage here—is a flexible neural parametrization of the score, automatic differentiation through long
trajectories, and a globally enforced self-consistent objective over the entire time horizon, rather than an instantaneous least-squares fit at each timestep. The parallel between generative modeling and quantum mechanics extends from deterministic trajectories
to stochastic ones. In modern generative modeling, flow-based models transport densities along deterministic ODEs, while diffusion-based models [12, 13]
use stochastic differential equations (SDEs) with a scoreproportional drift, the two linked by a probabilityflow ODE that reproduces the SDE’s marginals. The
Bohmian ODE is precisely the probability-flow ODE of
Nelson’s SDE: Bohmian mechanics is to flow-based generative models what Nelson’s stochastic mechanics is to
diffusion-based ones.Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Discussion and Extensions
Bohm’s theory was famously regarded as a conceptual framework to interpret quantum mechanics [8, 9] <ref:2604.25137#pg3> The link between score matching and quantum mechanics in fact predates that machinery itself <ref:2604. p. 3 trajectories turns it into a practical computational tool
for the TDSE, leveraging machinery from modern generative modeling. The link between score matching and
quantum mechanics in fact predates that machinery itself. Already in 2003, Garashchuk and Rassolov [15, 16]
fitted the quantum potential on trajectories by minimizing Eρ[
1
2
|s|
2 + ∇·s] ∝ ⟨Q⟩ in a polynomial basis — the
implicit score-matching loss of Hyv¨arinen [17] up to constants. What modern generative modeling contributes—
which we leverage here—is a flexible neural parametrization of the score, automatic differentiation through long
trajectories, and a globally enforced self-consistent objective over the entire time horizon, rather than an instantaneous least-squares fit at each timestep. We extend this construction to
Schr¨odinger dynamics. The broader toolkit of modern
generative modeling, including denoising score match- Fermionic wave functions generically have nodes: antisymmetry under particle exchange forces Ψ = 0 on a set
that partitions configuration space into sign-disconnected
cells [39]. These nodes violate the ρθ > 0 hypothesis of
the present analysis on two counts. Second, nodes resurrect the Wallstrom objection [40]: the Madelung system recovers the Schr¨odinger equation only under the
quantization condition H
v · dℓ = 2πnℏ/m, n ∈ Z, on
every closed loop in configuration space, a constraint automatic for a single-valued Ψ but invisible to a scoreonly formulation. A possible route that resolves both
issues is to employ the fermion flow architecture [41–
43], which parametrizes many-electron wave functions
as a permutation-equivariant normalizing flow from a
Slater determinant. Combining such fermionic flow architectures with self-consistent score matching is a promising path toward real-time quantum dynamics of manyelectron systems. The code and trained model weights that reproduce
the results of this Letter are publicly available at https:
//github. The code and trained model weights that reproduce
the results of this Letter are publicly available at https:
//github. com/wangleiphy/BohmianFlow. com/wangleiphy/BohmianFlow. The author acknowledges discussions with Tao Wang,
Yuan Wan, Kai Zhou, Han Wang, Linfeng Zhang,
Zongyue Liu, and Mar´ın Bukov.Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Green — the paper says it, and the page is printed. Red — no passage carries it, so treat that sentence as unverified. The same check runs on your own text: check a summary against its source, $5.
Improvements for AI systems
- Continuous Normalizing Flow for Quantum Dynamics
The framework recasts real-time quantum dynamics as a self-consistent score-driven normalizing flow, opening the time-dependent Schrödiger equation to modern generative modeling toolkit. This allows AI systems to model time evolution by training a neural network on data, rather than relying on fixed grid methods or parameterizing wave functions directly.
- Self-Consistent Score Matching for Dynamics
The system minimizes a self-consistent Fisher divergence between the neural network and the score of its own implied density, ensuring that any zero-loss minimizer of this self-consistent objective recovers Schrödiger dynamics for nodeless wave functions.
This enforces physical consistency across the entire time horizon.
- Automatic Density Support Allocation
The method automatically allocates training effort where the density has support, as the loss concentrates on regions where the physical density has support,
unlike PINNs which can degrade accuracy in tails where |Psi|2 is small. This leads to more efficient model training for complex potentials like those in Morse chains.
- Recovery of Exact Quantum States
The theorem proves that if the loss is zero and a strictly positive density is maintained, the score network recovers the exact wave function, stating sθ(x, t) = ∇ln Ψ(x, t)2.
This provides a mechanism to recover the full complex phase S by integrating the reconstructed trajectory.
- Real-Time Quantum Simulation for Many-Body Systems
The approach can be extended to fermionic systems using fermion flow architectures, which are permutation-equivariant normalizing flows from a Slater determinant.
This enables real-time quantum dynamics of many-electron systems while automatically satisfying the Wallstrom condition regarding nodal cells.
Abstract
We solve the time-dependent Schrödinger equation by learning the score function, the gradient of the log-probability density, on Bohmian trajectories. In Bohm's formulation of quantum mechanics, particles follow deterministic paths under the classical potential supplemented by a quantum potential depending on the score function of the evolving density. These non-crossing Bohmian trajectories form a continuous normalizing flow governed by the score. We parametrize the score with a neural network and minimize a self-consistent Fisher divergence between the network and the score of the resulting density. We prove that the zero-loss minimizer of this self-consistent objective recovers Schrödinger dynamics for nodeless wave functions, a condition naturally met in quantum vibrations of atoms. We demonstrate the approach on wavepacket splitting in a double-well potential and anharmonic vibrations of a Morse chain. By recasting real-time quantum dynamics as a self-consistent score-driven normalizing flow, this framework opens the time-dependent Schrödinger equation to the rapidly advancing toolkit of modern generative modeling.
Sources
- Monge-Amp\`ere Flow for Generative Modeling
- Score-Based Generative Modeling through Stochastic Differential Equations
- Training Deep Nets with Sublinear Memory Cost
- Adaptive Probability Flow Residual Minimization for High-Dimensional Fokker-Planck Equations
- Flow Matching for Generative Modeling
- Flow Straight and Fast: Learning to Generate and Transfer Data with Rectified Flow
- Building Normalizing Flows with Stochastic Interpolants
- Deep Stochastic Mechanics
- A Global Spacetime Optimization Approach to the Real-Space Time-Dependent Schr"odinger Equation
- A parameterized Wasserstein Hamiltonian flow approach for solving the Schr\"odinger equation
- FFJORD: Free-form Continuous Dynamics for Scalable Reversible Generative Models
Related papers
- Computational regimes in matrix-product-state-based quantum trajectory simulations
- Toward chemically accurate quantum simulations on quantum hardware: A quantum-HPC hybrid approach
- Transversal surface-code game with reconfigurable qubits
- Fulqrum: a generalized framework for quantum subspace diagonalization
- Flux-Activated Resonant Control of a Bosonic Quantum Memory
- Machine learning the effects of many quantum measurements