🔬 condensed matter

DiffGLE: Differentiable Coarse-Grained Dynamics using Generalized Langevin Equation

This paper introduces DiffGLE, a differentiable simulation framework that learns non-Markovian memory kernels for the Generalized Langevin Equation by optimizing a trainable colored-noise filter to match target velocity autocorrelation functions, thereby enabling accurate coarse-grained dynamics without explicit reconstruction of projected forces.

Original authors: Jinu Jeong, Ishan Nadkarni

Published 2026-07-10

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Jinu Jeong, Ishan Nadkarni

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

Imagine you are trying to build a video game world that feels exactly like the real one. You want the water to splash, the gas to swirl, and the giant, star-shaped molecules to wiggle just right. But here's the catch: your computer isn't powerful enough to simulate every single tiny atom. So, you decide to group them into "super-particles" to speed things up.

The problem? When you zoom out, the game physics break. The super-particles move too fast and slide around like they're on ice, because you accidentally deleted all the invisible friction and the "memory" of how they bumped into each other.

For a long time, scientists tried to fix this by looking at the past to guess the future, but it was like trying to rebuild a shattered vase by looking at the dust. They had to do a complicated, multi-step reconstruction to figure out how the missing friction worked, and it was often a mess.

The New Approach: A "Smart Filter"
In this paper, the authors, Jinu Jeong and Ishan Nadkarni, propose a clever new trick. Instead of trying to rebuild the broken vase piece by piece, they treat the missing friction like a smart audio filter.

Think of the motion of these particles as a song. The "conservative force" (the basic rules of how atoms attract and repel) is the melody. But the real world has a complex rhythm and background noise (friction and random jiggles) that the simple melody misses. The authors created a system where they can "train" a digital filter to add the right amount of noise and friction to the song.

Here is the magic part: They built a self-correcting loop.

They run a simulation of their "super-particles" using a random, trainable filter.
They compare the result to a "reference" (a perfect, high-speed simulation of the real atoms).
If the super-particles are moving too fast or too slow, the system doesn't just guess; it backtracks. It looks at the error, calculates exactly how to tweak the filter, and tries again.
Crucially, they made sure the "noise" (the random jiggles) and the "friction" (the slowing down) are mathematically locked together. If the filter changes the noise, the friction changes automatically to match, keeping the laws of physics happy. This is called the fluctuation-dissipation theorem, but you can think of it as a "balance beam" that never tips over.

What They Tested
They didn't just talk about it; they ran the simulation on three very different things:

Carbon Dioxide ( $CO_2$ ): A simple gas. The system learned to fix the speed of the particles, matching the real data with a tiny error of $6.98 \times 10^{-3}$ .
Water ( $H_2O$ ): This is harder because water molecules bounce and wobble in a specific, complex way. The system learned to capture that "bouncy" tail in the motion, achieving an error of $2.18 \times 10^{-2}$ .
A Star-Polymer: Imagine a giant molecule shaped like a star. This one has a very long "memory" of how it moves. A simple, one-size-fits-all friction model failed miserably here, but their smart filter learned the complex, long-lasting memory, reducing the error from $7.60 \times 10^{-2}$ (for the old method) down to $1.98 \times 10^{-2}$ .

What They Didn't Do (And What They Ruled Out)
It's important to know what this paper didn't do. The authors explicitly kept the basic "rules of the game" (the conservative forces) fixed. They did not try to relearn how the particles attract or repel each other. They only learned the "missing friction."

They also argue against the old way of doing things, where scientists had to do a separate, complicated reconstruction step to figure out the friction before they could even start the simulation. This new method does it all in one go, directly from the motion data.

How Sure Are They?
The authors are very confident in their results within the world of their simulations. They showed that in these specific computer models, their method works better than the old ways. They measured the "Root Mean Square Error" (a way of saying "how far off were we?") and found it was very small for all three test cases.

However, they are careful to say this is a simulation. They haven't proven this works for every single chemical in the universe yet. They also note that their current method works best for things in a calm, balanced state (equilibrium). If you want to simulate a storm or a chemical reaction where things are changing wildly, the rules might need to be tweaked.

The Bottom Line
This paper suggests that we can teach computers to "feel" the missing friction in simplified models by training a digital filter, rather than trying to calculate it from scratch. It's like teaching a video game engine to learn the right amount of drag and bounce by watching the real world and adjusting its own settings until the movement feels perfect. It's a promising step toward making our molecular simulations feel as real as the world around us.

Technical Summary: DiffGLE – Differentiable Coarse-Grained Dynamics using Generalized Langevin Equation

Problem Statement
Coarse-grained (CG) molecular modeling aims to extend simulation timescales by reducing atomistic degrees of freedom to effective variables. While conservative CG potentials can be successfully fitted to reproduce equilibrium structural and thermodynamic observables (e.g., via force matching or relative entropy), capturing dynamical fidelity remains a central challenge. The removal of microscopic degrees of freedom eliminates inertia and dissipation pathways, often causing CG simulations to evolve too rapidly compared to all-atom references.

The Mori–Zwanzig projection formalism identifies the missing physics as a history-dependent friction and a fluctuating force, governed by the Generalized Langevin Equation (GLE). These components are linked by the fluctuation–dissipation theorem (FDT). However, parameterizing the memory kernel in practice is difficult. The exact kernel is a history-dependent object coupled to colored random forces that are not directly observable from standard trajectories. Existing methods (projected-force correlations, iterative reconstruction, auxiliary-variable embeddings) often require dedicated reconstruction or iterative steps before the kernel can be utilized, separating the learning process from the simulation itself.

Methodology
The authors propose DiffGLE, a top-down framework that formulates memory-kernel learning as a single differentiable inverse problem. The core innovation is the integration of differentiable simulation with a colored-noise ansatz to learn non-Markovian memory kernels directly from time-correlation observables.

Parameterization via Colored Noise: Instead of learning the friction kernel and random force independently, the random force $R(t)$ is parameterized as the output of a trainable causal filter $h_\theta$ acting on unit white noise $\eta(t)$ .
$R(t) = \int_0^\infty h_\theta(u) \eta(t-u) du$
The FDT is enforced by construction: the memory kernel $\Gamma_\theta(\tau)$ is defined strictly as the autocorrelation of this learned filter. This ensures that the stochastic forcing and dissipative memory remain thermodynamically consistent throughout the optimization.
Differentiable Simulation: The GLE simulator is made differentiable end-to-end. The optimization objective is the mismatch between the simulated velocity autocorrelation function (VACF) and a reference target.
- Gradient Pathways: The paper explores two differentiation routes:
  - Direct Backpropagation: Computes gradients by storing the full forward trajectory and memory history. This is computationally expensive in memory but provides the literal gradient of the discrete simulator.
  - Adjoint Method: Solves an augmented adjoint equation backward in time, recomputing the trajectory to avoid storing the full history. This offers better memory scalability for large systems but requires an accurate representation of the augmented state.
- Fixed-Noise Reparameterization: To enable gradient flow through the stochastic simulator, the optimization uses a fixed-noise (reparameterized) viewpoint. The gradients measure the sensitivity of the trajectory to the filter parameters $\theta$ , rather than the probability of noise realizations.
Optimization Workflow: The conservative CG force is kept fixed. The trainable filter parameters are updated via backpropagation through the GLE trajectories to minimize the VACF error. The resulting filter defines both the noise and the memory kernel simultaneously.

Key Contributions

Unified Learning Framework: The paper introduces a method to learn non-Markovian memory kernels as a single optimization problem over filter coefficients, avoiding the need for separate projected-force reconstruction or iterative parameterization steps.
FDT Consistency: By deriving the memory kernel from the autocorrelation of a trainable noise filter, the method guarantees that the fluctuation–dissipation relation is satisfied by construction, eliminating a common source of thermodynamic inconsistency in data-driven CG models.
Differentiable GLE Implementation: The authors implement a differentiable GLE solver within a PyTorch-based molecular dynamics workflow (using TorchMD), demonstrating both direct and adjoint differentiation strategies for memory learning.
Benchmarking: The framework is validated on three distinct systems: bulk carbon dioxide, bulk water, and a force-free star-polymer memory benchmark.

Results
The framework was tested on systems with varying dynamical complexities:

Carbon Dioxide (CO2): Using the adjoint-assisted workflow, the model achieved a VACF Root Mean Square Error (RMSE) of $6.98 \times 10^{-3}$ and an RDF RMSE of $1.02 \times 10^{-2}$ . The learned kernel successfully corrected the time correlations while preserving the equilibrium pair structure.
Water (H2O): Water presents a more stringent test due to its rapid inertial decay and weak oscillatory tail. The adjoint training reduced the VACF RMSE to approximately $1.5 \times 10^{-2}$ (production value $2.18 \times 10^{-2}$ ). The learned kernel exhibited a dominant short-time friction component with weaker sign-changing contributions, accurately tuning the phase and amplitude of the VACF tail.
Star-Polymer Benchmark: In a force-free scenario designed to isolate memory effects, the DiffGLE model (using direct backpropagation) achieved a VACF RMSE of $1.98 \times 10^{-2}$ . This significantly outperformed an optimized Markovian friction baseline, which yielded an RMSE of $7.60 \times 10^{-2}$ , demonstrating the method's ability to capture long-memory relaxation beyond single-timescale friction.

Significance and Claims
The paper claims that DiffGLE demonstrates that differentiable simulation enables the direct optimization of non-Markovian memory kernels from time-correlation observables.

The authors position this work as a "dynamical calibration layer" that can be applied on top of existing, structurally validated coarse-grained models. This separation allows researchers to isolate dynamical errors arising from missing frictional memory without conflating them with errors in the equilibrium thermodynamics or conservative potential.

The significance lies in the shift from reconstructing memory kernels as intermediate objects to treating them as trainable components of a differentiable simulator. The authors note that while the current examples are restricted to fixed conservative forces and equilibrium targets, the paradigm offers a potential route toward driven and nonequilibrium systems, provided that appropriate extensions to the fluctuation–dissipation relations are made. The work establishes that the filter representation can learn broad memory responses required for frequency-dependent friction, a capability that standard Markovian approximations lack.

Technical Summary: DiffGLE – Differentiable Coarse-Grained Dynamics using Generalized Langevin Equation

More like this