Design decisions

Every deliberate choice, and what the build did to it.

The 14 decisions from DESIGN.md, written before any code existed. Each gives the original context, then what the working system does now and what the choice cost; the tag says whether it survived the build (3 were revised).

The problem is quantization, not coefficient prettiness#held up

Before the build: In floating point, h·b constant-folds and 1/3 costs the same as 0.25. The premise only survives in fixed point on an FPU-less MCU, where a power-of-two coefficient becomes a shift. Scope narrowed to that case.
As built: Kept, and measured (key finding 3).

Order ≥ 3 admits no all-dyadic tableau#held up

Before the build: Dyadic rationals are closed under addition and multiplication, and Σ b·c² = 1/3 is not dyadic. So the objective is to minimize non-dyadic multiplies subject to order, and the verifier code DYADIC_IMPOSSIBLE keeps the search out of the empty region.
As built: Kept, and it shaped the search space. A is snapped to dyadic values but b is solved exactly over the rationals, because snapping b would run into this very theorem. The verifier rejects all-dyadic order-3 claims without evaluating them (tests V5 to V7).

Static cycle counting, not simulation, not hardware#held up

Before the build: The inner loop is branchless straight-line code, so summing instruction costs gives an exact count and a real worst-case figure, and host load cannot disturb the metric.
As built: Kept, and sharpened: the count is analytic from the tableau, with no compiler or disassembly in the loop. One hand-counted ARMv6-M sequence, reproduced exactly by a test, ties the model to hardware, and emit_c exists for a one-off human cross-check.

Cortex-M0+ primary, AVR advisory, two M0+ multiplier variants#held up

Before the build: The M0+ has no FPU, divide or long multiply, so fixed point is forced. Running a 1-cycle and a 32-cycle multiplier model costs nothing and shows whether hardware awareness changes the ranking.
As built: Kept, and under the frozen epoch-1 rule the ranking does change: it prices rk4 cheaper with the fast multiplier and rk38 with the slow one (the anchor result, which also gives the compiled trace's counts for the same pair). After a live candidate was rejected on an infinity in the AVR column, verification was restricted to the primary-model columns.

Q15, wrapping semantics, overflow as a rejection#revised in build

Before the build: Q31 would have to be synthesized on the M0+, and saturation needs a compare and branch that breaks exact counting. Overflow at 2× amplitude is a verifier rejection, which makes it a property of the method rather than a runtime cost.
As built: Revised on one point: nothing wraps. A value outside int16 raises Q15OverflowError and becomes a verifier rejection. One addition the spec missed: rc_thermal's derivative times its state scale leaves Q15 range, so derivatives carry a per-problem power-of-two scale (DERIV_SCALE, 1/8 there) that the step undoes through h. Floor rounding turned out to be an experimental variable in its own right (key finding 2).

Classical optimizer in the inner loop, LLM in the outer loop#held up

Before the build: A six-parameter space has gradients, so CMA-ES does better than an LLM mutation operator at no cost. The LLM decides what to search and interprets what came back.
As built: Kept. When order-4 islands produced nothing (an exact order-4 b is rarely solvable over a dyadic A), the fix was a projection fallback in the optimizer, not more LLM. The outer loop grew hypotheses and a literature loop.

Search/held-out split, enforced structurally#held up

Before the build: The optimizer has no code path that reads HELDOUT_SET, and the held-out gap is a dashboard metric so it cannot rot unnoticed.
As built: Kept literally: a test walks the optimizer's import graph to enforce it, and the D5 drill shows the gap collapsing when the optimizer is fed the held-out set (testing). The gap is also a caveat on the best numbers (key finding 1).

MAP-Elites, one grid per order#held up

Before the build: Descriptors are stage count and cycle-cost bucket, which gives a table of results rather than a single champion.
As built: Kept unchanged. The findings site's explicit page and cell pages are built from these grids, and a cell's incumbent is what tier assignment compares against.

Equal cycle budget, never equal step size#held up

Before the build: A 2-stage method gets twice the steps of a 4-stage method for the same cost, and equal-h comparisons are the most common route to a wrong conclusion.
As built: Kept, and it frames every result on the key findings page: the rank flips and the efficiency frontier only exist at equal budget.

Fixed resource limits plus a pause watchdog#held up

Before the build: Low cpu-shares and docker pause on contention keep the run out of the way in about forty lines, with no dynamic allocation and no GPU.
As built: Kept, and grown a little; the host layer lists what the watchdog does now. Thresholds live in config.json rather than in code.

Credentials outside the container, harness mounted read-only#revised in build

Before the build: If the agent can write the verifier, the shortest path to a high score is editing the scorer. The token was to be scoped to rk-work and rk-findings, with the 403 on rk-harness as an acceptance test.
As built: Half kept. The read-only mount and pinned hash stand, but the token scoping did not survive: the owner's token could write everywhere, and the 403 probe passed for the wrong reason. The credential now never enters the container; a filtered env file and host-side pushes make that independent of token scope.

Auto-publish numbers, never claims#revised in build

Before the build: The site emits values with mechanically assigned tiers, so a wrong result is a wrong number in a table, not a claim that needs retracting.
As built: Amended by the owner, with the guard intact. The findings site also publishes model-written interpretations and literature digests, labeled as such and passed through a softener that replaces priority-claim words. The banned-words guard still fails any page it rejects, and it blocked real builds until the softener existed.

The encourager may change direction but not stop#held up

Before the build: Before a calendar date it can only redirect, widen, hypothesize or advance phase. A set-and-forget system with no calendar runs until the operator gets bored.
As built: Kept. PACKAGE (re-verify everything, no new directions) opens 2026-11-20 and FREEZE 2026-12-05, property-tested over random states and exercised through the real clock path.

Falsification experiment first#held up

Before the build: If derivative evaluation swamps coefficient arithmetic, the thesis is dead, so find out in week one rather than month three.
As built: Kept, and the verdict was stored as it came out, "mixed" (key finding 3 has the numbers).

What was deliberately cut

Adaptive step size and Newton-iteration implicit methods break the execution-time certificate that hard real-time needs, so they are wrong for the target whatever they cost. Order above 4 and linear multistep methods multiply the search space with no reason to expect a larger quantization effect. Rosenbrock methods remain the natural second project. The build added one item: round-to-nearest is measured as a counterfactual on the key findings page (finding 2) rather than searched over, because changing the arithmetic changes every score in the archive.

Two of those cuts have since been revisited, on terms that narrow the real-time objection. The adaptive class uses a division-free controller and books each attempt at its worst-case cycles, though the number of attempts still depends on the data. The implicit class fixes its Newton iteration count so each step costs the same. Both are measured outside the scored archive, on the findings site's adaptive and implicit pages.

Related work, and where the gap is

RKTK (Zhang, 2019) already runs unstructured numerical searches over Butcher order conditions and holds a stage-count record at order 10, so numerical tableau search is not the contribution. That line of work optimizes order, stage count and error constants in exact arithmetic. It does not price coefficients against a hardware cost model or measure end-to-end error in fixed point, and that gap is narrow enough to finish.

The closer line is the work on low-precision and reduced-precision time integration. Croci and Giles analyze Runge-Kutta discretizations of the heat equation under round-to-nearest and stochastic rounding, and show that the round-to-nearest solution stagnates once the timestep is small enough, with the global rounding error growing like the unit roundoff over the timestep until it does (Effects of round-to-nearest and stochastic rounding in the numerical solution of the heat equation in low precision, IMA J. Numer. Anal. 43(3)). Hopkins and coauthors measure reduced-precision fixed-point ODE solvers on neural models and find that the compiler's default downward rounding costs accuracy, while stochastic rounding recovers much of it (Stochastic rounding and reduced-precision fixed-point arithmetic for solving neural ordinary differential equations). A survey of that rounding mode collects the error analysis behind both (Stochastic rounding: implementation, error analysis and applications).

Two things are different here. That work is about floating point at low precision under round-to-nearest or stochastic rounding, while this run is fixed-point Q15 with directed floor rounding, where every inexact product moves the same way instead of scattering about zero. And that work analyzes fixed methods under an arithmetic, while this run searches the tableau space against the bias. The stagnation result is a check on this harness rather than a rival to it: finding 3 measures the same turn-up in a different arithmetic, which is what a working measurement of a known effect should do. The run's literature loop keeps collecting adjacent work, and its digests are in the findings site's research log, labeled as model-written.