w1w2w3w4w5w6stepmoveslearning by 1/t: the step spends itselfsearch sets the six weights directly
Technique

Q-learning and value learning

Keep a number for 'how good is it to do this here', play, and after each step nudge that number toward what actually happened plus the best number available next.

Read the primer: Q-learning

On this page

The problem

Erez Klein and Ben Friedmann's Stanford CS221 final project, "Drop7", is the only outside attempt at this game this site knows of. Its player asks one question per column: what happens the instant my disc lands there? Does it clear? Does it make its row or its column clear? Does the clear land next to gray discs and crack them? Is this the lowest column, so the board stays flat? Six such questions, each answered with a small count, each multiplied by a learned weight, and the column with the biggest total wins. Nothing about the position two moves from now, nothing about which numbers are buried where, nothing about the rise clock.

Two things were unknown. Whether the report's numbers, and its explanation of them, hold up when its own code is run again. And how much of Drop7 six first-wave features can see once they play the real game, with its opening gray row and corrected Hardcore scoring, against the depth-4 reference.

Proposed solution

Reproduce the report from its own code, port the six features and the learning rule onto the Rust engine, and measure where they stop. The learning rule is Q-learning with a linear function: after each drop, nudge the six weights so that the column's score moves toward "reward now plus the best score available next turn", the reward being one point per move survived. The report then tests the frozen weights with no exploration. Because the finished policy is only a ranking by six weights, the same six numbers can also be searched directly against whole-game lifetime, which is the third experiment on this page.

The policy reads the visible board and the visible next disc; the moves until the next rise are available and unused by the six features. The learner sees a reward while training and nothing else.

The six features, as the code computes them (the paper's prose differs in two places, noted in the accordions):

  1. Lowest column: 1 if the disc would land at the board's minimum height.
  2. Row detonations: how many discs already in the landing row would clear once the disc joins their run, each counted as 1 plus the number of gray neighbours it touches (a cracked neighbour counts double).
  3. Column detonations: the same count for discs below the landing cell, plus the landing cell's own gray-neighbour count whether or not anything clears.
  4. Tallest column: the column-detonation count again, but only when the disc lands at the maximum height and at most two columns share it.
  5. A clearing 1: 1 plus gray adjacency when the disc is a 1 that clears.
  6. The disc clears: 1 plus gray adjacency when the dropped disc clears by its row run or its column height.

How it works

  1. Read the position: the visible board and the visible next disc.
  2. For every legal column, compute the six features of dropping there.
  3. Score each column as the weighted sum. Ties go to the rightmost column, a quirk of Python's tuple comparison in the original, kept on purpose.
  4. Play the best column. In the original simulator the agent may also pick a full column and lose on the spot; the port restricts both the greedy choice and exploration to legal columns.
  5. While training, update the weights from the observed reward and the best successor score, with a step size of one over the number of moves played so far, an exploration probability of one over the fourth root of that count, and a ridge penalty of 0.1.
  6. For the direct search, skip the learning rule. A cross-entropy method proposes a population of six-weight vectors, plays every vector on the same paired games, keeps the best fraction, refits the proposal to them, and repeats until the population settles.

What happened

The report reproduces from its own code: three independent training runs and the random baseline all land inside the preregistered bands around the paper's own figures (RS-20260902T082726Z-75606ce7, mechanics-only tier, run valid, outcome pass). Almost all of that training is idle. Because the step size is one over the number of moves rather than games, the weights are effectively frozen after a few hundred games: a learner stopped early tests the same as the full-length learner to the second decimal. The report credits a ridge penalty for its stability; with the penalty removed the learner tests about where the regularised one does, while the report's Figure 5 has the unregularised agent falling below random.

On corrected Hardcore rules the six features are a survival heuristic, and a real one. Re-learned with the same schedule in the Rust port and read on 256 previously evaluated development games, the policy scores 107,147 points on average against 73,263 for uniform-random legal play on the same games (RS-20260902T084356Z-2488ecc7, pilot tier, run valid, outcome pass). The authors' own weights, transplanted unchanged, do better than the weights learned in the engine: same features, same algorithm, different opening experience, because the authors' board starts empty, the real game starts with a gray row, and a step size that dies within a few hundred moves locks in whatever it saw first.

A direct search over the six weights beat both learned vectors in a few seconds. Its frozen optimum, re-selected on a fresh block and then read once on the same 256 pilot games, scores 138,973 points (RS-20260902T084356Z-784ebf14, pilot tier, run valid, outcome pass). It puts its largest weight on "a 1 that clears" and almost none on the tallest-column feature. Slower step sizes did not raise the ceiling, and two of them diverged; rewarding corrected score instead of survival changed nothing measurable. The depth-4 reference beat every six-feature arm on nearly every paired game (the results table has the figures).

What we learned

The numbers reproduce to within a move; the explanation did not survive. The report credits ridge regularisation with taming divergence, but the shipped code is stable because its step size collapses, and it learns, for the same reason, only in its first few hundred games. Any future use of this report should cite its numbers and treat its account of the mechanism as unverified.

Six first-wave features are a survival prior worth about ten moves, about 34,000 points over random under Hardcore scoring on the 256-game pilot (RS-20260902T084356Z-2488ecc7), an order of magnitude short of the depth-4 reference in points. That agrees with what this site keeps finding, that lifetime is what local features can learn, and it puts a number on how much of lifetime purely local features capture.

When the policy is six numbers, whole-game search is the cheaper and better optimiser. Two temporal-difference weight vectors differed by 4.7 moves on the 256 pilot games and a few seconds of direct search beat both; the ceiling of these six features under that search is about 45 moves (RS-20260902T084356Z-784ebf14), an order of magnitude below depth 4 in points, so no screen against depth 4 on fresh seeds is warranted by any arm here.

The open question is whether "a 1 that clears next to gray" or "lands on the lowest column" earns a place as a cheap correction term inside the depth-4 leaf, which is a different experiment.

Agent contextRecords and provenance
  • Theory TH-20260902-kf-linear-q-transfer-68b41d66; experiments EX-20260902-kf-report-reproduction-b7f61bf1 (validation, CHECK) and EX-20260902-kf-linear-q-rust-transfer-4328a730 (algorithmic, PILOT); results RS-20260902T082726Z-75606ce7 and RS-20260902T084356Z-2488ecc7. The six-weight search is its own theory and experiment, TH-20260902-kf-six-weight-policy-search-8a6e41a8 and EX-20260902-kf-six-weight-cem-d018cc89, with result RS-20260902T084356Z-784ebf14. Machine profile MACH-20260902T080517Z-dec42aab (Apple M3 Pro, 12 cores, 18 GiB).
  • Upstream: github.com/ekreate/cs221-final-project at commit 8cc8a0edfa04f1a93088c951e217d3cd3d6013f0; no license, so the code is fetched at run time by reproduction/fetch-upstream.sh and never vendored. The paper is at ekreate.github.io/projects/drop7_q_learning.pdf. It is a CS221 course project by two NVIDIA engineers, and util.py is the course's homework scaffold.
  • Where the code differs from the paper: the paper lists max_eq_elem as an indicator; the code appends it with the column-detonation count as its value. The paper's col_dets counts detonations; the code also adds the landing cell's gray adjacency unconditionally. Both are ported as coded. The simulator's game also differs from Drop7 as shipped: the board starts empty (no gray row), score is one point per move, games are capped at 200 moves, dropping on a full column ends the game, and reveals inside a wave are applied sequentially rather than simultaneously.
  • Pilot cohort: seeds 0xa52770000xa52770ff, the first 256 of the Rust engine's benchmark sub-block of SEEDLEASE-A52-FAST, previously read by the centre policy; 2,000-move cap; no game censored. Training read the first 50,000 seeds of the SEEDLEASE-A52 d2 training block (0xa5200000-), role unchanged. Zero new seeds were opened. Paired one-sided 95% percentile-bootstrap lower bounds use 10,000 resamples with RNG seed 0x6b660001.
  • Files: reproduction/fetch-upstream.sh, reproduction/reproduce_kf.py, reproduction/export_parity.py fetch the pinned upstream code, run the report's protocol, and export feature and update transcripts for the gates. rust/ is the drop7-kf-linear-q crate on drop7-rs: features.rs (the six features), learn.rs (the update and schedules), policy.rs, game.rs, and the parity_features, parity_update, train, evaluate and search (cross-entropy over the six weights) binaries. analysis/summarize_reproduction.py and analysis/summarize_evaluate.py are the gate checks and the paired bootstrap, standard library only.
Agent contextFull results table

Reproduction in the authors' simulator (Python seeds 10, 11, 12; lambda 0.1; then seed 10 with lambda 0 and seed 10 stopped after 300 games; phases reseeded so all arms share their 10,000 test games), units of moves survived:

ArmTest mean (moves)Note
uniform random, seeds 10 / 11 / 1231.657 / 31.733 / 31.851over 5,000 games each; report 31.2
50,000-game learner, seeds 10 / 11 / 1249.080 / 49.053 / 49.015sd 11.75 / 11.68 / 11.74; report 49.61 (sd 11.18)
lambda 0 (no ridge penalty), seed 1048.967report's Figure 5 says below random
stopped after 300 games, seed 1049.08013,796 weight updates against 2,406,211

Pilot on the 256-game Rust cohort, corrected Hardcore scoring:

Arm (256 games)Mean scoreMean movesvs random, moves [LB95]vs upstream schedule, moves [LB95]
uniform-random legal73,26326.25−9.54 [−10.25]
centre-first55,08321.01−5.24 [−6.08]
upstream schedule, seed a107,14735.79+9.54 [+8.85]reference
upstream schedule, seed b107,23135.81+9.56 [+8.86]+0.02 [−0.08]
upstream schedule, seed c109,06836.27+10.03 [+9.26]+0.48 [+0.07]
per-game step (weights ~1e9)95,91832.47+6.23 [+5.44]−3.32 [−4.13]
harmonic step, tau 50,000 (NaN)54,56520.90−5.35 [−6.20]
constant step 0.001108,91836.29+10.04 [+9.35]+0.50 [+0.12]
score reward, harmonic (NaN)54,56520.90−5.35 [−6.20]
constant 0.01 (post hoc)110,03236.49+10.25 [+9.48]+0.70 [+0.18]
constant 0.0001 (post hoc)108,69436.19+9.94 [+9.23]+0.40 [+0.02]
score reward, constant 0.001 (post hoc)108,93436.23+9.99 [+9.29]+0.45 [+0.00]
authors' weights transplanted (Python seed 10)123,96840.53+14.29 [+13.25]+4.74 [+3.77]
cross-entropy optimum (separate experiment, read once)138,97344.82+18.57 [+17.24]+4.29 [+2.81] vs transplanted
fair d4s7, first 32 seeds380,205110.38

Points: the upstream-schedule arm gains +33,884 points over random [LB95 +31,361] (seed a). The transplanted weights live 40.5 moves and score 123,968 points, beating the weights learned in the Rust engine by 4.7 moves (lower bound 3.8). The cross-entropy search (population 64, elite 8, 30 generations of 256 paired training games, then re-selection of nine finalists on a fresh 1,024-game block) converged by generation ten and finished in 4.5 s; its optimum lives 44.82 moves and scores 138,973 points, +4.29 moves over the transplanted weights [LB95 +2.81] and +18.57 over random [LB95 +17.24], +15,005 points over the transplanted weights [LB95 +9,755], winning 136 of 256 paired games. Its direction is 0.75 cosine from the transplanted vector and 0.55 from the engine-learned one; unit-normalised weights 0.429, 0.277, 0.145, 0.033, 0.736, 0.419 for the six features in the order listed above. The record puts the ceiling of the six features under this search at about 45 moves and 139,000 points. A constant step of 0.001 gained 0.5 moves over the original schedule (lower bound 0.12), the same size as the gap between two identical-configuration seeds (0.48). Fair depth 4 with seven chance samples on the first 32 seeds scored 380,205 points and lived 110.4 moves, beating the transplanted arm by +256,507 points [LB95 +182,668] on 31 of 32 paired games and the cross-entropy optimum by +233,362 [LB95 +153,370] on 30 of 32.

Agent contextValidity, gates and limitations
  • Port gates (CHECK). Feature parity: 54,852 (state, action) pairs from 7,242 upstream states, 0 mismatches after the gray-encoding swap (upstream 9 = untouched, 8 = cracked; engine 8 = untouched, 9 = cracked). Update parity: 250 upstream weight updates replayed with worst relative difference 0. Legality and determinism: 64 probe games times three arms byte-identical across 1 and 8 threads and a repeat, zero illegal decisions.
  • The evidence tier is pilot and cannot be promoted: the cohort was previously read and zero new seeds were opened. No SCREEN against depth 4 on fresh seeds is warranted by any arm here.
  • The paired detection floor at 256 games is about 0.4 moves for arms this similar and about 0.8 moves against random. Divergent arms (NaN weights) play the rightmost legal column, which is why they tie the centre-first policy's neighbourhood.
  • An unregistered smoke run at seeds 0-2 preceded preregistration and is disclosed in the result record.
  • Training throughput was about 1.4 million moves per second on one core; each 50,000-game training run took 1.3 seconds.
Agent contextScoring mode

The reproduction arms are in the upstream simulator's units: one point per surviving move, a 200-move cap, an empty starting board, and a game that ends when a disc is dropped on a full column. None of them is a Hardcore score. The Rust-engine arms use corrected 17,000-point Hardcore scoring with a 2,000-move cap and no censored game; the "score reward" arms rewarded corrected score instead of survival.

RecordsTheories, experiments and results that reference this directory

Claim: The six-feature linear Q-learner of Erez Klein and Ben Friedmann (Stanford CS221 final report 'Drop7', code github.com/ekreate/cs221-final-project at commit 8cc8a0e) is a survival heuristic whose quality is fixed by its features, not by its training length or its regularisation: (i) its published figures reproduce from its own code (uniform-random about 31 moves, the trained agent about 49-50 moves on 10,000 test games with no exploration); (ii) because the step size is 1/t over MOVES, the weights are effectively frozen after a few hundred games, so a 50,000-game run and a 300-game run yield policies within 2 moves of each other and the ridge term has no measurable effect on the shipped configuration; (iii) transplanted onto corrected five-move Hardcore rules in the repository engine with a legal-column argmax and re-learned with survival reward, the same six features outlive uniform-random play by a paired-significant margin but reach a mean corrected score below two thirds of the fair depth-4 ledger mean (below 205,530 against 308,296) and lose to fair d4s7 on paired seeds; and (iv) a slower step schedule (per-game, harmonic, or constant) does not raise the transplanted policy's mean lifetime over the upstream schedule by more than the pilot cohort's paired detection floor.

This theory is currently mixed at the pilot (a small run to find bugs and project cost, not a strength claim) level.

Claim: For the six Klein-Friedmann features on corrected five-move Hardcore rules, the policy plateau observed in EX-20260902-kf-linear-q-rust-transfer-4328a730 (about 36 moves for engine-learned weights, 40.5 for the authors' transplanted weights) was set by the temporal-difference optimizer, not by the feature set: a direct search over the six weights against whole-game mean lifetime on training seeds finds a weight vector that, frozen and read once on the same 256-game pilot cohort, outlives the transplanted weights by a paired one-sided 95% lower bound above zero; yet even this optimum stays below two thirds of the fair depth-4 ledger mean (205,530 points) and loses to fair d4s7 on the paired 32-seed subset.

This theory is currently supported-as-tested at the pilot (a small run to find bugs and project cost, not a strength claim) level.

Claim: On states visited by fair d4s7 play under corrected five-move Hardcore rules, a linear action value over cheap one-ply features (the seven-stratum mean of the eighteen fair-leaf terms of the afterstate, the mean score delta, the terminal fraction, the six Klein-Friedmann drop features, a rise-clock one-hot and a bias), fitted by ridge regression to exact fair-d4s7 sibling values on training-game roots, (a) reproduces d4's top choice on held-out roots more often than the exact one-ply search value does, but only by a small margin (top-1 stays below 0.65), because a linear one-ply evaluator cannot represent the four-ply value function; (b) nevertheless keeps d4's best action inside its top three on at least 95% of held-out roots; so that (c) a fair search that expands only the prior's top three siblings at every interior max node with two or more plies remaining reproduces the full-width d4s7 action on at least 95% of held-out roots with mean normalised regret at most 0.02, at no more than 35% of the full-width logical work; and (d) the same pruning at depth five, at no more than twice the full-width d4s7 work per root, chooses actions whose mean regret under exact d5s7 values is lower than full-width d4s7's.

This theory is currently mixed at the pilot (a small run to find bugs and project cost, not a strength claim) level.

It compares drop7-kf-linear-q (Rust crate on drop7-rs): six-feature linear Q policy, several trained weight sets against uniform-random legal policy and centre-first policy on identical seeds (primary); fair d4s7 (drop7-rs Searcher, FairLeaf, 65,536-entry depth table, terminal utility -1,000,000, policy seed 0xd7075eed) on the first 32 seeds as a diagnostic reference at the PILOT (a small run to find bugs and project cost, not a strength claim) level, using previously-evaluated-development data.

valid run outcome: pass The run was valid and the outcome was pass (pilot (a small run to find bugs and project cost, not a strength claim)). Read the result.

It compares upstream cs221-final-project Q-learner (external Python simulator, commit 8cc8a0e) against uniform-random policy in the same upstream simulator (the report's baseline) at the CHECK (mechanics checks only, no games played) level, using no-gameplay data.

valid run outcome: pass The run was valid and the outcome was pass (mechanics-only (checks only, no games played)). Read the result.

It compares drop7-kf-linear-q search (CEM over six weights), frozen optimum against transplanted authors' weights (pilot arm transplant-py-seed10), uniform-random legal play, and fair d4s7 on the paired 32-seed subset, all from runs/RUN-20260902T081659Z-d2aa6375/kf-linear-q at the PILOT (a small run to find bugs and project cost, not a strength claim) level, using previously-evaluated-development data.

valid run outcome: pass The run was valid and the outcome was pass (pilot (a small run to find bugs and project cost, not a strength claim)). Read the result.

It compares pruned fair expectimax (drop7-oneply-q evaluate --arm pruned:...) against full-width fair d4s7 (the same FairSearch policy as RUN-20260902T081659Z-d2aa6375's fair-d4s7 arm), 256 games on the same seeds at the PILOT (a small run to find bugs and project cost, not a strength claim) level, using previously-evaluated-development data.

valid run outcome: inconclusive The run was valid and the outcome was inconclusive (pilot (a small run to find bugs and project cost, not a strength claim)). Read the result.

resultvalid runoutcome: passtier: mechanics-onlyRS-20260902T082726Z-75606ce7

The run was valid; the outcome was pass, at the mechanics-only (checks only, no games played) level. Of 4 preregistered checks, 3 passed and 1 failed.

The shipped Klein-Friedmann code (github.com/ekreate/cs221-final-project @ 8cc8a0edfa04f1a93088c951e217d3cd3d6013f0) reproduces its report in its own simulator: uniform-random means 31.657, 31.733, 31.851 over 5,000 games each (report 31.2), and the Q-learner's 10,000-game test means 49.080, 49.053, 49.015 moves with standard deviations near 11.7 (report 49.61, sd 11.18) after 50,000 training games each, so both preregistered bands pass. Two of the theory's clause-(ii) checks were decided here. (ii-a) Front-loading holds: a learner stopped after 300 training games (13,796 updates) tests at 49.0796 moves against 49.0795 for the 50,000-game learner (2,406,211 updates) on the same 10,000 test games, a difference of -0.0001; the per-1,000-game training curve is already at 46.8 in its first block and 48.2 in its last. (ii-b) The report's regularisation claim does NOT hold for the shipped configuration: with lambda = 0 the learner tests at 48.967 moves, indistinguishable from the lambda = 0.1 arm and far above random, where the report's Figure 5 says the unregularised agent fell below random. With eta = 1/t counted per move, the ridge step eta*lambda*w is of order 1e-5 for almost all of training, so the term cannot act; the report's divergence must come from a schedule the shipped code no longer contains. Units are the upstream simulator's (one point per surviving move, 200-move cap, empty starting board, dropping on a full column ends the game); nothing here is a corrected-Hardcore score or a repository cohort.

Technical recordLimitations recorded with the resultRS-20260902T082726Z-75606ce7
  • CHECK/validation tier: an external simulator with its own rules (survival score, 200-move cap, empty opening board, full-column drops end the game, sequential within-wave reveal semantics). No repository seed was read and no Hardcore score exists here.
  • The gate on clause (ii-b) is recorded as failed because the report's prediction (unregularised below random) did not hold; this is a finding against the report's explanation, not a defect of the run.
  • The 300-game and 50,000-game arms share their 10,000 test seeds by phase reseeding of Python's global RNG, a harness convention the upstream code lacks; the upstream flow would have compared different test games.
  • An unregistered smoke run at the identical configuration (Python seeds 0-2) preceded preregistration and is disclosed in metrics.smokeRunDisclosed; the registered arms used disjoint seeds 10-12.
  • Five arms ran concurrently on a 12-core laptop; wall times are indicative only. The upstream repository has no license, so its files are not retained in this repository; the run directory keeps a fetched copy and the manifest records its hashes.
  • Three training seeds cannot estimate the between-seed spread of the agent mean more precisely than about 0.03 moves; the bands, not the spread, are the gate.

Full record →

resultvalid runoutcome: passtier: pilotRS-20260902T084356Z-2488ecc7

The run was valid; the outcome was pass, at the pilot (a small run to find bugs and project cost, not a strength claim) level. Of 6 preregistered checks, 6 passed and 0 failed.

On corrected five-move Hardcore rules the six Klein-Friedmann features are a survival heuristic worth about ten moves and 34,000 points over uniform-random play, an order of magnitude below fair depth-4 in points. Pilot on 256 previously evaluated development seeds (0xa5277000-0xa52770ff, 2,000-move cap, no game censored, 0 illegal decisions): uniform-random legal play 26.25 moves / 73263 points; centre-first 21.01 / 55083; the six features re-learned with the upstream schedule (three exploration seeds) 35.79, 35.81, 36.27 moves and 107147, 107231, 109068 points, a paired gain over random of +9.54 moves [LB95 +8.85] and +33884 points [LB95 +31361] for seed a. The authors' own Python-learned weights (reproduction seed 10) transplanted unchanged live 40.53 moves / 123968 points, +4.74 moves over the engine-learned weights [LB95 +3.77]: same features, same update, same schedule, different opening experience (empty board vs gray row) frozen in by the per-move 1/t step size. Fair d4s7 (drop7-rs, 65,536-entry table) on the first 32 seeds: 380205 points / 110.38 moves, beating the transplanted arm by +256507 points [LB95 +182668] on 31/32 paired games. Slower schedules: per-game 1/g diverged to weights near 1e9 (32.47 moves), harmonic tau 50,000 and the score-reward harmonic arm diverged to NaN (20.90 moves, the rightmost-column policy), constant 0.001 gained +0.50 moves over the upstream schedule [LB95 +0.12], the same size as the +0.48 [+0.07] spread between two identical-configuration seeds. Gates G1-G5 pass; G6 records that a slower stable schedule clears LB95 > 0 by under a move, so theory clause (iv) is not supported at the letter while clauses (iii-a) and (iii-b) are. All CHECK gates (feature parity 54,852 pairs / 0 mismatches; update parity 250 steps / exact; determinism and legality) passed before any diagnostic seed was read. Training ran at about 1.4 million moves per second (1.3 s per 50,000-game arm).

Technical recordLimitations recorded with the resultRS-20260902T084356Z-2488ecc7
  • Pilot tier on previously evaluated development seeds: the cohort had been read by the centre policy before and can never become confirmation evidence; nothing here advances a benchmark tier.
  • Training re-read the first 50,000 seeds of an already-open training-role block without a new lease record; the coordinator has not yet confirmed that reuse. Any citation outside the pilot tier waits on that decision.
  • The fair d4s7 arm covers 32 of the 256 seeds (237.6 s per game on the laptop); its 32-game deltas have detection floors near 82,000 points and 22 moves.
  • Three arms (constant 0.01, constant 0.0001, score reward at constant 0.001) were added post hoc after the preregistered arms were trained; they are labelled post hoc everywhere and decide no gate.
  • The G6 outcome is recorded as observed: the constant-0.001 arm's +0.50 moves clears its LB95 but equals the identical-configuration seed spread; the theory's clause (iv) is therefore judged not supported at the letter and the theory assessment is 'mixed'.
  • Wall times were measured while other arms and the concurrent reproduction run shared the 12-core laptop; the 1.4 million moves per second figure is single-process throughput and not a clean benchmark.
  • The rules engine is the repository's; board-level parity with the upstream simulator is not claimed, only feature and update parity.

Full record →

resultvalid runoutcome: passtier: pilotRS-20260902T084356Z-784ebf14

The run was valid; the outcome was pass, at the pilot (a small run to find bugs and project cost, not a strength claim) level. Of 4 preregistered checks, 4 passed and 0 failed.

A cross-entropy search over the six Klein-Friedmann feature weights against whole-game lifetime (population 64, elite 8, 30 generations of 256 paired training games, then re-selection of nine finalists on a fresh 1,024-game block) converged by generation ten and finished in 4.5 s. Its frozen unit-normalised optimum (0.429, 0.277, 0.145, 0.033, 0.736, 0.419 for lowest-column, row detonations, column detonations, tallest-column, a-clearing-1, the-disc-clears), read once on the 256 pilot games, lives 44.82 moves and scores 138973 points: +18.57 moves over uniform-random [LB95 +17.24] and +4.29 moves [LB95 +2.81], +15005 points [LB95 +9755] over the transplanted authors' weights, winning 136 of 256 paired games. So the plateau of the temporal-difference-learned weights (about 36 moves engine-learned, 40.5 transplanted) was set by the optimizer, not by the feature set. The ceiling of the six features under this search is about 45 moves and 139,000 points; fair d4s7 on the first 32 seeds still beats the optimum by +233362 points [LB95 +153370] on 30 of 32 games, so no SCREEN against depth-4 is warranted. The optimum's direction is 0.75 cosine from the transplanted vector and 0.55 from the engine-learned one; it puts its largest weight on a clearing 1 next to gray discs and nearly none on the tallest-column feature. All three theory clauses are supported as tested at pilot tier.

Technical recordLimitations recorded with the resultRS-20260902T084356Z-784ebf14
  • Pilot tier: the frozen optimum was read once on a previously evaluated development cohort that the parent pilot had already read; the comparator rows are that pilot's artifact. Nothing here can be promoted.
  • Search fitness re-read 8,704 seeds of the already-open training block without a new lease record; the coordinator's confirmation requested for the parent pilot covers this run and is still pending.
  • One search configuration and one policy-sampling seed; the ceiling figure (about 45 moves) is a lower bound on what the six features can reach, not a proof of their optimum.
  • The fair d4s7 comparison uses 32 games with a detection floor near 85,000 points.
  • Ran concurrently with the fair-d4s7 arm on the same laptop; the 4.5 s wall time is indicative.

Full record →

resultvalid runoutcome: inconclusivetier: pilotRS-20260903T013022Z-d32ee053

The run was valid; the outcome was inconclusive, at the pilot (a small run to find bugs and project cost, not a strength claim) level. Of 3 preregistered checks, 1 passed and 0 failed.

On the 256 previously evaluated pilot games, full-width fair d4s7 (the same FairSearch as before; its first 32 rows reproduce RUN-20260902T081659Z-d2aa6375's checksums exactly) averages 404,497 points and 116.41 moves (median 315,158, lower quartile 211,976, maximum 1,746,375, no game censored). The pruned search selected by EX-4 (exact one-ply prior, width three at both interior layers) averages 370,889 points and 107.77 moves at 26.8% of the logical work per move (1.40M against 5.22M) and 3.4x faster wall time even under contention. Its paired score delta is -33,608 points with one-sided 95% bounds -69,418 and +1,448 (detection floor 35,114), and its paired lifetime delta is -8.64 moves (bounds -18.35, +0.89; floor 9.54); it wins 121 of 256 games and loses 135. Gate G1 is therefore inconclusive: the non-inferiority bound (-40,000) is not met and a measurable loss (upper bound below zero) is not shown either; the point estimate is 8.3% of the comparator's mean and its sign agrees with the panel (8% of decisions changed, all near-ties in value) and with the lifetime delta. The pruned depth-5 arm (one-ply prior, width two on all three interior layers, first 128 seeds, 1.80x the depth-4 work per move) averages 383,515 points and 111.17 moves against the comparator's 405,130 on the same 128 games: paired delta -21,615 (bounds -76,153, +31,957; floor 54,839), 62 wins to 66, so G2 is a non-measurement whose point estimate is negative, consistent with the panel finding that pruned depth 5 is no better than depth 4 in points. No illegal or incomplete decision in any arm. Read: the pruning is a four-times-cheaper policy that appears to give up about a twelfth of the score, not an engineering speed-up; and buying a fifth ply through pruning does not pay. Pilot tier, previously evaluated development cohort, zero new seeds.

Technical recordLimitations recorded with the resultRS-20260903T013022Z-d32ee053
  • Pilot tier on a previously evaluated development cohort read for the fourth time; nothing here can become confirmation evidence.
  • A 256-game paired cohort cannot resolve effects below about 35,000 points; the pruned-d4 point estimate sits at that floor, so 'about 8% worse' is the estimate, not a finding, and 0% to 17% are both inside the bounds. The 128-game depth-5 arm has a 55,000-point floor.
  • The four arms ran concurrently on the 12-core laptop with the EX-4 stages; wall times are contended and only logical work per move should be compared. The overall span (18:42 to 00:53 UTC, 22,230 s) exceeded the preregistered 21,600 s stop by 630 s; no arm was cut short and every row is a deterministic function of policy and seed, so no number is affected, but the stop was not enforced.
  • The pruned-d5 arm's configuration was chosen by the primary (normalised) regret metric of EX-4, whose raw-regret reading was unfavourable; the arm was run to the letter of the frozen protocol and is disclosed as such.
  • The per-game artifact for the candidate arms is evaluate-pilot-pruned-d4.json (256 rows) and evaluate-pilot-pruned-d5.json (128 rows) in the same directory.

Full record →

Agent contextSource files, operational notes and how to reproduce

Directory: approaches/value-policy-learning/klein-friedmann-linear-q