Uri Blass wrote: bob wrote: hgm wrote:
bob wrote:Note that was apparantely a FIDE rule, which is OK by me. But if a program says "this is a draw" and it isn't, the game should continue unless the program refuses and loses on time.
Yes, it was a FIDE rule, and by that FIDE rule all computer programs would forfeit their game even before it would start, as they have no hands and do not greet their opponent in any alternative way. That just illustrates how silly it is to require that Human rules apply without any adaptation to computers.
Furthermore note that the engines under WinBoard_F (if the user sets this option) do not forfeit because they say "this is a draw", but because they say "I won't play on" in a position that is not won or drawn by any rule. And if they don't mean that, they'd just better not say it. This is also completely similar to Human Chess, where there is also no way back if you say "I resign", and later claim that you meant something else... Even if you think this is undesirable (which I don't), in practice there is simply no way to accomodate engines that substitute arbitry commands for arbitrary other commands, by having a GUI second-guess what they really mean. Because where would it stop? You might as well have the GUI say, when a program plays 1. a2a3 "Well, but this is such a poor move, it cannot possibly mean that. Let's assume it is just bad pronunciation, and that it means 1. e2e3"... If you don't stick to the protocol, the consequences are entirely for you. That is true if you number the board files differently, and it is true when you decide 'resign' means castling. So why should it be any different when you say "this game is definitely over" when you mean you want to play on?
Sorry, but a computer playing in a FIDE event does have to shake hands with the opponent before the game starts. It is done by the human operator. The official rules have always been modified to allow computers to play, since computers obviously don't have hands to make moves or hit the clock, etc. USCF has computers using almost the same rules as those used by blind players, who can have an "assistant" that makes the move, hits the clock, and tells the player when a move has been made, etc...
But functional rules can be handled properly, things like draw offers and such...
There is a reason to have different functional rules for computer and humans in few cases like draw claims(offering draws is no problem).
The reason is that there are mistakes that non buggy programs do not do.
A wrong draw claim for 50 move rule or for repetition is one of them.
Engines usually also agree about non sufficient material draw claims
(K vs K draw
KN vs K draw KB vs K draw KB vs KB draw when the bishops have the same color)
Most engines are not smart enough to make correct draw claims in practical different cases and if there is an author that his program is smart enough to do it then he may send his code when to claim draws to H.G.Muller and I guess that Muller is not going to have problems to use it in the adjudication.
I have also seen many "correct programs" blow things like KN vs KN, which is drawn almost 100% of the time, but not exactly 100%... So the natural approach would be to have a GUI that "does it right 100% of the time, or else it is not that useful. Who would ask a FIDE Arbiter to show up at a major tournament, if it was known that he only makes the right decision 99% of the time? (and no bad jokes about the ICCA doing just this either.)
The target of interface is to support engines of different strength but
not to support a small number of buggy engines at the price of spending computer time so the simplest solution is that engines that make wrong draw claim fix the bugs and claim draw correctly.
What would happen at a FIDE tournament if you claim a draw by repetition, and the TD/arbiter comes over and says "no, you made a mistake, en passant status changed so that one of the positions is not the same as the other two..."? The game would continue even though the "buggy human" made an error. I suppose there is nothing wrong with having an option to "kill a program if it does something even slightly improper", but, for example, in the kind of testing I do I would rather see the game played out. Particularly in cases where the only information we have is the often inaccurate evaluations they produce when doing a search.
If the interface decide to continue after wrong draw claim then the engine that did the wrong claim may often lose on time(because the author usually assume that the game is not going to continue after draw claim so he does not care how his engine behaves in that case) and you may lose computer time relative to the case that the interface adjudicates the game based on the wrong draw claim.
Finally I believe that H.G.Muller's code for winboard is free so you are free to fix it and release your winboard version if you do not like adjudicating games in case of draw claims
That's what we don't need. Multiple versions that behave differently. I am already having problems with this with the two different 22.0 versions of Crafty I released and am fixing to release a 22.1 just to get past that problem.
The previous situation of accepting wrong draw claims cannot be considered as better even from your point of view.
My point has always been here that programs should not be able to "force a result". If a program wants to claim a draw, and the claim is incorrect, either the game continues or that program loses. The current situation where a program can send a "result" to xboard and end the game is bad, because I had cases where one program (arasan 9/10) would get the result backward if they were playing black, and they would claim a result that was wrong. To solve this for my testing, my "GUI" only pays attention to crafty's claims...
Detecting wrong draw claims is the first step even from your point of view and you can add option to continue the game after a wrong draw claim.
I guess that most testers will prefer to use H.G.Muller's version and not your version if you do it but testers are free to do what they like.
The goal of any software engineering project should be to design _one_ program that addresses the task in general, rather than just a subset of the task while leaving the rest to others... that leads to the mess we have today with GUI incompatibilities, etc.