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

[Don Dailey <drd@xxxxxxx>]

Hi Nick,

>  Yes, I have misunderstood something.  I thought it was you who argued, 
>  very persuasively, that it ought to be a requirement.

It's not really an important point whether it's required or not
because requiring it doesn't guarantee a solution.

Right now, Williams protocol "pretends" that every program has
implemented it whether it has or not.

And I think this works fine.  Indeed, there is no way to actually
enforce that it be implemented correctly.  You can't force a program
to send the dead group status correctly, the program might be too
weak.  So not sending it at all is the same as sending it incorrectly.
(The server views not sending it as sending an empty list and always
sending an empty list is a valid, although not very good,
implementation.)

You can't force a program to remove the opponents dead stones because
it may not be strong enough to do this correctly.  So
"kgs-genmove_cleanup" can only be a request.  It's a way to tell the
program, "Your opponent disagree's.  It's entirely up to you (whether)
to defend your claim by clearing out his dead stones."

And since Williams protocol can fake the answer, it is not neccessary
to insist that the programs try to respond correctly to these 2
commands.  (Of course it is in their best interest to try.)

In fact, from a purists point of view, it isn't right to insist that
a program capture the dead groups.  A pass move is ALWAYS a legal move
in any ruleset, so we are essentially dictating HOW a program should
play and forbidding some moves that are actually legal.    The command
has to be a suggestion, not a dictate.

But should we require programs to "accept" these commands in order to
play in tournaments?  I'm thinking it's probably a good idea as long
as we don't try to dictate what they do with the information or how it
affects their play.  The reason it might be good to require the
commands is for dispute resolution.  A tournament director can always
say, "your program was told that there was a disagreement and chose to
do nothing about it."  The mechanism guarantees that a program was
"aware" of the dispute and it could never be (reasonably) argued that
a program was treated unfairly.





>  Ok, I am still lost.  On Sunday, most of the programs in the Formal 
>  division got involved in arguments that went "These stones are dead" "No 
>  they are alive" "Dead" "Alive" "Dead" "Alive" "Dead" "Alive" ....

I think there is a minor bug in the protocol that William will
probably address.  I think this is what happened but someone please
correct me if I'm wrong:

  1. There were 2 pass moves.
  2. The server requested a status report.
  3. The programs disagreed.
  4. And undo was sent to the program that made the second pass.
  5. kgs-genmove_cleanup commands were issued after this.
  6. Both program passed again.
  7. Again, the server requested a status report.
  8. The programs disagreed.
  9. And undo was sent to the program that made the second pass.
 10. .. back to step 5  ... infinite loop.


If I am correct about this,  the problem is step 7.  There should not
be more than a single dead stone status request after the initial set
of passes.   After the second set of passes, the score should be 
computed AS IS.   After all, both programs were requested to clean
up the dead stones and should take responsibility for either doing
this or not doing this.

I think you would be in complete agreement with all of this if it
were not for a single point.   The possibility that a game might
get scored "incorrectly."   

I don't see this as a problem if the "winning" program was given the
opportunity to back up it's claim and refused.   

What would you do if both programs passed too early and it was completely
unclear which stones were living and dead, perhaps some were simply
undecided?    This isn't hypothetical,  if we put in 2 programs that
played random legal moves you would likely get an early pass that couldn't
be resolved,  and yet both program play legally.   

You can't resolve that situation the clean way you would like but the
protocol resolves it.  It doesn't matter who might win if the game
were played out the way we would play it, what matters is that the
game actually ended with 2 passes, there was no agreement about dead
stones and so the game gets scored as is.  It's equally fair to both
players and the players were given fair opportunity to know the
opponent disagreed and to do something about it.


- Don



   Date: Thu, 9 Jun 2005 09:14:35 +0100
   From: Nick Wedd <nick@xxxxxxxxxxxxxxxxx>

   Hi Don,

   In message <200506071849.j57InlhM007346@xxxxxxxxxxxxxxxxx>, Don Dailey 
   <drd@xxxxxxxxxxxxxxxxx> writes
   >
   >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.

   Yes, I have misunderstood something.  I thought it was you who argued, 
   very persuasively, that it ought to 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.)

   But if the demand is not enforced, a human will have to step in and 
   clean up.

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

   I am lost here.  If we don't add more procedure to the end of the game, 
   what do you think happens after both players have passed and they 
   disagree about the status of a group?

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

   But the way things were on Sunday, it _isn't_ played out.  I thought you 
   were arguing for things to be changed so that it does get played out.

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

   Ok, I am still lost.  On Sunday, most of the programs in the Formal 
   division got involved in arguments that went "These stones are dead" "No 
   they are alive" "Dead" "Alive" "Dead" "Alive" "Dead" "Alive" ....
      Were all these programs implementing the protocol?
      Were some of them implementing it?
      If they weren't implementing it, do you still believe that their 
   programmers could easily be induced to implement it?
      What decision should I have made, when the group was in fact 
   unsettled?


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

   But what if it doesn't?

   Nick
   -- 
   Nick Wedd    nick@xxxxxxxxxxxxxxxxx

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