How a court detects a derivative work

[chrisw]

Actually I have not criticised the work of ther reverse engineering artist specifically. Rather I pointed out that in the absence of the symbol table any attempt to recreate the original source is full of problems, that the work is art not science and the lables used in the recreated 'source' are entirely the creation of the artist.

for example to say

"int timer;" in one source is equivalent to "int timer;" in another recreated source is highly dubious, since the reverse engineer artist will have chosen the word "timer" himself in the second source. How do we know it isn't actually "int plydepth", for example?

Basically, any recreated source is going to be full of text put in by the artist. Why do we believe the text is as he says, when he has simply guessed at the names? This recreated source is made to look and appear more similar than it actually is.

In the quoted comparison:

45 infinite = false; infinite = 0;
46 ponder = false; ponder = 0;
47 movestogo = -1; movestogo = 25;
48 winc = -1.0; winc = 0;
49 wtime = -1.0; wtime = 0;
50 binc = -1.0; binc = 0;
51 btime = -1.0; btime = 0;
52 movetime = -1.0; movetime = 0;

well, apart from loading the alleged identical code (is it, you sure?) variables with *different* values (-1 not equal to 25 is it?) who says the second column listed variable names are as written? Or even do the same thing?

why is 2nd column binc actually binc? Because the artist wrote it so, that's why.

I suggest you're trying to influence non-programmers and lays with creative art masquerading as fact.

N'est ce pas?

In a post buried in the middle of the discussions about the possibility that Rybka 1.0 is a derivative work of Fruit 2.1, Chris Whittington has criticized the work done by the reverse-engineerer, claiming that he is just an "artist" inventing variable names and the like. I assume this was supposed to tear down any attempt to compare the source code of program A (say Fruit 2.1) with the disassembly of program B (say Rybka 1.0). The word "artist" is probably supposed to reduce the scientific credibility of the process.

Chris Whittington speaks with authority of what the courts would do, but unfortunately he has not done his homework. He does not know how the courts work through such cases.

The courts do not have to compare the source codes. Which means that a copyright or GPL infringement can be detected even if no source code, neither from program A or program B, is actually available. Only the object codes (the "executables") are really required.

The goal of the analysis conducted by the courts in order to determine if one program is a derivative work of the other is to find out if the ideas used by a program (which are not protectable) are expressed in the same way in both. What is protected, ultimately, is the "expression" of the ideas.

To achieve this, the courts compare the semantics of both programs in order to determine if the ideas and algorithms have been expressed in the same way. The data structures are also taken into account in the process.

The semantics of a program can be expressed in a number of ways. With logical graphs, in plain english or in pseudocode for example.

But in order to compare the semantics of two programs, an effective way can be... to disassemble one and reconstruct its source code with the goal of making it as similar as possible to the source code of the other program without touching the semantics.

There are a number of consequences of this process:
- variable and function names have absolutely no importance
- comments, blank lines, spaces... have no importance
- the order of the instructions can be changed as long as the program is semantically untouched
- even the programming language has no importance!

So the process of disassembling a program and reconstructing the source code so it is as close as possible to the source code of another program is a perfectly valid process and it is actually used by the legal system.

And something that has not really been discussed so far: the data structures used by a program are placed at the same level than the semantics. The similarity of data structures can contribute to evaluate the similarity of two programs.



// Christophe

While that is all well and good, the problem is you are saying that the basic "cheater" in programming assignments is perfectly safe. Because the first level of change a student will make is to change the variable names. Then the comments. And if they are still nervous, they change things syntactically, such as loop structures, altering the order of instructions when possible, etc.

As far as artist goes, this is not "art" which is creative by definition. This is no more art than the first attempt at deciphering writings in the great pyramids. It is just a lot of work. Variable names are meaningless and are not even a part of the executable, ditto for procedure names, structure names, etc.

Somehow you refuse to accept this plain fact... that if I have an assembly language program A, and I want to compare it to B, that I can do the following:

(1) verify that both function normally.

(2) change the veriable names in A so that they match B (presumably undoing what the original copier did.

(3) verify that the changed program still works identically to the way it did before the variable name substitutions were done. That is simple and absolute proof that changing the variable names changed nothing semantically, which then proves that this is not "creative" but rather "factual / scientific" in the way it was done. I don't see why you refuse to accept that this is not just possible, but is done every day somewhere. It is not misleading. It is not hyperbole. And something tells me that you actually know that...

Hehe!! The change subject obfuscation - very good

My concern expressed is the laying side by side of one source with another source derived from disassembly, and then claiming they correspond.

1. They correspond 28% only

2. The variable names correspond only because the reverse artist named them to correspond. Hence the correspondence is actually way less than 28%, because the apparent correspondence is creatively inspired.

My concern is that that published listing comparison which apparently forms a major part of your evidence looks more similar than it actually is, unless one has an understanding how it is produced. I seek to provide that understanding to lays and non-programmers.

All your above blah-blah is about something else and not relevent to the expressed concern. Why even append it to the post? Obfuscation?

Now, to go to your completely disconnected points ...

Even those make little sense. You claim rewriting the labels to some other form of words changes nothing. Absololutely. Programming 101. So what? Nor does it prove anything about any program, copying, similarity or anything else.

Your side has still not presented any identical program fragments, let along blocks of anything. What's been represented is different. Unless that is that 28% == 100% in C++ witchhunters variant language.

My response was made to show that your point 2 is absolutely irrelevant. The variable name issue is just absolute and utter nonsense. You know that. I know that. I know that you know that. You are just trying to argue points around the main issue in an attempt to divert attention from the simple fact that in 200 lines of code, finding 50 identical lines is absolutely unexpected, when the lines show major control decisions the odds go down even farther. You talk like 28% is tiny. When you know perfectly well that it is absolutely unexpected. As the "novel" discussion pointed out. Just copy 28% of a Clancy novel and see what happens. Just copy 10%. You might just as well argue "oh, you flipped a coin and got heads 1,000 times in a row? So what, statistics show that such a thing is bound to happen if you flip the coin enough times." But the probability of it happening on the _first_ 1000 flips is not so hot.

Blah-blah.

The function do similar things because the functions have to do similar things. They are the handlers of parameters (time etc) being passed to the UCI and then to the engine. Therefore there is functional similarity.

What 28% does is rule out cut 'n paste. It says this code was either independently written or rewritten. Either is quite legal. Period.

Next question?

[Albert Silver]

If Rybka 1.0 is found to be a derivative work of Fruit 2.1, then I guess Vas could simply rewrite the offending parts of the program and release it again, for example as "Rybka 1.0 GPL-free edition".

You are aware that Rybka 1.0 is no longer being distributed, right? It has been replaced by Rybka 2.2n as the free demo version of Rybka.

Albert

For one thing, everyone on earth has already obtained Rybka 1.0b, so it is irrelevant whether it is still distributed or not.

And you mean if you kill someone then save another soul (e.g. from drowning), you are clean, right?

I think you didn't understand anything at all.

The latest version of Tiger is Tiger 2007, right? Now let's suppose for argument's sake, someone finds a GPL infringement in Tiger 12, the oldest publicly available version of Tiger.

Do you think Theron would now be obligated to return to the code of Tiger 12, to rewrite it so he could release a GPL-free version of Tiger 12??? Are you kidding me?

Albert

[bob]

Actually I have not criticised the work of ther reverse engineering artist specifically. Rather I pointed out that in the absence of the symbol table any attempt to recreate the original source is full of problems, that the work is art not science and the lables used in the recreated 'source' are entirely the creation of the artist.

for example to say

"int timer;" in one source is equivalent to "int timer;" in another recreated source is highly dubious, since the reverse engineer artist will have chosen the word "timer" himself in the second source. How do we know it isn't actually "int plydepth", for example?

Basically, any recreated source is going to be full of text put in by the artist. Why do we believe the text is as he says, when he has simply guessed at the names? This recreated source is made to look and appear more similar than it actually is.

In the quoted comparison:

45 infinite = false; infinite = 0;
46 ponder = false; ponder = 0;
47 movestogo = -1; movestogo = 25;
48 winc = -1.0; winc = 0;
49 wtime = -1.0; wtime = 0;
50 binc = -1.0; binc = 0;
51 btime = -1.0; btime = 0;
52 movetime = -1.0; movetime = 0;

well, apart from loading the alleged identical code (is it, you sure?) variables with *different* values (-1 not equal to 25 is it?) who says the second column listed variable names are as written? Or even do the same thing?

why is 2nd column binc actually binc? Because the artist wrote it so, that's why.

I suggest you're trying to influence non-programmers and lays with creative art masquerading as fact.

N'est ce pas?

In a post buried in the middle of the discussions about the possibility that Rybka 1.0 is a derivative work of Fruit 2.1, Chris Whittington has criticized the work done by the reverse-engineerer, claiming that he is just an "artist" inventing variable names and the like. I assume this was supposed to tear down any attempt to compare the source code of program A (say Fruit 2.1) with the disassembly of program B (say Rybka 1.0). The word "artist" is probably supposed to reduce the scientific credibility of the process.

Chris Whittington speaks with authority of what the courts would do, but unfortunately he has not done his homework. He does not know how the courts work through such cases.

The courts do not have to compare the source codes. Which means that a copyright or GPL infringement can be detected even if no source code, neither from program A or program B, is actually available. Only the object codes (the "executables") are really required.

The goal of the analysis conducted by the courts in order to determine if one program is a derivative work of the other is to find out if the ideas used by a program (which are not protectable) are expressed in the same way in both. What is protected, ultimately, is the "expression" of the ideas.

To achieve this, the courts compare the semantics of both programs in order to determine if the ideas and algorithms have been expressed in the same way. The data structures are also taken into account in the process.

The semantics of a program can be expressed in a number of ways. With logical graphs, in plain english or in pseudocode for example.

But in order to compare the semantics of two programs, an effective way can be... to disassemble one and reconstruct its source code with the goal of making it as similar as possible to the source code of the other program without touching the semantics.

There are a number of consequences of this process:
- variable and function names have absolutely no importance
- comments, blank lines, spaces... have no importance
- the order of the instructions can be changed as long as the program is semantically untouched
- even the programming language has no importance!

So the process of disassembling a program and reconstructing the source code so it is as close as possible to the source code of another program is a perfectly valid process and it is actually used by the legal system.

And something that has not really been discussed so far: the data structures used by a program are placed at the same level than the semantics. The similarity of data structures can contribute to evaluate the similarity of two programs.



// Christophe

While that is all well and good, the problem is you are saying that the basic "cheater" in programming assignments is perfectly safe. Because the first level of change a student will make is to change the variable names. Then the comments. And if they are still nervous, they change things syntactically, such as loop structures, altering the order of instructions when possible, etc.

As far as artist goes, this is not "art" which is creative by definition. This is no more art than the first attempt at deciphering writings in the great pyramids. It is just a lot of work. Variable names are meaningless and are not even a part of the executable, ditto for procedure names, structure names, etc.

Somehow you refuse to accept this plain fact... that if I have an assembly language program A, and I want to compare it to B, that I can do the following:

(1) verify that both function normally.

(2) change the veriable names in A so that they match B (presumably undoing what the original copier did.

(3) verify that the changed program still works identically to the way it did before the variable name substitutions were done. That is simple and absolute proof that changing the variable names changed nothing semantically, which then proves that this is not "creative" but rather "factual / scientific" in the way it was done. I don't see why you refuse to accept that this is not just possible, but is done every day somewhere. It is not misleading. It is not hyperbole. And something tells me that you actually know that...

Hehe!! The change subject obfuscation - very good

My concern expressed is the laying side by side of one source with another source derived from disassembly, and then claiming they correspond.

1. They correspond 28% only

2. The variable names correspond only because the reverse artist named them to correspond. Hence the correspondence is actually way less than 28%, because the apparent correspondence is creatively inspired.

My concern is that that published listing comparison which apparently forms a major part of your evidence looks more similar than it actually is, unless one has an understanding how it is produced. I seek to provide that understanding to lays and non-programmers.

All your above blah-blah is about something else and not relevent to the expressed concern. Why even append it to the post? Obfuscation?

Now, to go to your completely disconnected points ...

Even those make little sense. You claim rewriting the labels to some other form of words changes nothing. Absololutely. Programming 101. So what? Nor does it prove anything about any program, copying, similarity or anything else.

Your side has still not presented any identical program fragments, let along blocks of anything. What's been represented is different. Unless that is that 28% == 100% in C++ witchhunters variant language.

My response was made to show that your point 2 is absolutely irrelevant. The variable name issue is just absolute and utter nonsense. You know that. I know that. I know that you know that. You are just trying to argue points around the main issue in an attempt to divert attention from the simple fact that in 200 lines of code, finding 50 identical lines is absolutely unexpected, when the lines show major control decisions the odds go down even farther. You talk like 28% is tiny. When you know perfectly well that it is absolutely unexpected. As the "novel" discussion pointed out. Just copy 28% of a Clancy novel and see what happens. Just copy 10%. You might just as well argue "oh, you flipped a coin and got heads 1,000 times in a row? So what, statistics show that such a thing is bound to happen if you flip the coin enough times." But the probability of it happening on the _first_ 1000 flips is not so hot.

Blah-blah.

The function do similar things because the functions have to do similar things. They are the handlers of parameters (time etc) being passed to the UCI and then to the engine. Therefore there is functional similarity.

What 28% does is rule out cut 'n paste. It says this code was either independently written or rewritten. Either is quite legal. Period.

Next question?

I have made the challenge previously. Take Crafty's source, and find 150 lines of code where 28% match. With any other source program you can find. And yes, you can change the variable and procedure names in any way you want to make the comparison.

That ought to be pretty easy according to your continual postings on the subject. So why don't you show us just how likely it is that two programs "do similar things because they have to do similar things." At a very high level of abstraction I would agree. But by the time the code hits the editor, that is nonsense.

Feel free to prove me wrong of course. There are plenty of bitboard programs around although since fruit is non-bitboard and rybka 1 is bitboard, I would suppose you need to compare crafty against non-bitboard programs only to make this apples-to-apples.

Go for it. No reverse-engineering or assembly-language programming skills required here. Offer evidence that your claim is true, since most of us are absolutely convinced it does not happen. You'd think I could find duplicates somewhere in 100+ different othello program sources. No such luck.

[bob]

If Rybka 1.0 is found to be a derivative work of Fruit 2.1, then I guess Vas could simply rewrite the offending parts of the program and release it again, for example as "Rybka 1.0 GPL-free edition".

You are aware that Rybka 1.0 is no longer being distributed, right? It has been replaced by Rybka 2.2n as the free demo version of Rybka.

Albert

For one thing, everyone on earth has already obtained Rybka 1.0b, so it is irrelevant whether it is still distributed or not.

And you mean if you kill someone then save another soul (e.g. from drowning), you are clean, right?

I think you didn't understand anything at all.

The latest version of Tiger is Tiger 2007, right? Now let's suppose for argument's sake, someone finds a GPL infringement in Tiger 12, the oldest publicly available version of Tiger.

Do you think Theron would now be obligated to return to the code of Tiger 12, to rewrite it so he could release a GPL-free version of Tiger 12??? Are you kidding me?

Albert

No but he would be absolutely obligated to (a) show the source for the current commercial version to the FSF, and (b) if there are any remnants of his old program in the current version, anything that was copied from a GPL program would have to be rewritten and then vetted by the FSF to satisfy them...

[Zach Wegner]

"int timer;" in one source is equivalent to "int timer;" in another recreated source is highly dubious, since the reverse engineer artist will have chosen the word "timer" himself in the second source. How do we know it isn't actually "int plydepth", for example?

Are you serious? You think that the reverse engineers simply reverse engineered one single block of code in isolation, and whenever they saw a variable declaration, or they saw a variable being modified, they just assumed it was the same variable that was in that place in Fruit?

When _I_ reverse engineer a block of code, it actually takes quite a long time. Most of that time is spent in places _other_ than the block of code in question. Every variable is checked to see its use. Based on this use, a variable name is chosen.

I'm sorry Chris, but this argument is nonsense. You aren't going to see a piece of code like this:

int plydepth = GetTickCount();

And if you read the code that was posted, you'd see that every one of the variables you listed are used _exactly_ as expected. E.g. "infinite" is set when it reads the string "infinite". "ponder" is set when it reads the string "ponder".

[chrisw]

"int timer;" in one source is equivalent to "int timer;" in another recreated source is highly dubious, since the reverse engineer artist will have chosen the word "timer" himself in the second source. How do we know it isn't actually "int plydepth", for example?

Are you serious? You think that the reverse engineers simply reverse engineered one single block of code in isolation, and whenever they saw a variable declaration, or they saw a variable being modified, they just assumed it was the same variable that was in that place in Fruit?

When _I_ reverse engineer a block of code, it actually takes quite a long time. Most of that time is spent in places _other_ than the block of code in question. Every variable is checked to see its use. Based on this use, a variable name is chosen.

I'm sorry Chris, but this argument is nonsense. You aren't going to see a piece of code like this:

int plydepth = GetTickCount();

And if you read the code that was posted, you'd see that every one of the variables you listed are used _exactly_ as expected. E.g. "infinite" is set when it reads the string "infinite". "ponder" is set when it reads the string "ponder".

What did the reverse artists do? Well, they have licence to call anything whatever they want. That is my point. Sometimes they get it right and sometimes not. Lays need to be aware it is art and not science.

As to

"infinite" is set when it reads the string "infinite". "ponder" is set when it reads the string "ponder".

well, I think everybody can see from this example how daft it was to post that example code side by side and expect it to prove anything.

The GUI passes the string "infinite", and "infinite" is set.
The GUI passes the string "ponder" and "ponder" is set.

Simple, basic, forced code. Here are the posted code correspondences:

Prog A
if (string_equal(ptr, "infinite"))
{
infinite = true;
}

Prog B
if (!strcmp(ptr, "infinite"))
{
infinite = 1;
}

I might have written Prog C
if (strcmp(ptr, "infinite") == FALSE)
{
infinite = true;
}

Did I cut 'n paste or copy? I just wrote utterly obvious code.

the examples for parameter handling are ridiculous as proof of anything. Too trivial. Too simple. Too forced. Waht do you expect a programmer to do to handle "infinite"? Give us your code for that example, probably very little difference.

[Zach Wegner]

OK, here's my code:

Code: Select all

void cmd_uci_go(void)
{
    int c;

    zct->zct_side = board.side_tm;
    set_time_control(0, 0, 0);
    for &#40;c = 1; c < cmd_input.arg_count; c++)
    &#123;
        /* "searchmoves" sets ZCT to only search certain root moves. */
        if (!strcmp&#40;cmd_input.arg&#91;c&#93;, "searchmoves"))
        &#123;
            /* Should this be implemented? */
        &#125;
        else if (!strcmp&#40;cmd_input.arg&#91;c&#93;, "wtime"))
        &#123;
            c++;
            if &#40;board.side_tm == WHITE&#41;
                set_zct_clock&#40;atoi&#40;cmd_input.arg&#91;c&#93;));
            else
                set_opponent_clock&#40;atoi&#40;cmd_input.arg&#91;c&#93;));
        &#125;
        else if (!strcmp&#40;cmd_input.arg&#91;c&#93;, "btime"))
        &#123;
            c++;
            if &#40;board.side_tm == BLACK&#41;
                set_zct_clock&#40;atoi&#40;cmd_input.arg&#91;c&#93;));
            else
                set_opponent_clock&#40;atoi&#40;cmd_input.arg&#91;c&#93;));
        &#125;
        else if (!strcmp&#40;cmd_input.arg&#91;c&#93;, "depth"))
        &#123;
            c++;
            zct->max_depth = atoi&#40;cmd_input.arg&#91;c&#93;);
        &#125;
        else if (!strcmp&#40;cmd_input.arg&#91;c&#93;, "nodes"))
        &#123;
            c++;
            zct->max_nodes = atoi&#40;cmd_input.arg&#91;c&#93;);
        &#125;
        else if (!strcmp&#40;cmd_input.arg&#91;c&#93;, "infinite"))
            zct->engine_state = INFINITE;
        else if (!strcmp&#40;cmd_input.arg&#91;c&#93;, "ponder"))
            zct->engine_state = INFINITE;
    &#125;
&#125;

As you can see, I have an incomplete UCI implementation.

And the code you posted doesn't even really touch on the important similarities. For one, there are _two_ variables, Infinite and SearchInput->infinite, in Fruit that are initialized as infinite || ponder; There is the exact same thing in Rybka.

Additionally, the time management code there is very similar.
Rybka:

Code: Select all

if ((Board->turn) == 0) { time = wtime; inc = winc; }
  else                    { time = btime; inc = binc; }

  // Rybka compares movetime with a double precision value: 0.0
  if (movetime >= 0.0) {
    time_limit_1 =    5 * movetime;
    time_limit_2 = 1000 * movetime;
  } else if (time > 0) {
    time_max = time - 5000;
    alloc = (time_max + inc * (movestogo - 1)) / movestogo;
    if (alloc >= time_max) alloc = time_max;
    time_limit_1 = alloc;
    alloc = (time_max + inc * (movestogo - 1)) / 2;
    if &#40;alloc < time_limit_1&#41; alloc = time_limit_1;
    if &#40;alloc > time_max&#41; alloc = time_max;
    time_limit_2 = alloc;
  &#125; 

Fruit:

Code: Select all

if (COLOUR_IS_WHITE(SearchInput->board->turn)) {
      time = wtime;
      inc = winc;
   } else {
      time = btime;
      inc = binc;
   }

   if &#40;movestogo <= 0 || movestogo > 30&#41; movestogo = 30; // HACK
   if &#40;inc < 0.0&#41; inc = 0.0;

   if &#40;movetime >= 0.0&#41; &#123;

      // fixed time

      SearchInput->time_is_limited = true;
      SearchInput->time_limit_1 = movetime * 5.0; // HACK to avoid early exit
      SearchInput->time_limit_2 = movetime;

   &#125; else if &#40;time >= 0.0&#41; &#123;

      // dynamic allocation

      time_max = time * 0.95 - 1.0;
      if &#40;time_max < 0.0&#41; time_max = 0.0;

      SearchInput->time_is_limited = true;

      alloc = &#40;time_max + inc * double&#40;movestogo-1&#41;) / double&#40;movestogo&#41;;
      alloc *= &#40;option_get_bool&#40;"Ponder") ? PonderRatio &#58; NormalRatio&#41;;
      if &#40;alloc > time_max&#41; alloc = time_max;
      SearchInput->time_limit_1 = alloc;

      alloc = &#40;time_max + inc * double&#40;movestogo-1&#41;) * 0.5;
      if &#40;alloc < SearchInput->time_limit_1&#41; alloc = SearchInput->time_limit_1;
      if &#40;alloc > time_max&#41; alloc = time_max;
      SearchInput->time_limit_2 = alloc;
   &#125;

Here are the differences:
--In Rybka the line equivalent to "if (movestogo <= 0 || movestogo > 30) movestogo = 30;" is moved to where movetime is read:
if (movestogo > 30) movestogo = 30;
if (movestogo < 1) movestogo = 1;
--For the line "SearchInput->time_limit_2 = movetime;", Rybka multiplies movetime by 1000. This is actually a BUG in Rybka: the UCI specs indicate that movetime means an _exact_ time. In Rybka, the nominal time is set to that time, but it uses more based on the search. If you type "go movetime 5000" into Fruit on the start position, it will search for exactly 5 seconds. Rybka searches for 14 seconds. I'd suspect that this could have crept in during a conversion from int to float, if that is what happened...
--Rybka doesn't have the line "if (inc < 0.0) inc = 0.0;", which is essentially useless
--"time_max = time * 0.95 - 1.0;" is converted to "time_max = time - 5000;" in Rybka
--"alloc *= (option_get_bool("Ponder") ? PonderRatio : NormalRatio);" is removed in Rybka, as it doesn't have that option (but NormalRatio = 1.0)
--"SearchInput->time_is_limited = true;" is removed from Rybka
--Here's the most important thing in this code, for me: as noted previously, Fruit uses float values for its time management. Rybka has ints. BUT, do you find it just a bit suspicious that Rybka compares movetime, an int value, with 0.0, a float value?

[bob]

Here are the differences:
--In Rybka the line equivalent to "if (movestogo <= 0 || movestogo > 30) movestogo = 30;" is moved to where movetime is read:
if (movestogo > 30) movestogo = 30;
if (movestogo < 1) movestogo = 1;
--For the line "SearchInput->time_limit_2 = movetime;", Rybka multiplies movetime by 1000. This is actually a BUG in Rybka: the UCI specs indicate that movetime means an _exact_ time. In Rybka, the nominal time is set to that time, but it uses more based on the search. If you type "go movetime 5000" into Fruit on the start position, it will search for exactly 5 seconds. Rybka searches for 14 seconds. I'd suspect that this could have crept in during a conversion from int to float, if that is what happened...
--Rybka doesn't have the line "if (inc < 0.0) inc = 0.0;", which is essentially useless
--"time_max = time * 0.95 - 1.0;" is converted to "time_max = time - 5000;" in Rybka
--"alloc *= (option_get_bool("Ponder") ? PonderRatio : NormalRatio);" is removed in Rybka, as it doesn't have that option (but NormalRatio = 1.0)
--"SearchInput->time_is_limited = true;" is removed from Rybka
--Here's the most important thing in this code, for me: as noted previously, Fruit uses float values for its time management. Rybka has ints. BUT, do you find it just a bit suspicious that Rybka compares movetime, an int value, with 0.0, a float value?

Of course it isn't suspicious. We all know that if you put enough monkeys in a room with enough computers, one of them would eventually write a comparison that violates good programming practice (nobody uses == in floating point comparison, I'll leave it as an exercise to the reader to find out why). So this proves nothing, as we now know.

[tiger]

In a post buried in the middle of the discussions about the possibility that Rybka 1.0 is a derivative work of Fruit 2.1, Chris Whittington has criticized the work done by the reverse-engineerer, claiming that he is just an "artist" inventing variable names and the like. I assume this was supposed to tear down any attempt to compare the source code of program A (say Fruit 2.1) with the disassembly of program B (say Rybka 1.0). The word "artist" is probably supposed to reduce the scientific credibility of the process.

Chris Whittington speaks with authority of what the courts would do, but unfortunately he has not done his homework. He does not know how the courts work through such cases.

The courts do not have to compare the source codes. Which means that a copyright or GPL infringement can be detected even if no source code, neither from program A or program B, is actually available. Only the object codes (the "executables") are really required.

The goal of the analysis conducted by the courts in order to determine if one program is a derivative work of the other is to find out if the ideas used by a program (which are not protectable) are expressed in the same way in both. What is protected, ultimately, is the "expression" of the ideas.

To achieve this, the courts compare the semantics of both programs in order to determine if the ideas and algorithms have been expressed in the same way. The data structures are also taken into account in the process.

The semantics of a program can be expressed in a number of ways. With logical graphs, in plain english or in pseudocode for example.

But in order to compare the semantics of two programs, an effective way can be... to disassemble one and reconstruct its source code with the goal of making it as similar as possible to the source code of the other program without touching the semantics.

There are a number of consequences of this process:
- variable and function names have absolutely no importance
- comments, blank lines, spaces... have no importance
- the order of the instructions can be changed as long as the program is semantically untouched
- even the programming language has no importance!

So the process of disassembling a program and reconstructing the source code so it is as close as possible to the source code of another program is a perfectly valid process and it is actually used by the legal system.

And something that has not really been discussed so far: the data structures used by a program are placed at the same level than the semantics. The similarity of data structures can contribute to evaluate the similarity of two programs.

// Christophe

then, is it necesary that program B (say Rybka 1.0)... give free code & GLP licence... ¿ and the next versions ( B3.0) don´t need that ?.... or YES..

the text blue is very importan...



The FSF, which now holds the copyright on Fruit 2.1 prefers to resolve GPL violations in a friendly way. They ask the author who has breached the GPL to either release the source code under GPL, or to simply remove all parts that constitute a derivative work from the infringing program.

-------------------------------------------------------------------------------------

((( Being new here, may i ask you a few questions?

1. Who is FSF?
2. Did the FSF say Vas breached the GPL or is it your assumption?
3. If FSF has facts that Vas breached the GPL, why is it taking so long to resolve this assumed infraction?
4. When will you and chris kiss and make up?

-------------------------------------------------------------------------------------
If Rybka 1.0 is found to be a derivative work of Fruit 2.1, then I guess Vas could simply rewrite the offending parts of the program and release it again, for example as "Rybka 1.0 GPL-free edition".

Remember: The discussion is only about Rybka 1.0. The FSF is not after the source code of infringing programs. They just want the GPL to be respected.

-------------------------------------------------------------------------------------

tiger wrote:
If Rybka 1.0 is found to be a derivative work of Fruit 2.1, then I guess Vas could simply rewrite the offending parts of the program and release it again, for example as "Rybka 1.0 GPL-free edition".


You are aware that Rybka 1.0 is no longer being distributed, right? It has been replaced by Rybka 2.2n as the free demo version of Rybka.

Albert
_________________
"Patience means restraining one's inclinations. There are seven emotions: joy, anger, anxiety, love, grief, fear, and hate, and if a man does not give way to these he can be called patient."

Tokugawa Ieyasu (1543-1616)

-------------------------------------------------------------------------------------
Now breathe.






// Christophe

The FSF is the Free Software Foundation, a nonprofit organization. Their goal is to defend the GPL. On their site they have a long list of GPL violations that they have resolved, many against big companies. Most of them have been resolved friendly. Some of them have been resolved thru court cases.

The FSF holds all copyrights on Fruit 2.1. At least that is what I know at this time. I have contacted Fruit's original author Fabien Letouzey for confirmation but he has not answered yet. The FSF knows Fruit 2.1 under the name "GnuChess 6.0".

The FSF has not been contacted yet. They have an email address where one can report violations. Then they can decide to start an action or not.



// Christophe

[Gerd Isenberg]

Of course it isn't suspicious. We all know that if you put enough monkeys in a room with enough computers, one of them would eventually write a comparison that violates good programming practice (nobody uses == in floating point comparison, I'll leave it as an exercise to the reader to find out why). So this proves nothing, as we now know.

To compare for equality (not the case here) with zero might be an exception, since binary representation of IEEE 754-1985 float and int is the same, also for IEEE 754-1985 double and long long. Some compiler may use the one or the other instruction set for comparison with zero. One may force it on source level with weird unions of int/float or u64/double.