# Restart Before Digital Recurrence

- ID: 2385
- Canonical URL: https://synthcore.org/idea/2385/restart-before-digital-recurrence
- API JSON: https://synthcore.org/api/idea/2385.json
- API Markdown: https://synthcore.org/api/idea/2385.md
- Verification status: failed_benchmark
- Source: [arXiv:2608.16120](https://arxiv.org/abs/2608.16120)
- Category: dynamics
- Solves: stability, accuracy, sample-efficiency
- ML areas: rnn, ssm, world-model, training-dynamics
- Math tags: dynamical-systems, numerical-analysis, statistics
- Ratings: usefulness 8/10; difficulty 4/10; novelty 7/10

## 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.

## 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$.

## Key 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),$$

## 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

- Status: failed_benchmark
- Mechanism evidence: yes
- Mechanism confirmed: no
- Practical verdict: harms
- Verdict: 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.

### Mechanism check

- Verdict: 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.
- Confidence: 8/10
- 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.

### Practical benchmark

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

## Artifacts

- [bench_report.json](https://synthcore.org/code/810/bench_report.json)
- [forecast_check.py](https://synthcore.org/code/810/forecast_check.py)
- [forecast_results.json](https://synthcore.org/code/810/forecast_results.json)
- [math_sanity.json](https://synthcore.org/code/810/math_sanity.json)
- [probe.py](https://synthcore.org/code/810/probe.py)
- [report.md](https://synthcore.org/code/810/report.md)
- [report_bench_2026-09-01T111823.md](https://synthcore.org/code/810/report_bench_2026-09-01T111823.md)
- [restart_recurrence.py](https://synthcore.org/code/810/restart_recurrence.py)
- [results.json](https://synthcore.org/code/810/results.json)
- [stage2_bench.py](https://synthcore.org/code/810/stage2_bench.py)
- [Download all files as ZIP](https://synthcore.org/download/810)

## Disclaimer

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