Epochs and research

The rk run is split into epochs. Every scored record stores the hash of the pinned files that do the scoring. When one of those files has to change, the run starts a new epoch and leaves the old archive as it was. The figures below date from 2026-09-23, when the run was in its second epoch; the run's findings site has current ones.

Timeline

The 2025 ML project, Novel-Numerical-Integration-Methods, committed its main work between 2025-09-13 and 2025-09-21. The rk run started almost a year later, on 2026-08-29.

Timeline of the 2025 ML project and the rk run's epochsDate axis from 2025-08 to 2026-09-23, broken between the two projects, one scale on both sides. Bars: The 2025 ML project's active window, 2025-09-13 to 2025-09-21; Epoch 1 runs, 2026-08-29 to 2026-09-10; The run stopped, 2026-09-17 to 2026-09-23. Points: Epoch 1 frozen, 2026-09-15; Epoch 2 starts, 2026-09-17; Data snapshot, 2026-09-23.The rk runThe 2025 ML projectRun stopped2025-082025-092026-09-012026-09-152025 ML project2025-09-13 to 2025-09-21The 2025 ML project's active window: 2025-09-13 to 2025-09-21, when its main work was committedEpoch 1 runs2026-08-29 to 2026-09-10Epoch 1 runs: 2026-08-29 to 2026-09-10, 3,931 search cycles, 141,364 records, runner started 24 timesEpoch 1 frozen2026-09-15Epoch 1 frozen: 2026-09-15, archive kept, not rescoredEpoch 2 starts2026-09-17Epoch 2 starts: 2026-09-17, verifier hash 2db0816cEpoch 2 stopped2026-09-17 to 2026-09-23The run stopped: 2026-09-17 to 2026-09-23, the watchdog's system-drive guard stopped it and nothing restarted it (fixed by D46)Snapshot2026-09-23Data snapshot: 2026-09-23
When the 2025 ML project did its main work, and the rk run's two epochs up to the snapshot on 2026-09-23. The date axis is broken between October 2025 and late August 2026. Both parts share one scale, so bar lengths can be compared across the break.
Data table
EventStartEndSource
The 2025 ML project's active window2025-09-132025-09-21Novel-Numerical-Integration-Methods git log
Epoch 1 runs2026-08-292026-09-10rk-work epochs/1/RUNSTATE.json
Epoch 1 frozen2026-09-152026-09-15rk-work EPOCH.json
Epoch 2 starts2026-09-172026-09-17rk-work
The run stopped2026-09-172026-09-23rk-work
Data snapshot2026-09-232026-09-23data/sources.json

Epoch 1

Epoch 1 ran from 2026-08-29 to 2026-09-10. It completed 3,931 search cycles over 13 days of archive and wrote 141,364 scored records. All but 21 of them carry verifier hash de5bec22. Those 21 were written minutes before that pin was set and carry 2411e83f. When it stopped, the search was in phase 3 and 18 cells of the archive grid held an elite.

The run is autonomous in a narrow sense: no person chose what the search tried or how it scored, and the pinned scorer never changed. It was not free of human operation, though. The runner started 24 times during epoch 1, including restarts to deploy changes to the harness code outside the pinned files.

Its main result came early. The champion, 11e898cb, appeared at search cycle 33, and no later cycle in epoch 1 lowered the best held-out error. The search kept filling and improving other cells: 11 of the 16 discovered cell elites appeared after that cycle, including elites of order 3 and order 4. The last new cell was filled on 2026-09-05, and the last improvement to any cell came on 2026-09-09.

Inside Q15 fixed point with floor rounding, at the 65,536-cycle budget, the champion has 2.95x lower held-out error than midpoint, the best of the eight classical methods. That figure uses the analytic cost model and magnitude weighting over four held-out problems, and it moves in both directions under other cost bases and weightings, as the counterfactual grid below shows. It is also an epoch-1 figure, on the cost model that a trace later found had rk4 and rk38 in the wrong order, and epoch 2 has not re-measured it.

Epoch 1 records per archive day
DayRecordsCumulative
2026-08-292222
2026-08-3021,13821,160
2026-08-3112,54033,700
2026-09-0111,95845,658
2026-09-0274046,398
2026-09-039,73556,133
2026-09-0411,65267,785
2026-09-0513,05980,844
2026-09-0616,13096,974
2026-09-075,108102,082
2026-09-0817,177119,259
2026-09-0913,601132,860
2026-09-108,504141,364

Why epoch 1 froze

Compiling and tracing the step showed the epoch-1 analytic cost rule mis-ordered rk4 and rk38, so epoch 2 prices each coefficient by the instructions GCC 13.2.1 emits for it. That edits a pinned file, which forces a new epoch (DECISIONS D42, D45).

A host-side audit did the compiling and tracing. Under the epoch-1 rule with the fast multiplier (m0plus_fast), rk4 cost 33 cycles per step and rk38 36. The compiled step, counted over the same scope the model prices, took 59 cycles for rk38 and 67 for rk4. The traced step matched the Python evaluator bit for bit in 144 of 144 cases, 25 of them overflow cases where both stop at the same operation. The emulator is instruction-accurate, not cycle-accurate: its cycle counts come from a timing table applied to the executed instructions, and nothing was measured on a physical chip.

With the pinned files changed, the verifier hash moved from de5bec22 over 10 files to 2db0816c over 14. The run did not rescore the epoch-1 archive under the new model, so epoch 1's results stand as they were scored, on the old one.

Epoch 1's last cycle ran on 2026-09-10, and epoch 2 started on 2026-09-17. The week between went to the boundary work: the trace, the change to the cost model and the pinned files, and the move of epoch 1's archive and documents under epochs/1/ in rk-work, where they stay as they were. Epoch 1 was frozen on 2026-09-15, and epoch 2 began a new archive.

Epoch 2 so far

Epoch 2 started at 17:54 UTC on 2026-09-17 under verifier hash 2db0816c. By 2026-09-23 it had reached search cycle 259 and written 10,850 records to its own archive. That count comes from the running work tree, so it includes the day's archive file before the run commits it at the day's close. Its cycles rotate among three lanes: the explicit lane scores candidates in Q15 into the archive, while the adaptive and implicit lanes measure how many cycles a float64 solve needs to reach a tolerance, and their results stay out of the archive. Cycles per lane so far: explicit 86, adaptive 87, implicit 86.

From 22:09 UTC on 2026-09-17 to 02:19 UTC on 2026-09-23 the run was down for about five days: the watchdog's system-drive guard stopped it and nothing restarted it (fixed by D46). Epoch 2's archive therefore has records from only two days so far: 5,439 on 2026-09-17 and 5,411 on 2026-09-23.

Two decisions followed that stop. Under D46 the watchdog resumes the stops it makes itself once the condition behind the stop clears. D47 added a logon task to start the run after a reboot, and that task has since been removed. After a reboot a person starts the run by hand with one command, start-integration-harness.

Research practice

The run publishes its checks and its negative results next to its headline result.

A premise test with thresholds set in advance

Before the search started, the run tested its own premise. The test ran rk4 and heun2 in Q15 on one problem, damped_osc, under both cost models, m0plus_fast and m0plus_slow. It measured the share of each step's cycles spent on coefficient arithmetic, and the step size at which rounding error overtakes truncation error. The thresholds were committed to the project's own repository before the test ran, not to an outside registry. The run would proceed if coefficient arithmetic took at least 30% of a step's cycles and rounding error overtook truncation error at a practical step size, between 0.001 and 1. It would stop if coefficient arithmetic took under 15% and no practical step size was rounding-dominated.

The stored verdict is mixed: rk4 on both cost models and heun2 on m0plus_fast met the proceed criterion. On m0plus_slow, heun2 spent 14.8% of its cycles on coefficient arithmetic, below both the 30% and the 15% lines, but it still had a rounding-dominated regime at a practical step size, so it met neither criterion.

A later comparison is separate from the premise test, and it was made after the search began. It compared four classical methods (euler, heun2, rk4 and rk38) on the seven search and held-out problems at the 65,536-cycle budget on m0plus_fast. Among them, rk4 had the lowest error on 0 of 7 under floor rounding, and on 1 of 7 under round-to-nearest.

A hypothesis ledger scored by code

The run keeps a ledger of hypotheses about its own search. Each hypothesis is a predicate in a small closed grammar that a hand-written parser reads, and code evaluates the predicate to assign its verdict. No model decides whether a hypothesis held. The run does not count the ledger among its sources for published numbers.

Literature digests, labelled as model-written

The run searches the web for related work and writes digests that feed later prompts. A language model writes them, and the run publishes them labelled as model-written, so a reader can keep them apart from results the code computed.

The counterfactual grid

The run recomputed the headline lead under three weightings of the held-out problems and two cost bases, six cells in all, and publishes every cell. Each ratio is the best classical method's held-out error over the champion's, so above 1 the champion leads.

Magnitude weighting
The published weighting: an RMS of the four problems' raw errors, so a problem's influence grows with the square of its error.
Median-anchor weighting (equal weight)
Each problem's error is divided by the median error of the eight classical methods on that problem before the RMS, which gives the four problems equal weight.
Reference-norm weighting
Each problem's error is divided by that problem's zero-state error before the RMS. The run publishes it as a counterexample: it puts most of the weight on rc_thermal instead of equalizing it.
Analytic basis
The cost model every archived score was computed under. It prices only the stage and weight combinations of a step.
Traced whole-step basis
Cycles for every instruction the compiled step executes, priced from the Cortex-M0+ timing table, leaving out the derivative routine's own body. The grid uses it only to decide how many steps fit in the budget.

Neither basis is the full cost of a step on a chip: the analytic model prices less than the traced count, and the traced count prices less than a real application step.

WeightingCost basisRatioLowest ratio, one problem droppedAhead with any one problem dropped
magnitudeanalytic2.95x1.92xyes
magnitudetraced whole step1.01x0.614xno
median anchor (equal weight)analytic1.1x0.814xno
median anchor (equal weight)traced whole step0.0494x0.0314xno
reference normanalytic3.36x1.92xyes
reference normtraced whole step1.84x0.604xno

The champion stays ahead with any one problem dropped in two of the six cells, both on the analytic basis: 2.95x under magnitude weighting and 3.36x under reference-norm weighting. In the other four, either the ratio is below 1 or it falls below 1 when one held-out problem is dropped.

On the traced whole-step basis the ratio is 1.01x under magnitude weighting, and dropping one problem takes it to 0.614x. Under reference-norm weighting on that basis it is 1.84x (lowest 0.604x). Under median-anchor weighting it is 1.1x on the analytic basis (lowest 0.814x) and 0.0494x on the traced one, where a classical method is far ahead. The source reads that last cell as the weighting magnifying one problem, not as the champion losing by that factor. Of the held-out problems, pendulum has the smallest median classical error, so dividing by it amplifies the champion's error there, and that error rises when the traced basis leaves the champion fewer steps.

Which archived method ranks highest also depends on the weighting. Re-ranking all 141,364 archived tableaus on the analytic basis puts the champion at rank 1 under magnitude weighting, rank 15 under reference-norm weighting and rank 9,974 under median-anchor weighting. Under all three, no classical method ranks above it, so a discovered method holds the top place each time.