✗ Failed on benchmark 2026

Weak Koopman Latent Dynamics

Implementation & benchmark of arXiv:2607.25950 — Weak-form Extended Dynamic Mode Decomposition

Usefulness8/10

Difficulty5/10

Novelty7/10

Dynamics Stability Accuracy Generalization Ssm Rnn World model Training dynamics Regularization Dynamical systems Functional analysis Linear algebra Statistics

Source paper: Weak-form Extended Dynamic Mode Decomposition arXiv:2607.25950 ⓘ · analyzed Aug 31, 2026

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

Idea description

Replace noisy pointwise derivative matching in a neural state-space model with a weak-form Koopman-generator residual. An encoder maps observations to latent observables, while a learned matrix generator propagates those observables. Integration by parts removes the need to differentiate noisy trajectories and provides a controllable noise-averaging mechanism.

Formulas

$$\mathcal{L}g(x)=f(x)\cdot\nabla g(x),\qquad \frac{d}{dt}g(x(t))=\mathcal{L}g(x(t)).$$

$$\int_a^b\psi_j(t)\mathcal{L}g(x(t))\,dt=-\int_a^b\psi_j'(t)g(x(t))\,dt,\qquad \psi_j(a)=\psi_j(b)=0.$$

$$G_{j\ell}=\int_a^b\psi_j(t)z_\ell(t)\,dt,\qquad B_{j\ell}=-\int_a^b\psi_j'(t)z_\ell(t)\,dt,\qquad A=\operatorname*{arg\,min}_A\|B-GA^\top\|_F^2.$$

$$\operatorname{Var}(\widehat{B}_j^{\mathrm{noise}})=\sigma^2\sum_i(w'_{j,i})^2,\qquad \operatorname{Var}\left(\frac{\epsilon_{i+1}-\epsilon_i}{\Delta t}\right)=\frac{2\sigma^2}{\Delta t^2}.$$

Mathematical statement

For a dynamical system $\dot{x}=f(x)$ and observable $g(x)$, the Koopman generator is $\mathcal{L}g=f(x)\cdot\nabla g(x)$, with $\frac{d}{dt}g(x(t))=\mathcal{L}g(x(t))$. For a smooth test function $\psi(t)$ vanishing at both endpoints of $[a,b]$, integration by parts gives $\int_a^b\psi(t)\mathcal{L}g(x(t))dt=-\int_a^b\psi'(t)g(x(t))dt$. For latent observables $z(t)=E_\theta(x(t))\in\mathbb{R}^d$, define $G_{j\ell}=\int\psi_j(t)z_\ell(t)dt$ and $B_{j\ell}=-\int\psi_j'(t)z_\ell(t)dt$. Fit a latent generator $A\in\mathbb{R}^{d\times d}$ through $B\approx GA^\top$. With independent observation noise of variance $\sigma^2$, the variance of a discrete weak estimate is $\sigma^2\sum_i(w'_{j,i})^2$, whereas a forward finite difference has variance $2\sigma^2/\Delta t^2$.

Implementation notes

1. Exact integration point: use this as the dynamics module of a neural ODE, recurrent state-space model, or world model. Let an encoder $E_\theta$ map each noisy observation $x_i$ to $z_i\in\mathbb{R}^d$, and optionally use a decoder to reconstruct observations. Sample trajectory windows and use compactly supported Hann or cubic B-spline test functions $\psi_j$. 2. Pseudocode: compute $z_i=E_\theta(x_i)$; compute $G[j,:]=\sum_iq_i\psi_j(t_i)z_i$ and $B[j,:]=-\sum_iq_i\psi'_j(t_i)z_i$; solve the ridge generator update $A^\top=(G^\top G+\lambda I)^{-1}G^\top B$; minimize $L=L_{\mathrm{recon}}+\alpha\|B-GA^\top\|_F^2+\beta\sum_i\|z_{i+1}-\exp(\Delta tA)z_i\|^2$. Alternate between solving for $A$ and updating encoder parameters, or differentiate through the ridge solution. Forecast with $z_{t+k\Delta t}=\exp(k\Delta tA)z_t$. 3. Computed from the paper: the weak identity, quadrature construction, and generator regression. Estimated empirically: encoder parameters, generator dimension, window width, noise variance, and test-function family. For a stable latent model, monitor the spectral abscissa $\alpha(A)=\max_i\operatorname{Re}\lambda_i(A)$ and reject or project updates with $\alpha(A)>0$, unless the physical system is known to be unstable. 4. First cheap experiment: use noisy Lorenz-63 or damped-pendulum trajectories, an MLP encoder with latent dimension $d=8$, and compare finite-difference derivative loss, ordinary EDMD, and weak-form loss at noise levels $\sigma\in\{0,0.05,0.1,0.2\}$. For each test-function width, estimate the residual variance over repeated noisy trajectories. The quantitative prediction is that weak residual variance matches $\sigma^2\sum_i(w'_{j,i})^2$ within 20 percent, while finite-difference variance scales as $2\sigma^2/\Delta t^2$ and increases as sampling becomes finer. The method is falsified if this scaling fails or if weak-form training does not reduce multi-step forecast error at nonzero noise.

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 9/10

Built a reproducible weak Koopman generator MVP with Hann test functions, quadrature-based G/B construction, integration-by-parts verification, analytic noise-variance predictions, and a finite-difference baseline. The weak identity error was 1.13e-6; measured weak and finite-difference noise variances matched theory within about 2.3%, with scaling slopes weak-vs-dt=+1.000, finite-difference-vs-dt=-1.999, and weak-vs-window=-0.995. In the oscillator generator fit at sigma=0.15, weak regression error was 0.223 versus 0.408 for finite differences, a 45.4% reduction, so the proposed noise-averaging mechanism manifested clearly in this toy setting.

Agent confidence: 9/10

Baseline: Finite-difference derivative regression: variance followed 2*sigma^2/dt^2; oscillator generator Frobenius error 0.4081 at sigma=0.15.
Idea: Weak Hann-form regression: variance matched sigma^2*sum(weights^2), weak variance scaled as dt^1 and window^-1; oscillator generator Frobenius error 0.2228, ratio 0.546 of baseline.

Limitations: This is a small linear oscillator experiment with directly observed two-dimensional observables, not a learned neural encoder or Lorenz-63/world-model task. It does not test decoder reconstruction, nonlinear latent representations, multi-step forecasting, stability projection, correlated or colored noise, or computational cost at neural-network scale.

How to run: python3 weak_koopman_experiment.py

Stage 2 — Benchmark vs. tuned baseline (arXiv:2607.25950) Aug 31, 2026

No significant difference vs. the tuned baseline (+0.4%, p=0.969, wins 4 / 8 paired seeds).

Benchmark: Dynamics forecasting
Model: rnn_small
Paired seeds: 8
Baseline mean: 0.0001
Idea mean: 0.0001
Effect (Δ): 0 (+0.4%; negative = idea better)
Wins: 4 / 8 paired seeds
p-value: 0.969 (permutation test, 20 000 shuffles)
Smallest detectable effect: ±17.7%
Mechanism: Not confirmed ✗
Practical effect: No effect
Baseline tuning: swept over 6 configs

Limitations:

This benchmark used the built-in actuated pendulum one-step target rather than long-horizon rollout forecasting, and the latent generator was jointly optimized without a separate ridge-update/decoder reconstruction objective. Only the supplied dynamics track and 8-seed protocol were tested; no Lorenz-63, colored noise, multi-step stability projection, decoder, or computational-cost comparison was run.

How to run: python3 bench_weak_koopman.py

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

Stage 2 — Benchmark Aug 31, 2026 latest Failed ✗

Agent confidence: 9/10

Implemented and reran Weak Koopman Latent Dynamics on the registered built-in dynamics track using the canonical rnn_small architecture and 8 paired seeds. The weak residual mechanism was confirmed at neural-network scale, but independent pendulum test MSE was marginally worse than the tuned baseline and the paired permutation test was not significant. Therefore the idea does not qualify as a benchmark win.

Baseline: Mean test MSE 0.0001381416768708732; tuned lr=0.01, weight_decay=0.0.
Delta mean: 5.984238669043407e-07
Idea: Mean test MSE 0.00013874010073777754; best alpha=0.01 at lr=0.01, weight_decay=0.0.
P value: 0.969

Benchmark result