📊 statistics

LatentFlow: A General Framework for Conditioning Stochastic Processes

LatentFlow is a training-free, general framework that enables exact conditional sampling of diverse stochastic processes by transforming the problem into tractable latent-space inference via a deterministic mapping and a single reverse-time SDE.

Original authors: Louis Sharrock, Lachlan Astfalck, Henry Moss

Published 2026-07-15

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Louis Sharrock, Lachlan Astfalck, Henry Moss

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 have a magical, chaotic machine that can generate infinite worlds. Maybe it's a weather simulator that spits out rainstorms, a financial engine that predicts stock market crashes, or a biological model that grows cells. Usually, running this machine is easy: you just press "start," and it rolls forward, creating a random story.

But what if you want to force the machine to tell a specific story? What if you demand, "I want a storm that hits exactly this city but misses that one," or "Show me a stock market crash where the price drops below 87 but volatility spikes above 0.42"?

For a long time, scientists had to build a brand-new, custom-made machine for every single "what if" question. If you wanted to change the rules, you had to rebuild the engine. It was slow, expensive, and often impossible for complex scenarios.

Enter LatentFlow, a new framework that acts like a universal remote control for these chaotic machines. It doesn't need to learn anything, train any neural networks, or memorize data. It just works.

The Secret Ingredient: The "Innovation"

The authors realized that every complex story generated by these machines actually starts with a simple, clean seed. Think of a complex movie (the final result) as being built from a simple script (the seed).

In the paper's language, they call this seed a "latent innovation." It's like a set of pure, random numbers (usually drawn from a simple bell curve) that the machine uses to build its world. The machine has a fixed recipe, a deterministic map, that turns these simple numbers into the complex reality we see.

The big breakthrough is this: Don't try to force the complex movie to fit your rules. Force the simple script to fit your rules instead.

How the Magic Trick Works

LatentFlow uses a clever three-step dance to make the machine obey your commands:

Pull Back: Imagine you have a condition, like "The stock price must stay below 87." Instead of trying to figure out how the complex stock market reacts to this, LatentFlow pulls that rule backwards through the machine's recipe. It translates the rule into the language of the simple script (the latent space). Suddenly, a complex, impossible-to-solve rule becomes a manageable math problem about simple numbers.
The Guided Flow: Now, the paper uses a technique called a "guided probability flow." Imagine you are trying to find a needle in a haystack, but you have a magnetic wand that pulls you toward the needle. LatentFlow creates a magnetic wand (a "guidance field") that gently pushes the simple random numbers away from bad outcomes and toward the ones that satisfy your rules. It does this by solving a single equation that runs backward in time, like rewinding a tape to find the perfect starting frame.
Push Forward: Once the simple numbers have been nudged into the right shape, you feed them back into the machine's recipe. The machine runs forward, and boom—you get a complex world that perfectly matches your condition.

What This Isn't

The authors are very clear about what this method is not.

It is not a neural network that needs to be trained. You don't feed it thousands of examples to "learn" how to condition. It works immediately with the machine's existing recipe.
It is not an approximation that guesses the answer. The paper proves mathematically that if you could run the math perfectly, the answer would be exact.
It is not limited to simple, smooth worlds. It works on "heavy-tailed" distributions (where extreme events happen more often), discrete systems (like switching between states), and even black-box simulators where you can't see the inside gears.

How Sure Are They?

The authors have done the math to prove that this method is theoretically exact. However, in the real world, we have to use computers, which means we have to take tiny steps (discretization) and use a limited number of guesses (Monte Carlo sampling).

The paper admits that these practical steps introduce small errors, but they are explicit and systematically reducible. This means if you want a more accurate answer, you can just throw more computing power at it, and the error gets smaller and smaller. It's not a "maybe"; it's a "yes, with a known, fixable margin of error."

The Speed Demon

Here is the part that makes the authors' eyes light up: Speed.
Because LatentFlow doesn't need to train a model, it can generate these conditioned samples in seconds.

For a complex epidemic model (SIR), it takes about 1 second per sample.
For a stock market model (Heston), it takes about 3 seconds.
For a massive, complex fluid simulation (Allen-Cahn), it takes about 2 seconds.

All of this happens on a single desktop CPU. No supercomputers required.

The "What If" Playground

The paper shows off LatentFlow by conditioning all sorts of wild scenarios:

Spatial: Making a map where the average temperature in a specific region is exactly a certain number, even if the underlying weather model is messy and heavy-tailed.
Time: Simulating a cell differentiating into a specific type, or a stock market crashing exactly when a volatility spike hits.
Rare Events: Finding a path where a predator population booms to a specific number, or a chemical reaction triggers a detector downstream.

In the past, finding these specific, rare paths was like trying to find a specific grain of sand on a beach by digging randomly. LatentFlow gives you a metal detector that points straight to the gold.

The paper concludes that this isn't just a faster way to do old things; it's a new way to think about conditioning. By moving the problem from the messy, complex world to the clean, simple world of the "innovation," they've built a universal key that unlocks any stochastic process, no matter how weird or complex, without ever needing to learn a single thing.

Technical Summary: LatentFlow

Problem Statement

Stochastic-process models are generally straightforward to simulate forward but notoriously difficult to condition on observations, constraints, or global events. Conditioning becomes intractable when faced with non-linear observations, non-Gaussian likelihoods, black-box information, or global constraints (e.g., "the maximum value exceeds a threshold" or "the path hits a specific detector"). Traditionally, addressing these conditioning problems requires bespoke, model-specific constructions such as Markov Chain Monte Carlo (MCMC), Sequential Monte Carlo (SMC), variational inference, or Laplace approximations. These methods are often expensive, approximate, or fail to scale across different model classes. While recent work like FlowGP (Moss et al., 2026) addressed conditioning for Gaussian processes by recasting it as a differential equation, a general, training-free framework for arbitrary stochastic processes remained elusive.

Methodology: LatentFlow

The authors introduce LatentFlow, a unified, training-free framework for conditioning stochastic processes. The core insight is that conditioning need not be performed directly in the complex process space but can be transferred to a tractable latent innovation space.

1. Latent Innovation Representation

The method relies on Assumption 2.1: any stochastic process prior $p_\vartheta(f_0)$ (where $f_0$ is a finite-dimensional discretization) can be expressed as the deterministic image of a simple reference distribution. Specifically, there exists a map $T_\vartheta: \mathbb{R}^{m_\xi} \to E_m$ and a reference density $r$ (typically standard Gaussian $\mathcal{N}(0, I)$ ) such that if $\xi_0 \sim r$ , then $f_0 = T_\vartheta(\xi_0) \sim p_\vartheta$ .

This representation holds for a vast array of processes, including Gaussian processes, Student-t processes, SDE-driven processes, SPDEs, and even black-box simulators (via probability integral transforms or Rosenblatt transforms).
Conditioning on information $C$ (encoded by a likelihood $L_C$ ) is transferred to the latent space by defining a latent likelihood $\Lambda_{\vartheta,C}(\xi_0) = L_C(T_\vartheta(\xi_0))$ . The target latent density becomes $\rho_\vartheta(\xi_0 | C) \propto \Lambda_{\vartheta,C}(\xi_0) r(\xi_0)$ .

2. Guided Latent Flows

To sample from the intractable latent posterior $\rho_\vartheta(\cdot | C)$ , LatentFlow employs a guided reverse-time diffusion process (or probability-flow ODE) in the latent space.

Noising Bridge: A variance-preserving (VP) noising process is defined on the latent space: $\xi_t = \alpha(t)\xi_0 + \sigma(t)\epsilon$ , where $\epsilon \sim \mathcal{N}(0, I)$ .
Guidance Field: The method defines a guidance field $g(t, u) = \nabla_u \log \psi(t, u)$ , where $\psi(t, u)$ is the expected latent likelihood under the noising bridge. This field steers the reverse-time dynamics toward regions of high likelihood.
Monte Carlo Guidance: Since $g(t, u)$ is rarely available in closed form, it is estimated via Monte Carlo. For a given state $u$ at time $t$ , $S$ samples of the latent variable are drawn from the conditional bridge distribution, and the gradient of the log-likelihood is estimated using a self-normalized importance weighting scheme. This allows the method to handle non-differentiable simulators via derivative-free estimators or relaxations.
Sampling: The sampler solves the reverse-time SDE (or ODE) numerically, starting from a noisy state (approximated by the reference distribution) and integrating backward to $t=0$ to obtain a sample $\xi_0$ . The conditioned process sample is then recovered via $f_0 = T_\vartheta(\xi_0)$ .

3. Parameter Estimation

The framework extends to guidance-aware parameter estimation. By treating the normalizing constant $Z_\vartheta$ (the evidence) as an objective function, the authors propose an outer-loop optimization scheme. Gradients of the evidence with respect to hyperparameters $\vartheta$ are estimated using the same latent samples generated during the conditioning process, allowing for joint inference of parameters and conditioning without retraining a neural network.

Key Contributions

A General, Training-Free Framework: LatentFlow provides a single method for conditioning diverse stochastic processes (GPs, heavy-tailed processes, SDEs, SPDEs, discrete processes, and black-box simulators) without requiring the training of neural score models or conditional generators.
Exactness and Controllable Approximation: The construction is provably exact at the level of the target law. Practical errors arise only from three explicit, systematically reducible sources: finite terminal noising, Monte Carlo guidance approximation, and time discretization.
Scalability and Speed: The method reduces conditioning to solving a single reverse-time SDE. Experiments demonstrate that conditional samples can be generated in seconds on a single desktop CPU, even for high-dimensional and complex models where traditional MCMC collapses or is prohibitively slow.
Theoretical Guarantees: The paper provides formal proofs for the equivalence of the latent and process targets (Proposition 2.2) and stability bounds for the numerical and guidance approximations (Appendix D). It also establishes a dynamic interpretation of the evidence maximization as balancing condition satisfaction against "guidance energy" (Theorem E.5).

Experimental Results

The authors evaluate LatentFlow across a wide spectrum of stochastic process priors:

Spatial Processes: Conditioning Gaussian, Student-t, Cauchy convolution, and Potts models on point observations, censored data, and regional summaries (means/maxima). LatentFlow produced samples in 3–4 seconds per sample, preserving the distinct tail behaviors and discrete structures of each prior.
Temporal Processes: Generating diffusion bridges for Ornstein-Uhlenbeck processes, cell-differentiation models, and FitzHugh–Nagumo systems. It successfully conditioned Lotka–Volterra, SIR epidemic, and Heston stochastic volatility models on rare events (e.g., market crashes, prey booms) and trajectory constraints, achieving sampling times of <1 to 3 seconds.
Spatio-Temporal Processes: Conditioning Allen–Cahn, advection–diffusion, and FitzHugh–Nagumo SPDEs on sparse sensors, obstacle avoidance, and detector hits. The method handled latent dimensions up to 122K, generating valid samples in 1–5 seconds.
Benchmarks: On standard challenging distributions (Banana, Ring, Mixture of Gaussians), LatentFlow achieved Maximum Mean Discrepancy (MMD²) scores competitive with or superior to NUTS, while producing independent samples with significantly higher Effective Sample Size per second (ESS/s).
Parameter Estimation: The guidance-aware scheme successfully recovered ground-truth hyperparameters (e.g., length scales in Cauchy fields, rates in Lotka–Volterra models) by optimizing the evidence, outperforming fixed-parameter approaches.

Significance and Claims

The paper claims that LatentFlow represents a fundamental shift in capability for stochastic process conditioning. By moving the conditioning problem from the process space to a tractable latent innovation space, it unifies the treatment of models that have previously required disparate, expensive, or approximate samplers.

The authors emphasize that this is the first general method capable of conditioning a broad class of stochastic processes (including non-Gaussian, heavy-tailed, and simulator-defined models) in real-time on standard hardware. Unlike diffusion-based methods that require pre-training on large datasets, LatentFlow is "training-free," relying solely on the known generative map $T_\vartheta$ and pointwise evaluations of the likelihood. The method is particularly highlighted for its ability to handle rare, nonlinear, or global conditioning events under non-Gaussian priors, a domain where traditional methods often fail or become computationally intractable.

The paper maintains a modest tone regarding limitations, acknowledging that performance depends on the tractability of the latent representation and the smoothness of the pulled-back likelihood. Discontinuous simulators or hard constraints may require relaxations or derivative-free guidance, but the framework remains applicable through these adaptations.