A parallel frontier for deep search, and an evolutionary NNUE leaf designed around two failures
Two threads landed today. The Rust fair solver gained a central work queue for continuation subtrees: exact local parity held and a reusable depth/strata/leaf matrix plus fail-closed EC2 workflow is ready for a separately authorized 192-core run. Separately, the opencode/evolutionary-approach branch registered a depth-3 NNUE-leaf approach: warm-started on a depth-5 teacher's sibling-complete root values, then refined by whole-game evolution with paired fitness blocks - implemented, gated, frozen, and not yet launched.
One deep search can now use more than seven CPUs (Codex)
The Rust engine's first parallel driver assigned one root column to one worker. That helped batches, but one decision exposed at most seven jobs and left an idle tail when one column owned a larger tree. Today's change keeps the same completed fixed-work search and replaces that assignment with a deterministic prefix planner and central task registry. Workers atomically claim public-state continuation subtrees, keep private bounded transposition tables, and publish into fixed slots; the coordinator reduces those slots in the original column and chance order.
The bounded central frontier passed its local speed and exactness gate
1.1352x at D5/S7; 0 semantic mismatchesOn the retained 12-logical-CPU arm64 profile, three interleaved repeats over
three D5/S7 roots moved from a 22.034955 s root-scheduler median to 19.410905 s
with the bounded frontier, a 1.1352x speedup and 88.23% task-phase occupancy.
The eight-root D4/S7 comparison improved from 4.076978 s to 3.232507 s
(1.2612x) with 99.51% occupancy. Root/frontier comparisons at one and 12
workers had zero value, action, or exactly-once task mismatches; the strict-FP
C++ comparison passed eight of eight roots. This is engineering evidence only:
no complete games, new seeds, or strength cohort were opened
(RS-20260825T052959Z-1b3ed9a5).
Maximum occupancy was not the fastest schedule
99.63% busy, only 1.0102xOne preregistered D5 arm expanded an extra prefix ply and manufactured 3,667 deduplicated tasks across the three roots. It kept workers 99.63% busy, but raised logical work from 381,642,037 to a median 539,523,663 (about 41%) by breaking useful private-table locality. Its median speedup was only 1.0102x, below the 10% gate. The shipped automatic rule therefore uses a small queueing cushion for expensive D5-and-deeper continuations and a wider one for cheap shallow work. Fine grain is a means to control the tail, not an objective to maximize blindly.
Depth, strata, and leaf comparisons now have one Rust artifact format
16/16 matrix cells; 2.418 GB D7/S7 planThe new analyzer consumes frozen public roots plus named leaf-weight files and writes one JSONL decision row for every root x leaf x strata x depth cell. Each row retains every legal sibling as decimal and exact f64 bits, the selected action, the previous depth's action and change flag, work/cache/task counts, planner/execution/reduction timings, projected memory, overall occupancy, and per-worker loads. The CHECK matrix emitted all 16 requested rows; frozen named weights matched the compiled fair leaf, and frozen plus perturbed leaves were worker-count independent with zero semantic mismatches.
The allocation-free D7/S7 plan for 192 workers selects one internal split ply,
bounds the worst frontier at 2,401 tasks, and projects 2,418,377,728 bytes under
an 8 GiB guard. The old 16,777,216-entry cache multiplied per worker to
154,618,822,656 bytes and was rejected before allocation. The package,
preflight, launch, timeout, collection, and shutdown scripts use a latest-x86
AMI lookup, encrypted storage, IMDSv2, no inbound security-group rule, a caller
price cap, finite optional Capacity Reservation, preflight shutdown trap, and
boot watchdog. A fail-closed fake-AWS plan accepted only describe, quota, and
SSM calls and made no mutation (RS-20260825T052959Z-57698687).
Run the frozen harness on 192 physical x86 cores
owner: coordinatorNo EC2 resource was created today, and the 2.418 GB figure is a resource plan,
not a saturation measurement. A real hpc7a.96xlarge run needs a new run ID,
current price assertion, explicit budget, exact source/config/root/weight
hashes, live AWS preflight, exclusive machine profile, and uploaded completion
artifacts. Its first job should compare root and frontier schedulers across the
frozen depths before producing any teacher corpus. Only after parity and
utilization hold on that host should a separately preregistered data lease turn
deeper sibling values into training labels.
Validation limits retained with the result
Rust release tests passed all 22 current tests and the repository TypeScript
suite passed 137 tests with one unrelated native-binary skip. The aggregate
make test target still stops at research validation because this checkout is
missing 72 gitignored historical artifacts; rerunning validation after the new
records were completed added no error of this work. The existing C++ build also
hits a macOS -Werror format mismatch. Compiling its search comparator with
that warning relaxed but default arm64 floating contraction produced one-to-
three-ULP differences on seven of 20 roots, with no action changes; disabling
contraction produced exact parity on all eight retained benchmark roots. Both
the failed default diagnostic and strict-FP pass remain in the run artifacts.
An evolutionary NNUE leaf, designed around two documented failures (Kimi K3 / OpenCode)
The owner's standing hypothesis is that the computer policies mis-price slow
risks a human sees immediately — a high number that can no longer be cracked
open horizontally, a 1 dropped next to a gray disc — and that a learned leaf
with the right training signal might price them. Today's work turned that into
a registered, falsifiable experiment with a complete implementation, on the new
branch opencode/evolutionary-approach.
Why this design and not another weight sweep
owner: kimi-k3 (OpenCode)The repository has already killed both halves of the naive version of this idea. Supervised NNUE students of exact search values failed the sibling-ranking gate (top-1 0.296 against 0.60, RS-20260823T194142Z-946e3cd1) because fitting played-action values does not teach a model to rank the six moves nobody played. And the one prior whole-game evolution — CMA-ES over the 18 fair-leaf weights — failed its held-out screen at −30,300 points (RS-20260822T120736Z-662b39ca): fresh seeds per generation removed overfitting as designed, and left selection noise alone to steer a random walk. The new approach keeps the lesson and changes the mechanism: the teacher's root evaluation prices all seven columns anyway, so the corpus is sibling-complete for free; and the evolutionary stage selects on the deployed quantity itself — mean whole-game score of the exact d3s7 configuration — with every candidate in a generation playing the same fresh block of seeds, tournament selection (ordinal, so one lucky game moves a rank and not a magnitude), and a top-8 elite re-selection on 128 fresh games before anything is frozen.
The pipeline exists and passes its mechanics gates
9/9 unit tests, 8/8 CHECK gates, 0 new seeds openedThe crate (approaches/lifetime-objective/nnue-evolution/, std-only, path dependency on the unmodified drop7-rs engine) ships five binaries: gate, teacher_corpus, pretrain, evolve, screen. The CHECK suite passes: feature determinism and bounds, information-boundary blindness (states differing only in score/level/moves_played give bit-identical evaluations), reflection consistency on asymmetric boards with the finding-13 symmetric exclusion, fresh-searcher and 1-vs-4-worker determinism, legality and completed depth under random, all-zero and saturated weights, finiteness fuzz, serialisation round-trip, and teacher argmax equivalence between column_values and choose_action at d3s7 and d5s7. The end-to-end smoke (teacher corpus at d3, pretrain, two evolution generations, elite selection, four-arm screen) ran on the already-opened 0xa5276*** probe block, and the screen artifact is consumed unchanged by the prior experiment's compare.py (RUN-20260825T063123Z-6f4fc021).
The T0 pilot re-priced the teacher before any lease was opened
owner: coordinatorThe frozen protocol's teacher stage plays 512 complete games at depth 5 / seven strata. The pilot (already-opened probe seeds, no lease touched) measured 9.5-13.6 s per live-board d5s7 decision on a quiet machine and 33 s under concurrent load, with heavy-tailed game lengths — one pilot game ran past two hours before being stopped. Transposition-table size (1M/4M/16M) is immaterial. The corpus stage is therefore ~10-14 CPU-seconds per root and projects to 10-16 wall-hours for 512 games on 16 dedicated cores: inside the frozen 24 h budget, but only with the resumable per-game part-file writer (implemented) and the wall-budget stop as the safety valve. The frozen stop rule already permits a partial corpus. Evolution (~3 h) and the screen (~1 h) are cheap by comparison. The launch decision — a ~15-19 h dedicated-machine commitment — is the owner's call; the leases SL-20260825T063000Z-a52e0300 (training) and SL-20260825T063000Z-a52e1300 (screen) stay reserved and unopened until then.
The registered chain is: theory TH-20260825-evolved-nnue-leaf-d3-0f47e46c, frozen experiment EX-20260825-nnue-evolution-d3-bca7f330, approach page at /approach/lifetime-objective/nnue-evolution. The falsifiers are explicit: if evolution's training fitness does not beat the paired fair-d3s7 control, the mechanism is dead before the screen; if the unevolved init passes the screen equally, the evolutionary stage contributed nothing; and the one-shot 64-game held-out screen decides the claim. The Codex thread's 192-core frontier work above is directly relevant here: if it proves out on the authorized host, the teacher-corpus stage is its natural consumer.
A log entry is a narrative written by the contributors listed above. Run validity, scientific outcome and evidence tier live with the experiment and result records the entry refers to.