Learned mesh simulators are graph neural networks that predict the next state of a physical system, such as a fluid or a deforming plate, from the current one. They are run autoregressively: each prediction is fed back in as the next input. They are trained and tested on one mesh resolution. Run one on a finer mesh than it saw in training and its rollout tends to fall apart, often within a few steps. This note argues that the collapse is partly a numerical stability problem with a concrete cause. A learned local update behaves like an explicit numerical scheme tuned to one grid spacing. Refining the mesh while keeping the time step fixed pushes it past its stability limit, so small errors are amplified at every step instead of damped.
The proposal is to replace part of the simulator's local message passing with a resolvent operator. A resolvent is the matrix inverse $(L - zI)^{-1}$ of a graph Laplacian $L$ shifted by a negative constant $z$. It was introduced to make graph networks give consistent answers across graph resolutions, and it is also exactly the operator applied by one implicit Euler step of diffusion. Its amplification is bounded independently of mesh size. The claim to test is that this one change gives a per-step error-growth bound that holds at every resolution. If it does, a simulator trained on cheap coarse meshes can be rolled out stably on fine ones, a setting no existing mesh simulator has benchmarked.
Core Claim
Two lines of work have so far not met. The first, by Koke and colleagues, proves that standard graph networks are discontinuous across resolutions. In Graph Neural Networks Are Not Continuous Across Graph Resolutions, Graph Networks Struggle With Variable Scale and ResolvNet: A Graph Convolutional Network with multi-scale Consistency, degree normalization isolates nodes that should merge. Heat-kernel and resolvent propagation repair this. On Incorporating Scale into Graph Networks further shows that such propagation converges to a unique continuum embedding as a manifold discretization is refined. All of this evidence is static: molecule energy regression on QM7, node classification on Cora, and synthetic tori. The second line, on compounding rollout error, treats drift as a training-time distribution shift. Message Passing Neural PDE Solvers addresses it with the pushforward trick and temporal bundling. Improving Long-Range Interactions in Graph Neural Simulators via Hamiltonian Dynamics treats it as energy dissipation and adds a port-Hamiltonian core. Both always evaluate on the training resolution.
The link between the two lines is per-step amplification. Let $\gamma_h$ be the largest factor by which one rollout step stretches a small state perturbation on a mesh with spacing $h$. Over $T$ steps, error behaves roughly like a local error times $\sum_t \gamma_h^t$. Rollouts survive only if $\gamma_h \lesssim 1$. A learned local explicit stencil calibrated at spacing $h_0$ has no reason to keep $\gamma_h \le 1$ at $h < h_0$. Classical explicit schemes for diffusion lose stability once the time step exceeds a threshold scaling with $h^2$, and the Hamiltonian simulator's symplectic Euler integrator is explicit as well. A resolvent layer instead satisfies
$$\|(L_h - zI)^{-1}\| \le \frac{1}{|z|} \quad \text{for every mesh } h,$$
because $L_h$ is positive semidefinite for any resolution and $z<0$. If the Laplacian is built in physical units, so that $L_h$ approximates the continuous Laplacian, the operator also converges as the mesh refines. This is the property the static work proved. The new step is carrying it into the time dimension.
The hypothesis is falsifiable. It predicts that measured $\gamma_h$ rises above one for standard simulators under zero-shot refinement and stays near or below one for the resolvent simulator. It also predicts that this gap, more than differences in one-step accuracy, explains the difference in rollout error.
Research Program
The model keeps the encoder, decoder and a few local edge-MLP message-passing layers of Learning Mesh-Based Simulation with Graph Networks. These handle short-range, directional effects such as advection, which symmetric Laplacian operators cannot represent; the file lists directed graphs as an open problem for this theory. The deep stack of further local layers is replaced with resolvent blocks. Each block computes a learned polynomial $\sum_k \theta_k R_z^k$ of the resolvent, applied to the node features as in ResolvNet, followed by a residual MLP.
Two deliberate departures from ResolvNet are made, and both are ablated. First, $L_h$ is the mass-weighted finite-element (cotangent) Laplacian rather than the combinatorial graph Laplacian, so that it converges under refinement rather than only under clique collapse. Second, $z$ is set in physical units of inverse length squared. The receptive field is then a physical distance rather than a hop count, which also addresses the shrinking-reach problem identified by MultiScale MeshGraphNets.
Resolvents are applied by sparse conjugate gradient with a fixed tolerance, not dense inversion. This responds to the overhead concern raised for ResolvNet and makes cost near-linear in mesh size. The analysis has two parts. One is a bound on $\gamma_h$ for the full block in terms of $1/|z|$ and the Lipschitz constants of the MLPs. The other is an empirical estimator of $\gamma_h$: power iteration on finite-difference Jacobian-vector products along true trajectories, applied identically to every model.
Baselines
The naive reference point is MeshGraphNet with 15 local message-passing steps and input-noise training, following Learning Mesh-Based Simulation with Graph Networks. It is trained on the coarsest resolution and rolled out unchanged on finer ones. A stronger version adds the pushforward loss of Message Passing Neural PDE Solvers, so that any gain from the resolvent cannot be attributed to the missing training trick. The resolvent model receives the same pushforward loss.
The strongest existing competitors for resolution transfer are hierarchical. Efficient Learning of Mesh-Based Physical Simulation with Bi-Stride Multi-Scale Graph Neural Network reports roughly 40% lower rollout error than baselines on InflatingFont and zero-shot generalization to meshes up to 7x larger. It is the only reported mesh-size transfer result in the file. MultiScale MeshGraphNets restores spatial convergence on CylinderFlow but gives no scalar error in the file. No reported result was found on Lacuna for cross-resolution autoregressive rollout error on CylinderFlow, Burgers, Kuramoto-Sivashinsky or Impact Plate for any method. Those numbers will be produced here, under one protocol. The Hamiltonian simulator (IGNS), which reduces Impact Plate error by nearly an order of magnitude on fixed meshes, is the strongest stability-oriented competitor and is run on the same refined meshes.
All models are matched in parameter count within 10%. They are trained on identical coarse data with the same optimizer, the same hyperparameter search budget (a fixed number of trials tuned on a held-out coarse validation set, never on fine meshes) and the same GPU-hour cap. Wall-clock time and memory are reported.
Ablations isolate the key ingredient. The first replaces the resolvent polynomial with a Chebyshev polynomial of the normalized adjacency, keeping the same receptive field without bounded amplification. The second keeps the resolvent but uses the combinatorial Laplacian with $z$ in hop units, isolating the physical scaling. The third removes the local edge-MLP layers.
Beating the baselines means two things at two, four and eight times the training resolution: lower error accumulated over the whole rollout, and a longer horizon before error crosses a fixed divergence threshold. The resolvent model must also stay within the error of BSMS-GNN on the training resolution itself.
Why not just…?
Why not just train on a mixture of resolutions? This is the most serious threat. If the training data covers the test resolutions, a standard simulator may simply learn stable stencils at each spacing. It will be run as a baseline with the same total compute. The claim is restricted to extrapolation, testing at resolutions finer than any training mesh, where data mixing cannot help. If mixed-resolution MeshGraphNet with pushforward matches the resolvent model even under extrapolation, the hypothesis is wrong and that will be reported.
Why not just use a mesh hierarchy, as in BSMS-GNN or MultiScale MeshGraphNets? Hierarchies fix reach, which is a real cause of failure. But their per-level aggregation is still local and normalized, so nothing bounds $\gamma_h$ under refinement. The measured-amplification experiment separates the two explanations directly. If BSMS-GNN keeps $\gamma_h \le 1$ on refined meshes, reach rather than stability is the dominant cause and the resolvent adds little.
Why not just use the Hamiltonian simulator, which already conserves energy? Energy conservation does bound growth in the continuous dynamics. However, IGNS integrates with symplectic Euler, an explicit method whose stability requires the time step to shrink as the highest graph frequency grows. On a refined mesh with a fixed time step, that condition should eventually fail. This predicts a sharp divergence at a specific refinement factor, which is directly testable on Impact Plate and Wave Balls.
Why not just add noise or more layers? MultiScale MeshGraphNets reports that noise-trained MeshGraphNet error plateaus as resolution grows. Learning Mesh-Based Simulation with Graph Networks reports degradation beyond about 15 steps. Neither change alters the operator's spectrum. Both are nonetheless included inside the naive baseline rather than dismissed.
Proposed Experiments
The first experiment is a clean check on heat and wave equations over the discretized torus used in the scale-continuity papers. There, exact solutions exist at every resolution and $\gamma_h$ can be compared against theory. The main benchmarks are 1D Burgers, KdV and Kuramoto-Sivashinsky from Message Passing Neural PDE Solvers, regenerated on grids of 2x, 4x and 8x the training spacing. CylinderFlow will be regenerated at several mesh densities with the same solver. Impact Plate tests long-range stress waves. The 2D turbulent Navier-Stokes setting of Hierarchical Implicit Neural Emulators provides a hard stress test. That paper reports 93.0% stable-rollout survival against 38.0% for its best baseline, but on fixed regular grids. The survival rate will be reported with the same definition, on an unstructured remeshing of that domain.
Metrics are rollout error against horizon, time to divergence, survival rate, and the estimated $\gamma_h$ at each resolution.
The decisive check is a scatter plot, per model and per resolution, of measured amplification against final rollout error. The thesis holds if three things hold together. Error must track amplification across models much more closely than it tracks one-step error. The resolvent model must be the only one, apart from possibly mixed-resolution training, whose amplification stays bounded under extrapolated refinement. The Chebyshev ablation must lose that property. If amplification does not predict divergence, or if the normalized-adjacency ablation performs equally well, the structural-obstruction explanation of rollout drift is refuted.
References
- Graph Neural Networks Are Not Continuous Across Graph Resolutions
- Graph Networks Struggle With Variable Scale
- ResolvNet: A Graph Convolutional Network with multi-scale Consistency
- On Incorporating Scale into Graph Networks
- Message Passing Neural PDE Solvers
- Improving Long-Range Interactions in Graph Neural Simulators via Hamiltonian Dynamics
- Learning Mesh-Based Simulation with Graph Networks
- MultiScale MeshGraphNets
- Efficient Learning of Mesh-Based Physical Simulation with Bi-Stride Multi-Scale Graph Neural Network
- Hierarchical Implicit Neural Emulators