✗ Failed on benchmark 2026

Generator-Flow Equivariance Training

Implementation & benchmark of arXiv:2608.01582 — LieStoNet: Learning Lie Symmetries from Spatiotemporal Data for Stochastic Dynamical Systems

Usefulness8/10
Difficulty5/10
Novelty6/10

Source paper: LieStoNet: Learning Lie Symmetries from Spatiotemporal Data for Stochastic Dynamical Systems arXiv:2608.01582 ⓘ · analyzed Aug 31, 2026

AI-generated research hypothesis, automatically tested. Not peer-reviewed.

Idea description

Use discovered infinitesimal generators to create small continuous transformations of hidden states and force a neural predictor to commute with those transformations. This converts symmetry discovery into self-supervised augmentation without prespecifying a group, canonical coordinates, or hand-designed equivariant layers.

Formulas

$$\Phi_{a,\epsilon}(z)=z+\epsilon G_a(z)+O(\epsilon^2)$$
$$\mathcal{L}_{\mathrm{eq}}=\frac{1}{|\mathcal{B}|r|\mathcal{E}|}\sum_{z,a,\epsilon\in\mathcal{E}}\left\|P_\theta(\Phi_{a,\epsilon}(z))-\Phi_{a,\epsilon}(P_\theta(z))\right\|_2^2$$
$$[G_a,F_\theta](z)=J_{F_\theta}(z)G_a(z)-J_{G_a}(z)F_\theta(z)$$
$$\mathcal{L}_{\mathrm{inf}}=\frac{1}{|\mathcal{B}|r}\sum_{z,a}\|[G_a,F_\theta](z)\|_2^2,\qquad \mathcal{L}_{\mathrm{eq}}(\epsilon)=O(\epsilon^4)\ \text{in squared norm when first-order equivariance holds}$$

Mathematical statement

Let F_theta(z) be a latent neural dynamics field and G_a(z) a learned symmetry generator. Commuting flows require [G_a,F_theta](z)=J_{F_theta}(z)G_a(z)-J_{G_a}(z)F_theta(z)=0. For a discrete predictor P_theta, use the finite-flow condition P_theta(Phi_{a,epsilon}(z)) approximately equals Phi_{a,epsilon}(P_theta(z)), where Phi_{a,epsilon} is the time-epsilon flow generated by G_a. With Euler integration, Phi_{a,epsilon}(z)=z+epsilon G_a(z)+O(epsilon^2). If the first-order equivariance condition is satisfied, the finite-flow discrepancy is O(epsilon^2), and its squared norm is expected to scale as O(epsilon^4).

Implementation notes

Insert the method into a latent predictor or world model. Encode x_t as z_t=E_theta(x_t), predict z_hat_(t+1)=P_theta(z_t), and obtain generators G_a from the learned Lie-algebra module. For each minibatch, select generator indices and amplitudes epsilon in {epsilon_0,2 epsilon_0}. Compute Phi(z)=z+epsilon G_a(z), evaluate P_theta(Phi(z)), evaluate Phi(P_theta(z)), and add their squared difference to the prediction loss. A more efficient infinitesimal implementation computes the commutator with two Jacobian-vector products and uses L_inf. Use several small epsilon values and stop gradients through G during early training so the system cannot satisfy equivariance by making generators zero. The learned-generator construction is taken from the paper; finite-flow augmentation and predictor commutation are the neural-network adaptation. First test on a latent predictor trained on rotated 2D damped-oscillator or isotropic Ornstein-Uhlenbeck trajectories, withholding several rotation angles during training. Compare ordinary prediction, random augmentation, and learned-flow equivariance. Plot equivariance error against epsilon on log-log axes. The quantitative prediction is that the squared error scales as epsilon^4 after first-order equivariance is learned, versus epsilon^2 for a non-equivariant baseline; rotated-test error should decrease when normalized commutator residual crosses below 10^-2.

Verification

Failed on benchmark

Stage 1 · Toy mechanism gate: Passed ✓

Stage 2 · Mechanism transferred to benchmark: Not reproduced ✗

Stage 2 · Practical benchmark result: No measurable effect

Methodology: 8 paired seeds, permutation test (p<0.05) against a learning-rate-tuned baseline. How verification works

Stage 1 — Mechanism check agent confidence 8/10

Built a reproducible generator-flow equivariance MVP with analytic rotation generators, finite-flow discrepancy sweeps, and a CUDA-enabled latent predictor experiment. The core mechanism matched its quantitative predictions: squared discrepancy slopes were 4.0000 for an equivariant radial map and 2.0000 for a non-equivariant map across generator strengths, while lambda slopes were 4.0000 and 2.0000 respectively. In the learned predictor, rotated-test MSE improved from 0.01903 to 0.01461 (23.2%), although the measured finite-flow error at epsilon=0.05 increased, so the generalization signal is promising but not a uniform win.

Agent confidence
8/10
Baseline
train MSE 7.7366e-05; rotated-test MSE 0.01903; finite-flow error 5.0752e-05
Idea
train MSE 7.2847e-05; rotated-test MSE 0.01461; finite-flow error 1.1831e-04; epsilon slopes 4.0000 vs predicted 4 and 2.0000 vs predicted 2

Limitations: This is a small 2D controlled toy experiment using a known fixed rotation generator rather than a learned generator module. It did not test the paper's full SDE generator discovery, random augmentation baseline, multiple seeds, FLOPs-normalized comparisons, longer trajectories, or an infinitesimal commutator/JVP implementation.

How to run: python3 experiment.py

Stage 2 — Benchmark vs. tuned baseline (arXiv:2608.01582)

No significant difference vs. the tuned baseline (+0.0%, p=0.1336, wins 2 / 8 paired seeds).

Benchmark
Dynamics forecasting
Model
rnn_small
Paired seeds
8
Baseline mean
0.0006
Idea mean
0.0006
Effect (Δ)
0 (+0.0%; negative = idea better)
Wins
2 / 8 paired seeds
p-value
0.1336 (permutation test, 20 000 shuffles)
Smallest detectable effect
n/a
Mechanism
Not confirmed ✗
Practical effect
No effect
Baseline tuning
swept over 3 configs
Limitations:

The run used the benchmark's fast 400-training/200-test sample size and 5 epochs after the original 20-epoch configuration exceeded the 40-minute shared-resource limit. The generator was a fixed nonzero block-rotation surrogate rather than a learned generator-discovery module, and no longer-horizon rollout or FLOP-normalized analysis was tested.

How to run: python3 bench_experiment.py

Verdict computed by deterministic test code from paired-seed statistics — not by the language model.

Stage 2 — Benchmark latest Failed ✗

Agent confidence: 9/10

Implemented generator-flow equivariance training on the structurally matched dynamics track with the benchmark rnn_small architecture, shared learning-rate sweep, and 8 paired seeds. Baseline test MSE was 0.000598690542 and idea MSE was 0.000598691426, giving a negligible worsening of +8.84e-10 with permutation p=0.1336. The trained-model mechanism signature showed epsilon^2 scaling for both systems rather than the predicted epsilon^4, so the proposed effect was not observed.

Baseline
dynamics/rnn_small; best lr=0.006; 8-seed test MSE mean 0.0005986905416648369, std 0.00013523162707717426
Idea
generator-flow loss; best lr=0.006; 8-seed test MSE mean 0.000598691425693687, std 0.0001352314673128437; paired delta +8.840288501232862e-10; permutation p=0.1336

Benchmark result

No significant difference vs. the tuned baseline (+0.0%, p=0.1336, wins 2 / 8 paired seeds).

Benchmark
Dynamics forecasting
Model
rnn_small
Paired seeds
8
Baseline mean
0.0006
Idea mean
0.0006
Effect (Δ)
0 (+0.0%; negative = idea better)
Wins
2 / 8 paired seeds
p-value
0.1336 (permutation test, 20 000 shuffles)
Smallest detectable effect
n/a
Mechanism
Not confirmed ✗
Practical effect
No effect
Baseline tuning
swept over 3 configs
Limitations:

The run used the benchmark's fast 400-training/200-test sample size and 5 epochs after the original 20-epoch configuration exceeded the 40-minute shared-resource limit. The generator was a fixed nonzero block-rotation surrogate rather than a learned generator-discovery module, and no longer-horizon rollout or FLOP-normalized analysis was tested.

How to run: python3 bench_experiment.py

Artifacts

Implementation overview ⬇ Download all as ZIP 6 files · code, reports and structured results