Polynomial Orbit-Pattern Regularization
Implementation & benchmark of arXiv:2608.06103 — Maximal pattern complexity and structure of null systems
Source paper: Maximal pattern complexity and structure of null systems arXiv:2608.06103 ⓘ · analyzed Aug 31, 2026
AI-generated research hypothesis, automatically tested. Not peer-reviewed.
Idea description
Add a trajectory-complexity monitor and regularizer to an RNN, SSM, or world model that limits the number of distinct hidden-state symbol patterns produced over selected time subsets. The paper's nullness criterion suggests targeting polynomial maximal pattern growth rather than merely minimizing one-step Jacobian norms, thereby suppressing combinatorial explosion of long-horizon behaviors while retaining nontrivial dynamics.
Formulas
Mathematical statement
Let $(X,T)$ be a compact dynamical system, let $\mathcal{U}=\{U_1,\ldots,U_K\}$ be a finite open cover, and let $F\subset\mathbb{Z}_+$ be a finite set of observation times. The join cover $\bigvee_{j\in F}T^{-j}\mathcal{U}$ distinguishes trajectories by their cover labels at all times in $F$. Its covering number is $N(\mathcal{U})=\min\{|\mathcal{V}|:\mathcal{V}\subseteq\mathcal{U},\ X\subseteq\bigcup_{V\in\mathcal{V}}V\}$, and the maximal pattern complexity is $p_{X,\mathcal{U}}(F)=N(\bigvee_{j\in F}T^{-j}\mathcal{U})$. The paper's mechanism is that nullness is equivalent to polynomial maximal pattern complexity: for every finite cover $\mathcal{U}$, there exist constants $C_{\mathcal{U}}>0$ and $d_{\mathcal{U}}\ge0$ such that $p_{X,\mathcal{U}}(F)\le C_{\mathcal{U}}(|F|+1)^{d_{\mathcal{U}}}$, while equicontinuity corresponds to sublinear growth. For neural trajectories $h_t\in\mathbb{R}^m$, choose quantization cells $U_1,\ldots,U_K$ and estimate the number $\widehat p(F)$ of distinct quantized label strings over initial states or inputs. Penalize excess log-complexity $[\log\widehat p(F)-\log C-d\log(|F|+1)]_+$.
Implementation notes
Integrate this at the hidden-state trajectory of an RNN, latent ODE discretization, or state-space model. Run the model for horizons up to $H$ from a batch of $B$ inputs or perturbed initial states, normalize each hidden coordinate using running quantiles, and map each normalized vector $h_t$ to a discrete cell index $q(h_t)\in\{1,\ldots,K\}$ using a fixed grid, random-hyperplane hash, or k-means centroids. For each subset size $r$, sample several time sets $F\subset\{0,\ldots,H-1\}$ with $|F|=r$, form the label string $(q(h_j^{(b)}))_{j\in F}$ for every trajectory, and count distinct strings after merging strings within a small Hamming tolerance. Use the hinge penalty in the formula, or use it only as a controller that reduces the recurrent gain, increases teacher forcing, or clips the recurrent update when the penalty is positive. The exact paper-derived quantities are the join-cover interpretation and the polynomial-versus-sublinear growth criterion; $C$, $d$, quantization scale, and finite-sample corrections must be estimated. The first cheap experiment is a vanilla GRU and gated state-space model on sequential MNIST or Copy Memory, compared with identical models without the penalty. Use $K=8$ random-hyperplane cells, $H=128$, $B=512$, and $r\in\{1,2,4,8,16,32\}$. Plot $\log\widehat p$ versus $\log(r+1)$ and fit the slope. The predicted signature is an approximately linear log-log curve for the regularized model, with slope $\widehat d$ stable as $H$ increases; an unstable unregularized model should show upward curvature and an effective slope increasing with $r$. Sweep recurrent gain or initialization scale and locate the point where fitted slope begins increasing with horizon. The regularizer should shift this transition to larger gains without materially increasing task loss.
Verification
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 7/10
Built a random-hyperplane orbit-pattern monitor and hinge-based recurrent-gain controller, with a reproducible circle-map sweep and TinyGRU comparison. The mechanism appeared clearly: the predicted neutral boundary at gain 1.0 was observed (constant count 4 at exactly 1.0), pattern growth became much larger as gain increased (full-horizon count 1163 at gain 1.6), and the controller reduced that count to 85 while reducing the mean gain to 0.649. However, the task result was not a win: baseline accuracy/loss were 0.973/0.064 versus 0.553/0.700 for the intervention, so this is evidence for complexity suppression, not task-preserving regularization.
- Agent confidence
- 7/10
- Baseline
- Circle map gain=1.6: 1163 distinct full-horizon patterns; TinyGRU task accuracy=0.9733, test loss=0.0637
- Idea
- Circle map gain=1.6 with controller: 85 distinct patterns, 92.7% reduction, mean gain factor=0.6487; TinyGRU task accuracy=0.5533, test loss=0.6999; hinge values for gains 0.8/1.2/1.8 were 0.245/1.080/2.918
Limitations: The toy uses a two-dimensional circle embedding, fixed random hyperplanes, finite sampled initial states, and short horizons; it does not establish the paper's compact-system theorem or generalization claims. The controller is a detached, non-differentiable intervention rather than a differentiable cardinality regularizer, and only one TinyGRU task, one seed, and one controller setting were tested.
How to run: python3 run_experiment.py
Stage 2 — Benchmark vs. tuned baseline (arXiv:2608.06103)
Ahead of the baseline (−2.3%) but not statistically significant (p=0.4325, wins 5 / 8 paired seeds).
- Benchmark
- Dynamics forecasting
- Model
- rnn_small
- Paired seeds
- 8
- Baseline mean
- 0
- Idea mean
- 0
- Effect (Δ)
- -0 (−2.3%; negative = idea better)
- Wins
- 5 / 8 paired seeds
- p-value
- 0.4325 (permutation test, 20 000 shuffles)
- Smallest detectable effect
- ±6.7%
- Mechanism
- Not confirmed ✗
- Practical effect
- Inconclusive
- Baseline tuning
- swept over 9 configs
The implementation uses a soft pairwise collision proxy rather than a differentiable exact cardinality estimator, and the post-training signature was collected only for the selected idea run rather than both systems, so it cannot confirm the predicted relative complexity reduction. The baseline sweep redundantly included lambda=0 configurations because the shared grid was used for parity; only 12 epochs and the built-in 8-step pendulum task were tested. The reported baseline full evaluation and idea evaluations used the required paired seeds, but the idea's nearby configurations were not all independently compared against full baseline re-evaluations.
How to run: python3 bench_orbit.py
Verdict computed by deterministic test code from paired-seed statistics — not by the language model.
Stage 2 — Benchmark latest Failed ✗
Agent confidence: 9/10
Built Polynomial Orbit-Pattern Regularization as a training-time soft random-hyperplane trajectory penalty on the matched dynamics/rnn_small benchmark. Across 8 paired seeds, the best idea configuration reduced test MSE by 2.42e-7 (2.32%) but permutation p=0.43245, so there was no significant task win. The trained-model mechanism signature showed increasing log-log pattern growth with mean slope 3.885, but no valid baseline-vs-idea complexity reduction was established and confirmed=false.
- Baseline
- dynamics/rnn_small, lr=0.01, 8-seed test MSE mean 1.0416466807e-05, std 3.3318682e-06
- Idea
- soft orbit penalty, lr=0.01, lambda=0.01, 8-seed test MSE mean 1.0174615170e-05, std 3.1955246e-06
- Mechanism signature
- idea trained-model exact pattern counts by subset size averaged over seeds were not summarized against a separately measured baseline; idea slopes ranged 2.726-4.788 with mean 3.885; confirmed=false
- Paired delta
- -2.4185163738e-07 (idea lower/better), 5/8 wins, permutation p=0.43245
Benchmark result
Ahead of the baseline (−2.3%) but not statistically significant (p=0.4325, wins 5 / 8 paired seeds).
- Benchmark
- Dynamics forecasting
- Model
- rnn_small
- Paired seeds
- 8
- Baseline mean
- 0
- Idea mean
- 0
- Effect (Δ)
- -0 (−2.3%; negative = idea better)
- Wins
- 5 / 8 paired seeds
- p-value
- 0.4325 (permutation test, 20 000 shuffles)
- Smallest detectable effect
- ±6.7%
- Mechanism
- Not confirmed ✗
- Practical effect
- Inconclusive
- Baseline tuning
- swept over 9 configs
The implementation uses a soft pairwise collision proxy rather than a differentiable exact cardinality estimator, and the post-training signature was collected only for the selected idea run rather than both systems, so it cannot confirm the predicted relative complexity reduction. The baseline sweep redundantly included lambda=0 configurations because the shared grid was used for parity; only 12 epochs and the built-in 8-step pendulum task were tested. The reported baseline full evaluation and idea evaluations used the required paired seeds, but the idea's nearby configurations were not all independently compared against full baseline re-evaluations.
How to run: python3 bench_orbit.py
Artifacts
- bench_orbit.py 4.4 KB View Raw
- bench_report.json 5.8 KB View Raw
- orbit_regularization.py 3.0 KB View Raw
- report.md 1.7 KB View
- report_bench_2026-09-01T012018.md 5.3 KB View
- results.json 3.9 KB View Raw
- run_experiment.py 5.3 KB View Raw