✗ Failed on benchmark 2026

Finite-horizon Lyapunov regularization for neural updates

Implementation & benchmark of arXiv:2608.22382 — Distributed model predictive control via finite-step control Lyapunov functions

Usefulness6/10
Difficulty4/10
Novelty7/10

Source paper: Distributed model predictive control via finite-step control Lyapunov functions arXiv:2608.22382 ⓘ · analyzed Aug 29, 2026

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

Idea description

Add a loss term requiring a neural optimizer or recurrent module to decrease a nonnegative Lyapunov-like energy over M update steps, rather than forcing monotonic one-step decrease. The term includes an empirically estimated mismatch allowance, so stochastic or delayed updates are tolerated while persistent instability remains penalized.

Formulas

$$V(z_{k+M})-V(z_k)\leq-\alpha V(z_k)+\varepsilon_k,$$
$$V_i(z_i(k+M))\leq\max\left\{\rho_iV_i(z_i(k)),\max_{j\in\mathcal N_i}\gamma_{ij}\bigl(V_j(z_j(k))\bigr)\right\}+\varepsilon_i(k),$$
$$V_k=\frac{1}{2}\|q_k\|_2^2,\qquad r_k=V_{k+M}-V_k+\alpha V_k-\widehat\varepsilon_k,$$
$$\mathcal L_{\mathrm{total}}=\mathcal L_{\mathrm{task}}+\lambda\,[r_k]_+^2,\qquad \widehat\varepsilon_k=\operatorname{EMA}\left(\left|V_{k+M}-V_k+\alpha V_k\right|\right).$$

Mathematical statement

The paper’s central construction is a finite-step Lyapunov condition for a discrete-time state update z_{k+1}=G(z_k): instead of requiring V(z_{k+1})-V(z_k)<0, require a finite-horizon decrease V(z_{k+M})-V(z_k)\leq -\alpha V(z_k)+\varepsilon_k. Here z_k is the state of the iterative process, V:\mathbb{R}^d o\mathbb{R}_{\geq 0} is a positive-definite certificate, M\in\mathbb{N} is the finite step horizon, \alpha\in(0,1] is the desired contraction fraction, and \varepsilon_k\geq0 is a mismatch or disturbance bound. For interconnected states z=(z_1,\ldots,z_\ell), the paper motivates finite-step small-gain inequalities of the form V_i(z_i(k+M))\leq\max\{\rho_iV_i(z_i(k)),\max_{j\in\mathcal N_i}\gamma_{ij}(V_j(z_j(k)))\}+\varepsilon_i(k), where V_i is a local certificate, \rho_i<1 is local contraction, and \gamma_{ij} measures neighbor influence. The neural adaptation uses the global scalar inequality as a soft training constraint. A concrete certificate is V_k=\frac{1}{2}\|q_k\|_2^2, where q_k is either the optimizer gradient or the recurrent hidden-state error relative to a detached target; the mismatch is estimated from repeated stochastic evaluations as \widehat\varepsilon_k=\operatorname{EMA}(|V_{k+M}-V_k+\alpha V_k|).

Implementation notes

(1) Integrate at the optimizer-update or recurrent-state-update level. Start with AdamW training a small MLP or Transformer encoder. Maintain a detached snapshot q_k of the current optimization state: for the optimizer experiment use q_k=g_k, the minibatch gradient after global-norm clipping; for an SSM experiment use q_k=h_k-h^\star, where h^\star is a stop-gradient exponential moving average of hidden states. Do not backpropagate through the first V_k term or through the EMA mismatch estimate. (2) Pseudocode: choose M in {2,4,8}, alpha in {0.05,0.1}; at step k compute V_k=0.5*||q_k||^2; save q_k in a FIFO queue; after M updates obtain q_{k+M} and V_{k+M}=0.5*||q_{k+M}||^2; update eps_hat = beta*eps_hat + (1-beta)*abs(V_{k+M}-V_k+alpha*V_k); form r=V_{k+M}-V_k+alpha*V_k-eps_hat.detach(); add lambda*relu(r)^2 to the ordinary task loss or, for an optimizer test, add the penalty to a meta-loss over a short unrolled trajectory. (3) The paper supplies the finite-step decrease structure; estimate V directly from gradients or hidden states and estimate epsilon empirically from recent violations. Clip r and normalize V by its batch mean to avoid scale domination. Log the violation rate, V_{k+M}/V_k, gradient norm, and task loss. (4) First experiment: train a 2-layer 256-unit MLP on CIFAR-10 with SGD or AdamW, comparing the baseline against M=4 and M=8 at equal batch size, FLOPs, and learning-rate search budget. Run three random seeds. The primary success signal is a lower fraction of exploding or highly oscillatory loss windows and a smaller variance of gradient norms at equal final accuracy; a secondary target is improved validation accuracy under a 20-30% larger learning rate. For an SSM follow-up, compare hidden-state norm stability and perplexity on a small character-level language-model task.

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 finite-horizon Lyapunov toy verifier and an online gradient-based MLP proxy. The mechanism manifested: predicted contraction boundaries for M=2,4,8 matched grid observations within 0.001; stochastic mismatch scaled quadratically with noise; and EMA violations transitioned from 0% for a=0.98 to 100% at a>=1.0, consistent with instability. The tiny MLP comparison did not show a practical win: the regularized run reached 26.7% accuracy versus 83.1% baseline and had higher tail loss and gradient variance, so the claim is supported only as a toy mechanism, not as an effective training method here.

Agent confidence
8/10
Baseline
MLP accuracy 0.8311; final tail loss 0.1600; tail loss std 0.0842; gradient std 0.3407.
Idea
MLP accuracy 0.2667; final tail loss 0.5933; tail loss std 0.9117; gradient std 0.8450. Toy contraction boundaries predicted/observed: M=2, 0.974004/0.974000; M=4, 0.986916/0.986000; M=8, 0.993437/0.993000. Noise mismatch normalization was 0.606-0.618; EMA violation rate was 0% at a=0.98 and 100% at a>=1.0.

Limitations: Only one fixed seed and a tiny sklearn digits MLP were used. CIFAR-10, multi-seed evaluation, optimizer meta-loss, recurrent modules, FLOP-matched hyperparameter search, and systematic lambda/M tuning were not tested. The gradient certificate is a practical delayed-minibatch-gradient proxy rather than a full unrolled optimizer-state Lyapunov implementation.

How to run: python3 experiment.py

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

Ahead of the baseline (−2.4%) but not statistically significant (p=0.4671, wins 5 / 8 paired seeds).

Benchmark
Dynamics forecasting
Model
rnn_small
Paired seeds
8
Baseline mean
0.0016
Idea mean
0.0015
Effect (Δ)
-0 (−2.4%; negative = idea better)
Wins
5 / 8 paired seeds
p-value
0.4671 (permutation test, 20 000 shuffles)
Smallest detectable effect
±6.5%
Mechanism
Not confirmed ✗
Practical effect
Inconclusive
Baseline tuning
swept over 3 configs
Limitations:

The final protocol used 800 training samples, 300 test samples, and 6 epochs to fit the runtime budget. Baseline and idea used the same three learning rates and all 8 paired seeds. Only the gradient certificate was tested; hidden-state certificates, other M values, lambda sweeps, and longer training were not tested.

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

The registered built-in dynamics track was benchmarked with rnn_small under the full 8-seed paired protocol. The Lyapunov intervention produced a small lower MSE, but the paired permutation test was not significant, and the trained-model gradient-energy ratio contradicted the predicted contraction; therefore the system did not work.

Baseline
Best tuned Adam baseline lr=0.01: test MSE 0.0015652803 ± 0.0007422460 over 8 seeds.
Idea
Best finite-horizon regularized model lr=0.01, M=4, alpha=0.1, lambda=0.002, beta=0.9: test MSE 0.0015269540 ± 0.0007877648; paired delta=-0.0000383263, p=0.46705.
Mechanism
Trained-model mean V[k+4]/V[k]=1.827379, violation rate=0.039474; contraction prediction was not confirmed.

Benchmark result

Ahead of the baseline (−2.4%) but not statistically significant (p=0.4671, wins 5 / 8 paired seeds).

Benchmark
Dynamics forecasting
Model
rnn_small
Paired seeds
8
Baseline mean
0.0016
Idea mean
0.0015
Effect (Δ)
-0 (−2.4%; negative = idea better)
Wins
5 / 8 paired seeds
p-value
0.4671 (permutation test, 20 000 shuffles)
Smallest detectable effect
±6.5%
Mechanism
Not confirmed ✗
Practical effect
Inconclusive
Baseline tuning
swept over 3 configs
Limitations:

The final protocol used 800 training samples, 300 test samples, and 6 epochs to fit the runtime budget. Baseline and idea used the same three learning rates and all 8 paired seeds. Only the gradient certificate was tested; hidden-state certificates, other M values, lambda sweeps, and longer training were not tested.

How to run: python3 bench_stage2.py

Artifacts

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