△ Mechanism confirmed, baseline not beaten 2026

Jacobian-Frozen Stable Rollouts

Implementation & benchmark of arXiv:2609.03348 — Taylor-Informed Indirect Adaptive Predictive Control Using Jacobian-Frozen Affine Predictors

Usefulness7/10

Difficulty5/10

Novelty5/10

Dynamics Stability Accuracy World model Rnn Ssm Training dynamics Regularization Dynamical systems Control theory Spectral theory Linear algebra Approximation theory

Source paper: Taylor-Informed Indirect Adaptive Predictive Control Using Jacobian-Frozen Affine Predictors arXiv:2609.03348 ⓘ · analyzed Sep 4, 2026

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

Idea description

Replace an expensive nonlinear rollout of a recurrent or neural state-space model by a locally affine rollout whose Jacobian is evaluated once at the current state and then frozen over a short horizon. Use the resulting transition matrix as an explicit stability monitor and optionally penalize or clip its spectral radius, reducing exploding long-horizon predictions without forcing the entire nonlinear network to be globally contractive.

Formulas

$$A_k=\left.\frac{\partial g_{\theta}(x,u)}{\partial x}\right|_{(x_k,u_k)},\qquad B_k=\left.\frac{\partial g_{\theta}(x,u)}{\partial u}\right|_{(x_k,u_k)},\qquad c_k=g_{\theta}(x_k,u_k)-A_kx_k-B_ku_k.$$

$$\widehat{x}_{k+i+1}=A_k\widehat{x}_{k+i}+B_k\widehat{u}_{k+i}+c_k,\qquad i=0,\ldots,H-1.$$

$$\rho(A_k)<1\ \Longrightarrow\ \|A_k^i\|\to0;\qquad \mathcal{L}_{\mathrm{jac}}=\left[\max\left(0,\rho(A_k)-r\right)\right]^2,$$

$$g_{\theta}(x_k+\delta x,u_k+\delta u)=g_{\theta}(x_k,u_k)+A_k\delta x+B_k\delta u+O(\|\delta x\|^2+\|\delta u\|^2).$$

Mathematical statement

Let $g_{\theta}(x,u)$ be a learned one-step state transition, with state $x\in\mathbb{R}^{n}$, input $u\in\mathbb{R}^{m}$, and parameters $\theta$. At the current operating point $(x_k,u_k)$, define $A_k=\partial g_{\theta}/\partial x|_{(x_k,u_k)}$, $B_k=\partial g_{\theta}/\partial u|_{(x_k,u_k)}$, and $c_k=g_{\theta}(x_k,u_k)-A_kx_k-B_ku_k$. The Jacobian-freezing mechanism uses $\hat{x}_{k+i+1}=A_k\hat{x}_{k+i}+B_k\hat{u}_{k+i}+c_k$ over a prediction horizon. For autonomous or fixed-input rollouts, local asymptotic stability is predicted when $\rho(A_k)<1$, where $\rho$ is the spectral radius; $\|A_k\|_2<1$ is a sufficient contraction condition. The first neglected nonlinear term gives local mismatch of order $O(\|\delta x\|^2+\|\delta u\|^2)$.

Implementation notes

Integrate this at the rollout layer of a recurrent world model, neural state-space model, or SSM that predicts latent states. At the beginning of every training sequence, compute one Jacobian-vector-product-based estimate of $A_k$ and $B_k$ at the observed initial state; construct $c_k$; then use the affine recurrence for an auxiliary horizon loss or for inference-time planning. Pseudocode: (1) evaluate $y=g_\theta(x_k,u_k)$; (2) obtain $A_k$ and $B_k$ with automatic differentiation, Hutchinson/vector-Jacobian products, or an explicit Jacobian for small latent dimensions; (3) set $c_k=y-A_kx_k-B_ku_k$; (4) repeatedly update $\hat{x}\leftarrow A_k\hat{x}+B_ku+c_k$; (5) minimize prediction loss plus $\lambda[\max(0,\rho(A_k)-r)]^2$. Compute $\rho(A_k)$ exactly for small states, or estimate it with 10--20 power iterations; use $r<1$, such as $0.98$, as the target. The paper supplies the frozen-affine construction; the contraction penalty and neural rollout use are adaptations. The first cheap experiment is a GRU or MLP state-space model trained on damped nonlinear oscillator or Lorenz-63 sequences, comparing ordinary nonlinear rollout, frozen-affine rollout, and spectral-penalty training. Sweep the learned Jacobian gain and measure the divergence boundary. The quantitative prediction is that affine error grows quadratically with radius around the expansion state, while long-horizon error sharply worsens when measured $\rho(A_k)$ crosses $1$; the empirical boundary should be within roughly 20% of this predicted threshold.

Verification

Mechanism confirmed, baseline not beaten

Stage 1 · Toy mechanism gate: Passed ✓

Stage 2 · Mechanism transferred to benchmark: Confirmed ✓

Stage 2 · Practical benchmark result: Significantly worse ✗

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 Jacobian-frozen affine rollouts with analytic Jacobians, spectral-radius monitoring/clipping, and reproducible toy checks. The Taylor remainder had log-log slope 1.97 with approximately 4x error reduction when perturbations were halved, confirming quadratic local mismatch; the scalar stability boundary matched rho=1. On a bounded locally unstable map, rho=1.024 caused the unclipped frozen rollout to reach norm 1.03 by horizon 100, while clipping to 0.98 kept it at norm 0.011, demonstrating the promised stabilization effect. The effect is real in this toy setting, though clipping can reduce fidelity to nonlinear dynamics.

Agent confidence: 8/10

Baseline: Nonlinear rollout final norms at radii 0.03, 0.10, 0.25, 0.50, 0.90: 0.0764, 0.0689, 0.0578, 0.0586, 0.0924. Scalar stability decayed for rho<1 and grew for rho>1.
Idea: Frozen-rollout RMSE versus nonlinear truth at those radii: 0.00114, 0.00296, 0.0161, 0.0675, 0.1618. In the unstable-map check, raw rho=1.0235 produced final norm 1.0306; clipping to rho=0.98 produced final norm 0.0110 and maximum norm 0.1032.

Limitations: No learned GRU or world-model training, CUDA benchmark, wall-clock speed measurement, multi-seed sweep, or high-dimensional Jacobian-vector-product approximation was tested. The clipping rule was simple radial rescaling of a 2D matrix, and the unstable example was hand-designed.

How to run: python3 experiment.py && /home/maxwelhelp/main/bin/python3 unstable_check.py

Stage 2 — Benchmark vs. tuned baseline (arXiv:2609.03348) Sep 4, 2026

Significantly WORSE than the tuned baseline (+6.9%, p=0.0081, wins 0 / 8 paired seeds).

Benchmark: Dynamics forecasting
Model: rnn_small
Paired seeds: 8
Baseline mean: 0.0005
Idea mean: 0.0006
Effect (Δ): 0 (+6.9%; negative = idea better)
Wins: 0 / 8 paired seeds
p-value: 0.0081 (permutation test, 20 000 shuffles)
Smallest detectable effect: ±7.0%
Mechanism: Confirmed ✓
Practical effect: Hurts
Baseline tuning: swept over 3 configs

Limitations:

The benchmark's dynamics task predicts one future angle from an 8-step window, so the implementation uses a local differentiable Jacobian stability penalty rather than a full multi-step hidden-state frozen affine rollout. Explicit spectral-radius clipping, longer-horizon forecasting, hidden-state Jacobians, and inference-speed savings were not 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 Sep 4, 2026 latest Failed ✗

Agent confidence: 10/10

The full stage-2 bench was run on the structurally matched registered dynamics/rnn_small track with a tuned baseline sweep and 8 paired seeds. The Jacobian penalty reduced observed local Jacobian gain from 0.3045 to 0.2943, confirming the mechanism signal, but increased test MSE from 0.00054517 to 0.00058295; the paired permutation test gave p=0.0081 and verdict "idea worse (significant)". Therefore the idea does not transfer as a task-metric win on this benchmark.

Baseline: Mean test MSE 0.00054517226817552; full per-seed values [0.0004930912400595844, 0.0004765945195686072, 0.0004673648509196937, 0.0010376222198829055, 0.000511663849465549, 0.00027233464061282575, 0.0005571767687797546, 0.0005455300561152399].
Idea: Mean test MSE 0.0005829526708112098; full per-seed values [0.000502792012412101, 0.0004844724608119577, 0.0005921015981584787, 0.0010409810347482562, 0.000540185603313148, 0.00027245740056969225, 0.000595726422034204, 0.0006349048344418406]. Paired delta +0.000037780402635689825, p=0.0081.

Benchmark result