Chan Rasjid wrote:[...]
I have written a fully working program with hashing, rather complicated, and can easily add nullmove, etc...but I don't have a clue what Thomas Mayer's main post meant.
well, I would like it more when you leave me out of discussion, a) my posting was written before Bryan & Dann posted their conclusion and b) I wrote it now several times that for me the vote by Bryan & Dann is final.
The only way how Strelka could be a clone of Rybka is by thinking the unthinkable: either he had fully decompiled and understood Rybka or he got the source code of Rybka in hands.
Anyway, some words about my post: Fernando had written that nobody should say anything about Strelka being derived from something as long he hasn't any proofs... I don't know why he has written that, it seems to me that he didn't read what was written about Strelka in all the forums (And then you should read the germans & russian forums as well) and therefor wasn't informed. Also he doesn't understand that a lot positions discover similar (or mimicri of similar) programming technics. Therefor I thought I should give him some positions.
How did I get the positions ? Well, that's the interesting thing: I went to the old CCC archives and started with the first positions that showed anomalies of Rybka 1.0 beta directly AFTER it's release. You can go yourself to the archives and will see that I didn't jump over some anomalies just to hide differences -> I just took position by position as long they showed programming technics and have a different theme. (So not two Zugzwang problems, two underpromotion problems etc. - one exception because both don't solve one zugzwang problem but another one which is for me really interesting but as somebody already pointed out Fritz 8 has the same behaviour (but not Fritz 9, Fritz 1-7 nor any other engine I know of))
The outcome of that was at the start pretty unclear for me but finally the behaviour and also the moves were so much equal that I myself was pretty sure that this can't be random. Of course Fernando pointed out that after all we know right now it wasn't enough to make a conclusion because it leds to the wrong conclusion. The interesting thing is that in the past based on less indications engines were and still are treated as clones. So when our clone detection system doesn't work for Strelka it isn't unlikey that it didn't work in the past as well and we have engines on some well known clone lists which are there for wrong reasons.
Some words on known clones:
a) we have the most stupid ones which just rename the executeable, patch the name in the executeable to something different. Those are easy to discover, you must just find the base version and then they should be compareable node by node.
b) next thing are the clones based on open source. Well, it depends on the knowledge of the cloner, the more they change the more difficult it gets to uncover them. E.g. when you change a lot of evaluation values and maybe some stuff in the move ordering and of course all texts, number of shown nodes per second (just multiply or devide them), how depth is shown (add, subtract something, count totally different, whatever) then it is hard to discover them, most usual chess positions wont work. Therefor you take positions that discover programming techniques, e.g. how and when it detects zugzwang, how the nullmove works, has it special mate detection system, special move ordering, does it crash in some situations, does it show special behaviour in illegal positions, underpromotion stuff, how it presents mates (matescore), how is his hash working (fine 70 for example)... etc. etc.
Of course you will find similarities among ALL programs even when they are totally different. Fernando pointed that out: they play chess and are good in that, so it's likely that they play similar moves in a lot positions. The best things in fact are bugs or situations where they crash: same bugs are a good indication. Anyway, this ALL isn't a real proof, because you can't compare the sources - the only way to be sure finally, but when you found an exceptional number of same techniques, bugs, behaviour, whatever it is clear that it gets more likely that something isn't so independant then the author wants to have it. BUT you can be wrong in that - as we were with Strelka. And believe me, after randomly taking positions out of the archive I was VERY sure that something is fishy, in fact I have never seen something similar and I compare programs since VERY long now.
c) a c-type clone would be a clone of a private not open source that doesn't belong to a-type. Thinkable is that it either was created by disassembling or decompiling or that it was created with the original source. So far I have only one c-type clone in mind, Greif. I don't know whether it really was proven by comparing source or whether they only had indications like described in b) -> Such a clone could be even created by the author of the original engine and to discover this you definitely have to have BOTH sources. Of course it's unclear why an author should do that, but well, this is just about what type of clones COULD exist. So I believe the last one can not be discovered at all, because the author would never allow a comparisson of the code and himself - when asked - might answer that they are independant.