Research log

Predicates resolved by code, and the model's own readings and reading list.

The rk run ended on 2026-11-10, and no more compute goes to it. Epoch 2 is frozen and these pages are its final snapshot: the site is no longer rebuilt. The overview site sums up the final findings, and the harness is public for anyone to download and run.

The hypothesis ledger: predicates the planning model committed to before the data could answer them, each resolved by code. Open a row for the statement, the proposed mechanism and the control that would have shown the mechanism wrong. Below the ledger are the model's readings of the archive and its literature digests.

How to read this

Each row pairs a machine-checkable predicate over per-cell statistics, for example slow.p3s4.heldout < slow.p4s4.heldout, with the mechanism and control the model recorded before the data could answer. p and s name an (order, stages) cell, the leading word picks the cost model, and heldout in a predicate is that cell elite's error on the held-out set, which selects elites and so is not a clean test set.

Verdicts come from code, never from the model. Once every cell a predicate names holds min_samples records, the predicate is evaluated against those cells' running statistics. d is Cohen's d; below 0.2 the verdict is inconclusive whichever way the comparison went, so a weak effect cannot be claimed. A predicate that names an empty cell is inconclusive too, because absence of evidence never refutes. n is the smallest record count among the named cells, and c is the cycle the verdict landed on (c123+ means proposed at cycle 123 and still open).

×N means the model posed that predicate N times over the run. The row shows the newest verdict and lists the id of every posing; mixed beside the verdict means those posings did not all get the same one.

Distinct predicates in each verdict group, with the count at the end of each bar. 380 hypotheses over 368 distinct predicates; 4 were posed more than once.
050100150supportedsupported: 110 distinct predicates110refutedrefuted: 81 distinct predicates81inconclusiveinconclusive: 90 distinct predicates90openopen: 87 distinct predicates87

Source: rk-work/hypotheses.jsonl; exact counts.

Every plotted bar, in one table (4 rows)
verdict groupdistinct predicates
supported110
refuted81
inconclusive90
open87

Every predicate, by verdict

supported (110 predicates) the predicate held once every cell it names had enough records
idverdictpredicatedncycle
H-378supportedfast.p2s6.heldout < 0.015 AND fast.p4s5.heldout > 0.03 AND slow.p2s6.heldout < slow.p4s5.heldout1e+09669c2553
statement
Under the fast cost model, the order-2 six-stage archive cell does better than the order-4 five-stage cell on held-out error, with errors below 0.015 and above 0.03, respectively.
mechanism
The extra stages let the order-2 method reduce error without the coefficient constraints of the order-4 method.
control
Under the slow cost model, the order-2 six-stage cell should retain the lower held-out error.
min_samples
100
H-375supportedfast.p2s5.heldout < fast.p3s4.heldout AND slow.p3s4.heldout <= slow.p2s5.heldout0.344463625c2548
statement
Under the fast cost model, the order-2 five-stage archive cell has lower held-out error than the order-3 four-stage cell.
mechanism
The fast model gives the five-stage cell enough budget to tune its coefficients for fixed-point accuracy.
control
Under the slow cost model, the order-3 four-stage cell should have no higher held-out error.
min_samples
100
H-370supportedfast.p2s4.heldout < 0.02 AND fast.p3s3.heldout > 0.035 AND slow.p2s4.heldout < slow.p3s3.heldout1e+091671c2539
statement
Under the fast cost model, the order-2 four-stage archive cell does better than the order-3 three-stage cell on held-out error, falling below 0.02 while the latter exceeds 0.035.
mechanism
The order-2 tableau has more coefficient freedom, allowing its extra stage to reduce error after fixed-point quantization.
control
If tableau flexibility drives the advantage, the order-2 four-stage cell should also have lower held-out error under the slow cost model.
min_samples
100
H-369supportedfast.p2s4.heldout < fast.p3s3.heldout AND fast.p2s4.search < fast.p3s3.search AND slow.p2s4.heldout < slow.p3s3.heldout AND slow.p2s4.search < slow.p3s3.search0.4613941671c2538
statement
Under the fast cost model, the order-2 four-stage archive cell does better than the order-3 three-stage cell on both held-out and search error.
mechanism
The four-stage tableau has enough coefficient freedom to reduce fixed-point error despite its lower formal order.
control
If that accuracy advantage comes from the tableau, both error rankings should persist under the slow cost model.
min_samples
64
H-367supportedfast.p2s5.heldout < fast.p4s5.heldout AND fast.p2s5.search < fast.p4s5.search AND fast.p2s5.cycles < fast.p4s5.cycles AND slow.p2s5.heldout < slow.p4s5.heldout AND slow.p2s5.search < slow.p4s5.search0.21457667c2535
statement
Under the fast cost model, the order-2 five-stage archive cell does better than the order-4 five-stage cell on held-out error, search error, and cycles.
mechanism
Its coefficient freedom can reduce fixed-point error while its lower-order conditions require less work.
control
Under the slow cost model, both error advantages should remain if they come from the tableau rather than the fast cycle accounting.
min_samples
100
H-365supportedfast.p4s6.heldout < fast.p4s5.heldout AND fast.p4s6.search < fast.p4s5.search AND fast.p4s6.cycles > fast.p4s5.cycles AND slow.p4s6.heldout < slow.p4s5.heldout AND slow.p4s6.search < slow.p4s5.search AND slow.p4s6.cycles > slow.p4s5.cycles0.606029320c2530
statement
Under the fast cost model, the order-4 six-stage archive cell does better than the order-4 five-stage cell on both held-out and search error despite using more cycles.
mechanism
The extra stage gives the tableau more freedom to reduce quantized error while adding computation.
control
Under the slow cost model, the six-stage cell should retain both error advantages and still use more cycles.
min_samples
40
H-364supportedfast.p2s5.heldout < 0.015 AND fast.p4s6.heldout > 0.025 AND slow.p2s5.heldout < slow.p4s6.heldout1e+09320c2529
statement
Under the fast cost model, the order-2 five-stage archive cell has held-out error below 0.015 while the order-4 six-stage cell exceeds 0.025.
mechanism
The five-stage order-2 tableau has more freedom to limit error after fixed-point rounding.
control
Under the slow cost model, the order-2 five-stage cell should still have lower held-out error than the order-4 six-stage cell.
min_samples
40
H-363supportedfast.p2s5.heldout < 0.015 AND fast.p4s5.heldout > 0.03 AND slow.p2s5.heldout < slow.p4s5.heldout1e+09667c2527
statement
Under the fast cost model, the order-2 five-stage archive cell does better than the order-4 five-stage cell on held-out error, falling below 0.015 while the order-4 cell remains above 0.03.
mechanism
Freedom in the order-2 coefficients lets the search reduce error after fixed-point rounding despite the lower formal order.
control
Under the slow cost model, the order-2 five-stage cell should also have lower held-out error than the order-4 five-stage cell.
min_samples
40
H-360supportedfast.p3s3.heldout < fast.p2s2.heldout AND fast.p2s2.cycles < fast.p3s3.cycles AND slow.p3s3.heldout < slow.p2s2.heldout AND slow.p2s2.cycles < slow.p3s3.cycles1.56441527c2523
statement
Under the fast cost model, the order-3 three-stage cell does better than the order-2 two-stage cell on held-out error, while the two-stage cell uses fewer cycles.
mechanism
The extra stage gives the order-3 method more room to reduce error but adds computation.
control
Under the slow cost model, the same error and cycle rankings should hold.
min_samples
30
H-359supportedavr_approx.p3s5.heldout < avr_approx.p2s2.heldout AND avr_approx.p3s5.search < avr_approx.p2s2.search AND avr_approx.p3s5.cycles > avr_approx.p2s2.cycles AND fast.p3s5.heldout < fast.p2s2.heldout AND fast.p3s5.search < fast.p2s2.search AND fast.p3s5.cycles > fast.p2s2.cycles0.263335527c2521
statement
Under the AVR approximation cost model, the order-3 five-stage archive cell does better than the order-2 two-stage cell on held-out and search error while using more cycles.
mechanism
The extra stages improve accuracy but require more computation per step.
control
Under the fast cost model, the same accuracy and cycle rankings should hold.
min_samples
40
H-357supportedavr_approx.p3s3.cycles < avr_approx.p4s6.cycles AND fast.p3s3.cycles < fast.p4s6.cycles9.5829318c2518
statement
Under the AVR approximation cost model, the order-3 three-stage archive cell uses fewer cycles than the order-4 six-stage cell.
mechanism
Three stages require fewer stage evaluations than six, reducing per-step work.
control
Under the fast cost model, the order-3 three-stage cell should also use fewer cycles.
min_samples
20
H-355supportedavr_approx.p2s5.heldout < avr_approx.p4s5.heldout AND avr_approx.p2s5.search < avr_approx.p4s5.search AND avr_approx.p2s5.cycles < avr_approx.p4s5.cycles AND slow.p2s5.heldout < slow.p4s5.heldout AND slow.p2s5.search < slow.p4s5.search0.405024662c2484
statement
Under the AVR approximation cost model, the order-2 five-stage archive cell does better than the order-4 five-stage cell on held-out error, search error, and cycles.
mechanism
The order-2 tableau can use coefficients that accumulate less Q15 rounding error while requiring fewer arithmetic operations.
control
Under the slow cost model, the order-2 five-stage cell should retain its held-out and search error advantages.
min_samples
50
H-353supportedfast.p4s6.heldout < fast.p2s2.heldout AND fast.p4s6.search < fast.p2s2.search AND fast.p4s6.cycles > fast.p2s2.cycles AND slow.p4s6.heldout < slow.p2s2.heldout AND slow.p4s6.search < slow.p2s2.search AND slow.p4s6.cycles > slow.p2s2.cycles1.06184318c2479
statement
Under the fast cost model, the order-4 six-stage archive cell does better than the order-2 two-stage cell on held-out and search error while using more cycles.
mechanism
The additional stages reduce integration error despite fixed-point rounding, at the cost of more evaluations.
control
Under the slow cost model, the same error and cycle rankings should hold if stage count drives the tradeoff.
min_samples
40
H-352supportedavr_approx.p4s6.heldout < avr_approx.p4s5.heldout AND slow.p4s6.heldout < slow.p4s5.heldout0.933819318c2478
statement
Under the AVR approximation cost model, the order-4 six-stage archive cell has lower held-out error than the order-4 five-stage cell.
mechanism
The extra stage reduces integration error enough to outweigh its additional fixed-point rounding.
control
If the stage benefit is real, the six-stage cell should also have lower held-out error under the slow cost model.
min_samples
30
H-343supportedslow.p3s6.heldout < slow.p4s5.heldout AND slow.p3s6.search < slow.p4s5.search AND slow.p3s6.cycles > slow.p4s5.cycles AND fast.p3s6.heldout < fast.p4s5.heldout AND fast.p3s6.search < fast.p4s5.search AND fast.p3s6.cycles > fast.p4s5.cycles0.308399623c2463
statement
Under the slow cost model, the order-3 six-stage archive cell does better than the order-4 five-stage cell on held-out and search error while using more cycles.
mechanism
The additional stage improves accuracy enough to offset the lower formal order, at a cycle cost.
control
Under the fast cost model, the same error and cycle rankings should hold if stage depth drives the result.
min_samples
100
H-339supportedavr_approx.p3s4.search < avr_approx.p2s6.search AND fast.p3s4.search < fast.p2s6.search0.2050033452c2457
statement
Under the AVR approximation cost model, the order-3 four-stage archive cell has lower search error than the order-2 six-stage cell.
mechanism
Its higher-order method may reduce search error despite using fewer stages.
control
The order-3 four-stage cell should also have lower search error under the fast cost model.
min_samples
100
H-327supportedavr_approx.p2s3.heldout < avr_approx.p2s4.heldout AND fast.p2s4.heldout < fast.p2s3.heldout0.2319721503c2436
statement
Under the AVR approximation cost model, the order-2 three-stage archive cell has lower held-out error than the order-2 four-stage cell.
mechanism
The AVR cost weighting may favor a three-stage tableau whose fixed-point rounding error is smaller than the four-stage tableau’s.
control
Under the fast cost model, the four-stage cell should have lower held-out error.
min_samples
20
H-324supportedavr_approx.p2s6.heldout < avr_approx.p4s5.heldout AND avr_approx.p2s6.search < avr_approx.p4s5.search AND fast.p2s6.heldout < fast.p4s5.heldout AND fast.p2s6.search < fast.p4s5.search0.66797598c2431
statement
Under the AVR approximation cost model, the order-2 six-stage archive cell has lower held-out and search error than the order-4 five-stage cell.
mechanism
Its extra stages may reduce fixed-point rounding error enough to outweigh its lower formal order.
control
The fast cost model should preserve both error rankings if the advantage comes from the tableau rather than the cost model.
min_samples
100
H-320supportedfast.p2s4.heldout < 0.02 AND fast.p4s5.heldout > 0.03 AND slow.p2s4.heldout < slow.p4s5.heldout0.59413598c2425
statement
Under the fast cost model, the order-2 four-stage archive cell does better than the order-4 five-stage cell on held-out error, falling below 0.02 while the latter exceeds 0.03.
mechanism
The simpler order-2 coefficients may accumulate less fixed-point rounding error.
control
If rounding drives the difference, the order-2 cell should retain its held-out advantage under the slow cost model.
min_samples
100
H-316supportedavr_approx.p2s6.heldout < avr_approx.p4s5.heldout AND fast.p2s6.heldout < fast.p4s5.heldout0.868609598c2418
statement
Under the AVR approximation cost model, the order-2 six-stage archive cell has lower held-out error than the order-4 five-stage cell.
mechanism
Six stages give the second-order method more room to reduce error while keeping its coefficients simple to represent in fixed point.
control
Under the fast cost model, the order-2 six-stage cell should retain its held-out error advantage if the extra stages drive the result.
min_samples
100

90 older predicates are not shown here. The whole log is in rk-work/hypotheses.jsonl.

refuted (81 predicates) the predicate failed on the data it names
idverdictpredicatedncycle
H-376refutedfast.p2s5.heldout < 0.015 AND fast.p3s5.heldout > 0.020 AND slow.p2s5.heldout < slow.p3s5.heldout1e+093625c2550
statement
Under the fast cost model, the order-2 five-stage archive cell does better than the order-3 five-stage cell on held-out error, with errors below 0.015 and above 0.020 respectively.
mechanism
The order-2 tableau has more coefficient freedom to reduce error after fixed-point quantization at the same stage count.
control
If coefficient freedom drives the difference, the order-2 five-stage cell should also have lower held-out error under the slow cost model.
min_samples
200
H-362refutedfast.p3s4.search < 0.006 AND fast.p4s5.search > 0.01 AND slow.p3s4.search < slow.p4s5.search1e+09667c2526
statement
Under the fast cost model, the order-3 four-stage archive cell does better than the order-4 five-stage cell on search error, falling below 0.006 while the latter remains above 0.01.
mechanism
The order-3 tableau has enough coefficient freedom to fit the search cases more closely despite using fewer stages.
control
Under the slow cost model, the order-3 four-stage cell should also have lower search error than the order-4 five-stage cell.
min_samples
20
H-361refutedavr_approx.p3s4.search < avr_approx.p2s4.search AND fast.p2s4.search < fast.p3s4.search0.2923841671c2524
statement
Under the AVR approximation cost model, the order-3 four-stage archive cell has lower search error than the order-2 four-stage cell.
mechanism
The AVR cost weighting may favor an order-3 tableau whose coefficients incur less fixed-point error.
control
Under the fast cost model, the order-2 four-stage cell should have lower search error.
min_samples
100
H-358refutedavr_approx.p4s5.search < avr_approx.p3s4.search AND fast.p3s4.search < fast.p4s5.search0.971789667c2520
statement
Under the AVR approximation cost model, the order-4 five-stage archive cell has lower search error than the order-3 four-stage cell.
mechanism
The AVR cost model may favor coefficients that let the higher-order method use its extra stage more effectively.
control
Under the fast cost model, the order-3 four-stage cell should have lower search error.
min_samples
64
H-350refutedavr_approx.p2s5.heldout < avr_approx.p3s6.heldout AND avr_approx.p3s6.search < avr_approx.p2s5.search AND fast.p2s5.search < fast.p3s6.search0.269353178c2475
statement
Under the AVR approximation cost model, the order-2 five-stage archive cell has lower held-out error than the order-3 six-stage cell, despite the latter having lower search error.
mechanism
Quantization may let the order-3 cell fit the search cases more closely while its coefficients generalize less well.
control
Under the fast cost model, the order-2 cell should have lower search error if the AVR-specific ranking comes from quantization.
min_samples
200
H-349refutedslow.p2s4.heldout < slow.p3s4.heldout AND slow.p2s4.search > slow.p3s4.search AND fast.p2s4.search < fast.p3s4.search0.2877091670c2473
statement
Under the slow cost model, the order-2 four-stage archive cell has lower held-out error than the order-3 four-stage cell despite higher search error.
mechanism
The slow cost model may favor an order-3 tableau that fits the search cases while accumulated fixed-point rounding worsens its held-out error.
control
Under the fast cost model, the order-2 four-stage cell should also have lower search error if that search advantage depends on slow-cost selection.
min_samples
20
H-347refutedfast.p2s6.heldout < fast.p3s4.heldout AND fast.p2s6.search > fast.p3s4.search AND slow.p2s6.heldout < slow.p3s4.heldout0.2131693499c2470
statement
Under the fast cost model, the order-2 six-stage archive cell has lower held-out error than the order-3 four-stage cell despite higher search error.
mechanism
The extra stages may reduce accumulated fixed-point error on held-out trajectories even when search error is higher.
control
Under the slow cost model, the order-2 six-stage cell should retain its held-out advantage if the benefit comes from the stage structure.
min_samples
100
H-346refutedavr_approx.p4s6.search < avr_approx.p2s6.search AND fast.p4s6.search < fast.p2s6.search0.590701316c2469
statement
Under the AVR approximation cost model, the order-4 six-stage archive cell has lower search error than the order-2 six-stage cell.
mechanism
The higher-order tableau reduces truncation error on the search trajectories despite fixed-point rounding.
control
If that numerical advantage is real, the order-4 six-stage cell should also have lower search error under the fast cost model.
min_samples
80
H-345refutedavr_approx.p2s6.cycles < avr_approx.p3s3.cycles AND fast.p3s3.cycles < fast.p2s6.cycles2.810963452c2466
statement
Under the AVR approximation cost model, the order-2 six-stage archive cell uses fewer cycles than the order-3 three-stage cell.
mechanism
The AVR cost model rewards a sparse tableau enough to offset the extra stages.
control
Under the fast cost model, the order-3 three-stage cell should use fewer cycles.
min_samples
40
H-342refutedfast.p4s5.cycles < fast.p3s4.cycles AND slow.p3s4.cycles < slow.p4s5.cycles0.354821623c2461
statement
Under the fast cost model, the order-4 five-stage archive cell uses fewer cycles than the order-3 four-stage cell, while the slow cost model reverses that ranking.
mechanism
The fast model rewards a sparse five-stage implementation, while the slow model magnifies the cost of its fourth-order arithmetic.
control
Under the slow cost model, the order-3 four-stage cell should use fewer cycles.
min_samples
100
H-338refutedavr_approx.p2s3.search < avr_approx.p3s4.search AND fast.p3s4.search < fast.p2s3.search0.7662311503c2455
statement
Under the AVR approximation cost model, the order-2 three-stage archive cell has lower search error than the order-3 four-stage cell.
mechanism
The AVR cost model favors a cheaper three-stage tableau, changing which coefficients the search retains.
control
Under the fast cost model, the order-3 four-stage cell should have lower search error.
min_samples
100
H-336refutedfast.p4s6.search < fast.p2s5.search AND fast.p2s5.heldout < fast.p4s6.heldout AND slow.p2s5.search < slow.p4s6.search0.431925306c2451
statement
Under the fast cost model, the order-4 six-stage archive cell does better than the order-2 five-stage cell on search error but loses on held-out error.
mechanism
The extra quantized stages can improve the search fit while accumulating rounding error that hurts held-out performance.
control
Under the slow cost model, the order-2 five-stage cell should beat the order-4 six-stage cell on search error if the fast-model advantage depends on stage cost.
min_samples
100
H-335refutedfast.p2s6.heldout < 0.02 AND fast.p4s6.heldout > 0.03 AND slow.p2s6.heldout < slow.p4s6.heldout1e+09306c2449
statement
Under the fast cost model, the order-2 six-stage archive cell has held-out error below 0.02, beating the order-4 six-stage cell whose held-out error exceeds 0.03.
mechanism
Fixed-point quantization of the order-4 coefficients may outweigh their formal accuracy advantage.
control
Under the slow cost model, the order-2 six-stage cell should also have lower held-out error than the order-4 six-stage cell.
min_samples
40
H-332refutedavr_approx.p3s4.heldout < avr_approx.p2s4.heldout AND fast.p2s4.heldout < fast.p3s4.heldout0.2479981611c2445
statement
Under the AVR approximation cost model, the order-3 four-stage archive cell has lower held-out error than the order-2 four-stage cell.
mechanism
The AVR cost model may favor coefficients whose fixed-point rounding errors accumulate less across four stages.
control
Under the fast cost model, the order-2 four-stage cell should retain the lower held-out error.
min_samples
200
H-330refutedfast.p2s4.search < fast.p3s4.search AND slow.p2s4.search < slow.p3s4.search0.2596741611c2442
statement
Under the fast cost model, the order-2 four-stage archive cell has lower search error than the order-3 four-stage cell.
mechanism
With the same stage count, the order-2 method has fewer order constraints, leaving more freedom to reduce error after coefficient quantization.
control
If that mechanism is real, the order-2 four-stage cell should also have lower search error under the slow cost model.
min_samples
40
H-323refutedfast.p2s6.heldout < fast.p3s3.heldout AND fast.p2s6.cycles < fast.p3s3.cycles AND slow.p2s6.heldout < slow.p3s3.heldout AND slow.p2s6.cycles > slow.p3s3.cycles0.2166563298c2430
statement
Under the fast cost model, the order-2 six-stage archive cell does better than the order-3 three-stage cell on held-out error and cycle count.
mechanism
Its additional stages give the search more room to reduce fixed-point error while fast arithmetic keeps their cycle cost low.
control
Under the slow cost model, the order-2 cell should retain its held-out advantage but lose its cycle advantage.
min_samples
30
H-319refutedavr_approx.p3s6.search < avr_approx.p4s6.search AND avr_approx.p3s6.cycles < avr_approx.p4s6.cycles AND fast.p3s6.search < fast.p4s6.search AND fast.p3s6.cycles < fast.p4s6.cycles0.962852298c2424
statement
Under the AVR approximation cost model, the order-3 six-stage archive cell has lower search error and uses fewer cycles than the order-4 six-stage cell.
mechanism
The third-order method can achieve the target search accuracy without the extra fixed-point work required by fourth-order constraints.
control
If this mechanism is real, the order-3 six-stage cell should retain both advantages under the fast cost model.
min_samples
30
H-317refutedavr_approx.p2s5.heldout < avr_approx.p4s6.heldout AND avr_approx.p2s5.search > avr_approx.p4s6.search AND fast.p2s5.heldout < fast.p4s6.heldout AND fast.p2s5.search < fast.p4s6.search0.415894298c2419
statement
Under the AVR approximation cost model, the order-2 five-stage archive cell has lower held-out error than the order-4 six-stage cell despite having higher search error.
mechanism
The simpler method may generalize better under fixed-point quantization even when the higher-order method fits the search cases more closely.
control
Under the fast cost model, the order-2 five-stage cell should retain its held-out advantage while also having lower search error.
min_samples
20
H-314refutedavr_approx.p2s6.cycles < avr_approx.p3s4.cycles AND fast.p3s4.cycles < fast.p2s6.cycles1.107783239c2415
statement
Under the AVR approximation cost model, the order-2 six-stage archive cell uses fewer cycles than the order-3 four-stage cell.
mechanism
The AVR cost model may favor the simpler order-2 arithmetic enough to offset its two additional stages.
control
Under the fast cost model, the order-3 four-stage cell should use fewer cycles.
min_samples
100
H-302refutedavr_approx.p4s6.search < avr_approx.p3s6.search AND fast.p3s6.search < fast.p4s6.search0.942806286c2395
statement
Under the AVR approximation cost model, the order-4 six-stage archive cell has lower search error than the order-3 six-stage cell.
mechanism
The AVR cycle weights may favor order-4 coefficients that fit the search trajectories more closely.
control
Under the fast cost model, the order-3 six-stage cell should have lower search error if that cost difference drives the ranking.
min_samples
50

61 older predicates are not shown here. The whole log is in rk-work/hypotheses.jsonl.

inconclusive (90 predicates) effect size under 0.2, or a named cell with no records
idverdictpredicatedncycle
H-379inconclusivefast.p2s5.search < fast.p2s4.search AND slow.p2s4.search < slow.p2s5.search0.181261855c2587
statement
Under the fast cost model, the order-2 five-stage archive cell has lower search error than the order-2 four-stage cell.
mechanism
An extra stage provides more freedom to reduce search error when multiplication is cheap.
control
Under the slow cost model, the four-stage cell should have lower search error if expensive multiplication changes which candidates the archive retains.
min_samples
100
H-374inconclusivefast.p2s5.heldout < fast.p3s3.heldout AND fast.p2s5.cycles < fast.p3s3.cycles AND slow.p2s5.heldout < slow.p3s3.heldout AND slow.p2s5.cycles >= slow.p3s3.cycles0.1234413567c2545
statement
Under the fast cost model, the order-2 five-stage archive cell does better than the order-3 three-stage cell on held-out error while using fewer cycles.
mechanism
The extra stages give the optimized order-2 tableau more freedom to reduce error, while its simpler stage calculations keep cycle cost low.
control
Under the slow cost model, the order-2 five-stage cell should retain its held-out error advantage but lose its cycle advantage.
min_samples
100
H-373inconclusivefast.p3s3.search < fast.p4s5.search AND slow.p4s5.search <= slow.p3s3.search0.0384773669c2544
statement
Under the fast cost model, the order-3 three-stage archive cell has lower search error than the order-4 five-stage cell.
mechanism
The three-stage tableau has enough coefficient freedom to fit the search cases while requiring fewer fixed-point operations.
control
If the advantage depends on the fast cost model, the order-4 five-stage cell should have no higher search error under the slow cost model.
min_samples
20
H-372inconclusivefast.p2s4.heldout < fast.p4s5.heldout AND fast.p2s4.search < fast.p4s5.search AND fast.p2s4.cycles < fast.p4s5.cycles AND slow.p2s4.heldout < slow.p4s5.heldout AND slow.p2s4.search < slow.p4s5.search AND slow.p2s4.cycles < slow.p4s5.cycles0.136125669c2542
statement
Under the fast cost model, the order-2 four-stage archive cell does better than the order-4 five-stage cell on held-out error, search error, and cycles.
mechanism
The four-stage order-2 tableau has enough coefficient freedom to reduce quantized error while requiring less work per step.
control
Under the slow cost model, the order-2 four-stage cell should retain all three advantages.
min_samples
200
H-371inconclusivefast.p2s4.heldout < fast.p3s6.heldout AND fast.p2s4.search < fast.p3s6.search AND fast.p2s4.cycles < fast.p3s6.cycles AND slow.p2s4.heldout < slow.p3s6.heldout AND slow.p2s4.search < slow.p3s6.search AND slow.p2s4.cycles < slow.p3s6.cycles0.02608631671c2541
statement
Under the fast cost model, the order-2 four-stage archive cell does better than the order-3 six-stage cell on held-out error, search error, and cycles.
mechanism
The four-stage method can use its freer coefficients to reduce fixed-point error while requiring fewer stage evaluations.
control
If this mechanism is real, the order-2 four-stage cell should retain all three advantages under the slow cost model.
min_samples
100
H-368inconclusiveavr_approx.p4s6.cycles < avr_approx.p3s5.cycles AND fast.p3s5.cycles < fast.p4s6.cycles0.0599082320c2536
statement
Under the AVR approximation cost model, the order-4 six-stage archive cell uses fewer cycles than the order-3 five-stage cell.
mechanism
The AVR approximation weights the cells’ coefficient operations differently, allowing the six-stage method to cost less per step.
control
Under the fast cost model, the order-3 five-stage cell should use fewer cycles if the AVR operation costs cause the reversal.
min_samples
100
H-351inconclusivefast.p2s4.heldout < fast.p3s3.heldout AND fast.p2s4.cycles < fast.p3s3.cycles AND slow.p2s4.heldout < slow.p3s3.heldout AND slow.p2s4.cycles >= slow.p3s3.cycles0.01833081670c2476
statement
Under the fast cost model, the order-2 four-stage archive cell does better than the order-3 three-stage cell on held-out error and cycle count.
mechanism
The order-2 tableau can use coefficients that accumulate less Q15 rounding error while remaining cheaper to evaluate under the fast model.
control
Under the slow cost model, its held-out error advantage should persist, but its cycle advantage should disappear if arithmetic cost drives the speed difference.
min_samples
200
H-341inconclusiveavr_approx.p2s2.heldout < avr_approx.p3s6.heldout AND fast.p3s6.heldout < fast.p2s2.heldout0.0876262527c2460
statement
Under the AVR approximation cost model, the order-2 two-stage archive cell has lower held-out error than the order-3 six-stage cell.
mechanism
AVR cycle weights may favor a two-stage tableau whose quantized coefficients accumulate less rounding error than the selected six-stage tableau.
control
Under the fast cost model, the order-3 six-stage cell should have lower held-out error if the AVR-specific selection drives the reversal.
min_samples
100
H-340inconclusivefast.p3s3.heldout < fast.p2s3.heldout AND fast.p3s3.search > fast.p2s3.search AND slow.p2s3.search < slow.p3s3.search AND slow.p2s3.heldout <= slow.p3s3.heldout0.1362251503c2458
statement
Under the fast cost model, the order-3 three-stage archive cell has lower held-out error than the order-2 three-stage cell despite higher search error.
mechanism
The third-order tableau generalizes better under fast arithmetic even when its search-set fit is worse.
control
Under the slow cost model, the order-2 cell should retain lower search error and match or beat the order-3 cell on held-out error.
min_samples
200
H-337inconclusiveavr_approx.p2s3.heldout < avr_approx.p4s5.heldout AND avr_approx.p2s3.search < avr_approx.p4s5.search AND avr_approx.p2s3.cycles < avr_approx.p4s5.cycles AND fast.p2s3.heldout < fast.p4s5.heldout AND fast.p2s3.search < fast.p4s5.search AND fast.p2s3.cycles < fast.p4s5.cycles0.157516623c2454
statement
Under the AVR approximation cost model, the order-2 three-stage archive cell does better than the order-4 five-stage cell on held-out error, search error, and cycles.
mechanism
The simpler order-2 tableau uses fewer stages and offers fewer opportunities for fixed-point rounding error to accumulate.
control
Under the fast cost model, the order-2 three-stage cell should retain the same three advantages if this mechanism is real.
min_samples
40
H-333inconclusivefast.p2s6.heldout < fast.p3s5.heldout AND fast.p2s6.cycles < fast.p3s5.cycles AND slow.p3s5.cycles < slow.p2s6.cycles0.1470883399c2446
statement
Under the fast cost model, the order-2 six-stage archive cell does better than the order-3 five-stage cell on held-out error and cycle count.
mechanism
The extra stages can reduce fixed-point integration error while the lower-order method needs fewer costly arithmetic operations.
control
Under the slow cost model, the order-3 five-stage cell should use fewer cycles if arithmetic cost drives the fast-model advantage.
min_samples
100
H-331inconclusiveavr_approx.p3s4.heldout < avr_approx.p4s5.heldout AND avr_approx.p3s4.cycles < avr_approx.p4s5.cycles AND fast.p3s4.heldout < fast.p4s5.heldout AND fast.p3s4.cycles < fast.p4s5.cycles0.118756621c2443
statement
Under the AVR approximation cost model, the order-3 four-stage archive cell does better than the order-4 five-stage cell on held-out error and cycle count.
mechanism
Its fewer stages and simpler coefficients should reduce both arithmetic work and accumulated fixed-point rounding error.
control
The fast cost model should preserve both advantages if this mechanism is real.
min_samples
20
H-329inconclusivefast.p3s3.heldout < fast.p3s5.heldout AND fast.p3s5.search < fast.p3s3.search AND slow.p3s3.heldout < slow.p3s5.heldout AND slow.p3s5.search < slow.p3s3.search0.0320354787c2440
statement
Under the fast cost model, the order-3 three-stage archive cell has lower held-out error than the order-3 five-stage cell, even though the five-stage cell has lower search error.
mechanism
The extra stages can fit the search trajectories more closely while accumulating fixed-point rounding error on held-out trajectories.
control
Under the slow cost model, the same search-error and held-out-error ranking should persist if stage-dependent rounding drives the gap.
min_samples
50
H-328inconclusivefast.p3s4.heldout < fast.p3s3.heldout AND avr_approx.p3s4.heldout >= avr_approx.p3s3.heldout0.08590834787c2439
statement
Under the fast cost model, the order-3 four-stage archive cell has lower held-out error than the order-3 three-stage cell.
mechanism
The extra stage reduces integration error when the fast cost model permits its selection.
control
If that advantage depends on the cost model, the AVR approximation should not preserve the same held-out ranking.
min_samples
100
H-325inconclusivefast.p2s6.heldout < fast.p2s5.heldout AND slow.p2s5.heldout < slow.p2s6.heldout0.0422853178c2433
statement
Under the fast cost model, the order-2 six-stage archive cell has lower held-out error than the order-2 five-stage cell.
mechanism
The extra stage improves accuracy under fast arithmetic, while its additional fixed-point rounding accumulates more error under slow arithmetic.
control
Under the slow cost model, the five-stage cell should have lower held-out error than the six-stage cell.
min_samples
100
H-321inconclusivefast.p2s2.search < fast.p2s3.search AND fast.p2s2.heldout > fast.p2s3.heldout AND slow.p2s2.search < slow.p2s3.search AND slow.p2s2.heldout > slow.p2s3.heldout0.0283952527c2427
statement
Under the fast cost model, the order-2 two-stage archive cell does better than the order-2 three-stage cell on search error but loses on held-out error.
mechanism
The two-stage cell may fit the search cases more closely while its quantized coefficients accumulate larger errors on held-out cases.
control
If this mechanism is real, the same search and held-out ranking should appear under the slow cost model.
min_samples
100
H-318inconclusiveavr_approx.p2s3.search < avr_approx.p3s3.search AND fast.p2s3.search < fast.p3s3.search0.1362251503c2421
statement
Under the AVR approximation cost model, the order-2 three-stage archive cell has lower search error than the order-3 three-stage cell.
mechanism
With the same number of stages, the lower-order method has more freedom to minimize search error.
control
The order-2 three-stage cell should also have lower search error under the fast cost model.
min_samples
30
H-312inconclusiveavr_approx.p3s6.search < avr_approx.p2s6.search AND fast.p2s6.search <= fast.p3s6.search0.05959533239c2412
statement
Under the AVR approximation cost model, the order-3 six-stage archive cell has lower search error than the order-2 six-stage cell.
mechanism
At the same stage count, the higher order gives the search more ways to reduce truncation error under the AVR cost estimate.
control
Under the fast cost model, the order-2 six-stage cell should have equal or lower search error if the AVR cost estimate drives the advantage.
min_samples
20
H-308inconclusivefast.p2s4.search < fast.p3s5.search AND avr_approx.p3s5.search < avr_approx.p2s4.search0.1196451610c2404
statement
Under the fast cost model, the order-2 four-stage archive cell has lower search error than the order-3 five-stage cell.
mechanism
The four-stage method can reach low search error with fewer quantized stage calculations.
control
If the advantage depends on the cost model, the order-3 five-stage cell should have lower search error under the AVR approximation.
min_samples
40
H-301inconclusiveavr_approx.p2s6.search < avr_approx.p3s5.search AND fast.p3s5.search < fast.p2s6.search0.03578683187c2394
statement
Under the AVR approximation cost model, the order-2 six-stage archive cell has lower search error than the order-3 five-stage cell.
mechanism
The AVR approximation may favor a six-stage second-order method whose coefficients incur less fixed-point quantization error.
control
Under the fast cost model, the order-3 five-stage cell should have lower search error if the advantage depends on AVR costs.
min_samples
40

70 older predicates are not shown here. The whole log is in rk-work/hypotheses.jsonl.

open (87 predicates) waiting for min_samples in at least one named cell
idverdictpredicatedncycle
H-380openfast.p3s3.heldout < 0.045 AND fast.p4s4.heldout > 0.06 AND slow.p3s3.heldout < slow.p4s4.heldoutn/an/ac2589+
statement
Under the fast cost model, the order-3 three-stage archive cell does better than the order-4 four-stage cell on held-out error, staying below 0.045 while the latter exceeds 0.06.
mechanism
The fourth-order constraints leave fewer coefficient choices that retain accuracy after fixed-point rounding.
control
Under the slow cost model, the order-3 three-stage cell should still have lower held-out error, though the absolute errors may shift.
min_samples
100
H-377openavr_approx.p3s4.heldout < avr_approx.p4s4.heldout AND avr_approx.p3s4.cycles < avr_approx.p4s4.cycles AND fast.p3s4.heldout < fast.p4s4.heldout AND fast.p4s4.cycles < fast.p3s4.cyclesn/an/ac2551+
statement
Under the AVR approximation cost model, the order-3 four-stage archive cell does better than the order-4 four-stage cell on held-out error and cycle count.
mechanism
The order-4 coefficient arithmetic adds enough cost to outweigh any accuracy gain from its higher formal order.
control
Under the fast cost model, the order-3 cell should retain its held-out error advantage, while the order-4 cell uses fewer cycles.
min_samples
200
H-366openfast.p2s5.heldout < fast.p4s4.heldout AND fast.p2s5.cycles > fast.p4s4.cycles AND slow.p2s5.heldout < slow.p4s4.heldout AND slow.p2s5.cycles < slow.p4s4.cyclesn/an/ac2533+
statement
Under the fast cost model, the order-2 five-stage archive cell has lower held-out error than the order-4 four-stage cell but uses more cycles.
mechanism
The extra stages give the order-2 search room to reduce quantized error while increasing execution work.
control
If cost weighting drives the cycle tradeoff, the order-2 five-stage cell should retain its error advantage and use fewer cycles under the slow cost model.
min_samples
20
H-356openfast.p1s1.cycles < fast.p2s3.cycles AND slow.p1s1.cycles < slow.p2s3.cyclesn/an/ac2485+
statement
Under the fast cost model, the order-1 one-stage archive cell uses fewer cycles than the order-2 three-stage cell.
mechanism
The one-stage method evaluates fewer stages, reducing its cycle cost.
control
Under the slow cost model, the one-stage cell should also use fewer cycles.
min_samples
100
H-354openfast.p4s4.heldout < fast.p2s2.heldout AND slow.p2s2.heldout < slow.p4s4.heldoutn/an/ac2481+
statement
Under the fast cost model, the order-4 four-stage archive cell has lower held-out error than the order-2 two-stage cell, while the slow cost model reverses that ranking.
mechanism
Fast multiplication makes the fourth-order cell's accuracy gain affordable, whereas slow multiplication favors the shorter method within the cycle budget.
control
Under the slow cost model, the order-2 two-stage cell should have lower held-out error.
min_samples
100
H-348openfast.p2s5.heldout < 0.015 AND fast.p4s4.heldout > 0.06 AND slow.p2s5.heldout < slow.p4s4.heldoutn/an/ac2472+
statement
Under the fast cost model, the order-2 five-stage archive cell does better than the order-4 four-stage cell on held-out error, with errors below 0.015 and above 0.06, respectively.
mechanism
The extra stages reduce integration error while the quantized order-4 coefficients leave a larger accumulated rounding error.
control
Under the slow cost model, the order-2 five-stage cell should still have lower held-out error.
min_samples
40
H-344openfast.p1s1.cycles < fast.p2s4.cycles AND slow.p1s1.cycles < slow.p2s4.cyclesn/an/ac2464+
statement
Under the fast cost model, the order-1 one-stage archive cell uses fewer cycles than the order-2 four-stage cell.
mechanism
The one-stage method requires fewer stage evaluations per step.
control
The one-stage cell should also use fewer cycles under the slow cost model.
min_samples
20
H-334openavr_approx.p2s2.search < avr_approx.p4s4.search AND fast.p2s2.search < fast.p4s4.searchn/an/ac2448+
statement
Under the AVR approximation cost model, the order-2 two-stage archive cell has lower search error than the order-4 four-stage cell.
mechanism
Fewer stages and quantized coefficients leave fewer opportunities for fixed-point rounding error to accumulate.
control
If this stage-count effect is real, the order-2 two-stage cell should also have lower search error under the fast cost model.
min_samples
60
H-326openavr_approx.p2s6.heldout < avr_approx.p4s4.heldout AND avr_approx.p2s6.search < avr_approx.p4s4.search AND avr_approx.p2s6.cycles < avr_approx.p4s4.cycles AND fast.p2s6.heldout < fast.p4s4.heldout AND fast.p2s6.search < fast.p4s4.search AND fast.p4s4.cycles < fast.p2s6.cyclesn/an/ac2434+
statement
Under the AVR approximation cost model, the order-2 six-stage archive cell does better than the order-4 four-stage cell on held-out error, search error, and cycle count.
mechanism
A lower-order tableau can reduce fixed-point rounding error while its simpler arithmetic keeps execution cost low.
control
Under the fast cost model, the order-2 six-stage cell should retain the error advantage, but the order-4 four-stage cell should use fewer cycles.
min_samples
20
H-322openfast.p2s6.heldout < 0.02 AND fast.p4s4.heldout > 0.05 AND slow.p2s6.heldout < slow.p4s4.heldoutn/an/ac2428+
statement
Under the fast cost model, the order-2 six-stage archive cell does better than the order-4 four-stage cell on held-out error, falling below 0.02 while the latter exceeds 0.05.
mechanism
The extra stages reduce integration error enough to outweigh the order-2 cell’s coefficient quantization error.
control
Under the slow cost model, the order-2 six-stage cell should retain the lower held-out error.
min_samples
20
H-315openfast.p1s1.cycles < fast.p2s6.cycles AND fast.p1s1.heldout > fast.p2s6.heldout AND slow.p1s1.cycles < slow.p2s6.cycles AND slow.p1s1.heldout > slow.p2s6.heldoutn/an/ac2416+
statement
Under the fast cost model, the order-1 one-stage archive cell uses fewer cycles than the order-2 six-stage cell but has higher held-out error.
mechanism
The six-stage method performs more arithmetic while reducing truncation error.
control
The slow cost model should preserve both rankings if stage count drives this tradeoff.
min_samples
30
H-313openavr_approx.p1s1.cycles < avr_approx.p3s6.cycles AND fast.p1s1.cycles < fast.p3s6.cyclesn/an/ac2413+
statement
Under the AVR approximation cost model, the order-1 one-stage archive cell uses fewer cycles than the order-3 six-stage cell.
mechanism
The six-stage method requires more stage evaluations and fixed-point arithmetic per step.
control
The fast cost model should preserve the same cycle ranking.
min_samples
20
H-311openfast.p4s6.search < fast.p1s1.search AND slow.p4s6.search < slow.p1s1.searchn/an/ac2410+
statement
Under the fast cost model, the order-4 six-stage archive cell has lower search error than the order-1 one-stage cell.
mechanism
The additional stages reduce truncation error enough to outweigh fixed-point rounding during the search.
control
If this mechanism is real, the order-4 six-stage cell should also have lower search error under the slow cost model.
min_samples
20
H-310openfast.p2s4.search < fast.p1s1.search AND slow.p2s4.search < slow.p1s1.searchn/an/ac2409+
statement
Under the fast cost model, the order-2 four-stage archive cell has lower search error than the order-1 one-stage cell.
mechanism
The extra stages reduce truncation error enough to outweigh fixed-point rounding.
control
Under the slow cost model, the order-2 four-stage cell should retain the lower search error.
min_samples
20
H-309openavr_approx.p3s6.heldout < avr_approx.p4s4.heldout AND slow.p3s6.heldout < slow.p4s4.heldoutn/an/ac2406+
statement
Under the AVR approximation cost model, the order-3 six-stage archive cell has lower held-out error than the order-4 four-stage cell.
mechanism
The extra stages give the order-3 method more room to reduce error despite fixed-point rounding.
control
The order-3 six-stage cell should also have lower held-out error under the slow cost model.
min_samples
20
H-307openfast.p1s1.cycles < fast.p3s3.cycles AND slow.p1s1.cycles < slow.p3s3.cyclesn/an/ac2403+
statement
Under the fast cost model, the order-1 one-stage archive cell uses fewer cycles than the order-3 three-stage cell.
mechanism
The three-stage method requires more derivative evaluations per step.
control
The one-stage cell should also use fewer cycles under the slow cost model.
min_samples
30
H-306openfast.p1s1.cycles < fast.p4s5.cycles AND slow.p1s1.cycles < slow.p4s5.cyclesn/an/ac2401+
statement
Under the fast cost model, the order-1 one-stage archive cell uses fewer cycles than the order-4 five-stage cell.
mechanism
One stage requires fewer stage evaluations and fixed-point operations than five stages.
control
The one-stage cell should also use fewer cycles under the slow cost model.
min_samples
20
H-305openavr_approx.p1s1.cycles < avr_approx.p2s5.cycles AND avr_approx.p1s1.heldout > avr_approx.p2s5.heldout AND fast.p1s1.cycles < fast.p2s5.cycles AND fast.p1s1.heldout > fast.p2s5.heldoutn/an/ac2400+
statement
Under the AVR approximation cost model, the order-1 one-stage archive cell uses fewer cycles than the order-2 five-stage cell but has higher held-out error.
mechanism
The single stage requires less computation, while the five-stage method can reduce integration error.
control
Under the fast cost model, the same cycle and held-out error ordering should hold.
min_samples
40
H-304openavr_approx.p1s1.cycles < avr_approx.p3s5.cycles AND fast.p1s1.cycles < fast.p3s5.cyclesn/an/ac2398+
statement
Under the AVR approximation cost model, the order-1 one-stage archive cell uses fewer cycles than the order-3 five-stage cell.
mechanism
The one-stage method requires fewer stage evaluations per step.
control
The one-stage cell should also use fewer cycles under the fast cost model.
min_samples
20
H-303openfast.p1s1.cycles < fast.p4s4.cycles AND slow.p1s1.cycles < slow.p4s4.cyclesn/an/ac2397+
statement
Under the fast cost model, the order-1 one-stage archive cell uses fewer cycles than the order-4 four-stage cell.
mechanism
Evaluating one stage requires less fixed-point work per step than evaluating four stages.
control
Under the slow cost model, the order-1 one-stage cell should also use fewer cycles.
min_samples
20

67 older predicates are not shown here. The whole log is in rk-work/hypotheses.jsonl.

Interpretation

Model-written text, in this section and the next. The sources are citations the model collected itself, so check them before relying on them.

Readings of the archive the model wrote during the run, newest at the top. Each one comments on the numbers as they stood at its cycle, so where the text and the tables disagree, trust the tables. Unlike hypotheses these readings carry no predicate, so code cannot catch them being wrong.

cycle 2575 written 2026-09-28 12:42 CT

At cycle 2574, the archive fills 16 of 40 searchable order-two cells, 9 of 32 order-three cells, and 5 of 24 order-four cells. No searchable order-one cell is filled, though one candidate lies outside its stage range. The lowest held-out error shown is 0.01223 for an order-two, five-stage candidate. The best shown order-three and order-four held-out errors are 0.02286 and 0.02787. These are results for the archived candidates, not a general ranking of method orders.

Search error often understates held-out error. One order-three, five-stage cell has search error 0.003999 but held-out error 0.06314; an order-four, six-stage cell has search error 0.002124 and held-out error 0.02787. More stages also do not consistently improve held-out error within an order. Fixed-point rounding, coefficient arithmetic, and the problems used for search and evaluation could each contribute, but the archive does not isolate their effects. The recent cross-model hypotheses listed in the run are marked refuted by the harness; their combined predicates do not show which individual comparison failed.

The literature digest supports judging error together with execution time under a fixed sampling budget. It also cautions that reduced precision can alter observed convergence and stability. For Cortex-M0+, multiplication can take either 1 or 32 cycles depending on the implementation, while memory access and coefficient arithmetic add costs that stage count alone misses. The archive’s cycle figures are therefore useful comparisons within this run, but they do not establish timing on a particular device. The digest’s discussion of implicit methods reinforces the same limit: stage counts omit iteration and linear-solve work.

The current order-four, four-stage bucket-three cell remains empty, and the stall counter is 13. A useful next check is whether candidates in that cell can meet the archive criteria, followed by repeated held-out evaluations of the strongest occupied cells. Tracing rounding and overflow alongside measured cycles on the intended hardware would help distinguish fixed-point effects from search-set mismatch and clarify whether the apparent error gains fit the available time budget.

cycle 2550 written 2026-09-28 11:40 CT

The archive is sparse. Order 2 fills 16 of 40 searchable cells, order 3 fills 9 of 32, and order 4 fills 5 of 24; order 1 has no filled searchable cells, though one result sits outside the stage range. The lowest recorded held-out error is 0.01291 in an order-2, six-stage cell. The best recorded values for orders 3 and 4 are 0.02286 and 0.02787, both at six stages. These are results from the occupied cells, not a ranking of what each order could achieve across the empty cells.

Search error often understates held-out error substantially. For example, the order-4, six-stage bucket-3 cell has search error 0.002124 and held-out error 0.02787. That gap is consistent with candidates fitting the search cases more closely than the held-out cases, although the archive alone does not identify the cause. Fixed-point rounding, shifts, coefficient representation, and overflow behavior are possible contributors. Cycle counts also vary within a stage count and overlap across stage counts, so stage count by itself does not explain the measured cost.

The literature digest gives reasons to check those mechanisms directly. On a Cortex-M0+, multiplication can take either 1 or 32 cycles depending on the implementation; shifts, memory access, and register use also matter. Arithmetic shifts round negative values downward, and multiplication retains only the low 32 bits, both of which can affect fixed-point results. The digest also notes that implicit Runge, Kutta methods may incur stage solves, Jacobian work, and linear solves. The archive does not say whether its candidates use those structures, so those costs should only be applied where relevant.

Several recent cross-cost-model hypotheses are recorded as refuted, but the supplied grid does not show the model-specific measurements needed to explain each verdict. With many empty cells and a stall counter of 42, it remains unclear how much of the pattern reflects attainable methods versus search coverage. Useful next checks are the held-out cases with the largest search gaps, the instruction and arithmetic traces behind cycle counts, and targeted searches in empty neighboring cells.

cycle 2500 written 2026-09-28 09:35 CT

At cycle 2499, the archive fills 16 of 40 second-order cells, 9 of 32 third-order cells, and 5 of 24 fourth-order cells. No earliest-order cell is filled within the searchable stage range, though one entry lies outside it. The lowest displayed held-out errors are 0.01291 for a six-stage second-order cell, 0.02286 for a six-stage third-order cell, and 0.02787 for a six-stage fourth-order cell. In this archive, a higher order label has not consistently meant a lower held-out error.

Search error and held-out error often separate. For example, the five-stage second-order cell in bucket 3 has search error 0.001701 and held-out error 0.03179, while its six-stage bucket 2 counterpart has higher search error, 0.008088, but lower held-out error, 0.01291. Q15 coefficient quantization, floor rounding, and a fixed cycle budget can change which tableau performs well beyond the search cases. The recent cross-model ranking hypotheses listed here were refuted, which further limits what can be inferred from a ranking under one cost model.

The literature digest explains why comparing tableaus within the same order and stage count is useful: order conditions can leave free coefficients that affect error. Published coefficient objectives do not directly predict held-out error under this fixed-point evaluation. It also cautions that stage count alone cannot represent cost, particularly for implicit methods, where solver iterations, Jacobian work, and linear solves matter.

Many cells remain empty, and the run is stalled at the five-stage, bucket 3 cell, so the observed rankings may change as coverage grows. The next useful checks are repeated held-out evaluations of close candidates, comparisons across the cost models using the same tableaus, and measurements of the work included in each cycle count. Those checks would help distinguish persistent accuracy differences from sensitivity to the test set or cost assumptions.

cycle 2475 written 2026-09-28 08:34 CT

The archive fills 30 searchable cells: 16 for order 2, nine for order 3, and five for order 4. No order-1 cell is filled within the searchable stage range, though one entry lies outside it. The lowest recorded held-out error is 0.01291 for an order-2, six-stage method in bucket 2. The best recorded values for orders 3 and 4 are 0.02286 and 0.02787, both at six stages. These are results for the tableaus found so far, not a general ranking of the orders.

Search error often understates held-out error. For example, the order-2, five-stage entry in bucket 3 has search error 0.001701 and held-out error 0.03179, while its bucket-2 counterpart has higher search error, 0.002731, but lower held-out error, 0.01356. Quantized coefficients, Q15 multiplication with floor rounding, and errors accumulated across stages and steps can all affect performance on cases outside the search set. The occupied cells also show a cycle and error tradeoff: the lowest held-out errors occur among methods using more stages and, in these entries, more cycles.

The literature digest gives reasons to compare individual tableaus rather than rely on order labels. Order conditions can leave coefficients free, and earlier optimization work uses that freedom to reduce error or meet other constraints. The fixed-point studies show that rounding rules and intermediate precision can change integration results even when the method and step size stay fixed. Those findings are consistent with the archive’s variation within each order, but they do not predict its Q15 held-out rankings or cycle costs.

Many cells remain empty, and a 105-cycle stall limits what can be inferred from the current archive. The recent cross-cost-model hypotheses listed in the run state were refuted; 83 hypotheses remain open. A useful next examination would compare repeat evaluations of the leading tableaus on held-out cases, then inspect how coefficient quantization, floor-rounded products, and cost-model assumptions change their error and cycle rankings.

cycle 2425 written 2026-09-28 06:22 CT

At cycle 2424, the archive fills 30 of 136 searchable cells: 16 for order 2, nine for order 3, and five for order 4. No order 1 cells are filled within the searchable stage range, though one lies outside it. The lowest held-out error shown for each filled order is 0.01291 for order 2, 0.02286 for order 3, and 0.02787 for order 4. These are the best entries in different cells, so they do not establish an overall ranking of the methods.

Search error often understates held-out error. In the order 4, six-stage, bucket 3 cell, search error is 0.002124 while held-out error is 0.02787. The order 3, five-stage, bucket 2 cell shows a wider gap: 0.003999 versus 0.06314. This suggests that optimizing against the search cases can select coefficients whose accuracy does not carry over to held-out cases. Stage count alone does not explain the results; the occupied buckets and reported cycle costs also vary.

The literature digest gives plausible sources for this sensitivity. Floor rounding of fixed-point products can add directional error at each stage, while quantized coefficients and step sizes can accumulate further error. Wider intermediate values and more accurate constants improved the cited ODE experiments, indicating that the implementation can matter as much as the tableau. The recent cross-cost hypotheses were recorded as refuted, but their predicates combine several comparisons; those outcomes do not isolate which comparison failed or establish a general rule across cost models.

The archive does not yet show whether the empty cells are infeasible or simply unfilled, and the stall counter of 72 leaves the rate of further coverage uncertain. Useful next checks are to examine the individual comparisons behind the recent hypothesis outcomes, repeat the large search-to-held-out gaps across more test cases, and vary rounding, coefficient precision, and intermediate width. Measured cycle costs on the intended processor would also help interpret the cost-model comparisons, since the digest notes that multiplication timing can differ substantially across Cortex-M0+ implementations.

47 older entries are not shown here. The whole log is in rk-work/interpretation/interpretations.jsonl.

Literature

Digests of published work the model looked up on the web during the run, newest at the top. They feed the directive and hypothesis prompts. Nothing here is a measurement from this project, and no measured page depends on it.

Cycle numbers restart at each epoch, so every entry names the epoch its cycle counts in.

Real-time integration under limited precision collected 2026-09-28 12:41 CT, epoch 2, cycle 2575

A 2024 study of numerical optimal control reports that fixed-grid integration can produce large errors while adaptive grids can exceed the available sampling time. This supports evaluating solver error alongside a fixed execution budget, rather than using formal order alone to judge suitability for real-time control.

  • Sampling-time limits can rule out adaptive integration even when it reduces error.
  • Reduced precision can change the observed convergence and stability of a Runge, Kutta method.
  • Energy behavior is a separate property from classical order and endpoint error.
  • The cited studies do not establish cycle counts or method rankings for Q15 arithmetic on Cortex-M0+.

sources:

Cortex-M0+ multiplication and constant arithmetic collected 2026-09-28 11:40 CT, epoch 2, cycle 2550

Arm documents two Cortex-M0+ multiplier implementations: MULS takes either 1 or 32 cycles and returns the low 32 bits. With zero wait states, shifts, adds, and subtracts each take 1 cycle; ordinary loads typically take 2. These figures make the chosen multiplier implementation central to a fixed cycle budget, while memory accesses and register use also affect the cost of a Runge, Kutta stage.

  • MULS takes 1 or 32 cycles, depending on the Cortex-M0+ implementation.
  • The documented cycle table assumes zero wait states.
  • ASR rounds signed division by a power of two toward negative infinity.
  • MULS returns only the low 32 bits of a product.
  • Signed-digit recoding can reduce shift-add work for fixed coefficients.

sources:

Implicit Runge, Kutta costs on small MCUs collected 2026-09-28 09:35 CT, epoch 2, cycle 2500

Implicit families have different costs even at the same stage count. A diagonally implicit Runge, Kutta method solves its stages in sequence; an SDIRK method uses the same diagonal coefficient, allowing a linear-system factorization to be reused when the relevant Jacobian is held fixed. Radau IIA is fully implicit, so its stages are coupled. These structures make stage count alone an incomplete measure of per-step work.

  • SDIRK stages are sequential implicit solves, with potential factorization reuse.
  • Radau IIA stages are coupled; SciPy’s Radau implementation is order five.
  • Rosenbrock stages require linear solves and have been used in real-time embedded control.
  • A fixed iteration cap bounds work, but convergence and achieved accuracy still need checking.
  • Cycle comparisons should include solver iterations, Jacobian work, and linear solves as well as stage count.

sources:

Optimizing low-order Runge, Kutta tableaus collected 2026-09-28 08:34 CT, epoch 2, cycle 2475

Runge, Kutta order conditions constrain tableau coefficients but can leave free parameters. Ralston used that freedom to derive second-, third-, and fourth-order methods with minimum truncation-error bounds of a specified type. For two-stage, second-order methods, the choice of stage location distinguishes methods such as midpoint, Heun, and Ralston’s method; the order label alone does not determine the leading error.

Numerical searches extend this approach. RK-Opt searches coefficients for a prescribed order and stage count and can minimize a principal error norm while imposing stability or storage constraints. Constraint-programming work likewise solves order conditions and optimizes remaining freedom. These results support comparing tableaus within each order and stage count. They do not establish which tableau has the lowest held-out error after Q15 quantization, floor rounding, and a fixed cycle budget; that comparison requires evaluation under those conditions.

  • Order conditions can leave tableau coefficients free.
  • Leading error depends on the chosen coefficients, even at fixed order and stage count.
  • RK-Opt searches prescribed order and stage counts using error and stability objectives.
  • Published coefficient objectives do not directly measure Q15 held-out error or cycle cost.

sources:

Fixed-point rounding in Runge, Kutta integration collected 2026-09-28 06:22 CT, epoch 2, cycle 2425

Fixed-point ODE experiments show that arithmetic error can materially change a solver’s result even when its Runge, Kutta method and step size stay fixed. In tests of RK2 and RK3 neuron solvers, rounding down multiplication results produced substantial accumulated timing errors; rounding constants more accurately and retaining wider intermediate values also improved results. The authors define right-shift truncation of signed two’s-complement values as rounding down, including for negative values.

  • Floor-rounded Q15 multiplication can introduce directional error at every inexact product.
  • Quantized coefficients and step sizes can contribute accumulated error.
  • Runge, Kutta stage errors depend on the implementation as well as the tableau.
  • Stochastic rounding improved the cited ODE tests, but incurred measured runtime overhead.
  • Cortex-M0+ multiplication may take one or 32 cycles, depending on the processor implementation.

sources:

Embedded Runge, Kutta step control in fixed point collected 2026-09-28 05:19 CT, epoch 2, cycle 2400

Bogacki, Shampine 3(2) and Dormand, Prince 5(4) use shared stages to produce solutions of two orders. Their difference supplies a local error estimate. SciPy’s implementations control error using the lower-order estimate and advance with the higher-order result. These are useful reference methods for assessing whether the accuracy gained from extra stages justifies their cost under a fixed cycle budget.

PI step-size controllers use the current and previous scaled error estimates to choose the next step size. Published implementations bound the change in step size and retry rejected steps. Those retries make execution time variable, so a fixed-budget comparison must account for the controller and its worst-case work, as well as the RK stages.

Fixed-point ODE research reports that reducing the step size can eventually increase error when quantization dominates truncation error. For Q15 with floor rounding, a small difference between embedded results can also disappear on the integer grid; this is an inference from the embedded error calculation and fixed-point quantization, not a measured Cortex-M0+ result. Arm’s Q15 DSP operations document saturation, which must be distinguished from the specified floor-rounding arithmetic. The consulted sources do not establish a particular pair or controller as best for this target.

  • Embedded pairs estimate local error from two results sharing stages.
  • Bogacki, Shampine is a 3(2) pair; Dormand, Prince is a 5(4) pair.
  • PI control uses error history and can incur rejected-step retries.
  • Quantization can limit the value of smaller steps and obscure embedded error estimates.
  • Q15 saturation behavior does not specify the required floor-rounding behavior.

sources:

Production ODE integrator storage and error control collected 2026-09-28 03:19 CT, epoch 2, cycle 2350

SciPy’s default solve_ivp method is the adaptive RK45 5(4) pair, with default tolerances rtol=1e-3 and atol=1e-6. Its explicit Runge, Kutta implementation stores stage derivatives in an array of shape (stages+1, state size). It accepts a step when the RMS norm of the estimated error, scaled componentwise by atol + rtol × max(|old state|, |new state|), is below 1. Its step-size controller uses a 0.9 safety factor, limits reductions to a factor of 0.2 and growth to a factor of 10, and can retry rejected steps.

  • SciPy RK45 uses embedded error estimation and stores a full stage array.
  • SciPy’s explicit RK acceptance test uses a scaled RMS norm.
  • Boost.Odeint permits different state containers and algebras; its controlled Runge, Kutta stepper uses the maximum scaled component error.
  • Odeint’s documented controller uses a 0.9 safety factor and step-size factors bounded by 0.2 and 5.
  • CVODE uses variable-step, variable-order Adams or BDF multistep methods, with Nordsieck history and a weighted RMS error test.
  • Adaptive rejection and retry make the work per accepted step variable; these library defaults do not specify a fixed-cycle schedule.

sources:

Roundoff and truncation at large step counts collected 2026-09-28 02:29 CT, epoch 2, cycle 2325

For a fixed integration interval, reducing the step size lowers an order-p method’s global truncation error, but increases the number of rounding events. Kehlet and Logg derive an accumulated roundoff bound proportional to the inverse step size when errors do not cancel, and an inverse-square-root scaling under a model of unbiased random errors. The latter model cannot be assumed for floor-rounded Q15 arithmetic: each downward quantization has a directional error, and correlations across steps may matter. Fixed-point ODE experiments also show that rounding choice can materially change accuracy.

  • More steps can increase total error after truncation error becomes small.
  • Square-root error growth relies on assumptions about rounding errors that floor rounding does not satisfy.
  • Runge, Kutta stage implementation affects amplification of internal rounding errors.
  • Classical backward error results for numerical integrators do not by themselves establish finite-precision error bounds.
  • Compare candidate methods using their implemented Q15 arithmetic over the full held-out trajectory and cycle budget.

sources:

Real-time integration under limited precision and compute collected 2026-09-28 00:34 CT, epoch 2, cycle 2275

A 2025 motor-control study compared Euler, backward Euler, Heun, and RK4 for an embedded predictive controller. In that application, two-stage Heun closely matched the RK4 reference at a 1 ms step and fit the available computation budget; Euler needed much smaller steps, while RK4 was too costly. This supports testing error per cycle rather than assuming that either fewer stages or higher formal order will win. The study used a dSPACE platform, so its timing results do not establish Cortex-M0+ cycle counts.

  • A two-stage, second-order method can offer a useful accuracy, compute tradeoff in real-time control.
  • Low-precision perturbations can change RK accuracy and stability; floating-point results do not directly establish Q15 behavior.
  • Energy behavior is a separate measure from trajectory error or formal order.
  • The consulted studies do not resolve the listed archive-cell comparisons under floor rounding.

sources:

Runge, Kutta stability under cycle limits collected 2026-09-27 23:53 CT, epoch 2, cycle 2250

An explicit Runge, Kutta method has a bounded stability region. For a stiff, decaying mode, its step size must keep the scaled mode inside that region even when accuracy would permit a larger step. Studies of optimized stability polynomials show that extra stages can extend the stable step size, especially along the negative real axis; the benefit depends on the problem’s spectrum and the method’s order. [Ketcheson and Ahmadia](https://projecteuclid.org/journals/communications-in-applied-mathematics-and-computational-science/volume-7/issue-2/Optimal-stability-polynomials-for-numerical-integration-of-initial-value-problems/10.2140/camcos.2012.7.247.pdf) [Doehring and colleagues](https://link.springer.com/article/10.1007/s10915-024-02478-5)

  • Explicit stability regions are bounded, so stiffness can limit step size before accuracy does.
  • Additional stages can buy a larger stable step, but their cycle cost matters.
  • An implicit method pays off only if the steps it saves outweigh its solve cost.

sources:

132 older digests are not shown here. The whole log is in rk-work/literature/digests.jsonl.