✓✓ Beats tuned baseline 2026

STL-Robust Mixture-of-Experts Gating

Implementation & benchmark of arXiv:2607.26527 — Online Monitoring and Risk Assessment of Non-Cooperative UAVs via STL-Aware Adaptive Fusion Kalman Filtering

Usefulness8/10

Difficulty5/10

Novelty7/10

Dynamics Stability Accuracy Generalization Moe routing Rnn Ssm World model Training dynamics Dynamical systems Control theory Probability Optimization

Source paper: Online Monitoring and Risk Assessment of Non-Cooperative UAVs via STL-Aware Adaptive Fusion Kalman Filtering arXiv:2607.26527 ⓘ · analyzed Aug 31, 2026

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

Idea description

Replace a standard mixture-of-experts router or recurrent transition-mode classifier with a gate whose logits are adapted by the robustness of temporal safety specifications. Experts represent distinct dynamical regimes, while robustness increases the probability of experts whose predicted trajectories satisfy the specification and suppresses modes producing imminent violations. This should improve mode switches and long-horizon rollout quality precisely near safety-critical transitions.

Formulas

$$\rho_{g(x)\geq 0}(t)=g(x_t),\qquad \rho_{\varphi\wedge\psi}(t)=\min\{\rho_\varphi(t),\rho_\psi(t)\},\qquad \rho_{\mathbf{G}_{[a,b]}\varphi}(t)=\min_{\tau\in[a,b]}\rho_\varphi(t+\tau).$$

$$T_t(i\mid j)=\frac{\exp(a_{ji}+\beta\rho_i^\varphi(t))}{\sum_{\ell=1}^{M}\exp(a_{j\ell}+\beta\rho_\ell^\varphi(t))},\qquad \widetilde{\pi}_{t+1}(i)\propto p(y_{t+1}\mid i)\sum_{j=1}^{M}T_t(i\mid j)\pi_t(j).$$

$$h_{t+1}=\sum_{i=1}^{M}\widetilde{\pi}_{t+1}(i)f_i(h_t,u_t),\qquad \mathcal{L}=\mathcal{L}_{\mathrm{task}}+\lambda\,\operatorname{softplus}(-\rho^\varphi(t:t+H)).$$

Mathematical statement

Let z_t in {1,...,M} be the latent expert, pi_t(i)=P(z_t=i|h_t) its gate probability, x-hat_{t:t+H}^{(i)} expert i's predicted trajectory, and rho_i^varphi(t) the STL quantitative robustness of formula varphi evaluated on that trajectory. Use a robustness-dependent transition matrix T_t(i|j) and Bayesian-style gate update pi-tilde_{t+1}(i) proportional to p(y_{t+1}|i) times the sum over j of T_t(i|j) pi_t(j). A concrete differentiable adaptation is T_t(i|j)=softmax_i(a_{ji}+beta rho_i^varphi(t)), where a_{ji} are learned transition logits and beta is nonnegative. For STL, atomic predicates have robustness rho_{g(x)>=0}=g(x), conjunction uses min, and the globally operator uses a temporal minimum; replace min and max with smooth log-sum-exp during training. The key mechanism is a measurable increase in gate probability for high-robustness modes and a transition boundary controlled by beta.

Implementation notes

First integrate the mechanism into a small GRU or state-space model with M parallel transition experts f_i and a router producing transition logits a_{ji}. At every training step, roll out each expert for horizon H, evaluate one or more STL predicates such as position-safe, velocity-bounded, or collision-free, and modify the transition matrix with the robustness term above. Use the resulting posterior mixture for the next hidden state and output. Pseudocode is: compute all expert rollouts; compute smoothed STL robustness with softmin_tau(x)=-tau log sum_r exp(-x_r); set T=softmax(A+beta rho); update pi-prime=normalize(likelihood times T-transpose times pi); blend expert states using pi-prime; backpropagate task loss plus robustness violation loss. The STL recursion and probability update are computed directly; observation likelihoods can initially be Gaussian residual likelihoods, while beta and the smoothing temperature tau are tuned. The first cheap experiment should use a four-expert GRU on synthetic 2-D trajectories switching among constant-velocity, acceleration, and turning modes with randomly missing observations. Compare ordinary softmax gating against STL gating on one-step and 50-step rollout error. The prediction is that near rho approximately zero, safety-aware gating switches earlier, and odds obey log(T_i/T_j)=Delta a+beta(rho_i-rho_j). A transition should occur when beta times the robustness difference exceeds the ordinary logit gap; excessive beta should cause premature switching and worsen prediction error.

Verification

Beats tuned baseline

Stage 1 · Toy mechanism gate: Passed ✓

Stage 2 · Mechanism transferred to benchmark: Not reproduced ✗

Stage 2 · Practical benchmark result: Significant win ✓

Methodology: 8 paired seeds, permutation test (p<0.05) against a learning-rate-tuned baseline. How verification works

How to read this: The implementation beat the baseline, but the claimed mechanism did not reproduce at benchmark scale. The gain may come from another effect; treat the cause as unresolved.

Stage 1 — Mechanism check agent confidence 9/10

Built a NumPy MVP of STL-robust MoE gating with smooth STL robustness, robustness-adapted transitions, Bayesian posterior updates, and synthetic dynamical experts. The mechanism checks passed: observed log-odds slope 1.3000 versus predicted 1.3000, switching boundary beta=1.500 versus predicted 1.500, and beta=0 robustness sensitivity was exactly zero across the sweep. However, at beta=2.8 the STL router worsened one-step MSE (0.02525 vs 0.02513) and 50-step rollout MSE (3.531 vs 3.115), so there is no demonstrated accuracy win; worked=true reflects that the requested mechanism manifested, not that task performance improved.

Agent confidence: 9/10

Baseline: One-step MSE 0.02513; 50-step rollout MSE 3.115; mode-2 selection rate 0.4313.
Idea: At beta=2.8: one-step MSE 0.02525; 50-step rollout MSE 3.531; mode-2 selection rate 0.2063. Math: log-odds slope 1.3000/1.3000 predicted, boundary 1.500/1.500 predicted, beta=0 max transition difference 0.0.

Limitations: This is a fixed-expert NumPy prototype rather than a trained GRU/state-space model; it uses one synthetic safety formula, one true regime, and a modest 160-episode experiment. The beta performance sweep uses independently sampled episodes rather than a shared paired dataset, and no CUDA, learning, missing-observation training, multi-formula STL, or statistical significance analysis was tested.

How to run: python3 stl_robust_moe.py

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

Beats the tuned baseline by 63.3% (p=0.0081, wins 8 / 8 paired seeds; metric: lower is better).

Benchmark: Dynamics forecasting
Model: rnn_small
Paired seeds: 8
Baseline mean: 0.0008
Idea mean: 0.0003
Effect (Δ): -0.0005 (−63.3%; negative = idea better)
Wins: 8 / 8 paired seeds
p-value: 0.0081 (permutation test, 20 000 shuffles)
Smallest detectable effect: ±28.8%
Mechanism: Not confirmed ✗
Practical effect: Helps
Baseline tuning: swept over 3 configs

Limitations:

The benchmark mechanism signature was measured using a separately retrained CPU probe rather than persisted weights from the scored runs. The idea grid duplicated lr=0.006 instead of including the nearby lr=0.003 setting, although all idea learning rates were present in the baseline sweep. No long-horizon rollout metric beyond the built-in dynamics test MSE was evaluated, and the safety robustness proxy was a scalar one-step differentiable predicate rather than a full multi-step STL formula.

How to run: python3 stl_bench.py

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

Stage 2 — Benchmark Sep 2, 2026 latest Worked ✓

Agent confidence: 7/10

Implemented STL-robust MoE gating on the structurally matched dynamics track with paired end-to-end neural training and an equal-budget baseline learning-rate sweep. The idea achieved significantly lower test MSE across all 8 seeds (0.0003050 vs 0.0008321, delta -0.0005271, permutation p=0.0081). However, the trained-model mechanism signature did not confirm the expected positive robustness-to-gate sensitivity (observed slope -0.1122), so the accuracy win is real in this benchmark but the proposed mechanism was not quantitatively validated.

Baseline: Test MSE mean 0.0008321261 ± 0.0002982995 over 8 seeds; best lr=0.006, epochs=20.
Idea: Test MSE mean 0.0003050095 ± 0.0001339860 over 8 seeds; beta=1.5, lr=0.006, epochs=20; all 8 paired seeds improved.
Paired delta: -0.0005271166; idea wins 8/8; permutation p=0.0081; verdict idea better (significant).

Benchmark result