✗ Failed on benchmark 2026

Support-Sparse Koopman World Model

Implementation & benchmark of arXiv:2608.29057 — Sparse Koopman Autoencoders Identify Local Dynamical Regimes in Multibasin Systems

Usefulness7/10
Difficulty5/10
Novelty5/10

Source paper: Sparse Koopman Autoencoders Identify Local Dynamical Regimes in Multibasin Systems arXiv:2608.29057 ⓘ · analyzed Sep 1, 2026

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

Idea description

Replace a dense Koopman autoencoder latent with a sparse code whose active-coordinate support can represent the local dynamical regime or basin. Train reconstruction, latent linear prediction, and multi-step rollout losses jointly; use the learned support as a label-free regime variable and optionally select a local transition matrix for forecasting.

Formulas

$$x_{k+1}=F_{\Delta t}(x_k),\qquad x_k\in\mathbb{R}^{d_x}.$$
$$z_k=E_\theta(x_k),\qquad \hat{x}_k=D_\phi(z_k),\qquad \hat{z}_{k+h}=K^h z_k.$$
$$\mathcal{L}=\|D_\phi(E_\theta(x_k))-x_k\|_2^2+\alpha\|E_\theta(x_{k+1})-K E_\theta(x_k)\|_2^2+\gamma\frac{1}{H}\sum_{h=1}^{H}\|D_\phi(K^hE_\theta(x_k))-x_{k+h}\|_2^2+\lambda\|E_\theta(x_k)\|_1+\eta\|s(E_\theta(x_{k+1}))-s(E_\theta(x_k))\|_1.$$
$$s_j(z)=\frac{|z_j|}{|z_j|+\varepsilon},\qquad m_j(z)=\mathbf{1}\{|z_j|>\tau\},\qquad m(z)\in\{0,1\}^{d_z}.$$

Mathematical statement

The paper models sampled dynamics by the discrete recurrence x_{k+1}=F_{Delta t}(x_k), where x_k is the observed state in R^{d_x} and F_{Delta t} is the unknown time-Delta t flow map. Introduce an encoder E_theta from R^{d_x} to R^{d_z}, a decoder D_phi from R^{d_z} to R^{d_x}, and a latent linear operator K in R^{d_z times d_z}, with sparse latent code z_k=E_theta(x_k). The adapted objective is L=L_rec+alpha L_koop+gamma L_roll+lambda L_sparse+eta L_support. Here L_rec=||D_phi(z_k)-x_k||_2^2, L_koop=||z_{k+1}-K z_k||_2^2, L_roll=(1/H) sum from h=1 to H of ||D_phi(K^h z_k)-x_{k+h}||_2^2, and L_sparse=||z_k||_1. Define the soft support s_j(z)=|z_j|/(|z_j|+epsilon), where epsilon is positive, and encourage support persistence along a trajectory with L_support=||s(z_{k+1})-s(z_k)||_1. At inference, the discrete support is m_j(z)=1 if |z_j| exceeds tau and 0 otherwise, where tau is a validation-selected threshold. The intended mechanism is that different basins use different active coordinate subsets while each subset admits approximately linear evolution under K.

Implementation notes

Integrate this into a small state-space or world-model network, not into a language model. Use an MLP encoder E_theta mapping state vectors to a latent width d_z such as 32 or 64, an MLP decoder D_phi, and a trainable matrix K. Training batches should contain contiguous windows (x_k,...,x_{k+H}) from trajectories; use H=5 initially and increase to 10 after reconstruction stabilizes. For each window, compute z_k=E_theta(x_k), decode it, compute the one-step latent residual E_theta(x_{k+1})-K z_k, recursively generate K^h z_k, decode every rollout, and add the L1 latent penalty. Compute s(z) with absolute value divided by absolute value plus epsilon, using epsilon=10^{-6}, and add the support-persistence penalty for adjacent states from the same trajectory. Pseudocode: z=E(x[:,0]); rec=mean((D(z)-x[:,0])^2); pred_lat=0; pred_obs=0; sparse=mean(abs(z)); support=0; for h in 1..H: z=K @ z; pred_lat += mean((z-E(x[:,h]))^2); pred_obs += mean((D(z)-x[:,h])^2); support += mean(abs(s(E(x[:,h]))-s(E(x[:,h-1])))); loss=rec+alpha*pred_lat/H+gamma*pred_obs/H+lambda*sparse+eta*support. Select tau on validation data to produce an average active fraction of 10 to 30 percent, then cluster binary masks to test basin separation. The first experiment should use a two-basin nonlinear system such as a double-well oscillator or a mixture of two stable systems, with 1,000 training trajectories and held-out trajectories from each basin. Compare against a dense Koopman autoencoder with identical encoder width, parameter count, optimizer, and rollout loss. Success requires lower 20-step state MSE, less long-rollout divergence, and support-mask classification accuracy above the dense baseline on held-out basin-interior states. Include ablations without support persistence and with only one-step loss; the method is supported only if sparse supports remain stable along trajectories and forecasting improves at equal latent width.

Verification

Failed on benchmark

Stage 1 · Toy mechanism gate: Passed ✓

Stage 2 · Mechanism transferred to benchmark: Not reproduced ✗

Stage 2 · Practical benchmark result: Inconclusive

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 support-sparse Koopman autoencoder with reconstruction, latent prediction, multi-step rollout, L1 sparsity, and support-persistence losses, plus a two-basin double-well experiment. The three mathematical predictions were numerically confirmed: support derivative error 0.08%, rollout scaling error 0, and small-perturbation support scaling error 0.48%. Support persistence reduced adjacent support change by about 17x and basin-mask accuracy rose from 68.3% to 80.0%, but 20-step MSE worsened from 0.01398 to 0.01589, so the representation mechanism appeared without a forecasting win.

Agent confidence
8/10
Baseline
20-step MSE 0.013982; mask/basin accuracy 0.6833; support step change 3.3441e-05
Idea
20-step MSE 0.015889; mask/basin accuracy 0.8000; support step change 1.9406e-06; active fraction 0.2458

Limitations: Only one random seed and one small synthetic double-well system were tested. The dense and sparse models were not exhaustively parameter-matched or hyperparameter-tuned; no 40-minute super-check, longer horizons, multiple seeds, or rigorous held-out threshold selection was performed.

How to run: python3 experiment.py

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

Ahead of the baseline (−3.1%) but not statistically significant (p=0.7986, wins 6 / 8 paired seeds).

Benchmark
Dynamics forecasting
Model
rnn_small
Paired seeds
8
Baseline mean
0.0505
Idea mean
0.0489
Effect (Δ)
-0.0016 (−3.1%; negative = idea better)
Wins
6 / 8 paired seeds
p-value
0.7986 (permutation test, 20 000 shuffles)
Smallest detectable effect
n/a
Mechanism
Not confirmed ✗
Practical effect
Inconclusive
Baseline tuning
swept over 3 configs
Limitations:

CPU fallback was required after GPU allocation failures. The reduced run used NTR=400, NTE=200, and 4 epochs. Longer horizons, persistence ablations, basin-mask classification, and other architectures were not tested.

How to run: python3 stage2_bench.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

Support-sparse Koopman training was implemented on the matched dynamics track with an rnn_small backbone and auxiliary reconstruction, latent prediction, decoded rollout, sparsity, and support-persistence losses. Mean MSE improved from 0.0504752 to 0.0489187, but the paired permutation test was non-significant (p=0.7986), so the idea did not demonstrate a benchmark win.

Baseline
MSE 0.0504752, std 0.0150831, best lr 0.006
Idea
MSE 0.0489187, std 0.0086294, best lr 0.006, lambda 0.0005, eta 0.002
Mechanism signature
latent MSE 0.0325081, decoded h6 rollout MSE 0.305510, support change 3.44031e-05, active fraction 0.6012, confirmed=false
Paired delta
-0.00155656, 6/8 wins, p=0.7986

Benchmark result

Ahead of the baseline (−3.1%) but not statistically significant (p=0.7986, wins 6 / 8 paired seeds).

Benchmark
Dynamics forecasting
Model
rnn_small
Paired seeds
8
Baseline mean
0.0505
Idea mean
0.0489
Effect (Δ)
-0.0016 (−3.1%; negative = idea better)
Wins
6 / 8 paired seeds
p-value
0.7986 (permutation test, 20 000 shuffles)
Smallest detectable effect
n/a
Mechanism
Not confirmed ✗
Practical effect
Inconclusive
Baseline tuning
swept over 3 configs
Limitations:

CPU fallback was required after GPU allocation failures. The reduced run used NTR=400, NTE=200, and 4 epochs. Longer horizons, persistence ablations, basin-mask classification, and other architectures were not tested.

How to run: python3 stage2_bench.py

Artifacts

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