You don't need to be a strong chess player for such positions, it's as easy as playing a game, seeing the variations, and figuring out that you can't make progress.

I don't think programmers have been taken the right approach for such endgames, what they do is adding special knowledge for known drawn positions of the board so the engine tags them as 0.00 instead of using normal evaluation. This works for the special positions but leaves huge gaps for similar positions where the knowledge doesn't apply (say, a pawn on a different file doesn't make a difference for a draw result, yet the engine thinks this is winning because here its knowledge doesn't apply.)

With so many possibilities the approach of adding cases one by one becomes impractical, instead, I think the chess engine should change its paradigm of how the positions are searched because the way it builds a tree of lines no longer works, because all the leaf nodes have the wrong winning evaluation. Also, if the position is actually winning, there will be leaf nodes with right evaluation and wrong evaluation, and the engine can't tell them apart, the chance that it picks the wrong move is high.

Instead, I propose that the engine should find ways to win the position, and tag them temporary as 0.00 the ones it can't win. It can be as simple as doing something that I'd call "super-extensions", where the mainline is extended out till the end of the game (at depth 1 this shouldn't be too costly for a single leaf) or till the fail low happens where the engine realizes it can no longer win, or until the score gets to a zenith (say, root eval+4.00 cp, means 4 pawns of progress which should be enough.)

In drawn endgames, the engine will not be able to do that, because eventually 50-move rule hits in, and then, the engine can tag the whole branch without pawn moves and captures, and all the moves that transpose to it as 0.00 (temporarily), and repeat the process somewhere else. It doesn't matter if the position is actually winning, because the engine will go back to it when the other alternatives hit the 0.00 tag. Eventually the engine will be left with positions that are really winning (at least the engine can see from current position to winning position, which means the endgame isn't "dead drawn"), will prune most of the drawish positions increasing speed significantly, or tag all lines 0.00 without deviation so it'll show the right score of the position.

Currently, the engine uselessly and hopelessly reaches very high depths in such positions giving the wrong score, and all that time is wasted, so a good endgame module that takes over, at say, depth 20 onwards, would make a better time spent.

As an example, here's a position Richard Vida posted recently:



It's an obvious draw a human can defend without engine assistance, but most engines think white is totally winning. Heh, I'd love to see the Rybka Cluster analyzing this and showing a wrong winning eval up to several hours of analysis.

Well, here, if the engine switched paradigms, it could see that its mainline can't be won and that there are not possible winning deviations and the position would show a right 0.00 very fast.

Critter is currently analyzing this position correctly but I guess it's knowledge based, or based on fortress recognition that would be something too specific to be useful on other kinds of positions Critter is still analyzing wrongly.

I think the right search approach could solve such positions on the fly, and perhaps it could be used in other stages of the games as well (i.e. when two top non-transposing moves are tied in score, the engine could see and search if one of them could lead to a bigger advantage with "super-extensions".)