✗ Failed on benchmark 2026

Restart Before Digital Recurrence

Implementation & benchmark of arXiv:2608.16120 — When More Data Become Less Informative: Finite-Precision Periodicization and Collapse of Forecast-Error Lyapunov Estimates

Usefulness8/10

Difficulty4/10

Novelty7/10

Dynamics Stability Accuracy Sample efficiency Rnn Ssm World model Training dynamics Dynamical systems Numerical analysis Statistics

Source paper: When More Data Become Less Informative: Finite-Precision Periodicization and Collapse of Forecast-Error Lyapunov Estimates arXiv:2608.16120 ⓘ · analyzed Sep 1, 2026

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

Idea description

Train or evaluate a neural dynamical model using many independently restarted finite-precision trajectories instead of one very long rollout. Detect repeated hidden states or quantized state hashes and terminate a segment before its digital transient-plus-period scale, preventing duplicate futures from dominating Lyapunov, loss, and long-horizon forecast estimates.

Formulas

$$z_{t+1}=Q(F_\theta(z_t,u_t)),\qquad z_{t+T}=z_t\ \text{for some }t\geq 0,\ T\geq 1,$$

$$\widehat{\lambda}_{\mathrm{FE}}=\operatorname{slope}_{k\in[1,K]}\left[\log\frac{\|\delta_k\|}{\|\delta_0\|}\right],\qquad \delta_{k+1}=J_F(z_k)\delta_k,$$

$$N_{\mathrm{usable}}\lesssim t_{\mathrm{rec}}+T_{\mathrm{rec}},\qquad \widehat{\lambda}_{\mathrm{restart}}=\frac{1}{R}\sum_{r=1}^{R}\widehat{\lambda}^{(r)}(K),$$

Mathematical statement

Let the finite-precision neural state be $z_t=Q(F_\theta(z_{t-1},u_t))$, where $F_\theta$ is the recurrent or state-space transition, $Q$ is the actual quantizer or floating-point execution map, and $z_t$ belongs to a finite reachable set $\mathcal S$. A deterministic trajectory must eventually satisfy $z_{t+T}=z_t$ for a transient length $t$ and digital period $T$. For a forecast-error estimate with perturbation $\delta_t$, use $\widehat\lambda=(1/K)\sum_{k=1}^{K}\log(\|\delta_k\|/\|\delta_0\|)/k$ or the fitted slope of $\log\|\delta_k\|$ versus $k$. Once the evaluation horizon includes predominantly repeated cycle segments, the estimate measures the finite-state cycle rather than the intended continuous dynamics. The paper's logistic-map control gives the quantitative signature: float32 records reached recurrence before iteration $7612$, and the estimated exponent fell from $0.6853$ at $N=15000$ to $0.1827$ at $N=20000$ and approximately zero at $N=30000$, whereas independent length-100 restarts gave $0.6917$.

Implementation notes

1. Integration point: apply this to the rollout engine used for training losses, validation, or Lyapunov diagnostics in an RNN, neural ODE discretization, SSM, or world model. Execute the model in the deployment precision, including fp16, bf16, fp32, or integer quantization; do not compute recurrence only in fp64. 2. Pseudocode: choose a segment budget $K$ and $R$ independent initial states. For each restart, initialize $z_0$ from the data or simulator, maintain a hash of the quantized hidden state (or a tolerance-binned state), advance $z_{k+1}=Q(F_\theta(z_k,u_k))$, and stop the segment when a hash repeats or when $k=K$. Compute forecast-error slopes only within segments, then average across restarts. During training, replace a single length-$N$ rollout loss by the mean of the $R$ segment losses. 3. Compute the exact recurrence time from hashes when the state is discrete; for floating-point vectors, estimate it with hashed bit patterns or a collision tolerance and report false-positive checks. 4. First cheap experiment: train a small tanh RNN or linear SSM on Lorenz-63 or the logistic map in fp32. Compare one length-100,000 rollout with 1,000 independent length-100 rollouts and an fp64 control. The predicted signature is a sharp degradation in the single-rollout forecast-error Lyapunov estimate after the measured recurrence time, with the restarted estimate remaining stable; on the logistic-map reproduction, recurrence should occur before 7,612 steps and the long-record estimate should approach zero near 30,000 steps, while restarted estimates should remain near $\ln 2\approx0.6931$.

Verification

Failed on benchmark

Stage 1 · Toy mechanism gate: Passed ✓

Stage 2 · Mechanism transferred to benchmark: Not reproduced ✗

Stage 2 · Practical benchmark result: Significantly worse ✗

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 a bit-exact float32 logistic-map recurrence detector and forecast-error Lyapunov estimator. The mechanism manifested clearly: all 25 swept initial states entered finite cycles (median detection step 5187; x0=0.1 at 6088), while a single finite-precision perturbation slope fell from 0.665 at K=10 and 0.641 at K=20 to 0.082 at K=100 and approximately zero by K=1000–3000. Independent short restarts recovered the expected ln(2)=0.693 signal well at K=20 (median 0.685, 88.5% within 0.15), although segments of K>=50 also suffered perturbation saturation; this supports restarting before the empirical forecast-error transition, not merely before exact state recurrence.

Agent confidence: 8/10

Baseline: Single float32 forecast-error record: slope 0.6414 at K=20, 0.0821 at K=100, 0.0004 at K=1000, approximately 0 at K=3000 and beyond; exact x0=0.1 recurrence detected at step 6088.
Idea: Independent restart segments: at K=20, median slope 0.6851 versus theoretical ln(2)=0.6931, with 88.5% of 200 segments within 0.15; exact recurrence sweep detected cycles for 25/25 seeds, median step 5187 and maximum 6951.

Limitations: Only the scalar logistic-map control was tested; no RNN, SSM, neural ODE, training-loss, GPU, fp16/bfloat16, or wall-clock comparison was performed. The forecast-error estimator is sensitive to perturbation saturation, and the restart mean was not uniformly reliable for K>=50, so segment length must be selected empirically.

How to run: python3 forecast_check.py && /home/maxwelhelp/main/bin/python3 restart_recurrence.py

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

Significantly WORSE than the tuned baseline (+105.4%, p=0.0081, wins 0 / 8 paired seeds).

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

Limitations:

The registered dynamics track contains independent 8-step pendulum windows rather than long recurrent rollouts, so it is much shorter than the stage-1 recurrence scale. No long-horizon neural rollout, fp16/bfloat16/integer deployment quantization, or wall-clock comparison was tested.

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

The full registered dynamics/rnn_small bench used 8 paired seeds, a tuned baseline learning-rate sweep, parity idea settings, and a trained-model mechanism signature. Baseline test MSE was 0.00141983 versus 0.00291572 for Restart Before Digital Recurrence; paired delta was +0.00149589 with permutation p=0.0081, so the idea was significantly worse. No hidden-state recurrence occurred within the track's 8-step windows, and the mechanism signature was not confirmed at neural-network scale.

Baseline: Best lr=0.01; 8-seed mean test MSE=0.0014198302378645167
Idea: Selected lr=0.003, K=8; 8-seed mean test MSE=0.0029157200769986957; paired delta=+0.001495889839134179; p=0.0081; 0/8 wins

Benchmark result