Re: [computer-go] Third KGS tournament: game-end protocol

[Don Dailey <drd@xxxxxxx>]

Hi Nick,

>  I have been persuaded by posters to this list that I should eventually 
>  require bots playing in KGS computer Go tournaments to support the 
>  game-end protocol. 

I think there is a misunderstanding here.  This should not be a
requirement.

According the rules of Go, a player can pass whenever he wants to.  

kgs-genmove_cleanup is just "genmove" with a request attached to it.
The request is, "please try to capture your opponents dead stones."

It is up to the program whether it wants to honor this request, because
it is not illegal to pass.  

Therefore the kgs-genmove_protocol command is a request at best, not
an enforcable demand (according to the rules of GO anyway.)

That's why this whole business of having a human step in to clean up
the results is so unatural and ugly (in my opinion.)

So why not just let the programs simply play by the rules?  Why add
more procedure to the end of the game protocol and make it
complicated?

One huge advantage of Chinese rules is that there should never be an
argument at the end about whether a group is dead or not, it is simply
played out.  In fact, William Shubert set up the protocol to let
computers play the game the way the chinese rules expect.  This is not
a new idea or some elaborate scheme, it is part of basic chinese play.

And it doesn't require any program to do anything different unless
they want to.  It is legal to pass any time you want to in any
ruleset.  Of course it might be advantageous to clean up dead stones,
but it should not be "forced", even artifically after the game is
over.

What's the worst thing that could happen?  A program will think it's
winning but fail to defend it's claim and lose the game.   But it's
not like the program didn't have a choice.   During the actual game,
the program is expected to defend itself,  why is it suddenly ok
not to defend itself when there is disagreement?    


So here is what you could easily have:

  1. William Shuberts kgs-genmove_cleanup protocol
  2. A programmers choice whether to implement the protocol or not.
  3. A programmers choice HOW to implement it if he does implement it.
  4. A server that can easily score all games without human intervention.

Even if your program accepts the "kgs-genmove_cleanup" it is up to the
program what it will do with the information (the knowledge that there
is a disagreement) and this can't be enforced by the rules of GO so it
can't properly be a requirement.

But a good program will want accept this optional command and clear off
the opponents dead groups when it realizes the opponent is unaware that
his group is dead, otherwise it risks losing some points.   



- Don









   X-Original-To: computer-go@xxxxxxxxxxxxxxxxx
   Date: Tue, 7 Jun 2005 16:41:47 +0100
   From: Nick Wedd <nick@xxxxxxxxxxxxxxxxx>
   Reply-To: computer-go <computer-go@xxxxxxxxxxxxxxxxx>
   Sender: computer-go-bounces@xxxxxxxxxxxxxxxxx
   X-Spam-Score: -2.6
   X-Spam-Flag: NO
   X-Scanned-By: MIMEDefang 2.42

   I have been persuaded by posters to this list that I should eventually 
   require bots playing in KGS computer Go tournaments to support the 
   game-end protocol.  The protocol is:

   < --------------------------- quote starts --------------------------- >
       1. To play in a tournament, programs must either implement both 
   "kgs-genmove_cleanup" and "final_status_list dead", or they must play 
   until all of their opponent's dead stones are removed from the board. 
   It's OK if "play until dead stones removed" is an option, but they have 
   to make sure that this option is turned on whenever they are going to be 
   in a tournament, or they will do poorly in the tournament!
       2. Programs play as normal.
       3. After double pass in a tournament game, programs that support both 
   "kgs-genmove_cleanup" and "final_status_list dead" will be sent 
   "final_status_list dead", which will be uploaded to the server as the 
   list of dead stones. Programs which are missing either of those from 
   their list of supported commands will tell the server that no stones are 
   dead.
	  If there is disagreement, "kgs-genmove_cleanup" will be sent to 
   programs that support it, "genmove" to programs that do not. Note that 
   there cannot be a disagreement if neither program supports 
   "kgs-genmove_cleanup" (since after all both will have reported all 
   stones as alive!), so at least one program will get the cleanup command.
       4. After a second double pass, both programs will report to the 
   server that no stones are dead, and the server will score from there.
   < ---------------------------- quote ends ---------------------------- >

   I am sceptical about programmers' ability to implement this correctly, 
   so I am not yet requiring bots to support this protocol.  Instead, at 
   present the following applies:

   < --------------------------- quote starts --------------------------- >
   If at the end of a game, there is a group whose status is uncertain (in 
   the view of the Tournament Director), then:
       1. If both bots have implemented the game-end protocol as 
   recommended, this can't happen.
       2. If only one bot has implemented the protocol, the Tournament 
   Director will give the win to that bot, even if it thinks it is its own 
   group that is dead.
       3. If neither bot has implemented the protocol, the Tournament 
   Director will use his discretion. He may assign a loss to both players 
   [actually, he can't - there is no way to do this in a KGS event].
   < ---------------------------- quote ends ---------------------------- >

   The recent third KGS Computer Go Tournament did not see any bot resume 
   play to establish its claims about status.  What did happen, in four of 
   the games, was that two bots disagreed about the status of at least one 
   group, and rather than resume play, they alternately and repeatedly 
   asserted their claim by marking the disputed group(s) as dead and as 
   alive.  In the least clear such case, the disputed group was unsettled: 
   it had one eye, and could make, or be denied, a second eye.  In the 
   clearest such case, the disputed group had 26 foolproof eyes.  Six of 
   the eight bots in the Formal division became involved in these 
   arguments, and one risked missing its game in the next round, preferring 
   to continue to argue.

   In each case, I as Director had to form a view about the true result of 
   the game (which is made harder when the stones keep flashing on and 
   off), and enter the result manually.  In three of these four cases, the 
   game record was then wrongly saved by the KGS system, so as to be 
   inaccessible/unreadable.

   Right.  Now to the point of this email.  If (2) above applies, i.e. one 
   bot implements the game end protocol correctly and the other doesn't, 
   how will I as Director know?  What will I see happen?  Can I conclude 
   that all six bots that became involved in disputes did not implement the 
   protocol correctly?  Or is it possible that some of the six did 
   implement it correctly, but were foiled by their opponent's lack of 
   cooperation?

   Nick
   -- 
   Nick Wedd    nick@xxxxxxxxxxxxxxxxx
   _______________________________________________
   computer-go mailing list
   computer-go@xxxxxxxxxxxxxxxxx
   http://www.computer-go.org/mailman/listinfo/computer-go/

_______________________________________________
computer-go mailing list
computer-go@xxxxxxxxxxxxxxxxx
http://www.computer-go.org/mailman/listinfo/computer-go/