22...dxe3 23. Qxe3 Qxe3+ 24. Nxe3 Nxf4 25. Ne2 Nxe2+ 26. Rxe2 Ba8 27. c2 Rxa7 28. Rc8+ Kg7 29. a3.

White threatens Nxc6, Nxb7, Qxf4 and Rxb7.

Black can attack the white king with four pieces, starting with 27... Nh3+:

A) 28.gxh3 Qh1+ 29.Kf2 Rf6+

A.1) 30.Ke3 Qe4(f3)#.

A.2) 30.Ke2 Qf1+ (or 30... Qf3+ 31.Ke1 Qf1#) 31.Ke3 Q(R)f3#.

A.3) 30.Kg3 Qf3+ 31.Kh4 Rf4+ and mate next.

A.4) 30.Qf4 Rxf4+ and mate soon.

B) 28.Kh1 Rf6

B.1) 29.Ne3 Qe4 (threatens Qb1+ and Qxe3)

B.1.a) 30.Qc(e)1 Qxe3 31.Qxe3 (due to Qxc1+ and Bxg2+; 31.Qd1 Qd2 wins) 31... Rf1+ 32.Qg1 Rxg1#.

B.1.b) 30.Nac4 Qb1+ and mate in two.

B.2) 29.Qe2 Qxg2+ 30.Qxg2 Rf1#.

C) 28.Kf1 Qe4 (neither Rf6+ nor Ba6+ seem to work)

C.1) 29.Rxb7 Rf6+

C.1.a) 30.Nf2 Qb1+ 31.Ke2 (31.Qe1 Rxf2+ 32.Kg1 Qxe1#) 31... Rxf2+ 32.Ke3 Rxd2 33.Kxd2 Nf4 looks winning (34.a8=Q Qd3+ and mate next; 34.Rb3 Qe4; 34.Kc3 Qe1+ and 35... Qxa5; 34.Ke3 g5 threatening Qe1+ and creating a mating net).

C.1.b) 30.Qf2 Qd3+ 31.Ke1 Nxf2 32.Nxf2 Qe3+ and mate soon.

C.2) 29.gxh3 Rf6+

C.2.a) 30.Nf2 Qg2+ 31.Ke1 Qg1+ 32.Ke2 Rxf2+ 33.Ke3 Rxd2 34.Kxd2 Qxd4+ and 35... Qxa7 wins decisive material.

C.2.b) 30.Qf2 Qd3+ 31.Ke1 Re6+ 32.Ne3 Rxe3+ 33.Qxe3 Qxe3+ 34.Kd1 (34.Kf1 Bf3 and mate soon) 34... Qxd4+ as above.

Stockfish 11 says:

27... Nh3+

(27. .. Nh3+ (♘f4-h3+ ♔g1-f1 ♕c6-e4 ♕d2-e3
♕e4xg2+ ♔f1-e1 ♘h3-g5 ♖b8xb7 ♖d6-e6 ♖b7xf7+ ♔g7xf7 a7-a8♕ ♕g2xa8 ♘a5-c4 ♖e6xe3+ ♘d1xe3 ♕a8xa2 d4-d5 ♕a2-b1+ ♔e1-e2 ♔f7-g7 ♘e3-f1 ♕b1-e4+ ♘f1-e3 ♕e4-h4 ♔e2-d3 ♕h4xh2 ♘e3-d1 ♕h2-g3+ ♘d1-e3 ♕g3-f4 ♘c4-d2 ♕f4-e5 ♘d2-c4 ♕e5-e4+ ♔d3-c3 ♘g5-h3 ♔c3-b3 ♕e4-d4 ♔b3-b4 ♘h3-f2 d5-d6 ♘f2-e4 d6-d7 ♕d4xd7 ♘e3-c2 ♕d7-d5 ♘c2-e3 ♕d5-d4 ♔b4-a3 ♕d4-c5+ ♔a3-a4 ♕c5-a7+ ♔a4-b3 ♕a7-b8+ ♔b3-c2 ♕b8-b5 ♔c2-d3) +13.71/42 204)

I needed to spoon-feed Stockfish with its own suggestion. After its first 4 ply, 28 Kf1 Qe4 29 Qe3 Qxg2+ 30 Ke1,

click for larger view

Stockfish gives

30 … Nf4 (now evaluated as winning at -2.83, a pawn better than after 28 Kf1)

30.Kg1? leads to the brilliant Qxg2+! 31.Nxg2 Nh3+ 32.Kh1 Rf1# as Black solved both the queen defending g2 and the defender of f1 by successfully playing Nf2+ and Qxg2+. However, after 30.Qxf2! I thought 30....Qc1+ won as Black controls the back rank sufficiently. Any interposing on f1 is just Qxf1+ with Rxf1#. But 31.Qg1! +- works as the knight's no longer on h3 (this oversight I missed). Shame, as that ending would have been flashy enough :>

Incidentally, in the line you gave, in the position resulting from 29.Qg1:

click for larger view

You should double check <ALL>classic engine analysis regardless of the time spent in evaluating the next move, whether it's 6 secs or 60 hours. Engines evaluate a move based on the leaf nodes of its search tree, and in each and every instance the evaluation of the moves at the end of the line is based on a shallower search than the moves at the beginning of a line. In the most extreme example a classic chess engine might evaluate the position after White's last move in a search as winning, even though Black might have a mate in one on it's next move. The classic chess engine is simply blind at the end, one type of horizon effect. Check my forum's header for the definition of what I egotistically call AKC2ML (AylerKupp's Corollary to Murphy's Law).

Stockfish in particular is prone to gross mis-evaluations in a shallow search such as the example you gave. This is also commonly evident in it's analysis during on-line chess games; you see it evaluate a certain move in a position as being the best, the player makes it, and on it's next move it evaluates the position much differently than it did a ply before, even though the player made the move it suggested as best. You simply need to let Stockfish calculate longer so that it reaches a deeper search ply than other engines before you can have adequate confidence in its evaluations.

If the sac is accepted, then it's a quick death for white with 28... ♕h1+ 29. ♔f2 ♖f6+ 30. ♔g3 ♕f3+ 31. ♔h4 ♖f4+ and mate next move.

If white plays 28. ♔h1, then 28... ♖f6 Δ ♖f1#. The h2 pawn is physically blocked and the g2 pawn is pinned, so there's no way of giving the king some luft. 29. ♘e3 covering the f1 square looks like a good try, but it fails to 29... ♕e4 Δ ♕b1+, and white can't cope with the number of threats to its weak back rank.

Forward sliding is an effective, although highly time-consuming way, to make sure that an engine's evaluations are not adversely affected by the horizon effect. Then it's a question of deciding at which move to restart the analysis. The most extreme example was used by user <kutztown46> where he restarted the analysis multiple times and each time one ply later. I called this a "creeping barrage" alluding to the bombarding of enemy lines during WW I as the infantry advanced.

Sometimes I do what I call "forward leaping", a play on the words "forward sliding". It's meant to be a quick confidence check and involves starting the analysis at the position reached after the last move in the initial analysis. It's not so much about finding better moves or determining where the engine might have gone wrong but to try to verify the soundness of the initial analysis. If the engine's evaluation after forward leaping is consistent with the initial evaluation, then I have reasonable confidence that the initial evaluation was reasonable. But if it is very different then I conclude that the engine made a mistake somewhere along the way and there were better moves to be made.

In that case my preferred approach in finding where the engine went wrong is to do a binary-like search. Say the engine generates a 40-ply analysis and its principal variation (representing best play by both sides) evaluates the resulting position at [+1.23]. I do a forward leap and let the engine do another 40-ply analysis and it comes up with an evaluation of [+0.12]. Clearly the initial evaluation might have been faulty (it's also possible that it was the subsequent evaluation that was faulty). So I restart the analysis at the position 20 plies from the initial position. If that evaluation is, say, [+1.20], then the analysis after the first 20 plies was reasonable and no obvious mistakes were made by the engine during its evaluation of the first 20 plies. If that evaluation is, say, [+0.10] then the engine seemingly made a mistake during its evaluation of its first 20 plies. In the first case I restart the analysis from the position after the 30th ply since if the engine made a mistake it made in its analysis of plies 20 – 40, and in the second case I restart the analysis on the position after the 10th ply since if the engine made a mistake, it made it in plies 1 – 20.

I then repeat the process each time halving the interval between plies in the initial analysis until I converge to a ply in the initial analysis where I get a significant difference between the initial and subsequent evaluations. That would be the ply where the engine made a mistake in the initial analysis, most likely due either to the horizon effect or a too-aggressive pruning of its search tree.

At my level of play (national master, although beyond the 2200 rating now), I run my games by the engine for the very pragmatic reason that I want to either confirm or spot what I did wrong, and confirm or spot what better choices I had. I don't try to answer the question "what was the best move?" unless it's pure tactics, at which any engine is much, much better than me, of course.

IMHO, the ultimate limitation of engines is that they cannot factor in human psychology. From a practical point of view, a suboptimal move may be the psychologically advisable move. What is the point evaluation of tricking your opponent into playing a line that he usually avoids, for example?

In this game, sure, I would have probably lost if my opponent had played anything reasonable but the tempting 27.Na5. But given what I had at move 24 (that self-inflicted disaster), I did pretty much the best available with 24...Qc6 and subsequent moves to maximize my likelihood of swindling the game.

The computer may not agree, because the computer calculates everything and has no psychological factor. So, if one line risks losing the game immediately but creates a trap (what I played) and another line goes into a completely hopeless, lost endgame, the computer will choose the slow death because it assumes the trap will be spotted and foiled.

Another way of putting this is: if line A gives +4 and line B gives +3, black is not necessarily significantly less likely to lose in line B than in line A. Both positions are technically lost. Black is less likely to lose if he plays the line that creates more traps and problems for white. If that line is A, then go for A even if the computer rejects it.

Yes, that's one purpose. But I should say "goal" since I realize that the ultimate truth is unattainable. My second purpose is to learn and figure out why the computer suggested a particular best move but that's not an easy thing to do. I've felt for some time that, since all the information is available that the computer uses to determine what the best move is, you should be able to request it and have it presented in a simpler, human-understandable way. In older rule-based system you had an expert or set of experts define appropriate rules and let the computer decide which, often conflicting, rules to use. You could then query the computer for it to tell you why it evaluated a particular answer to be the best.

But that's not likely to happen with commercial chess engines because the details of their evaluation function are considered proprietary, and a wonderful learning opportunity is lost.

<IMHO, the ultimate limitation of engines is that they cannot factor in human psychology. From a practical point of view, a suboptimal move may be the psychologically advisable move.>

User <Sally Simpson> and I have had many discussions along the same lines. While it may be true that a classic chess engine will not play anything other than what it evaluates to be the best move (although it will suggest as many second, third, etc. best moves as you ask it to, within reason), I don't think that it has much practical significance. Currently engines only play against other engines and humans only play against other humans. And if in a reasonably lost position an engine tries to fool the other engine and tries to swindle it by playing other than the best move, it will not likely fool the other engine at all. The winning engine will select the best move to play in response and, the losing engine will simply lose more quickly.

Only in games between humans and engines, when the engine finds itself in a losing position, would an attempted swindle by playing objectively worse moves would make sense. But how a engine capable of superior play find itself in a losing position in the first place?

And I'm sure there are exceptions but I doubt that there are many. Now, developers of chess engines that use MCTS instead of minimax to determine which move to make claim that the engines play more "human like", as though this is something to strive for. Well, for some it is, but not to me. The fact is that for sometime when a human plays against a chess engine the human will likely lose, unless the engine is operating under a material or time handicap or both. So, if the objective is to win, I don't see much virtue of having the engine play "human like" moves which may not be necessarily the best and increase its losing chances.

<Black is less likely to lose if he plays the line that creates more traps and problems for white.>