Rybka 1.0 vs. Strelka

[kranium]

I think it would just be better to handle the case with the FSF and it can either be proven or it cant. A web site could just turn into a slander site seen as a way to drag someone down. Just my point of view, I am not taking sides on the issue.

agreed, my web site is probably far from ideal. i've contacted Zach that it's probably not a good idea...

[Dann Corbit]

According to the evidence provided, I see two possibilities.
1. The Rybka author took Fruit code and modified it.
2. The Ryka author studied Fruit code and took the ideas in it.

Item 1 is illegal and item 2 is legal. There is obviously no way to differentiate which one was done. I assume that there are no patents on any of Fruit's algorithms. If this is the case, then it is not wrong, immoral or unethical to read the code, study the code, improve the code, rewrite the code, alter the code, etc. and then write your own version.

The code is not identical. The similar parts that have been demonstrated are all trivial anyway.

If you read the thread that I just posted ("Questions for Vas") and still believe that, then I would have to seriously question your expertise on the matter. How many engines do you know that store both an upper and lower bound in the hash table? How many do you know that use setjmp to exit the search function? How many do you know that store only the hashkeys for game history?

I'm not saying that it's impossible for any other engine to have these same ideas in them. But there are very many low level similarities (in non trivial areas), and only to Fruit.

Using the same techniques is not illegal, immoral or otherwise bad in any way. To read and understand what Fruit is doing and then do the same thing yourself is not wrong, even if you do it the same way.

Everyone who wrote a chess program borrowed ideas from other people. People who claim otherwise are liars. Either that or they do not use alpha-beta, null move pruning, hash tables, etc.

I think that the mud slinging contest is a silly farce.
Slingers: "LOOK HE COPIED!"
Of course, we *all* did. Let's be honest. Everyone who failed to learn from Fruit's code is an idiot.

Personally, I learned nothing. I really don't like Fruit's code at all. Feel free to say whatever you want about me...

I think you are a smart person, but if you do not read and understand the ideas in Fruit your engine will never be as strong as Fruit.

I totally disagree. What did Fabien study before he wrote fruit?

I would guess that he studied all available chess programs, articles, books and papers. I would guess that he read chess programming boards and things of that nature.

It is not an accident that all successful chess programs use hash tables (and almost all use Zobrist hashing).
It is not an accident that all successful chess programs use some variant of either:
A. Alpha-beta
or:
B. MTD(f)
It is not an accident that all successful chess programs use move ordering.
The fundamental parts of most evaluations will also be very similar.
All chess programs will count the wood.
All successful chess programs will evaluate pawn structure.
Successful chess programs will have *most* features in common and many of them will be very similar to some other program or article (no doubt the program or article that they learned it from).

People who claim to have invented everything in their chess program are not thinking clearly. Of course with crafty (one of the oldest public source programs) most of it is probably your invention, but some significant fraction will also have been borrowed from other programs or articles.

[kranium]

The whole thing smells like a witch hunt to me, from people who are having a hard time competing with Rybka. For decades new ideas have propagated freely in chess programming. Now a new program comes out that easily trounces all others and other chess programmers want the author's head on a pole. It is crystal clear that he uses lots of Fruit ideas (and even freely admits to it in his very first beta notice). That is not an indication of wrongdoing to me.

I do not say that Vas is innocent or guilty. I honestly do not know. But I think the people who claim clairvoyance on this are letting their emotions flavor their arguments.

Dann, you post is well taken, but I do want to point out that he said "I took many things"...not "I took many ideas", like some people have reported.
it's not a big point, and i dont believe it proves anything, but i think what he said should reproduced with as much accuarcy as possible.

[Graham Banks]

The whole thing smells like a witch hunt to me, from people who are having a hard time competing with Rybka. For decades new ideas have propagated freely in chess programming. Now a new program comes out that easily trounces all others and other chess programmers want the author's head on a pole. It is crystal clear that he uses lots of Fruit ideas (and even freely admits to it in his very first beta notice). That is not an indication of wrongdoing to me.

I do not say that Vas is innocent or guilty. I honestly do not know. But I think the people who claim clairvoyance on this are letting their emotions flavor their arguments.

Dann, you post is well taken, but I do want to point out that he said "I took many things"...not "I took many ideas", like some people have reported.
it's not a big point, and i dont believe it proves anything, but i think what he said should reproduced with as much accuarcy as possible.

"I took many things" can be interpreted as "I took many ideas".
Depends how you wish to interpret it.

[Dann Corbit]

the generated code is exactly the same in both cases.

I'm no expert in disassembly, but it seems clear to me that for the above statement, ANY source producing identical code is identical for the purposes of comparing actual source with a disassembled binary. The variable names could be different, presumably.

I would be looking at implementation quirks such as comment 7:

Fruit

Code: Select all

static void parse_setoption( char string []) //1
{
const char *name; //2
char* value; //3

name = strstr(string, "name "); //4
value = strstr(string, "value "); //5
if (name == NULL || value == NULL || name >= value)return;//6
value[-1] = '\0'; //7
name += 5; //8
value += 6; //9  

Strelka

Code: Select all

void parse_setoption(char string[]) //1 without static
{
char *name, *value;//2,3 in one line
int size;

name = strstr(string,"name "); //4
value = strstr(string,"value "); //5
if (name == NULL || value == NULL || name >= value) return;//6
value[-1] = 0; //7
name += 5; //8
value += 6; //9

Comment 7's implementation detail is far from the obvious choice. It's certainly not a very good practice.

That is one of many tests... is the executable identical? But there are ways to prevent that from happening. For example, doing a sort a bit earlier in the code, rather than exactly where it is needed.

Other student tricks:

for (i=0; i<n; i++) {
...
}

vs

loop_index = 0;
while (loop_index < n) {
...
loop_index++;
}

Those are semantically identical. They are syntatically equivalent. Any decent programmer would pick up on that immediately. And comments don't count since they are not used by the compiler. They are actually the easiest thing to change to try to disguise plagiarism.

The code is equivalent but it does not prove plagiarism unless the task is complicated enough and many non trivial things are like that

If you ask 2 students to write a program that get a number p from the user and find if the number is prime then you can be sure that independent programmers may have the type of similiarity that you give in your example.

Uri

what I am talking about is two different programs. They are identical except every loop of type 1 above in program A has been replaced by a loop of type 2 in program B. Programs A and B are now no longer syntactically identical, but they are certainly semantically identical. That was my point. You are claiming they are different. _most_ of us would say they are identical. It is a judgement I have to deal with every semester.

If we were trying to prove plagiarism and Vas did not give credit to Fabian for Fruit's ideas then *clearly* Vas would be guilty. I do not think that there is any possible way to skirt that charge. However, credit for Fabian was given so the charge of Plagiarism does not apply.

The only issue to be decided (as I see it) is:
Did Vas read Fruit code and write his own version or did he copy the code and tweak it?

Now, Fruit (the public version) is not a bitboard program. So clearly the programs Fruit 2.1 and Rybka 1.0 are not the same. How did we get from point A to point B is the question and I think that only Vas can answer it.

Yes, some of the things in both programs are unusual. For example, in the UCI parser both programs call strtok() inline and other programs do not do that (they often call strtok() to create a token list first, and then pass the fully tokenized list to a processor). However, the UCI readers are not identical (e.g. Fabian handles errors inline and Rybka does not).

It appears to me that chess authors are looking for plagiarism evidence which is not what is needed in this case.

I want to make it clear that I do not know if Vas is guilty or innocent but I think that the evidence given so far does not answer the question. I must also admit that I have not gone over all of the evidence with a fine toothed comb, but the evidence that I have gone over (and my initial searches long ago) do not lead me to a clear conclusion of wrongdoing.

[Terry McCracken]

ok, no problem

it is important to make your case that everything is laid out in full detail

it's no good to post a Rybka disassembly and just state "Fruit is the same". People need to see the Fruit disassembly and then make their own judgement.

also, the other side need to see your full evidence in order to be able to make a refutation

Sorry to be so pedantic

That's fine. I haven't looked at the Fruit disassembly, only at the source. It might be worthwhile at some point to try to compile it with certain compilers and see if the instruction scheduling etc. match up with the binary, but I haven't done it yet.

I haven't posted all the evidence yet simply because the questions are mainly for Vas to refute. He's the one with the Rybka code, and everyone has access to the Fruit code. So he can basically answer "that's just a coincidence", "I was looking at Fruit when I wrote that", or "that's not true". For the last case I will post disassembly, otherwise I will wait to get it all organized into a webpage.

It's hard to show a comparison, because the huge block of assembly I posted are equivalent to about 20 lines of Fruit code. I will try to make a side-by-side with a line of Fruit next to 10 or so lines of assembly, but it might look crappy. Just warning you.

Whatever you do, it needs to be open to critical review. Forum is best place for that.

You saw what happened with your disassembly listing. Several who didn't understand it just accepted it as proof.

If you can get it past the forum, then it's good evidence. Your aim should be to silence forum criticism by the power of your argument and data.

Can you do that? We'll see ....

Pretty arrogant Chris....We will see.

[tiger]

If I understand this thread correctly, large part of Rybka 1 is based on the program Fruit 2.1, and make Rybka 1 fall under GPL lisence!?

Lets just for arguments sake say that it is true.
What does this implie?
That Vas has to publish the source code of R1?
Do it mean anything for later Rybkas?

Or is this simply a case of programmers envy? (He is so much better than us, lets get at him and make him reveal his secrets!)

It's all about fairness, fair game, fair play.

Fabien Letouzey has released Fruit 2.1 under the General Public Licence version 2 (GPLv2, lets call it "GPL" here). The choice of this licence is significant because it means that the will of the author is that his code can be re-used at the condition that any derived work is also published under the GPL, which means open source.

In other words, it's like Fabien saying "I give you this code as an act of generosity, I'm not asking money for it, I just ask that you pass this generosity to other if you change/improve this code".

The fact that Fruit 2.1 is GPL is not hidden. It's impossible for a programmer to ignore it. And Fruit being GPL means "if you are a programmer and want to create a closed source program, please do not copy a single line from Fruit".

If you do not respect the licence that comes with Fruit 2.1 and produce a closed source program derived from it, you are unfair in at least 2 ways:
1. you are unfair to Fabien
2. you are unfair to all the people who respect the will of Fabien

I think number 1 is obvious.

Number 2 is because this is a competitive field. Fruit 2.1 was extremely strong at the time it has been published. Many programmers could have used Fruit 2.1 to very quickly get an elo boost and reach the top level.

All of those who did not because they saw that it was forbidden can now see that it looks likely that at least one competitor has allowed himself to use this protected source code to get an advantage.

This is unfair. And either it is fixed in some way, or the field will degenerate into a no-rule area.

The motive is not to get someone's secrets. The source code of Rybka 1.0 has already been published under the name "Strelka 2.0" (actually a version very close to it). So if there is any secret in it, then it's already public.

All the published evidence is only about Rybka 1.0.

The motive is fairness.



// Christophe

But where is the evidence for code theft? I have tried to find anything resembling evidence in this tread, but can not find any! Maybee I have missed some posts, or? Anyway, in this thread http://www.talkchess.com/forum/viewtopi ... 83&t=23239 Chris W. asked a simple question about shoving some evidence. As far as I can see, nothing is comming forth!
Torstein

You asked if it was programmer envy, so I answered your question...

Some evidence has already been shown, more is to come.



// Christophe

[bob]

the generated code is exactly the same in both cases.

I'm no expert in disassembly, but it seems clear to me that for the above statement, ANY source producing identical code is identical for the purposes of comparing actual source with a disassembled binary. The variable names could be different, presumably.

I would be looking at implementation quirks such as comment 7:

Fruit

Code: Select all

static void parse_setoption( char string []) //1
{
const char *name; //2
char* value; //3

name = strstr(string, "name "); //4
value = strstr(string, "value "); //5
if (name == NULL || value == NULL || name >= value)return;//6
value[-1] = '\0'; //7
name += 5; //8
value += 6; //9  

Strelka

Code: Select all

void parse_setoption(char string[]) //1 without static
{
char *name, *value;//2,3 in one line
int size;

name = strstr(string,"name "); //4
value = strstr(string,"value "); //5
if (name == NULL || value == NULL || name >= value) return;//6
value[-1] = 0; //7
name += 5; //8
value += 6; //9

Comment 7's implementation detail is far from the obvious choice. It's certainly not a very good practice.

That is one of many tests... is the executable identical? But there are ways to prevent that from happening. For example, doing a sort a bit earlier in the code, rather than exactly where it is needed.

Other student tricks:

for (i=0; i<n; i++) {
...
}

vs

loop_index = 0;
while (loop_index < n) {
...
loop_index++;
}

Those are semantically identical. They are syntatically equivalent. Any decent programmer would pick up on that immediately. And comments don't count since they are not used by the compiler. They are actually the easiest thing to change to try to disguise plagiarism.

The code is equivalent but it does not prove plagiarism unless the task is complicated enough and many non trivial things are like that

If you ask 2 students to write a program that get a number p from the user and find if the number is prime then you can be sure that independent programmers may have the type of similiarity that you give in your example.

Uri

what I am talking about is two different programs. They are identical except every loop of type 1 above in program A has been replaced by a loop of type 2 in program B. Programs A and B are now no longer syntactically identical, but they are certainly semantically identical. That was my point. You are claiming they are different. _most_ of us would say they are identical. It is a judgement I have to deal with every semester.

If we were trying to prove plagiarism and Vas did not give credit to Fabian for Fruit's ideas then *clearly* Vas would be guilty. I do not think that there is any possible way to skirt that charge. However, credit for Fabian was given so the charge of Plagiarism does not apply.

I do not follow that. Plagiarism is not about copying ideas. It is about copying text (or in this case programming statements)...

The only issue to be decided (as I see it) is:
Did Vas read Fruit code and write his own version or did he copy the code and tweak it?

Now, Fruit (the public version) is not a bitboard program. So clearly the programs Fruit 2.1 and Rybka 1.0 are not the same. How did we get from point A to point B is the question and I think that only Vas can answer it.

Yes, some of the things in both programs are unusual. For example, in the UCI parser both programs call strtok() inline and other programs do not do that (they often call strtok() to create a token list first, and then pass the fully tokenized list to a processor). However, the UCI readers are not identical (e.g. Fabian handles errors inline and Rybka does not).

It appears to me that chess authors are looking for plagiarism evidence which is not what is needed in this case.

I want to make it clear that I do not know if Vas is guilty or innocent but I think that the evidence given so far does not answer the question. I must also admit that I have not gone over all of the evidence with a fine toothed comb, but the evidence that I have gone over (and my initial searches long ago) do not lead me to a clear conclusion of wrongdoing.

And I agree. but as I said, the evidence continues to pile up. Now we have disassembled output from both Rybka, and Strelka and Fruit.

[bob]

According to the evidence provided, I see two possibilities.
1. The Rybka author took Fruit code and modified it.
2. The Ryka author studied Fruit code and took the ideas in it.

Item 1 is illegal and item 2 is legal. There is obviously no way to differentiate which one was done. I assume that there are no patents on any of Fruit's algorithms. If this is the case, then it is not wrong, immoral or unethical to read the code, study the code, improve the code, rewrite the code, alter the code, etc. and then write your own version.

The code is not identical. The similar parts that have been demonstrated are all trivial anyway.

If you read the thread that I just posted ("Questions for Vas") and still believe that, then I would have to seriously question your expertise on the matter. How many engines do you know that store both an upper and lower bound in the hash table? How many do you know that use setjmp to exit the search function? How many do you know that store only the hashkeys for game history?

I'm not saying that it's impossible for any other engine to have these same ideas in them. But there are very many low level similarities (in non trivial areas), and only to Fruit.

Using the same techniques is not illegal, immoral or otherwise bad in any way. To read and understand what Fruit is doing and then do the same thing yourself is not wrong, even if you do it the same way.

Everyone who wrote a chess program borrowed ideas from other people. People who claim otherwise are liars. Either that or they do not use alpha-beta, null move pruning, hash tables, etc.

I think that the mud slinging contest is a silly farce.
Slingers: "LOOK HE COPIED!"
Of course, we *all* did. Let's be honest. Everyone who failed to learn from Fruit's code is an idiot.

Personally, I learned nothing. I really don't like Fruit's code at all. Feel free to say whatever you want about me...

I think you are a smart person, but if you do not read and understand the ideas in Fruit your engine will never be as strong as Fruit.

I totally disagree. What did Fabien study before he wrote fruit?

I would guess that he studied all available chess programs, articles, books and papers. I would guess that he read chess programming boards and things of that nature.

It is not an accident that all successful chess programs use hash tables (and almost all use Zobrist hashing).
It is not an accident that all successful chess programs use some variant of either:
A. Alpha-beta
or:
B. MTD(f)
It is not an accident that all successful chess programs use move ordering.
The fundamental parts of most evaluations will also be very similar.
All chess programs will count the wood.
All successful chess programs will evaluate pawn structure.
Successful chess programs will have *most* features in common and many of them will be very similar to some other program or article (no doubt the program or article that they learned it from).

People who claim to have invented everything in their chess program are not thinking clearly. Of course with crafty (one of the oldest public source programs) most of it is probably your invention, but some significant fraction will also have been borrowed from other programs or articles.

My point was that nobody has to read _fruit_ to write a program that is strong. In fact, fruit is "old news" and there are stronger freeware programs around.

Many of us developed hashing independently. If you find the original paper on Greenblatt's chess program he also had a transposition table, although he did not us hashing, he actually encoded the entire position exactly so there would be no errors. Other programs of the early 70's did this (including chess 4.x by the way) but it was not an efficient way to do things obviously. I added hashing to my program around 1976 or so after re-reading the greenblatt article that was published in the DEC journal. The idea of SEE came from the original paper on COKO published in the CACM journal.

Looking at other programs can certainly help, because it shows real implementations rather than abstract descriptions/algorithms.

[Uri Blass]

According to the evidence provided, I see two possibilities.
1. The Rybka author took Fruit code and modified it.
2. The Ryka author studied Fruit code and took the ideas in it.

Item 1 is illegal and item 2 is legal. There is obviously no way to differentiate which one was done. I assume that there are no patents on any of Fruit's algorithms. If this is the case, then it is not wrong, immoral or unethical to read the code, study the code, improve the code, rewrite the code, alter the code, etc. and then write your own version.

The code is not identical. The similar parts that have been demonstrated are all trivial anyway.

If you read the thread that I just posted ("Questions for Vas") and still believe that, then I would have to seriously question your expertise on the matter. How many engines do you know that store both an upper and lower bound in the hash table? How many do you know that use setjmp to exit the search function? How many do you know that store only the hashkeys for game history?

I'm not saying that it's impossible for any other engine to have these same ideas in them. But there are very many low level similarities (in non trivial areas), and only to Fruit.

Using the same techniques is not illegal, immoral or otherwise bad in any way. To read and understand what Fruit is doing and then do the same thing yourself is not wrong, even if you do it the same way.

Everyone who wrote a chess program borrowed ideas from other people. People who claim otherwise are liars. Either that or they do not use alpha-beta, null move pruning, hash tables, etc.

I think that the mud slinging contest is a silly farce.
Slingers: "LOOK HE COPIED!"
Of course, we *all* did. Let's be honest. Everyone who failed to learn from Fruit's code is an idiot.

Personally, I learned nothing. I really don't like Fruit's code at all. Feel free to say whatever you want about me...

I think you are a smart person, but if you do not read and understand the ideas in Fruit your engine will never be as strong as Fruit.

I totally disagree. What did Fabien study before he wrote fruit?

I would guess that he studied all available chess programs, articles, books and papers. I would guess that he read chess programming boards and things of that nature.

It is not an accident that all successful chess programs use hash tables (and almost all use Zobrist hashing).
It is not an accident that all successful chess programs use some variant of either:
A. Alpha-beta
or:
B. MTD(f)
It is not an accident that all successful chess programs use move ordering.
The fundamental parts of most evaluations will also be very similar.
All chess programs will count the wood.
All successful chess programs will evaluate pawn structure.
Successful chess programs will have *most* features in common and many of them will be very similar to some other program or article (no doubt the program or article that they learned it from).

People who claim to have invented everything in their chess program are not thinking clearly. Of course with crafty (one of the oldest public source programs) most of it is probably your invention, but some significant fraction will also have been borrowed from other programs or articles.

My point was that nobody has to read _fruit_ to write a program that is strong. In fact, fruit is "old news" and there are stronger freeware programs around.

Many of us developed hashing independently. If you find the original paper on Greenblatt's chess program he also had a transposition table, although he did not us hashing, he actually encoded the entire position exactly so there would be no errors. Other programs of the early 70's did this (including chess 4.x by the way) but it was not an efficient way to do things obviously. I added hashing to my program around 1976 or so after re-reading the greenblatt article that was published in the DEC journal. The idea of SEE came from the original paper on COKO published in the CACM journal.

Looking at other programs can certainly help, because it shows real implementations rather than abstract descriptions/algorithms.

Toga based on fruit is still the strongest free source code so saying that fruit is old news is not correct.

Fruit derivative free source is still the strongest.

Uri