✗ Failed on benchmark 2026

Horizon-Adaptive Neural Tube Rollouts

Implementation & benchmark of arXiv:2608.27659 — Horizon-Dependent Tube MPC for Elliptical-Orbit Rendezvous Under Mass Uncertainty

Usefulness7/10
Difficulty5/10
Novelty7/10

Source paper: Horizon-Dependent Tube MPC for Elliptical-Orbit Rendezvous Under Mass Uncertainty arXiv:2608.27659 ⓘ · analyzed Sep 1, 2026

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

Idea description

Attach a robust, horizon-dependent uncertainty tube to a recurrent neural state-space model or learned policy. Instead of training only the nominal rollout, propagate state-estimation, model, and disturbance uncertainty through local Jacobians and impose a loss that keeps the tube inside task constraints. The method should be especially useful when short-horizon predictions are accurate but small Jacobian gains cause long-horizon divergence.

Formulas

$$\mathbf{x}_{k+1}=A_k\mathbf{x}_k+B_k\mathbf{u}_k+\mathbf{w}_k,\qquad |\mathbf{w}_k|\leq\bar{\mathbf{w}}.$$
$$r_{k+1}=|J_k|r_k+d_k,\qquad J_k=\left.\frac{\partial f_\theta(z,u)}{\partial z}\right|_{(\hat z_k,u_k)}.$$
$$r_H=\left(\prod_{j=0}^{H-1}|J_j|\right)r_0+\sum_{i=0}^{H-1}\left(\prod_{j=i+1}^{H-1}|J_j|\right)d_i.$$
$$g(\hat z_k)+\|\nabla g(\hat z_k)\|_1r_k\leq0,\qquad \rho(J^{\mathrm{cl}})<1\ \text{predicts bounded asymptotic tubes}.$$

Mathematical statement

The paper uses a time-varying model $\mathbf{x}_{k+1}=A_k\mathbf{x}_k+B_k\mathbf{u}_k+\mathbf{w}_k$, where $\mathbf{x}_k$ is the state, $\mathbf{u}_k$ the control, $A_k$ and $B_k$ vary with phase, and the bounded disturbance satisfies $|\mathbf{w}_k|\leq\bar{\mathbf{w}}$ componentwise. Transfer this construction to a neural transition $z_{k+1}=f_\theta(z_k,u_k)$ with nominal state $\hat z_k$ and radius vector $r_k\geq0$. If $J_k=\partial f_\theta/\partial z$ evaluated at $(\hat z_k,u_k)$ is the local state Jacobian and $d_k$ bounds model, input, and process uncertainty, then an axis-aligned robust tube obeys $r_{k+1}=|J_k|r_k+d_k$. For a feedback policy $u_k=\pi_\phi(z_k)$, use the closed-loop Jacobian $J_k^{\mathrm{cl}}=f_z+f_u\pi_z$. A constraint $g(z)\leq0$ is robustly enforced with $g(\hat z_k)+\|\nabla g(\hat z_k)\|_1r_k\leq0$. In a stationary regime, $\rho(J^{\mathrm{cl}})<1$ predicts bounded asymptotic tubes; $\rho(J^{\mathrm{cl}})>1$ predicts exponential growth.

Implementation notes

1) Integration point: use a GRU, residual RNN, or neural state-space model with transition $z_{k+1}=f_\theta(z_k,u_k)$. During training, maintain the nominal hidden state $\hat z_k$ and an elementwise radius vector $r_k$; for a policy, include the policy derivative in the closed-loop Jacobian. 2) Pseudocode: initialize $\hat z=E(o_0)$ and $r=r_0$; at each step compute $u=\pi_\phi(\hat z)$, update $\hat z\leftarrow f_\theta(\hat z,u)$, obtain $J$ by automatic differentiation, update $r\leftarrow |J|r+d$, and add $\lambda_r\|r\|_1$ plus penalties for violated robust constraints $g(\hat z)+|\nabla g|r>0$ to the ordinary prediction loss. Stop gradients through $r$ initially if memory is limiting. 3) Compute the tube recursion and Jacobians exactly; estimate $d_k$ from held-out transition-residual quantiles, and estimate $r_0$ from repeated encoder evaluations or initial-state uncertainty. Use a high residual quantile such as 99%. 4) First cheap experiment: train a small GRU world model on CartPole or a nonlinear pendulum with injected observation and transition noise, comparing ordinary multi-step training with tube-regularized training at equal parameter count. Sweep rollout horizon and a scalar Jacobian-gain multiplier. The quantitative prediction is a sharp change near the measured spectral-radius boundary $\rho(J^{\mathrm{cl}})=1$: below it, median $r_k$ should plateau; above it, $\log r_k$ should grow with slope approximately $\log\rho(J^{\mathrm{cl}})$. Constraint violations should decrease when robust backoff inequalities hold.

Verification

Failed on benchmark

Stage 1 · Toy mechanism gate: Passed ✓

Stage 2 · Mechanism transferred to benchmark: Not reproduced ✗

Stage 2 · Practical benchmark result: No measurable effect

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 an exact axis-aligned neural tube recursion with autograd Jacobians, robust constraint backoff, and a matched small neural state-space comparison. The toy verification confirmed all three mechanism predictions: the stability boundary was observed at gamma=1.25 (=1/lambda), unstable growth slopes matched log(gamma·lambda) within 0.02%, and steady-state radius scaled linearly with disturbance magnitude to numerical precision. The tube regularizer did not improve this particular neural task: rollout MSE was essentially unchanged and constraints were never violated by either model, so the mechanism is validated but a practical win was not demonstrated.

Agent confidence
9/10
Baseline
one-step MSE 0.00169880; 20-step rollout MSE 0.12039916; violation rate 0.0
Idea
one-step MSE 0.00169907; 20-step rollout MSE 0.12040418; violation rate 0.0; toy boundary gamma 1.25 predicted/observed; unstable slope relative error 0.014% at q=1.04 and approximately 0% at q=1.20; disturbance-scaling relative error 2.5e-16

Limitations: The neural comparison used a tiny synthetic stable plant, fixed uncertainty radii rather than learned held-out 99th-percentile residuals, one-step tube regularization rather than full horizon-adaptive training, and no genuinely active constraints. GPU execution, CartPole, policy closed-loop Jacobians, and larger or harder long-horizon tasks were not tested.

How to run: python3 tube_experiment.py

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

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

Benchmark
Dynamics forecasting
Model
rnn_small
Paired seeds
8
Baseline mean
0.786
Idea mean
0.7857
Effect (Δ)
-0.0003 (−0.0%; negative = idea better)
Wins
5 / 8 paired seeds
p-value
0.58 (permutation test, 20 000 shuffles)
Smallest detectable effect
±0.2%
Mechanism
Not confirmed ✗
Practical effect
No effect
Baseline tuning
swept over 3 configs
Limitations:

The implementation uses a compact Jacobian penalty on the observed input-window map rather than a fully unrolled hidden-state tube with closed-loop policy Jacobians. Active robust constraints, held-out 99th-percentile residual estimation, and longer free-running rollout evaluation were not tested.

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

Built and reran Horizon-Adaptive Neural Tube Rollouts on the registered dynamics/rnn_small track with matched architecture, paired seeds, tuned baseline, and a shared learning-rate sweep. The idea achieved a tiny lower MSE, but the paired permutation test was not significant (p=0.58005), so there is no demonstrated benchmark win. The trained-model mechanism signature was also not quantitatively confirmed.

Baseline
Best lr=0.001; 8-seed mean test MSE=0.7859984934329987.
Idea
Best lr=0.006, lambda=0.03; 8-seed mean test MSE=0.7857095971703529; paired delta=-0.00028889626264572144; p=0.58005.

Benchmark result

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

Benchmark
Dynamics forecasting
Model
rnn_small
Paired seeds
8
Baseline mean
0.786
Idea mean
0.7857
Effect (Δ)
-0.0003 (−0.0%; negative = idea better)
Wins
5 / 8 paired seeds
p-value
0.58 (permutation test, 20 000 shuffles)
Smallest detectable effect
±0.2%
Mechanism
Not confirmed ✗
Practical effect
No effect
Baseline tuning
swept over 3 configs
Limitations:

The implementation uses a compact Jacobian penalty on the observed input-window map rather than a fully unrolled hidden-state tube with closed-loop policy Jacobians. Active robust constraints, held-out 99th-percentile residual estimation, and longer free-running rollout evaluation were not tested.

How to run: python3 bench_tube.py

Artifacts

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