Reversible Graph Network Simulator (R-GNS)

• R-GNS is a reversible graph-based neural simulation framework that employs invertible latent message passing for bidirectional inference.
• Its architecture integrates a semi-symmetric physical interface, Invertible Linear Projection, and Residual Reversible Message Passing blocks to ensure consistency between forward and inverse dynamics.
• Empirical evaluations demonstrate that R-GNS outperforms traditional GNS models in accuracy and efficiency for particle-based fluid simulations with fast, one-step inverse inference.

Reversible Graph Network Simulator (R-GNS) denotes a graph-based neural simulation framework in which latent message passing is constructed to be mathematically invertible, allowing forward dynamics and inverse inference to be handled within a single architecture. In the formulation explicitly named R-GNS, the setting is particle-based fluid simulation: particles are nodes, neighborhood relations define edges, and reversibility is imposed on the learned latent propagation rather than on the underlying dissipative physics itself. The framework is designed to enforce bidirectional consistency, so that forward and inverse operators are coupled by construction while remaining compatible with physically irreversible systems such as dissipative fluids (Huang et al., 26 Sep 2025).

1. Origins and conceptual setting

R-GNS emerged against two relevant lines of work. The first is the Graph Network-based Simulator (GNS), which represents physical systems as particle graphs and predicts accelerations through learned message passing. In GNS, particles are nodes, directed edges are added between particle pairs within a fixed connectivity radius, the graph is rebuilt each rollout step, and the learned simulator is combined with a fixed update mechanism using semi-implicit Euler. The paper states explicitly that reversibility or invertibility is not covered there, and that the default update is not time-reversible (Sanchez-Gonzalez et al., 2020). This establishes the baseline limitation that R-GNS directly targets.

The second line is reversible graph representation learning. Graph Normalizing Flows introduced reversible message passing through affine coupling, splitting node features into partitions and updating them with RealNVP-style graph modules. In the supervised setting, the resulting GRevNets reconstruct lower-layer activations exactly from upper layers, requiring only $O(\#\text{nodes})$ storage rather than storing hidden states across all message-passing steps (Liu et al., 2019). This provided a graph-specific precedent for exact inversion and reduced-memory backpropagation.

Within this landscape, R-GNS combines the simulation-oriented particle graph formulation of GNS with the exact invertibility principles of reversible graph architectures. A plausible implication is that R-GNS can be read as an overview of neural physical simulation and reversible graph computation: it preserves the graph-based inductive bias of particle simulators while making the latent update rule bijective.

2. Core architecture

The named R-GNS architecture is built from three components: a semi-symmetric physical interface, an Invertible Linear Projection (ILP) between physical and latent states, and Residual Reversible Message Passing (RRMP) blocks (Huang et al., 26 Sep 2025).

The physical state at time $t$ is written as $\chi^t = \{x_i^t\}_{i=1}^N$, with

$x_i^t = [p_i^t, m_i],$

where $p_i^t$ is position and $m_i$ denotes static attributes. Dynamic quantities such as velocities are carried in node features, while edge features encode relative positions. The architecture uses a Semi-Symmetric Input–Output Design: the input graph encodes velocity history, current positions, and static attributes, whereas the output is masked to retain only the predicted velocity $v^{t+1}$. Positions are then updated using $p^t$ and the predicted $v^{t+1}$. The inverse mirrors this update, preserving symmetry while predicting only dynamic quantities.

The ILP provides the reversible interface between physical and latent variables: $$\boldsymbol{n} = W \boldsymbol{\chi} + \boldsymbol{B} \quad (\text{encode}), \qquad \boldsymbol{\chi} = W^{\dagger}(\boldsymbol{n} - \boldsymbol{B}) \quad (\text{decode}),$$ with $t$0 computed by SVD,

$t$1

The decoder is the least-squares inverse, and the reported reconstruction error is empirically near machine precision.

The RRMP blocks generalize RevNet-style coupling to graph message passing. Node features are split into two partitions, $t$2, while edge features remain fixed during a time step. The forward coupling is

$t$3

and the inverse coupling is

$t$4

Here $t$5 are edge MLPs and $t$6 are node MLPs. The same parameters are shared across forward and inverse directions. Under fixed conditional edge features and this additive residual coupling, each layer is exactly invertible in latent space.

Architecturally, the final reported configuration uses 10 reversible propagation steps, hidden dimension 128, and a feature split into two 64-dimensional halves.

3. Forward simulation, inverse inference, and training objectives

The forward operator is written as

$t$7

while inverse inference is written as

$t$8

The per-step physical update is described by predicting $t$9 and then updating positions as

$\chi^t = \{x_i^t\}_{i=1}^N$0

Static attributes remain unchanged (Huang et al., 26 Sep 2025).

The forward pipeline is: encode $\chi^t = \{x_i^t\}_{i=1}^N$1 to latent space using ILP; apply $\chi^t = \{x_i^t\}_{i=1}^N$2 RRMP forward blocks with fixed edges; decode back to physical variables; retain only the predicted dynamic component; then update positions. The inverse pipeline uses the same steps in reverse order, substituting RRMP inverse blocks for forward blocks: $\chi^t = \{x_i^t\}_{i=1}^N$3

The training objective is MSE-dominated. The paper gives

$\chi^t = \{x_i^t\}_{i=1}^N$4

$\chi^t = \{x_i^t\}_{i=1}^N$5

and a bidirectional consistency loss,

$\chi^t = \{x_i^t\}_{i=1}^N$6

An ablation reported that using only MSE, denoted DL$\chi^t = \{x_i^t\}_{i=1}^N$7, achieved the best results, while adding MMD or cosine similarity hurt performance. The optimizer is Adam with initial learning rate $\chi^t = \{x_i^t\}_{i=1}^N$8 and cosine decay, batch size 2, and early stopping on validation loss. The reported complexity is dominated by message passing: each RRMP layer costs $\chi^t = \{x_i^t\}_{i=1}^N$9, and the total per-step cost is $x_i^t = [p_i^t, m_i],$0.

The major operational consequence is that inverse inference is non-iterative. Unlike optimization-based inverse solvers, the model does not solve a trajectory-level optimization problem at inference time; it applies a one-pass inverse map per step. This design is central to its reported speed and stability properties.

4. Relation to structure-preserving reversible graph dynamics

A broader, more physically structured view of reversible graph simulation appears in bracket-based graph dynamics. A self-contained blueprint for designing and analyzing an R-GNS using the framework of “Reversible and irreversible bracket-based dynamics for deep graph neural networks” formulates the graph state as $x_i^t = [p_i^t, m_i],$1, with $x_i^t = [p_i^t, m_i],$2 on nodes and $x_i^t = [p_i^t, m_i],$3 on edges. Reversible dynamics are written in Hamiltonian form,

$x_i^t = [p_i^t, m_i],$4

with skew-symmetric $x_i^t = [p_i^t, m_i],$5, so that

$x_i^t = [p_i^t, m_i],$6

Irreversible dynamics use a positive semidefinite operator $x_i^t = [p_i^t, m_i],$7,

$x_i^t = [p_i^t, m_i],$8

implying

$x_i^t = [p_i^t, m_i],$9

The same framework also includes double-bracket and metriplectic combinations with degeneracy conditions $p_i^t$0 and $p_i^t$1 (Gruber et al., 2023).

On graphs, the key operators are built from graph calculus. With signed incidence $p_i^t$2, learned adjoint

$p_i^t$3

and SPD clique-wise metrics $p_i^t$4, the reversible generator is

$p_i^t$5

A basic energy is

$p_i^t$6

with

$p_i^t$7

For depth discretization, the blueprint recommends a leapfrog layer: $p_i^t$8

$p_i^t$9

$m_i$0

The reverse step uses the same three updates in reverse order with $m_i$1. In this construction, reversibility is tied to skew-adjointness, symplectic integration, and exact-sequence properties such as $m_i$2 and $m_i$3.

This suggests a conceptual distinction within reversible graph simulation. The RRMP-based R-GNS enforces algebraic invertibility of latent message passing for bidirectional inference in dissipative fluids, whereas the bracket-based blueprint emphasizes structure-preserving graph dynamics with explicit conservation or dissipation guarantees across network depth.

5. Empirical performance

The named R-GNS was evaluated on WaterDrop, WaterRamp, and Water_3D for forward simulation, inverse inference, and goal-conditioned control (Huang et al., 26 Sep 2025). Forward simulation results were reported as rollout MSE values in units of $m_i$4.

Dataset	R-GNS	GNS
Water_3D	9.5	12.1
WaterDrop	0.31	0.70
WaterRamp	9.0	10.9

The same comparison included NeuralSPH, EGNN, DMCF, and an ablated R-GNS$m_i$5, with R-GNS reported as best on all three datasets listed above. On WaterDrop, efficiency figures were: Parameter Count (M) $m_i$6 for R-GNS versus $m_i$7 for GNS; Inference Time (ms/step) $m_i$8 for R-GNS versus $m_i$9 for GNS; and Inference Memory (MB) $v^{t+1}$0 for R-GNS versus $v^{t+1}$1 for GNS.

Inverse inference on WaterDrop at inverse step $v^{t+1}$2 reported Consistency MSE $v^{t+1}$3 of $v^{t+1}$4 for R-GNS, $v^{t+1}$5 for Sep-GNS, and $v^{t+1}$6 for DiffTaichi+SPH. The corresponding inference times were $v^{t+1}$7 s, $v^{t+1}$8 s, and $v^{t+1}$9 s, with Max Stable Steps reported as $p^t$0, $p^t$1, and $p^t$2, respectively. The paper summarizes this as more than $p^t$3 faster inverse inference than optimization-based baselines and only one quarter of the parameters of training two separate GNS models.

Goal-conditioned experiments treated the target shape as a given final state and applied inverse inference followed by forward rollout. The reported examples include Water-3D targets shaped as the characters “L” and “N”, with R-GNS described as maintaining structural fidelity where Sep-GNS loses structural consistency and optimization methods fail at that scale.

These results should be read together with the original GNS findings. GNS already showed strong long-horizon generalization and plausible rollouts across fluids, rigid solids, and deformables, but it relied on one-step training, noise corruption for rollout robustness, and a non-reversible update rule (Sanchez-Gonzalez et al., 2020). R-GNS addresses a different regime: not only forward prediction, but also consistent inverse recovery under dissipative dynamics.

6. Misconceptions, limitations, and open questions

A central misconception is that R-GNS “reverses fluid physics.” The paper explicitly states otherwise: it does not attempt to reverse the underlying physics. Instead, it imposes a mathematically reversible latent mapping and uses that mapping to recover one plausible initial trajectory consistent with the learned forward dynamics (Huang et al., 26 Sep 2025). Because dissipative fluids are physically irreversible, the inverse solution is not a unique physical ground truth.

A second misconception is that reversibility was already implicit in earlier GNS formulations. The GNS paper states that reversibility or invertibility is not discussed, and that the default semi-implicit Euler update is not time-reversible (Sanchez-Gonzalez et al., 2020). R-GNS is therefore not a minor reinterpretation of GNS, but a different architectural commitment.

The main limitations reported for R-GNS are also specific. Computational efficiency degrades when scaling to very large particle counts of $p^t$4–$p^t$5, and richer goal conditioning demands finer detail. The architecture additionally depends on fixed edge features during each forward or inverse step to preserve conditional symmetry. A plausible implication is that settings with rapidly changing topology or more complex control constraints may require modified reversible interfaces or hierarchical graph updates.

More broadly, reversible graph simulation sits within an unresolved methodological tension. In bracket-based deep graph dynamics, both reversible and irreversible mechanisms can avoid oversmoothing, and partially dissipative models may perform best on some tasks, including node classification (Gruber et al., 2023). This suggests that exact reversibility is not universally optimal. In fluid simulation, the R-GNS results indicate that reversible latent propagation can be advantageous even for dissipative systems, but the broader question remains task-dependent: whether one should prioritize exact inversion, controlled dissipation, or a metriplectic combination of the two.

Taken together, the literature defines R-GNS not as a single universal recipe, but as a specific family of reversible graph simulators whose unifying feature is structural control over information flow across depth or time. In the particle-fluid setting, that control is realized through ILP and RRMP for bidirectional consistency; in structure-preserving graph dynamics, it is realized through bracket operators, learned inner products, and reversible integrators.