Lazy eval

[wgarvin]

150 is certainly not an 'original' or 'brilliant' idea,
Ippolit, Robbolito, Igorrit, and IvanHoe all use 150, exactly in the manner Richard described above for Critter...

from common.c:
#define LazyValue 150
#define LazyValue2 300

Houdart did claim earlier in the thread that Robbolito doesn't do what Houdini does.

I honestly did not care enough to check.

[Houdini]

150 is certainly not an 'original' or 'brilliant' idea,
Ippolit, Robbolito, Igorrit, and IvanHoe all use 150, exactly in the manner Richard described above for Critter...

from common.c:
#define LazyValue 150
#define LazyValue2 300

Houdart did claim earlier in the thread that Robbolito doesn't do what Houdini does.

I honestly did not care enough to check.

We were discussing the following text from Richard: "Also, when the absolute value of positional component from ply-1 eval is greater than 150 cp, lazy eval is not used."
Ippolit doesn't do this - Norman's post incorrectly combines quotes that actually talk about different things.

Robert

[kranium]

150 is certainly not an 'original' or 'brilliant' idea,
Ippolit, Robbolito, Igorrit, and IvanHoe all use 150, exactly in the manner Richard described above for Critter...

from common.c:
#define LazyValue 150
#define LazyValue2 300

Houdart did claim earlier in the thread that Robbolito doesn't do what Houdini does.

I honestly did not care enough to check.

We were discussing the following text from Richard: "Also, when the absolute value of positional component from ply-1 eval is greater than 150 cp, lazy eval is not used."
Ippolit doesn't do this - Norman's post incorrectly combines quotes that actually talk about different things.

Robert

my post is quite clear...
using lazyeval margin of 150 is not original or brilliant...regardless of you claims

i realize you'd like to world to think Houdini is utterly original and brilliant...but it's completely not.


quite pathetic to see you spamming forums with so-much pro-Houdini 'originality propaganda'
(sorry, i mean 'nonsense'...shit! it's even starting to fool me!)

[kranium]

One more thing-

You seem keen to discuss technical details here in the 'programming' forum...
with the likes of Bob, Don, Mark, and Richard etc.

I believe they are all completely aware of the origins of Houdini, how it came about, and your continuous, ridiculous, and shameful denials, lies, and fancy word-dancing...

Do you honestly think anyone actually attaches any tiny significance of truth to anything you post?

If so, it just illustrates the sheer overwhelming magnitude of the egotistical 'fantasy' you are attempting to perpetrate...
i.e. apparently you are completely lost in it yourself!?

[Houdini]

my post is quite clear...
using lazyeval margin of 150 is not original or brilliant...regardless of you claims

Your post is clear but incorrect.
I made a claim about the special criterion for not using lazy eval. I quoted and replied to the following: "Also, when the absolute value of positional component from ply-1 eval is greater than 150 cp, lazy eval is not used.". Please reread the post http://www.talkchess.com/forum/viewtopic.php?p=435709 .
You are probably aware that this idea is not used in Ippolit nor Robbolito.

You incorrectly attached my reply to another statement made by Richard: "Critter uses 150 cp lazy margin in qsearch and 300 cp margin at interior nodes.", which I didn't quote and didn't reply to.

Robert

[kranium]

my post is quite clear...
using lazyeval margin of 150 is not original or brilliant...regardless of you claims

Your post is clear but incorrect.
I made a claim about the special criterion for not using lazy eval. I quoted and replied to the following: "Also, when the absolute value of positional component from ply-1 eval is greater than 150 cp, lazy eval is not used.". Please reread the post http://www.talkchess.com/forum/viewtopic.php?p=435709 .
You are probably aware that this idea is not used in Ippolit nor Robbolito.

You incorrectly attached my reply to another statement made by Richard: "Critter uses 150 cp lazy margin in qsearch and 300 cp margin at interior nodes.", which I didn't quote and didn't reply to.

Robert

the post in which you accuse Richard V. of stealing your 'original' code?!




EDIT-

damn! i had to send the post early...
i wanted to fill the page with LOls but i was laughing so hard, i couldn't finish

[Houdini]

Indeed, it's good that at last you've understood what we're talking about.
Next time it's probably a good idea that you actually read the thread before starting long rants...

Robert

[wgarvin]

150 is certainly not an 'original' or 'brilliant' idea,
Ippolit, Robbolito, Igorrit, and IvanHoe all use 150, exactly in the manner Richard described above for Critter...

from common.c:
#define LazyValue 150
#define LazyValue2 300

They're also found in Robbolito's comune.h:

Code: Select all

#define valu_pigro 150
#define valu_pigro2 300

The search passes these values to a "chiamata_valu_pigra" macro, which I guess is used for evaluation:

Code: Select all

#define chiamata_valu_piena(m)\
 valutazione (POSIZIONE, -0x7fff0000, 0x7fff0000, m)
#define chiamata_valu_pigra(B, A, p, m)\
 valutazione (POSIZIONE, (B) - (p), (A) + (p), m)

The 0x7fff0000 stuff looks familiar from the similar Ippolit code. It passes those as the min/max for most eval calls.

Code: Select all

evaluation_scoring (-0x7fff0000, 0x7fff0000, 0);

But for some eval calls, Ippolit uses smaller bounds. e.g. in white_cut/black_cut (and several others):

Code: Select all

evaluation_scoring (notch - 300, notch + 300, move);

In white_slide_check/black_slide_check (and several others):

Code: Select all

evaluation_scoring (notch - 150, notch + 150, move);

If you search Robbolito for "valu_pigro" you'll find the equivalent evaluation calls, with the same bounds, in its search code:

Code: Select all

D:\wylie\chess\robbolito\RobboLito-0.085f1a\cerca_fine.c/104:       chiamata_valu_pigra (VALU, VALU, valu_pigro, mossa);
D:\wylie\chess\robbolito\RobboLito-0.085f1a\cerca_fine.c/132: 	  chiamata_valu_pigra (VALU, VALU, valu_pigro, mossa);
D:\wylie\chess\robbolito\RobboLito-0.085f1a\cerca_fine.c/258:       chiamata_valu_pigra (VALU, VALU, valu_pigro, mossa);
D:\wylie\chess\robbolito\RobboLito-0.085f1a\cerca_mezzo.c/144:       chiamata_valu_pigra (VALU, VALU, valu_pigro, mossa);
D:\wylie\chess\robbolito\RobboLito-0.085f1a\cerca_mezzo.c/289:       chiamata_valu_pigra (VALU, VALU, valu_pigro, mossa);
D:\wylie\chess\robbolito\RobboLito-0.085f1a\escludo.c/148:       chiamata_valu_pigra (VALU, VALU, valu_pigro2, mossa);
D:\wylie\chess\robbolito\RobboLito-0.085f1a\escludo.c/326:       chiamata_valu_pigra (VALU, VALU, valu_pigro2, mossa);
D:\wylie\chess\robbolito\RobboLito-0.085f1a\nodo_tagliato.c/166:       chiamata_valu_pigra (VALU, VALU, valu_pigro2, mossa);
D:\wylie\chess\robbolito\RobboLito-0.085f1a\nodo_tagliato.c/386:       chiamata_valu_pigra (VALU, VALU, valu_pigro2, mossa);
D:\wylie\chess\robbolito\RobboLito-0.085f1a\nodo_totale.c/144:       chiamata_valu_pigra (VALU, VALU, valu_pigro2, mossa);
D:\wylie\chess\robbolito\RobboLito-0.085f1a\nodo_totale.c/316:       chiamata_valu_pigra (VALU, VALU, valu_pigro2, mossa);

So I'm convinced (for now) that Robbolito does not really differ from Ippolit in that respect.

Next, one might wonder what all of these different Ippolit clones do with those evaluation bounds? Turns out they do the obvious thing--compare against them, and take an early exit from eval.

e.g. from the middle of ippolit's evaluation_scoring method:

Code: Select all

void
evaluation_scoring (int mini, int maximum, int move)
{
  // <a bunch of stuff removed..>

  if &#40;position_fixed.white_engine&#41;
    &#123;
      // <a bunch of stuff removed..>

      score = &#40;endings * negative_phase + opening * phase&#41; / 32;
      raz += score;
      itog = raz + material_valuations;
      if &#40;itog < -maximum - 16 * &#40;int&#41; &#40;tower_dynamics - 1&#41;->sleepy || itog > -mini + 16 * &#40;int&#41; &#40;tower_dynamics - 1&#41;->sleepy&#41;
	&#123;
	  tower_dynamics->sleepy = &#40;tower_dynamics - 1&#41;->sleepy + 1;
	  tower_dynamics->score_value = itog;
	  tower_dynamics->positional = raz;
	  evaluation_mobility ();
	  return;  // <line 5404 or so>
	&#125;

Robbolito of course contains identical code in valu.c, around line 673 for example:

Code: Select all

	  valu = (finale * anti_fase + apertura * fase) / 32;
	  posizionale += valu;
	  v = posizionale + materiale_valu;
	  if &#40;v < -massimo - 16 * &#40;int&#41; &#40;DINAMICO - 1&#41;->pigro
	      || v > -minimo + 16 * &#40;int&#41; &#40;DINAMICO - 1&#41;->pigro&#41;
	    &#123;
	      DINAMICO->pigro = &#40;DINAMICO - 1&#41;->pigro + 1;
	      DINAMICO->valu = v;
	      DINAMICO->valu_posizionale = posizionale;
	      mobilita &#40;POSIZIONE&#41;;
	      return;
	    &#125;

So you'll forgive me if I'm inclined not to take Houdart's claim (that Houdini is different and magical with respect to 150 lazy margin in eval) at face value. After a quick skim of their sources, it looks more to me as if Houdini inherited that behaviour directly from Robbolito.

---------------
Edit: In case it isn't clear, this post is a reaction to the following comment from Houdart earlier in the thread:

Also, when the absolute value of positional component from ply-1 eval is greater than 150 cp, lazy eval is not used.

What a coincidence, Houdini does exactly the same...
LOL.

I was annoyed by his cheap shot at Richard who as I understand it, acknowledges that his engine is derived from the ippolit family. He reverse-engineered an early Houdini using robbolito as a road map. Apparently it was not too difficult since Houdini started life as an exact clone of robbolito. What annoys me is that Robert Houdart will not acknowledge this, and dances around the issue in his posts to try and mislead people into believing that Houdini is largely or entirely his original work. When the evidence we've seen so far makes it vanishingly unlikely that is the case.

------
Edit 2: Okay, it looks like Houdart is claiming that Houdini uses that 150 threshold for a different thing entirely (to avoid taking lazy exit when the score is unbalanced in one player's favor). I might be ranting about the wrong thing then (and this post might be entirely beside the point). Sorry!

[Don]

What you said is, "What a coincidence, Houdini does exactly the same... LOL" in response to Richards post about the position component from ply-1 eval.

The you followed up with, "It's just funny to see how much of Houdini ideas have already made it into other engines..."

If you say the idea was not in Ippolit I'll take your word for it. HOWEVER, your comment that it is a "Houdini idea" is what Mark Lefler refuted. I have to say that claiming other peoples ideas or work as your own is completely in character for you. What is next? Are you going to claim that you invented null move pruning?

my post is quite clear...
using lazyeval margin of 150 is not original or brilliant...regardless of you claims

Your post is clear but incorrect.
I made a claim about the special criterion for not using lazy eval. I quoted and replied to the following: "Also, when the absolute value of positional component from ply-1 eval is greater than 150 cp, lazy eval is not used.". Please reread the post http://www.talkchess.com/forum/viewtopic.php?p=435709 .
You are probably aware that this idea is not used in Ippolit nor Robbolito.

You incorrectly attached my reply to another statement made by Richard: "Critter uses 150 cp lazy margin in qsearch and 300 cp margin at interior nodes.", which I didn't quote and didn't reply to.

Robert

[/b]

[Houdini]

HOWEVER, your comment that it is a "Houdini idea" is what Mark Lefler refuted.

As far as I know this idea and its specific implementation, which is now also exactly found in Critter and in Strelka 5, is original to Houdini.

Do you have any reference to a past discussion (in this or another forum) in which this idea is exposed? I'm really interested.

Robert