Fix IID's killer-blind gate and its ordering-flag/history contamination

of iValue; harden against a latent ComputeMoveExtension bug.

DO_IID's "is the top move crappy" gate compared raw iValue against
SORT_THESE_FIRST only, missing that ordinary killer moves (FIRST_KILLER
through FOURTH_KILLER) sit below that threshold too -- a killer that
already proved itself elsewhere in the tree was being treated as
"crappy" and triggering an unnecessary shallow rescore. Fixed by also
excluding killer-flagged moves from the gate.

RescoreMovesViaSearch corrupted the winning move's real search score by
OR-ing in SORT_THESE_FIRST to force it to sort first (`mvf[uBest].iValue
|= SORT_THESE_FIRST`) -- unnecessary (SelectBest{With,No}History already
find the true max by plain magnitude comparison, no flag needed) and
actively dangerous: a later ComputeMoveScore() call on that same move,
if it's a capture, would see the corrupted value, mistake it for
generate.c's biased-capture-ordering format, and subtract the wrong
bias entirely. Removed the OR; added an explicit
PLY_INFO.fMovesRescoredByIID flag so ComputeMoveScore and the main
search-loop's move-selection call can both recognize "this ply's
iValue holds a real eval-axis score" without relying on bit-pattern
inference.

Consequently, ComputeMoveScore now trusts an IID-rescored move's score
outright instead of running it through the capture-bias-subtraction or
quiet-move-collapse-to-0 logic (both of which assume generate.c's
ordering encoding, which a rescored ply no longer holds). Separately
hardened it against quiet killer-mate moves, which can reach
SORT_THESE_FIRST via a different, capture-unrelated path and were
incorrectly getting the capture bias subtracted from them; they now
correctly collapse to 0 like other quiet moves.

Two follow-on ideas -- blending history into the real IID score (scaled
or capped) and a exact-tie-only history tiebreak -- were implemented,
measured, and rejected: blending invents a new, leak-prone move-scoring
axis for no measured benefit, and the tiebreak-only compromise still
cost solves relative to just trusting the real score outright. Main
search's move-selection call now branches once per selection (not once
per candidate move) between SelectBestNoHistory (IID-rescored plies)
and SelectBestWithHistory (everyone else), keeping the overwhelmingly
common non-rescored path at zero added cost.

Net measured effect (ecm_ringers.ep_/ecm_confident_quick.ep_/
ecm_hard_quick.ep_, sn=5M): 10/90/9, down from a pre-existing 11/88/10
on ringers and hard specifically -- see lmr_testing/RESULTS.md for the
full sweep of rejected alternatives and why the regression was accepted
as the cost of removing a latent, leak-prone bug class rather than
chasing the exact prior numbers.

Co-Authored-By: Claude Sonnet 5 <[email protected]>
Claude-Session: https://claude.ai/code/session_01YGSMkwjqiCk4XhbfN7ugD2

1 files changed, 40 insertions, 5 deletions

diff --git a/src/search.c b/src/search.c
index eb931bc..6e596ab 100755
--- a/src/search.c
+++ b/src/search.c
@@ -200,6 +200,7 @@ Search(IN SEARCHER_THREAD_CONTEXT *ctx,
     DTEnterNode(ctx, uDepth, FALSE, iAlpha, iBeta);
     iInitialAlpha = iAlpha;
     pi->fPvNode = (iBeta != iAlpha + 1);
+    pi->fMovesRescoredByIID = FALSE;
     ASSERT((IS_CHECKING_MOVE(mvLast) && (TRUE == pi->fInCheck)) ||
            (!IS_CHECKING_MOVE(mvLast) && (FALSE == pi->fInCheck)));
 
@@ -413,13 +414,19 @@ Search(IN SEARCHER_THREAD_CONTEXT *ctx,
                     // EXPERIMENT: If we got no best move from the
                     // hash table and the best move we got from the
                     // generator looks crappy (i.e. is not a winning
-                    // or even capture/promotion) then rescore the
-                    // moves we generated at this ply using a
-                    // shallower search.  "Internal Iterative
-                    // Deepening" or something like it.
+                    // or even capture/promotion, AND not a killer --
+                    // a killer move already proved itself elsewhere in
+                    // the tree, unlike an untested quiet move, so it
+                    // doesn't need IID's help) then rescore the moves
+                    // we generated at this ply using a shallower
+                    // search.  "Internal Iterative Deepening" or
+                    // something like it.
                     if ((iAlpha + 1 != iBeta) &&
                         (mvHash.uMove == 0) &&
                         (ctx->sMoveStack.mvf[x].iValue < SORT_THESE_FIRST) &&
+                        (0 == (ctx->sMoveStack.mvf[x].iValue &
+                               (FIRST_KILLER | SECOND_KILLER |
+                                THIRD_KILLER | FOURTH_KILLER))) &&
                         (uDepth >= FOUR_PLY))
                     {
                         ASSERT(uDepth >= (IID_R_FACTOR + ONE_PLY));
@@ -457,7 +464,35 @@ Search(IN SEARCHER_THREAD_CONTEXT *ctx,
                     ASSERT(x >= ctx->sMoveStack.uBegin[ctx->uPly]);
                     if (uLegalMoves < SEARCH_SORT_LIMIT(ctx->uPly))
                     {
-                        SelectBestWithHistory(ctx, x);
+                        // On an IID-rescored ply, mvf[].iValue holds a
+                        // real, honest eval-axis score from an actual
+                        // shallow search (see RescoreMovesViaSearch) --
+                        // trust it outright, same principle as
+                        // ComputeMoveScore's IID-trust branch. Two
+                        // alternatives were measured and rejected (see
+                        // RESULTS.md): blending history into the real
+                        // score (scaled or capped) invents a new,
+                        // leak-prone move-scoring axis on top of an
+                        // already-crowded set (generate.c's ordering
+                        // encoding, RescoreMovesViaSearch's real scores,
+                        // root.c's own scheme) and measures no better
+                        // than trusting the score outright; a pure
+                        // tiebreak-on-exact-ties compromise still cost
+                        // solves relative to full mixing, so it wasn't
+                        // buying its complexity either. The branch lives
+                        // here (once per selection call), not inside
+                        // SelectBestWithHistory (once per candidate
+                        // move in a hot per-node loop), to keep the
+                        // overwhelmingly common non-rescored path at
+                        // zero added cost.
+                        if (TRUE == pi->fMovesRescoredByIID)
+                        {
+                            SelectBestNoHistory(ctx, x);
+                        }
+                        else
+                        {
+                            SelectBestWithHistory(ctx, x);
+                        }
                     }
                     mv = ctx->sMoveStack.mvf[x].mv;
 #ifdef DEBUG