First KGS Slow Computer Go Tournament

Monday-Friday December 18th-22nd, 2006

These results also appear on the official KGS page, which links to the game records.


board size19x19
time710 minutes absolute, i.e. 11 hours 50 minutes. (The KGS page states 11 hours 20 minutes. This is false, and is my error.)


Five-round Swiss.


The first round started at Sunday/Monday midnight UCT.



The "real" names of the bots listed above, and of their programmers, are listed here: programs which have registered for KGS Computer Go Tournaments.


This event used time limits of almost twelve hours each – much longer than any previous bot tournament, on KGS or anywhere else. This should give Monte-Carlo bots, already proven to be good at small-board Go given enough time, a chance to show their strength at 19x19 Go. MC bots in this event were botnoid, Mango, MoGo (twice), and SimpleBot.

I made the entry conditions easier than for the Formal division of a regular monthly bot tournament. This allowed both GNU Go and Slug Go to enter. Also, I decided to allow two versions of MoGo to enter: MoGoBot is the regular version, using global UCT, and MoGoBot19 is a version which uses local UCT only, searching moves near to the last-placed stone.

WeakBot50k also registered, on the understanding that it would only play if its presence made the numbers even, to avoid byes. There were eight other entrants, so I withdrew it at the last minute. I am grateful to Aloril for providing an entrant that can be used like this.

Several things went wrong in the course of the tournament: a bug in KGS, bugs in one of the entrants, and internet connection problems by another. This was all instructive. The event proved popular, and I hope soon to hold another Slow tournament after these bugs have been fixed.

Round 1

GNU beat AyaBot in an uneventful game.

Mango suffered problems in its game with MoGoBot. It is running UCT on the full 19x19 board, and this filled up its memory, causing swapping problems and crashes. Eventually Mango resigned.

MoGoBot19 achieved an overwhelmingly won position in its game with SimpleBot.
       However, it has been found that getting UCT to maximise expected winning margin is not as effective (in winning games) as getting it to maximise expectation of winning, and so both MoGoBots do the latter. A consequence of this is that, once they believe that they have a certain win, they pass. They don't mind their opponent rescuing dead groups if this does not take away their win. (I don't altogether see the logic of this – if any move is good enough to win, why not put a meaningless stone on the board, or even deliberately make a one-point eye, rather than passing?)
       Anyway, the consequence of this was that MoGoBot eventually won by only 13½ points.

SlugGo did not connect to KGS for its game with botnoid. Botnoid made its move, and was then evicted from the game by the server applying the "five minute rule". This rule says that if a bot is in a game from which its opponent has been absent for five minutes, then the bot gets removed from the game (but not from the server). This is appropriate if a bot is playing against a human who has "escaped", but is definitely not appropriate in a tournament game.
       This rule has caused problems in previous KGS bot tournaments, and I have reported on it several times, giving a detailed report in my account of the 18th KGS bot tournament. However I have failed to convey these reports to wms, who would have fixed the problem. I have now reported it to him, and he has fixed it. The fix will appear with the next release, version 3.3.12, of the server. I shall not hold another Slow tournament until then.
       Botnoid's author, Don Dailey, was watching, and feared that if slugGo appeared when Don was not watching, ready to force his botnoid to reconnect, it might lose on time. So he wrote a script for botnoid, that caused it to reconnect automatically. This worked, but was not needed: slugGo had lost on time before it mananged to connect. SlugGo did eventually connect, but too late.

Round 2

AyaBot started well against slugGo, and appeared to be well ahead around move 100. But it started to miss opportunities, and collapsed. SlugGo eventually won by over 100 points.

MoGoBot achieved a convincingly won position against botnoid, but then started to pass whenever it was not absolutely necessary for it to move. Eventually MoGoBot won by only 1½ points.

In its game against SimpleBot, Mango had a few crashes and reconnects. It also played out a non-working ladder for ten moves. Despite this, Mango was able to win by 70½ points.

MoGoBot19 played a sensible-looking game against GNU. However MoGoBot19 gave up its aji in the lower right to build a dead group on the lower side, and had little chance after this. It eventually resigned, giving GNU a well-deserved win.

Round 3

AyaBot started convincingly agaist SimpleBot. It built a large moyo, and competently resisted SimpleBot's attempt to make two eyes for its invasion. But this is a risky strategy for a weak player to use: even though each of SimpleBot's attempts to live its invasion had only a 5% chance of success, it was permitted to make many attempts, and eventually one succeeded, ruining AyaBot's moyo and giving SimpleBot a won game.

In its game against MoGoBot19, botnoid spoiled its chances by chasing a non-working ladder for 11 moves. The game was pretty much over by move 250, but both players preferred to play meaningless dead stones inside their opponent's territory rather than pass, and it eventually finished, with MoGoBot19 winning as expected, on move 557. I do not know why MoGoBot19 was now playing dead stones rather than passing when it had nothing constructive to do.

GNU played sensibly against a rather erratic MoGoBot. MoGoBot resigned after losing a group at the top.

Mango crashed in its game against slugGo. It was relaunched by its operator, but meanwhile slugGo had been removed from the game by the "five minute rule" mentioned above. Eventually I noticed that this had happened, and conjectured that I could cause slugGo to re-join the game by using my admin power to "kick" it from the server. To my delight, this worked. I noticed that the delay between the kick and the reappearance of the kicked bot was very close to five minutes.
       After the game got going again, Mango "misread" a semeai, and got a poor position. SlugGo, despite all its lost time, continued to play well, and achieved an overwhelmingly won position.
       However, when I next looked at the game, both players were absent, and Mango's clock was running. I did not attempt to "kick" the players into action, as one of them (my records do not say which) was not present on the server, and so kicking the other one would have given it an unjustified win. We just waited while Mango lost on time, it would surely have lost anyway if play could have been made to resume.

Round 4

In the AyaBot – Mango game, Mango again suffered crashes. During one of its absences, AyaBot suffered from the "five minute rule" being applied. I spotted this, and kicked AyaBot from the server to wake it up - but its owner appeared at about the same time, so it was not clear that my kick was necessary, or effective.
       Later I looked at the game and found that both players were absent from the game but present on the server, and both their operators were absent from the server. I decided to kick them both, so as to get the game going again. I kicked one, and when (after the now familiar five-minute delay) it had re-joined the game, I kicked the other. However, by the time the second one had re-joined the game the first one had been removed again by the five-minue rule. I went round this loop a few times before realising that I needed to apply synchronous kicks. I waited until both were missing again, and then kicked them both, a few seconds apart. To my delight, this worked: they both joined the game together, and stayed joined.
       The game eventually came to an end with Mango 17½ points ahead. However, the players did not agree on the status of one of the groups, and the server sent them both the kgsGtp clean-up command. This asks them to continue playing until all dead stones have been reomved from the game. AyaBot complied with this and captured Mango's dead stones, but Mango did not know what it was meant to do, and the game came to a stop with two of AyaBot's clearly dead stones still on the board, destroying Mango's largets territory. So AyaBot was declared the winner.

The game between botnoid and SimpleBot was entertaining. Botnoid knows the importance of connecting its stones, and SimpleBot knows the importance of making groups with two eyes in them (even if it sometimes later fills in one of them). In this game each player did what it knows best, with little interference from its opponent. At move 255 they had arrived at the position shown. Black has eight groups, seven of them (currently) alive, while White has one.
       White eventually won by over 100 points. It could have won by more but for its UCT-induced attitude "any move that guarantees the win is good enough".

SlugGo beat GNU in a sensible and uneventful game. This is not a surprising result, as slugGo uses GNU's code (as well as its own), and runs on 22 processors.

The MoGoBot – MoGoBot19 game was very interesting. Initially, observers expected MoGoBot, with its global search, to outplay MoGoBot19's same code but restricted to a local search.
       I try to be impartial in these events. But for this game, with two bots by the same authors, indeed very nearly identical bots, I allowed my feelings to show. I wanted Black, the local-searching MoGoBot19, to win. I thought that Black was like a beginner who tries to read things out, but doesn't always see the context; while White was like a beginner who tries to make what look like good moves, without understanding.
       In fact MoGoBot19's superior skill in fighting won the game for it. In a game between humans, with the same skills and weaknesses as these two programs, and recognition of these skills and weaknesses, the global strategist would probably have beaten the local fighter; but that is because a human who knows he is worse at fighting has the sense to avoid fights. MoGoBot was quite content to get into fights in which it would be outfought. It eventually resigned.

Round 5

The botnoid – Mango game started with botnoid building solid walls, while Mango secured most of the board. Mango suffered occasional crashes and reconnects, but this did not prove a problem. By the time the sensible moves were over, Mango was winning by over 200 points.
       However, while both programs were playing meaningless stones, Mango suffered an accident. It crashed, but this time, while it reconnected soon enough, it immediately crashed again. It continued rapidly crashing and rejoining the game, without being connected for long enough to make a move, and left to itself would have eventually lost on time. Don Dailey, botnoid's author and operator, was present, and he did not want to see his program get a win in this position: he generously asked me to assign the game as a win to Mango. It is shown as a win by Forfeit. This means that the win was assigned by me, not that the loser had done anything wrong.
       Operators are forbidden to communicate with their bots in any way during a game. I shall change this rule, to allow them to instruct the bot to resign. This would involve some way of ordering the bot to resign while it is running; and, preferably, a "do you really mean it" dialog. Meanwhile, I am happy to assign a win as I did in this game; but I can only do this if I happen to be watching.

MoGoBot outplayed AyaBot, and by move 170 was making meaningless moves, confident that they were good enough to guarantee a win. It continued this so effectively that it eventually won by exactly half a point.

The winner of the MoGoBot19 – slugGo game would be the winner of the tournament. It was a well-played game, with no gross blunders. MoGoBot19's capture of some central stones put it in the lead, and it won by 2½ points.

SimpleBot had little chance against GNU. Its third move was on the 1-line; and worse, when GNU attacked this stone, SimpleBot ran it along the 1-line for nine moves before having it killed. GNU eventually killed all of SimpleBot's other stones too; it does not share MoGo's view that a half-point victory is enough.
       With move 310, SimpleBot created a group which could only be killed by the bent-four-in-the-corner process. It would have been interesting to see if GNU could carry this out correctly (I guess it could); but with move 330, SimpleBot filled one of the internal liberties itself, dieing unconditionally, though in sente.


Note on "UCT"

The abbreviation "UCT" appears frequently in these reports, in two unrelated senses. This note is to remove any confusion.

UCT used by Go-playing programs is a tree-searching algorithm described in the paper Bandit based Monte-Carlo Planning by Levente Kocsis and Csaba Szepesvári. It is an development of "UCB", Upper Confidence Bounds, and stands for UCB applied to Trees.

UCT as applied to times stands for Universal Coordinate Time. It is the same, for most practical purposes including ours, as GMT, Greenwich Mean Time, the time zone based on London, England. The difference is that GMT divides each day into 86,400 seconds of equal length, while UCT uses seconds of constant length, and has an occasional leap-second to bring it into step with the observed rotation of the earth. UCT and GMT never differ by more than two seconds. UCT is prefered to GMT because it is Politically Correct: some people regard the use of GMT as Eurocentric.