Koivisto 5.0

[Madeleine Birchfield]

You should say the same about Lelenstein Alliestein, Scorpio, Stoofvlees as well than, since they copy things from Lc0 too...

I don't think you know if Stoofvlees has copied anything or to what extent. Besides that, note that the author of Stoofvlees is also the author of Leela Zero - from which Leela Chess Zero was initially forked.

Stoofvlees author also was the principal developer involved in the rewrite of lczero in the middle of 2018.

[connor_mcmonigle]

1) same logic and even same formula for LMR initialization

Code: Select all

    for (d = 0; d < 256; d++)
        for (m = 0; m < 256; m++)
            lmrReductions[d][m] = 1.25 + log(d) * log(m) * 100 / LMR_DIV;

anyone interested can read more about this formula copied by everyone in the thread "A question about code similarities" opened by Oliver Brausch in the engine origins forum

This isn't exactly the same formula from Stockfish. None of the coefficients are copied, nevermind the fact that Stockfish does LMR quite unusually (see here: https://github.com/official-stockfish/S ... ch.cpp#L75). The log based formulas have proven the best simple way to compute a base reduction time and time again. 90%+ of the top 50 engines do this.

(0/1)

2) same "improving" variable to check if the evaluation is improving to do less pruning/reductions

Code: Select all

bool  isImproving = inCheck ? false : sd->isImproving(staticEval, b->getActivePlayer(), ply);

This is a well known trick that originated from Stockfish. They also don't use "improving" the same way Stockfish does in their search. This trick is ubiquitous in modern engines as it simply gains elo to tweak your margins based on improving.
(0.5/2)

3) same adjusting of the static eval based on tt bounds and score

The fact that you think Stockfish is somehow responsible for this is comical. It would be stupid not to do this.

(0.5/3)

4) basically the same razoring, static null move pruning, null move pruning and probcut

Koivisto's probcut implementation is pretty Stockfish specific, I'd agree. So far you're at 1.5/4.

(1.5/4)

5) the reduction proposed by Ed Schröder to replace IID but you get a pass on that as Stockfish took it from Schröder but you still call it "Internal Iterative Deepening" which is not anymore. Internal Iterative Reduction as suggested by Ed himself would probably be more accurate

They have it incorrectly named in their search, sure, but it's definitely not copied from Stockfish.

(1.5/5)

6) basically the same late move pruning, history pruning, see pruning

All of their implementations differ a fair bit. Stockfish is not the progenitor of any of these heuristics.

(1.5/6)

7) basically the same singular extension

The singular extension logic found in Stockfish and many other top engines was first implemented in Rybka iirc. It's also not a Stockfish invention or at all specific to Stockfish. You can find basically the same implementation on CPW.

(1.5/7)

8) basically the same lmr adjustments using history scores

The adjustments differ pretty significantly. Nearly everyone adjusts reductions based on history scores as it's a pretty obvious thing to do.

(1.5/8)

9) same counter move history

They use a slightly different formula to adjust their history values and counter move history is pretty ubiquitous nowadays. I'll be generous and give you another half point here.

(2/9)

10) you have also copied the capture history

Their implementation pretty clearly differs. It's also a pretty obvious thing to try some variant of after observing the history heuristic works so well for quiet moves.

(2/10)

As original ideas I see (but I haven't checked Stockfish in a while ):

1) threat pruning
2) kk reductions (which, as you write in the comments, is similar to Stockfish cutnode reduction)

did I miss anything?

care to share how much ELO points are these original ideas worth? and how much the stuff taken from Stockfish?

I honestly cannot bear all these so called chess programmers that come here to lecture the others about what real men should do and they are the first to plunder the hell out of Stockfish, always very careful not to copy same implementation details, to gain places on rating lists they despise so much.

there are no new algorithms in all these engines and since they cannot copy line by line their master, we simply get worse Stockfishes with subpar implementations.

and I really don't understand people like Albert and Norman: writing a weak engine from scratch is really simple. Then you simply copy all the stuff from Stockfish and then you release it under GPL license. As Andrew taught us thanking Stockfish in your sources/home page is not mandatory, commits are enough. Nobody could accuse you of anything

You've missed a number of other innovations, yes (see Koivisto's behindNMP concept for starters). You seem to have a poor understanding of where the search heuristics found in modern chess engines originate from, attributing everything to Stockfish. Furthermore, you seem unable to identify any nuance in these aforementioned search heuristics' implementations.

[aryan1508]

Our search has also made a lot of progress. Adding further unique ideas not found in any other engine so far, we gained a large amount of elo inside our search since then.

could you please point me to these "unique ideas not found in any other engine so far" ?

I've taken a look at your search and all I see is stuff copied from Stockfish with some minor modifications so that one can't really say "100%" copied (just like in Ethereal, Booot):

1) same logic and even same formula for LMR initialization

Code: Select all

    for (d = 0; d < 256; d++)
        for (m = 0; m < 256; m++)
            lmrReductions[d][m] = 1.25 + log(d) * log(m) * 100 / LMR_DIV;

anyone interested can read more about this formula copied by everyone in the thread "A question about code similarities" opened by Oliver Brausch in the engine origins forum

2) same "improving" variable to check if the evaluation is improving to do less pruning/reductions

Code: Select all

bool  isImproving = inCheck ? false : sd->isImproving(staticEval, b->getActivePlayer(), ply);

3) same adjusting of the static eval based on tt bounds and score

4) basically the same razoring, static null move pruning, null move pruning and probcut

5) the reduction proposed by Ed Schröder to replace IID but you get a pass on that as Stockfish took it from Schröder but you still call it "Internal Iterative Deepening" which is not anymore. Internal Iterative Reduction as suggested by Ed himself would probably be more accurate

6) basically the same late move pruning, history pruning, see pruning

7) basically the same singular extension

8) basically the same lmr adjustments using history scores

9) same counter move history

10) you have also copied the capture history

As original ideas I see (but I haven't checked Stockfish in a while ):

1) threat pruning
2) kk reductions (which, as you write in the comments, is similar to Stockfish cutnode reduction)

did I miss anything?

care to share how much ELO points are these original ideas worth? and how much the stuff taken from Stockfish?

I honestly cannot bear all these so called chess programmers that come here to lecture the others about what real men should do and they are the first to plunder the hell out of Stockfish, always very careful not to copy same implementation details, to gain places on rating lists they despise so much.

there are no new algorithms in all these engines and since they cannot copy line by line their master, we simply get worse Stockfishes with subpar implementations.

and I really don't understand people like Albert and Norman: writing a weak engine from scratch is really simple. Then you simply copy all the stuff from Stockfish and then you release it under GPL license. As Andrew taught us thanking Stockfish in your sources/home page is not mandatory, commits are enough. Nobody could accuse you of anything

This post is just absurd. It seems to me that you are clueless about where these techniques originate from and are assuming that Stockfish owns all of them.

[Madeleine Birchfield]

This post is just absurd. It seems to me that you are clueless about where these techniques originate from and are assuming that Stockfish owns all of them.

Wilson has been accusing many different engines for years of taking stuff from Stockfish, and most of the time he is wrong.

[Wilson]

1) same logic and even same formula for LMR initialization

Code: Select all

    for (d = 0; d < 256; d++)
        for (m = 0; m < 256; m++)
            lmrReductions[d][m] = 1.25 + log(d) * log(m) * 100 / LMR_DIV;

anyone interested can read more about this formula copied by everyone in the thread "A question about code similarities" opened by Oliver Brausch in the engine origins forum

This isn't exactly the same formula from Stockfish. None of the coefficients are copied, nevermind the fact that Stockfish does LMR quite unusually (see here: https://github.com/official-stockfish/S ... ch.cpp#L75). The log based formulas have proven the best simple way to compute a base reduction time and time again. 90%+ of the top 50 engines do this.

(0/1)

Stockfish 5 and other versions were the first to use the formula lmr[d][m] = A + log(d) * log(m) + B just like the one used by Koivisto and many others as noticed by Oliver Brausch. Even Crafty copied it.

given your poor reply to my first point I'm not interested in reading further and I suggest to do your homework before replying and assigning points to others.

I'm more interested in a reply by the Koivisto team who was so quick to enquire about that new engine Revenge and probably missed my post here.

[connor_mcmonigle]

1) same logic and even same formula for LMR initialization

Code: Select all

    for (d = 0; d < 256; d++)
        for (m = 0; m < 256; m++)
            lmrReductions[d][m] = 1.25 + log(d) * log(m) * 100 / LMR_DIV;

anyone interested can read more about this formula copied by everyone in the thread "A question about code similarities" opened by Oliver Brausch in the engine origins forum

This isn't exactly the same formula from Stockfish. None of the coefficients are copied, nevermind the fact that Stockfish does LMR quite unusually (see here: https://github.com/official-stockfish/S ... ch.cpp#L75). The log based formulas have proven the best simple way to compute a base reduction time and time again. 90%+ of the top 50 engines do this.

(0/1)

Stockfish 5 and other versions were the first to use the formula lmr[d][m] = A + log(d) * log(m) + B just like the one used by Koivisto and many others as noticed by Oliver Brausch. Even Crafty copied it.

given your poor reply to my first point I'm not interested in reading further and I suggest to do your homework before replying and assigning points to others.

I'm more interested in a reply by the Koivisto team who was so quick to enquire about that new engine Revenge and probably missed my post here.

Meh. Strawman.

What's your point exactly? I never stated that Stockfish never used a similar formula. My claim was that Stockfish never used those exact coefficients, currently uses a somewhat unusual variant for LMR and, furthermore, log formulas are basically ubiquitous at this point for calculating a base reduction.
If you actually read through Koivisto's LMR code, you'd see the base reduction values are adjusted very differently as compared to Stockfish.

I think you must be trolling as no possible formula would satisfy you. Dividing the remaining depth by some N? That won't work as Senpai did something similar first (and probably many others) -> you can't just divide remaining depth. Some type of exponential decay formula? That's already been tried by many historical engines. Some type of sqrt formula? Nope, can't use that either. Would a hardcoded table of values work? No as other engines have already used tables of values for computing a base reduction before (also you'd probably argue that you could fit one of the aforementioned formulas to the values in the table anyways).

Do you see how stupid this is?

[smatovic]

Meh. Strawman.

What's your point exactly?
....

Hmm, not sure, but I guess Wilson tries to point out that most of the top engines rely on each other, Stockfish is some kind of blackhole, sucking in all the ideas out there, implementing them, varifiying them with their framework, then others jump on the waggon, taking from the blackhole, implementing ideas, improving them, giving back to Stockfish, something like this. Where did the real innovation the last years come from? SF? It was said they improve their engine with ~50 Elo per year - incremental process. Giraffe showed the path back then in 2015, neural networks on CPU with AB. First AlphaGo then A0 for chess, MCTS-PUCT with CNN and Reinforcement Learning, then the Shogi guys with NNUE. We all rely on each other. The Giraffe author Matthew Lai implemented all his Giraffe stuff on his own, original work, research, ~4 month of work, ~2400 CCRL Elo. Now, what could have happened if he simply forked the Stockfish engine and implemented all his ideas into this, yes - derivative work, but an possible Elo-killer? Just some thoughts....

--
Srdja

[smatovic]

...
The Giraffe author Matthew Lai implemented all his Giraffe stuff on his own, original work, research, ~4 month of work, ~2400 CCRL Elo.
..

For the nitpickers...

- Giraffe used the Eigen linear algebra library
- Giraffe used Pradyumna Kannan's magic move generator
- the feature set structure was already proposed by others

https://www.chessprogramming.org/Giraffe

...but then you really miss my point.

--
Srdja

[Wilson]

I think you must be trolling as no possible formula would satisfy you. Dividing the remaining depth by some N? That won't work as Senpai did something similar first (and probably many others) -> you can't just divide remaining depth. Some type of exponential decay formula? That's already been tried by many historical engines. Some type of sqrt formula? Nope, can't use that either. Would a hardcoded table of values work? No as other engines have already used tables of values for computing a base reduction before (also you'd probably argue that you could fit one of the aforementioned formulas to the values in the table anyways).

and did they test all these other formulas? or they immediately took the easier path copying Stockfish formula changing just a bit the coefficients? you are proving exactly my point.

I don't care where Stockfish devs took and put together ideas through the years, if now you are taking Stockfish search as a whole you are copying it from Stockfish.

how come the Koivisto author asked Revenge author how his net was trained and didn't ask instead "where your search comes from?". The answer is easy: because nowadays it's taken for granted one can copy Stockfish search. That's what all these GPL authors do and most likely also closed source authors though I can't prove it. The first 3000-3200 are for free and then they come here blabbing about what real men do

for these people all computer chess is now about is writing your own tuner

and I bet the next step will be to use Stockfish and Leela data to train their nets because Stockfish did it.
Mark my words: it's not a matter of if but when
Just wait for someone to get fed up of getting demoted in TCEC and then the other copycat kids will follow

[AndrewGrant]

I think you must be trolling as no possible formula would satisfy you. Dividing the remaining depth by some N? That won't work as Senpai did something similar first (and probably many others) -> you can't just divide remaining depth. Some type of exponential decay formula? That's already been tried by many historical engines. Some type of sqrt formula? Nope, can't use that either. Would a hardcoded table of values work? No as other engines have already used tables of values for computing a base reduction before (also you'd probably argue that you could fit one of the aforementioned formulas to the values in the table anyways).

and did they test all these other formulas? or they immediately took the easier path copying Stockfish formula changing just a bit the coefficients? you are proving exactly my point.

You are such a misdirected [Moderation] unfriendly form of addressing deleted.