Support-Sparse Koopman World Model
Implementation & benchmark of arXiv:2608.29057 — Sparse Koopman Autoencoders Identify Local Dynamical Regimes in Multibasin Systems
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
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
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
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
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
- bench_report.json 3.5 KB View Raw
- experiment.py 5.5 KB View Raw
- report.md 1.4 KB View
- report_bench_2026-09-02T012706.md 3.1 KB View
- results.json 3.0 KB View Raw
- stage2_bench.py 4.6 KB View Raw
- stage2_stdout.json 3.5 KB View Raw