lossfunk lossfunk · NeurIPS 2026

Accepted at NeurIPS 2026 · Main Track

Hybrid Neural World Models for Physical Dynamics

Pranav Lakshmanan · Paras Chopra

One network. Any horizon. Label-free trust signal.

The setup in 30 seconds: one neural network leaps any number of simulator steps ahead, and tells you when to trust the prediction.

Neural physics simulators are fast. The hard part is knowing when to trust them: a surrogate can run 72x faster than a classical solver and quietly produce nonsense at deployment.

We trained one neural network to leap any number of simulator steps ahead in a single forward pass, on three different physical systems. Asking the same network for the same future in two different ways gives back two predictions. The disagreement between them is a per–cell trust signal that needs no ground–truth labels and costs two extra forward passes of the same network.

The rest of this page covers the recipe, the per–environment results, the speedup numbers, the safety net the trust signal enables at deployment, a comparison with conformal prediction, and how the probe relates to classical step doubling.

The trust signal, in one move

We train a single network \(f_\theta(s, T)\) that, given the current state \(s\) of a physical system, predicts the state \(T\) simulator steps later, for any \(T\) on the base–2 ladder \(\{1, 2, 4, 8, 16, 32, 64\}\). The training objective is supervised:

\[ \mathcal{L}_{\text{sup}}(\theta) \;=\; \mathbb{E}_{(s_0, s_T, T)\sim \mathcal{D}} \left\lVert \tilde{f}_\theta(s_0, T) - \tilde{s}_T \right\rVert_2^{2} \]

where \(\tilde{\cdot}\) denotes per-channel normalisation by training-set statistics. In the main runs, 10% of the loss is a two–step composition term: the network's own half–horizon prediction is fed back in, and the composed answer is also supervised against the stored ground truth (no solver is called during training). For any future you care about, the trained network can answer the same question two ways:

  • The direct answer: \(f_\theta(s, T)\) – jump \(T\) steps in one forward pass.
  • The doubled answer: \(f_\theta(f_\theta(s, T/2), T/2)\) – take two half–steps and compose them.

If the network has learned the dynamics correctly, the two answers must agree. Their disagreement is our trust signal:

\[ \hat{e}(s, T) \;=\; \left\lVert\, f_\theta(s, T) \;-\; f_\theta\!\left(f_\theta(s, T/2),\, T/2\right) \right\rVert_2 \]

The cost is two extra forward passes through the same network, with no calibration set and no retraining. The shape of \(\hat{e}\) depends on the state space. For grid PDEs (Oregonator, Euler 2D) the channels collapse at each spatial location and \(\hat{e}\) becomes a 2D map. For low–dimensional states (Ball 3D) \(\hat{e}\) is a per–ball scalar.

To gate a whole trajectory in Mode 2 below, we average the per–cell map into a single scalar

\[ \bar{e}(s, T) \;=\; \frac{1}{|\Omega|} \sum_{\Omega} \hat{e}(s, T), \]

where \(\Omega\) is the grid (or the set of balls). That trajectory–mean score is what ranks trajectories for the trust–gated fallback. The spatial map stays useful for inspection: it tells you where the prediction is fragile inside one trajectory.

Three-panel diagram: chemical input at time t, neural prediction at t+64 steps, and a trust signal map highlighting where the network expects to be wrong.
From a chemical concentration field at time \(t\), the network predicts the field 64 simulator steps later in one shot. The third panel is \(\hat{e}\), the step–doubling probe, a label–free signal that highlights exactly where the prediction is fragile.

Why we have to supervise the training

A tempting shortcut would be to train the network on the self–consistency loss alone, with no ground truth:

\[ \mathcal{L}_{\text{SC}}(\theta) \;=\; \mathbb{E}_{(s_0, T)\sim p} \left\lVert\, \tilde{f}_\theta(s_0, T) - \tilde{f}_\theta\!\left(f_\theta(s_0, T/2),\, T/2\right) \right\rVert_2^{2}. \]

The objective looks attractive because it needs no labels. It also has an easy global minimum that has nothing to do with physics: the identity map \(f_\theta(s, T) = s\) satisfies self–consistency exactly. Gradient descent drives \(\mathcal{L}_{\text{SC}}\) down by about three orders of magnitude, to \(\sim 10^{-6}\), within 5–10 epochs on both systems we tried:

epoch \(\mathcal{L}_{\text{SC}}\) val MSE vs GT \(\mathrm{MSE}\big(f_\theta(s, T),\, s\big)\)
Oregonator1\(3.3\!\times\!10^{-3}\)0.031\(<10^{-4}\)
5\(2.8\!\times\!10^{-6}\)0.030\(<10^{-4}\)
10\(2.0\!\times\!10^{-6}\)0.029\(<10^{-4}\)
20\(2.3\!\times\!10^{-6}\)0.037\(<10^{-4}\)
Euler 2D1\(5.9\!\times\!10^{-3}\)5.78\(4.8\!\times\!10^{-3}\)
5\(1.6\!\times\!10^{-5}\)9.40\(8.5\!\times\!10^{-4}\)
10\(5.8\!\times\!10^{-6}\)7.38\(3.9\!\times\!10^{-4}\)
20\(2.7\!\times\!10^{-6}\)8.23\(8.8\!\times\!10^{-5}\)
Trained with self–consistency alone, \(\mathcal{L}_{\text{SC}}\) falls to \(\sim 10^{-6}\) within 5–10 epochs and the network sits on \(f_\theta(s, T)\approx s\) (last column). On Euler 2D the validation MSE against ground truth stays between 5.8 and 9.4 at the epochs shown (ground truth is \(\mathcal{O}(1)\)). The model has perfectly satisfied the constraint and learned nothing.

The lesson is the asymmetry. Training has to be supervised so the network learns the actual dynamics. Once the dynamics are in there, self–consistency is free to do its job at deployment as the trust signal \(\hat{e}\).

Three different physical systems, one recipe

The trust signal isn't tuned to a particular equation. We test it on three systems that span the modelling spectrum: a stiff reaction–diffusion PDE, a nonlinear hyperbolic conservation law, and a rigid–body ODE with discrete collision events. The dynamics, the natural state space, and the reference numerical method are all different. The training recipe and the probe are the same; the backbone is a U–Net on the two grid PDEs and a FiLM–conditioned MLP on Ball 3D.

Environment 1 · Reaction–diffusion PDE

Belousov–Zhabotinsky waves (Oregonator)

The Oregonator model captures the Belousov–Zhabotinsky reaction, a real chemistry experiment where colored waves and spirals spontaneously appear and travel across a dish. Mathematically it's a two–variable reaction–diffusion PDE for activator \(u\) and inhibitor \(v\):

\[ \begin{aligned} \partial_t u &= D\,\nabla^{2} u + \tfrac{1}{\varepsilon}\!\left(u(1-u) - f\,v\,\tfrac{u-q}{u+q}\right), \\ \partial_t v &= D\,\nabla^{2} v + (u - v), \end{aligned} \]

on a 256×256 periodic grid in non–dimensional units (\(D{=}1,\ q{=}0.002\), with \(\varepsilon \sim \mathcal{U}(0.02, 0.08)\) and \(f \sim \mathcal{U}(0.5, 2.0)\) drawn per training trajectory). Reference solver: Strang splitting, with explicit FTCS finite differences (5–point Laplacian, CFL–limited substeps) for the diffusion and implicit Euler, solved by Newton iteration, for the stiff reaction. One simulator step is \(\Delta t{=}0.05\), so an \(h{=}64\) prediction replaces 64 Strang steps.

One of the trajectories the network learns to predict. Chaotic activator–inhibitor patterns spread, collide, and dissipate across the 256×256 grid.

The network is asked to skip 64 simulator steps ahead in one forward pass. The video below sweeps the requested horizon from \(h{=}2\) to \(h{=}64\) on one test trajectory. The trust signal \(\hat{e}\) (third panel) tracks the true error pattern (fourth panel) at every horizon, without seeing the ground truth at any point.

Input field, surrogate prediction, step–doubling trust signal \(\hat{e}\), and true error, swept across horizons \(h \in \{2,\,4,\,8,\,12,\,16,\,24,\,32,\,40,\,48,\,56,\,64\}\).
Five-column panel: input field, ground truth, network prediction, predicted error map, and true error map for the Oregonator system.
The static publication view at \(h{=}64\): input, ground truth, prediction, \(\hat{e}\), and true error.

Environment 2 · Compressible flow PDE

Euler equations in 2D

The compressible Euler equations are the math behind aerodynamics: shocks, contact discontinuities, vortex sheets. In conservative form,

\[ \partial_t \mathbf{q} + \partial_x \mathbf{F}(\mathbf{q}) + \partial_y \mathbf{G}(\mathbf{q}) \;=\; \mathbf{0}, \qquad \mathbf{q} = (\rho,\,\rho u,\,\rho v,\,E)^{\!\top}, \]

with fluxes \(\mathbf{F},\mathbf{G}\) determined by the equation of state \(p = (\gamma{-}1)\!\left(E - \tfrac{1}{2}\rho(u^2{+}v^2)\right)\), \(\gamma=1.4\). We solve on a 128×128 grid with outflow boundaries. Initial conditions are 2D Riemann problems (Schulz–Rinne configurations 3, 4, 6 and 12) and Sedov blasts. Reference solver: first–order Godunov finite–volume with the HLL Riemann solver and explicit stepping at CFL 0.4.

Euler prediction evolution. Input density, surrogate prediction, step–doubling trust signal \(\hat{e}\), and true error, swept across horizons \(h \in \{2,\,4,\,8,\,12,\,16,\,24,\,32,\,48,\,64\}\). The trust map concentrates on the contact discontinuity and the shock ring, the same regions where the true error lives.
Five-column panel showing input density, ground truth, prediction, predicted error map, and true error map for the Euler 2D system.
The static publication view at \(h{=}32\) on a Schulz–Rinne quadrant problem: input, ground truth, prediction, \(\hat{e}\), and true error. The trust map concentrates on the quadrant interfaces, where the true error lives.

Environment 3 · Rigid–body ODE

3D bouncing balls

The third system is a rigid–body ODE: balls flying around a 3D box under gravity with partially elastic wall collisions (restitution 0.70–0.95). Between bounces the dynamics are classical kinematics,

\[ \ddot{\mathbf{x}} = \mathbf{g}, \qquad \dot{\boldsymbol{\omega}} = \mathbf{0}. \]

A wall collision flips the velocity component normal to the wall with restitution \(e\) and leaves the tangential component alone (frictionless): \(\mathbf{v}_n \to -e\,\mathbf{v}_n,\ \mathbf{v}_t \to \mathbf{v}_t\). Per–ball state is the 9–vector \((\mathbf{x},\dot{\mathbf{x}},\boldsymbol{\omega})\in\mathbb{R}^{9}\). Reference solver: a semi–implicit Euler integrator with 50 substeps per frame, projecting the ball back inside the box and reflecting the normal velocity at every substep. Pure NumPy.

Six independent trajectories rendered in one scene. State is per–ball position, linear velocity, and angular velocity.
Per-ball prediction visualization showing predicted vs ground truth positions for several balls, with a per-ball error magnitude bar that matches a step-doubling estimate.
\(\hat{e}\) on rigid bodies gives a per–ball score (column 4) that tracks the actual error (column 5). Same training recipe and probe, a different backbone and state space.

One network, every horizon

One set of weights handles every horizon on the base ladder \(\{1, 2, 4, 8, 16, 32, 64\}\). At deployment you pass the horizon as input and read off the prediction; the same network handles short–range refinement and the long–range jump.

A grid with one row per horizon (2, 8, 32, 64 steps). Columns show the input, the true future, the surrogate prediction, the step-doubling error map, and the true error. The two error maps track each other at every horizon.
Oregonator, one row per horizon \(h \in \{2, 8, 32, 64\}\). Columns: input, true future, surrogate prediction, \(\hat{e}\), and true error. The probe stays informative across more than an order of magnitude in horizon length. This is the property the two deployment modes below rely on.

Speed

At \(h{=}64\), one forward pass through the surrogate replaces a chain of 64 sequential classical solver steps. We report two comparisons. The first runs both the surrogate and the solver on the same CPU. This is the honest apples–to–apples comparison and the one to quote when latency budgets sit on identical hardware:

  • Oregonator (vs Strang–split solver): 72x at \(h{=}64,\ B{=}1\).
  • Euler 2D (vs HLL finite–volume): 26x at \(h{=}64,\ B{=}1\).
  • Ball 3D (vs NumPy collision integrator): the solver is sub–millisecond per step, which leaves no room for a single surrogate call to win at \(B{=}1\).

With the surrogate on GPU and the solver unbatched on CPU, at \(h{=}64\) across batch sizes, the PDE surrogates saturate near \(B{=}1\) at 734x on Oregonator and 186x on Euler 2D. Ball 3D recovers from below the solver baseline at \(B{=}1\) to 31x at \(B{=}128\), the regime where many trajectories run in parallel. These GPU numbers compare a batched surrogate against an unbatched solver; JAX/JIT or GPU–vectorised solvers would shrink them. The same–CPU numbers above do not have this caveat.

Step doubling at deployment costs two extra forward passes, so trust–instrumented inference costs three times the surrogate alone.

Two-panel figure: left shows same-CPU speedup over the reference solver across horizons; right shows GPU surrogate speedup over the unbatched CPU solver as a function of batch size for all three systems.
Left: same–CPU speedup over the reference solver as a function of horizon at \(B{=}1\). Right: GPU surrogate versus the unbatched CPU solver at \(h{=}64\) across batch sizes, for all three systems. The dashed line marks the solver baseline.

Mode 2: a built–in safety net

The trust signal gives two natural ways to deploy the same model.

  • Mode 1 Surrogate alone. Maximum speedup, no fallback. The right choice when average accuracy is what matters and a few outliers are tolerable.
  • Mode 2 Use \(\bar{e}\) (the trajectory–averaged step–doubling score) as a gate: trajectories above a chosen threshold get recomputed by the classical solver, the rest stay on the surrogate. One scalar threshold \(q\) controls the cost–accuracy trade–off, no retraining required.
Three bar groups (one per system) comparing trajectory-mean RMSE of Mode 1 and Mode 2 at h=64. Mode 2 bars are roughly half as tall.
Test split, \(h{=}64\), \(q{=}0.75\) (defer 25% of trajectories to the reference solver). Mode 2 cuts trajectory–mean RMSE by 42–48% while keeping about 3x effective speedup. Across all 54 cells (3 systems × 6 horizons × 3 splits) the cut ranges from 28% to 79%, always above the 25% that random deferral would give.

Trust threshold sensitivity

Mode 2 has one parameter: the gate threshold \(q\). Trajectories whose mean step–doubling score \(\bar{e}\) lands in the top \(1-q\) fraction get deferred to the classical solver; the remaining \(q\) fraction is left to the surrogate. Lower \(q\) means more deferral, which means more accuracy at the cost of more solver calls. The trade–off is smooth:

split Mode 1 RMSE \(q=0.50\)
defer 50%
\(q=0.60\)
40%
\(q=0.75\)
25%
\(q=0.85\)
15%
\(q=0.90\)
10%
Oregonatortest0.0600.0120.0190.0290.0380.044
ood near0.1100.0270.0410.0600.0780.086
ood far0.1220.0160.0340.0570.0860.097
Euler 2Dtest0.2630.0640.0990.1260.1550.174
ood near0.6950.1900.2410.3040.3640.418
ood far0.6320.0870.1520.2370.3440.422
Mode 2 RMSE at \(h{=}64\) as the gate threshold sweeps from very aggressive deferral (\(q{=}0.5\)) to barely any (\(q{=}0.9\)). On the Oregonator out–of–distribution far split, even deferring 10% of trajectories cuts RMSE 20%. This sweep uses a separate 80–pair seed–0 sample, so its \(q{=}0.75\) column differs slightly from the figure above.

The deployment dial

Sliding the trust threshold moves you anywhere along the speed–vs–accuracy frontier. No retraining, no extra network. One knob.

Two-panel figure: left shows speedup versus horizon for Mode 1 and Mode 2; right shows the speed-accuracy Pareto frontier per environment as the trust threshold sweeps.
Left: same–CPU speedup versus horizon for Mode 1 (solid) and Mode 2 at \(q{=}0.75\) (dashed). This panel scales a single \(h{=}64\) timing, so it reads 70x and 25x rather than the 72x and 26x measured per horizon in the Speed section. Right: the Pareto frontier in (RMSE, speedup) at \(h{=}64\). Each curve runs from Mode 1 (fastest) through Mode 2 as \(q\) decreases; one threshold moves you along it.

Beyond the trained horizon

The network is trained on horizons up to \(T_{\max}{=}64\). What happens when we ask it for \(h{=}80\), or \(128\), or \(160\)? The trust signal degrades gracefully and, on Euler, actually improves:

split \(h{=}64\) \(h{=}80\) \(h{=}96\) \(h{=}128\) \(h{=}160\)
Oregonatortest0.840.840.930.910.71
ood near0.850.910.890.890.86
ood far0.910.870.840.970.81
Euler 2Dtest0.960.990.99——
ood near0.980.990.99——
ood far0.991.001.00——
Per–trajectory AUROC of \(\hat{e}\) at horizons past the trained \(T_{\max}{=}64\). On Euler, AUROC rises because the absolute error grows but the variance across trajectories grows faster, making them more separable. The probe rides that separation.

How does step doubling compare to conformal prediction?

Conformal prediction is the obvious classical baseline: take a calibration set, find the test point's nearest neighbours in some embedding, and use the empirical quantile of their errors as the predicted bound. We ran locally–adaptive split conformal with \(K{=}20\) KNN reweighting, using per–channel state statistics as the embedding.

split Conformal AUROC Step–doubling AUROC \(\Delta\) Coverage
Oregonatortest0.660.92+0.260.84
ood near0.490.91+0.420.72
ood far0.460.91+0.440.68
Euler 2Dtest0.940.95+0.010.87
ood near0.930.94+0.010.69
ood far0.930.99+0.060.54
Mean0.740.94+0.200.73
Means over horizons \(h \in \{2, \dots, 64\}\), 60 test pairs per horizon. Conformal lands well on Euler, where the Riemann–quadrant and Sedov initial conditions are visually distinctive enough for KNN to find useful neighbours. On Oregonator it collapses: every initial condition looks similar, so the embedding is uninformative and the procedure degenerates. Coverage also drops badly under OOD shift (down to 54% versus the 90% target on Euler ood–far). Step doubling queries the surrogate's own consistency at the actual test input. It has no calibration assumption to violate.

Step doubling has a history

The intuition behind \(\hat{e}\) is old. Lewis Fry Richardson worked out the classical version in 1910 for ODE solvers: run the same integration at step size \(h\) and at step size \(h/2\), compare the two answers, and the difference is an error estimate with a known leading order. Modern adaptive ODE codes still rely on it today. Our probe sits in that lineage.

The classical formula carries an assumption that the neural regime breaks. Richardson extrapolation works when the underlying solver has a known convergence order \(p\), so the local error scales like \(h^{p+1}\). Take the \(h\)–vs–\(h/2\) difference, divide by \(2^{p+1}-1\), and you get a calibrated error estimate. A trained neural network has no such order. There is nothing to divide by.

What replaces the order assumption is the multi–horizon training curriculum. The network is trained on the entire base ladder \(\{1, 2, 4, 8, 16, 32, 64\}\) at once, which forces it to behave consistently across scales. \(\hat{e}\) measures that scale–consistency at the actual test input. A surrogate trained on a single horizon would have no probe at all, since the half–horizon path would not be defined.

The recipe travels because the assumption it relies on (multi–horizon training produces a network whose two paths agree on what it has learned) is structural, not equation–specific. The same recipe and the same probe carry across reaction–diffusion, compressible flow, and rigid–body physics.

Citation

@inproceedings{lakshmanan2026hybrid,
  title     = {Hybrid Neural World Models for Physical Dynamics},
  author    = {Lakshmanan, Pranav and Chopra, Paras},
  booktitle = {Advances in Neural Information Processing Systems},
  year      = {2026},
  url       = {https://openreview.net/forum?id=uWsmvC2jq5}
}

@misc{hybrid_neural_world_models_2026,
  title         = {Hybrid Neural World Models},
  author        = {Lakshmanan, Pranav and Chopra, Paras},
  year          = {2026},
  eprint        = {2605.28317},
  archivePrefix = {arXiv},
  primaryClass  = {cs.LG},
  note          = {lossfunk},
  url           = {https://arxiv.org/abs/2605.28317}
}

Acknowledgements

Thanks to @awscloudindia for the generous compute credits to lossfunk that made this research possible.