Old testposition I posted revisited...

[Eelco de Groot]

..but it's not for Rybka that will find it fast, and the position is also from a game against Rybka, Rybka 2.2n2 the free version. Ancalagon can only find the move stably after a few minutes, and that is after I increased the value for an open rookfile from Stockfish's value 43 to 50.

Code: Select all

  // Rooks on open files
  const Value RookOpenFileBonus = Value(50);

Maybe 50 is too much, but it seemed the simplest method to get that rook on e8 where it belongs Ancalagon was thinking ages about the 27... Re8 move but rejecting it twice while Rd7 slowly sank further - I think that move loses-, so I knew just a little push might help the right move over the alpha-testedge

[d]3r1k2/p5pp/n1NP1p2/1NbB1b2/5P2/1P6/5P1P/5RK1 b - - bm Re8; id "critical defence 001 am 27...Rd7"; c0 "Rybka 2.2n2-Blueberry Beta4 Build 375 10-03-2009";

3r1k2/p5pp/n1NP1p2/1NbB1b2/5P2/1P6/5P1P/5RK1 b - -

Engine: Ancalagon 1.3 WS180 [new] Build 98 (Athlon 2009 MHz, 256 MB)
by Romstad, Costalba, Kiiski, de Groot

2.00 0:00 -0.70 1...Rd7 2.Ra1 (936) 4

3.00 0:00 -0.52 1...Rd7 2.Ra1 Nb4 (15.602) 66

4.00 0:00 +0.07 1...Rd7 2.Re1 Bxd6 3.Nxd6 Rxd6 (52.836) 177

5.00 0:00 +0.31 1...Rd7 2.Ra1 Nb4 3.Bg2 Nxc6 4.Bxc6 (125.903) 335

6.00 0:00 -0.76 1...Rd7 2.Rc1 (183.512) 405

7.00 0:00 -1.25 1...Rd7 2.Rc1 Bd3 3.Ncxa7 Bg6 4.Nc8 Bd3
5.Bc6 (583.389) 602

8.01 0:01 -1.25 1...Rd7 2.Rc1 Bd3 3.Ncxa7 Bg6 4.Nc8 Bd3
5.Bc6 (945.060) 687

9.01 0:02 -1.15 1...Rd7 2.Rc1 Bb6 3.b4 Bd3 4.Bc4 Bxc4
5.Rxc4 Ke8 6.Re4+ Kf7 (1.507.206) 742

10.01 0:02 -1.29 1...Rd7 2.Rc1 Rxd6 3.Nxd6 Bxd6 4.Ra1 Nc7
5.Bc4 Be4 6.Nd4 Bc5 (2.413.303) 812

11.01 0:04 -1.27 1...Rd7 2.Rc1 Rxd6 3.Nxd6 Bxd6 4.Ra1 Nc7
5.Bc4 Be4 6.Nd4 Bc5 7.Re1 (4.276.666) 903

12.01 0:11 -1.07 1...Rd7 (10.772.909) 914

13.01 0:19 -1.49 1...Rd7 2.Rc1 Bxd6 3.Ncd4 Bc5 4.Be6 Rxd4
5.Nxd4 Bg6 6.Nc6 Nc7 7.f5 Nxe6
8.fxe6 Be7 9.Nxe7 Kxe7 10.Rc7+ Kxe6
11.Rxg7 (17.968.916) 931

14.01 0:36 -1.49 1...Rd7 2.Rc1 Bxd6 3.Ncd4 Bc5 4.Be6 Rxd4
5.Nxd4 Bg6 6.Nc6 Nc7 7.f5 Nxe6
8.fxe6 Be7 9.Nxe7 Kxe7 10.Rc7+ Kxe6
11.Rxg7 (34.229.070) 942

15.01 0:58 -1.58 1...Rd7 2.Rc1 Bxd6 3.Ncd4 Bc5 4.Be6 Rxd4
5.Nxd4 Bg6 6.Nc6 Bb6 7.f5 Be8 8.Rc3 Bxc6
9.Rxc6 (57.287.537) 986

16.01 5:37 -1.62 1...Rd7 2.Rc1 Bxd6 3.Ncd4 Bc5 4.Be6 Rxd4
5.Nxd4 Bg6 6.Nf5 Nc7 7.Bd7 Bb6 8.Kg2 Bf7
9.b4 Bd5+ 10.Kg3 (303.069.946) 898

16.02 5:58 -1.62 1...Re8 (322.475.693) 898

17.01 7:40 -1.42 1...Re8 (424.415.824) 921

18.01 8:53 -1.47 1...Re8 2.Ra1 Nb8 3.Rc1 Bb6 4.Nc7 Nxc6
5.Nxe8 Nb4 6.Nc7 Nd3 7.Rc6 Nxf4
8.Rc4 Bd4 9.Nb5 Be5 10.Be4 Bd7
11.Nxa7 Bxd6 12.Bxh7 (484.837.451) 908

19.01 33:07 -1.33 1...Re8 2.Ra1 Nb4 3.Nxb4 Bxb4 4.Rxa7 Bh3
5.Rf7+ Kg8 6.Rc7+ Kh8 7.f3 Rb8 8.Bb7 Rd8
9.Rc4 Bxd6 10.Nxd6 Rxd6 11.Bc8 f5
12.b4 Rd2 13.b5 Rg2+ 14.Kh1 Rb2 (1.741.452.104) 876

20.01 50:05 -1.27 1...Re8 2.Ra1 Nb4 3.Nxb4 Bxb4 4.Rxa7 Bh3
5.Rf7+ Kg8 6.Rc7+ Kh8 7.f3 Rb8 8.Bb7 Rd8
9.Kf2 Be6 10.Kg2 Bxb3 11.Rc8 Rxc8
12.Bxc8 Kg8 13.d7 Be7 14.Kg3 (2.628.489.771) 874

21.01 88:30 -1.27 1...Re8 2.Ra1 Nb4 3.Nxb4 Bxb4 4.Rxa7 Bh3
5.Rf7+ Kg8 6.Rc7+ Kh8 7.f3 Rb8 8.Bb7 Rd8
9.Rc4 Bxd6 10.Nxd6 Rxd6 11.Bc8 f5
12.Kf2 Rd2+ 13.Ke3 Rxh2 14.Rc7 g6 (4.640.418.577) 873

best move: Rd8-e8 time: 112:41.219 min n/s: 877.465 nodes: 5.932.710.462

Are there programs out there that will find it as fast as Rybka does? I think it is the only saving move in a difficult position. I wrote before that I intended to make a testsuite with these kinds of positions but I don't really seem to have enough time for playing testgames and then finding some critical positions in them, my excuse is programming is too difficult to do that kind of rigorous testing as well... It would be a good practice though, also for myself because it trains you in analysis and allows you to concentrate hopefully some chess knowedge both for your program or yourself if you want to improve chess-skills, condensed in a single position to remember. But so far I have only 'Critical defence 001'

Eelco

[kgburcham]

[d] 3r1k2/p5pp/n1NP1p2/1NbB1b2/5P2/1P6/5P1P/5RK1 b - -


Cyclone 3.0

15/36 0:01 +1.55 1...Rd7 2.Rc1 Bxd6 3.Ncd4 Bc5 4.Be6 Rxd4 5.Nxd4 Bd3 6.Bf5 Bxf5 7.Nxf5 g6 8.Ne3 Ke7 9.Kg2 Kd7 10.Kf3 (1.650.579) 4096
15/38 0:04 +1.05 1...Re8 2.Ra1 Nb4 3.Nxb4 Bxb4 4.Rxa7 Bh3 5.Rf7+ Kg8 6.Rc7+ Kh8 7.f3 Rd8 8.Kf2 Bxd6 9.Nxd6 Rxd6 10.Rc5 h5 11.b4 Bf5 12.b5 Kh7 13.Ke3 (4.042.598) 4010
16/42 0:09 +1.03 1...Re8 2.Ra1 Nb4 3.Nxb4 Bxb4 4.Rxa7 Bh3 5.Rf7+ Kg8 6.Rc7+ Kh8 7.f3 Rd8 8.Kf2 Bxd6 9.Nxd6 Rxd6 10.Rc5 Bf5 11.b4 h5 12.b5 Kh7 13.Ke3 Kg6 (8.974.298) 3915
17/42 0:11 +1.07 1...Re8 2.Ra1 Nb4 3.Nxb4 Bxb4 4.Rxa7 Bh3 5.Rf7+ Kg8 6.Rc7+ Kh8 7.f3 Rd8 8.Kf2 Bxd6 9.Nxd6 Rxd6 10.Rc5 g6 11.b4 Bd7 12.Ke3 Kg7 13.b5 h5 14.Kd4 (11.268.432) 3923
18/42 0:17 +1.12 1...Re8 2.Ra1 Nb4 3.Nxb4 Bxb4 4.Rxa7 Bh3 5.Rf7+ Kg8 6.Rc7+ Kh8 7.f3 Rd8 8.Kf2 Bxd6 9.Nxd6 Rxd6 10.Rc5 g6 11.b4 Bd7 12.b5 Kg7 13.Ke3 Kf8 14.Kd4 Ke7 (16.771.780) 3945
19/43 0:29 +1.07 1...Re8 2.Ra1 Nb4 3.Nxb4 Bxb4 4.Rxa7 Bh3 5.Rf7+ Kg8 6.Rc7+ Kh8 7.f3 Rd8 8.Be4 Bxd6 9.Nxd6 Rxd6 10.f5 Kg8 11.Kf2 Rd2+ 12.Ke3 Rxh2 13.Bd5+ Kf8 14.Rf7+ Ke8 (29.302.356) 3975
20/48 1:02 +1.06 1...Re8 2.Ra1 Nb4 3.Nxb4 Bxb4 4.Rxa7 Bh3 5.Rf7+ Kg8 6.Rc7+ Kh8 7.f3 Rd8 8.Kf2 g6 9.Bc6 Bxd6 10.Nxd6 Rxd6 11.Kg3 Be6 12.b4 Rd2 13.b5 Rb2 14.h4 Bc4 (62.151.640) 3998
21/52 2:21 +1.10 1...Re8 2.Ra1 Nb4 3.Nxb4 Bxb4 4.Rxa7 Bh3 5.Rf7+ Kg8 6.Rc7+ Kh8 7.f3 g6 8.Be4 Rd8 9.Kf2 Bxd6 10.Nxd6 Rxd6 11.Ke3 Be6 12.b4 Rb6 13.Re7 Bc4 14.f5 g5 (141.888.038) 4007

[michiguel]

[d] 3r1k2/p5pp/n1NP1p2/1NbB1b2/5P2/1P6/5P1P/5RK1 b - -


Cyclone 3.0

15/36 0:01 +1.55 1...Rd7 2.Rc1 Bxd6 3.Ncd4 Bc5 4.Be6 Rxd4 5.Nxd4 Bd3 6.Bf5 Bxf5 7.Nxf5 g6 8.Ne3 Ke7 9.Kg2 Kd7 10.Kf3 (1.650.579) 4096
15/38 0:04 +1.05 1...Re8 2.Ra1 Nb4 3.Nxb4 Bxb4 4.Rxa7 Bh3 5.Rf7+ Kg8 6.Rc7+ Kh8 7.f3 Rd8 8.Kf2 Bxd6 9.Nxd6 Rxd6 10.Rc5 h5 11.b4 Bf5 12.b5 Kh7 13.Ke3 (4.042.598) 4010
16/42 0:09 +1.03 1...Re8 2.Ra1 Nb4 3.Nxb4 Bxb4 4.Rxa7 Bh3 5.Rf7+ Kg8 6.Rc7+ Kh8 7.f3 Rd8 8.Kf2 Bxd6 9.Nxd6 Rxd6 10.Rc5 Bf5 11.b4 h5 12.b5 Kh7 13.Ke3 Kg6 (8.974.298) 3915
17/42 0:11 +1.07 1...Re8 2.Ra1 Nb4 3.Nxb4 Bxb4 4.Rxa7 Bh3 5.Rf7+ Kg8 6.Rc7+ Kh8 7.f3 Rd8 8.Kf2 Bxd6 9.Nxd6 Rxd6 10.Rc5 g6 11.b4 Bd7 12.Ke3 Kg7 13.b5 h5 14.Kd4 (11.268.432) 3923
18/42 0:17 +1.12 1...Re8 2.Ra1 Nb4 3.Nxb4 Bxb4 4.Rxa7 Bh3 5.Rf7+ Kg8 6.Rc7+ Kh8 7.f3 Rd8 8.Kf2 Bxd6 9.Nxd6 Rxd6 10.Rc5 g6 11.b4 Bd7 12.b5 Kg7 13.Ke3 Kf8 14.Kd4 Ke7 (16.771.780) 3945
19/43 0:29 +1.07 1...Re8 2.Ra1 Nb4 3.Nxb4 Bxb4 4.Rxa7 Bh3 5.Rf7+ Kg8 6.Rc7+ Kh8 7.f3 Rd8 8.Be4 Bxd6 9.Nxd6 Rxd6 10.f5 Kg8 11.Kf2 Rd2+ 12.Ke3 Rxh2 13.Bd5+ Kf8 14.Rf7+ Ke8 (29.302.356) 3975
20/48 1:02 +1.06 1...Re8 2.Ra1 Nb4 3.Nxb4 Bxb4 4.Rxa7 Bh3 5.Rf7+ Kg8 6.Rc7+ Kh8 7.f3 Rd8 8.Kf2 g6 9.Bc6 Bxd6 10.Nxd6 Rxd6 11.Kg3 Be6 12.b4 Rd2 13.b5 Rb2 14.h4 Bc4 (62.151.640) 3998
21/52 2:21 +1.10 1...Re8 2.Ra1 Nb4 3.Nxb4 Bxb4 4.Rxa7 Bh3 5.Rf7+ Kg8 6.Rc7+ Kh8 7.f3 g6 8.Be4 Rd8 9.Kf2 Bxd6 10.Nxd6 Rxd6 11.Ke3 Be6 12.b4 Rb6 13.Re7 Bc4 14.f5 g5 (141.888.038) 4007

Gaviota finds it in 12 seconds (AMD 2.4 gHz)

Miguel

Code: Select all

      8404   4:      0.1    -0.24  Rd7 2.Ra1 Nb4 3.Nxb4 Bxb4
     11285   5       0.1    -0.23  Rd7 2.Ra1 Nb4 3.Nxb4 Bxb4 4.Bc6
     17966   5:      0.2    -0.23  Rd7 2.Ra1 Nb4 3.Nxb4 Bxb4 4.Bc6
     27851   6       0.3    -0.43  Rd7 2.Ra1 Nb4 3.Nxb4 Bxb4 4.Bc6 Rd8
                                   5.Rxa7 Bxd6 6.Nxd6 Rxd6
     50593   6:      0.5    -0.43  Rd7 2.Ra1 Nb4 3.Nxb4 Bxb4 4.Bc6 Rd8
                                   5.Rxa7 Bxd6 6.Nxd6 Rxd6
     68984   7       0.7    -0.43  Rd7 2.Ra1 Nb4 3.Nxb4 Bxb4 4.Bc6 Rd8
                                   5.Rxa7 Bxd6 6.Nxd6 Rxd6
    128106   7:      1.1    -0.43  Rd7 2.Ra1 Nb4 3.Nxb4 Bxb4 4.Bc6 Rd8
                                   5.Rxa7 Bxd6 6.Nxd6 Rxd6
    232209   8       1.6      :-(  Rd7
    429388   8       2.2      :-(  
    515397   8       2.5    -1.07  Rd7 2.Rc1 Bxd6 3.Ncd4 Bc7 4.Be6 Rxd4
                                   5.Nxd4 Bxf4
    765511   8:      3.2    -1.07  Rd7 2.Rc1 Bxd6 3.Ncd4 Bc7 4.Be6 Rxd4
                                   5.Nxd4 Bxf4
    943992   9       3.7    -1.07  Rd7 2.Rc1 Bxd6 3.Ncd4 Bc7 4.Be6 Rxd4
                                   5.Nxd4 Bxf4
   1434055   9:      5.3    -1.07  Rd7 2.Rc1 Bxd6 3.Ncd4 Bc7 4.Be6 Rxd4
                                   5.Nxd4 Bxf4
   1873511  10       6.6      :-(  Rd7
   3589454  10      12.1    -1.18  Re8 2.Ra1 Nb4 3.Nxb4 Bxb4 4.Rxa7 Bh3
                                   5.Rf7+ Kg8 6.Re7+ Kf8 7.Bg2 Bg4 8.h3
                                   Bf5
   4645755  10:     15.3    -1.18  Re8 2.Ra1 Nb4 3.Nxb4 Bxb4 4.Rxa7 Bh3
                                   5.Rf7+ Kg8 6.Re7+ Kf8 7.Bg2 Bg4 8.h3
                                   Bf5
   9081130  11      29.1    -0.85  Re8 2.Ra1 Nb4 3.Nxb4 Bxb4 4.Rxa7 Bh3
                                   5.Rf7+ Kg8 6.Rc7+ Kh8 7.f3 Rb8 8.Bc4
                                   Bd2 9.Kf2 Bxf4
  11717706  11:     36.7    -0.85  Re8 2.Ra1 Nb4 3.Nxb4 Bxb4 4.Rxa7 Bh3
                                   5.Rf7+ Kg8 6.Rc7+ Kh8 7.f3 Rb8 8.Bc4
                                   Bd2 9.Kf2 Bxf4
  23668131  12      73.0    -0.96  Re8 2.Ra1 Nb4 3.Nxb4 Bxb4 4.Rxa7 Bh3
                                   5.Rf7+ Kg8 6.Rc7+ Kh8 7.f3 Rb8 8.Bc4
                                   Rd8 9.Kf2 Bd7 10.Ke3 Bxb5 11.Bxb5 Bxd6
  34240774  12:    103.0    -0.96  Re8 2.Ra1 Nb4 3.Nxb4 Bxb4 4.Rxa7 Bh3
                                   5.Rf7+ Kg8 6.Rc7+ Kh8 7.f3 Rb8 8.Bc4
                                   Rd8 9.Kf2 Bd7 10.Ke3 Bxb5 11.Bxb5 Bxd6

[Eelco de Groot]

Thanks guys for trying the position! Impressively done by Gaviota and Cyclone 3.0!

So it seems that Rybka is not unique for finding this but seems simply alround good in finding these kind of prophylactic moves, actually this is more a last ditch defence of course and Rybka's prophylaxis would have never steered to such a position in the first place.

I maybe managed to improve Ancalagon's search just a bit but only tested in this position, I think one of the difficulties is that Glaurung gives a penalty if there are blocking pieces in front of a passed pawn, so moving the Rook to another file is discouraged especially with the pawn already advanced to the sixth rank. But the Rook here when on d7 is under the attack of those two Knights and the passed pawn is suficiently controlled by the white squared Bishop attacking the square directly in front of it, and one Knight, that could possibly challenge control of the square can't move because it has to defend the pawn from attack by the other, dark squared, Bishop from Black. So simplifying to the extreme you might say that Black's Bishop pair is possibly just barely enough to counter the advantage of a plus passed pawn that is so far advanced and even seemingly supported by the white Knights.

I tried to modify Glaurung's code for this kind of passed pawn where a blocking piece is not necessary and probably even dangerous to try, as d7 is not a safe square for the Rook. I was lucky that it really had an effect as predicted.

This is the codeblock that specifically handles the passed pawn with no Rook or with Rook in front of it:

Code: Select all

                    if ((b2 & pos.pieces_of_color(them)) == EmptyBoardBB)
                    {
                        // There are no enemy pieces in the pawn's path! Are any of the
                        // squares in the pawn's path attacked by the enemy?
                        if (b3 == EmptyBoardBB)
                            // No enemy attacks, huge bonus!
                            ebonus += Value(tr * (b2 == b4 ? 17 : 15));
                        else
						      {
                            // OK, there are enemy attacks. Are those squares which are
                            // attacked by the enemy also attacked by us?  If yes, big bonus
                            // (but smaller than when there are no enemy attacks), if no,
                            // somewhat smaller bonus.

New part:

Code: Select all

                            bonuspoints = Value(tr * ((b3 & b4) == b3 ? 13 : 8));

						          // Subtract some points if our passed pawn can't immediately 
						          // advance and especially if it is also attacked.
						          bonuspoints -= Value(indirectBlock * tr * (passed_pawnAttacked ? 4 : 3));
							       ebonus += bonuspoints;
						    }
                    }
                    else
                    {

3r1k2/p5pp/n1NP1p2/1NbB1b2/5P2/1P6/5P1P/5RK1 b - -

Engine: Ancalagon 1.3 WS180 Build 99 [new] (Athlon 2009 MHz,256 MB)
by Romstad, Costalba, Kiiski, de Groot

2.00 0:00 -0.70 1...Rd7 2.Ra1 (936) 3

3.00 0:00 -0.52 1...Rd7 2.Ra1 Nb4 (16.206) 60

4.00 0:00 +0.07 1...Rd7 2.Re1 Bxd6 3.Nxd6 Rxd6 (67.103) 195

5.00 0:00 +0.01 1...Rd7 2.Rd1 Nb4 3.Nxb4 Bxb4 4.Nd4 (138.878) 329

6.00 0:00 -0.70 1...Rd7 2.Rc1 (242.772) 431

7.00 0:00 -0.80 1...Rd7 2.Rc1 Bxd6 3.Ncd4 Bc5 4.Be6 Bxd4
5.Bxd7 (364.608) 518

8.00 0:01 -0.92 1...Rd7 2.Rc1 Ke8 3.Nb8 Nxb8 4.Rxc5 a6
5.Nd4 Bh3 6.Rc8+ Rd8 7.Rc7 Rxd6 (1.190.992) 680

9.01 0:02 -1.00 1...Rd7 2.Rc1 Ke8 3.Nb8 Nxb8 4.Rxc5 Kd8
5.Kg2 Na6 6.Rc1 Nb4 (2.034.867) 770

10.01 0:03 -1.09 1...Rd7 2.Rc1 Ke8 3.Nb8 Nxb8 4.Rxc5 Kd8
5.Nd4 Na6 6.Ra5 Bd3 (2.964.198) 821

11.01 0:08 -1.13 1...Rd7 2.Rc1 Ke8 3.b4 Bxd6 4.Ncd4 Bxf4
5.Rc8+ Rd8 6.Bc6+ Bd7 7.Bxd7+ Kxd7
8.Rxd8+ Kxd8 9.Ne6+ Ke7 10.Nxf4 Nxb4
11.Nxa7 (7.930.192) 888

12.01 0:13 -1.33 1...Rd7 2.Rc1 (13.130.054) 941

12.02 0:37 -1.21 1...Re8 2.Ra1 Nb4 3.Nxb4 Bxb4 4.Rxa7 Bh3
5.Rf7+ Kg8 6.Rc7+ Kf8 7.f3 Re2 8.f5 Bxf5
9.Nd4 Rd2 10.Nxf5 Rxd5 (33.607.033) 889

13.01 0:42 -1.21 1...Re8 2.Ra1 Nb4 3.Nxb4 Bxb4 4.Rxa7 Bh3
5.Rf7+ Kg8 6.Rc7+ Kf8 7.f3 Re2 8.f5 Bxf5
9.Nd4 Rd2 10.Nxf5 Rxd5 (39.215.203) 916

14.01 0:54 -1.21 1...Re8 2.Ra1 Nb4 3.Nxb4 Bxb4 4.Rxa7 Bh3
5.Rf7+ Kg8 6.Rc7+ Kf8 7.f3 Re2 8.f5 Bxf5
9.Nd4 Rd2 10.Nxf5 Rxd5 (51.971.072) 946

15.01 1:27 -1.41 1...Re8 2.Ra1 (85.866.306) 986

16.01 4:38 -1.39 1...Re8 2.Ra1 Nb8 3.Rc1 Bb6 4.Nc7 Nxc6
5.Nxe8 Nb4 6.Nc7 Nd3 7.Rc4 Nxf2
8.Kf1 Bd3+ 9.Kg2 Bxc4 10.bxc4 Ng4
11.Kf3 Nxh2+ 12.Ke4 (261.413.115) 939

17.01 5:58 -1.39 1...Re8 2.Ra1 Nb8 3.Rc1 Bb6 4.Nc7 Nxc6
5.Nxe8 Nb4 6.Nc7 Nd3 7.Rc4 Nxf2
8.Kf1 Bd3+ 9.Kg2 Bxc4 10.bxc4 Ng4
11.Kf3 Nxh2+ 12.Ke4 (342.254.246) 954

18.01 9:32 -1.45 1...Re8 2.Ra1 Nb8 3.Rc1 Bb6 4.Nc7 Nxc6
5.Nxe8 Nb4 6.Nc7 Nd3 7.Rc4 Nxf2
8.Kg2 Ng4 9.Kf3 Nxh2+ 10.Kg2 Ng4
11.Ne6+ Bxe6 12.Bxe6 (536.848.251) 937

19.01 20:39 -1.43 1...Re8 2.Ra1 Nb4 3.Nxb4 Bxb4 4.Rxa7 Bh3
5.Rf7+ Kg8 6.Rc7+ Kh8 7.f3 g6 8.Bb7 Ba5
9.Re7 Bb6+ 10.Kh1 Rd8 11.Bd5 Bc5
12.Be6 Bf1 13.Rd7 Rxd7 14.Bxd7 (1.138.672.774) 918

20.01 41:16 -1.43 1...Re8 2.Ra1 Nb4 3.Nxb4 Bxb4 4.Rxa7 Bh3
5.Rf7+ Kg8 6.Rc7+ Kh8 7.f3 g6 8.Bb7 Rd8
9.Kf2 Be6 10.Ke3 Kg8 11.Be4 Bxb3
12.f5 g5 13.f4 gxf4+ 14.Kxf4 Bxd6+ (2.218.964.492) 895

21.01 80:06 -1.23 1...Re8 (4.227.598.593) 879

22.01 110:02 -1.13 1...Re8 2.Ra1 Nb4 3.Nxb4 Bxb4 4.Rxa7 Bh3
5.Rf7+ Kg8 6.Rc7+ Kh8 7.f3 Rb8 8.Bc6 Bc5+
9.Kh1 g6 10.Bb7 Bb6 11.Rf7 Bc5
12.Nc3 Be6 13.Rxf6 Bxb3 14.d7 Kg7 (5.741.272.336) 869

best move: Rd8-e8 time: 223:20.078 min n/s: 848.370 nodes: 11.368.200.292

Not as fast as Gaviota or Cyclone but still significant improvement

Eelco

[mcostalba]

New part:

Code: Select all

                            bonuspoints = Value(tr * ((b3 & b4) == b3 ? 13 : 8));

						          // Subtract some points if our passed pawn can't immediately 
						          // advance and especially if it is also attacked.
						          bonuspoints -= Value(indirectBlock * tr * (passed_pawnAttacked ? 4 : 3));
							       ebonus += bonuspoints;
						    }
                    }
                    else
                    {

Hi Eelco,

this seems interesting.

As soon as we get rid of the possibe regression that is affecting CEGT results I would like, if you don't mind, to test your change with real games that currently are the only metrics that we use for Stockfish advances.

BTW a metric a bit broken as it seems after the latest CEGT results. It seems I still need to improve my testing skills a lot....

[Eelco de Groot]

New part:

Code: Select all

                            bonuspoints = Value(tr * ((b3 & b4) == b3 ? 13 : 8));

						          // Subtract some points if our passed pawn can't immediately 
						          // advance and especially if it is also attacked.
						          bonuspoints -= Value(indirectBlock * tr * (passed_pawnAttacked ? 4 : 3));
							       ebonus += bonuspoints;
						    }
                    }
                    else
                    {

Hi Eelco,

this seems interesting.

As soon as we get rid of the possibe regression that is affecting CEGT results I would like, if you don't mind, to test your change with real games that currently are the only metrics that we use for Stockfish advances.

BTW a metric a bit broken as it seems after the latest CEGT results. It seems I still need to improve my testing skills a lot....

Hi Marco,

Sure, that would be great, if you could test some of those changes and actually use them for Stockfish! I do try to be a bit more disciplined with making new code, I can only make anything when I have a good example for a change, but still anything C or C++ or C# that is beyond standard Pascal or Algol which I learned in High school waaay back, in the time of the first Boris and Chess Challengers is still really too complicated for me. But hopefully I learn a bit, it's great to have Tord's code and now yours as a real live application where you can test everything and anything!

I just know though that some of the changes I made, in the beginning mostly, are hurting much more than helping elo, but I still feel it was and is a good way to learn to simply try something and not throw it out right away if it does not seem to work. My theory is that some ideas just need to grow and could only begin to constitute real chess knowledge when they are more refined over time.

So, in that context there are still some things from the old Ancalagon which I did not really want to throw out, because I still believe in them for the future. And still learning what they do because that is the only way I could hope to one day make a better version. The King Safety changes I made for instance in Glaurung when it was still in the beta and -ε stages can't be good because they could increase normal values to even 0x350/0x100 times the values you guys are using for the King Attacks. And Tord even pointed out, right away, when I dared to post about the silly code that it was hopelessly flawed, - Tord would never say such a thing though!- because it breaks the symmetry, things are computed differently for Black and White. Very dangerous! But stubbornly I refused to listen to throw it out or even try to measure how much it would hurt in games. I know it would!

Well, only the King Safety I copied from the old version into Stockfish, all the passed pawn code I made I left out so far because Tord made a much better version that actually works

I think you should not worry to much about those figures that seem to indicate regression in the scaling for Stockfish 1.3. I think it is just very hard to get good figures for this, and you would have to be very disciplined in making the testing conditions completely equal so all the opponents would have to be the same, tested on the same machines by the same testers, you would need an enormous amount of games and you would be comparing single threaded versions mainly with double threaded versions, double threaded with four threaded, which is a very different thing than comparing programs only in their own class, single threaded against single threaded elonumbers, double threaded elo against double threaded competitors, those differences will be much more reliable!

Moreover if the multi CPU code from Glaurung or older Stockfish is essentially unchanged, I just would assume you guys can't have broken it much... If it is really unchanged then you are testing for zero deltas comparing two threads minus one thread with two threads minus one thread elo in the CEGT lists, four threads elo minus two threads elo compared with four threads minus the two threads elo between the two versions. It is very hard to prove any changes you do find there from zero are not normal statistical fluctuations...


Regards,
Eelco

[mcostalba]

Hi Marco,

Sure, that would be great, if you could test some of those changes and actually use them for Stockfish! I do try to be a bit more disciplined with making new code, I can only make anything when I have a good example for a change, but still anything C or C++ or C# that is beyond standard Pascal or Algol which I learned in High school waaay back, in the time of the first Boris and Chess Challengers is still really too complicated for me.

Pascal is more then enough

I am confident in C / C++ but sometime I look at sources that are almost unreadable or very difficult to understund. This is not due to the language but to the programmer that wrote a mess.

So if you find some difficult parts, please, it would be very appreciated if you can point me out to them so that I can rewrite in a better and more clear way.

The King Safety changes I made for instance in Glaurung when it was still in the beta and -ε stages can't be good

King safety is difficult. In a comment Tord says

Code: Select all

// King safety.  This is quite complicated, and is almost certainly far
// from optimally tuned.

For sure is difficult, but I don't think is far from optimally tuned because all the trials that we made to improve it were failures !

I think you should not worry to much about those figures that seem to indicate regression in the scaling for Stockfish 1.3.

I believe a lot in CEGT results, admittely currently are still "in flux" because single CPU results are way better then SMP, and we didn't touch SMP code, but one possibility is that also single CPU results will lower and will align with SMP case.

In the release cycle that lead to 1.3 testing was at 80% made against previous version of Stockfish. We know testing with different engines is better, but if you don't have a cluster, and we don't have, it takes more then double the time only for testing against a SINGLE different engine becuase you need to test also the original version not only the new modified one to have a test base.

Consider that to test _any_ modification that yields to a functionality change we run _at least_ 1000 games against each opponent, very often with cascading time controls: firts at very fast games then we do a verification at slower time controls.

So already now testing takes more then 90% of development time. What we are learning from CEGT results is that we should go to 99% !!!

I am more and more convinced that a testing team is the difference between a wanna be engine and a winner. I don't know how a lone developer, like it seems the Naum author, can afford to tackle this all alone. Perhaps he as a cluster too ?

[mcostalba]

Code: Select all

                    if ((b2 & pos.pieces_of_color(them)) == EmptyBoardBB)
                    {
                        // There are no enemy pieces in the pawn's path! Are any of the
                        // squares in the pawn's path attacked by the enemy?
                        if (b3 == EmptyBoardBB)
                            // No enemy attacks, huge bonus!
                            ebonus += Value(tr * (b2 == b4 ? 17 : 15));
                        else
						      {
                            // OK, there are enemy attacks. Are those squares which are
                            // attacked by the enemy also attacked by us?  If yes, big bonus
                            // (but smaller than when there are no enemy attacks), if no,
                            // somewhat smaller bonus.

New part:

Code: Select all

                            bonuspoints = Value(tr * ((b3 & b4) == b3 ? 13 : 8));

						          // Subtract some points if our passed pawn can't immediately 
						          // advance and especially if it is also attacked.
						          bonuspoints -= Value(indirectBlock * tr * (passed_pawnAttacked ? 4 : 3));
							       ebonus += bonuspoints;
						    }
                    }
                    else
                    {

Hi Eelco,

I am trying to implement your code but it is not clear where to attach the new part, as example bonuspoints is even not defined.

Could you please post _all_ the code chunk it mean all the outer if statment code.

Code: Select all

if (pos.square_is_empty(blockSq))

From the above until the end of the above 'if'.

Thanks
Marco

[Eelco de Groot]

Hi Eelco,

I am trying to implement your code but it is not clear where to attach the new part, as example bonuspoints is even not defined.

Could you please post _all_ the code chunk it mean all the outer if statment code.

Code: Select all

if (pos.square_is_empty(blockSq))

From the above until the end of the above 'if'.

Thanks
Marco

Hi Marco,

When you posted I thought that I just had discovered a fatal bug and that it was only in the Ancalagon code, but I was wrong; it was just that I had copied some move wrong from the PV and let it analyze that. But it still means that I am not very satisfied with any of the changes and can't give a positive verdict on any of them yet. Well you know about the King Safety changes, those are just an ongoing experiment. Maybe it would be better if I just mailed you some of the changes because the forum copies the code here with tabstops it seems that I do not see in the MSVC compiler, so every time I have to try to correct the code, it is never quite right. It looks alright in the Visual C++ editor but not when I put it in between <code></code> here.

I don't have any CVS repository system, I'm just editing the files by hand and trying to save every old file with the last build that used this file as a tag in its name. As long as I don't forget to save the old versions I can reconstruct any build, but sometimes you want to do things too fast and you mess things up. As you mentally have to try to keep track of your changes anyway the system is not too bad but not well designed to be used by others.

So keep in mind I don't feel very confident that any change is working like I would like yet!

For now though the complete evaluate.cpp as used in my Build 110, Because I think that would be easier to copy into a file for comparison of the changes. I first viewed it in Wordpad and then copied that here, it seems to look a bit better now in preview mode, without the invisble tabstops so far :

Code: Select all

  // evaluate_passed_pawns() evaluates the passed pawns for both sides.

  void evaluate_passed_pawns(const Position &pos, EvalInfo &ei) {

    bool hasUnstoppable[2] = {false, false};
    int movesToGo[2] = {100, 100};

    for (Color us = WHITE; us <= BLACK; us++)
    {
        Color them = opposite_color(us);
        Square ourKingSq = pos.king_square(us);
        Square theirKingSq = pos.king_square(them);
        Bitboard b = ei.pi->passed_pawns() & pos.pawns(us), b2, b3, b4;

        while (b)
        {
            Square s = pop_1st_bit(&b);

            assert(pos.piece_on(s) == piece_of_color_and_type(us, PAWN));
            assert(pos.pawn_is_passed(us, s));

            int r = int(relative_rank(us, s) - RANK_2);
            int tr = Max(0, r * (r - 1));
            Square blockSq = s + pawn_push(us);
			bool indirectBlock = pos.see(s, blockSq) < 0;
			bool passed_pawnAttacked = bit_is_set(ei.attacked_by(them),s);

            // Base bonus based on rank
            Value mbonus = Value(20 * tr);
            Value ebonus = Value(10 + r * r * 10);

            // Adjust bonus based on king proximity
            if (tr != 0)
            {
                ebonus -= Value(square_distance(ourKingSq, blockSq) * 3 * tr);
                ebonus -= Value(square_distance(ourKingSq, blockSq + pawn_push(us)) * 1 * tr);
                ebonus += Value(square_distance(theirKingSq, blockSq) * 6 * tr);

                // If the pawn is free to advance, increase bonus
                if (pos.square_is_empty(blockSq))
                {
					Value bonuspoints;

                    b2 = squares_in_front_of(us, s);
                    b3 = b2 & ei.attacked_by(them);
                    b4 = b2 & ei.attacked_by(us);

                    // If there is an enemy rook or queen attacking the pawn from behind,
                    // add all X-ray attacks by the rook or queen.
                    if (    bit_is_set(ei.attacked_by(them,ROOK) | ei.attacked_by(them,QUEEN),s)
                        && (squares_behind(us, s) & pos.rooks_and_queens(them)))
                        b3 = b2;

                    if ((b2 & pos.pieces_of_color(them)) == EmptyBoardBB)
                    {
                        // There are no enemy pieces in the pawn's path! Are any of the
                        // squares in the pawn's path attacked by the enemy?
                        if (b3 == EmptyBoardBB)
						{
                            // No enemy attacks, huge bonus!
                            bonuspoints = Value(tr * (b2 == b4 ? 17 : 15));
						 
						    // Subtract some points if our passed pawn can't immediately 
						    // advance and especially if it is also attacked
						    bonuspoints -= Value(indirectBlock * tr * (passed_pawnAttacked ? 5 : 4));
                            ebonus += bonuspoints;
						}
                        else
						{
                            // OK, there are enemy attacks. Are those squares which are
                            // attacked by the enemy also attacked by us?  If yes, big bonus
                            // (but smaller than when there are no enemy attacks), if no,
                            // somewhat smaller bonus.
                            bonuspoints = Value(tr * ((b3 & b4) == b3 ? 13 : 8));

						    // Subtract some points if our passed pawn can't immediately 
						    // advance and especially if it is also attacked
						    bonuspoints -= Value(indirectBlock * tr * (passed_pawnAttacked ? 4 : 3));
							ebonus += bonuspoints;
						}
                    }
                    else
                    {
                        // There are some enemy pieces in the pawn's path. While this is
                        // sad, we still assign a moderate bonus if all squares in the path
                        // which are either occupied by or attacked by enemy pieces are
                        // also attacked by us.
                        bonuspoints = Value((((b3 | (b2 & pos.pieces_of_color(them))) & ~b4) == EmptyBoardBB) * tr * 6);

						// Subtract some points if our passed pawn can't immediately 
						// advance and especially if it is also attacked
						bonuspoints -= Value(indirectBlock * tr * (passed_pawnAttacked ? 3 : 2));
                        ebonus += bonuspoints;
                    }
                    // At last, add a small bonus when there are no *friendly* pieces
                    // in the pawn's path.
                    if ((b2 & pos.pieces_of_color(us)) == EmptyBoardBB)
                        ebonus += Value(tr);
                }
            }

            // If the pawn is supported by a friendly pawn, increase bonus
            b2 = pos.pawns(us) & neighboring_files_bb(s);
            if (b2 & rank_bb(s))
                ebonus += Value(r * 20);
            else if (pos.pawn_attacks(them, s) & b2)
                ebonus += Value(r * 12);

            // If the other side has only a king, check whether the pawn is
            // unstoppable
            if (pos.non_pawn_material(them) == Value(0))
            {
                Square qsq;
                int d;

                qsq = relative_square(us, make_square(square_file(s), RANK_8));
                d =  square_distance(s, qsq)
                   - square_distance(theirKingSq, qsq)
                   + (us != pos.side_to_move());

                if (d < 0)
                {
                    int mtg = RANK_8 - relative_rank(us, s);
                    int blockerCount = count_1s_max_15(squares_in_front_of(us,s) & pos.occupied_squares());
                    mtg += blockerCount;
                    d += blockerCount;
                    if (d < 0)
                    {
                        hasUnstoppable[us] = true;
                        movesToGo[us] = Min(movesToGo[us], mtg);
                    }
                }
            }
            // Rook pawns are a special case:  They are sometimes worse, and
            // sometimes better than other passed pawns. It is difficult to find
            // good rules for determining whether they are good or bad. For now,
            // we try the following: Increase the value for rook pawns if the
            // other side has no pieces apart from a knight, and decrease the
            // value if the other side has a rook or queen.
            if (square_file(s) == FILE_A || square_file(s) == FILE_H)
            {
                if(   pos.non_pawn_material(them) <= KnightValueMidgame
                   && pos.piece_count(them, KNIGHT) <= 1)
                    ebonus += ebonus / 4;
                else if(pos.rooks_and_queens(them))
                    ebonus -= ebonus / 4;
            }

            // Add the scores for this pawn to the middle game and endgame eval.
            ei.mgValue += apply_weight(Sign[us] * mbonus, WeightPassedPawnsMidgame);
            ei.egValue += apply_weight(Sign[us] * ebonus, WeightPassedPawnsEndgame);
        }
    }

    // Does either side have an unstoppable passed pawn?
    if (hasUnstoppable[WHITE] && !hasUnstoppable[BLACK])
       ei.egValue += UnstoppablePawnValue - Value(0x40 * movesToGo[WHITE]);
    else if (hasUnstoppable[BLACK] && !hasUnstoppable[WHITE])
       ei.egValue -= UnstoppablePawnValue - Value(0x40 * movesToGo[BLACK]);
    else if (hasUnstoppable[BLACK] && hasUnstoppable[WHITE])
    {
        // Both sides have unstoppable pawns! Try to find out who queens
        // first. We begin by transforming 'movesToGo' to the number of
        // plies until the pawn queens for both sides.
        movesToGo[WHITE] *= 2;
        movesToGo[BLACK] *= 2;
        movesToGo[pos.side_to_move()]--;

        // If one side queens at least three plies before the other, that
        // side wins.
        if (movesToGo[WHITE] <= movesToGo[BLACK] - 3)
            ei.egValue += UnstoppablePawnValue - Value(0x40 * (movesToGo[WHITE]/2));
        else if(movesToGo[BLACK] <= movesToGo[WHITE] - 3)
            ei.egValue -= UnstoppablePawnValue - Value(0x40 * (movesToGo[BLACK]/2));

        // We could also add some rules about the situation when one side
        // queens exactly one ply before the other: Does the first queen
        // check the opponent's king, or attack the opponent's queening square?
        // This is slightly tricky to get right, because it is possible that
        // the opponent's king has moved somewhere before the first pawn queens.
    }
  }

Complete evaluate.cpp did not fit so just the passed pawns routine

Regards, Eelco

[mcostalba]

Complete evaluate.cpp did not fit so just the passed pawns routine

Hi Eelco,

thanks a lot !

In the mean time I have written something myself that I am testing now, it is along your ideas but code is a bit different. If tests are good I will post the code.

In case you are interested I suggest to use a CVS system. I use git, it is very powerful but not difficult to use and it comes very handy when you makes a lot of changes and you want to keep track of each of them.

Also exchanging patches it comes much easier.

Thanks
Marco