Comments/Ratings for a Single Item

Some general impressions I have gotten from this research:

• 1. c4 looks to be white’s best first move.
• 1. c4 Mh6 looks to be black’s best reply.
• Black should reply to f4 with 1. f4 c5 (The “Winther defense”) and e4 with 1. e4 d5 2. exd5 Nb6

This is just one of many, many possible opening setups for the Capablanca pieces—there are some 126,000 possible setups if we use this set of pieces (two each of rooks, knights and bishops, one each of the strong pieces), force the bishops to be on opposite colors, and the queen to be left of the king. There is a nearly endless land to explore with just Capablanca chess and the many, many possible setups.

But, real life is calling me and this will be my last look at Schoolbook for 2009. Well, except to finish up the game with Wolff.

As an aisde, I have 132 games where one side thought they were even or ahead, but the other side found a mating combination to win the game:

http://www.samiam.org/schoolbook/

Here are some interesting ideas I have made public on this server (it looks like Google doesn’t index things very well here, so I’m making some public bookmarks):

• 31 short-range pieces
• The 16 basic sliders that can traverse the entire board
• The “Sage” (Camel + Bishop) piece
• A discussion of various piece ideas
• A discussion of some Capablanca opening setups, along with a little of the discussion about the “Sage” piece.
• An idea I had to have Rook + King, Knight + King, and Bishop + King on an 8x10 board After playtesting this idea, I didn’t like it: Not enough tactical fireworks

Move    PV
-----   ---
e5	73
Ng6	69
f6	40
c6	13
e6	10
d6	5

Opening moves   Win      Loss     Draw     Games played
--------------- -------- -------- -------- ---
1. c4 e5 2. d3  100%     0%       0%         3
1. c4 e5 2. Bc2 53.0997% 35.0404% 11.8598% 371
1. c4 e5 2. f3  48.2456% 37.7193% 14.0351% 114
1. c4 e5 2. h3  47.619%  44.7619% 7.61905% 105

Opening moves       Win      Loss     Draw     Games played
------------------- -------- -------- -------- ---
1. c4 e5 2. Bc2 a6  100%     0%       0%         2
1. c4 e5 2. Bc2 Cj6 100%     0%       0%         5
1. c4 e5 2. Bc2 Ch6 71.4286% 28.5714% 0%         7
1. c4 e5 2. Bc2 g6  58.2915% 31.1558% 10.5528% 199
1. c4 e5 2. Bc2 f6  50%      37.5%    12.5%     24
1. c4 e5 2. Bc2 Be7 48.3871% 38.7097% 12.9032%  62
1. c4 e5 2. Bc2 Ng6 42.3077% 44.2308% 13.4615%  52
1. c4 e5 2. Bc2 Ad6 26.3158% 47.3684% 26.3158%  19
1. c4 e5 2. Bc2 Ni6 0%       100%     0%         1

More research has to be done, including looking for a reasonable Black reply to 2. f3.

As an aside, I get a lot more pretty mates when I have Joker80 play at 40-moves-in-4-seconds than when I use slower time controls.

These types of positions are actually quite rare; in the 5,000 games or so I have had my computer play to research Schoolbook, only 24 mates of this nature were found; a mate like this happens about once every 200 games.

These mates (in addition to the script that data-mines the .pgn files to find these kinds of positions) can be found here:

http://www.samiam.org/schoolbook/

f3    Win: 51.462%  Loss: 35.0877% draw 13.4503% Total 171
c4    Win: 48.5075% Loss: 38.0597% draw 13.4328% Total 134
c3    Win: 47.6923% Loss: 38.4615% draw 13.8462% Total 130
e4    Win: 46.9965% Loss: 40.636%  draw 12.3675% Total 283
f4    Win: 45.6522% Loss: 43.1159% draw 11.2319% Total 276
h3    Win: 41.6667% Loss: 50%      draw 8.33333% Total 12
Total Win: 47.6143% Loss: 39.8608% draw 12.5249% Total 1006

j3    Win: 100%     Loss: 0%       draw 0%       Total 2
f4    Win: 54.7945% Loss: 31.5068% draw 13.6986% Total 73
e3    Win: 53.8462% Loss: 46.1538% draw 0%       Total 13
c4    Win: 48.1663% Loss: 36.6748% draw 15.1589% Total 409
f3    Win: 47.4576% Loss: 45.7627% draw 6.77966% Total 59
e4    Win: 46.9444% Loss: 40.8333% draw 12.2222% Total 360
c3    Win: 42.5926% Loss: 42.5926% draw 14.8148% Total 54
g4    Win: 36.3636% Loss: 63.6364% draw 0%       Total 11
h3    Win: 31.5789% Loss: 52.6316% draw 15.7895% Total 19
b3    Win: 0%       Loss: 100%     draw 0%       Total 1
g3    Win: 0%       Loss: 100%     draw 0%       Total 1
Total Win: 47.505%  Loss: 39.4212% draw 13.0739% Total 1002

It would appear he may be able to.

For example, I have had my computer play a lot of 40-moves-in-16-seconds games, starting with either 1. e4 d5 or 1. e4 d5 2. exd5 Nb6 (here, White can not hold on to the pawn). Here are the results:

e4-d5-exd5-Ad6 Win: 100%     Loss: 0%       draw 0%       Total 1
e4-d5-exd5-f6  Win: 55.6604% Loss: 33.0189% draw 11.3208% Total 106
e4-d5-exd5-f5  Win: 54.1353% Loss: 37.594%  draw 8.27068% Total 133
e4-d5-exd5-Nb6 Win: 45.4765% Loss: 41.9783% draw 12.5452% Total 1658
Total          Win: 46.6807% Loss: 41.1486% draw 12.1707% Total 1898

My theory is that we can find equalizing replies for Black to other White first moves in the Schoolbook opening array. For example, preliminary research suggest that the position after 1. f4 c5 strongly favors Black (but I’m putting this line of research on hold because I’m currently playing a Game Courier game with this opening).

It is.

I had my computer spend all weekend playing over 1,000 games of the Schoolbook setup giving Joker80 90 seconds to make 40 moves (each side got 90 seconds to make these 40 moves). Here are the win/loss/draw ratio for White when given all this time to make a move:

Win: 48% Loss: 39% draw 13% Total 1002

Compare this to the results we got when we play much faster 40-moves-in-4-seconds games:

Win: 48% Loss: 40% Draw: 13% Total 1006

The numbers are identical, within the +-2% margin of error because we used 1,000 games in our study.

Conclusion: Giving a game different time controls does not appear to affect the Win/Loss/Draw ratio for Joker80.

My next bit of research is whether fine-tuning the opening by hand affects the Win/Loss/Draw ratios. In other words, can we come up with a better opening book than the openings Joker80 comes up with during the game?

It looks like I can. I don't have over 1,000 games for a given opening, but my preliminary findings show that Black has about as many wins as White after 1. e4 d5 2. exd5 Nb6 and Black creams White after what I call the “Winther Defense”, 1. f4 c5 (named thusly because Zillions, when using a Capablanca rules file tweaked by Winther to play the opening better, came up with this defense); it looks like the tactical complications after 1. f4 c5 2. Bxc5 Qxf4+ 3. Af3 strongly favor Black.

>Note that only recently are advanced chess engines making 
>good opening moves without a book. Zillions for example is 
>horrible in openings. 

Charles, yes, but Zillions can easily be tweaked to play better in the openings. All my zrf:s have been tweaked. Why don't you try one, for example 'Chess with extended castle'. This is very close to Fide-chess. You will find that it plays openings much better. There are two opening play personalities to choose from. Please allow it some thinking time and you will find that it takes responsibility of the centre situation.
http://hem.passagen.se/melki9/chesswithextended.htm
/Mats

In terms of the opening research, right now I'm researching the White win/Draw ratio of the Schoolbook setup. One concern brought up by Charles Daniel is how well Joker80 is playing the opening. Indeed, earlier I did some opening research by comparing how well Joker80 plays 15 different openings suggested by ChessV (see this posting for the openings). Joker80 was given 10 seconds to play 40 moves, and 100 games of each of the 15 openings was played (1500 games total). Here are the results:

Win: 46% Loss: 42% draw 11% Total 1389 (we played 1,500 games but only tallied games ending in a checkmate or draw)

Here, we see that the White advantage, which is 8% without any Schoolbook opening book, is only 4% when both White and Black play openings suggested by ChessV. Indeed, with the opening 1. e4 d5 2. exd5 Nb6, which appears to be a strong defense to 1. e4 in Schoolbook chess, we get the following results when playing at a time control of 60 seconds for 40 moves:

Win: 44% Loss: 43% draw 13% Total 204

The research I'm currently doing is the White win/loss/draw ratio when playing Schoolbook Chess at a pace of 90 seconds for 40 moves. I will have better results early next week, but here is the results I have so far:

Win: 52% Loss: 35% draw 13% Total 162

Here, we see White does a lot better when given more time to think about his move (but these results may change once I get 1,000 games or so at this slower time control).

I think the biggest conclusion we have gotten from all those 40-move-in-4-second games done with six different Capablanca opening setups is that having undefended flank pawns does not make the game an automatic win for White. It has been proposed (without empirical evidence backing the proposal) that having undefended pawns in a Capablanca opening setup strongly biases the game in White's favor, but I didn't see that at all in my experiment.

In terms of this being a popular variant, one advantage of Capablanca Chess is that there are a number of engines (Zillions, of course, but also ChessV, Joker80, TJchess10x8, etc.) that can play this variant. This allows us to do a lot of research; no Chess variant is popular enough to have tournaments with even dozens of participants, but we can simulate a huge tournament with very strong players and thousands of games played by having computer chess engines play each other over and over and over.

There seem to be two different communities of Chess Variant players: Chess Variant players who don't want to stick around with a given variant for very long; the majority of the community here is like this, which is why, for example, no one has played Schoolbook here for a while (people have since moved on to new variants). Then there's a community only interested in modest variants to Chess and analyzing those modest variants including building up an opening library and have a computer program play the variant in question as well as possible. For example, people making computer engines talk about having the engines play simple variants like Capablanca Chess in places like this forum.

I did another Schoolbook match, this time between ChessV and Fairy-Max. Since neither of those implements pondering, it was played with ponder off, at 15 min/game. Of the 52 games, 40 did run to completion, and 12 got stuck, leading to a forfeit on time. One of the games that got stuck was because ChassV promoted to Marshall, and Winboard did not understand M as a valid piece. This should be counted as a clear win for ChessV, as FairyMax was reduced to K+P and ChessV already had another Marshall. From the other 11 games 9 got stuck because of ChessV playing a free castling, refused by Fairy-Max. The remaining 2 got stuck because of Fairy-Max playing a Capablanca castling, and ChessV choking on it. (This seems to be a remaining ChessV bug; often but not always it dies when you input a perfctly valid castling.)

When a game gets stuck on a castling it is usually early in the game, and difficult to predict how the game would have ended. So if I discard those games for the moment, the match ended in a 29-12 victory for Fairy-Max. This result is similar to that of a blitz match (40 moves/min) between the two that I did earlier. The game quality is a bit lower than that of the Joker80-TJchess10x8 match, as both ChessV and Fairy-Max are pretty poor at King Safety. In general ChessV has much better positional play, (Fairy-Max really wrecking its own position with poor Pawn structure and development), but then suddenly gets outplayed tactically by Fairy-Max.

If I find a way to continue the unfinished games, I might put the PGN file on my website.

I still have to study your recent comments on the opening work; it all seems very interesting, but I haven't had the time yet to digest them.

Zillions is a general-purpose engine which is excellent for prototyping variants, but it does not play Chess all that well. I use it for basic testing to make sure a given game is sane (no forced mate in the opening, reasonable White-Black balance, not too drawish, etc.), but not for serious opening analysis.

ChessV, with some heuristics to evaluate opening moves, actually comes up with a reasonable opening book for FIDE chess. You should download and try it; I have a copy of it at samiam.org/chessv; to say it plays the opening better than Zillions is a vast understatement. It can’t find the Sicilian defense, but besides that its replies to 1. e4 in FIDE chess (when its opening book is removed) are fine; keep in mind people played FIDE chess for centuries before deciding the Sicilian was a really good reply to 1. e4.

The reason why many Chess engines designed to play FIDE Chess can’t come up with very good opening moves is because they don’t have to. It’s a lot simpler to just have a really big opening book and play moves from the opening book until a novelty is finally played.

Joker80, the engine I used (which, as it turns out, I didn’t write), actually plays the opening quite well, since it’s an engine designed to play Chess without an opening book.

Have you not seen zillions make opening moves in regular chess? That is the type of 'chess' engines played unless they have some sophisticated opening book/algorithm built in. 

We are not talking simple e4 /e5 here we are talking about opening plans 20 moves deep as in a Ruy Lopez, a Sicilian -- what program has come up with something as detailed?  
 
 
I am not criticizing your engine - and I understand that NO ONE has developed any opening book for capablanca  chess .. 
But you cannot expect your engine to make complex strategical decisions (esp in the opening) unless you program it that way .. 
In any case, you have misunderstood my point - Lets say you try the same thing with 8x8 chess and one is the std setup. Your machine might pick up tactical threats  but it certainly will NOT play the openings very well as least in comparison to a GM (std chess setup of course)  
Do you realize that it took at least 100 yrs + to get opening theory where it is now? There is no program ever made that could ever come up with anything close to it.  

Even Rybka plays very questionable lines when opening book is completely removed 


IN any case your experiment is still useful in throwing out some setups - greater tactical threats will pressure a human player even more.

But given time, humans can certainly come up with better ways to play the opening than your engine can by itself esp for the first 10-15 moves. This may or may not change your results but that was not my point of contention.

I am of the opinion that criticisms against legitimate research have no real merit unless backed up by their own research. For example, can you find an opening book for Black to better defend against White’s attacks in the RMNBAKBNQR opening array? It’s one thing to assert “Joker80 doesn’t play the opening very well” (I’m not sure this is what you’re asserting; however, Joker80 was used to play all games, and Zillions was never used); however, this assertion is unsupported unless it is a claim like “Joker80 doesn’t play the RMNBAKBNQR opening very well. Black most commonly replies to 1. e4 with 1. ... e5 (Which, indeed, is the most common opening for this setup); however my research shows that Black gets much better results if he instead responds to 1. e4 with...”

Is there a reasonable Black defense with the RMNBAKBNQR array that Joker80 missed? If so, what is it?

And, yes, the Aberg setup does look to be the best setup of the Capablanca pieces.

Certainly, this shows that there may be greater tactical advantage for
white in some of these setups. 
But  one would have to be careful about this -- these engines are not 
very good in openings esp in making moves that are sensible strategically.


Note that only recently are advanced chess engines making good opening
moves without a book. Zillions for example is horrible in openings. 


I believe and I am sure many would confer that the Capablanca chess
varieties are the closest to orthodox chess when considering larger
board/new pieces type of games. 

I would like to see this experiment with the foll array:

R N B Q M K A B N R 

I believe this was one patented but nevertheless would be fascinating to
compare against. 
I do not like Queen not next to king nor queen in the wing for fixed
setups. 
I believe that the Alberg variation is the best setup not just from the
results but from the the nice initial placement of pieces. 

There was some fairly good work done...[following passage removed by
editor Jeremy Good for chessvariants.org policy reasons - email me if
details are wanted]

However, I see no mention of the Alberg setup. 



Myself, I have played some Capablanca chess games and enjoyed them, but
the novelty wears off after a while .. I was of course much more interested
in 10x10 then and  now I am reverting back to 8x8 ...but thats another
story.

In the 2000s, we have had many discussions about what makes for the best Capablanca setup. It has been asserted, for example, that all of the pawns need to be defended in the opening setup, and that any opening setup with undefended pawns gives White a sizable advantage.

What I have done is research a subset of Capablanca setups to see if this is true. Since there are some 126,000 setups where the Queen is to the left of the King and the bishops are on opposite colors with the Capablanca pieces, I have reduced the number of setups to six thusly:

• The rooks must be in the corners. The king must be in the F file. This is to accommodate the software I used for my testing, which only allows castling if these conditions are met.
• The knights must be in the C and H files, and the bishops must be in in the D and G files. The thinking is this: Since the knights are weaker in Capablanca setups on a 10x8 board than they are in FIDE chess, placing the knights relatively near the center makes them more relevant in the opening and midgame. The bishops are placed near the center just like they are placed in FIDE chess; this is done so that natural pawn development moves (e4, f4) do not hamper the development of the bishops.
• The Archbishop (Knight + Bishop), Marshall (Rook + Bishop), and Queen may be placed anywhere in the three remaining files.

• RMNBAKBNQR (I call this arrangement “Notetaker’s Chess”; all pawns are defended in the opening array)
• RQNBAKBNQR (“Schoolbook Chess”; again, all pawns are defended)
• RANBMKBNQR (I call this arrangement “Narcotic Chess”; the B pawn is undefended in the opening array)
• RQNBMKBNAR (I call this arrangement “Opiate Chess”; the D and I pawns are undefended in the opening array and White can threaten mate on the first move with Md3)
• RANBQKBNMR (“Aberg Chess”; the B pawns are undefended)
• RMNBQKBNAR (“Carrera Chess”; the original 10x8 setup from the 1600s; the I pawns are undefneded)

(Numbers may not add up to 100% because of rounding). Since we played 1,000 games with each variant, the scores may be off by as much as 2% or so.

In conclusion, we can see that whether or not all pawns are defended is not a relevant factor in White having more of an advantage. The setup with the lowest White advantage (ranbqkbnmr, White advantage 3%) has one undefended pawn for each side in the opening array, and the setup with the highest White advantage (rmnbakbnqr, White advantage 16%) has all pawns defended in the opening array.

ranbqkbnmr appears to be the most balanced setup (3% White advantage); this is followed by rmnbqkbnar (5% White advantage). ranbmkbnqr and rqnbakbnmr both have an 8% White advantage; ranbmkbnqr has fewer draws, however. Both rqnbmkbnar and rmnbakbnqr give White a considerable advantage (12% and 16%, respectively); I am not surprised rqnbmkbnar has a considerable White advantage, since the D pawn near the King is unprotected, and since White can threaten mate on the first move with Md3. However, it is a mystery why White has such an advantage with the rmnbakbnqr, since all pawns are defended in this setup. It would appear undefended flank pawns don’t give White any significant advantage.

For people interested in this research, I have made a 4-megabyte archive with all of the games played in the course of this research here:

http://www.samiam.org/schoolbook/

Edit: The Aberg and Carrera setups only have one undefended pawn.

So, I started my computer making a bunch of 40-moves-in-4-second games last night. There's another issue: About once every 1,000 games, Joker80 crashes, and this stops WinBoard from generating games unattended. I'll see if removing the offending pop-up from WinBoard allows Winboard to restart and continue making games when Joker80 crashes. It may also be necessary to suppress the 'send bug report to Microsoft' window.

The nice thing about games this quickly is that I already have +/- 2% numbers for White's wins with the 1. e4 f5 2. exf5 Nb6 Schoolbook opening:

Win: 45.3718% Loss: 42.868% draw 11.7602% score 51.2519% Total 1318

(Win: Number of White wins. Loss: Number of White losses. Draw: Number of draws. Score: White wins + draws/2 Total: Number of games played)

Compare this to the +/- 5% numbers I got from 100 40-moves-in-60-second games for the same Schoolbook opening yesterday:

Win: 46% Loss: 45% draw 9% score 50.5% Total 100

As we can see, the numbers are almost the same.

This might be normal statistical noise. The standard deviation in N games is 45%/sqrt(N), so for 100 games that would be 4.5%. The standard diviation in the difference of two independent 100-game matches is sqrt(2) times as large, i.e. 6.3%. So the difference between the 10-sec match and 30-sec match is more or less as one should expect when the average score for white (over an asymptotically large number of games) would be exactly equal for the two cases.

This is the problem with this kind of empirical testing; the number of games needed to get significant results is very large.

Win: 47.2527% Loss: 35.1648% draw 17.5824% score 56.044%

So, then, looking at the games I saw Black wasn't defending as well as he should, so I ran 100 games with three times the time: 40 moves in 30 seconds. I got considerably different results:

Win: 40.8602% Loss: 45.1613% draw 13.9785% score 47.8495%

('score' above is White wins + Draws/2)

Here, we see Black defends a lot better and White doesn't win nearly as often.

Point being, on my system (Core 2 dual, 1.5 ghz), the 40-moves-in-10-seconds games does not give us enough time to play well enough to determine whether a given opening is any good. 1. e4 d5 2. exd5 Nb6 is a fine defense for Black, but we need more time for each game to see that.

As an aside, one of the 30-seconds-for-40-moves games has this pretty checkmate:

1. e4 d5 2. exd5 Nb6 3. Ne2 Nxd5 4. f3 c6 5. c4 Nb6 6. c5 Nd5 7. Bc2 g6 8. Cj3 Ad7 9. Qd1 h5 10. Nhg3 Ke8 11. Bf2 Nb4 12. Ba4 b5 13. cxb6 axb6 14. O-O Ni6 15. d4 Qd6 16. Ne4 Qe6 17. Ci5 j6 18. Nf4 Qc4 19. b3 Qa6 20. Axb4 jxi5 21. Bxc6 Kf8 22. Bxd7 Nh4 23. g3 Cj6 24. Axa6 Cxj2 25. Nxg6+ fxg6 26. gxh4 Cj1# 0-1

Note that games lost on time do not count; only games with a definite resolution were counted in these statistics (if we played 100 games and 10 were lost on time, I only counted the other 90):

Nd3-Nd6 57%
Nd3-Ng6 56%
Nd3-f5 55%
e4-Ng6 57%
e4-d5 52%
e4-e5 51%
f4-Nd6 60%
f4-f5 52%
f4-c6 47%
c3-e5 58%
c3-Ng6 47%
c3-e6 46%
Ng3-e5 49%
Ng3-Ng6 48%
Ng3-c6 45%

Here, the first column is the first two moves played; the second column is the percent figure as described above. I’ve grouped all of whites moved together in the above list, and have sorted them based on White’s winning percentage if Black makes his best reply.

Anyway, that was fun but this should be my last work on Schoolbook until 2010, when I start preparing for the Schoolbook 2010 tournament. I have a DNS server that I want to finish up that I’ve been neglecting this last week.

Here is the final ChessV-0.9.0-generated list (with human tweaking) of Schoolbook openings:

1. c3 Ng6
1. c3 e5
1. c3 e6
1. Nd3 f5
1. Nd3 Nd6
1. Nd3 Ng6
1. e4 e5
1. e4 Ng6
1. e4 d5
1. f4 f5
1. f4 Nd6
1. f4 c6
1. Ng3 Ng6
1. Ng3 e5
1. Ng3 c6

Next: Run 100 40-moves-in-10-second games for each of these openings to see which ones make Joker80 have more wins as white at this time control. Should I point out, at this point, that Joker80’s wins as White decrease when I increase its time control?

Timeline: There is no timeline. Whenever I feel like doing it.

Reply on the thread

Sometimes, one of the sides loses on time. Since it is a little more complicated to adjudicate such a game to see who had the better position when the flag fell, I have simply discarded any game which does not end with a draw or a checkmate (Joker80, unlike TJChess10x8, never resigns).

Once I did this, here is the win/loss/draw statistics I have so far for Joker80 playing Schoolbook Chess against itself with a 40 moves in 10 seconds time control:

e4 Win: 51.6556% Loss: 38.4106% draw 9.93377% Total 151
f4 Win: 51.4019% Loss: 41.1215% draw 7.47664% Total 107
f3 Win: 52.381% Loss: 33.3333% draw 14.2857% Total 63
c4 Win: 44.2623% Loss: 40.9836% draw 14.7541% Total 61
c3 Win: 38.8889% Loss: 50% draw 11.1111% Total 18
h3 Win: 100% Loss: 0% draw 0% Total 2
Ni3 Win: 100% Loss: 0% draw 0% Total 1
Total Win: 50.3722% Loss: 38.9578% draw 10.67% Total 403

#!/bin/sh

awk '{

	l=$0;
	sub(/\[.*\]/,'',l);
	# Get opening move
	if(match(l,/^1\./)) {
		sub(/{.*/,'',l);
		sub(/^1\.[ \t]*/,'',l);
		sub(/[ ]+.*$/,'',l);
		opening=l
	}
	# Tally up wins and losses
	if(match(l,/Checkmate/) || match(l,/mates/) || match(l,/resign/)) {
		sub(/{.*}[ ]*/,'',l);
		if(match(l,/0\-1/)) {
			loss[opening]++;
		} else if(match(l,/1\-0/)) {
			win[opening]++;
		}
		opening = 'invalid'
	}
	# Tally up draws
	if(match(l,/1\/2\-1\/2/)) {
		draw[opening]++
		opening = 'invalid'
	}
}

END {
	for(a in win) {
		print 'W Opening ' a ' won ' win[a] ' times.'
	}
	for(a in loss) {
		print 'L Opening ' a ' lost ' loss[a] ' times.'
	}
	for(a in draw) {
		print 'D Opening ' a ' drew ' draw[a] ' times.'
	}
}' | awk '# Tally total results by opening
	{result = $1; opening = $3; times = $5; 
		tally[opening] = tally[opening] ' ' result ' ' times;
		total[opening] += times;
	}
	END { for(o in tally) {
		print o ' ' tally[o] ' T ' total[o]
	} }' | awk '# Make percentage win/los/draw
	{
		opening = $1

		for(a in z) { delete z[a]; }

		for(a=2;a<=NF;a++) {
			if(a % 2 == 0) {
				d = $a
			} else {
				z[d] = $a
			}
		}

		if(z['T'] > 0) {
			t = z['T'];
			if(t != 0) { 
				w = z['W'] / t;	
				l = z['L'] / t;	
				d = z['D'] / t;	
				w *= 100; l *= 100; d *= 100;
				tt += z['T']; tw += z['W']; 
				tl += z['L']; td += z['D'];
			}
		 print opening ' Win: ' w '% Loss: ' l '% draw ' d '% Total ' t
		}
	}

		END {
		 if(tt != 0) {
		 	tw = tw / tt; tw *= 100;
		 	tl = tl / tt; tl *= 100;
		 	td = td / tt; td *= 100;
		}
		 print 'Total Win: ' tw '% Loss: ' tl '% draw ' td '% Total ' tt
	}'		

• Gave each side 40 seconds to do 40 moves (too slow for what we're doing)
• Disabled pondering with -xponder

#!/bin/sh

SECS=10

while : ; do

        winboard.exe -noGUI -xanimate -cp -fcp joker80.exe -scp joker80.exe \
          -boardSize middling -xponder \
          -variant capablanca -lpf schoolbook.fen -tc 0:${SECS} -mps 40 \
          -autosave -sgf game-${SECS}sec-40moves-$(date +%s).pgn -mg 10

        sleep 1

done

Note that I also hacked backend.c to remove the popup that tells you the match results at the end of a match.

There is a new version (4.4.0) obtainable from WinBoard forum:

http://www.open-aurec.com/wbforum/viewtopic.php?f=19&t=50387

This new version supports the -noGUI option, which supresses updating of board and clocks completely. The Animate Moving checkbox should be in the Options -> General... dialog. I guess I misremembered a little; I looked it up and Joker80 was playing 15 sec/game against 24 min/game for ArcBishop. But at that speed (which should be equivalent to 40 moves / 10 sec, as the average 10x8 blitz game takes about 60 moves), it was able to win games without forfeiting on time. This was on a 2.4GHz Core 2 Duo.

Since we want self-play with absolutely equal engines, it should also be possible to make a version of the engine that does this without GUI. ChessV has such an option to play itself. Both sides would use the same hash table, which is equivalent to having a ponder-on tournament with 100% guarantee for a ponder hit, but only using a single CPU! The first 30 moves of each game could then be saved together with the result in binary format, to build a book from it later.

With the version of WinBoard I'm using, there is no option for animation (and no animation in the game) nor an option for turning off the GUI (-noGUI doesn't work, nor does /noGUI, and the help files don't seem to have anything). I'm using Winboard 4.3.15m.

Which version of Winboard are you using? It's in the GUI under Help->about.

40 moves in 10 seconds is a little too fast for Joker80. So, I've opten for 40 moves in 30 seconds; I might be able to get away with 40 moves in 15 seconds. Joker80 randomizes its move enough that it's worth it to have it run a few thousands games against itself; a version of Joker80 that essentially randomizes its first two moves would be nice too (or I can have the script just give the engines one of the 784 setups where the first two moves are randomized).

Here is the script that does this:

#!/bin/sh

A=1

while : ; do

        winboard.exe -cp -fcp joker80.exe -scp joker80.exe \
          -boardSize middling \
          -variant capablanca -lpf schoolbook.fen -tc 0:30 \
          -mps 40 \
          -autosave -sgf game-hour-${A}.pgn -mg 60

        A=$(( $A + 1 ))

done

rqnbakbncr/pppppppppp/10/10/10/10/PPPPPPPPPP/RQNBAKBNCR w KQkq - 0 1

Well, lets look at the ChessV 0.9.0 + Human tweaking opening book 1. c3, 1. Nd3, 1. e4, and 1. f4; I will probably do black responses to 1. Ng3 tonight.

Here is the opening book I have so far:

1. c3 Ng6
1. c3 e5
1. c3 e6
1. Nd3 f5
1. Nd3 Nd6
1. Nd3 Ng6
1. e4 e5
1. e4 Ng6
1. e4 d5
1. f4 f5
1. f4 Nd6
1. f4 c6

And compare it with Joker80’s 12-ply opening book, where it thinks White’s five best moves are: 1. e4 (PV +.05 pawns), 1. c4 (+.05 pawns), 1. c3 (PV +.04 pawns), 1. g4 (PV +.02 pawns), and 1. f3 (PV +.01 pawns). Observe that there are no Knight openings in Joker’s list, and that it thinks 1. f3 (+.01 PV) is better than 1. f4 (+.00 PV, or equality). In addition, Joker80 likes 1. g4 more than ChessV does.

So, there are some significant differences between the openings Joker80 likes and the openings ChessV likes. Both opening books look reasonable; Capa variants have a somewhat higher branching factor than FIDE chess (after White and Black move once in FIDE chess, there are 400 possible positions; in the Schoolbook Capa setup, that number is 784), so I would not be surprised if there are more reasonable openings than in FIDE Chess.

I retract my statement that there is no value in setups where we randomly advance pawns for both sides one square (if we advance White’s c pawn, we advance Black’s c pawn, for example). In FIDE chess, it increases the number of openings by 256; with Capa arrays, it increases the number of openings by 1024 and computer analysis can tell us if certain pawn advancements make for usable opening setups.

Again, I will finish up my ChessV 0.9.0 analysis of the Schoolbook opening setup over the next few days and should have a final opening list up soon.

Reply to this thread

Sam: The most obvious difference is that Joker80 likes c2-c4 quite a lot, while ChessV thinks it a pretty poor move.

Mats: I think this technique could be useful to reveal flaws in the array that would cause an unusually large white bias. E.g. essential weaknesses due to undefended Pawns or critical mate threats.

To create an opening book, a better approach would probably be to play a few hundred thousand ultra-fast games, with an engine that randomizes through a root bias of 10 centiPawn or so. This should provide Monte-carlo sampling of the opening tree, fully taking into account strategic effects like those you mention.

With 40 moves/10 sec one could do 120 games/hour on a single CPU. So a quad would make you about 500 games/hr or 12,000 games/day. Keep that up for a month, and a very nice data set would emerge.

Sam, for a computer to make reasonable opening moves in orthochess it is sufficient to allow it to randomly choose between 1.c4, 1.d4, 1.e4 and 1.Nf3. It's equally simple in Capablanca variants. It is completely meaningless to allow an engine to run overnight to determine which first move is the best. Many moves are equally good until grandmasters after years of play and analysis have arrived at a conclusion.

The ramification of variations is so vast and one can't draw any conclusions about first opening moves this way. There are deep strategies involved, concerning endgame properties, for instance. In the Sicilian defence, black's minority attack and the pressure on the backward white c-pawn will create a slight advantage for black if the endgame is reached. A computer cannot draw such conclusions and determine in favour of 1...c5 after a night's analysis. The ramification in Capablanca variants is even greater. This effort of computer analysis is meaningless. If you want to establish the foundational openings, then move any centre pawn and a knight in any reasonable combination for both parties. Then you will have perhaps 30-40 good openings to choose from.

However, randomized pawns is not 'untested blue sky ideas' while I have tested it in Chess256, and Zade has implemented it for [a Capablanca chess variant*]. Obviously, the randomized pawn configuration, in itself, lessens the deterministic aspect of computer play. Moreover, as the pawn development is already partly established, a computer can immediately choose between good piece moves and good pawn moves. Otherwise, with all pawns on the second rank, it has almost only good pawn moves at his disposal. I never suggested Embassy Chess or Teutonic Chess, but this solution would probably work for those as well. /Mats *edited for site policy

I’ll have my list finished up by early next week: Muller’s list also helps a lot with starting up an opening book.

Mats: The reason why we’re studying openings is so computer programs can make reasonable opening moves. It looks like you haven’t been reading this thread. We use a basic opening book to minimize the issues caused when a deterministic computer program plays a given Capablanca setup more than once.

As for human players, an opening book gives a player a pretty good idea of how to start the game. Avoiding “over-analyzed” opening books is easy in Capa setups; there are 720 different opening setups with the rooks in the corner, bishops on opposite colors, and the king on the F file. Of those, 18 have symmetry with the knights and the bishops, and the bishops closer to the center file than the knights.

There simply is no need to implement your idea to advance some pawns one square randomly, and you yourself have pointed out it causes problems in, say, the Embassy setup (RNBQKMABNR or if you insist on having the King in the F file, RNBAMKQBNR), or even your own Teutonic setup (RNBQAKMBNR). Can we please keep the discussion here on-topic without coming up with untested blue-sky ideas?

*edited for site policy

OK, this is the Joker80 analysis of Schoolbook array. I let it run for 12 ply from the opening, printing every position with an exact score searched to a depth of 10 ply, keeping the window open from -0.10 to + 0.20 (white POV) on all searches of 10 ply or deeper. Both the 11-ply and 12-ply search came up with c2-c4 as best move. At 11 ply e2-e3 was deemed as good, but it dropped a lot in the 12ply search. But f2-f4 did exactly the opposite.

The following table gives the move path, followed by the score/depth of the position after these moves. Because I searched 12 ply, and printed everything with d>=10, it did not only print the white moves but also the black replies. elow I did list some replies to the best white moves.

c2c4  0.10/11 (0.05/10)
f2f4  0.05/11 (0.00/10)
g2g4  0.04/11 (0.02/10)
c2c3  0.04/11 (0.04/10)
e2e3  0.01/11 (0.00/10)
e2e4  0.00/11 (0.05/10)
f2f3  0.00/11 (0.01/10)
h1i3  0.00/11 (-0.00/10)
g2g3  0.00/11 (-0.02/10)
d2d4  0.00/11 (-0.03/10)
h2h3 -0.00/11 (0.00/10)
c1b3 -0.01/11 (-0.01/10)
h1g3 -0.01/11 (-0.01/10)
d2d3 -0.03/11 (-0.04/10)
e1d3 -0.03/11 (-0.05/10)
h2h4 -0.03/11 (-0.06/10)
c1d3 -0.04/11 (-0.07/10)
a2a4 -0.06/11 (-0.09/10)
i1h3 -0.09/11 (-0.06/10)
j2j3 -0.09/11 

c2c4 c7c5: -0.10/10
c2c4 g7g6: -0.11/10
c2c4 c7c6: -0.14/10
c2c4 g7g5: -0.14/10
c2c4 h8i6: -0.15/10
c2c4 e7e5: -0.16/10
c2c4 f7f6: -0.16/10
c2c4 e8d6: -0.16/10
c2c4 e7e6: -0.18/10
c2c4 i8h6: -0.18/10
c2c4  0.10/11
12      10  2582729  104628430 ? c2c4 c7c5 f2f3 i8h6 c1b3 d8c7 h1g3
e2e4 c7c6:  0.00/10
e2e4 c7c5: -0.04/10
e2e4 e8f6: -0.09/10
e2e4 e7e5: -0.10/10
e2e4 h7h6: -0.10/10
e2e4 f7f6: -0.13/10
e2e4 e7e6: -0.14/10
e2e4 g7g6: -0.15/10
e2e4 g7g5: -0.16/10
e2e4 h8i6: -0.18/10
e2e4  0.00/11
11       4    25428   83877288 ? e2e4 f7f6 d2d4 c7c6 f2f3 d8c7 i1h3 e8i4
12       0   426852 1429007351 ? e2e4 c7c6 i1h3 e8d6 f2f3 f8e8 d2d4 h7h6 e4e5
f2f4 f7f6: -0.05/10
f2f4 c7c6: -0.07/10
f2f4 f7f5: -0.08/10
f2f4 h7h6: -0.10/10
f2f4 d7d5: -0.11/10
f2f4 e8d6: -0.11/10
f2f4 h8i6: -0.13/10
f2f4 d7d6: -0.13/10
f2f4 e7e6: -0.14/10
f2f4 c8b6: -0.14/10
f2f4 g7g6: -0.15/10
f2f4 j7j5: -0.16/10
f2f4 b7b6: -0.16/10
f2f4 c8d6: -0.17/10
f2f4 i7i5: -0.19/10
f2f4  0.05/11
12       5   692665 -1980185374 ? f2f4 f7f6 e2e3 g7g5 h1g3 c7c6 f4f5 d8c7 d1g4
g2g4 c7c5: -0.04/10
g2g4 f7f6: -0.05/10
g2g4 g7g6: -0.07/10
g2g4 h7h6: -0.08/10
g2g4 e7e5: -0.08/10
g2g4 d7d5: -0.08/10
g2g4 c7c6: -0.08/10
g2g4 g7g5: -0.09/10
g2g4 e8d6: -0.10/10
g2g4 c8b6: -0.13/10
g2g4 h8g6: -0.14/10
g2g4 i8h6: -0.14/10
g2g4 h8i6: -0.15/10
g2g4 d7d6: -0.16/10
g2g4 b7b5: -0.16/10
g2g4 i7i6: -0.17/10
g2g4 a7a5: -0.18/10
g2g4 e7e6: -0.18/10
g2g4 j7j6: -0.19/10
g2g4  0.04/11
c2c3 c7c6: -0.04/10
c2c3 c7c5: -0.04/10
c2c3 g7g5: -0.07/10
c2c3 g7g6: -0.07/10
c2c3 e7e6: -0.10/10
c2c3 c8b6: -0.14/10
c2c3 h8i6: -0.15/10
c2c3 i8h6: -0.15/10
c2c3 h7h5: -0.17/10
c2c3 h8g6: -0.18/10
c2c3 e7e5: -0.18/10
c2c3 d7d5: -0.18/10
c2c3  0.04/11

In terms of making an opening book, while it would be nice to do so with refined values of the pieces (as Greg pointed out, this can be done in ChessV 0.9.0, and my Schoolbook Zillions preset even has a ChessV save game file which one can easily modify with a text editor to tweak the value of the pieces), I’ve already done over half of the work to get a basic 15-node or so opening book for Schoolbook out there so two deterministic Chess engines can play each other a Schoolbook “showdown” and not just play the same game 15 times over.

It’s not a perfect opening book, but I’ve reviewed the openings by hand and I don’t see anything that doesn’t look reasonable. We can always make a better opening book later on, and even play some very fine chess with our imperfect opening book. Indeed, some very excellent Chess was made in the 19th century when openings like the Queen’s pawn opening and the Sicilian defense were considered inferior and very rarely used.

In terms of changing the Joker80 engine to choose from a greater range of possible moves in the opening, I think this is a good idea. I’ve always liked Zillions’ ability to make the move done from a given position more random and I also think it will make Joker80 a stronger Chess player.

I’m very glad to see some serious work being done to computer programs that play Chess and Chess variants competitively. Capablanca/Carrera/Bird Chess, in particular, results in some very sharp and tactical games that computers play very well, and it’s relatively easy to tweak an engine that can play FIDE Chess to play 10x8 Chess. There are dozens of possible opening positions for the pieces, and opening positions we thought in the mid-2000s were no good (positions with first-move mating threats and what not) may very well be OK, but one open question is whether there is any measurable White advantage to a setup where he can threaten mate on the first move.

One thing I would love to see is to have a Chess engine that can be told “Make a reasonable opening library for this particular opening setup”, run the program on a high-end machine for a could of days, and have it output a 1000-node or 2000-node opening book for the setup in question. It won’t be a perfect opening book, but it will be one we can use to research things like seeing how much of an edge White has with a given setup.

Very interesting discussion!  I've been away too long ...

First of all, thanks go out to H. G. for adding code to make ChessV compatible with WinBoard.  I'm rolling these terrific improvements into the main code base as well as fixing the problems that resulted in version 0.9.x being so much worse than 0.9.  Update will be released this weekend (with full source code.)

Secondly, thanks go out to Sam for putting on this tournament.  I look forward to the sequel, especially since my next-generation engine will be ready for Schoolbook Chess play very shortly, and with a playing strength that will beat up on ChessV like a body-builder beating up on a cripple :)  Regarding inclusion of Zillions-of-Games, since it is a commercial product, I don't see any problem... If you've actually paid money for it, don't you have a right to use it?

Also, H. G., you mentioned that ChessV might not evaluate the pieces correctly.  This is, of course, true :)  But you can change ChessV's piece evaluations (without re-compiling the source code.)   You use a save-game (SGF) file.  To the extent that there's different opinions about the relative values of the pieces, it would be very interesting to try the alternate values and re-run Sam's opening move analysis and see if it makes any significant difference.

Also, regarding the Schoolbook chess castling rule, I refer to this rule as 'flexible' castling.  That's the name Fergus gave it because the name 'free' castling was already used by Aberg in his Capablanca variant in which not only can the king travel as far as it likes, but the rook can choose any square that the king has passed over...  (I don't personally like the free castling rule, but ChessV supports both, and some other variations, as described in the file extensability.doc.)

Will post an update soon, as soon as ChessV 0.9.4 is ready!

I would like to do this with Joker80, because I cannot be sure that ChassV uses correct piece values, which might affect its opinion on some opening lines very much. I am still thinking how I should modify Joker to get the information we want.

One way to do it might be like this: In stead of narrowing the search window by delimiting it with the scores of the best two variations found by either side, it should discount the scores by a margin of, say, 50 centiPawn, and only narrow the window if that discounted score is better than the current window setting. Then a single reply on an alternative move, which would make the score come out, say, 30 cP lower, would not immediately be considered a refutattion of that alternative move. In stead the search of replies would continue until either one was found that refuted the move by a margin of more than 50 cP, or all moves would be search to make it sure what the best reply is, so we would get an exact score for the alternative move. (Which would the ly closer to the score of the best move than 50 cP.)

The margin sets how much score we are willing to sacrifice to create variation so that the opponent cannot use a well-prepared variation against us. (i.e. this depends on how much weaker in terms of a centi-Pawn score odds we estimate the difference between a well-prepared opponent and someone who would have to find the moves behind the board.) I guess this means the margin should decrease as we get deeper into the game, based on how much branching we already created: If at move 6 we have already selected a 1-out-of-100 path, the preparation of the opponent on this particular position will necessarily on average be 100 times worse than his preparation from the standard opening, so throwing in more variation to make him totally unprepared will not bring much further gain. So we should have an idea of how common the current position will be.

We can obtain this 'rareness factor' by multiplying the move choices along the branch. If on ply 1 we had 3 playable moves (within the score margin), on ply 3 we had 2 and on ply 5 we have 4 moves, we are in a 1:3*2*4 = 1:24 position, and could shrink the margins accoringly. When we search the opening position through iterative deepening, the previous iteration will tell us how many playable moves there are, before searching each of them at the new, increased depth.

This is a bit complicated, though. So perhaps it would be better to simply do an iteratively deepened search where the search window will be kept open in every internal tree node to at least the margin around the root score of the previous iteration. That would mean that all positions in the tree within +/- margin from the previous root score would acquire exact scores. Only outside this window, positions would get upper or lower-bound scores, telling us that they should be considered refuted by one side or the other.

The main question is how to present any output from this process. Perhaps for every node in the tree that receives an exact score we should simply print out the entire branch leading up to that node, together with the score. I guess we would be happy if we have, say 10,000 lines, which should be easily doable. That would on average be a 1:100 choice for white as well as black, diluting any possile preparation efforts of the opponent 100-fold I guess that only after we have such an opening tree we could check if there are problems with the 'on average' notion, i.e. if the tree is robust in the sense that it could never be reduced by opponent move choice to a tree that is much smaller than the average.

Reply to this message

The truth is that chess programs have, historically, had a hard time
being creative because they simply cannot calculate whether a pawn
storm, or a positional exchance sacrifice, or a pawn sacrifice for
dynamic compensation, will lead to a concrete gain. It lies beyond the
horizon. So that's why computers have refrained from being creative,
and this is why Kasparov deemed Fritz to be a lousy program. Still
today, human grandmasters play better chess than Rybka, et al., but
it's not certain that it will always remain so.

Today, orthochess is becoming more and more dependent on preparation.
Soon it can be defined as a form of information science, with the
addition of an impressive calculating ability. This is a bad
development, and it's true that Capablanca chess, and many other
variants, represent a way out of this anti-creative and unadventurous
devlopment.

Today's chess is strongly dependent on encyclopaedic knowledgeability,
which follows from the computerization and the scientific study of
chess. A a consequence the world elite becomes younger and younger.
The average age in today's elite is below 25. At this low age people
are capable of stuffing their brains with knowledge, especially about
openings. Undoubtedly, the average age will continue to decrease.

I think that this is the expression of a form of neurosis that has
taken root In today's collectivity. It expresses itself in a wish to
develop into a perfect machine. An 'anal' attitude takes the
expression of a wish to be in total control. The ideal would be to
turn oneself into an automaton that needn't be creative, only applying
its own knowledge and exacting calculative ability on a well-known
concrete position.

Comparatively, in Anglo-Saxon checkers they randomly decide the three
first half-moves before tournament play begins, by the use of so
called ballot cards. In history, chess was most often played with long
dice. People had a different view on life back then, and were more
acceptant toward chance events. Unlike today, they weren't always in
for total control. I think that most chessplayers should begin to
loosen up their rigid standpoint toward chess, and perhaps life
overall.

'Chess holds its master in its own bonds, shackling the 
mind and brain so that the inner freedom of the very 
strongest must suffer' 
(Albert Einstein)

Mats

Tal was great because he understood the psychology of Chess. Chess is a draw if there is perfect play on both sides. So, in Chess, the goal is to make your opponent make a mistake. Tal was very good at making moves that, while not the best from a theoretical standpoint, would put his opponent off-balance, resulting in them making mistakes.

I like Capablanca chess because it's tactically very sharp, a lot more than FIDE Chess. H.J.Murray, in his 'History of Chess', complained about how 20th century chess has become too strategic. I feel Capablanca chess, by having so much power on the board, recreates the spirit of 19th century romantic chess, where tactics are king and sacrifices are very common.

Of course it can be derived from algorithms. Tal and Petrosjan are also nothing but algorithms. Exceedingly complex and unpublished algorithms, perhaps, but algorithms nonetheless. Your argument on classical music is unconvincing. What computers cannot do now, might be common place in a decade. Thirty years ago one could have said exactly the same about computers lacking the creativity to play Chess at grand-master level.

If Tal and Petrosjan subdued their opponents by theoretically unsound moves, they were only able to do it because they were much better than their opponents. This is quite normal in Chess. Speculating on that your opponent will not see the refutation but in stead will fall into a trap you set is a very efficient way to speed up winning a game against a weaker player. And that might look brilliant to one who is not able to recognize the trap either. Computers can be very easily programmed to play that way. But it will get them slaughtered by their peers, of course. It is easy to look brilliant and creative when you are _much_ better than your opponents. But when you are hardly better, it calls for realism. This has nothing to do with computer vs human algorithms. It is just the computer's bad luck that they always meet their match, in terms of search depth. So they cannot afford fancy-looking strategies that can be exposed as unsound at their own level. When your traps are exposed and backfire, they suddenly don't look so brilliant anymore. If you win by sacrificing a Queen everyone is in awe. But when you lose by it, they shrug and say, ' he blundered his Queen away again. Will this guy never learn?'...

Muller, Michail Tal played incorrectly, and hence brilliantly, and
won. He even gained the world champion title in that way. Petrosian
sacrificed the exchange in order to defend, and Spassky swept
grandmasters overboard already when the middle game had hardly begun.
Nothing of this can be derived from algorithms. A computer will
scarcely ever perform a Petrosianic form of exchange sacrifice. Not all
aspects of creativity are analyzable. It cannot be broken down into
algorithms. If that were the case then we would have programs who
created fine classical music. I didn't mention Joker80 or TJchess10x8.
I only expressed my view that computer games should be judged
according to other criteria also, not only how many points they score.
That is not a controversial standpoint at all. If you judge this
particular match as dazzling, then the losing party should get a point
or two for that. /Mats

Aesthetics aside, that leads to an interesting question: Is it possible to make a Zillions .zrf file that noticeably improves Zillions' pay ('improve' being defined as having more wins) compared to a Zillions rule file that simply implements the rules of the games, leaving it up to Zillions to come up with the best move.

It's a good question, and one I would like to see answered in the 2010 Schoolbook tournament.

In the meantime, I'm slowly but surely building up a Schoolbook opening book. Last night, I ran ChessV all night doing a 12-ply PV evaluation of all of Black's replies to 1. c3. ChessV decided there are really two reasonable replies: 1. ... Ng6 (PV: +29) and 1. ... e5 (PV: +29). The other move that looks reasonable to me, 1. ... e6 (followed by 2. ... f5 to hinder White's control of this central diagonal) was #5 on ChessV's list (after 1. ... f6 and 1. ... d6) with a PV of -23.

> In the tournament, Zillions will probably only achieve a draw, at
> most, but this doesn't matter if it plays good and interesting chess.
> These are factors which have been tragically left out of computer
> chess.

I don't understand how you can say that. Have you looked at the Joker80 vs TJchess10x8 Schoolbook games at all? I think they are all extremely interesting games, of dazzling brilliance.

And I don't follow your reasoning. What is good and what is poor Chess is determined by the rules of the game and the aim to win. If that good Chess is not aesthetically appealing to your personal taste, it cannot be blamed on the players. The players are bound by the rules, and must do the moves that lead to the best possible result these rules allow. If the result of this optimization is not to your liking, it can only be blamed on the rules.

If a program can see that a Pawn storm will be losing, it won't engage in a Pawn storm. Programming it such that it will start the Pawn storm anyway as a pathetic attempt, so that it willingly runs into the knife and gets slaughtered, might be entertaining to you, but it is simply poor Chess. If you want to see Pawn storms, you should design a Chess variant where it pays to do Pawn storms. Mad Queeen's in general does not seem to be one.

Sam, perhaps it's too ambitious to let both Zillions versions
participate. You could decide which of the two versions that should
participate by playing a game or two between them. You would find that
the tweaked version tries to control the centre with the pawns, that
it more often castles, etc. The untweaked version will spend much time
jumping about with the knights and  super-knights. So the tweaked
version should participate in the tournament and the other left out.
In the tournament, Zillions will probably only achieve a draw, at
most, but this doesn't matter if it plays good and interesting chess.
These are factors which have been tragically left out of computer
chess. This is on account of the inferior understanding of chess among
chess programmers. They are experts in algorithms, but not in chess.
In the tournament result one should also weigh such factors as
seemingly intelligent and creative play. Today, programs like Rybka
are very sophisticated. But historically the focusing on the result
implied that it was only the bean counting capacity that carried
weight. The program that succeeded in counting beyond the other
programs' move horizon was always the one which won the tournament.
However, a program that made positional pawn sacrifices, or made
daring pawn storms on the wing, etc. counted as nothing. So these
tournaments only make sense if one not only looks at the result but
also takes into account whether the programs manage to play fine
chess. /Mats

> My plan ('plan' being the operative word) is to modify Winboard to 
> implement free castling, having it so, if playing Schoolbook, one of 
> the engines doesn't recognize the free castling move, Winboard will 
> simply rearrange the pieces for that engine and continue the game. 
> This will give engines that know how to do free castling an edge. 

There might be more problems with that then you think. Some engines might consider loading a new position the start of a new game, and would get out of sync with WinBoard for counting moves to the next time control. If you play an incremental TC that should not matter, though.

Perhaps what you propose could be added as a general option to WinBoard: when an engine refuses a move through the prescribed illegal-move error message, WinBoard could reset the engine and force the position after the move into it, and restart it.

I think that the current WinBoard actualy does understand all King moves that step more than one file as castlings, putting the Rook located in that direction to the other side of it. (Except when you do a wrap-around move for Cylinder Chess.) So the engine could send f1d1, f1c1 or f1b1, and they would all be performed as queen-side castlings in -variant capablanca, provided you switch Test Legality off.

>is it OK if I change the graphics it uses to point to the piece 
>graphics I made for Schoolbook?

Yes, but why don't you keep the different colour board so that one can differ between them.
/Mats

I understand that it can be hard to get a chess engine to vary its move. Perhaps it would be possible to add more randomness to the beginning of the game, which decreases as the game progresses. Or perhaps just have another program that automatically generates a fairly reasonable opening book...

That said, Zillions does have a parameter that allows one to adjust how random moves are; I'm not sure how Jeff Mallett and Mark Lefler implemented it.

My plan ('plan' being the operative word) is to modify Winboard to implement free castling, having it so, if playing Schoolbook, one of the engines doesn't recognize the free castling move, Winboard will simply rearrange the pieces for that engine and continue the game. This will give engines that know how to do free castling an edge.

I hope to do all of this 2010 sometime. Right now, my geek time is pretty much filled with finishing up the next release of a DNS server I have written.

In terms of coming up with an opening book for a given variant, assuming a given setup has five reasonable opening moves for white, and each one of those moves has three replies for black (15 so far), and white has three replies for each of those replies (45), and each subsequent reply has three reasonable responses, we have 1215 leaves after 6 plies, or three moves. This is enough to check for things like white having an edge and what not, assuming all chess engines we use are completely deterministic.

Indeed, the number of required games increases fast. But the WinBoard games are not so much a problem, they can be run automatically overnight. So Zillions and ChessV are the participants that really count, in terms of effort. Perhaps it is an idea to first play Mat's improved version of Zillions against all the other engines. Then, if it loses all games, it might be pointless to play the weaker version of Zillions. ;-)

Btw, Gregory Strong is working on the follow-up of ChessV. It is called Quadrox, and it already plays normal Chess. It participated in my on-line blitz tourney yesterday. It is planned to be a WinBoard engine as well, and soon will be able to do 10x8 Chess.

Not all engines are deterministic, and Joker80 is mildly non-deterministic. (At very long time control it might become more deterministic, though.) It adds a pseudo-random term to its evaluation, determined from the starting time of the game and the hash signature of the position. This way of implementing randomization acts as a kind of poor-man's mobility evaluation, and thus should increase playing strength compared to the purely determiistic version.

Another method of introducing randomness is to add a small pseudo-random number to the score of every move in the root. When several moves have nearly equal score, this should randomly choose between them. This does not increase playing strength, but it stays effective at arbitrary large search depth.

Put this multi-PV mode (givin scores for several moves, rather than just the best) such as you show on ChessV can definitely be very useful for constructing a book. Perhaps I should implement it in Joker80 too. The idea of a book is that you are willing to play theoretically sub-optimal moves to provide diversity, so that the opponent cannot easily prepare, and thus will eventually play even more sub-optimal moves. If you are striving for a variabilty of 1000 lines, and you can choose between 10 moves on each ply, you only need a book of depth 3. (Well, perhaps 4 because many lines are transpositions of other lines.) But you would be choosing the 10th best move on some of these lines, and its score might be really a lot lower than that of the best. So in practice you only choose on average between 2-3 moves on each ply, and your book had to be 10 deep before it fans out to 1000 lines (assuming the opponent always plays his best move). But then all these lines can be very close in score to the best line. So there is a trade-off between depth of the book and how much score you have to sacrifice to get a given variability.

It would be interesting to develop (and implement) an algorithm that would create the minimal tree that would have a given number of end leaves with a score (as determined by an engine search of a given quality) within a preset margin from the best line. E.g. how much variation would it buy us if we are willing to sacrifice 30 centiPawn after 1, 2, 3, 4, 5 moves, against optimal play.

I will probably include both a simple implementation of Schoolbook and Mats' tweaked version of Schoolbook in the 2010 tournament. My current plan is to have a double round robin with the following engines:

• Joker80
• FairyMax
• TJChess10x8
• ChessV 0.9.0
• Zillions (Mats' tweaks)
• Zillions (simple .zrf)

OK, as for the opening array, it sounds like there really isn't that much of a difference between say, RNBQAKMBNR (1. Mh3 mating threat) and, say RNQBMKBANR (all pawns defended in the opening array). Looks like the ideas around in the mid-2000s that about needing all of the pawns defended in the opening array didn't hold water. If arrays without all of the pawns defended gave white a significant advantage, I'm sure Muller would have seen it by now.

One issue with computers playing chess is that computers are deterministic. It's akin to Pac-Man in the early 80s, where the ghosts always moved certain ways and players developed patterns to avoid the ghosts and win the maze. Many chess engines are the same; they always make a given move at a given position and time control.

Chess engines playing FIDE chess work around this problem by having an opening book, and choosing a move from their opening book at random until they're out of the book. To do this, however, we need an opening book. Without an opening book, computers do mistakes like developing strong pieces too quickly or trying to set up dubious tactical traps before fully developing pieces.

One way to make an opening book is to have a Chess engine have an analysis mode, where at a given position, the chess engine evaluates all of the possible moves and comes up with a list of all the moves and how good the moves are. A human then, with this list, decides if all of the moves the engine likes are actually good moves, removing moves that develop strong pieces too quickly or set up dubious tactical traps.

I know ChessV has an analysis mode that does just this. For example, in Schoolbook's opening position, here is ChessV 0.9.0's 9-ply analysis of all possible moves:

f4	51
f3	23
e4	21
Nd3	20
Ng3	5
e3	0
c3	-17
d3	-23
Nb3	-42
Ni3	-60
g3	-71
d4	-75
h3	-78
c4	-83
g4	-109
j4	-120
a3	-140
a4	-140
b4	-168
i4	-168
i3	-176
b3	-180
h4	-223
Ad3	-400
Af3	-400
Mh3	-400
Mj3	-400

Likewise, the computer likes c3 more than c4 probably because after 1. c4 f6 (not f5 because of 2. Qxf5+), black has a bishop attacking the pawn on c4 and you can't naturally develop a piece to defend it; indeed Joker80 also seems to prefer c3. So, based on this analysis, and human evaluation of the resulting positions, White's best moves are probably f4, e4, Nd3, Ng3, and c3. This last move allows White's queen to immediately put pressure on the center, and a subsequent Bc2 increases that pressure.

One can argue that an opening book is a bit of a cop-out, especially since there are dozens of equally valid Capablanca opening setups. I agree that having a Chess engine that can reasonably evaluate the opening is a lot better than just using an opening book when playing variants, but it's a lot harder to develop. Since the emphasis has been on FIDE chess for so long, people haven't really done much work on making an engine that can make better opening moves without an opening book. I also find Joker80's non-castling king moves unusual, but Zillions seems to do those too.

Sam, if you're going to use Zillions to play Schoolbook Chess, please use my implementation. It is tweaked to play better. Castling is encouraged. Early centre pawn moves are encouraged. Wasting king moves to the corners is discouraged. Early queen moves are discouraged. Diverse code improvements. Piece values have been tweaked, too. It can be downloaded here:
http://hem.passagen.se/melki9/SchoolbookChess.zip
(you could add this zrf to your Schoolbook page)
/Mats

I found a page with a download link for SMIRF here:

http://www.chessbox.de/Compu/schachsmirf.html

Do you have Smirfoglot to run it under WiBoard? For the latest WinBoard version, downloadable from WinBoard forum, I include Smirfoglot with the (optional) Chess-Variants profile of the install.

I never noticed a big advantage for white in any opening array, but my method of testing might hide it. White bias in normal Chess is 3-4%, so to measure changes of that you really have to measure at the 1% level, which means a 1000+ games. When I test for piece values I play that number of games, but usually I shuffle the array, and any particular aray is only played a few times. In addition, Fairy-Max is programmed to do its first 3 moves more or less randomly, to create even more diversity. So if there is a particular line that would give white a better advantage, it would not be played often enough to stick out of the statistical noise in the result.

I guess what would be needed is really avoid randomness as much as possible, and let the positio play by 1000 different engines. But I don't have that many engines. As an alternative I could try to program more randomness during the game, and less in the beginning. But the problem is that engines might prefer some opening line then, which need not be the best at all. Especially at fast time controls. In normal Chess most engines would have grave difficulty in rediscovering major opening lines known from theory, when they have to play without book. Some make an absolute mess of it even at long TC. Joker is actually pretty good at this, because it was designed to play (normal Chess) without book, and I tuned its evaluation to not make silly opening errors. But if this also works well in 10x8 is anybody's guess. I discovered a very bad misadjustment of Joker's way to score castling w.r.t. King Safety after castling, which in Schoolbook led it to destroy its own castling rights (because it could not find a way to castle within the horizon fast enough, like it always would in normal Chess).

I guess that the best way to test such things would be to create a small opening tree of likely moves by hand. Or perhaps run an engine in multi-PV mode to analyze early opening positions for a few minutes each, to get the best few moves in every position, and construct a tree from that. And then evaluate the leaves of that tree by using it as starting position for a deep analysis, or for a thousand fast games. And then propagate the scores or winning probabilities along the opening tree towards the root.

It is my personal opinion that immediate mate threats do not impact the white beas very much, anymore than the existence of fool's mate or shephard's mate have a big impact on openings of ordinary Chess. In fact threatening those latter mates are considered very poor opening moves. To my eye threatening mate with the Marshal looks much the same. It does not look like a good opening move, (which you would likely wanted to play when it did not make the mate threat), and the opponent will simply defend against the mate with a good development move, like advancing the attacked Pawn, or defending it with a Knight, or blocking the Marshall's path with a Knight

Even the arguments I have seen that the Capablaca is a bad because of its high white bias are strongly based on the assumption of piece values, considering many lines as 'losing' because they contain a (B+N) vs (R+N) trade. While in fact these trades might be favorable in reality, and just misevaluated because of underestimation of the (B+N) value. Part of what makes the Joker80-TJchess10x8 games so interesting is that these engines do have a very different opinion on the relative values of the superpieces, so that unequal trades occur quite often (e.g. A vs M or A vs. R+B). This gives several nice examples of an Archbishop slaughtering a Marshall or Queen.

P.S. after spending most of the day by being captivated by the Schoolbook match, I hosted the monthly on-line computer blitz tourney on my Internet Chess Server in the evening. And it really struck me how incredibly boring ordinary Chess was compared to the 10x8 games I had been watching in the afternoon...

Hey, it's really great you did this contest! I have taken the liberty of taking the file, renaming it to Schoolbook-2009-Muller, using a program to make the .zip file a little smaller (Advancecomp, based on the 7-zip code), and putting it at http://samiam.org/schoolbook.

I agree developing the Queen in the Schoolbook array is awkward. The quickest way to develop her (which Joker likes to do) is 1. c3 followed often by 2. Bc2. Unlike FIDE chess, in Schoolbook it's very different to develop the strong pieces quickly early in the game.

It's also a bit difficult to develop the Marshall (Rook + Knight piece). Indeed, because of the setup, often times people end up exchanging off the Marshall early. After 1. f4 f5 2. Bd4, black can now do 2. ... Mh6, which threatens Mxh2.

Now, excuse me while I let some inventor's pride through:

I observed similar problems when designing this variant. The thinking is this: By making the major pieces harder and more awkward to develop, we lower White's advantage. Since there's so much more power on the board than in FIDE Chess, it's important we don't let White quickly dominate things.

Just as, in FIDE Chess, the rooks are pieces that are usually not put in to play until the mid-game or endgame, Schoolbook's unusual setup makes it so all the really powerful pieces aren't as often put in to play until past the opening. This way, the minor pieces are still relevant, develop more easily (knight and bishop development is basically the same as in FIDE Chess, without the tension caused by the queen defending a center pawn), and allow Black to more easily equalize than in other Capablanca setups.

Of course, the disadvantage of this is that games can be longer than for other Capa setups, and some of the patterns are very different from FIDE's patterns.

Speaking of how the Capa opening setup affects the game, the following setups allow white to threaten mate on the first move:

RQNBMKBNAR		1. Md3 mating threat
RQBNAKNBMR		1. Mh3 mating threat
RNBQAKMBNR      	Gargoyle substitute (1. Mh3 mating threat)
RNBAQKMBNR      	Capa 1 (1.Mh3 mating threat)
RNBAQKMBNR		Embassy substitute (1. Mh3 mating threat)
RBNQKMANBR		1. Mg3 mating threat
RABNQKNBMR		Capablanca substitute (1. Mh3 mating threat)

What is your experience with these setups where White can threaten mate on the first move? You used three of them as 'substitute' setups in your 10x8 contest, so I know you have played with some of these. Do they give White a strong advantage? Do these setups seem unbalanced to you?

We had a discussion about this in another thread a couple of years ago, but none of us had the tools to really test the setups, so we were unable to come to any real conclusions.

About SMIRF, it looks like 8x10.net is down, so I was unable to download the most recent version of SMIRF. I have older versions of SMIRF, and they play Schoolbook chess quite nicely, but I don't feel it is fair to enter an older outdated version of SMIRF in to the contest.

OK, sounds good. Did you consider SMIRF? It can play under WinBoard with my Smirfoglot adapter, and I am pretty sure it should be able to do Schoolbook. In last years 10x8 tourney I held, SMIRF finished between Joker and TJ. But I think TJ has been much improved; I was playing 0.96 last year, and now we have 0.121.

The past day I have been playing Joker80.np vs TJchess10x8 0.121 at game/15 min in Schoolbook. That is, to make sure I got all different games, I started from the Schoolbook opening, and then 16 positions that had a (different) first move made by white. Each engine played each position with white and black, for 34 games in total. Joker80 beat TJchess10x8 by 22 vs 12. 

Most games were very exciting, lots of fireworks. (There were only 2 draws.) Interesting is that the engines differ very much in evaluation for most of the game, usually by 3-4 Pawns, so that they can each think they are 2 Pawns ahead! If you are interested: the PGN file can be downloaded at:

http://home.hccnet.nl/h.g.muller/Schoolbook.zip

From watching the games, it seemed to me that the Schoolbook opening array is a bit awkward; in many games the engines had grave difficulty developing the Queen. Often this was the decisive factor leading to their demise.

However, my description of the Schoolbook rules have the standard 'The rules are otherwise as in FIDE chess' line in them; that includes FIDE tournament time controls. Just as I penalize an engine that can't recognize a castling move the opponent just made (Schoolbook allows the king to move two or three squares while castling, as well as four squares to the left) by resetting the board so the castling move can be done and docking time from the engine that didn't recognize the move, I feel it's fair to penalize engines that don't use FIDE tournament time controls (which have changed over the years, used to be 40 moves in two hours, and are currently 40 moves in 75 minutes, 30 seconds added per move, but because of some grumbling, 40 moves in two hours is still OK).

I might do Schoolbook 2010 as another 'quick chess' tournament (40 moves in 20 minutes, 30 seconds per move for older engines), or I might do it as 40 moves in two hours, or three minutes per move for the engines that can't handle tournament time controls. I haven't decided yet.

As for RTFM and WinBoard fairy, I think all you need to do is add a link to the manual.

Some other points: I have added a disclaimer to Schoolbook 2009 that Joker80's play in the tournament does not reflect its playing strength. In addition, I will have FairyMax be a contestant in Schoolbook 2010, so we can compare it to the other engines.

I hope Zillions gives me permission to enter their engine in to the contest. Or maybe I'll just enter some engines in to the contest without permission, as long as the maker does not object to having the engine in the contest. The reason why I followed the 'permission from the engine maker' rule for Schoolbook 2009 is because there have been issues with this in the past.

Well, I guess if some participants only can play with some fixed time per move, which does not accumulate when they are fast and do not use all their time, this will severely handicap those engines. So it would only be fair if you would handicap the other engines likewise. The quality of the play for a given invested amount of CPU time would go down by this, but you might consider that less of a drawback than favoring the engines with more versatile time management.

An engine playing at 1 move / N sec would be able to quickly build uo some time reserve during the first 10 moves (in which they are unlikly to lose the game already, because both sides will be underdeveloped in this phase), and then have the advantage of being able to alot more time on difficult moves, which the others can't. So perhaps it is not as bad as I first thought to use the 1 move / N minute mode, and certainly fairer towards the opponents.

WinBoard does have a TC mode where you can set fixed, non-accumulatng time per move, but it is cannot be set from the TC dialog, and my engines do not support it well. (Joker80 would play, but probably use less than 30% of its time, while Fairy-Max would sooner or later forfeit every game, because it does not have an emergency break to cut extreme flukes of its highly variable search time.) But I notice that you do not play Fairy-Max anyway (although I was under the impression that it is a lot stronger than ChessV).

It depeds a bit on your philosophy, I guess. Is it fair that engines with more advanced time management have a better chance of winning? Some would say yes, because time management is part of the game. Others would be interested purely in the quality of the search engine.

As to the docs: This might be an idea, although the help file of WinBoard is already very long. As I did not change any of the basic TC modes, which have been around for decades, I did not change the docs on it either. I had to add enough for describing all the enhancements I made, and concentrated on that. But now that I look at it I see that the description is not very clear. In addition, I added time-odds controls to this dialog, and tey are not described in the menu section at all. So I guess I should make some additions here anyway.

Does that sound fair to you for the 2010 Schoolbook tournament?

As an aside, if you have time for it, more documentation for WinBoard and Joker80 (so others don't make the same mistakes I did) would be nice.

That depends on how you define reasonable. I guess it would only reduce its strength by about 150 Elo compared to non-extreme time controls of the same average time per move. (Of course the opponents would likely also suffer, and it is difficult to predict if they would suffer more or less.) That is at least more reasonable than reducing its strength by 2500 Elo through making it search 1 ply only.

The reason is that engines function optimally if they can allocate time to those moves where it is needed. This results in a strongly variable time per move: there are natural points where they could stop, and time spent after that is largely wasted, until you go all the way to the next point where to stop. Unless they discover that they are really in trouble, i.e. the move they focused on so far suddenly turns sour at larger depth. Then it pays to allow them extra time until they found at least a reasonale alternative. After all, time is only a factor if you plan to fight on. So playing a move that you know to be immediately losing just to save time is never an attractive proposition.

By harrassing the engine through facing it with a time control on every move, you largely make sensible time management impossible. In particular, Joker calculates its nominal search time as T/(N+3), where T is the remaining time on its clock, N is the number of moves it still has to do in that time. So it keeps 3 moves worth of time reserve to be able to solve inadvertant trouble on the last move before the TC. But if N=1 always, this would make it do the initial moves very fast.

I would advice against trying extreme time controls, but use the engines in modes for which they are designed, rather than see how much you can stress them before they break. At least, I assume you are interested in how well they play Chess. If you put two grand masters to a game where someone is constantly knocking them over the head with a pillow, and hosing them down with a fire hose... Well, they might be able to complete the game, but who wins is likely to reflect other properties than their skill at chess. Just play game/time, game + small increment per time or 40 moves/time. So 15+0, 10+5 or 40/10 would be good controls to test them at (i.e. 15 min sudden death, 10 min + 5 sec/move or 40 moves / 10 min). Trying extremes only tells you something about the robustness of their time management outside the range of its design parameters, and has little to do with chess.

Joker80 does game/time very well, but you have to tell it that it should do game per time for that to be apparent. This time control is known as 'Incremental', and you have to select it in the Time Control dialog, and then enter 15 min per game + 0 sec per move.

All you have discovered is that the code for reading the time control does not test the input for reasonability. I should simply make Joker80 exit immediately when someone specifies more than 60 movesin a conventional time control. Conventional time controls are never played with more than 40 moves per session; in Chess that would be quite pointless. You would get a huge amount of extra time at a point where in 95% of the cases the game is already decided, if not finished.

9999999 moves per 15 minutes is just not a valid way to enter game / time for WinBoard engines.

My plan, for the 2010 Schoolbook tournament, is to have the games be played at a time control of 30 seconds per move (1 move in 30 seconds), so that the engines that can't handle tournament time controls (ChessV 0.9.0, Zillions if they ever give me permission, etc.) will be on an even playing field with the engines that can't handle tournament time controls.

I chose Game/15 because this is the time control used at an old chess club where I used to play chess.

I am not sure what exactly you have done, but from the PGN of the first game (I did not look at the others yet) I can see it is something very strange. For one, these was not a 15 min game. The TimeControl tag in the PGN says 9999999/7200, which means 10 million moves in 7200 sec, or about 1.3 msec/move. As a result Joker moves instantly on many moves, having searched only 1 ply deep. (This can be seen from the comments between {} printed after each Joker move, which list score/depth (in Pawn units and ply), and time in sec). This means it essentially plays a random move.

To my surprise there are also moves where Joker searches 11 ply, and thinks 20-30 sec. I guess this is caused by ponder hits, where Joker could reach high depth in the opponent's time, and then finished the iteration. When there was a ponder miss, and Joker had to start searching from scratch when its turn started, it moved instantly and randomly.

This is not a useful way to use Joker80.

[Event 'Computer Chess Game']
[Site 'MEREQUETENGUE']
[Date '2009.09.08']
[Round '-']
[White 'Sam Trenholme']
[Black 'Joker80.np']
[Result '1-0']
[TimeControl '9999999/7200']
[Variant 'capablanca']
[FEN 'rqnbakbncr/pppppppppp/10/10/10/10/PPPPPPPPPP/RQNBAKBNCR w KQkq - 0 1']
[SetUp '1']

1. f4 h5 {+0.04/1 0.2} 2. e4 Bi6 {-0.29/11 30} 3. Ni3 e5 {-0.33/1 0.2} 4.
fxe5 h4 {-0.29/1 0.2} 5. Ng4 Bh7 {-0.70/11 22} 6. Bf3 Be7 {-0.25/1 0.2} 7.
Bf2 Ni6 {-0.74/11 14} 8. Ni5 Bg8 {-0.64/11 22} 9. Nd3 b5 {+0.05/1 0.2} 10.
Qd1 Ch8 {-0.12/1 0.3} 11. Be3 Ci8 {+0.10/1 0.1} 12. Nxj7 Rxj7 {-0.54/1 0.1}
13. Bxi6 Rj6 {-1.37/12 12} 14. Bxg8 Kxg8 {-1.66/12 30} 15. Ch3 i6
{-0.66/1 0.2} 16. O-O a5 {-1.93/11 29} 17. Qf3 Nb6 {-1.41/1 0.3} 18. Bg5
Bxg5 {-2.67/12 23} 19. Cxg5 i5 {-3.02/11 20} 20. Qf5 Ra7 {-2.54/1 0.7} 21.
Qxi8#
{White mates} 1-0

I got permission from three makers of chess engines to enter the 2009 Schoolbook Chess computer tournament; the tournament was a six-game double round robin. The final results were:

ChessV 0.9.0 with time handicap: 3
TJChess10x8: 3
Joker80: 0

The games were Game/15 (all moves in 15 minute) games done on a Core 2 Dual 1.5 ghz laptop processor. A reasonable, but not extensive, effort was made to make sure no other processes were running during the tournament. Both engines played (and pondered) at the same time on the same computer.

TJChess and Joker80 played at Game/15 in WinBoard. ChessV 0.9.0 was given 30 seconds to make a single move.

Joker80 lost all four games it played, giving TJChess10x8 and ChessV 2 points each. In the ChessV-TJChess10x8 games, TJChess10x8 won once as white, as did ChessV.

I observe that Joker80 is usually stronger than TJChess10x8, but plays Game/15 very poorly.

In both TJ-vs-ChessV games, ChessV made a castling move TJChess could not recognize (in Schoolbook, it is legal to move the kind two or three squares while castling, and four squares while castling on the queenside). When this happened, I stopped the clocks, set up the board to have the castling move be done, restarted WinBoard, and gave TJChess10x8 10 minutes to complete the rest of its moves.

The actual games, including Zillions of Games save files of all games, and PGN files of all games played by Joker80, are available at the following location:

http://samiam.org/schoolbook/

For people who do not have Zillions of Games, the save files are in a format that looks like a normal Chess score.

I note you make pawns less valuable than they are in 8x8 FIDE chess; I think a big reason is because, with three powerful pieces on the board, the game is more tactical and less strategic.

- Sam

Scharnagl> Falcon 5690334 covers all 453,600 arrays 8x10, 9x10, 10x10 and larger. There is no distinction. We recommend from playtesting RNBFQK..., RNFBQK..., RFNBQK..., FBRNQKNRBF, FRNBQK..., BRNQFFK..., RNBQFFK...   Notice Rooks are always a1, b1, or c1, and King within d1 to g1. Most would not want Randomized all possibilites. You are right, it is different when Rooks are only two from King, but we recommend to avoid adjacent Rook and King. For Rook and King two apart, I will define ''free castling'' as ''not a1, not j1, and King must go at least two over, overtaking Rook if necessary or if K & R are within three.'' That means Kingside castling is fixed destination in three of the above. (Other CVs may vary.)

The table was actually given in my first post in that thread. It might be burried very deep under what unfortunately followed. I am sorry about that, it arose from Derek taking it as a personal offense when I pointed out that the values he derived from elaborate theoretical arguments were no good in practice. So let me repeat the table:

P =  85
N = 300
B = 350 (B-pair bonus = 40)
R = 475
A = 875
C = 900
Q = 950 

I usually normalize on the Q value, as Pawns come in many forms (doubled, isolated, backward, passed, doubled, edge), with extremely different values. So giving a value for the Pawn wouldn't mean a thing if you don't tell at the same time which kind of Pawn. All values above are opening values, where the Pawn is f2/f7 in the opening array.

The values were empirically derived from playing 20,000 games starting from opening setups where selected pieces were deleted from the array to create a material imbalance.

Rooks are known to be orth a lot more in end-games than in the early opening, so the Rook value might be higher than given here during most of the game.