Research log

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

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. 712 hypotheses over 389 distinct predicates; 56 were posed more than once.
050100150200supportedsupported: 47 distinct predicates47refutedrefuted: 162 distinct predicates162inconclusiveinconclusive: 20 distinct predicates20openopen: 160 distinct predicates160

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

Every plotted bar, in one table (4 rows)
verdict groupdistinct predicates
supported47
refuted162
inconclusive20
open160

Every predicate, by verdict

supported (47 predicates) the predicate held once every cell it names had enough records
idverdictpredicatedncycle
H-704supportedavr_approx.p3s4.search < avr_approx.p2s4.search AND fast.p2s4.search < fast.p3s4.search0.762376280c2603
statement
The order-3, four-stage archive cell does better than the order-2, four-stage cell on search error under the AVR-approximate cost model.
mechanism
AVR-like arithmetic costs favor the order-3 coefficient structure because it reduces accumulated directional floor-rounding error without adding a stage.
control
Under the fast cost model, the order-2, four-stage cell should instead have lower search error if this cost-specific mechanism is real.
min_samples
40
H-044 ×32supportedslow.p3s5.heldout < slow.p2s5.heldout AND fast.p2s5.heldout < fast.p3s5.heldout0.46305249c2592
statement
The order-3, five-stage archive cell does better than the order-2, five-stage cell on held-out error under the slow cost model.
mechanism
The slow budget permits enough steps for the third-order cell's lower truncation error to outweigh its fixed-point coefficient sensitivity.
control
Under the fast cost model, the order-2, five-stage cell should instead have lower held-out error if limited step count suppresses the higher-order advantage.
min_samples
50
posed as
H-044, H-046, H-047, H-049, H-068, H-074, H-082, H-085, H-092, H-095, H-098, H-100, H-102, H-111, H-121, H-124, H-130, H-134, H-141, H-143, H-148, H-151, H-161, H-169, H-171, H-182, H-183, H-233, H-355, H-356, H-369, H-694
H-540 ×2supportedslow.p3s5.search < slow.p2s4.search AND fast.p2s4.search < fast.p3s5.search0.950788280c2495
statement
The order-3, five-stage archive cell does better than the order-2, four-stage cell on search error under the slow cost model.
mechanism
The slow cost model should reward the extra order and stage enough to offset their execution overhead and improve search accuracy.
control
Under the fast cost model, the order-2, four-stage cell should instead have lower search error if the mechanism is real.
min_samples
20
posed as
H-540, H-607
H-604supportedslow.p3s6.search < slow.p2s5.search AND fast.p2s5.search < fast.p3s6.search1.62277249c2492
statement
The order-3, six-stage archive cell does better than the order-2, five-stage cell on search error under the slow cost model.
mechanism
The slow cost model rewards the additional stage flexibility of the higher-order cell enough to improve search fit.
control
Under the fast cost model, the order-2, five-stage cell should have lower search error if the mechanism is real.
min_samples
30
H-431 ×3supportedavr_approx.p3s5.search < avr_approx.p2s5.search AND fast.p2s5.search < fast.p3s5.search1.31801249c2482
statement
The order-3, five-stage archive cell does better than the order-2, five-stage cell on search error under the AVR-approximate cost model.
mechanism
AVR-like instruction costs reward the order-3 method's improved accuracy per stage enough to offset its additional order constraints.
control
Under the fast cost model, the order-2, five-stage cell should instead have lower search error if the mechanism is real.
min_samples
20
posed as
H-431, H-588, H-595
H-577supportedslow.p2s6.cycles < slow.p3s6.cycles AND fast.p3s6.cycles < fast.p2s6.cycles1.95931114c2462
statement
The order-2, six-stage archive cell has lower cycle cost than the order-3, six-stage cell under the slow cost model.
mechanism
With equally many stages, the order-2 tableau should require fewer costly coefficient products when multiplication is iterative.
control
Under the fast cost model, the order-3, six-stage cell should instead have lower cycle cost because multiplication count matters less than scheduling and data movement.
min_samples
30
H-552supportedavr_approx.p3s6.cycles < avr_approx.p2s6.cycles AND slow.p2s6.cycles < slow.p3s6.cycles2.35996114c2434
statement
The order-3, six-stage archive cell has lower cycle cost than the order-2, six-stage cell under the AVR-approximate cost model.
mechanism
At equal stage count, the order-3 tableau can favor AVR-cheap coefficients and operation ordering enough to offset its additional order constraints.
control
Under the slow cost model, the order-2, six-stage cell should instead have lower cycle cost if the advantage is caused by AVR-specific arithmetic.
min_samples
20
H-534supportedavr_approx.p3s3.search < avr_approx.p2s2.search AND fast.p2s2.search < fast.p3s3.search0.2141684933c2414
statement
The order-3, three-stage archive cell does better than the order-2, two-stage cell on search error under the AVR-approximate cost model.
mechanism
AVR-weighted operation costs favor the higher-order three-stage scheme enough to offset its additional stage.
control
Under the fast cost model, the order-2, two-stage cell should have lower search error if the mechanism is real.
min_samples
30
H-048 ×11supportedavr_approx.p3s3.heldout < avr_approx.p2s3.heldout AND fast.p2s3.heldout < fast.p3s3.heldout0.397561296c2394
statement
The order-3, three-stage archive cell does better than the order-2, three-stage cell on held-out error under the AVR-approximate cost model.
mechanism
At equal stage count, the higher-order method's reduced truncation error should outweigh its fixed-point coefficient and rounding penalties under AVR-approximate costs.
control
Under the fast cost model, the order-2, three-stage cell should retain lower held-out error if the advantage is caused by cost-model-dependent step affordability.
min_samples
100
posed as
H-048, H-051, H-053, H-054, H-057, H-058, H-059, H-061, H-062, H-063, H-516
H-502 ×3supportedfast.p2s2.search < fast.p3s3.search AND slow.p3s3.search < slow.p2s2.search0.2141684933c2386
statement
The order-2, two-stage archive cell does better than the order-3, three-stage cell on search error under the fast cost model.
mechanism
The fast cost model favors the shallower two-stage tableau because its lower execution burden permits solutions with less accumulated fixed-point rounding error.
control
Under the slow cost model, the order-3, three-stage cell should instead achieve lower search error if the reversal is genuinely cost-driven.
min_samples
20
posed as
H-502, H-507, H-509
H-476 ×5supportedslow.p3s3.search < slow.p2s2.search AND fast.p2s2.search < fast.p3s3.search0.2141684933c2383
statement
The order-3, three-stage archive cell does better than the order-2, two-stage cell on search error under the slow cost model.
mechanism
The slow cost model gives the third-order cell enough effective accuracy per step for reduced truncation error to outweigh its extra stage and quantization site.
control
Under the fast cost model, the order-2, two-stage cell should instead have lower search error because its lower stage cost permits more steps within the budget.
min_samples
20
posed as
H-476, H-478, H-501, H-503, H-506
H-408 ×3supportedfast.p3s5.search < fast.p3s3.search AND slow.p3s3.search < slow.p3s5.search0.4765654933c1247
statement
The order-3, five-stage archive cell does better than the order-3, three-stage cell on search error under the fast cost model.
mechanism
Under fast arithmetic, the two additional stages improve approximation enough to outweigh their modest execution-cost penalty.
control
Under the slow cost model, the three-stage cell should instead have lower search error because expensive extra stages reduce the usable step budget.
min_samples
30
posed as
H-408, H-414, H-486
H-425supportedavr_approx.p3s3.search < avr_approx.p2s3.search AND fast.p2s3.search < fast.p3s3.search0.382945296c1158
statement
The order-3, three-stage archive cell does better than the order-2, three-stage cell on search error under the AVR-approximate cost model.
mechanism
At equal stage count, the higher-order method reduces truncation error enough under AVR-like costs to offset coefficient quantization and floor-rounding bias.
control
Under the fast cost model, the order-2, three-stage cell should instead have lower search error if the advantage is caused by the AVR-specific cost regime.
min_samples
296
H-389 ×5supportedslow.p3s4.search < slow.p2s4.search AND fast.p2s4.search < fast.p3s4.search0.80999274c1129
statement
The order-3, four-stage archive cell does better than the order-2, four-stage cell on search error under the slow cost model.
mechanism
The slow cost model rewards the additional order conditions at fixed stage count enough to offset their implementation overhead.
control
If this mechanism is real, the order-2, four-stage cell should instead have lower search error under the fast cost model.
min_samples
40
posed as
H-389, H-390, H-392, H-393, H-399
H-133 ×6supportedavr_approx.p3s4.heldout < avr_approx.p2s4.heldout AND fast.p2s4.heldout < fast.p3s4.heldout0.788882274c1099
statement
The order-3, four-stage archive cell does better than the order-2, four-stage cell on held-out error under the AVR-approximate cost model.
mechanism
At equal stage count, AVR-sensitive coefficient and scaling choices reduce systematic Q15 floor-rounding amplification enough for the higher-order cell to generalize better.
control
Under the fast cost model, the order-2, four-stage cell should instead have lower held-out error if the AVR-specific mechanism is real.
min_samples
40
posed as
H-133, H-197, H-219, H-278, H-300, H-372
H-260 ×15supportedslow.p3s5.heldout < slow.p2s6.heldout AND fast.p2s6.heldout < fast.p3s5.heldout0.622824114c1092
statement
The order-3, five-stage archive cell does better than the order-2, six-stage cell on held-out error under the slow cost model.
mechanism
When stages are costly, the higher-order five-stage method should achieve better accuracy per unit cost than the lower-order six-stage method.
control
Under the fast cost model, the order-2, six-stage cell should retain the lower held-out error because its extra stage is less heavily penalized.
min_samples
30
posed as
H-260, H-306, H-311, H-320, H-337, H-339, H-342, H-344, H-347, H-350, H-352, H-353, H-358, H-364, H-365
H-040 ×13supportedslow.p3s4.heldout < slow.p2s4.heldout AND fast.p2s4.heldout < fast.p3s4.heldout0.785884274c1089
statement
The order-3, four-stage archive cell does better than the order-2, four-stage cell on held-out error under the slow cost model.
mechanism
The slow cost model gives the higher-order tableau enough arithmetic fidelity for its lower truncation error to outweigh its greater sensitivity to quantization.
control
Under the fast cost model, the order-2, four-stage cell should instead have lower held-out error if reduced arithmetic fidelity causes the reversal.
min_samples
30
posed as
H-040, H-071, H-077, H-087, H-093, H-094, H-096, H-097, H-099, H-101, H-104, H-152, H-363
H-113 ×9supportedslow.p3s4.heldout < slow.p2s5.heldout AND fast.p2s5.heldout < fast.p3s4.heldout0.345102249c1086
statement
The order-3, four-stage archive cell does better than the order-2, five-stage cell on held-out error under the slow cost model.
mechanism
The extra formal order should reduce truncation error enough under the slow budget to outweigh the four-stage method's fixed-point perturbation amplification.
control
Under the fast cost model, the order-2, five-stage cell should retain lower held-out error because the tighter budget favors its lower-order implementation.
min_samples
100
posed as
H-113, H-139, H-142, H-144, H-238, H-327, H-329, H-346, H-360
H-276 ×2supportedavr_approx.p3s5.heldout < avr_approx.p2s6.heldout AND fast.p2s6.heldout < fast.p3s5.heldout0.621154114c1073
statement
The order-3, five-stage archive cell does better than the order-2, six-stage cell on held-out error under the AVR-approximate cost model.
mechanism
The higher-order five-stage method should use AVR-weighted work more effectively by reducing truncation error without paying for a sixth stage.
control
Under the fast cost model, the order-2, six-stage cell should instead have lower held-out error if the advantage is caused by AVR-specific stage costs.
min_samples
20
posed as
H-276, H-348
H-264 ×18supportedslow.p3s4.heldout < slow.p2s6.heldout AND fast.p2s6.heldout < fast.p3s4.heldout2.69902114c1069
statement
The order-3, four-stage archive cell does better than the order-2, six-stage cell on held-out error under the slow cost model.
mechanism
The higher-order four-stage method uses fewer costly stage evaluations while retaining enough tableau freedom to suppress implementation-level error.
control
Under the fast cost model, the order-2, six-stage cell should beat the order-3, four-stage cell if costly stage evaluations drive the reversal.
min_samples
114
posed as
H-264, H-267, H-286, H-288, H-292, H-295, H-302, H-304, H-309, H-313, H-314, H-322, H-323, H-324, H-325, H-333, H-338, H-345

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

refuted (162 predicates) the predicate failed on the data it names
idverdictpredicatedncycle
H-700refutedfast.p3s5.heldout < fast.p2s5.heldout AND slow.p2s5.heldout < slow.p3s5.heldout0.464701249c2598
statement
The order-3, five-stage archive cell does better than the order-2, five-stage cell on held-out error under the fast cost model.
mechanism
Cheap multiplication lets the higher-order cell exploit its accuracy advantage without sacrificing as much search budget to arithmetic cost.
control
Under the slow cost model, the order-2, five-stage cell should instead have lower held-out error if multiplication cost drives the reversal.
min_samples
30
H-697refutedavr_approx.p3s6.cycles < avr_approx.p2s6.cycles AND fast.p2s6.cycles < fast.p3s6.cycles2.00017114c2595
statement
The order-3, six-stage archive cell has lower cycle cost than the order-2, six-stage cell under the AVR-approximate cost model.
mechanism
Reusable shift-add partial products in the order-3 coefficients should outweigh its higher algebraic order when constant-specific arithmetic costs are modeled.
control
Under the fast-multiplier cost model, the order-2, six-stage cell should retain lower cycle cost because coefficient-specific shift-add reuse no longer offsets its simpler computation.
min_samples
30
H-696refutedfast.p2s5.cycles < fast.p3s4.cycles AND slow.p3s4.cycles < slow.p2s5.cycles2.50465249c2594
statement
The order-2, five-stage archive cell has lower cycle cost than the order-3, four-stage cell under the fast cost model.
mechanism
With cheap multiplication, the lower-order cell's simpler coefficient arithmetic outweighs its extra stage.
control
Under the slow cost model, the order-3, four-stage cell should have lower cycle cost because avoiding expensive multiplications matters more than stage count.
min_samples
249
H-574 ×5refuted mixedslow.p3s5.cycles < slow.p2s5.cycles AND fast.p2s5.cycles < fast.p3s5.cycles0.20046249c2593
statement
The order-3, five-stage archive cell has lower cycle cost than the order-2, five-stage cell under the slow cost model.
mechanism
Sparser quantized coefficients reduce expensive multiplication work enough for the order-3 cell to overcome its additional arithmetic overhead when multiplication is slow.
control
Under the fast cost model, the order-2, five-stage cell should have lower cycle cost because non-multiplication overhead dominates.
min_samples
30
posed as
H-574, H-576, H-587, H-591, H-695
H-683refutedslow.p3s6.search < slow.p2s3.search AND fast.p2s3.search < fast.p3s6.search0.542675333c2579
statement
The order-3, six-stage archive cell does better than the order-2, three-stage cell on search error under the slow cost model.
mechanism
Slow-cost optimization rewards the extra stages' improved fixed-point convergence enough to offset their execution overhead.
control
Under the fast cost model, the order-2, three-stage cell should instead have lower search error if the mechanism is real.
min_samples
20
H-639refutedavr_approx.p2s4.cycles < avr_approx.p2s5.cycles AND fast.p2s5.cycles < fast.p2s4.cycles3.49758249c2530
statement
The order-2, four-stage archive cell has lower cycle cost than the order-2, five-stage cell under the AVR-approximate cost model.
mechanism
AVR-aware coefficient approximation should give the four-stage cell sparser shift-add realizations that outweigh any accuracy-driven coefficient complexity.
control
Under the fast cost model, the five-stage cell should instead have lower cycle cost if multiplier-sensitive coefficient sparsity causes the reversal.
min_samples
30
H-638refutedslow.p3s4.cycles < slow.p2s5.cycles AND fast.p2s5.cycles < fast.p3s4.cycles2.50465249c2529
statement
The order-3, four-stage archive cell has lower cycle cost than the order-2, five-stage cell under the slow cost model.
mechanism
Its coefficients should admit sparser shift-add implementations that avoid more iterative multiplications despite the higher order.
control
Under the fast cost model, the order-2, five-stage cell should instead have lower cycle cost because multiplication is cheap and its extra stage dominates.
min_samples
20
H-616refutedfast.p2s6.search < fast.p3s5.search AND slow.p3s5.search < slow.p2s6.search0.460984114c2505
statement
The order-2, six-stage archive cell does better than the order-3, five-stage cell on search error under the fast cost model.
mechanism
The fast cost model favors the lower-order cell's cheaper arithmetic enough for its additional stage to improve search optimization.
control
Under the slow cost model, the order-3, five-stage cell should instead have lower search error if cost-model-specific arithmetic pricing drives the reversal.
min_samples
20
H-614refutedavr_approx.p2s3.cycles < avr_approx.p2s2.cycles AND fast.p2s2.cycles < fast.p2s3.cycles14.8226333c2503
statement
The order-2, three-stage archive cell has lower cycle cost than the order-2, two-stage cell under the AVR-approximate cost model.
mechanism
The AVR-approximate model can favor the three-stage cell when its coefficients require fewer expensive fixed-point operations despite the extra stage.
control
Under the fast cost model, the two-stage cell should retain lower cycle cost if AVR-specific arithmetic costs cause the inversion.
min_samples
30
H-609refutedavr_approx.p2s4.cycles < avr_approx.p3s4.cycles AND slow.p3s4.cycles < slow.p2s4.cycles0.817317280c2497
statement
The order-2, four-stage archive cell has lower cycle cost than the order-3, four-stage cell under the AVR-approximate cost model.
mechanism
AVR-weighted arithmetic costs should favor the simpler order-2 coefficient structure despite equal stage count.
control
If coefficient-arithmetic complexity drives the advantage, the order-3, four-stage cell should instead have lower cycle cost under the slow model.
min_samples
20
H-608refutedavr_approx.p3s3.cycles < avr_approx.p3s4.cycles AND fast.p3s4.cycles < fast.p3s3.cycles7.240764933c2496
statement
The order-3, three-stage archive cell has lower cycle cost than the order-3, four-stage cell under the AVR-approximate cost model.
mechanism
The AVR-like instruction mix makes the additional stage's arithmetic and state-update overhead outweigh any scheduling benefit.
control
Under the fast cost model, the order-3, four-stage cell should instead have lower cycle cost if this mechanism is real.
min_samples
20
H-601refutedavr_approx.p2s5.cycles < avr_approx.p3s5.cycles AND fast.p3s5.cycles < fast.p2s5.cycles0.255643249c2488
statement
The order-2, five-stage archive cell has lower cycle cost than the order-3, five-stage cell under the AVR-approximate cost model.
mechanism
At equal stage count, the lower-order tableau requires fewer fixed-point arithmetic operations and therefore fewer AVR cycles.
control
Under the fast cost model, the order-3, five-stage cell should instead have lower cycle cost if AVR-specific instruction weighting causes the reversal.
min_samples
30
H-599refutedfast.p2s6.cycles < fast.p3s6.cycles AND slow.p3s6.cycles < slow.p2s6.cycles1.97482114c2486
statement
The order-2, six-stage archive cell has lower cycle cost than the order-3, six-stage cell under the fast cost model.
mechanism
At equal stage count, the fast model favors the simpler order-2 tableau because its arithmetic dependency structure incurs less fixed-point overhead.
control
Under the slow cost model, the order-3, six-stage cell should instead have lower cycle cost if model-specific operation weights drive the reversal.
min_samples
30
H-596refutedfast.p3s4.cycles < fast.p3s6.cycles AND slow.p3s6.cycles < slow.p3s4.cycles3.2805440223c2483
statement
The order-3, four-stage archive cell has lower cycle cost than the order-3, six-stage cell under the fast cost model.
mechanism
The fast cost model should favor the four-stage cell because its two fewer stages reduce arithmetic and quantization overhead.
control
Under the slow cost model, the six-stage cell should instead have lower cycle cost if model-specific arithmetic weighting causes the reversal.
min_samples
20
H-593refutedavr_approx.p2s4.search < avr_approx.p2s2.search AND fast.p2s2.search < fast.p2s4.search0.574498280c2479
statement
The order-2, four-stage archive cell does better than the order-2, two-stage cell on search error under the AVR-approximate cost model.
mechanism
AVR-like instruction costs favor the four-stage cell's numerical efficiency despite its additional stages.
control
Under the fast cost model, the order-2, two-stage cell should instead have lower search error if the mechanism is real.
min_samples
20
H-589refutedslow.p2s2.cycles < slow.p2s4.cycles AND fast.p2s4.cycles < fast.p2s2.cycles9.33872280c2475
statement
The order-2, two-stage archive cell has lower cycle cost than the order-2, four-stage cell under the slow cost model.
mechanism
The slow cost model disproportionately rewards the shorter dependency chain of the two-stage method.
control
Under the fast cost model, the order-2, four-stage cell should instead have lower cycle cost if the mechanism is real.
min_samples
20
H-582refutedavr_approx.p3s6.search < avr_approx.p2s2.search AND fast.p2s2.search < fast.p3s6.search0.2218610940c2467
statement
The order-3, six-stage archive cell does better than the order-2, two-stage cell on search error under the AVR-approximate cost model.
mechanism
The additional stages improve fixed-point stability enough to offset their AVR-weighted execution cost during search.
control
Under the fast cost model, the order-2, two-stage cell should instead have lower search error if AVR-specific stage costs drive the reversal.
min_samples
30
H-581refutedavr_approx.p3s3.cycles < avr_approx.p3s5.cycles AND fast.p3s5.cycles < fast.p3s3.cycles10.09694933c2466
statement
The order-3, three-stage archive cell has lower cycle cost than the order-3, five-stage cell under the AVR-approximate cost model.
mechanism
AVR-like instruction costs penalize the extra fixed-point stage operations enough to favor the shorter tableau.
control
Under the fast cost model, the five-stage cell should instead have lower cycle cost if cost-model-specific archive selection drives the reversal.
min_samples
20
H-580refutedslow.p2s3.search < slow.p3s3.search AND fast.p3s3.search < fast.p2s3.search0.401783333c2465
statement
The order-2, three-stage archive cell does better than the order-3, three-stage cell on search error under the slow cost model.
mechanism
Slow arithmetic amplifies fixed-point rounding in the higher-order tableau enough to outweigh its truncation-error advantage.
control
Under the fast cost model, the order-3, three-stage cell should instead have lower search error if rounding sensitivity causes the reversal.
min_samples
30
H-579refutedslow.p2s6.search < slow.p2s4.search AND fast.p2s4.search < fast.p2s6.search0.465179114c2464
statement
The order-2, six-stage archive cell does better than the order-2, four-stage cell on search error under the slow cost model.
mechanism
Sparse quantized coefficients let the six-stage method replace enough expensive multiplications with shift-add operations to offset its extra stages.
control
Under the fast cost model, the four-stage cell should regain the advantage because its smaller stage count matters more when multiplication is cheap.
min_samples
30

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

inconclusive (20 predicates) effect size under 0.2, or a named cell with no records
idverdictpredicatedncycle
H-709inconclusiveavr_approx.p3s4.search < avr_approx.p3s5.search AND fast.p3s5.search < fast.p3s4.search0.0098871421300c2608
statement
The order-3, four-stage archive cell does better than the order-3, five-stage cell on search error under the AVR-approximate cost model.
mechanism
The AVR-approximate model favors the shorter stage pipeline because its reduced quantized arithmetic exposure limits accumulated floor-rounding bias.
control
Under the fast cost model, the five-stage cell should instead achieve lower search error if the reversal is caused by AVR-specific quantization costs.
min_samples
20
H-411 ×8inconclusiveavr_approx.p3s6.search < avr_approx.p3s5.search AND fast.p3s5.search < fast.p3s6.search0.04563821087c2604
statement
The order-3, six-stage archive cell does better than the order-3, five-stage cell on search error under the AVR-approximate cost model.
mechanism
The AVR-approximate cost model rewards the six-stage cell's additional truncation-error reduction enough to offset its extra stage cost.
control
Under the fast cost model, the five-stage cell should instead have lower search error if AVR-specific stage costing drives the reversal.
min_samples
20
posed as
H-411, H-430, H-436, H-438, H-482, H-560, H-690, H-705
H-266 ×5inconclusivefast.p3s6.heldout < fast.p2s6.heldout AND slow.p2s6.heldout < slow.p3s6.heldout0.0644114114c2577
statement
The order-3, six-stage archive cell does better than the order-2, six-stage cell on held-out error under the fast cost model.
mechanism
At equal stage count, the fast cost model makes the third-order constraints improve truncation error without imposing an additional cycle penalty.
control
Under the slow cost model, the order-2, six-stage cell should instead have lower held-out error if implementation overhead reverses the advantage.
min_samples
114
posed as
H-266, H-315, H-357, H-367, H-681
H-409 ×26inconclusiveslow.p3s5.search < slow.p3s4.search AND fast.p3s4.search < fast.p3s5.search0.01329519549c2574
statement
The order-3, five-stage archive cell does better than the order-3, four-stage cell on search error under the slow cost model.
mechanism
The extra stage improves fixed-point error suppression enough to outweigh its added cost when slow arithmetic governs selection.
control
Under the fast cost model, the order-3, four-stage cell should instead have lower search error if the cost-dependent mechanism is real.
min_samples
20
posed as
H-409, H-413, H-416, H-417, H-420, H-421, H-444, H-446, H-447, H-448, H-451, H-453, H-456, H-463, H-465, H-475, H-477, H-483, H-485, H-491, H-499, H-514, H-538, H-559, H-620, H-678
H-412 ×15inconclusiveslow.p3s5.search < slow.p3s6.search AND fast.p3s6.search < fast.p3s5.search0.040271419270c2569
statement
The order-3, five-stage archive cell does better than the order-3, six-stage cell on search error under the slow cost model.
mechanism
The slow model makes the sixth stage sufficiently expensive that the five-stage method can allocate more effective integration work within the fixed cost budget.
control
Under the fast cost model, the six-stage cell should instead have lower search error if stage-cost sensitivity causes the reversal.
min_samples
20
posed as
H-412, H-422, H-423, H-464, H-470, H-487, H-488, H-504, H-532, H-561, H-563, H-564, H-586, H-613, H-674
H-459 ×8inconclusivefast.p3s5.search < fast.p3s4.search AND slow.p3s4.search < slow.p3s5.search0.012642419040c2565
statement
The order-3, five-stage archive cell does better than the order-3, four-stage cell on search error under the fast cost model.
mechanism
When arithmetic is cheap, the fifth stage provides enough additional trajectory correction to outweigh its rounding and evaluation overhead.
control
Under the slow cost model, the order-3, four-stage cell should instead have lower search error because the extra stage consumes too much of the cost budget.
min_samples
30
posed as
H-459, H-472, H-585, H-602, H-603, H-605, H-618, H-670
H-571 ×6inconclusiveslow.p2s5.cycles < slow.p3s5.cycles AND fast.p3s5.cycles < fast.p2s5.cycles0.103043249c2504
statement
The order-2, five-stage archive cell has lower cycle cost than the order-3, five-stage cell under the slow cost model.
mechanism
At equal stage count, the order-2 method's simpler fixed-point coefficient arithmetic reduces cycle cost when arithmetic operations are weighted heavily.
control
Under the fast cost model, the order-3, five-stage cell should have lower cycle cost if the advantage is specifically caused by slow fixed-point arithmetic.
min_samples
249
posed as
H-571, H-572, H-573, H-578, H-583, H-615
H-584inconclusiveslow.p2s6.search < slow.p2s3.search AND fast.p2s3.search < fast.p2s6.search0.0269721114c2469
statement
The order-2, six-stage archive cell does better than the order-2, three-stage cell on search error under the slow cost model.
mechanism
The extra stages enlarge the usable stability region enough to reduce quantized trajectory error when arithmetic is costly and rounding-sensitive.
control
Under the fast cost model, the three-stage cell should instead have lower search error if the advantage is caused by the slow-cost stability tradeoff.
min_samples
30
H-381 ×13inconclusiveslow.p3s6.search < slow.p3s5.search AND fast.p3s5.search < fast.p3s6.search0.041177715940c2454
statement
The order-3, six-stage archive cell does better than the order-3, five-stage cell on search error under the slow cost model.
mechanism
The slow model rewards the six-stage cell's greater truncation-error suppression enough to offset its additional stage cost.
control
Under the fast cost model, the five-stage cell should have lower search error because its lower stage overhead dominates.
min_samples
20
posed as
H-381, H-383, H-391, H-395, H-397, H-433, H-455, H-457, H-484, H-489, H-492, H-528, H-570
H-542 ×5inconclusivefast.p2s3.cycles < fast.p3s3.cycles AND slow.p3s3.cycles < slow.p2s3.cycles0.0317479296c2432
statement
The order-2, three-stage archive cell does better than the order-3, three-stage cell on cycle cost under the fast cost model.
mechanism
At equal stage count, enforcing third-order conditions adds arithmetic overhead that the fast cost model exposes.
control
If this mechanism is cost-model-specific, the order-3, three-stage cell should have lower cycle cost under the slow cost model.
min_samples
20
posed as
H-542, H-543, H-546, H-549, H-550
H-460 ×5inconclusiveslow.p3s4.search < slow.p3s5.search AND fast.p3s5.search < fast.p3s4.search0.0096446915733c2388
statement
The order-3, four-stage archive cell does better than the order-3, five-stage cell on search error under the slow cost model.
mechanism
Expensive fixed-point multiplications make the fifth stage consume budget without enough rounding-error reduction to offset the reduced search depth.
control
Under the fast cost model, the five-stage cell should instead beat the four-stage cell because its extra stage is comparatively inexpensive.
min_samples
20
posed as
H-460, H-462, H-469, H-471, H-511
H-410 ×7inconclusiveavr_approx.p3s5.search < avr_approx.p3s4.search AND fast.p3s4.search < fast.p3s5.search0.0090110615676c2382
statement
The order-3, five-stage archive cell does better than the order-3, four-stage cell on search error under the AVR-approximate cost model.
mechanism
AVR-weighted operation costs let the extra stage reduce discretization error enough to offset its added work.
control
Under the fast cost model, the order-3, four-stage cell should instead have lower search error if the advantage is cost-model-specific.
min_samples
20
posed as
H-410, H-418, H-450, H-466, H-473, H-474, H-505
H-289 ×10inconclusivefast.p3s6.search < fast.p3s5.search AND slow.p3s5.search < slow.p3s6.search0.040632115580c2373
statement
The order-3, six-stage archive cell has lower search error than the order-3, five-stage cell under the fast cost model.
mechanism
The fast cost model rewards the additional stage's optimization flexibility enough to offset its execution cost.
control
If this mechanism is real, the five-stage cell should have lower search error under the slow cost model, where the extra stage is more heavily penalized.
min_samples
30
posed as
H-289, H-382, H-388, H-401, H-428, H-439, H-449, H-454, H-458, H-497
H-467inconclusiveslow.p2s2.search < slow.p2s3.search AND fast.p2s3.search < fast.p2s2.search0.0840826103c1226
statement
The order-2, two-stage archive cell does better than the order-2, three-stage cell on search error under the slow cost model.
mechanism
Charging expensive fixed-point stage arithmetic under the slow model favors the two-stage method despite its lower per-step accuracy.
control
Under the fast cost model, the three-stage cell should instead achieve lower search error because its additional stage is less costly.
min_samples
30
H-239 ×4inconclusivefast.p3s6.search < fast.p3s4.search AND slow.p3s4.search < slow.p3s6.search0.038941330220c1163
statement
The order-3, six-stage archive cell does better than the order-3, four-stage cell on search error under the fast cost model.
mechanism
The fast cost model rewards the six-stage method's greater optimization flexibility enough to offset its additional stage cost.
control
If this mechanism is real, the order-3, four-stage cell should beat the six-stage cell on search error under the slow cost model.
min_samples
30
posed as
H-239, H-380, H-398, H-429
H-310 ×18inconclusiveavr_approx.p3s6.heldout < avr_approx.p2s6.heldout AND fast.p2s6.heldout < fast.p3s6.heldout0.0607814114c1105
statement
The order-3, six-stage archive cell does better than the order-2, six-stage cell on held-out error under the AVR-approximate cost model.
mechanism
At equal stage count, third-order accuracy should outweigh its extra shift-add overhead when AVR-like constant multiplication is modeled.
control
Under the fast cost model, the order-2, six-stage cell should instead have lower held-out error if the reversal is genuinely cost-model driven.
min_samples
30
posed as
H-310, H-312, H-316, H-317, H-328, H-330, H-332, H-335, H-336, H-354, H-359, H-362, H-370, H-371, H-374, H-375, H-376, H-377
H-351 ×2inconclusiveslow.p3s6.search < slow.p3s4.search AND fast.p3s4.search < fast.p3s6.search0.029237626776c1087
statement
The order-3, six-stage archive cell does better than the order-3, four-stage cell on search error under the slow cost model.
mechanism
The slow model rewards the six-stage cell's greater opportunity to distribute fixed-point approximation error across stages.
control
Under the fast cost model, the four-stage cell should instead have lower search error because its smaller stage count reduces execution-cost pressure.
min_samples
30
posed as
H-351, H-361
H-263 ×9inconclusiveavr_approx.p2s6.heldout < avr_approx.p3s6.heldout AND fast.p3s6.heldout < fast.p2s6.heldout0.062365114c1036
statement
The order-2, six-stage archive cell does better than the order-3, six-stage cell on held-out error under the AVR-approximate cost model.
mechanism
AVR-specific instruction costs favor the order-2 tableau's simpler fixed-point implementation enough to offset its lower formal order.
control
Under the fast cost model, the order-3, six-stage cell should instead have lower held-out error if AVR-specific implementation cost drives the reversal.
min_samples
30
posed as
H-263, H-270, H-279, H-285, H-319, H-321, H-326, H-331, H-334
H-251 ×17inconclusiveslow.p3s6.heldout < slow.p2s6.heldout AND fast.p2s6.heldout < fast.p3s6.heldout0.0639731114c1004
statement
The order-3, six-stage archive cell does better than the order-2, six-stage cell on held-out error under the slow cost model.
mechanism
With stage count fixed, the slow model rewards the order-3 cell's greater accuracy enough to offset its added computational complexity.
control
Under the fast cost model, the order-2, six-stage cell should instead have lower held-out error if the mechanism is real.
min_samples
30
posed as
H-251, H-255, H-256, H-258, H-259, H-268, H-273, H-275, H-282, H-283, H-284, H-290, H-291, H-296, H-299, H-301, H-305
H-262 ×4inconclusivefast.p2s6.heldout < fast.p3s6.heldout AND slow.p3s6.heldout < slow.p2s6.heldout0.0642983114c984
statement
The order-2, six-stage archive cell does better than the order-3, six-stage cell on held-out error under the fast cost model.
mechanism
At equal stage count, the fast model rewards the order-2 cell's greater coefficient freedom and lower cycle burden, allowing better tuning against fixed-point error.
control
Under the slow cost model, the order-3, six-stage cell should instead achieve lower held-out error if the reversal is genuinely cost-model driven.
min_samples
30
posed as
H-262, H-269, H-271, H-287
open (160 predicates) waiting for min_samples in at least one named cell
idverdictpredicatedncycle
H-712openavr_approx.p4s5.cycles < avr_approx.p2s3.cycles AND fast.p2s3.cycles < fast.p4s5.cyclesn/an/ac3930+
statement
The order-4, five-stage archive cell has lower cycle cost than the order-2, three-stage cell under the AVR-approximate cost model.
mechanism
The higher-order cell should need fewer quantized step-control retries, offsetting its greater per-step stage cost on AVR-like arithmetic.
control
Under the fast cost model, the simpler order-2, three-stage cell should retain lower cycle cost if AVR-specific retry reduction drives the advantage.
min_samples
20
H-711openavr_approx.p2s2.cycles < avr_approx.p4s5.cycles AND slow.p4s5.cycles < slow.p2s2.cyclesn/an/ac2610+
statement
The order-2, two-stage archive cell has lower cycle cost than the order-4, five-stage cell under the AVR-approximate cost model.
mechanism
The AVR-approximate model amplifies the cycle advantage of executing fewer stages and less coefficient arithmetic.
control
Under the slow cost model, the order-4, five-stage cell should instead have lower cycle cost if model-specific arithmetic overhead drives the reversal.
min_samples
20
H-710openavr_approx.p3s3.cycles < avr_approx.p4s5.cycles AND slow.p4s5.cycles < slow.p3s3.cyclesn/an/ac2609+
statement
The order-3, three-stage archive cell has lower cycle cost than the order-4, five-stage cell under the AVR-approximate cost model.
mechanism
The AVR-approximate model magnifies the cycle savings from evaluating two fewer stages despite the lower-order cell's potentially less favorable convergence behavior.
control
Under the slow cost model, the order-4, five-stage cell should instead have lower cycle cost if improved convergence outweighs its extra stages.
min_samples
20
H-708openslow.p4s5.cycles < slow.p2s6.cycles AND fast.p2s6.cycles < fast.p4s5.cyclesn/an/ac2607+
statement
The order-4, five-stage archive cell has lower cycle cost than the order-2, six-stage cell under the slow cost model.
mechanism
The slow model amplifies per-stage evaluation overhead, allowing the five-stage method's reduced stage count to outweigh its higher-order coefficient complexity.
control
Under the fast cost model, the simpler order-2 coefficients should instead give the six-stage cell lower cycle cost.
min_samples
20
H-707openslow.p4s5.cycles < slow.p3s3.cycles AND fast.p3s3.cycles < fast.p4s5.cyclesn/an/ac2606+
statement
The order-4, five-stage archive cell has lower cycle cost than the order-3, three-stage cell under the slow cost model.
mechanism
The slow model rewards coefficients and stage layouts that reduce expensive fixed-point operations enough to offset the two additional stages.
control
Under the fast cost model, the order-3, three-stage cell should have lower cycle cost because its smaller stage count dominates.
min_samples
20
H-706openavr_approx.p4s5.search < avr_approx.p2s6.search AND fast.p2s6.search < fast.p4s5.searchn/an/ac2605+
statement
The order-4, five-stage archive cell does better than the order-2, six-stage cell on search error under the AVR-approximate cost model.
mechanism
The AVR instruction weighting favors the five-stage order-4 coefficient structure enough to offset its greater order-compliance cost.
control
Under the fast cost model, the order-2, six-stage cell should instead have lower search error if the mechanism is real.
min_samples
20
H-703openavr_approx.p4s5.cycles < avr_approx.p3s6.cycles AND fast.p3s6.cycles < fast.p4s5.cyclesn/an/ac2602+
statement
The order-4, five-stage archive cell has lower cycle cost than the order-3, six-stage cell under the AVR-approximate cost model.
mechanism
Its shorter stage sequence and quantization-friendly coefficients should reduce AVR instruction and memory costs despite its higher order.
control
Under the fast cost model, the order-3, six-stage cell should instead have lower cycle cost if the advantage is AVR-specific.
min_samples
20
H-702openavr_approx.p3s6.cycles < avr_approx.p4s6.cycles AND fast.p4s6.cycles < fast.p3s6.cyclesn/an/ac2600+
statement
The order-3, six-stage archive cell has lower cycle cost than the order-4, six-stage cell under the AVR-approximate cost model.
mechanism
At equal stage count, the order-3 cell should require fewer or cheaper fixed-point coefficient operations under AVR-like constant-specific costing.
control
Under the fast-multiplier cost model, the order-4 cell should instead have lower cycle cost if coefficient-specific arithmetic is driving the reversal.
min_samples
30
H-701openslow.p4s5.cycles < slow.p2s2.cycles AND fast.p2s2.cycles < fast.p4s5.cyclesn/an/ac2599+
statement
The order-4, five-stage archive cell has lower cycle cost than the order-2, two-stage cell under the slow cost model.
mechanism
Shift-add-friendly coefficients and reusable partial products let the five-stage method avoid enough iterative multiplications to offset its extra stages.
control
Under the fast cost model, the order-2, two-stage cell should regain the cycle-cost advantage because multiplication is cheap and stage overhead dominates.
min_samples
20
H-699openfast.p4s4.cycles < fast.p4s5.cycles AND slow.p4s5.cycles < slow.p4s4.cyclesn/an/ac2597+
statement
The order-4, four-stage archive cell has lower cycle cost than the order-4, five-stage cell under the fast cost model.
mechanism
With multiplication cheap, the four-stage method benefits primarily from executing one fewer stage despite any coefficient-encoding advantages of the five-stage method.
control
Under the slow cost model, the five-stage cell should have lower cycle cost if its coefficients permit sufficiently cheaper shift-add implementations.
min_samples
30
H-698openfast.p4s5.search < fast.p4s6.search AND slow.p4s6.search < slow.p4s5.searchn/an/ac2596+
statement
The order-4, five-stage archive cell does better than the order-4, six-stage cell on search error under the fast cost model.
mechanism
Single-cycle multiplication makes the five-stage cell's lower stage overhead more important than coefficient-specific shift-add savings available to the six-stage cell.
control
Under the slow cost model, the order-4, six-stage cell should beat the order-4, five-stage cell on search error if the mechanism is real.
min_samples
20
H-693openfast.p4s5.search < fast.p3s6.search AND slow.p3s6.search < slow.p4s5.searchn/an/ac2590+
statement
The order-4, five-stage archive cell does better than the order-3, six-stage cell on search error under the fast cost model.
mechanism
The fast model rewards the five-stage method's lower stage overhead while its extra order reduces truncation error.
control
Under the slow cost model, the order-3, six-stage cell should instead have lower search error if stage-cost sensitivity causes the reversal.
min_samples
20
H-692openslow.p4s5.search < slow.p3s6.search AND fast.p3s6.search < fast.p4s5.searchn/an/ac2589+
statement
The order-4, five-stage archive cell does better than the order-3, six-stage cell on search error under the slow cost model.
mechanism
The slow model rewards the five-stage order-4 cell's truncation accuracy enough to outweigh the six-stage order-3 cell's additional fixed-point work.
control
Under the fast cost model, the order-3, six-stage cell should instead have lower search error if cost-sensitive stage execution causes the reversal.
min_samples
30
H-691openavr_approx.p4s5.search < avr_approx.p3s3.search AND fast.p3s3.search < fast.p4s5.searchn/an/ac2588+
statement
The order-4, five-stage archive cell does better than the order-3, three-stage cell on search error under the AVR-approximate cost model.
mechanism
The AVR-approximate cycle weighting should reward the five-stage cell's extra coefficient freedom enough to offset its additional quantized stage operations.
control
Under the fast cost model, the order-3, three-stage cell should instead have lower search error if this cost-model-specific mechanism is real.
min_samples
30
H-689openfast.p4s5.heldout < fast.p3s3.heldout AND slow.p3s3.heldout < slow.p4s5.heldoutn/an/ac2586+
statement
The order-4, five-stage archive cell does better than the order-3, three-stage cell on held-out error under the fast cost model.
mechanism
The extra stages and higher order reduce truncation error enough to outweigh fixed-point perturbations when the fast model rewards the resulting implementation.
control
Under the slow cost model, the order-3, three-stage cell should instead have lower held-out error if the advantage is cost-model-driven.
min_samples
20
H-688openfast.p4s5.search < fast.p3s3.search AND slow.p3s3.search < slow.p4s5.searchn/an/ac2585+
statement
The order-4, five-stage archive cell does better than the order-3, three-stage cell on search error under the fast cost model.
mechanism
The fast cost model makes the five-stage cell's extra order and optimization freedom more valuable than its added stage cost.
control
Under the slow cost model, the order-3, three-stage cell should instead have lower search error if stage-cost sensitivity causes the reversal.
min_samples
30
H-687openslow.p4s5.heldout < slow.p3s3.heldout AND fast.p3s3.heldout < fast.p4s5.heldoutn/an/ac2584+
statement
The order-4, five-stage archive cell does better than the order-3, three-stage cell on held-out error under the slow cost model.
mechanism
The slow cost model rewards the additional stages that let the fourth-order method reduce truncation error despite its greater computational burden.
control
If this mechanism is real, the order-3, three-stage cell should beat the order-4, five-stage cell under the fast cost model.
min_samples
30
H-686openfast.p4s5.heldout < fast.p3s6.heldout AND slow.p3s6.heldout < slow.p4s5.heldoutn/an/ac2583+
statement
The order-4, five-stage archive cell does better than the order-3, six-stage cell on held-out error under the fast cost model.
mechanism
The fast cost model favors the higher-order five-stage method's accuracy per unit cost over the extra stage of the lower-order method.
control
Under the slow cost model, the order-3, six-stage cell should instead have lower held-out error if the mechanism is real.
min_samples
20
H-685openavr_approx.p4s5.heldout < avr_approx.p3s6.heldout AND fast.p3s6.heldout < fast.p4s5.heldoutn/an/ac2582+
statement
The order-4, five-stage archive cell does better than the order-3, six-stage cell on held-out error under the AVR-approximate cost model.
mechanism
AVR-like instruction costs favor the five-stage order-4 method's higher accuracy per weighted stage over the six-stage order-3 method.
control
Under the fast cost model, the order-3, six-stage cell should instead have lower held-out error if the advantage is caused by AVR-specific costs.
min_samples
20
H-684openslow.p4s5.heldout < slow.p3s6.heldout AND fast.p3s6.heldout < fast.p4s5.heldoutn/an/ac2580+
statement
The order-4, five-stage archive cell does better than the order-3, six-stage cell on held-out error under the slow cost model.
mechanism
The slow cost model should reward the higher-order five-stage method's accuracy enough to offset the six-stage third-order method's extra evaluation capacity.
control
Under the fast cost model, the order-3, six-stage cell should instead have lower held-out error.
min_samples
20

140 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 2600 written 2026-09-08 21:06 CT

The archive remains sparse despite 2,599 cycles and a stall counter of 569. Order 2 has the broadest coverage, with 8 of 40 cells filled, compared with 6 of 32 for order 3 and 3 of 24 for order 4; no searchable order-1 cell is filled. Most occupied cells lie in buckets 1, 3, leaving the higher buckets unexplored. The lowest recorded held-out error is 2.862e-02 for the order-2, three-stage cell in bucket 1, followed by 3.766e-02 for the order-3, six-stage cell in bucket 3. Search error and held-out error are only weakly aligned: the latter cell has the best search error, 4.851e-03, while several candidates with similarly small search errors generalize substantially worse.

This mismatch is consistent with coefficient-specific quantization effects rather than a simple advantage from adding stages or increasing classical order. Floor rounding can accumulate directional bias, and individual tableaux can amplify or suppress that bias differently across trajectories. Extra stages also introduce more rounded intermediate values and more opportunities for error accumulation, so their theoretical approximation benefit need not survive fixed-point execution. The archive reflects this tension: the order-3, six-stage result is strong, but the corresponding five-stage cells are not clearly better than order-2 alternatives, and the available order-4 cells have held-out errors between roughly 6.0e-02 and 8.5e-02.

The recent sequence of observations also provides little support for clean cost-model crossovers based on order and stage count. Several comparisons involving order-2 and order-3 methods were resolved as refuted, including both error reversals and cycle-cost reversals across fast, slow, and AVR-approximate models. Some cycle comparisons have large effect sizes, while error comparisons are more moderate. This fits the literature digest: arithmetic precision, stage placement, rounding behavior, compiled instruction paths, memory traffic, and right-hand-side evaluation costs can vary independently. The mixed fixed-reference result and the different RK4 coefficient fractions under fast and slow models likewise suggest that hardware assumptions materially alter which coefficient patterns are favored.

Substantial uncertainty remains because most grid cells are empty, only best-in-cell summaries are shown, and the current search is stalled at the order-5-stage, bucket-2 cell. The next useful examinations are repeated held-out evaluation of the strongest order-2 three-stage and order-3 six-stage candidates, coefficient-level measures of rounding sensitivity and directional drift, and invariant or pseudo-energy drift over longer trajectories. Cycle comparisons would also benefit from compiled, hardware-appropriate measurements rather than stage-count proxies. Expanding coverage around the empty neighboring buckets and the entirely empty order-4 five-stage row would help distinguish genuine structural patterns from archive selection effects.

cycle 2575 written 2026-09-08 19:32 CT

The archive remains sparse and strongly concentrated in low-to-middle buckets: 17 of 136 searchable cells are filled, with no searchable order-1 entries and no entries above bucket 3. Order 2 has the broadest coverage, while orders 3 and 4 occupy progressively fewer stage, bucket combinations. The lowest held-out error is 2.862e-02 for the order-2, three-stage entry in bucket 1; the order-3, six-stage bucket-3 entry follows at 3.766e-02. More stages therefore do not produce a monotone improvement, and the current five-stage bucket-3 target remains empty despite the long run and a stall counter of 544.

The populated cells show a persistent gap between search and held-out error. One of the sharpest examples is the order-3, six-stage bucket-3 entry, whose search error is 4.851e-03 but held-out error is 3.766e-02; the order-2, four-stage bucket-2 entry similarly moves from 7.239e-03 to 5.865e-02. This is consistent with coefficient choices fitting the search cases more closely than unseen cases, with quantization buckets, stability constraints, and stage interactions limiting transfer. Cycle cost also generally rises with stage count, although its dependence on order and cost model is not simple enough to support model-independent rankings.

The recently resolved hypotheses reinforce that qualification. Several proposed reversals between fast, slow, and AVR-approximate cost models were not observed, including comparisons across two versus three stages and across four, five, and six stages. Effect sizes range from modest to very large, but the sample counts vary from 114 to 4,933, so the archive supports some contrasts much more densely than others. This pattern is compatible with the literature digest’s general emphasis on hardware-aware Runge, Kutta tradeoffs: arithmetic structure, coefficient representation, and target architecture can matter alongside formal order and stage count, while simple expectations about higher order or additional stages need not predict realized error or cost.

Substantial uncertainty remains because most cells are empty, order 1 appears only outside the searchable stage range, and the search is currently stalled. The fixed-reference result is mixed, with the RK4 coefficient fraction changing from about 0.559 under the fast model to 0.362 under the slow model and a reported crossover at h = 0.15625; this suggests that conclusions may depend on workload scale as well as cost assumptions. Useful next examinations include repeated held-out evaluation of the best occupied cells, analysis of why the search-to-held-out gap is so large, targeted attempts to populate the empty five-stage and higher-bucket cells, and sensitivity checks around the crossover step size and the coefficient quantization boundaries.

cycle 2550 written 2026-09-08 18:00 CT

The archive is sparse and strongly concentrated in low-to-middle cost buckets: 17 of 136 searchable cells are filled, with no searchable order-1 entries and no occupied buckets above b3. Order 2 has the broadest coverage, while orders 3 and 4 become progressively thinner. The best held-out error is 2.862e-02 for the three-stage, order-2 entry, followed by 3.766e-02 for the six-stage, order-3 entry. Increasing stage count or formal order does not produce a monotone improvement: some candidates have low search error but substantially worse held-out error, especially the order-3 six-stage b3 entry, whose search error is 4.851e-03 but held-out error is 3.766e-02.

This pattern is consistent with a tradeoff among approximation quality, quantized coefficients, and execution cost. Additional stages enlarge the coefficient search space and can reduce error on the search workload, but they also add cycles and more opportunities for fixed-point rounding or workload-specific fitting. The gap between search and held-out error in several cells suggests that search optimization is not always transferring cleanly. Cycle counts generally rise with stage count, although bucket placement and cost-model details complicate direct comparisons.

The recent hypothesis observations reinforce that these tradeoffs are cost-model dependent rather than simple stage-count rules. Several proposed reversals between fast, slow, and AVR-approximate models were refuted, with effect sizes ranging from modest to very large. Together with the literature-digest reference result, mixed falsification, RK4 coefficient fractions of about 0.56 under the fast model and 0.36 under the slow model, and a crossover near h = 0.15625, the archive fits the familiar expectation that implementation details and step size can change which method looks preferable. It does not support treating formal order, stage count, or one cost model as a universal proxy for practical performance.

The main uncertainty is coverage. The stall counter is 519, the current five-stage b3 region remains empty for orders 1 and 4, and most buckets have no representative, so the visible frontier may reflect search reachability as much as underlying method quality. Next examinations should distinguish genuine infeasibility from search failure, repeat the strongest entries across workloads and fixed-point formats, and map error around the reported step-size crossover. It would also be useful to investigate why the order-2 three-stage candidate generalizes best despite its small stage count, and why some very low search-error candidates show comparatively large held-out degradation.

cycle 2525 written 2026-09-08 16:27 CT

The archive remains sparse and strongly concentrated in low-to-middle cost buckets. Order two occupies 8 of 40 searchable cells, order three 6 of 32, and order four only 3 of 24; order one has no searchable entries, although one result exists outside the stage range. The best held-out value is 2.862e-02 for the three-stage, order-two entry, followed by 3.766e-02 for the six-stage, order-three entry. Additional stages therefore do not produce a monotone improvement: they sometimes reduce search error, but held-out performance varies irregularly and can worsen substantially.

A persistent gap between search and held-out error suggests that selection on the search workload is a major mechanism shaping the archive. The six-stage, order-three entry is the clearest example, with search error 4.851e-03 but held-out error 3.766e-02; several other cells show still larger proportional gaps. Stage count also raises cycle cost broadly, while fixed-point quantization and coefficient structure can change both approximation error and execution cost enough to disrupt simple order-based rankings. The recent hypothesis outcomes reinforce this picture: several proposed reversals between cost models or neighboring order-stage combinations were not observed, including some with large standardized effects.

This pattern accords with the literature digest’s general expectation that classical Runge, Kutta order alone is not a reliable proxy for performance after coefficients are quantized and implementation costs are included. It also fits the fixed-reference result, whose mixed verdict, differing RK4-coefficient fractions under fast and slow models, and crossover at h = 0.15625 indicate workload-dependent tradeoffs rather than a single dominant construction. The current archive offers more support for interactions among stage count, cost model, step size, and generalization than for a uniform rule favoring higher order or more stages.

Substantial uncertainty remains because most cells are empty, the search has stalled for 494 cycles, and the current five-stage bucket-three cell is itself unfilled. Comparisons may consequently reflect uneven discovery as much as underlying feasibility, especially for order four and higher buckets. The next useful examinations are targeted attempts to populate nearby empty cells, repeated held-out evaluation of entries with unusually low search error, and direct coefficient-level comparisons around the h = 0.15625 crossover. It would also help to separate infeasible cells from cells that are merely hard to reach and to test whether the observed search-to-held-out gaps persist across additional workloads and fixed-point formats.

cycle 2500 written 2026-09-08 14:28 CT

The archive remains sparse and strongly concentrated in low-numbered buckets: 17 of 136 searchable cells are filled, with no searchable order-1 cells, eight order-2 cells, six order-3 cells, and three order-4 cells. The lowest held-out error is 2.862e-02 for the order-2, three-stage entry in bucket 1, followed by 3.766e-02 for order 3 with six stages in bucket 3. Search error and held-out error are not closely aligned: the latter entry has the best search error, 4.851e-03, but not the best held-out result, while several other cells show much larger gaps. This suggests that optimizing the search workload alone does not reliably predict performance on held-out cases.

More stages generally carry higher recorded cycle costs, but accuracy does not improve monotonically with either stage count or formal order. Order 2 with three stages does better than the populated two-, four-, five-, and six-stage order-2 cells on held-out error, whereas the strongest populated order-3 result occurs at six stages. The recent hypothesis records also show that several proposed cost-model crossovers were refuted, sometimes with large effect sizes, indicating that simple stage-count comparisons do not capture the observed ordering across fast, slow, and AVR-approximate multiplication models. Coefficient arithmetic, derivative work, controller overhead, and model-specific multiply latency can all change the balance.

The literature digest provides mechanisms for both the cost variability and the search-to-held-out gaps. Embedded pairs share stages, and FSAL methods can reuse a derivative after accepted steps, so nominal stage count can overstate steady-state work; rejected steps interrupt that reuse and make realized cost dependent on controller behavior. PI-style control can reduce step-size oscillation, while Q15 floor rounding introduces a systematic negative bias and small updates can disappear entirely through finite-precision stagnation. These effects plausibly produce method-specific failure regimes that are not summarized by formal order, stage count, or a single aggregate search score. The fixed reference crossover at h = 0.15625 and the differing RK4 coefficient fractions under fast and slow models further illustrate the sensitivity to arithmetic-cost assumptions.

Considerable uncertainty remains because most cells are empty, the search has stalled for 469 cycles, and the current order-1 target cell has no searchable representative. Comparisons are therefore conditional on a narrow and unevenly sampled archive, and some hypothesis records have far fewer samples than others. The most useful next examination would separate accepted and rejected steps, FSAL reuse rates, saturation events, vanished updates, and controller arithmetic by cell and cost model. Re-evaluating leading candidates across step sizes near the reference crossover, with alternative rounding modes and matched workloads, would help determine whether the observed rankings arise from truncation behavior, fixed-point bias, controller dynamics, or hardware cost assumptions.

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

Embedded RK pairs and fixed-point step control collected 2026-09-08 21:39 CT, cycle 2608

Bogacki, Shampine introduced an embedded 3(2) Runge, Kutta pair whose shared stages provide a third-order update and a second-order error estimate. The commonly used scheme has four stages and the earliest-same-as-last property, allowing the final derivative of an accepted step to be reused as the earliest derivative of the next step. Dormand and Prince constructed embedded 5(4) pairs with seven stages, emphasizing small principal fifth-order truncation terms and extended absolute-stability regions. These results show that nominal stage count alone does not determine recurring cost: derivative reuse, accepted-step rate, coefficient arithmetic, and stability-limited step size also matter. They therefore give no general ordering between the archive cells in H-703 through H-709 without cell-specific tableaux and cycle measurements.

  • Embedded pairs obtain two different-order solutions from shared stage derivatives.
  • Bogacki, Shampine 3(2) uses four stages and supports FSAL reuse after an accepted step.
  • Dormand, Prince 5(4) was designed for small principal fifth-order error terms and useful stability regions.
  • PI step controllers use current and previous normalized errors and can produce smoother step sequences than an elementary one-error controller.
  • Adaptive-controller formulas ordinarily contain powers, ratios, safety factors, clipping, and accept-or-reject decisions.
  • In Q15, coefficients and intermediate products require explicit scaling, narrowing, and saturation policies.
  • Floor rounding is asymmetric for signed values, so floating-point controller behavior cannot be assumed to survive direct Q15 translation.
  • Quantized step sizes can collapse multiple controller outputs to the same representable value and introduce deadbands or repeated decisions.

sources:

Budgeted low-precision RK and energy behavior collected 2026-09-08 21:05 CT, cycle 2600

Recent mixed-precision Runge, Kutta research treats arithmetic precision and stage evaluation placement as separate design variables. A 2026 study of Bogacki, Shampine 3(2) found that mixed precision can retain much of the high-precision accuracy, but low precision did not reduce the number of function evaluations enough to offset slower operations in the tested setting. Work on reduced-precision fixed-point ODE solvers also shows that rounding mode materially affects trajectory error: stochastic rounding outperformed deterministic round-to-nearest in the reported neuron-model experiments. Because floor rounding is directional rather than unbiased, classical order and stage count alone do not characterize its accumulated error.

Structure preservation introduces another axis beyond classical order. Explicit pseudo-energy-preserving RK schemes have been constructed with energy-preservation order higher than their classical order; tests reported smaller errors than same-order RK methods over moderately long Hamiltonian simulations. Thus, comparisons among four-, five-, and six-stage archive cells require coefficient-level measures of quantization sensitivity and invariant drift, not only nominal order. For cycle hypotheses, Arm identifies the Cortex-M0+ technical reference manual as the source for instruction timing, while Zephyr exposes direct cycle-difference measurements; measured compiled paths are therefore needed because equal stage counts need not imply equal instruction, memory-access, or right-hand-side costs.

  • Arithmetic precision and RK stage placement can be optimized independently.
  • Low precision does not automatically reduce function-evaluation count.
  • Rounding mode can materially change fixed-point ODE trajectory error.
  • Floor rounding can introduce systematic directional error.
  • Classical order does not determine energy-drift behavior.
  • Explicit RK coefficients can be selected for enhanced approximate energy preservation.
  • Stage count alone is insufficient to establish Cortex-M0+ cycle cost.
  • Cycle hypotheses should be checked on compiled code with hardware-appropriate timing measurements.

sources:

Cortex-M0+ fixed-point multiplication costs collected 2026-09-08 20:35 CT, cycle 2592

Arm documents two implementation-time multiplier choices for Cortex-M0+: a fast single-cycle array multiplier and a smaller 32-cycle iterative multiplier. Both execute MULS, which returns the low 32 bits of a 32-by-32-bit product. The core timing table lists register addition, subtraction, and immediate or register shifts as one-cycle instructions, while loads can take one or two cycles depending on the implementation. Consequently, a cost model that assigns one universal price to multiplication does not represent all Cortex-M0+ devices. For signed Q15 operands, the full product fits within 31 significant bits, so MULS followed by ASRS #15 can implement the usual arithmetic-shift floor scaling without needing a 64-bit product.

Constant multiplication can instead be expressed as shifts plus additions or subtractions. Canonical signed-digit encoding minimizes the number of nonzero signed digits, but it does not necessarily produce the shortest possible addition chain; adder-graph methods can reuse intermediate expressions and sometimes improve on direct CSD expansion. GCC explicitly distinguishes Cortex-M0/M0+/M1 targets with the small iterative multiplier and may replace multiplication with add/subtract/shift sequences. These findings support treating fast-multiplier, slow-multiplier, and constant-specific shift-add costs separately when comparing Runge-Kutta cells: stage count alone does not determine cycles, because coefficient encodings, reused partial products, constant materialization, scaling shifts, and register spills can materially change the arithmetic cost.

  • Cortex-M0+ offers either a one-cycle or a 32-cycle MULS implementation.
  • MULS returns the least-significant 32 bits of a 32-by-32-bit product.
  • Basic register adds, subtracts, and shifts are listed as one-cycle operations.
  • ASRS supplies sign-preserving right shifts suitable for floor-style power-of-two scaling.
  • A signed Q15-by-Q15 product fits in the available 32-bit MULS result.
  • CSD reduces nonzero signed digits but is not always the optimal addition chain.
  • Adder graphs can share partial products across several constant multiplications.
  • GCC has distinct small-multiplier Cortex-M0+ tuning that favors shift-add replacements.

sources:

Numerical optimization of Runge, Kutta tableaus collected 2026-09-08 20:06 CT, cycle 2584

Runge, Kutta design is naturally a constrained optimization problem: the Butcher coefficients must satisfy polynomial order conditions, while remaining degrees of freedom can optimize leading truncation-error norm, stability, SSP behavior, or storage. RK-Opt supports searches indexed by stage count and order, including minimization of the principal error norm. Its documentation stresses that coefficient optimization is highly nonconvex, so multistart searches can converge to different local solutions and do not automatically certify global optimality. Classical constructions likewise use free parameters and numerical searches to reduce error coefficients; Dormand and Prince’s search over a parameterized family is a documented example.

Extra stages can therefore improve a method even without raising its formal order, but neither order nor stage count alone determines realized error. Higher order suppresses truncation error asymptotically, whereas principal-error optimization addresses only the leading exact-arithmetic term. Internal-error research shows that roundoff or inexact stage computations can be amplified and that amplification depends strongly on the implementation. Consequently, the literature makes an order-4 five-stage advantage over order-2 or order-3 cells plausible in a truncation-dominated regime, but it does not establish H-682 or H-684 through H-687 under Q15 floor rounding and fixed cycle budgets; those comparisons require objectives or validation that explicitly include quantized coefficients, floor-rounded stage arithmetic, implementation form, and the applicable cost model.

  • Order conditions constrain tableau coefficients through nonlinear polynomial equalities.
  • Free parameters left after satisfying order conditions can be optimized for principal error, stability, SSP properties, or storage.
  • Adding stages can create useful design freedom without increasing formal order.
  • Principal error norm measures leading truncation terms, not total fixed-point execution error.
  • RK coefficient searches are highly nonconvex and commonly use many random or multistart solves.
  • Small error constants in exact arithmetic do not guarantee small error under Q15 floor rounding.
  • Internal perturbation amplification depends on the particular RK implementation, not only its Butcher tableau.
  • The cited theory does not by itself rank the specified archive cells under slow, AVR-approximate, or fast cycle models.

sources:

RK stability under fixed cycle budgets collected 2026-09-08 19:36 CT, cycle 2576

For an explicit Runge, Kutta method, linear stability is governed by a polynomial whose earliest coefficients are fixed by the requested order and whose remaining coefficients can enlarge the stability region. Recent work formulates method selection as maximizing the admissible step for the actual eigenvalue spectrum. Consequently, stage count and order alone do not establish superiority: a five-stage fourth-order method has fewer free stability-polynomial coefficients than a six-stage second-order method, while a four-stage third-order method can devote its extra coefficient to stability. Runge, Kutta, Chebyshev results show the limiting alternative for diffusion-like spectra: low-order stabilized explicit methods can obtain a negative-real stability interval proportional to the square of the stage count, although their applicability assumes spectra concentrated near the negative real axis. Internal amplification of roundoff is a separate constraint and becomes important in low precision.

Under a fixed cycle budget, the relevant comparison is stable simulated time and achieved error per cycle, not error per step. Extra stages pay when their larger stable step or higher-order accuracy compensates for fewer completed steps; optimized stability must also match whether the problem spectrum is real-negative or substantially complex. Implicit DIRK and ESDIRK methods provide stiffly accurate, L-stable formulas, but each implicit stage requires solving an algebraic system. They pay for themselves only when explicit stability restrictions would otherwise require enough additional steps to exceed those solve costs. That crossover moves against implicit methods on Cortex-M0+, where hardware division is absent and multiplication latency is implementation-dependent; fixed-point nonlinear solves also require convergence tests, scaling, and safeguards. For the stated comparisons, the literature therefore supports measuring spectrum-specific stability extent, internal roundoff amplification under Q15 floor rounding, and total cycles per accepted unit of simulated time alongside held-out error.

  • Explicit RK stability is determined by a degree-s stability polynomial constrained by order conditions.
  • At fixed stage count, higher order leaves fewer coefficients available for stability optimization.
  • A five-stage fourth-order stability polynomial has one coefficient beyond the required exponential terms.
  • A four-stage third-order stability polynomial likewise has one free stability coefficient.
  • A six-stage second-order polynomial has four coefficients beyond its order constraints.
  • RKC negative-real stability extent grows proportionally to the square of the stage count.
  • RKC theory targets spectra lying in a narrow strip around the negative real axis.
  • Stability-region area is less informative than containment of the scaled problem spectrum.

sources:

Quantized Runge, Kutta rounding and MCU fixed point collected 2026-09-08 19:06 CT, cycle 2568

Runge, Kutta error in low precision contains both discretization error and propagated arithmetic perturbations. General RK analysis shows that roundoff introduced at successive steps can accumulate globally, while reduced-precision analyses give a deterministic roundoff contribution proportional to u/h in addition to the method term h^p. Consequently, decreasing the step size or increasing formal order does not necessarily reduce total error once Q15 quantization dominates. Floor rounding is directed and introduces a non-positive error at every nonexact quantization, so its errors cannot be modeled as unbiased independent noise; repeated stage multiplications and state updates can create systematic drift.

Experiments with fixed-point neural ODE solvers found stochastic rounding more accurate than round-to-nearest fixed point and even binary32 for the studied neuron models and solvers. That work used a fixed-step, second-order Runge, Kutta variant optimized for fixed-point execution and reported that a small random residual was sufficient for stochastic rounding. Related Runge, Kutta heat-equation analysis found that implementation details affect error accumulation and that stochastic rounding can avoid stagnation, although random-number generation adds work and conflicts with a tightly deterministic cycle budget.

For Cortex-M implementations, Q15 stores 15 fractional bits in a signed 16-bit value and Q31 uses a signed 32-bit representation. Arm CMSIS-DSP supplies wider intermediate storage and both saturating and nonsaturating operations, making accumulator width, rescaling points, and saturation behavior part of the numerical method. A five- or six-stage RK cell has more potential quantization sites than a two-stage cell, but the resulting error depends on where values are narrowed and whether products are accumulated at wider precision. Thus formal order and stage count alone do not determine the comparisons in H-668, H-669, H-671, H-672, or H-673; they require evaluation with the exact floor-rounding schedule, scaling, overflow policy, and target instruction costs.

  • Deterministic low-precision RK error can contain an O(u/h) global component alongside O(h^p) discretization error.
  • Floor rounding is one-sided and can produce systematic drift rather than zero-mean roundoff.
  • More RK stages create more possible rounding and narrowing sites unless intermediates remain wide.
  • Stochastic rounding reduces bias and stagnation in published low-precision ODE experiments.
  • Random-number generation makes stochastic rounding unsuitable as a cost-free substitution under a fixed cycle budget.
  • Q15 spans -1 through 1-2^-15; scaling is therefore necessary for states, derivatives, or coefficients outside that interval.
  • Wider products and accumulators can materially change accuracy without changing the nominal Q15 state format.
  • Saturation, overflow, coefficient quantization, and the exact placement of right shifts must be included in method comparisons.

sources:

Production ODE integrator architecture collected 2026-09-08 18:37 CT, cycle 2560

SciPy’s default solve_ivp method, RK45, stores the state as a one-dimensional NumPy array and the stage derivatives in a contiguous matrix shaped (stages + 1, state dimension). Its embedded error vector is divided componentwise by atol + rtol·max(|y_old|, |y_new|), then reduced with an RMS norm. Defaults are rtol=1e-3 and atol=1e-6. The proportional step controller uses safety 0.9, permits factors from 0.2 to 10, and prevents immediate growth following a rejected step. Boost.Odeint instead templates its steppers over the state container, algebra, operations, resizer, error checker, and step adjuster. Its default checker scales each component by eps_abs + eps_rel·(a_x|x| + a_dxdt|dt·dx/dt|), with eps_abs=eps_rel=1e-6 and both scale coefficients equal to 1; controlled Runge, Kutta steppers own reusable derivative, output, and error buffers and reduce the scaled error through the selected algebra.

CVODE is not a Runge, Kutta implementation: it uses variable-order Adams, Moulton formulas for nonstiff systems or BDF formulas for stiff systems, together with solution-history vectors, predictor-corrector data, and abstract N_Vector storage supporting multiple backends. It applies a weighted RMS norm with weights 1/(rtol·|y_i|+atol_i). Its controller jointly selects step size and order, begins at order 1, uses a 1/6 safety factor in the local-error step calculation, normally caps growth at 10, and retries rejected steps with additional failure-dependent limits. These libraries therefore demonstrate that production adaptive solvers incur costs beyond tableau stages: full-vector stage or history storage, component scaling, squared-error accumulation, square roots, controller powers, rejection paths, and sometimes nonlinear solves. Their designs do not establish any of H-662 through H-666, which compare fixed-cycle, fixed-point archive cells; they instead identify operations that should be excluded, fixed, or explicitly charged when relating floating-point library behavior to a Q15 Cortex-M0+ cost model.

  • SciPy RK45 stores stage derivatives in a (stages + 1) by state-dimension NumPy array.
  • SciPy uses an RMS norm of the componentwise scaled embedded error.
  • SciPy RK defaults are rtol=1e-3, atol=1e-6, safety=0.9, minimum factor=0.2, and maximum factor=10.
  • Boost.Odeint abstracts state layout through container, algebra, operations, and resizer template parameters.
  • Boost’s default error scale includes both state magnitude and dt times derivative magnitude.
  • Boost default_error_checker defaults eps_abs and eps_rel to 1e-6 and both scale coefficients to 1.
  • CVODE uses Adams, Moulton or BDF multistep formulas, not Runge, Kutta tableaux.
  • CVODE represents vectors through the N_Vector abstraction and retains multistep history.

sources:

Embedded RK pairs and quantized step control collected 2026-09-08 18:08 CT, cycle 2552

Bogacki, Shampine 3(2) uses four stages and embeds a second-order estimate in a third-order result; its FSAL structure can reduce subsequent accepted steps to three new right-hand-side evaluations. Dormand, Prince 5(4) was constructed as a higher-order embedded family with shared stages and favorable principal truncation errors. These results show that formal order alone does not determine cycle cost: stage count, coefficient arithmetic, retained-stage reuse, rejected steps, and the target processor’s instruction costs all matter. They therefore do not establish either proposed ordering between the archived order-4/five-stage and order-2/four-stage cells, although they support separately measuring evaluations and coefficient operations under each cost model.

  • Bogacki, Shampine is an embedded 3(2) pair with four stages and FSAL reuse.
  • Dormand, Prince derives embedded 5(4) formulas whose two estimates share stage evaluations.
  • Embedded error estimates avoid a wholly separate integration but still require a weighted difference.
  • PI/PID step controllers use present and previous error information to damp step-size oscillation.
  • Adaptive rejection and retry make cycle consumption data-dependent unless retries or step choices are bounded.
  • FSAL saves an evaluation only when the retained final derivative remains valid for the following step.
  • Q15 multiplication needs widened intermediate products followed by rescaling; saturation and truncation policy affect the realized method.
  • Published reduced-precision ODE experiments report that rounding mode materially changes accumulated error.

sources:

Long-run quantization and truncation balance collected 2026-09-08 17:37 CT, cycle 2544

ODE error analyses predict a crossover as the step size decreases: discretization error falls with the formal order, while accumulated arithmetic error grows because more steps are taken. Kehlet and Logg derive a worst-case roundoff contribution proportional to the inverse step size and, under independent zero-mean errors, an expected contribution proportional to the inverse square root of the step size. Their residual-and-dual formulation also shows that problem-dependent stability factors govern amplification. Mosbach and Turner similarly model deterministic Euler and RK4 trajectories probabilistically and show that unstable structures such as saddle points can amplify tiny arithmetic perturbations into distributions of long-run trajectories.

These probabilistic cancellation results do not directly describe Q15 floor rounding. Floor is directed rounding and therefore introduces negative bias rather than zero-mean perturbations; the assumptions behind square-root accumulation and stochastic-rounding backward-error bounds are consequently absent. Fixed-point ODE experiments report the characteristic error minimum where truncation and quantization balance, along with accumulated errors from truncated constants and operations. Backward error analysis interprets a numerical trajectory as the exact solution of a modified differential equation, but arithmetic quantization adds implementation-dependent residuals to that modification. Thus, a fourth-order five-stage method can retain an error advantage over lower-order cells only while its smaller discretization error exceeds neither the Q15 quantization floor nor systematic floor-rounding drift; formal order alone does not establish the comparisons in H-647 and H-649 through H-651, and these error analyses provide no evidence for the cycle-cost claim H-648.

  • Decreasing the step size eventually increases arithmetic-error exposure because the step count rises.
  • Zero-mean independent rounding gives square-root-style accumulation; worst-case coherent accumulation is linear in step count.
  • Floor rounding is biased, so zero-mean probabilistic roundoff models cannot be transferred directly to Q15 floor arithmetic.
  • Higher formal RK order stops improving results after quantization or accumulated computational error dominates.
  • Coefficient quantization and the ordering of stage operations can change the effective modified equation.
  • Residual-based a posteriori analysis can separate discretization and computational errors using problem-dependent stability factors.
  • Sensitive or unstable dynamics can amplify the same local quantization residual very differently across test problems.
  • The cited error literature does not determine relative Cortex-M0+ cycle costs.

sources:

Budgeted low-precision and energy-preserving integration collected 2026-09-08 17:07 CT, cycle 2536

Recent reduced-precision Runge, Kutta literature shows that formal order alone does not predict realized accuracy or cost. Naive low-precision implementations can lose convergence as the step size decreases, while compensated accumulation and selective higher-precision operations can recover accuracy. Mixed-precision stabilized RK methods further demonstrate that stages serving stability and stages serving accuracy need not use identical arithmetic. For a Q15 implementation with mandatory floor rounding, these results support evaluating each complete arithmetic schedule: floor is biased rather than unbiased, and mitigation operations would consume part of the fixed cycle budget.

Hard-real-time literature continues to favor fixed-step methods because they provide a constant operation count and analyzable worst-case execution time; adaptive schemes introduce variable work unless adaptation and rejection are explicitly bounded. Research on FPGA hardware-in-the-loop simulation likewise evaluates integration methods jointly by stability, model bandwidth, accuracy, and execution time. Consequently, equal-stage RK formulas can have different measured costs because coefficient representation, multiplication, accumulation, reuse, and storage differ; higher formal order does not by itself establish lower cost or lower finite-precision error.

Energy-preserving collocation methods offer a different objective from minimizing trajectory error: for port-Hamiltonian systems they can impose an exact discrete energy-balance relation and retain high formal accuracy, with reported advantages at larger sampling intervals. These methods are generally implicit and therefore bring solve work that is difficult to reconcile with a small fixed cycle allowance. The literature nevertheless suggests adding invariant or energy-drift measurements to held-out evaluation, since a conventional explicit RK method may have small short-horizon state error while introducing undesirable long-horizon energy behavior.

  • Formal RK order is not a reliable proxy for Q15 accuracy under biased floor rounding.
  • Fixed-step execution supports hard deadlines through a constant per-step operation count.
  • Equal stage counts do not imply equal cycle costs because tableau coefficients and dataflow change arithmetic work.
  • Naive reduced precision can destroy expected convergence as steps become smaller.
  • Compensated or mixed-precision operations can improve accuracy but must be charged to the cycle budget.
  • Energy preservation is a distinct quality metric from pointwise or terminal state error.
  • Exact energy-balance collocation is usually implicit, creating potentially substantial and variable solve costs.

sources:

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