✗ Mechanism failed 2026

Robust Lyapunov Training Under Model Error

Implementation & benchmark of arXiv:2608.29303 — Learning neural controllers for nonlinear systems from data

Usefulness7/10
Difficulty6/10
Novelty7/10

Source paper: Learning neural controllers for nonlinear systems from data arXiv:2608.29303 ⓘ · analyzed Sep 1, 2026

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

Idea description

Require Lyapunov decrease not only under the nominal learned transition, but throughout a bounded uncertainty set around that transition. The policy is therefore optimized against identification error and distribution shift rather than trusting a potentially overconfident world model.

Formulas

$$f(x,u)=\hat f_{\phi}(x,u)+e(x,u),\qquad \|e(x,u)\|_{2}\leq\delta(x,u),$$
$$|V_{\psi}(z+e)-V_{\psi}(z)|\leq L_{V}(z)\|e\|_{2},\qquad z=\hat f_{\phi}(x,\pi_{\theta}(x)),$$
$$V_{\psi}(z)-V_{\psi}(x)+L_{V}(z)\delta(x,\pi_{\theta}(x))\leq-c_{2}\|x-x^{\star}\|_{2}^{2},$$
$$\mathcal{L}_{\mathrm{rob}}=\mathcal{L}_{\mathrm{task}}+\lambda\,\operatorname{softplus}\!\left(\Delta V+L_{V}(z)\delta(x,u)+c_{2}\|x-x^{\star}\|_{2}^{2}\right).$$

Mathematical statement

Let the true transition be $f(x,u)=\hat f_{\phi}(x,u)+e(x,u)$, where the unknown model error satisfies $\|e(x,u)\|_{2}\leq\delta(x,u)$. Let $L_{V}(z)$ be a bound on the local Lipschitz constant of $V_{\psi}$, meaning $|V_{\psi}(z+e)-V_{\psi}(z)|\leq L_{V}(z)\|e\|_{2}$. A sufficient robust decrease condition is $V_{\psi}(\hat f_{\phi}(x,\pi_{\theta}(x)))-V_{\psi}(x)+L_{V}(\hat f_{\phi}(x,\pi_{\theta}(x)))\delta(x,\pi_{\theta}(x))\leq-c_{2}\|x-x^{\star}\|_{2}^{2}$. The uncertainty term is the worst-case increase in Lyapunov energy caused by identification error. The certificate is meaningful only where the residual bound $\delta$ is calibrated on held-out transitions or obtained from a statistical confidence bound.

Implementation notes

1. Integration point: place the robust penalty in model-based RL or closed-loop sequence training after the learned dynamics model predicts the next state. Use an ensemble of dynamics models or residual statistics to estimate uncertainty. For each replay transition, compute $z=\hat f_{\phi}(x,u)$ and a residual radius $\delta(x,u)$; compute the Lyapunov decrease and add the uncertainty margin before backpropagation into the policy and Lyapunov networks. 2. Pseudocode: fit $M$ dynamics ensembles on the training split; at each batch, evaluate their next-state predictions, set $\delta(x,u)$ to a high quantile such as the empirical 95th-percentile ensemble deviation plus held-out residual error, compute $L_{V}(z)$ either by automatic differentiation $\|\nabla V(z)\|_{2}$ or by a local finite-difference maximum, and minimize the displayed robust loss. Initially stop gradients through $\delta$ to prevent the policy from gaming the uncertainty estimator. Periodically evaluate the robust inequality on held-out transitions. 3. The robust inequality and Lipschitz inflation are the analytic mechanism; $\delta$ and $L_{V}$ are estimated quantities. Calibrate $\delta$ so that at least 95% of held-out residuals fall inside the claimed ball. 4. First cheap experiment: use a two-dimensional nonlinear stabilization system, train with 20%, 50%, and 100% of the transition data, and compare ordinary Lyapunov regularization with uncertainty inflation. Measure the minimum robust margin $m=\min_x[-\Delta V-L_{V}\delta-c_{2}\|x-x^{\star}\|^{2}]$ on held-out states and the fraction of real rollouts that converge. The quantitative prediction is that the robust policy maintains convergence as data are removed until $m$ crosses zero; empirical failures should concentrate near this predicted boundary, while the nominal certificate can remain positive on the learned model but fail on real transitions.

Verification

Mechanism failed

Stage 1 · Toy mechanism gate: Failed ✗

Stage 2 · Mechanism transferred to benchmark: Not tested

Stage 2 · Practical benchmark result: Not run

Methodology: Toy-system gate first; the benchmark stage runs only after a pass. How verification works

Stage 1 — Mechanism check agent confidence 9/10

Built a nonlinear 2D stabilization MVP with nominal and robust Lyapunov penalties, analytic local Lipschitz inflation, bounded model mismatch, mechanism sweeps, and matched data-scarcity comparisons. The Lipschitz inequality passed numerically, with maximum violation about -1.5e-7, and the delta sweep matched the analytic certificate degradation within about 2e-7. However, convergence remained near 1% and robust training did not improve it, so the promised practical effect was not demonstrated.

Agent confidence
9/10
Baseline
Convergence 0.0113, 0.0147, 0.0087 at data fractions 1.0, 0.5, 0.2; actual violation 0.549, 0.548, 0.535; minimum robust margins -0.623, -0.779, -0.944.
Idea
Convergence 0.0093, 0.0133, 0.0087 at data fractions 1.0, 0.5, 0.2; actual violation 0.543, 0.533, 0.507; minimum robust margins -0.618, -0.751, -0.915. The delta mechanism sweep matched prediction, but all certificates were negative.

Limitations: The optimizer was deliberately small and used a fixed quadratic Lyapunov function rather than jointly learning V. Uncertainty was prescribed instead of estimated from an ensemble or calibrated held-out residuals. The controller was not stabilizing, so a meaningful zero-margin convergence transition was not located, and no larger RL benchmark was tested.

How to run: python3 experiment.py

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

Artifacts

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