△ Mechanism confirmed, baseline not beaten 2026

Differentiable Asymmetric Admissibility Layer

Implementation & benchmark of arXiv:2608.15375 — Admissibility-Preserving Control for Strict-Feedback Nonlinear Systems with Asymmetric Actuator Constraints

Usefulness8/10

Difficulty4/10

Novelty7/10

Architecture Stability Accuracy Generalization Mlp Rl World model Architecture Control theory Dynamical systems Optimization Numerical analysis

Source paper: Admissibility-Preserving Control for Strict-Feedback Nonlinear Systems with Asymmetric Actuator Constraints arXiv:2608.15375 ⓘ · analyzed Sep 1, 2026

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

Idea description

Replace hard clipping or post-hoc asymmetric saturation with a dynamic output state that remains inside a prescribed asymmetric interval. A neural network emits a command uc, while the realized output u evolves through the APIR vector field, producing bounded actions, temporal smoothing, and gradients that remain available in the interior.

Formulas

F(u,uc) = p1 uc [1 - (u/u_max)^gamma] - p2 u, for u >= 0; F(u,uc) = p1 uc [1 - (u/u_min)^gamma] - p2 u, for u < 0

F(u_max,uc) = -p2 u_max < 0; F(u_min,uc) = -p2 u_min > 0

xi [1 - (u_xi_plus/u_max)^gamma] - p2 u_xi_plus = 0

-xi [1 - (u_xi_minus/u_min)^gamma] - p2 u_xi_minus = 0

u_(k+1) = u_k + dt F(u_k,uc_k), with uc_k = pi_theta(s_k)

Mathematical statement

Let u_min < 0 < u_max denote the lower and upper action limits, uc(t) the neural command, p1 > 0 and p2 > 0 realization gains, and gamma an even integer at least 2. For u at least 0, use F(u,uc) = p1 uc [1 - (u/u_max)^gamma] - p2 u. For u below 0, use F(u,uc) = p1 uc [1 - (u/u_min)^gamma] - p2 u. At the upper boundary, F(u_max,uc) = -p2 u_max < 0. At the lower boundary, F(u_min,uc) = -p2 u_min > 0. Therefore the interval [u_min,u_max] is forward invariant for the continuous-time realization. If the command magnitude is bounded by xi, interior equilibrium locations are predicted by the APIR root equations. A sampled neural implementation uses numerical integration with time step dt.

Implementation notes

Integration point: place the layer after an MLP policy head, transformer action head, or world-model decoder. The network emits an unconstrained command uc, but the layer maintains u as persistent state and returns only u to the environment or downstream model. Use separate u_min and u_max for each action dimension. Pseudocode: compute uc = policy(observation); choose the branch from the current u; set limit to u_max when u is nonnegative and to u_min otherwise; compute d = p1 times uc times [1 minus (u divided by limit) raised to gamma] minus p2 times u; update u = u + dt times d; return u. Use Heun integration or semi-implicit treatment of the p2 term if Euler integration crosses a boundary. Backpropagate through the unrolled recurrence, with truncated backpropagation for long trajectories. The paper supplies the continuous-time invariance argument and equilibrium equations. The implementation must estimate command bounds, discrete-time safety margin, effective lag, and gradient statistics. First experiment: train a two-layer MLP on Pendulum-v1 or a synthetic action-tracking task with u_min = -0.5 and u_max = 1.0. Compare this layer with hard clipping and an asymmetric sigmoid at matched parameter counts. Log boundary violations, action jerk, tracking error, and policy-gradient norms. The prediction is zero continuous-time boundary violations, a measured discrete-time violation rate that becomes zero below a sufficiently small dt, and steady-state actions within 20 percent of the two APIR root equations. Increasing p2 should move the steady state toward the interior and increase restoring behavior; increasing p1 should reduce response lag without changing the invariant limits.

Verification

Mechanism confirmed, baseline not beaten

Stage 1 · Toy mechanism gate: Passed ✓

Stage 2 · Mechanism transferred to benchmark: Confirmed ✓

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 9/10

Built and ran a self-contained APIR layer experiment with asymmetric limits [-0.5, 1.0] and gamma=4. The mechanism manifested: boundary vector-field identities were exact, equilibria matched numerical roots to 7.2e-13 relative error, Euler violations were zero through dt=0.01 and appeared at dt=0.02, and increasing p1 reduced response time from 0.459 s at p1=2 to 0.093 s at p1=8. APIR had zero boundary violations and much lower jerk than hard clipping, although its tracking MSE was worse than both baselines in this noisy open-loop toy task.

Agent confidence: 9/10

Baseline: Hard clip: tracking MSE 0.11396, jerk RMS 2720.95, violations 0
Boundary check: F(umin)=+p2*0.5 and F(umax)=-p2*1.0 exactly across 36 parameter cases; all inward
Discrete safety: Violation rate 0 at dt=0.001, 0.005, and 0.01; 0.004995 at dt=0.02; 0.08445 at dt=0.05
Equilibrium check: Maximum relative error 7.22e-13 and mean 9.76e-14 across 12 p1/p2 cases
Gradient availability: APIR command-gradient nonzero on 99.9% of the tested state-command grid; it was exactly zero at the hard boundary as expected
Idea: APIR: tracking MSE 0.12863, jerk RMS 42.65, violations 0
Other baseline: Asymmetric sigmoid: tracking MSE 0.06921, jerk RMS 1917.41, violations 0
P1 response: Time to 95% of the p1=2 reference equilibrium was 0.459 s at p1=2, 0.197 s at p1=4, and 0.093 s at p1=8

Limitations: This was a synthetic open-loop command-tracking experiment, not Pendulum-v1 or a trained neural policy. No long-horizon RL return, GPU benchmark, Heun or semi-implicit integrator, multidimensional persistent-state module, or end-to-end policy-gradient training was tested; the gradient comparison was a one-step analytical sensitivity sweep rather than learned-policy optimization.

How to run: python3 apir_experiment.py

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

Ahead of the baseline (−31.0%) but not statistically significant (p=0.1077, wins 7 / 8 paired seeds).

Benchmark: Dynamics forecasting
Model: rnn_small
Paired seeds: 8
Baseline mean: 0.0042
Idea mean: 0.0029
Effect (Δ): -0.0013 (−31.0%; negative = idea better)
Wins: 7 / 8 paired seeds
p-value: 0.1077 (permutation test, 20 000 shuffles)
Smallest detectable effect: ±39.1%
Mechanism: Confirmed ✓
Practical effect: Inconclusive
Baseline tuning: swept over 3 configs

Limitations:

Only the registered built-in dynamics regression track was tested. The implementation used one Euler realization step from a zero state per sample rather than persistent multi-step hidden action state or Heun/semi-implicit integration; no Pendulum-v1 RL return, long-horizon policy-gradient training, multidimensional action state, or larger seed count was tested.

How to run: python3 stage2_apir_bench.py

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

Stage 2 — Benchmark Sep 1, 2026 latest Failed ✗

Agent confidence: 9/10

APIR was implemented as an end-to-end modification of the matched dynamics rnn_small system and evaluated under the full 8-seed paired protocol. It reduced test MSE from 0.0042319348 to 0.0029216045 with 7/8 paired wins, but the permutation p-value was 0.1077, so the required significant-win criterion was not met. The trained-model mechanism signature was confirmed by zero observed violations, while the numerical boundary and equilibrium checks also passed.

Baseline: Best hard-clipped rnn_small, MSE 0.0042319348 ± 0.0012655845, lr=0.01, dt=0.05.
Idea: Best APIR rnn_small, MSE 0.0029216045 ± 0.0014296272, lr=0.01, p1=4.0, p2=0.8, dt=0.05; paired delta=-0.0013103303, 7/8 wins, p=0.1077.

Benchmark result