Validation

Problems no search saw, measured speed, and the premise test.

The practical validation suite runs 8 problems from embedded application domains that no optimizer saw and no archive statistic includes. Discovered methods from the live archive and the classical anchors integrate each one in Q15 at the same cycle budget, 65536 cycles under m0plus_fast with floor rounding, and each run is scored by its final-state error against an independent reference solution.

The suite below reads validation/results.json, built at 141,364 archive records, verifier hash de5bec22.

practical problems
4 of 5
non-stiff problems where the best of 3 discovered methods ends with a lower Q15 error than the best of 5 classical anchors
practical median ratio
0.475
best discovered over best classical on those problems; below 1.0 favors discovered
stiff problems
0 of 1
stiff problems where both sides finish, best of 3 discovered against best of 5 classical; 1 of them is a tie inside the 2 percent band; 1 left out as degenerate (enzyme_qssa), over the 8 methods this suite ran
stiff median ratio
1.000
over the stiff problems both sides finish, after the two filters
no discovered finisher
1 of 3
stiff problems where every discovered method overflows

Python wall clock on a desktop preserves the cycle model's ordering, and the cycle counts are modeled rather than measured on a Cortex-M0+.

Q15 error per problem: practical (non-stiff)

One row per method within each problem; the dot is final-state Q15 error at the shared cycle budget on a log axis, so left is better, and each method takes as many steps as its per-step cost allows. Blue is a discovered method, orange a classical anchor; the ringed dot is the problem's lowest error, printed exactly.
discovered (archive)classical anchor
1e-41e-31e-21e-11e0buck_convertereulerbuck_converter / euler (classical): Q15 error 0.0253608, float64 7.5204e-05 over the same 6553 steps (10 cycles/step)heun2buck_converter / heun2 (classical): Q15 error 0.0434966, float64 4.99565e-07 over the same 2520 steps (26 cycles/step)midpointbuck_converter / midpoint (classical): Q15 error 0.022902, float64 3.57687e-07 over the same 2978 steps (22 cycles/step)rk4buck_converter / rk4 (classical): Q15 error 0.03238, float64 1.14781e-10 over the same 992 steps (66 cycles/step)rk38buck_converter / rk38 (classical): Q15 error 0.0208238, float64 1.62089e-10 over the same 910 steps (72 cycles/step)11e898cbbuck_converter / 11e898cb (discovered): Q15 error 0.00198385, float64 9.69071e-07 over the same 1489 steps (44 cycles/step)0.0019838542863b93buck_converter / 42863b93 (discovered): Q15 error 0.0147768, float64 3.04888e-07 over the same 436 steps (150 cycles/step)196b1d17buck_converter / 196b1d17 (discovered): Q15 error 0.00432324, float64 1.52023e-09 over the same 520 steps (126 cycles/step)battery_2rceulerbattery_2rc / euler (classical): Q15 error 0.0986711, float64 4.57811e-05 over the same 4369 steps (15 cycles/step)heun2battery_2rc / heun2 (classical): Q15 error 0.0776365, float64 7.68948e-08 over the same 1680 steps (39 cycles/step)midpointbattery_2rc / midpoint (classical): Q15 error 0.0905505, float64 5.50663e-08 over the same 1985 steps (33 cycles/step)rk4battery_2rc / rk4 (classical): Q15 error 0.117303, float64 7.60152e-13 over the same 661 steps (99 cycles/step)rk38battery_2rc / rk38 (classical): Q15 error 0.105182, float64 1.07549e-12 over the same 606 steps (108 cycles/step)11e898cbbattery_2rc / 11e898cb (discovered): Q15 error 0.0368753, float64 1.49545e-07 over the same 992 steps (66 cycles/step)0.036875342863b93battery_2rc / 42863b93 (discovered): Q15 error 0.056326, float64 8.3658e-09 over the same 291 steps (225 cycles/step)196b1d17battery_2rc / 196b1d17 (discovered): Q15 error 0.0442465, float64 1.01584e-11 over the same 346 steps (189 cycles/step)bicycle_lateraleulerbicycle_lateral / euler (classical): Q15 error 0.105013, float64 5.45857e-07 over the same 6553 steps (10 cycles/step)heun2bicycle_lateral / heun2 (classical): Q15 error 0.0561341, float64 1.42198e-09 over the same 2520 steps (26 cycles/step)midpointbicycle_lateral / midpoint (classical): Q15 error 0.000394556, float64 1.01808e-09 over the same 2978 steps (22 cycles/step)rk4bicycle_lateral / rk4 (classical): Q15 error 0.0439865, float64 3.64986e-14 over the same 992 steps (66 cycles/step)rk38bicycle_lateral / rk38 (classical): Q15 error 0.00394005, float64 5.27405e-14 over the same 910 steps (72 cycles/step)11e898cbbicycle_lateral / 11e898cb (discovered): Q15 error 0.000539394, float64 2.75832e-09 over the same 1489 steps (44 cycles/step)42863b93bicycle_lateral / 42863b93 (discovered): Q15 error 0.0459941, float64 1.05546e-10 over the same 436 steps (150 cycles/step)196b1d17bicycle_lateral / 196b1d17 (discovered): Q15 error 0.0001774, float64 5.01308e-13 over the same 520 steps (126 cycles/step)0.0001774pll_lockeulerpll_lock / euler (classical): Q15 error 0.0481865, float64 6.31115e-06 over the same 6553 steps (10 cycles/step)heun2pll_lock / heun2 (classical): Q15 error 0.0325573, float64 3.90381e-08 over the same 2520 steps (26 cycles/step)midpointpll_lock / midpoint (classical): Q15 error 0.0334146, float64 2.80062e-08 over the same 2978 steps (22 cycles/step)rk4pll_lock / rk4 (classical): Q15 error 0.0386035, float64 7.64901e-13 over the same 992 steps (66 cycles/step)rk38pll_lock / rk38 (classical): Q15 error 0.0128489, float64 1.08125e-12 over the same 910 steps (72 cycles/step)0.012848911e898cbpll_lock / 11e898cb (discovered): Q15 error 0.0159381, float64 7.60478e-08 over the same 1489 steps (44 cycles/step)42863b93pll_lock / 42863b93 (discovered): Q15 error 0.0244659, float64 7.98545e-09 over the same 436 steps (150 cycles/step)196b1d17pll_lock / 196b1d17 (discovered): Q15 error 0.0243841, float64 1.00502e-11 over the same 520 steps (126 cycles/step)glucose_minimaleulerglucose_minimal / euler (classical): Q15 error 0.0840464, float64 3.9061e-05 over the same 6553 steps (10 cycles/step)heun2glucose_minimal / heun2 (classical): Q15 error 0.0738776, float64 2.96109e-08 over the same 2520 steps (26 cycles/step)midpointglucose_minimal / midpoint (classical): Q15 error 0.0372548, float64 4.36692e-08 over the same 2978 steps (22 cycles/step)rk4glucose_minimal / rk4 (classical): Q15 error 0.0542891, float64 1.23695e-13 over the same 992 steps (66 cycles/step)rk38glucose_minimal / rk38 (classical): Q15 error 0.0610666, float64 2.42427e-13 over the same 910 steps (72 cycles/step)11e898cbglucose_minimal / 11e898cb (discovered): Q15 error 0.0207014, float64 5.20727e-08 over the same 1489 steps (44 cycles/step)0.020701442863b93glucose_minimal / 42863b93 (discovered): Q15 error 0.0280853, float64 2.35809e-09 over the same 436 steps (150 cycles/step)196b1d17glucose_minimal / 196b1d17 (discovered): Q15 error 0.0279905, float64 2.04531e-12 over the same 520 steps (126 cycles/step)

Source: rk-work/validation/results.json, results. Arithmetic: Q15 with floor rounding under m0plus_fast; the table below this chart carries each run's float64 error over the same steps.

Every plotted run, in one table (40 rows)
problemmethodkindQ15 errorfloat64 errorstepscycles/step
buck_convertereulerclassical0.02536087.5204e-05655310
buck_converterheun2classical0.04349664.99565e-07252026
buck_convertermidpointclassical0.0229023.57687e-07297822
buck_converterrk4classical0.032381.14781e-1099266
buck_converterrk38classical0.02082381.62089e-1091072
buck_converter11e898cbdiscovered0.001983859.69071e-07148944
buck_converter42863b93discovered0.01477683.04888e-07436150
buck_converter196b1d17discovered0.004323241.52023e-09520126
battery_2rceulerclassical0.09867114.57811e-05436915
battery_2rcheun2classical0.07763657.68948e-08168039
battery_2rcmidpointclassical0.09055055.50663e-08198533
battery_2rcrk4classical0.1173037.60152e-1366199
battery_2rcrk38classical0.1051821.07549e-12606108
battery_2rc11e898cbdiscovered0.03687531.49545e-0799266
battery_2rc42863b93discovered0.0563268.3658e-09291225
battery_2rc196b1d17discovered0.04424651.01584e-11346189
bicycle_lateraleulerclassical0.1050135.45857e-07655310
bicycle_lateralheun2classical0.05613411.42198e-09252026
bicycle_lateralmidpointclassical0.0003945561.01808e-09297822
bicycle_lateralrk4classical0.04398653.64986e-1499266
bicycle_lateralrk38classical0.003940055.27405e-1491072
bicycle_lateral11e898cbdiscovered0.0005393942.75832e-09148944
bicycle_lateral42863b93discovered0.04599411.05546e-10436150
bicycle_lateral196b1d17discovered0.00017745.01308e-13520126
pll_lockeulerclassical0.04818656.31115e-06655310
pll_lockheun2classical0.03255733.90381e-08252026
pll_lockmidpointclassical0.03341462.80062e-08297822
pll_lockrk4classical0.03860357.64901e-1399266
pll_lockrk38classical0.01284891.08125e-1291072
pll_lock11e898cbdiscovered0.01593817.60478e-08148944
pll_lock42863b93discovered0.02446597.98545e-09436150
pll_lock196b1d17discovered0.02438411.00502e-11520126
glucose_minimaleulerclassical0.08404643.9061e-05655310
glucose_minimalheun2classical0.07387762.96109e-08252026
glucose_minimalmidpointclassical0.03725484.36692e-08297822
glucose_minimalrk4classical0.05428911.23695e-1399266
glucose_minimalrk38classical0.06106662.42427e-1391072
glucose_minimal11e898cbdiscovered0.02070145.20727e-08148944
glucose_minimal42863b93discovered0.02808532.35809e-09436150
glucose_minimal196b1d17discovered0.02799052.04531e-12520126

Q15 error per problem: stiff subset

Same layout as the practical chart, for the moderately stiff problems. A run that overflowed has no error, so it has no dot; the full table at the bottom lists it.
discovered (archive)classical anchor
1e-31e-21e-11e0servo_load_stepeulerservo_load_step / euler (classical): Q15 error 0.0118808, float64 2.3216e-05 over the same 6553 steps (10 cycles/step)heun2servo_load_step / heun2 (classical): Q15 error 0.0118296, float64 3.67262e-08 over the same 2520 steps (26 cycles/step)midpointservo_load_step / midpoint (classical): Q15 error 0.0115746, float64 2.62928e-08 over the same 2978 steps (22 cycles/step)0.0115746rk4servo_load_step / rk4 (classical): Q15 error 0.0124489, float64 2.62516e-13 over the same 992 steps (66 cycles/step)rk38servo_load_step / rk38 (classical): Q15 error 0.0148399, float64 3.68864e-13 over the same 910 steps (72 cycles/step)11e898cbservo_load_step / 11e898cb (discovered): Q15 error 0.0115754, float64 7.12907e-08 over the same 1489 steps (44 cycles/step)enzyme_qssaeulerenzyme_qssa / euler (classical): Q15 error 0.00974111, float64 1.89045e-05 over the same 6553 steps (10 cycles/step)heun2enzyme_qssa / heun2 (classical): Q15 error 0.00974111, float64 3.42268e-08 over the same 2520 steps (26 cycles/step)midpointenzyme_qssa / midpoint (classical): Q15 error 0.00969807, float64 2.09683e-08 over the same 2978 steps (22 cycles/step)rk4enzyme_qssa / rk4 (classical): Q15 error 0.00991375, float64 3.24934e-11 over the same 992 steps (66 cycles/step)rk38enzyme_qssa / rk38 (classical): Q15 error 0.00982743, float64 3.20492e-11 over the same 910 steps (72 cycles/step)11e898cbenzyme_qssa / 11e898cb (discovered): Q15 error 0.00965521, float64 6.47158e-08 over the same 1489 steps (44 cycles/step)0.00965521robertson_scaledeulerrobertson_scaled / euler (classical): Q15 error 0.194335, float64 8.80946e-05 over the same 4369 steps (15 cycles/step)heun2robertson_scaled / heun2 (classical): Q15 error 0.154215, float64 3.81289e-07 over the same 1680 steps (39 cycles/step)midpointrobertson_scaled / midpoint (classical): Q15 error 0.0894046, float64 3.16523e-07 over the same 1985 steps (33 cycles/step)0.0894046

Source: rk-work/validation/results.json, results. Arithmetic: Q15 with floor rounding under m0plus_fast; the table below this chart carries each run's float64 error over the same steps.

Every plotted run, in one table (15 rows)
problemmethodkindQ15 errorfloat64 errorstepscycles/step
servo_load_stepeulerclassical0.01188082.3216e-05655310
servo_load_stepheun2classical0.01182963.67262e-08252026
servo_load_stepmidpointclassical0.01157462.62928e-08297822
servo_load_steprk4classical0.01244892.62516e-1399266
servo_load_steprk38classical0.01483993.68864e-1391072
servo_load_step11e898cbdiscovered0.01157547.12907e-08148944
enzyme_qssaeulerclassical0.009741111.89045e-05655310
enzyme_qssaheun2classical0.009741113.42268e-08252026
enzyme_qssamidpointclassical0.009698072.09683e-08297822
enzyme_qssark4classical0.009913753.24934e-1199266
enzyme_qssark38classical0.009827433.20492e-1191072
enzyme_qssa11e898cbdiscovered0.009655216.47158e-08148944
robertson_scaledeulerclassical0.1943358.80946e-05436915
robertson_scaledheun2classical0.1542153.81289e-07168039
robertson_scaledmidpointclassical0.08940463.16523e-07198533

This suite is compared problem by problem and summarized by medians of those per-problem ratios and by win counts, not by a root mean square, so no problem carries a weight here and there is no share to report. The weight shares that do exist are on the cell pages, where the archive's search error and held-out error are formed.

The champion against each anchor

The comparator here is fixed: the archive champion 11e898cbab59, the elite with the lowest held-out error when the suite was built, with its coefficients unchanged. It was picked at cycle 33 out of 141,364 archived records, before this suite ran. It runs against each of the 5 classical anchors on all 8 problems. Each cell gives that anchor's Q15 error and one word for the champion against it: lower, higher, tie when the two sit inside the 2 percent band, or flagged when the degeneracy filter flagged the problem over the 8 methods this suite ran.

The problems on this page are not the held-out set. Those four select the archive's elites, so a champion's held-out error carries selection bias; these select nothing, which is what makes them the harder test.

problemchampion Q15 erroreulerheun2midpointrk4rk38
buck_converter0.001983850.0253608 (lower)0.0434966 (lower)0.022902 (lower)0.03238 (lower)0.0208238 (lower)
battery_2rc0.03687530.0986711 (lower)0.0776365 (lower)0.0905505 (lower)0.117303 (lower)0.105182 (lower)
bicycle_lateral0.0005393940.105013 (lower)0.0561341 (lower)0.000394556 (higher)0.0439865 (lower)0.00394005 (lower)
pll_lock0.01593810.0481865 (lower)0.0325573 (lower)0.0334146 (lower)0.0386035 (lower)0.0128489 (higher)
glucose_minimal0.02070140.0840464 (lower)0.0738776 (lower)0.0372548 (lower)0.0542891 (lower)0.0610666 (lower)
servo_load_step0.01157540.0118808 (lower)0.0118296 (lower)0.0115746 (tie)0.0124489 (lower)0.0148399 (lower)
enzyme_qssa0.009655210.00974111 (flagged)0.00974111 (flagged)0.00969807 (flagged)0.00991375 (flagged)0.00982743 (flagged)
robertson_scaledno finish0.1943350.1542150.0894046n/an/a

Of the 30 cells in this table where both methods finish and the problem is not flagged, the champion has the lower Q15 error in 27, the higher error in 2, and 1 is a tie. Against the best of the 5 anchors on each problem it is lower on 3 of 5 non-stiff problems. On the stiff problems where both sides finish it is lower on 0 of 1, with 1 tie. That is 1 discovered method against 5 classical anchors, on every row, with no maximum taken on either side.

On bicycle_lateral the champion is not the discovered method with the lowest error: 196b1d17d0b7 reaches 0.0001774 while the champion reaches 0.000539394. A row like that counts for the discovered side in the maximum-over-both view below and against the champion here, which is the whole difference between the two tallies.

Degeneracy verdict, problem by problem

problemfinishersverdictwhy
battery_2rc8cleanthe 8 finishers' Q15 errors span 218.11 percent from best to worst, over the 5 percent threshold, and none of them sits within 5 percent of the reference solution's norm of 1.39672, so the comparison is about the methods
bicycle_lateral8cleanthe 8 finishers' Q15 errors span 59095.95 percent from best to worst, over the 5 percent threshold, and none of them sits within 5 percent of the reference solution's norm of 1.03867, so the comparison is about the methods
buck_converter8cleanthe 8 finishers' Q15 errors span 2092.53 percent from best to worst, over the 5 percent threshold, and none of them sits within 5 percent of the reference solution's norm of 0.772995, so the comparison is about the methods
enzyme_qssa6flaggedthe 6 finishers' Q15 errors span 2.68 percent from best to worst, under the 5 percent threshold, so the comparison is reporting the problem rather than the method
glucose_minimal8cleanthe 8 finishers' Q15 errors span 305.99 percent from best to worst, over the 5 percent threshold, and none of them sits within 5 percent of the reference solution's norm of 0.274207, so the comparison is about the methods
pll_lock8cleanthe 8 finishers' Q15 errors span 275.02 percent from best to worst, over the 5 percent threshold, and none of them sits within 5 percent of the reference solution's norm of 0.954011, so the comparison is about the methods
robertson_scaled3cleanthe 3 finishers' Q15 errors span 117.37 percent from best to worst, over the 5 percent threshold, and none of them sits within 5 percent of the reference solution's norm of 0.708764, so the comparison is about the methods
servo_load_step6cleanthe 6 finishers' Q15 errors span 28.21 percent from best to worst, over the 5 percent threshold, and none of them sits within 5 percent of the reference solution's norm of 1.4082, so the comparison is about the methods

Every problem in this suite carries a verdict from the same rule, computed over the 8 methods the suite ran on each of them. The finishers column is how many of those returned a finite Q15 error, which is what the rule reads. A flagged problem stays in the tables above and out of every count, and the thresholds behind the flag are on the methodology page.

Best per problem, a maximum over 3 discovered and 5 classical methods

Practical (non-stiff)

problemwinnerbest classicalQ15 errorbest discoveredQ15 errorratio
buck_converter11e898cb (discovered)rk380.020823811e898cb0.001983850.0953
battery_2rc11e898cb (discovered)heun20.077636511e898cb0.03687530.475
bicycle_lateral196b1d17 (discovered)midpoint0.000394556196b1d170.00017740.45
pll_lockrk38 (classical)rk380.012848911e898cb0.01593811.24
glucose_minimal11e898cb (discovered)midpoint0.037254811e898cb0.02070140.556

Stiff

problemwinnerbest classicalQ15 errorbest discoveredQ15 errorratiofinishers (classical / discovered)
servo_load_steptie (inside the 2 percent band)midpoint0.011574611e898cb0.011575415 / 1
enzyme_qssaflagged (left out of the tallies)midpoint0.0096980711e898cb0.009655210.9965 / 1
robertson_scaledmidpoint (classical)midpoint0.0894046none finishedn/an/a3 / 0

ratio is best-discovered over best-classical Q15 error; below 1.0 the discovered method has the lower error. Each row takes a maximum over both sides, 3 discovered methods against 5 classical anchors, so the discovered column has more chances to produce the row's best number and this view reads better for it than the fixed comparison above.

Measured time per step

Wall clock per Q15 step, next to the analytic cycle model the rest of this site ranks by. Every fixed-step row runs the same pinned Q15 path at the shared cycle budget of 65536 cycles.

Measured wall clock per Q15 step for each method, linear axis in microseconds. The faded bar and the number at the right are the median across the benchmark problems; each dot is one problem. Every method runs the same pinned solve_q15 path, so row differences isolate tableau cost. Blue is a discovered method, orange a classical anchor; the table under the chart carries every median and every per-problem value.
discovered (archive)classical anchor
0255075100125eulereuler (classical): median 6.38 µs per Q15 step over 7 problems; min 4.37, max 9.46euler / dahlquist: 4.37 µs per stepeuler / damped_osc: 7.57 µs per stepeuler / dc_motor: 5.73 µs per stepeuler / pendulum: 6.15 µs per stepeuler / quaternion: 8.89 µs per stepeuler / rc_thermal: 9.46 µs per stepeuler / vanderpol_mild: 6.38 µs per step6.38heun2heun2 (classical): median 13.96 µs per Q15 step over 7 problems; min 8.86, max 19.01heun2 / dahlquist: 8.86 µs per stepheun2 / damped_osc: 13.23 µs per stepheun2 / dc_motor: 13.96 µs per stepheun2 / pendulum: 13.42 µs per stepheun2 / quaternion: 18.56 µs per stepheun2 / rc_thermal: 19.01 µs per stepheun2 / vanderpol_mild: 15.66 µs per step13.96midpointmidpoint (classical): median 12.46 µs per Q15 step over 7 problems; min 8.45, max 21.46midpoint / dahlquist: 8.45 µs per stepmidpoint / damped_osc: 11.33 µs per stepmidpoint / dc_motor: 11.55 µs per stepmidpoint / pendulum: 18.36 µs per stepmidpoint / quaternion: 18.77 µs per stepmidpoint / rc_thermal: 21.46 µs per stepmidpoint / vanderpol_mild: 12.46 µs per step12.46rk4rk4 (classical): median 31.99 µs per Q15 step over 7 problems; min 21.09, max 45.37rk4 / dahlquist: 21.09 µs per steprk4 / damped_osc: 34.75 µs per steprk4 / dc_motor: 30.88 µs per steprk4 / pendulum: 29.08 µs per steprk4 / quaternion: 45.37 µs per steprk4 / rc_thermal: 38.58 µs per steprk4 / vanderpol_mild: 31.99 µs per step31.99rk38rk38 (classical): median 33.23 µs per Q15 step over 7 problems; min 21.11, max 57.42rk38 / dahlquist: 21.11 µs per steprk38 / damped_osc: 32.29 µs per steprk38 / dc_motor: 38.23 µs per steprk38 / pendulum: 30.24 µs per steprk38 / quaternion: 57.42 µs per steprk38 / rc_thermal: 50.46 µs per steprk38 / vanderpol_mild: 33.23 µs per step33.2311e898cb11e898cb (discovered): median 20.47 µs per Q15 step over 7 problems; min 13.17, max 38.1011e898cb / dahlquist: 13.17 µs per step11e898cb / damped_osc: 20.47 µs per step11e898cb / dc_motor: 18.61 µs per step11e898cb / pendulum: 21.84 µs per step11e898cb / quaternion: 38.10 µs per step11e898cb / rc_thermal: 32.83 µs per step11e898cb / vanderpol_mild: 19.81 µs per step20.4742863b9342863b93 (discovered): median 66.37 µs per Q15 step over 7 problems; min 35.54, max 124.0642863b93 / dahlquist: 35.54 µs per step42863b93 / damped_osc: 55.93 µs per step42863b93 / dc_motor: 66.37 µs per step42863b93 / pendulum: 71.88 µs per step42863b93 / quaternion: 124.06 µs per step42863b93 / rc_thermal: 71.26 µs per step42863b93 / vanderpol_mild: 59.33 µs per step66.37196b1d17196b1d17 (discovered): median 71.89 µs per Q15 step over 7 problems; min 43.76, max 93.43196b1d17 / dahlquist: 43.76 µs per step196b1d17 / damped_osc: 62.60 µs per step196b1d17 / dc_motor: 63.00 µs per step196b1d17 / pendulum: 72.50 µs per step196b1d17 / quaternion: 93.43 µs per step196b1d17 / rc_thermal: 84.98 µs per step196b1d17 / vanderpol_mild: 71.89 µs per step71.89

Source: rk-work/benchmark/results.json, speedup.per_method_us_per_step. Python wall clock of the pinned solve_q15 path in Q15 (time.perf_counter, median of 15 repeats after 3 warmups).

Every plotted value, in one table (64 rows)
methodproblemmicroseconds per Q15 stepproblems in the median
eulermedian over its problems6.387
eulerdahlquist4.37
eulerdamped_osc7.57
eulerdc_motor5.73
eulerpendulum6.15
eulerquaternion8.89
eulerrc_thermal9.46
eulervanderpol_mild6.38
heun2median over its problems13.967
heun2dahlquist8.86
heun2damped_osc13.23
heun2dc_motor13.96
heun2pendulum13.42
heun2quaternion18.56
heun2rc_thermal19.01
heun2vanderpol_mild15.66
midpointmedian over its problems12.467
midpointdahlquist8.45
midpointdamped_osc11.33
midpointdc_motor11.55
midpointpendulum18.36
midpointquaternion18.77
midpointrc_thermal21.46
midpointvanderpol_mild12.46
rk4median over its problems31.997
rk4dahlquist21.09
rk4damped_osc34.75
rk4dc_motor30.88
rk4pendulum29.08
rk4quaternion45.37
rk4rc_thermal38.58
rk4vanderpol_mild31.99
rk38median over its problems33.237
rk38dahlquist21.11
rk38damped_osc32.29
rk38dc_motor38.23
rk38pendulum30.24
rk38quaternion57.42
rk38rc_thermal50.46
rk38vanderpol_mild33.23
11e898cbmedian over its problems20.477
11e898cbdahlquist13.17
11e898cbdamped_osc20.47
11e898cbdc_motor18.61
11e898cbpendulum21.84
11e898cbquaternion38.10
11e898cbrc_thermal32.83
11e898cbvanderpol_mild19.81
42863b93median over its problems66.377
42863b93dahlquist35.54
42863b93damped_osc55.93
42863b93dc_motor66.37
42863b93pendulum71.88
42863b93quaternion124.06
42863b93rc_thermal71.26
42863b93vanderpol_mild59.33
196b1d17median over its problems71.897
196b1d17dahlquist43.76
196b1d17damped_osc62.60
196b1d17dc_motor63.00
196b1d17pendulum72.50
196b1d17quaternion93.43
196b1d17rc_thermal84.98
196b1d17vanderpol_mild71.89
problemchampion µs/steprk4 µs/steppredicted ratiomeasured ratiochampion Q15 errorrk4 Q15 errorlower error
dahlquist13.1721.091.5001.6020.0001987410.00016747rk4
damped_osc20.4734.751.5001.6980.003939480.015924811e898cb
vanderpol_mild19.8131.991.5001.6150.01946820.10097311e898cb
pendulum21.8429.081.5001.3320.004744380.00403234rk4
dc_motor18.6130.881.5001.6600.02764760.076358911e898cb
rc_thermal32.8338.581.5001.1750.04608750.15815911e898cb
quaternion38.1045.371.5001.1910.01910550.054056411e898cb

Geometric mean over the problems: measured 1.452, predicted 1.500. A ratio above 1.0 means the champion needs less time per step. The measured mean is taken over the per-problem ratios in this table, and the chart's two medians are each taken over that method's own problems, so their quotient is a different number again. At the same budget the champion reaches the lower Q15 error on 5 of 7 problems, 1 discovered method against 1 classical baseline (rk4), with a median error ratio of 0.353.

Across 56 fixed-step Q15 runs the Pearson correlation between analytic cycles per step and measured seconds per step is 0.970. The analytic model counts Cortex-M0+ arithmetic while the measurement is Python interpreter time, so the correlation speaks to ordering, not to absolute scale.

How the timings were taken

This head-to-head is valid because both sides run the identical solve_q15 path in the same interpreter: same arithmetic, same per-step machinery, only the tableau differs, so the per-step ratio compares like against like. Budget wall-clock totals also carry constant Python per-step overhead, which favors methods that take fewer, larger steps inside the budget; on the Cortex-M0+ target the analytic cycle count is the time, and the predicted ratio column states what that model expects of the measured ratio beside it.

Environment: CPython 3.13.5; Windows 11 (AMD64); scipy 1.14.1; numpy 2.1.3; CPU Intel64 Family 6 Model 141 Stepping 1, GenuineIntel.

All timings are Python-level wall clock on one desktop machine: the Q15 runs pay Python interpreter overhead per primitive while scipy runs compiled internals, so timings compare like against like only within a regime and do not transfer to microcontroller cycle counts.

Compiled and traced against the cost model

The cost model is analytic. It derives an instruction sequence from a tableau's sparsity pattern and each coefficient's bit pattern and prices it, and no compiler is in that loop. This section is what happened when the Q15 step it describes was compiled for cortex-m0plus with arm-none-eabi-gcc (15:13.2.rel1-2) 13.2.1 20231009 at -O2, executed under unicorn 2.1.4, and the executed instructions were priced against the Cortex-M0+ technical reference manual's cycle table.

The emulator is instruction accurate and NOT cycle accurate. It reports which instructions execute and in what order. Every cycle count here comes from applying the Cortex-M0+ TRM table to that instruction stream offline, under the assumptions below. No number here was measured on any physical part.

Correctness came before any timing number. The compiled step ran against the pinned Python evaluator over 144 cases, compared on the exact final int16 state and on every stage input, and all 144 agree. 25 of the cases push the Q15 primitives past the range they check, where they raise instead of wrapping, and the checked build traps at the same operation in all of them.

The analytic model prices the stage and b combinations only. It prices no derivative call, no h times k product, no loop control and no stack frame, so the whole-step traced number is larger by construction. Both are published: ratio is whole step, ratio_model_scope is the matched scope.

methodstagescycles_analyticcycles_traced, matched scoperatioMULS per stepoutside the band
euler1551.0001no
midpoint211141.2732no
heun2213171.3082no
ralston2216271.6882yes, gap 0.407
11e898cb322351.5913yes, gap 0.371
heun3323421.8263yes, gap 0.452
kutta3326491.8853yes, gap 0.469
rk4433672.0304yes, gap 0.507
rk38436591.6394yes, gap 0.390

Both columns are at n_states = 1 under m0plus_fast. The traced column is restricted to what cycle_count prices, which is the stage and b combinations: it excludes the derivative call, the h times k product, loop control and the stack frame. The whole-step figures, and the same counts at two, three and four states, are in the fold below and do not compare with cycles_analytic.

6 of 9 methods sit outside the 0.25 band this comparison chose for itself, measured as |cycles_analytic minus cycles_traced| over cycles_traced at matched scope: ralston2 at 0.407, 11e898cb at 0.371, heun3 at 0.452, kutta3 at 0.469, rk4 at 0.507, rk38 at 0.390. That is published rather than tuned, and the cause is in the next paragraph.

Ranking the 9 methods in this table by cost, the analytic order and the traced order agree to a Spearman correlation of 0.9833 under m0plus_fast. One pair comes out the other way round: the model prices rk4 at 33 cycles against 36 for rk38, while the trace gives rk38 59 and rk4 67. Under the small-multiplier model the two orders do not match: 2 pairs rank differently (ralston2 against 11e898cb and kutta3 against rk38), at a Spearman correlation of 0.9667.

Two results, and the load-bearing one is good news. Every MULS in every trace is the h times k product, one per stage, and not one of them applies a tableau coefficient: the compiler turned the coefficients, dyadic and otherwise, into shifts and adds. The other result is the gap above. Because the analytic model charges each coefficient the cheaper of a shift-add chain and a hardware multiply, and a multiply costs one cycle on the fast multiplier variant, it prices a multiply the compiler does not emit in these nine traces, so it counts low for coefficient-heavy tableaus. The widest gap above is rk4 at 0.507.

For the champion tableau (11e898cb) the trace contains 3 MULS per step, one per stage at 3 stages, and 0 of them apply a tableau coefficient. The dyadic-coefficient assumption behind its cost holds, and holds more strongly than it was stated.

Correcting the cost model would change every archived cycle count, so it moves VERIFIER_HASH and invalidates all scores in the archive. That is an epoch decision for the run's owner, not a fix inside a cycle, and this page publishes the disagreement in the meantime.

State dimension is where the two prices part company. Every count in this paragraph and in the ladder below is one whole rk_step with the derivative routine's own body excluded, priced from the same instruction-accurate emulator. The analytic model charges a fixed amount per state, so its count at four states is four times its count at one for every method above. The compiled step does not keep that shape: at four states it costs 4.03 to 6.04 times its own one-state cost, and a straight line through the one-state and two-state traced costs, read at four states, underprices the measured four-state cost by 1.46x for rk4 up to 2.43x for midpoint. That is why nothing here is priced at a state count the tracer did not run.

The assumptions, the limits and the whole-step counts

What the cycle table assumes

  • BL: 4 cycles
  • branch not taken: 1 cycle
  • taken branch: 3 cycles
  • bus: no contention
  • data processing: 1 cycle
  • flash: zero wait state
  • interrupts: none
  • LDR: 2 cycles
  • MULS on the fast multiplier: 1 cycle
  • MULS on the small multiplier: 32 cycles
  • multi-register transfer: 1 + N for N registers, plus 2 more when the register list contains PC, which is the same pipeline refill that makes a taken branch cost 3
  • STR: 2 cycles

What this does not establish

  • wall clock time on any physical part
  • memory system behaviour: flash wait states, bus contention, buffering
  • interrupt or RTOS overhead
  • anything about a chip other than the one the TRM table describes

Whole-step counts, which cycles_analytic does not cover

methodinstructions per stepcycles traced, whole stepcycles traced, matched scopecycles_analytic, small multiplierratio at matched scope, small multiplier
euler1632551.000
midpoint305014111.273
heun2335517131.308
ralston2446627300.900
11e898cb588635291.207
heun3659342500.840
kutta37210249650.754
rk49913967850.788
rk389013059640.922

Traced whole-step cost by state count

method1 state2 states3 states4 states
euler324152129
midpoint5074144296
heun25592160305
ralston266116264362
11e898cb86144297490
heun393164363543
kutta3102187419582
rk4139256478716
rk38130235532785

Cycles for one whole rk_step under m0plus_fast, at each state count the seven scored problems use. The derivative routine's own body is excluded, and the emulator is instruction accurate rather than cycle accurate, so every entry is a priced instruction stream and not a measurement on any part. These counts do not compare with cycles_analytic, which prices a narrower scope. What they are is the denominator a cycle budget is divided by to get a step count.

Source: rk-work/trace/results.json, written on the host by rk_harness.tracecheck and pinned by TRACE_HASH 61f3a1bc. Arithmetic: Q15 with floor rounding, the same pinned step the archive scores.

Where roundoff overtakes truncation

Before any search ran, the project tested its own premise on two fixed classical methods, heun2 and rk4: is coefficient arithmetic a real share of step cost, and does Q15 roundoff matter at practical step sizes? Code computed the verdict from the measurements: mixed.

Left of a crossover step size, floor rounding loses more per extra step than the smaller step recovers, so the Q15 line turns back up while float64 keeps falling. Each chart carries its step sizes and both errors in the table beneath it.

Q15 fixed pointfloat64, same steps
heun2: final-state error against step size h, log-log, Q15 and float64 over identical steps; the dashed line is the measured crossover. Float64 errors above 1, at h = 1.25, 2.5, 5, are left off so the Q15 curve keeps its scale.
1e-21e-11e-51e-41e-31e-21e-1step size hfinal-state errorcrossover h=0.0390625heun2 q15_error at h=0.625: 0.0466968heun2 q15_error at h=0.3125: 0.0127543heun2 q15_error at h=0.15625: 0.00400537heun2 q15_error at h=0.078125: 0.00297096heun2 q15_error at h=0.0390625: 0.00642073heun2 q15_error at h=0.0195312: 0.0126341heun2 q15_error at h=0.00976562: 0.0276052heun2 float_error at h=0.625: 0.0467395heun2 float_error at h=0.3125: 0.0123373heun2 float_error at h=0.15625: 0.00312695heun2 float_error at h=0.078125: 0.000786061heun2 float_error at h=0.0390625: 0.00019668heun2 float_error at h=0.0195312: 4.91511e-05heun2 float_error at h=0.00976562: 1.22823e-05

Source: rk-work/falsification.json; Q15 and float64 as labeled.

heun2: every plotted step size (7 rows)
step size hstepsQ15 errorfloat64 error
0.625640.04669680.0467395
0.31251280.01275430.0123373
0.156252560.004005370.00312695
0.0781255120.002970960.000786061
0.039062510240.006420730.00019668
0.019531220480.01263414.91511e-05
0.0097656240960.02760521.22823e-05
rk4: final-state error against step size h, log-log, Q15 and float64 over identical steps; the dashed line is the measured crossover. Float64 errors above 1, at h = 5, are left off so the Q15 curve keeps its scale.
1e-21e-11e01e-111e-101e-91e-81e-71e-61e-51e-41e-31e-21e-1step size hfinal-state errorcrossover h=0.15625rk4 q15_error at h=0.625: 0.00133582rk4 q15_error at h=0.3125: 0.00112763rk4 q15_error at h=0.15625: 0.00253715rk4 q15_error at h=0.078125: 0.00479333rk4 q15_error at h=0.0390625: 0.0156265rk4 q15_error at h=0.0195312: 0.0398531rk4 q15_error at h=0.00976562: 0.0258308rk4 float_error at h=2.5: 0.0176384rk4 float_error at h=1.25: 0.0124722rk4 float_error at h=0.625: 0.00101889rk4 float_error at h=0.3125: 6.29326e-05rk4 float_error at h=0.15625: 3.88382e-06rk4 float_error at h=0.078125: 2.40922e-07rk4 float_error at h=0.0390625: 1.49965e-08rk4 float_error at h=0.0195312: 9.35305e-10rk4 float_error at h=0.00976562: 5.83937e-11

Source: rk-work/falsification.json; Q15 and float64 as labeled.

rk4: every plotted step size (9 rows)
step size hstepsQ15 errorfloat64 error
2.516inf0.0176384
1.2532inf0.0124722
0.625640.001335820.00101889
0.31251280.001127636.29326e-05
0.156252560.002537153.88382e-06
0.0781255120.004793332.40922e-07
0.039062510240.01562651.49965e-08
0.019531220480.03985319.35305e-10
0.0097656240960.02583085.83937e-11
methodcoefficient share, m0plus_fastcoefficient share, m0plus_slowcrossover hcrossover in the practical range
heun20.50.1477270.0390625yes
rk40.5593220.3617020.15625yes
How to read this

The protocol fixes two classical methods, rk4 and heun2, on the damped oscillator and measures two things. One is the share of a step's cycle count spent on coefficient arithmetic rather than derivative evaluation, under both primary cost models. The other is a sweep over n = 8, 16, ..., 4096 steps that compares the Q15 integrator with float64 on identical steps, looking for the step size where roundoff overtakes truncation error.

The verdict is mechanical. proceed needs every coefficient share at 0.30 or more and at least one crossover inside the practical range 1e-3 ≤ h ≤ 1.0. kill needs every share below 0.15 and no practical crossover. Anything else reads mixed. A proceed verdict says that searching over coefficients can plausibly matter; it does not show that any searched method is good.

Full tables

The suite's verdict, in words

On the 5 non-stiff practical problems at a 65536-cycle budget under m0plus_fast with floor rounding, the best discovered method has lower Q15 error than the best classical anchor on 4 of 5; the median ratio of best-discovered to best-classical Q15 error is 0.475 (below 1.0 favors the discovered methods). On the 3 moderately stiff problems (stiffness ratios 292 to 1030): where both sides finish, the best discovered method is ahead on 1 of 2 with a median error ratio of 0.998; on 1 of 3 no discovered method finishes at all; every one overflows in Q15 while cheap low-stage classical methods complete the run. Explicit methods pay for stability: at a fixed cycle budget an expensive high-order tableau takes larger steps, and once the step size times the fast eigenvalue leaves the stability interval the Q15 run overflows, whoever found the tableau. This is why the implicit (SDIRK) class is measured.

That paragraph is quoted from validation/results.json, which counted its wins and losses before the tie band and the degeneracy filter existed and over a maximum of 3 discovered methods against a maximum of 5 classical anchors. Where it differs from the tallies above, the tallies above are this page applying both filters; rewriting the stored sentence needs a host validation run, not a site build.

Q15 against float64, every run

Float64 runs of the same tableaus over the same steps land between 3.64986e-14 and 0.0106122, and the largest raw Q15 magnitude seen anywhere is 20130 of the int16 limit 32767. Where a row's float64 error sits far below its Q15 error, the Q15 number measures quantization, not truncation.

The cycles/step column is one method's analytic cost for one step of that problem, so a single method shows more than one number here: the cost model prices a step at one state and multiplies by the problem's state count. The champion costs 22 cycles per step at one state, which is the figure the archive and the frontier chart carry, and 44 on the 2-state problems and 66 on the 3-state problems.

problemmethodkindstepscycles/stepQ15 errorfloat64 errormax |q|note
buck_convertereulerclassical6553100.02536087.5204e-054743
battery_2rceulerclassical4369150.09867114.57811e-0519616
bicycle_lateraleulerclassical6553100.1050135.45857e-078221
pll_lockeulerclassical6553100.04818656.31115e-067845
glucose_minimaleulerclassical6553100.08404643.9061e-0511428
servo_load_stepeulerclassical6553100.01188082.3216e-0513977
enzyme_qssaeulerclassical6553100.009741111.89045e-0516384
robertson_scaledeulerclassical4369150.1943358.80946e-0516384
buck_converterheun2classical2520260.04349664.99565e-074777
battery_2rcheun2classical1680390.07763657.68948e-0819875
bicycle_lateralheun2classical2520260.05613411.42198e-098663
pll_lockheun2classical2520260.03255733.90381e-087955
glucose_minimalheun2classical2520260.07387762.96109e-0811428
servo_load_stepheun2classical2520260.01182963.67262e-0813978
enzyme_qssaheun2classical2520260.009741113.42268e-0816384
robertson_scaledheun2classical1680390.1542153.81289e-0716384
buck_convertermidpointclassical2978220.0229023.57687e-074840
battery_2rcmidpointclassical1985330.09055055.50663e-0819967
bicycle_lateralmidpointclassical2978220.0003945561.01808e-099168
pll_lockmidpointclassical2978220.03341462.80062e-088217
glucose_minimalmidpointclassical2978220.03725484.36692e-0811428
servo_load_stepmidpointclassical2978220.01157462.62928e-0813975
enzyme_qssamidpointclassical2978220.009698072.09683e-0816384
robertson_scaledmidpointclassical1985330.08940463.16523e-0716384
buck_converterrk4classical992660.032381.14781e-104776
battery_2rcrk4classical661990.1173037.60152e-1319681
bicycle_lateralrk4classical992660.04398653.64986e-148773
pll_lockrk4classical992660.03860357.64901e-137914
glucose_minimalrk4classical992660.05428911.23695e-1311428
servo_load_steprk4classical992660.01244892.62516e-1314013
enzyme_qssark4classical992660.009913753.24934e-1116384
robertson_scaledrk4classical66199n/an/an/aq15 run failed: Q15OverflowError
buck_converterrk38classical910720.02082381.62089e-104810
battery_2rcrk38classical6061080.1051821.07549e-1219860
bicycle_lateralrk38classical910720.003940055.27405e-149135
pll_lockrk38classical910720.01284891.08125e-128093
glucose_minimalrk38classical910720.06106662.42427e-1311428
servo_load_steprk38classical910720.01483993.68864e-1314184
enzyme_qssark38classical910720.009827433.20492e-1116384
robertson_scaledrk38classical606108n/an/an/aq15 run failed: Q15OverflowError
buck_converter11e898cbdiscovered1489440.001983859.69071e-074889
battery_2rc11e898cbdiscovered992660.03687531.49545e-0720130
bicycle_lateral11e898cbdiscovered1489440.0005393942.75832e-099168
pll_lock11e898cbdiscovered1489440.01593817.60478e-088396
glucose_minimal11e898cbdiscovered1489440.02070145.20727e-0811428
servo_load_step11e898cbdiscovered1489440.01157547.12907e-0813976
enzyme_qssa11e898cbdiscovered1489440.009655216.47158e-0816384
robertson_scaled11e898cbdiscovered99266n/an/an/aq15 run failed: Q15OverflowError
buck_converter42863b93discovered4361500.01477683.04888e-074879
battery_2rc42863b93discovered2912250.0563268.3658e-0920038
bicycle_lateral42863b93discovered4361500.04599411.05546e-108757
pll_lock42863b93discovered4361500.02446597.98545e-098291
glucose_minimal42863b93discovered4361500.02808532.35809e-0911428
servo_load_step42863b93discovered436150n/an/an/aq15 run failed: Q15OverflowError
enzyme_qssa42863b93discovered436150n/a0.0106122n/aq15 run failed: Q15OverflowError
robertson_scaled42863b93discovered291225n/an/an/aq15 run failed: Q15OverflowError
buck_converter196b1d17discovered5201260.004323241.52023e-094860
battery_2rc196b1d17discovered3461890.04424651.01584e-1120045
bicycle_lateral196b1d17discovered5201260.00017745.01308e-139169
pll_lock196b1d17discovered5201260.02438411.00502e-118291
glucose_minimal196b1d17discovered5201260.02799052.04531e-1211428
servo_load_step196b1d17discovered520126n/an/an/aq15 run failed: Q15OverflowError
enzyme_qssa196b1d17discovered520126n/a7.18161e-09n/aq15 run failed: Q15OverflowError
robertson_scaled196b1d17discovered346189n/an/an/aq15 run failed: Q15OverflowError
Methods
kindname / tableau_hashorderstagesrolesarchive provenance
classicaleuler11anchorclassical fixture
classicalheun222anchorclassical fixture
classicalmidpoint22anchorclassical fixture
classicalrk444anchorclassical fixture
classicalrk3844anchorclassical fixture
discovered11e898cbab591a7f432670d4040b788f4c00cc646a005d4f967505578e2c003323champion, best_elite_order_2cycle 33, unreplicated, held-out 0.0286181
discovered42863b93bf7d570f7f6fd94033452451bf70bb8adf803e7f2c965f612914472e36best_elite_order_3cycle 632, heldout_verified, held-out 0.0376551
discovered196b1d17d0b708c06c798239ed34bd466fa7e9b6ba7e59797ec5d22645b2ab0346best_elite_order_4cycle 358, unreplicated, held-out 0.0603389
Problems

buck_converter

power electronics; oscillatory, 2 states, integrated to t = 25.

Non-stiff; stiffness ratio 1 (single complex pole pair; both eigenvalues share Re = -1/(2*Qf)).

x1' = D - x2; x2' = x1 - x2/Qf (D = 5/12, Qf = 2)

Reference: closed form via matrix exponential of the augmented affine system.

Source: Averaged CCM buck converter model, R. W. Erickson and D. Maksimovic, Fundamentals of Power Electronics, 2nd ed., Kluwer, 2001; the same averaged equations appear in arXiv:2002.02544. Per-unit normalization with Vg = 12 V, D = 5/12, L = 100 uH, C = 100 uF, R = 2 ohm (Z0 = 1 ohm, Qf = 2, omega0 = 1e4 rad/s). Startup transient from rest.

battery_2rc

battery management; linear, 3 states, integrated to t = 6.

Non-stiff; stiffness ratio 6.8 (tau2 / tau1 = 222.9 s / 32.8 s for the two RC branches).

dod' = T*I/(3600*Cn); vk' = T*(-vk/(Rk*Ck) + I/Ck), k = 1, 2

Reference: exact closed form: linear ramp plus two RC charge curves.

Source: Li-ion Thevenin 2RC equivalent circuit, M. Chen and G. A. Rincon-Mora, IEEE Trans. Energy Conversion 21(2):504-511, 2006, parameters for the 850 mAh TCL PL-383562 cell at SOC 0.5: R1 = 0.0467 ohm, C1 = 703 F, R2 = 0.0498 ohm, C2 = 4475 F. Constant 1.7 A (2C) discharge pulse is our scenario choice. States (dod, v1, v2), time unit 20 s.

bicycle_lateral

vehicle dynamics / ADAS; linear, 2 states, integrated to t = 15.

Non-stiff; stiffness ratio 1 (single complex pole pair (sideslip and yaw share their real part)).

v' = T*(-u*w + (Fy1+Fy2)/m); w' = T*(lf*Fy1 - lr*Fy2)/Iz; Fy1 = kf*((v+lf*w)/u - delta), Fy2 = kr*(v-lr*w)/u

Reference: closed form via matrix exponential of the augmented affine system.

Source: Linear-tire dynamic single-track model, Q. Ge, S. E. Li, Q. Sun, S. Zheng, arXiv:2011.09612 (2020), eqs. (1) and (3), model attributed to R. Rajamani, Vehicle Dynamics and Control, Springer 2011; Table I parameters (CarSim C-Class Hatchback 2017): m = 1412 kg, Iz = 1536.7 kg m^2, lf = 1.06 m, lr = 1.85 m, kf = -128916 N/rad, kr = -85944 N/rad. Constant 30 m/s, step steer 0.01 rad. States (v, w), time unit 0.1 s.

pll_lock

communications / clocking; nonlinear, 2 states, integrated to t = 10.

Non-stiff; stiffness ratio 1 (complex pole pair near the lock point (zeta = 0.7)).

theta_e' = w_free - Kvco*(x + (tau2/tau1)*sin(theta_e)); x' = sin(theta_e)/tau1

Reference: mpmath odefun at 30 digits (no closed form).

Source: Second-order type-2 analog PLL with active PI filter and sinusoidal phase detector, N. V. Kuznetsov, G. A. Leonov, M. V. Yuldashev, R. V. Yuldashev, arXiv:1705.05013, model (15). Kvco = 1, tau1 = 1, tau2 = 1.4 (wn = 1 rad/s, zeta = 0.7), frequency step w_free = 0.5 rad/s inside the lock-in range (no cycle slip). States (theta_e, x).

glucose_minimal

biomedical devices; nonlinear, 2 states, integrated to t = 12.

Non-stiff; stiffness ratio 1.5 (ratio of the two decay rates, 10*(0.01*y2 + p1) over 10*p2, at the y2 peak).

y1' = 10*(-0.01*y1*y2 + 0.0265*(0.82 - y1)); y2' = 10*(-0.0254*y2 + 0.1282*exp(-0.5*t))

Reference: mpmath odefun at 30 digits (no closed form).

Source: Bergman glucose minimal model (MINMOD) for an IVGTT, Pacini and Bergman, Comput. Methods Programs Biomed. 1986, via the MLAB worked example (civilized.com/mlabexamples/glucose.htmld/): p1 = 0.0265, p2 = 0.0254, p3 = 1.282e-5, Gb = 82 mg/dl, Ib = 8 uU/ml, G0 = 279 mg/dl. The insulin input is idealized as I(t) = Ib + 100*exp(-0.05*t_min) uU/ml (our modeling choice; the source drives it from measured data). Normalized y1 = G/100, y2 = 100*X, time unit 10 min. Only time-dependent RHS in the suite.

servo_load_step

motor control; linear, 2 states, integrated to t = 260.

Stiff; stiffness ratio 546.4 (electrical pole 9.649/ms over electromechanical pole 0.01766/ms).

di' = (-R*di - ke*dw)/L; dw' = (kt*di - dT_L)/J (deviations; per-ms coefficients -9.667, -9.75, 0.017476, -0.0074683)

Reference: closed form via matrix exponential of the augmented affine system.

Source: Armature-controlled DC servo, the standard two-state model (electrical and mechanical equations coupled by the back-EMF and torque constants; see e.g. Franklin, Powell and Emami-Naeini, Feedback Control of Dynamic Systems, ch. 2). Motor parameters from the maxon RE 25 catalog page, part 118752 (24 V, graphite brushes, 20 W): R = 2.32 ohm, L = 0.24 mH, kt = ke = 23.4 mNm/A, rotor inertia 10.3 g cm^2. Our scenario choice: a 12x reflected load inertia (total J = 13.39e-6 kg m^2) and a 10 mNm load-torque step from steady spin. States are deviations from the pre-step equilibrium, (delta_i / 1 A, delta_omega / 100 rad/s).

enzyme_qssa

biochemical kinetics; nonlinear, 2 states, integrated to t = 12.

Stiff; stiffness ratio 1030 (Jacobian eigenvalue ratio 128.4 over 0.1246 at t = 0; the separation narrows to about 130 as the substrate empties).

u' = -u + (u + 1/2)*v; v' = 64*(u - (u + 1)*v)

Reference: mpmath odefun at 30 digits (no closed form).

Source: Michaelis-Menten enzyme kinetics in the standard dimensionless form of the quasi-steady-state literature: Segel and Slemrod, SIAM Review 31(3):446-477, 1989; Murray, Mathematical Biology I, 3rd ed., Springer 2002, ch. 6. u is substrate, v the enzyme-substrate complex scaled by e0. Dimensionless parameters K = 1, lambda = 1/2, eps = e0/s0 = 1/64 are our scenario choice, placing the problem in the moderately stiff regime. The run starts on the QSS manifold v(0) = u(0)/(u(0)+K), the state reached after the fast initial burst.

robertson_scaled

chemical kinetics; nonlinear, 3 states, integrated to t = 200.

Stiff; stiffness ratio 292 (largest fast eigenvalue over the window (11.7, from the y2 equation) over the slow consumption rate a = 0.04; the third eigenvalue is 0 because y1 + y2/10 + y3 is conserved).

y1' = -a*y1 + (b/10)*y2*y3; y2' = 10*a*y1 - b*y2*y3 - (c/10)*y2^2; y3' = (c/100)*y2^2 (y2 stored 10x physical; y1 + y2/10 + y3 conserved)

Reference: mpmath odefun at 30 digits (no closed form).

Source: Reaction structure of the Robertson problem: H. H. Robertson, The solution of a set of reaction rate equations, in J. Walsh (ed.), Numerical Analysis: An Introduction, Academic Press, 1966, pp. 178-182 (original rates 0.04, 1e4, 3e7). Our scaling choices: rate constants cut to (a, b, c) = (0.04, 20, 250) and the intermediate stored as y2 = 10x its physical concentration, so the quasi-steady intermediate stays resolvable in Q15 while a clear fast/slow separation remains.

Provenance

validation/results.json

archive_records
141364
champion_hash
11e898cbab591a7f432670d4040b788f4c00cc646a005d4f967505578e2c0033
verifier_hash
de5bec229ffa404a85b9172fdc808ef6035716c3df8b308c816e90ffb54fd6e9

benchmark/results.json

champion_hashes
11e898cbab591a7f432670d4040b788f4c00cc646a005d4f967505578e2c0033, 42863b93bf7d570f7f6fd94033452451bf70bb8adf803e7f2c965f612914472e, 196b1d17d0b708c06c798239ed34bd466fa7e9b6ba7e59797ec5d22645b2ab03
scipy
1.14.1
validation_results
rk-work/validation/results.json (methods[].tableau)