# Robust Instability Radius Monitor

- ID: 2534
- Canonical URL: https://synthcore.org/idea/2534/robust-instability-radius-monitor
- API JSON: https://synthcore.org/api/idea/2534.json
- API Markdown: https://synthcore.org/api/idea/2534.md
- Verification status: mechanism_failed
- Source: [arXiv:2608.18561](https://arxiv.org/abs/2608.18561)
- Category: regularization
- Solves: stability, generalization
- ML areas: rnn, ssm, regularization, training-dynamics
- Math tags: control-theory, dynamical-systems, spectral-theory
- Ratings: usefulness 7/10; difficulty 6/10; novelty 7/10

## Idea description

Apply the paper's distance-to-stabilization concept to the Jacobian of a recurrent or state-space neural layer. Estimate the smallest channel-wise diagonal perturbation that makes the local hidden-state dynamics contractive, then penalize models whose estimated radius is below a target margin.

## Mathematical statement

Let F_theta be the discrete hidden-state update, x_(t+1) = F_theta(x_t, u_t), and let J_theta be its Jacobian with respect to x evaluated at a sampled hidden state. Let d be a vector of channel-wise static perturbations and D(d) be the diagonal matrix with entries d_i. The neural robust instability radius is estimated as rho_hat(theta) = min over d of ||d||_infinity subject to spectral_radius(J_theta + D(d)) < 1. A target margin m is enforced with the penalty max(0, m - rho_hat(theta)) squared. The mechanism is useful because spectral radius below one implies local asymptotic decay of perturbations for the linearized discrete dynamics.

## Key formulas

- Delta = diag(delta_1, ..., delta_n), where each delta_i is a stable channel-wise uncertainty
- rho_star = inf { ||Delta||_infinity : Sigma(Delta,H,A) is stable }
- rho_hat(theta) = min_d { ||d||_infinity : spectral_radius(J_theta + diag(d)) < 1 }
- L_RIR(theta) = lambda_R max(0, m - rho_hat(theta))^2

## Implementation notes

Integration point: use an RNN or state-space layer with update x_next = F_theta(x, u). At each selected training step, sample hidden states from the current minibatch and estimate the Jacobian action with automatic-differentiation Jacobian-vector products. Pseudocode: set d to zero; for several candidate radii r in a binary search, run projected gradient descent on d within the box [-r, r] in every channel; estimate the largest eigenvalue magnitude of J plus diag(d) using 10 to 20 power or Arnoldi iterations; declare r feasible when that estimate is below one; use the smallest feasible r as rho_hat; add lambda_R times max(0, m minus rho_hat) squared to the task loss. The paper supplies the diagonal uncertainty structure and the minimum stabilizing norm; the Jacobian, adversarial perturbation, and spectral radius are estimated numerically. For continuous-time SSMs, replace spectral radius below one by maximum real eigenvalue below zero. First experiment: compare vanilla RNN, GRU, and diagonal-plus-low-rank SSM models on sequential MNIST or the adding problem, with and without the penalty. Sweep recurrent gain initialization and target margin m. Measure hidden-state growth, gradient norms, and rho_hat over training. Prediction: trajectories with estimated spectral radius above one will show non-decaying or growing perturbations, while trajectories below one will show exponential decay with slope approximately log of the measured spectral radius. The empirical transition should occur within about 20 percent of the predicted radius boundary.

## Verification

- Status: mechanism_failed
- Mechanism evidence: yes
- Mechanism confirmed: no
- Verdict: Built a reproducible Robust Instability Radius Monitor toy implementation with exact diagonal-radius checks, a coarse 2x2 coupled-matrix search, and a scalar recurrent training comparison. The math predictions passed: diagonal radius error was 0, the decay/growth transition occurred at |g|=1.0 exactly, and radius scaled as |g|-1. However, the proposed max(0, margin-rho_hat)^2 penalty has the wrong optimization direction: when active it drove g to 1.2066, rho_hat to 0.2066, and hidden growth to 2.12, versus baseline g=1.0, rho_hat=0, growth=1.0 and task loss 0.0. The radius estimator is numerically valid, but the stated regularizer does not penalize instability.

### Mechanism check

- Verdict: Built a reproducible Robust Instability Radius Monitor toy implementation with exact diagonal-radius checks, a coarse 2x2 coupled-matrix search, and a scalar recurrent training comparison. The math predictions passed: diagonal radius error was 0, the decay/growth transition occurred at |g|=1.0 exactly, and radius scaled as |g|-1. However, the proposed max(0, margin-rho_hat)^2 penalty has the wrong optimization direction: when active it drove g to 1.2066, rho_hat to 0.2066, and hidden growth to 2.12, versus baseline g=1.0, rho_hat=0, growth=1.0 and task loss 0.0. The radius estimator is numerically valid, but the stated regularizer does not penalize instability.
- Confidence: 10/10
- Limitations: Not tested on sequential MNIST, GRUs, larger RNNs, continuous-time SSMs, or automatic-differentiation Jacobian estimation. The coupled 2x2 radius values use a coarse brute-force grid rather than projected optimization, and a corrected penalty such as lambda*max(0,rho_hat-m)^2 was not evaluated.

## Artifacts

- [report.md](https://synthcore.org/code/973/report.md)
- [results.json](https://synthcore.org/code/973/results.json)
- [rir_experiment.py](https://synthcore.org/code/973/rir_experiment.py)
- [Download all files as ZIP](https://synthcore.org/download/973)

## Disclaimer

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