# Computer Chess Club Archives

## Messages

### Subject: "Percentage of fail-highs" question

Author: Daniel Clausen

Date: 13:52:21 01/03/00

```Hi

I have a question concerning the percentage of fail highs, especially fail
highs after the first tried move in a position. I heard from different
sources that the expected fail high percentage for the first tried move
should be somewhere >90%.

When I calculate 7 plies from the initial position I get the following values:

branching factor = 4.61
#nodes=170429            // Total number of nodes generated
#q=19291 [1%]         // #(quiescense-nodes#
#i=401 [0%]           // #(illegal nodes) (ie side-to-move in check)
#positions=50063         // #positions on which a search is applied to
#fhs=27982 [55%]      // #positions where I get a fail-high (FH)
#fh1s=23591 [47%]     // #positions where the FH occurs after the 1st move
#pvsTries=126872         // # of search-tries with [alpha, alpha+1] window
#pvsFails=21 [0%]     // # of PVS-related researches

As you can see, the percentage on fail-highs after the 1st move, are *far*
away from the 90%...

I agree that my move-ordering is not the best:
- Hash move
- Capture moves (ordered by MVV/LVA)
- Other moves (the first two sorted by history-value)

So I surely can improve a bit with a more decent move-ordering. But my
feeling is that hash moves should have the biggest influence. And without
hashing I get the values:

branching factor = 5.58
#positions=171551
#fhs=85721 [49%]
#fhs1s=67770 [39%]

So hash-moves helped but not as much as expected... 39% -> 47%.

I'm beginning to think that maybe I count them in a wrong way.
Here's the relevant code:

int searchWhite(ply, alpha, beta, ...)
{
legalMoves = 0;
positions  = 0;

// Loop over all moves.
while( (move=nextMove(ply)) != NO_MOVE)
{
makeWhiteMove(move);

// Search the 1st move with the full window.
// Is that okay?
if(legalMoves==0)
{
score = searchBlack(ply+1, alpha, beta, ...);
}
// Search the rest of the moves with a minimal window.
else
{
pvsTries++;
score = searchBlack(ply+1, alpha, alpha+1, ...);

if(score>alpha && score<beta)
{
pvsFails++;
score = searchBlack(ply+1, alpha, beta, ...);
}
}

best = max(best, score);
unmakeWhiteMove(move);

if(alpha>=beta)
{
failHighs++;
if(legalMoves == 0) failHighsOn1st++;

return beta;
}

legalMoves++;
}
}

Any comments? Did I miss something or is my move-ordering simply