# Low-rank one-shot horizon predictor

- ID: 852
- Canonical URL: https://synthcore.org/idea/852/low-rank-one-shot-horizon-predictor
- API JSON: https://synthcore.org/api/idea/852.json
- API Markdown: https://synthcore.org/api/idea/852.md
- Verification status: beats_baseline
- Source: [arXiv:2607.13289](https://arxiv.org/abs/2607.13289)
- Category: architecture
- Solves: speedup, scalability, stability
- ML areas: world-model, inference-speedup, architecture, rl
- Math tags: approximation-theory, tensor-decomposition, linear-algebra
- Ratings: usefulness 8/10; difficulty 5/10; novelty 6/10

## Idea description

Replace an autoregressive rollout of a learned dynamical model with a branch-trunk factorization that predicts all future steps simultaneously. The branch network encodes the future action sequence, while the trunk network encodes the current state and query coordinates; their inner products produce the complete horizon. This removes repeated state updates during inference and gives a compact differentiable model for planning.

## Mathematical statement

The paper uses the finite-rank separable representation \(\widehat{T}_{\max,k+i}=\sum_{j=1}^{p}B_{ij}(\mathbf{u}_{k})T_j(\mathbf{y}_{k})+b_i\). Here \(N_h\) is the prediction horizon, \(\mathbf{u}_k\) is the encoded future input sequence, \(\mathbf{y}_k\) is the encoded current state and query information, \(B(\mathbf{u}_k)\in\mathbb{R}^{N_h\times p}\) is the branch output, \(T(\mathbf{y}_k)\in\mathbb{R}^{p}\) is the trunk output, \(p\) is the latent basis rank, and \(\mathbf b\) is a trainable horizon bias. This is a low-rank separable approximation of a nonlinear map from an input sequence and state/query pair to an output trajectory. The transferable property is that one branch evaluation and one trunk evaluation produce every horizon output instead of recursively evaluating a one-step model \(N_h\) times. For a vector-valued forecast with output dimension \(d\), use \(B(\mathbf u)\in\mathbb R^{N_h\times p\times d}\) and \(\widehat{Y}_{i,:}=\sum_{j=1}^{p}B_{i,j,:}(\mathbf u)T_j(\mathbf y)+b_{i,:}\).

## Key formulas

- $$\widehat{T}_{\max,k+i}=\sum_{j=1}^{p}B_{ij}(\mathbf{u}_{k})\,T_{j}(\mathbf{y}_{k})+b_i,\qquad i=1,\dots,N_h.$$
- $$\widehat{Y}_{i,:}=\sum_{j=1}^{p}B_{i,j,:}(\mathbf u)T_j(\mathbf y)+b_{i,:},\qquad i=1,\dots,N_h.$$
- $$\mathcal L=\frac{1}{BN_hd}\sum_{b=1}^{B}\sum_{i=1}^{N_h}\sum_{r=1}^{d}\left(\widehat Y^{(b)}_{i,r}-Y^{(b)}_{i,r}\right)^2+\lambda\|B(\mathbf u)\|_F^2.$$

## Implementation notes

Integrate this at the world-model or differentiable-planning interface, replacing an autoregressive model call that currently predicts the next state, feeds it back, and repeats for \(N_h\) steps. Construct training examples from contiguous trajectories: the branch input is the full future action sequence \(\mathbf u_t=(a_t,\ldots,a_{t+N_h-1})\) plus optional exogenous inputs; the trunk input is the current state \(\mathbf y_t=s_t\) and normalized query coordinates \(q_i=i/N_h\). Use two MLPs with latent width \(p\). The branch output should have shape \([B,N_h,p,d]\), and the trunk output shape \([B,p]\). Compute predictions with `Yhat = einsum('bjpd,bp->bjd', Bcoef, T) + bias`. Pseudocode is `Bcoef=Branch(u); T=Trunk(concat(s,q)); Yhat=einsum('bjpd,bp->bjd',Bcoef,T)+bias; loss=mse(Yhat,Y)+lambda*mean(Bcoef**2)`. The mathematical component is the finite-rank separable factorization; rank, network widths, and regularization are empirical choices. Train on teacher-generated trajectory windows with normalized state and action channels. The first experiment should use Pendulum or CartPole with horizons 8, 16, and 32, comparing against an equally sized one-step MLP rolled out autoregressively. Measure wall-clock latency, GPU memory, horizon-wise MSE, gradient-based action-planning reward, and error under shifted action distributions. Success means similar or better long-horizon error with lower latency and fewer sequential kernel launches; report loss and planning performance at equal FLOPs.

## Verification

- Status: beats_baseline
- Mechanism evidence: yes
- Mechanism confirmed: yes
- Practical verdict: helps
- Verdict: Built a reproducible low-rank branch/trunk one-shot horizon predictor and compared it with an autoregressive one-step MLP. The finite-rank check matched the omitted-singular-value prediction to numerical precision, reaching approximately zero error at rank 7 for a rank-7 operator. Measured inference latency showed the predicted horizon scaling, while the H=16 one-shot model also achieved lower test MSE and lower latency in the synthetic benchmark.

### Mechanism check

- Verdict: Built a reproducible low-rank branch/trunk one-shot horizon predictor and compared it with an autoregressive one-step MLP. The finite-rank check matched the omitted-singular-value prediction to numerical precision, reaching approximately zero error at rank 7 for a rank-7 operator. Measured inference latency showed the predicted horizon scaling, while the H=16 one-shot model also achieved lower test MSE and lower latency in the synthetic benchmark.
- Confidence: 9/10
- Limitations: The mechanism sweep uses a synthetic finite matrix and exact SVD rather than a trained nonlinear operator. The learned benchmark uses a synthetic scalar dynamical system, one horizon, and non-equal parameter/FLOP budgets; it does not test Pendulum or CartPole, action-gradient planning reward, shifted action distributions, memory, or a real world-model interface.

### Practical benchmark

- Paired seeds: 8
- Baseline mean: 0
- Idea mean: 0
- p-value: 0.0081
- Paired wins: 8/8
- Benchmark verdict: idea better (significant)

## Artifacts

- [bench_report.json](https://synthcore.org/code/156/bench_report.json)
- [bench_run.py](https://synthcore.org/code/156/bench_run.py)
- [custom_horizon_dynamics.py](https://synthcore.org/code/156/custom_horizon_dynamics.py)
- [experiment.py](https://synthcore.org/code/156/experiment.py)
- [patch.py](https://synthcore.org/code/156/patch.py)
- [report.md](https://synthcore.org/code/156/report.md)
- [report_bench_2026-08-30T175229.md](https://synthcore.org/code/156/report_bench_2026-08-30T175229.md)
- [results.json](https://synthcore.org/code/156/results.json)
- [results2.json](https://synthcore.org/code/156/results2.json)
- [Download all files as ZIP](https://synthcore.org/download/156)

## Disclaimer

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