Sparse Lyapunov Search for Safe Optimizer Hyperparameters
Implementation & benchmark of arXiv:2607.08753 — Finding Simple Proofs for First-Order Optimization
Source paper: Finding Simple Proofs for First-Order Optimization arXiv:2607.08753 ⓘ · analyzed Aug 30, 2026
AI-generated research hypothesis, automatically tested. Not peer-reviewed.
Idea description
Use the paper's certificate-sparsification procedure to search for a small Lyapunov proof of an optimizer's contraction on local strongly convex quadratic models. The active interpolation inequalities and resulting sparse Lyapunov coefficients become a data-driven rule for limiting learning rate and momentum per layer or parameter block, instead of relying only on global heuristics.
Formulas
Mathematical statement
For a function that is simultaneously mu-strongly convex and L-smooth, the paper represents each interpolation condition between points (x_i,g_i) and (x_j,g_j) as H_mu,L(x_i,x_j)=<s,q_{i,j}>+tr(GQ_{i,j}), where G is a positive semidefinite Gram matrix of displacement and gradient vectors, s contains function-value differences, q_{i,j}=e_i-e_j, and Q_{i,j} is defined by tr(GQ_{i,j})=-<g_j,x_i-x_j>-(1/(2(L-mu)))||g_i-g_j-mu(x_i-x_j)||^2-(mu/2)||x_i-x_j||^2. A performance-estimation proof is an SDP over G and s, with objective <s,q_P>, interpolation constraints H_mu,L(x_i,x_j)>=0, and linear equalities encoding optimizer iterations. The paper then performs a second optimization over nonnegative dual multipliers lambda_{ij}, minimizing a weighted l1 cost sum_{ij} w_{ij} lambda_{ij} while retaining a valid certificate. The sparse support identifies the inequalities essential for the Lyapunov/convergence argument. In the ML adaptation, mu and L are estimated from Hessian-vector products or gradient secant pairs, and the sparse certificate is used to choose a safe per-block learning rate eta and momentum beta.
Implementation notes
(1) Exact integration point: build an offline certificate-search tool around a momentum-SGD update and use its output online as a per-layer learning-rate and momentum ceiling. For each layer or optimizer parameter block, collect a warmup history of parameter displacements and gradient displacements, then approximate the local objective by a quadratic with curvature interval [mu,L]. (2) Pseudocode: collect K pairs (delta_x, delta_g); estimate L=max_k ||delta_g_k||/max(||delta_x_k||,epsilon) and mu=max(0,min_k <delta_g_k,delta_x_k>/max(||delta_x_k||^2,epsilon)); enumerate a short trajectory x_0,...,x_N under candidate eta and beta; create Gram variables G and function-value variables s; impose G positive semidefinite, H_mu,L(x_i,x_j)>=0 using the displayed interpolation formula, and trajectory equations x_{k+1}=x_k-eta g_k+beta(x_k-x_{k-1}); solve the performance SDP for contraction ratio rho. Then solve the weighted l1 re-optimization over nonnegative dual multipliers lambda_ij, minimizing sum w_ij lambda_ij while preserving rho<=rho_target. Binary-search the largest eta and beta for which a sparse certificate exists. During training, clip the proposed eta_layer and beta_layer to these certified values. (3) Computed from the paper's mathematics: the Gram SDP, interpolation residuals, dual multipliers, active inequality set, and certified contraction bound. Estimated empirically: mu, L, rho_target, and the validity horizon of the local quadratic approximation; smooth curvature estimates with an exponential moving average and recompute certificates every M updates. (4) First cheap experiment: train a 2-layer MLP and a small ResNet on MNIST or CIFAR-10 using momentum SGD, comparing global cosine-decay tuning with certificate-based per-layer ceilings at equal batch size and FLOPs. Log training loss, validation loss, gradient norms, estimated eta times L, loss spikes, and divergence frequency. Success means fewer instability events and faster loss descent during the first 20 percent of training without reducing final validation accuracy; a stronger result is reaching the same validation loss with fewer warmup steps.
Verification
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 compact interpolation-residual verifier and curvature-based sparse certificate proxy for blockwise momentum SGD. The interpolation formula behaved as claimed: valid [mu,L] pairs had nonnegative residuals, while an underestimated L produced a negative residual. However, the secant-based curvature estimates were sometimes nonconservative, causing certificates with endpoint spectral radius above 1 and catastrophic divergence in 5/10 trials; the claimed safe optimizer behavior was therefore not reproducibly observed.
- Agent confidence
- 9/10
- Baseline
- 10 trials: mean loss at 20% = 0.1768, mean final loss = 4.47e-08, mean loss-increase events = 80.1
- Idea
- 10 trials: mean loss at 20% = 3.01e11, mean final loss = 5.61e59, mean loss-increase events = 70.5; 5/10 trials diverged, max checked endpoint rho = 1.475
Limitations: This MVP uses an endpoint spectral-radius proxy rather than the paper's full Gram SDP and dual weighted-l1 sparsification. It tests only small diagonal quadratic blocks, not neural-network training, GPU execution, online certificate recomputation, or robust confidence bounds for curvature estimation.
How to run: python3 evaluate.py
Verdict computed by deterministic test code from paired-seed statistics — not by the language model.
Artifacts
- evaluate.py 1.6 KB View Raw
- report.md 1.4 KB View
- sparse_lyapunov.py 5.1 KB View Raw