The rk run
The rk run is an autonomous search for Runge-Kutta coefficients that give the lowest error in Q15 fixed point with floor rounding, at a fixed budget of 65,536 cycles on a modeled Cortex-M0+. Under those conditions, on the analytic m0plus_fast cost model with magnitude weighting, it found a three-stage method, 11e898cb, whose held-out error is 2.95x lower than that of midpoint, the best of the eight classical methods.
That is an epoch-1 figure. It was scored on the cost model that a later trace found had rk4 and rk38 in the wrong order, and epoch 2 has not re-measured it under the corrected model. Elites were picked on that held-out error, so the lead carries winner's-curse bias. It also moves with how a step's cost is counted and how the four held-out problems are weighted, and it is a floor-rounding result.
Outside Q15 the result does not carry over. In float64, at the step count the budget gives each method, the champion's error was 1,992x to 420,975x that of rk4. All the cycle counts come from a cost model or an emulator; none were measured on a physical chip.
These numbers were read on 2026-09-23. The run ended on 2026-11-10, after cycle 17,364, and no more compute goes to it. Epoch 2 closed at 358,752 archive records, and the rk-findings site is its final snapshot.
The question
Q15 stores each value as a signed 16-bit integer that stands for a fraction between minus one and one. A Cortex-M0+ has no floating-point unit, so it multiplies two Q15 values as integers and shifts the product right by fifteen bits. The shift is arithmetic, and like the ARM ASRS instruction it rounds toward minus infinity, so every product loses part of its last bit, always in the same direction.
Textbook coefficients such as those of rk4 were derived for exact arithmetic. The run asks which coefficients give the lowest error once that downward rounding is part of every step.
It scores a method by the error it reaches within a fixed budget of 65,536 cycles, not at a fixed step size. A cheaper step buys more, smaller steps, so the cost of each coefficient is part of the score. That cost only matters in fixed point. In floating point, multiplying by 1/3 costs the same as multiplying by 1/4. In Q15 a dyadic coefficient such as 13/16 takes a couple of shifts and adds, while 1/3, which has no short binary form, takes many more.
The cycle counts come from an analytic model of the Cortex-M0+, m0plus_fast, which prices the stage and weight combinations of a step. Every epoch-1 score was computed under it.
Before the search began, the run tested whether that cost is large enough to matter. Its thresholds were committed to the project's own repository ahead of the test, not to an outside registry. On damped_osc it measured what share of each step's cycles goes to coefficient arithmetic rather than the derivative, for heun2 and rk4 under both cost models, m0plus_fast and the slow-multiplier m0plus_slow, and whether Q15 roundoff overtakes truncation error at a practical step size, between 0.001 and 1. The rule was to proceed if every share reached 30% and roundoff took over at a practical step size, and to stop if every share was under 15% and it never did.
The verdict was mixed. Three of the four method and model pairs met the proceed bar: heun2 on m0plus_fast (50.0%), rk4 on m0plus_fast (55.9%) and rk4 on m0plus_slow (36.2%). On m0plus_slow, heun2 (14.8%) met neither bar: its share is under 15%, but roundoff did take over at a practical step size. A later comparison of four classical methods on the seven search and held-out problems, made after the search began, found rk4 best on 0 of 7 under floor rounding and 1 of 7 under round-to-nearest.
How a candidate is scored and verified
Every candidate tableau goes through a verifier before it is scored. The verifier checks the order conditions exactly, in rational arithmetic, and rejects a tableau that is not explicit, breaks the row-sum conditions, would overflow Q15 with a two-times margin, or falls outside the coefficient and stability limits.
A language model proposes each search cycle's direction as a JSON directive. The directive can only narrow the search, and an unknown key sends the runner to a fixed fallback. The scorer, the verifier and every hypothesis verdict are code.
A tableau that passes is run in Q15 with floor rounding on a set of search problems, each at the 65,536-cycle budget. The optimizer, CMA-ES, is scored on the search problems only. The archive sorts methods into cells by order, stage count and cost band, and keeps in each cell the method with the lowest RMS error on four held-out problems: pendulum, dc_motor, rc_thermal and quaternion. No optimizer reads the held-out problems, but elites are picked on them and the language model is shown their errors, so they act as a selection set rather than an independent test.
The scorer is out of the search's reach. The harness is mounted read-only, and a sha256 over the pinned files (10 in epoch 1, 14 since epoch 2) is checked at every start and stored in every record. Before any search cycle runs, 91 golden and canary cases must pass. No GitHub credential enters the container: it commits, and the host pushes. The one credential inside is the model's sign-in file, mounted read-only. On 2026-09-23 the test suite collected 1,908 tests.
What the search found
The champion, 11e898cb, has 3 stages and order 2, and costs 22 cycles per step on the analytic model. Every coefficient is a dyadic fraction.
0 | |||
|---|---|---|---|
13/16 | 13/16 | ||
1/2 | 5/32 | 11/32 | |
b | 0 | 0 | 1 |
In Q15 with floor rounding, at the 65,536-cycle budget, on the analytic m0plus_fast cost model with magnitude weighting, the champion's held-out RMS error is 0.0286 against 0.0844 for midpoint, the best classical method: a lead of 2.95x. Elites were picked on held-out error from 141,364 archived tableaus, so the four held-out problems act as a selection set and the lead carries winner's-curse bias. It is also an epoch-1 figure: the trace later found this cost model had rk4 and rk38 in the wrong order, and epoch 2, which scores under a corrected model, has not re-measured it.
The 2.95x is an RMS over four problems, and it hides a split. The champion has lower error than midpoint on dc_motor, rc_thermal and quaternion, and higher error on pendulum (0.00474 against 6.45e-05). Much of the gap comes from rc_thermal, where every classical method stalls between 0.156 and 0.158, near a quantization floor, and the champion gets under it at 0.0461.
| Held-out problem | Champion 11e898cb | midpoint | Lower error |
|---|---|---|---|
pendulum | 0.00474 | 6.45e-05 | midpoint |
dc_motor | 0.0276 | 0.0568 | champion |
rc_thermal | 0.0461 | 0.156 | champion |
quaternion | 0.0191 | 0.0322 | champion |
| RMS over the four (magnitude weighting) | 0.0286 | 0.0844 | champion |
Dropping any one of the four held-out problems leaves the champion ahead, by 1.92x to 3.17x on the same basis. The low end, 1.92x, comes from dropping rc_thermal. Magnitude weighting lets problems with small errors count for little, so this check cannot show a loss on one of them, and the champion does lose to midpoint on pendulum.
| Held-out problem dropped | Ratio, best classical error over champion |
|---|---|
| none (all four problems) | 2.95x |
pendulum | 2.96x |
dc_motor | 3.17x |
rc_thermal | 1.92x |
quaternion | 3.05x |
The champion appeared at search cycle 33, and no later cycle in epoch 1's 3,931 lowered the best held-out error. The search kept filling and improving other cells after that: 11 of the 16 discovered cell elites appeared later, elites of order 3 and 4 among them. The last new cell was filled on 2026-09-05 and the last cell improvement came on 2026-09-09.
The champion is not the only discovered method ahead. Epoch 1's archive has 18 occupied cells: discovered methods hold 16 and classical methods 2. Under the same conditions, and with the same selection bias, the discovered method in each of those 16 cells has lower held-out error than all eight classical methods, whatever their cost. The closest, a four-stage elite at 30 cycles per step, has 0.0836 against midpoint's 0.0844.
m0plus_fast cost model with magnitude weighting. Lower is better. Every discovered elite has lower error than every classical method. Elites were picked on these errors, so they carry selection bias. Source: rk-overview/tools/key_findings.json at commit 1a8e0a739ce4, key efficiency.series.frontier_cycles_vs_heldout; efficiency.numbers.Data table
| Series | Method | Order | Stages | Cycles per step | Held-out RMS error |
|---|---|---|---|---|---|
| classical | euler | 5 | 0.32 | ||
| classical | midpoint | 11 | 0.0844 | ||
| classical | heun2 | 13 | 0.0961 | ||
| classical | ralston2 | 16 | 0.0919 | ||
| classical | heun3 | 23 | 0.0852 | ||
| classical | kutta3 | 26 | 0.0873 | ||
| classical | rk4 | 33 | 0.0919 | ||
| classical | rk38 | 36 | 0.0853 | ||
| discovered | cell elite | 2 | 2 | 15 | 0.0613 |
| discovered | cell elite | 2 | 2 | 17 | 0.0494 |
| discovered | champion 11e898cb | 2 | 3 | 22 | 0.0286 |
| discovered | cell elite | 3 | 3 | 29 | 0.0477 |
| discovered | cell elite | 2 | 4 | 30 | 0.0836 |
| discovered | cell elite | 2 | 4 | 39 | 0.0587 |
| discovered | cell elite | 3 | 4 | 46 | 0.0651 |
| discovered | cell elite | 2 | 5 | 57 | 0.0533 |
| discovered | cell elite | 3 | 5 | 59 | 0.0587 |
| discovered | cell elite | 4 | 6 | 63 | 0.0603 |
| discovered | cell elite | 3 | 6 | 63 | 0.0822 |
| discovered | cell elite | 3 | 5 | 65 | 0.0604 |
| discovered | cell elite | 2 | 5 | 65 | 0.0639 |
| discovered | cell elite | 2 | 6 | 72 | 0.0453 |
| discovered | cell elite | 3 | 6 | 75 | 0.0377 |
| discovered | cell elite | 4 | 6 | 77 | 0.0808 |
How the lead depends on cost basis and weighting
The 2.95x figure is one cell in a grid of six: three ways to weight the held-out problems against each other, times two ways to count what a step costs.
The analytic basis is the one every archived score was computed under. It prices the stage and weight combinations only. The traced whole-step basis compiles the step and prices every instruction it executes with the Cortex-M0+ timing table: loop control, the h times k products and the call into the derivative, but not the derivative's own code. It uses that count only to decide how many steps fit in 65,536 cycles. 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 leaves out the derivative's own code.
Magnitude weighting, the published one, is an unweighted RMS of the four problems' errors, so a problem's influence grows with the square of its error. Median-anchor weighting divides each error by the median error of the eight classical methods on that problem before the RMS, which weights the four problems equally. Reference-norm weighting divides by each problem's zero-state error instead. The rk-overview analysis publishes it as a counterexample, because it concentrates weight on rc_thermal rather than equalizing it.
Of the six cells, the champion keeps its lead on every leave-one-out subset in two, both on the analytic basis: 2.95x under magnitude weighting and 3.36x under reference-norm weighting. On the traced whole-step basis the ratio is 1.01x under magnitude weighting, a near tie that dropping one problem turns into a loss (lowest leave-one-out 0.614x), and 1.84x under reference-norm weighting (lowest leave-one-out 0.604x). Under median-anchor weighting it is 1.1x on the analytic basis (lowest leave-one-out 0.814x) and 0.0494x on the traced one, where a classical method is far ahead.
The rk-overview analysis reads the 0.0494x cell as the weighting magnifying one problem, not as the champion losing by that factor. Median-anchor weighting divides by each problem's median classical error, which is smallest on pendulum, so it magnifies any rise in a method's pendulum error. The traced basis leaves the champion fewer steps, and its pendulum error rises.
Which tableau counts as the champion depends on the weighting too. Re-ranking all 141,364 archived tableaus on the analytic basis puts 11e898cb at rank 1 under magnitude weighting, 15 under reference-norm weighting and 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.
rk-overview/tools/key_findings.json at commit 1a8e0a739ce4, key counterfactual.numbers.headline_checks.cells; counterfactual.numbers.archive_reranking.Data table
| Weighting | Cost basis | Ratio, best classical over champion | Lowest leave-one-out ratio | Champion ahead on every leave-one-out subset |
|---|---|---|---|---|
| magnitude | analytic cost basis | 2.95x | 1.92x | yes |
| magnitude | traced whole-step basis | 1.01x | 0.614x | no |
| median-anchor | analytic cost basis | 1.1x | 0.814x | no |
| median-anchor | traced whole-step basis | 0.0494x | 0.0314x | no |
| reference-norm | analytic cost basis | 3.36x | 1.92x | yes |
| reference-norm | traced whole-step basis | 1.84x | 0.604x | no |
Out-of-sample check
The run then tried eight methods on eight further problems from embedded domains, five non-stiff and three stiff: three discovered methods, the champion among them, and five classical methods, euler, heun2, midpoint, rk38 and rk4. No optimizer or model saw these problems, and the champion was fixed before they ran. People chose the problems after the search began, though, so this is an out-of-sample check rather than an independent benchmark.
In Q15 with floor rounding at the 65,536-cycle budget, the best of the three discovered methods tried had lower Q15 error than the best of the five classical methods run on 4 of 5 non-stiff problems, with a median error ratio of 0.475 (discovered over classical) across those five. The fixed champion alone had the lower error on 3 of the 5.
The stiff problems went less well under the same conditions. A discovered method had the lower error on 1 of the 3, enzyme_qssa. On servo_load_step midpoint had the lower error, 0.01157 against 0.01158 for the best discovered method. On robertson_scaled every discovered method overflowed, and so did rk4 and rk38; only euler, heun2 and midpoint finished, midpoint with the lowest error.
11e898cb against the best of five classical methods run (euler, heun2, midpoint, rk38 and rk4) on each problem. Lower is better. On bicycle_lateral the best of the three discovered methods tried is not the champion; the data table gives its error beside the others. The champion overflowed on robertson_scaled, so that problem has no points. Source: rk-work/epochs/1/validation/results.json at commit 59a43b36953c, key verdicts; results[].Data table
| Problem | Stiff | Champion Q15 error | Best classical method | Its Q15 error | Best discovered Q15 error | Lower error, best discovered against best classical |
|---|---|---|---|---|---|---|
battery_2rc | no | 0.03688 | heun2 | 0.07764 | 0.03688 | discovered |
bicycle_lateral | no | 0.0005394 | midpoint | 0.0003946 | 0.0001774 | discovered |
buck_converter | no | 0.001984 | rk38 | 0.02082 | 0.001984 | discovered |
enzyme_qssa | yes | 0.009655 | midpoint | 0.009698 | 0.009655 | discovered |
glucose_minimal | no | 0.0207 | midpoint | 0.03725 | 0.0207 | discovered |
pll_lock | no | 0.01594 | rk38 | 0.01285 | 0.01594 | classical |
robertson_scaled | yes | overflow | midpoint | 0.0894 | overflow | classical |
servo_load_step | yes | 0.01158 | midpoint | 0.01157 | 0.01158 | classical |
In float64, rk4 is far more accurate
The search optimized for Q15 floor arithmetic on purpose. The like-for-like test of its coefficients in ordinary arithmetic is the champion against rk4, both run in float64 on the out-of-sample problems, each at the step count the 65,536-cycle budget gives it. The cheaper champion takes more steps: 1,489 against rk4's 992 on six of the eight problems. Its float64 error was still 1,992x to 420,975x that of rk4 on the 7 out-of-sample problems where both finish. The champion is order 2 and rk4 order 4, and the classical order-2 methods trail float64 rk4 by a similar margin in the same runs.
Two wider comparisons measure the arithmetic rather than the coefficients. Both ran on the seven search and held-out problems, not on the out-of-sample set. Float64 rk4, run as an arithmetic control, had lower error than every Q15 run, classical and discovered alike, in 56 of 56 fixed-step cells at identical step counts. The benchmark attributes that gap to 16-bit floor arithmetic, not to the tableaus. At tolerances of one Q15 least significant bit, the most accurate library solver, Radau on each of those problems, was a median 519x more accurate than the most accurate Q15 run. The library set is RK23, RK45, Radau, BDF and LSODA, run in compiled float64 through SciPy. Dormand-Prince (SciPy RK45) was among them but was never the most accurate, and it was never run against the champion in the same arithmetic.
11e898cb and of rk4 on the out-of-sample problems where both finish, each at the step count the 65,536-cycle budget gives it, so the cheaper champion takes more steps than rk4. Lower is better. The champion is order 2 and rk4 order 4. At their budgeted step sizes neither the champion nor rk4 finished robertson_scaled, in Q15 or in float64, so it has no points. Source: rk-work/epochs/1/validation/results.json at commit 59a43b36953c, key results[].float_error.Data table
| Problem | Stiff | Champion steps | Champion float64 error | rk4 steps | rk4 float64 error |
|---|---|---|---|---|---|
battery_2rc | no | 992 | 1.50e-07 | 661 | 7.60e-13 |
bicycle_lateral | no | 1,489 | 2.76e-09 | 992 | 3.65e-14 |
buck_converter | no | 1,489 | 9.69e-07 | 992 | 1.15e-10 |
enzyme_qssa | yes | 1,489 | 6.47e-08 | 992 | 3.25e-11 |
glucose_minimal | no | 1,489 | 5.21e-08 | 992 | 1.24e-13 |
pll_lock | no | 1,489 | 7.60e-08 | 992 | 7.65e-13 |
robertson_scaled | yes | 992 | overflow in Q15, no float64 result | 661 | overflow in Q15, no float64 result |
servo_load_step | yes | 1,489 | 7.13e-08 | 992 | 2.63e-13 |
Rounding reorders the classical methods
Floor rounding changes which classical method does best. On the search problems, in Q15 at the 65,536-cycle budget, euler has the lowest RMS error under floor rounding (0.0129) of the four classical methods compared (euler, heun2, rk4 and rk38), and rk4 the highest (0.059). Under round-to-nearest, rk4 (0.0289) is back ahead of euler (0.0469).
That ordering holds on the search set and on the published basis only. On the held-out problems rk38 has the lowest error of the four methods compared under both rounding modes.
The champion's lead is a floor-rounding result. Under round-to-nearest, at the same budget and cost model and with no extra cycles charged for the rounding, rk38, one of the four classical methods run under both rounding modes, reaches 0.0263 held-out error, below the champion's 0.0286 under floor rounding. That comparison did not include the champion.
m0plus_fast cost model, under floor rounding and under round-to-nearest, with no extra cycles charged for round-to-nearest. Lower is better. The held-out errors of the same runs are in the data table only. Source: rk-overview/tools/key_findings.json at commit 1a8e0a739ce4, key floor_bias_flip.numbers.aggregate.Data table
| Method | Search set, floor rounding | Search set, round-to-nearest | Held-out, floor rounding (not plotted) | Held-out, round-to-nearest (not plotted) |
|---|---|---|---|---|
euler | 0.0129 | 0.0469 | 0.32 | 0.287 |
heun2 | 0.0174 | 0.061 | 0.0961 | 0.106 |
rk4 | 0.059 | 0.0289 | 0.0919 | 0.0337 |
rk38 | 0.0219 | 0.0196 | 0.0853 | 0.0263 |
Speed and the cost model
Every Q15 result rests on a cost model, so the run checked the model against measurement. Measured in Python on the same solver path, the champion's step ran 1.45x faster than rk4's (geometric mean over problems), against a model prediction of 1.5x, and analytic cycles tracked measured time with Pearson r = 0.97 over 56 runs. That is Python wall-clock time, so it speaks to ordering, not to absolute cycle counts on a Cortex-M0+, and only as far as Python mirrors the chip. Python timed rk4 slightly faster than rk38, as the analytic model predicts, while the compiled trace found rk38 cheaper on a Cortex-M0+.
A host-side audit then compiled the step with GCC 13.2.1 for the Cortex-M0+ and traced it under the unicorn emulator. The compiled step agreed with the Python evaluator bit for bit in 144 of 144 cases, 25 of them overflow cases where both stop at the same operation. It also showed that m0plus_fast, the cost model the epoch-1 archive was scored under, put rk4 and rk38 in the wrong order: it prices rk4 at 33 cycles per step and rk38 at 36, while the traced count at matched scope, which covers the same work, is 67 and 59.
The browser demo on the rk-overview site is an independent check on the solver. It reimplements the Q15 solver in JavaScript and reproduces the Python evaluator in 154 of 154 fixture cases.
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. Rather than rescore the old archive, the run froze epoch 1 and started epoch 2 under a corrected cost model that prices each coefficient by the instructions GCC emits for it.
| Method | Analytic | Matched scope (traced) | Whole step (traced) |
|---|---|---|---|
euler | 5 | 5 | 32 |
midpoint | 11 | 14 | 50 |
heun2 | 13 | 17 | 55 |
ralston2 | 16 | 27 | 66 |
11e898cb | 22 | 35 | 86 |
heun3 | 23 | 42 | 93 |
kutta3 | 26 | 49 | 102 |
rk4 | 33 | 67 | 139 |
rk38 | 36 | 59 | 130 |
Source: rk-work/epochs/1/trace/results.json at commit 59a43b36953c, key methods[]; verdicts.
What the run did not show
- It measured nothing on hardware. All cycle counts come from an analytic model, checked against Python timing and an instruction-accurate emulator.
- It did not show the champion ahead outside Q15. In float64,
rk4was far more accurate than the champion, and Dormand-Prince was never run against the champion in the same arithmetic. - Its held-out errors are not independent of the search. Elites are chosen on them and the model that proposes directions is shown them, so the 2.95x lead (Q15 with floor rounding, 65,536-cycle budget, analytic basis, magnitude weighting) carries winner's-curse bias.
- Its validation is an out-of-sample check, not an independent benchmark. No optimizer or model saw the validation problems, but people chose them after the search began.
- Its lead depends on the cost basis and the weighting. Of the six cost-basis and weighting cells, the champion keeps its lead on every leave-one-out subset in two, both analytic.
- It has not re-measured the lead under the corrected epoch-2 cost model. Epoch 2 has no validation, benchmark or trace results of its own yet, so all of these results are from epoch 1.
- Its lead was measured only under floor rounding. Under round-to-nearest, with no extra cycles charged for the rounding,
rk38, one of the four classical methods run under both rounding modes, has lower held-out error than the champion has under floor rounding. - Its discovered methods did not handle every stiff problem. On
robertson_scaledevery one of them overflowed in Q15, and so didrk4andrk38. - It did not map the search space. The plateau after search cycle 33 describes one search, not a field of local minima.
Archive growth
Epoch 1 ran from 2026-08-29 to 2026-09-10: 3,931 search cycles over 13 days of archive and 141,364 scored records, all under verifier hash de5bec22 apart from 21 written minutes before that pin was set. No person chose candidates or scores, and the pinned scorer never changed, though the runner started 24 times, including restarts to deploy changes to the unpinned harness code. Autonomous here means that no person chooses what the search tries or how it scores. It does not mean free of human operation.
Epoch 2 started on 2026-09-17 under a new verifier hash, 2db0816c. It stopped late that day, and nothing restarted it until 2026-09-23. The watchdog now resumes the stops it makes itself; after a reboot the run is started by hand with one command. As of 2026-09-23, epoch 2 had reached search cycle 259 with 10,850 records. They are scored under the corrected cost model, so they are not comparable with epoch 1's.
rk-work/EPOCH.json; epochs/1/archive/*.jsonl; archive/*.jsonl; RUNSTATE.json; schedule/cycles.jsonl at commit 59a43b36953c, key frozen[0]; line counts.Data table
| Day | Epoch | Records that day | Cumulative records |
|---|---|---|---|
| 2026-08-29 | 1 | 22 | 22 |
| 2026-08-30 | 1 | 21,138 | 21,160 |
| 2026-08-31 | 1 | 12,540 | 33,700 |
| 2026-09-01 | 1 | 11,958 | 45,658 |
| 2026-09-02 | 1 | 740 | 46,398 |
| 2026-09-03 | 1 | 9,735 | 56,133 |
| 2026-09-04 | 1 | 11,652 | 67,785 |
| 2026-09-05 | 1 | 13,059 | 80,844 |
| 2026-09-06 | 1 | 16,130 | 96,974 |
| 2026-09-07 | 1 | 5,108 | 102,082 |
| 2026-09-08 | 1 | 17,177 | 119,259 |
| 2026-09-09 | 1 | 13,601 | 132,860 |
| 2026-09-10 | 1 | 8,504 | 141,364 |
| 2026-09-17 | 2 | 5,439 | 5,439 |
| 2026-09-23 | 2 | 5,411 | 10,850 |