Search-guided self-play with every-sibling labels converts compute into long-horizon strength
Every learned board-scorer in this repository has been trained once, from data generated by something else, and then judged. This theory asks a different question: what if the data and the scorer improved each other in a loop?
The proposal is the AlphaZero pattern, adapted to a one-player game with luck and a hard information boundary. Many games run at once. At every position, a fair search evaluates every legal column under shared imagined futures — successor-closed data by construction, which is exactly what the sibling trap kept punishing. A learner trains a board evaluator on those labels. The trained evaluator then becomes the leaf of the next round's search, which produces better labels than the evaluator that guided it, and the cycle repeats. That feedback is the reason more compute might buy longer-horizon play rather than a more confident copy of the same bias.
The candidate is the frozen public student that falls out of any iteration; the comparator is unchanged fair D4. The full build, the staging order, and where each stage would run are written up on what a large-scale run would look like.
Where it stands. Nothing has been run. The record is draft / untested,
its evidence tier is proposal, and there is no implementation and no result.
It exists so that the plan and its failure tests are on paper before any compute
is spent — see also is more computation the
answer?, which is honest about how
often that assumption has failed here.
How you could help. The theory names its own cheap kill-shots, and all of them run on one workstation. Stage 0 is a paper audit: can existing every-sibling data seed the first dataset without opening new seeds? Stage 3 asks whether held-out sibling ranking improves across iterations on the locked panel — if three iterations do not improve, the loop is falsified before a cluster is ever requested. Stage 4 doubles actor compute with everything else held fixed and looks for a paired 32-game gain beyond the noise band. A clean negative at any of those stages is a finished contribution.
The registered record
Claim
A search-guided self-play loop — actors that run a fair public-information search at every visited position, record the value of every legal sibling column under aligned chance scenarios, and train a public board evaluator on those successor-closed labels, which then becomes the leaf of the next iteration's search — produces a frozen public student whose mean whole-game score on fresh paired development cohorts rises with the compute spent per iteration, and at sufficient scale exceeds fair D4's mean by a preregistered margin.
Mechanism
Most learned evaluators in the ledger failed at ranking siblings because training data labelled only the move that was played (status.md §4-§7; sibling extrapolation). The distributional-afterstate pilot (TH-20260820-distributional-afterstate-ranker-7aba7fb3) removed that defect — it labelled every legal sibling under chance scenarios shared across siblings — and its four recorded pilot experiments relocate the bottleneck rather than resolving it: label stability required raising aligned scenarios from 8 to 256, and the resulting model still lost to fair D4 on ranking, with its own result record naming an undertrained checkpoint (11 of 20 epochs) and a weak D1-continuation teacher as the likely causes. This theory claims the missing element is the loop: using a search to produce the labels makes them stronger than the evaluator that guided the search (policy improvement), and feeding the trained evaluator back as that search's leaf and repeating is approximate policy iteration. Each iteration's labels then come from a strictly stronger searcher, which is the mechanism by which additional compute - more actors, more aligned scenarios per label, deeper or wider search per label, more iterations, longer training - turns into longer-horizon play rather than into a more confident copy of the same bias. It is the AlphaZero pattern adapted to a single-player stochastic game with a hard information boundary. No iteration of that loop has been run in this repository.
What would prove it wrong
- Pilot scale (this workstation): after a preregistered number of iterations, the evaluator's held-out sibling ranking on a locked every-sibling panel (top-1 and pairwise agreement with the fair-D4 gold standard, as in the 477-root panel) does not improve across iterations, or never reaches fair D4's own agreement.
- Compute response: doubling actor compute between two consecutive iterations, with the data pipeline and learner held fixed, produces no paired SCREEN-tier (32-game) mean-score improvement beyond the whole-game bootstrap interval.
- Deployment: the frozen public student of any iteration, evaluated through the public interface on a fresh paired 64-game development cohort, does not exceed fair D4's mean with a one-sided 95% whole-game bootstrap lower bound on the paired difference above zero.
- Information boundary: any student that reads seed, hidden values, future discs, score, level, or move number is disqualified regardless of score.
Experiments that test it
- Scale-out stage 1: successor-closed fair-D4 search-value labels; held-out D4-ranking agreementafterstate-d4q-student vs fair-d4 · CHECK · completed
Results recorded against it
Scale-out stage 1 fails its prerequisite: a compact action-free afterstate model cannot learn fair D4's within-root ordering even from successor-closed, exactly-labeled search values. Training labels were the pinned reference's own depth-3 values of every legal sibling's resolved afterstate under its own five-stratum quadrature (291,890 labeled afterstates over 8,639 training roots, completeness 1.0). On 3,030 fresh held-out roots the model's one-ply chance-averaged ordering agreed with exact fair D4 at top-1 0.375 (frozen threshold >= 0.60), pairwise 0.643 (>= 0.78), normalized regret 0.291 (<= 0.13), failing every criterion in both origin-hash half-folds. For scale, exact fair D1 agrees with D4 at 0.486 top-1 on the historical panel - the learned student is WORSE than the cheapest exact search. Combined with the repository's prior played-action distillation failures, this strengthens the conclusion to: the obstacle to learning D4's ranking is not sibling coverage but the representational capacity of a compact board evaluator for the 4-ply search-value function. The registered self-play loop's stage-1 prerequisite is not met at this model scale.
- ✓Successor-closed D4-value labels on >= 8,000 training roots, completeness 1.0 — observed: 8,639 roots, 291,890 afterstate labels, every legal sibling x 5 strata
- ✕Held-out top-1 agreement >= 0.60 on each half-fold — observed: half1 0.3628, half2 0.3864
- ✕Held-out pairwise agreement >= 0.78 on each half-fold — observed: half1 0.6375, half2 0.6473
- ✕Normalized regret <= 0.13 on each half-fold — observed: half1 0.3055, half2 0.2778
- ✓All CHECK-tier self-tests pass before any label is inspected — observed: SELFTEST OK (10 checks including D2-continuation determinism)
Recorded metrics
- The student is the compact 3.4M-param ResNet; a materially larger model was not tested (the iGPU's FP32 throughput bounds what is trainable overnight).
- Labels are the depth-3 value of afterstates (the value one ply below the D4 root), so the student approximates D4's search through its own horizon, not an oracle's.
- The gate measures agreement with D4's ordering, which is itself a strong-but-not-optimal reference; a student below D4's agreement could in principle still add value inside a different search, which this experiment does not test.
- Single machine profile; FP32 on the shared-memory iGPU.