✗ Failed on benchmark 2026

LQ-Compressed LPV Latent Rollouts

Implementation & benchmark of arXiv:2607.28490 — A subspace approach to data-driven predictive control for linear parameter-varying systems

Usefulness7/10

Difficulty6/10

Novelty6/10

Dynamics Stability Scalability Inference speedup World model Rnn Ssm Inference speedup Control theory Dynamical systems Linear algebra Optimization

Source paper: A subspace approach to data-driven predictive control for linear parameter-varying systems arXiv:2607.28490 ⓘ · analyzed Aug 31, 2026

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

Idea description

Replace a neural sequence model's unconstrained multi-step latent rollout with a data-driven LPV predictor acting on a learned latent state. Build the predictor from Hankel matrices of past latent observations, inputs, and scheduling features, then use an LQ factorization to project the large data coefficient matrix into a fixed-dimensional coordinate system. The model preserves scheduling-conditioned dynamics while making rollout cost independent of the number of training trajectories.

Formulas

$$y_{[k,k+T-1]}=\Gamma_xx_k^0+\Gamma_zz_k^P+\mathcal{H}_du_k^F+\mathcal{H}_se_k^F.$$

$$Y_F\approx K D,\qquad D=LQ,\qquad QQ^{\top}=I.$$

$$\widehat{Y}_F=K L\,Qd_k.$$

$$\|Y_F-\widehat{Y}_{F,r}\|_F^2\ \text{is expected to scale with}\ \sum_{i>r}\sigma_i^2(KL).$$

Mathematical statement

For a latent or observed signal with past horizon M and prediction horizon T, let x_k^0 denote the initial latent state reconstructed from past data, z_k^P the lifted past input-output-scheduling vector, u_k^F the future input sequence, and e_k^F future innovation variables. The LPV subspace predictor is y_[k,k+T-1]=Gamma_x x_k^0+Gamma_z z_k^P+H_d u_k^F+H_s e_k^F, where Gamma_x, Gamma_z, H_d, and H_s are multi-step observability, past-data, future-input, and innovation operators. Given a data matrix D formed by stacked Hankel rows, estimate K from Y_F approximately equal to K D, where Y_F is the future latent-output Hankel matrix. Compute an LQ factorization D=LQ with Q having orthonormal rows, retain a numerical rank r, and use K L as the compressed predictor coordinate. The online coordinate dimension is r rather than the number of data columns. The discarded projection error is controlled by the tail singular values of the retained matrix.

Implementation notes

1. Exact integration point: use this as the rollout head of a latent world model or recurrent state-space model. An encoder maps observations to latent vectors; concatenate latent states, controls, and scheduling features into the past data vector. Initially keep the encoder fixed or pretrained, and replace only the multi-step prediction head. 2. Pseudocode: collect trajectories; construct aligned Hankel columns d_j from past latent states, past inputs, future scheduling variables, and candidate future controls; construct Y_F from future latent states; fit K=Y_F D^T(DD^T+lambda I)^(-1); compute an LQ or QR factorization of D; retain rank r using a singular-value threshold; and train or fine-tune the encoder with multi-step loss ||Y_F-K_rD||_F^2 plus decoded observation loss. During inference, form the current past vector, project it using the retained factors, and recursively predict the next T latent states. 3. Computed from the paper: the separation into past, future-input, scheduling, and innovation blocks and the LQ compression. Estimated empirically: latent dimension, ridge coefficient lambda, retained rank r, and whether innovations are set to zero, sampled, or produced by a learned noise head. 4. First cheap experiment: train a small GRU baseline and this compressed LPV latent predictor on Lorenz-63 or cart-pole trajectories with a measured time-varying parameter. Compare 10-, 25-, and 50-step rollout error, wall-clock inference, and parameter count for r in {4,8,16,32}. The prediction is that error decreases until the singular-value elbow, while online cost remains nearly constant as the number of stored trajectories grows; the measured Frobenius error should track the singular-value tail within about 20%.

Verification

Failed on benchmark

Stage 1 · Toy mechanism gate: Passed ✓

Stage 2 · Mechanism transferred to benchmark: Not reproduced ✗

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

Built an LQ-compressed LPV latent-rollout toy predictor with synthetic scheduling-conditioned dynamics. The core mechanism was confirmed: compression error matched the omitted squared singular-value tail to numerical precision, decreased monotonically with rank, and vanished at numerical rank. The compressed operator shape stayed fixed as training columns increased from 200 to 5000; rank 16 matched the full ridge predictor essentially exactly, although this toy did not establish a meaningful wall-clock speedup.

Agent confidence: 8/10

Baseline: Full ridge predictor: 10-step test RMSE 0.0752323; operator size 20x22 = 440 entries.
Idea: Rank 4/8/16/20 gave RMSE 0.0890176/0.0786395/0.0752327/0.0752323 with compressed operator entries 80/160/320/400. Singular-tail error ratios were 1.000000 for ranks 1, 2, 4, 8, 12, and 16; residual was numerical zero at ranks 20 and 22.

Limitations: This is a synthetic observed-state LPV toy, not a learned encoder, GRU, Lorenz-63/cart-pole benchmark, or decoded neural world model. It fits one multi-step horizon of 10 rather than true recursive 10/25/50-step rollouts, does not model innovations, and does not provide a robust repeated timing benchmark or GPU comparison; the singular-tail identity is exact for the constructed orthonormal LQ coordinates.

How to run: python3 lq_lpv_experiment.py

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

No significant difference vs. the tuned baseline (+46.4%, p=0.1255, wins 3 / 8 paired seeds).

Benchmark: Dynamics forecasting
Model: rnn_small
Paired seeds: 8
Baseline mean: 0.0001
Idea mean: 0.0001
Effect (Δ): 0 (+46.4%; negative = idea better)
Wins: 3 / 8 paired seeds
p-value: 0.1255 (permutation test, 20 000 shuffles)
Smallest detectable effect: ±58.5%
Mechanism: Not confirmed ✗
Practical effect: Inconclusive
Baseline tuning: swept over 3 configs

Limitations:

Only the built-in dynamics track was tested; no Lorenz/cart-pole world-model transfer, recursive 10/25/50-step rollout horizon, innovation/noise head, trajectory-count scaling benchmark, or wall-clock inference advantage was measured. The implementation is a rank-constrained latent readout rather than a full Hankel LPV predictor with explicit future-input and scheduling blocks.

How to run: python3 stage2_lq_lpv.py

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

Stage 2 — Benchmark Aug 31, 2026 latest Failed ✗

Agent confidence: 9/10

Built the LQ-compressed LPV-style latent rollout head with the same GRU backbone and evaluated it on the structurally matched actuated-pendulum dynamics track. The best baseline achieved MSE 5.4413e-05 versus 7.9685e-05 for the idea, giving delta_mean +2.5272e-05 and permutation p=0.1255; therefore there was no significant win. The mechanism signature was not confirmed: the scalar readout is rank one, so the singular-tail diagnostic is degenerate and cannot support the claimed quantitative effect.

Baseline: Best lr=0.006, weight_decay=0.0; 8-seed mean MSE 5.4413083717008703e-05, std 2.2964909777119843e-05.
Idea: Rank=8 compressed GRU latent readout, best lr=0.006, weight_decay=0.0; 8-seed mean MSE 7.968471209096606e-05, std 2.0505388407006306e-05; 3/8 paired wins; delta_mean +2.5271628373957356e-05; permutation p=0.1255.

Benchmark result