Comments/Ratings for a Single Item

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.

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.)

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

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 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

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.

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.

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.

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.

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.

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.

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.

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.

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...

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 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.

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 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.

>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

> 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.

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

> 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.

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.