From 0b12137376929d96da81cd088d3d288cb1eec32d Mon Sep 17 00:00:00 2001 From: Scott Gasch Date: Sat, 29 Aug 2026 15:03:54 -0700 Subject: Dynamic move ordering overhaul: continuation-history, evidence-gated countermove promotion, retired hung-piece-escape and NumLeftoverMovesToSelect. Full session was built on a "measure the pick, not the game" methodology: aggregate solve counts on curated suites are too noisy to tune move-ordering knobs against, so most decisions here came from per-move fail-high/alpha-raise rates at much larger sample sizes (leftover FH% instrumentation, a zero- selection-budget diagnostic that isolates a single best-of-remaining pick, and evidence-bucket calibration), not solve-count deltas alone. See CLAUDE.md's "Dynamic move ordering experiments" section for the reusable methodology and generate.c's _ScoreAllMoves comment for the resulting ordering hierarchy. Changes: - Added g_ContinuationHistory: same growth/decay math as the existing g_HistoryCounters butterfly table, additionally keyed by the previous move, so its magnitude is self-calibrated rather than a hand-picked constant. Flat, sufficient response across a 256x scale sweep. - Countermove-table matches now get a real GOOD_MOVE-tier promotion (previously the table was write-only, tracked for stats but never read for ordering), but only when the match's own accumulated history+continuation evidence clears COUNTERMOVE_EVIDENCE_THRESHOLD (10,000) -- a raw match with no track record was shown to perform identically to an ordinary leftover (~0.6-0.85% FH), so promoting on match alone would have repeated hung-piece-escape's mistake below. - Retired hung-piece-escape's unconditional GOOD_MOVE-tier promotion. Evidence-calibration showed the overwhelming majority of triggers (a zero-evidence population 250-1000x larger than countermove's) performed at the plain-leftover baseline -- the promotion was mostly free tier- escape treatment for moves that hadn't earned it. Replaced with FLEE_BONUS, a flat same-tier nudge inside SelectBestWithHistory (never escapes GOOD_MOVE/leftover classification, unlike a generation-time promotion) at the magnitude found to plateau a same-tier-nudge sweep. - Retired NumLeftoverMovesToSelect (the depth-indexed budget on how many leftover moves got a full selection scan before falling back to unsorted order). search.c's main move loop now always fully selects -- the leftover pool was shown to contain real, findable signal a bailout budget was discarding for a node-count savings that didn't hold up net- net once measured by solve counts and fail-high rates rather than raw node counts (noisy on small suites independent of this change). - Collapsed leftover-move instrumentation from sorted/raw pairs down to a single set now that "raw" (unsorted fallback) is structurally impossible; kept the countermove evidence-bucket calibration counters (ongoing check that COUNTERMOVE_EVIDENCE_THRESHOLD stays well- calibrated); removed the contested-node A/B harness and hung-piece evidence calibration now that the decisions they were built to inform are made. Net effect on the three curated suites (sd 10): solve counts wash (tied, +1, -1 across ringers/confident/hard), leftover fail-high rate improved consistently on all three (the intended, directly-measured target of this work). Not yet validated beyond sd 10 -- an sn-based run or eval_tune/match_play.py head-to-head gate is the natural next check before leaning on this as a proven strength gain rather than a directionally- sound, sd-10-clean change. Co-Authored-By: Claude Sonnet 5 Claude-Session: https://claude.ai/code/session_014XePz6Sk4qQsTaP2jVJWJu --- src/script.c | 45 ++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 44 insertions(+), 1 deletion(-) (limited to 'src/script.c') diff --git a/src/script.c b/src/script.c index 142b42c..0bc09e4 100755 --- a/src/script.c +++ b/src/script.c @@ -59,6 +59,11 @@ typedef struct _SUITE_COUNTERS UINT64 u64TotalBetaCutoffsOnFirstMove; UINT64 u64TotalCounterMoveTries; UINT64 u64TotalCounterMoveHits; + UINT64 u64TotalLeftoverTries; + UINT64 u64TotalLeftoverAlpha; + UINT64 u64TotalLeftoverFH; + UINT64 u64TotalCMEvidenceTries[CM_EVIDENCE_BUCKETS]; + UINT64 u64TotalCMEvidenceFH[CM_EVIDENCE_BUCKETS]; double dSigmaEBF; // sum of per-problem nodes^(1/depth) ULONG uEBFCount; // number of problems with depth > 0 double dAverageTimeToSolution; @@ -420,6 +425,19 @@ Return value: g_Options.u64CounterMoveTries; g_SuiteCounters.u64TotalCounterMoveHits += g_Options.u64CounterMoveHits; + g_SuiteCounters.u64TotalLeftoverTries += + g_Options.u64LeftoverTries; + g_SuiteCounters.u64TotalLeftoverAlpha += + g_Options.u64LeftoverAlpha; + g_SuiteCounters.u64TotalLeftoverFH += + g_Options.u64LeftoverFH; + for (v = 0; v < CM_EVIDENCE_BUCKETS; v++) + { + g_SuiteCounters.u64TotalCMEvidenceTries[v] += + g_Options.u64CMEvidenceTries[v]; + g_SuiteCounters.u64TotalCMEvidenceFH[v] += + g_Options.u64CMEvidenceFH[v]; + } } else { @@ -448,6 +466,8 @@ Return value: " avg. eff. branching : %5.3f\n" " counter move hit %% : %5.2f percent (%" COMPILER_LONGLONG_UNSIGNED_FORMAT " tries)\n" + " leftover : %5.2f%% alpha, %5.2f%% FH (%" + COMPILER_LONGLONG_UNSIGNED_FORMAT " tries)\n" " script time : %6.1f sec\n\n", g_SuiteCounters.uCorrect, g_SuiteCounters.uIncorrect, @@ -467,8 +487,31 @@ Return value: (100.0 * (double)g_SuiteCounters.u64TotalCounterMoveHits / ((double)g_SuiteCounters.u64TotalCounterMoveTries + 1.0)), g_SuiteCounters.u64TotalCounterMoveTries, + (100.0 * (double)g_SuiteCounters.u64TotalLeftoverAlpha / + ((double)g_SuiteCounters.u64TotalLeftoverTries + 1.0)), + (100.0 * (double)g_SuiteCounters.u64TotalLeftoverFH / + ((double)g_SuiteCounters.u64TotalLeftoverTries + 1.0)), + g_SuiteCounters.u64TotalLeftoverTries, (SystemTimeStamp() - dSuiteStart)); - + + // Countermove evidence calibration -- FH% per evidence bucket, + // an ongoing check that COUNTERMOVE_EVIDENCE_THRESHOLD (chess.h) + // is still well-calibrated as the engine/data evolve. + { + static const ULONG uCMEvidenceFloors[CM_EVIDENCE_BUCKETS] = + { 0, 1, 100, 1000, 10000, 100000, 1000000 }; + Trace("\ncountermove evidence calibration:\n"); + for (v = 0; v < CM_EVIDENCE_BUCKETS; v++) + { + Trace(" evidence >= %8lu : %5.2f%% FH (%" + COMPILER_LONGLONG_UNSIGNED_FORMAT " tries)\n", + uCMEvidenceFloors[v], + (100.0 * (double)g_SuiteCounters.u64TotalCMEvidenceFH[v] / + ((double)g_SuiteCounters.u64TotalCMEvidenceTries[v] + 1.0)), + g_SuiteCounters.u64TotalCMEvidenceTries[v]); + } + } + // Histogram stuff if (g_SuiteCounters.uTotal > 0) { uMax = g_SuiteCounters.uHistogram[0]; -- cgit v1.3