*Infinite recursion / infinitely recursive emulation detection criteria*

int H(ptr p, ptr i)
{ p(i);
}

void P(ptr x)
{ H(x, x);
return;
}

int main()
{ H(P,P);
}

If the execution trace of function P() called by function H() shows:
(1) Function H() is called twice in sequence from the same machine
address of P().
(2) With the same parameters to H().
(3) With no control flow instructions between the invocation of P() and
the call to H() from P().

Then the function call from P() to H() is infinitely recursive.
The exact same pattern applies when H() simulates its input with an x86
emulator.

When H is an infinite recursion detector it simply matches the above
criteria in its execution trace of P, aborts its simulation of its input
and reports that its simulated input would never reach its "return"
instruction.

To avoid using static local memory for its stored execution trace H must
know its own address and see itself called from P with the same
arguments that it was called with.

--
Copyright 2022 Pete Olcott

"Talent hits a target no one else can hit;
Genius hits a target no one else can see."
Arthur Schopenhauer

On Friday, 22 July 2022 at 11:20:57 UTC+8, olcott wrote:
> *Infinite recursion / infinitely recursive emulation detection criteria*
>
> int H(ptr p, ptr i)
> {
> p(i);
> }
>
> void P(ptr x)
> {
> H(x, x);
> return;
> }
>
> int main()
> {
> H(P,P);
> }
>
> If the execution trace of function P() called by function H() shows:
> (1) Function H() is called twice in sequence from the same machine
> address of P().
> (2) With the same parameters to H().
> (3) With no control flow instructions between the invocation of P() and
> the call to H() from P().
>
> Then the function call from P() to H() is infinitely recursive.
> The exact same pattern applies when H() simulates its input with an x86
> emulator.
>
> When H is an infinite recursion detector it simply matches the above
> criteria in its execution trace of P, aborts its simulation of its input
> and reports that its simulated input would never reach its "return"
> instruction.
>
> To avoid using static local memory for its stored execution trace H must
> know its own address and see itself called from P with the same
> arguments that it was called with.
>
> --
> Copyright 2022 Pete Olcott
>
> "Talent hits a target no one else can hit;
> Genius hits a target no one else can see."
> Arthur Schopenhauer

EVERYBODY KNOWS the H and P shown are both "infinite recursive functions".
This fact is like 2+3=5, very elementary, does not need a complicated program
or devise other criteria to prove. It is ALREADY VERY OBVIOUS (lots of your work
addresses this unnecessary/useless part).

However, the HP asks for a deterministic (pure) decision PROGRAM H (not you):
H(P,x)==1, if P(x) halts.
H(P,x)==0, otherwise.

The deterministic (pure) H means H(P,P) must return the same value whether or
not it is from main or from P. Otherwise, this H is not a function in discussion and interested.

int main() {
H(P,P); // H must return the same value as the one in P
P(P); // this P
}

No matter what criteria you use, copy from all possible authoritative sources as
you can, it will all be useless because we know the author is an idiot who
cannot even get the basic logic right. It contains no technical meaning.

This only chance for you is a real H that satisfies the requirements shown, not
your 'criteria'. So far as we know it for these years, none.

On 7/21/2022 11:36 PM, wij wrote:
> On Friday, 22 July 2022 at 11:20:57 UTC+8, olcott wrote:
>> *Infinite recursion / infinitely recursive emulation detection criteria*
>>
>> int H(ptr p, ptr i)
>> {
>> p(i);
>> }
>>
>> void P(ptr x)
>> {
>> H(x, x);
>> return;
>> }
>>
>> int main()
>> {
>> H(P,P);
>> }
>>
>> If the execution trace of function P() called by function H() shows:
>> (1) Function H() is called twice in sequence from the same machine
>> address of P().
>> (2) With the same parameters to H().
>> (3) With no control flow instructions between the invocation of P() and
>> the call to H() from P().
>>
>> Then the function call from P() to H() is infinitely recursive.
>> The exact same pattern applies when H() simulates its input with an x86
>> emulator.
>>
>> When H is an infinite recursion detector it simply matches the above
>> criteria in its execution trace of P, aborts its simulation of its input
>> and reports that its simulated input would never reach its "return"
>> instruction.
>>
>> To avoid using static local memory for its stored execution trace H must
>> know its own address and see itself called from P with the same
>> arguments that it was called with.
>>
>> --
>> Copyright 2022 Pete Olcott
>>
>> "Talent hits a target no one else can hit;
>> Genius hits a target no one else can see."
>> Arthur Schopenhauer
>
> EVERYBODY KNOWS the H and P shown are both "infinite recursive functions".
> This fact is like 2+3=5, very elementary, does not need a complicated program
> or devise other criteria to prove. It is ALREADY VERY OBVIOUS (lots of your work
> addresses this unnecessary/useless part).
>

Great. I also want H() to know this, that is why I need specific
criteria to be validated.

> However, the HP asks for a deterministic (pure) decision PROGRAM H (not you):
> H(P,x)==1, if P(x) halts.
> H(P,x)==0, otherwise.
>

I am not even talking about halts. I am talking about P() never reaching
its "return" instruction.

> The deterministic (pure) H means H(P,P) must return the same value whether or
> not it is from main or from P. Otherwise, this H is not a function in discussion and interested.
>

I am not asking if a Turing machine determines if its input halts. I am
asking if my C function H() determines whether it not its simulated
input P() reaches its "return" instruction.

> int main() {
> H(P,P); // H must return the same value as the one in P
> P(P); // this P
> }
>

Maybe if H() is required to be a pure function. I am dropping that
requirement for now.

> No matter what criteria you use, copy from all possible authoritative sources as
> you can, it will all be useless because we know the author is an idiot who
> cannot even get the basic logic right. It contains no technical meaning.
>
> This only chance for you is a real H that satisfies the requirements shown, not
> your 'criteria'. So far as we know it for these years, none.

I am taking this as a two step process:
(1) Seeing if people are honest:
(a) If they say that the simulated P() can reach its "return"
instruction then they flunked the honesty test.

(b) If they refuse to confirm that the simulated P() can never reach its
"return" instruction then they flunked the honesty test.

After they pass these two tests then we can begin to examine pure
functions.

--
Copyright 2022 Pete Olcott

"Talent hits a target no one else can hit;
Genius hits a target no one else can see."
Arthur Schopenhauer

On 2022-07-22 03:20:48 +0000, olcott said:

> *Infinite recursion / infinitely recursive emulation detection criteria*
>
> int H(ptr p, ptr i)
> {
> p(i);
> }
>
> void P(ptr x)
> {
> H(x, x);
> return;
> }
>
> int main()
> {
> H(P,P);
> }
>
> If the execution trace of function P() called by function H() shows:
> (1) Function H() is called twice in sequence from the same machine
> address of P().
> (2) With the same parameters to H().
> (3) With no control flow instructions between the invocation of P() and
> the call to H() from P().
>
> Then the function call from P() to H() is infinitely recursive.

In the above code both H and P areobviously infinitely recursive.
P is infinitely recursive for all x and H as called by P and
whenever the first argument is P, in particular as called by main.

Mikko

On 7/22/2022 5:22 AM, Mikko wrote:
> On 2022-07-22 03:20:48 +0000, olcott said:
>
>> *Infinite recursion / infinitely recursive emulation detection criteria*
>>
>> int H(ptr p, ptr i)
>> {
>>    p(i);
>> }
>>
>> void P(ptr x)
>> {
>>    H(x, x);
>>    return;
>> }
>>
>> int main()
>> {
>>    H(P,P);
>> }
>>
>> If the execution trace of function P() called by function H() shows:
>> (1) Function H() is called twice in sequence from the same machine
>> address of P().
>> (2) With the same parameters to H().
>> (3) With no control flow instructions between the invocation of P()
>> and the call to H() from P().
>>
>> Then the function call from P() to H() is infinitely recursive.
>
> In the above code both H and P areobviously infinitely recursive.
> P is infinitely recursive for all x and H as called by P and
> whenever the first argument is P, in particular as called by main.
>
> Mikko
>

Great the question also asks does H know the P is infinitely recursive
on the basis of it seeing the above criteria are met?

--
Copyright 2022 Pete Olcott

"Talent hits a target no one else can hit;
Genius hits a target no one else can see."
Arthur Schopenhauer

On Thu, 21 Jul 2022 21:36:08 -0700 (PDT)
wij <wyniijj2@gmail.com> wrote:

> On Friday, 22 July 2022 at 11:20:57 UTC+8, olcott wrote:
> > *Infinite recursion / infinitely recursive emulation detection
> > criteria*
> >
> > int H(ptr p, ptr i)
> > {
> > p(i);
> > }
> >
> > void P(ptr x)
> > {
> > H(x, x);
> > return;
> > }
> >
> > int main()
> > {
> > H(P,P);
> > }
> >
> > If the execution trace of function P() called by function H()
> > shows: (1) Function H() is called twice in sequence from the same
> > machine address of P().
> > (2) With the same parameters to H().
> > (3) With no control flow instructions between the invocation of P()
> > and the call to H() from P().
> >
> > Then the function call from P() to H() is infinitely recursive.
> > The exact same pattern applies when H() simulates its input with an
> > x86 emulator.
> >
> > When H is an infinite recursion detector it simply matches the
> > above criteria in its execution trace of P, aborts its simulation
> > of its input and reports that its simulated input would never reach
> > its "return" instruction.
> >
> > To avoid using static local memory for its stored execution trace H
> > must know its own address and see itself called from P with the
> > same arguments that it was called with.
> >
> > --
> > Copyright 2022 Pete Olcott
> >
> > "Talent hits a target no one else can hit;
> > Genius hits a target no one else can see."
> > Arthur Schopenhauer
>
> EVERYBODY KNOWS the H and P shown are both "infinite recursive
> functions". This fact is like 2+3=5, very elementary, does not need a

There is no "infinite recursion" in [Strachey 1965] and associated
proofs.

/Flibble

On 7/21/22 11:20 PM, olcott wrote:
> *Infinite recursion / infinitely recursive emulation detection criteria*
>
> int H(ptr p, ptr i)
> {
>   p(i);
> }
>
> void P(ptr x)
> {
>   H(x, x);
>   return;
> }
>
> int main()
> {
>   H(P,P);
> }
>
> If the execution trace of function P() called by function H() shows:
> (1) Function H() is called twice in sequence from the same machine
> address of P().
> (2) With the same parameters to H().
> (3) With no control flow instructions between the invocation of P() and
> the call to H() from P().
>
> Then the function call from P() to H() is infinitely recursive.
> The exact same pattern applies when H() simulates its input with an x86
> emulator.
>
> When H is an infinite recursion detector it simply matches the above
> criteria in its execution trace of P, aborts its simulation of its input
> and reports that its simulated input would never reach its "return"
> instruction.
>
> To avoid using static local memory for its stored execution trace H must
> know its own address and see itself called from P with the same
> arguments that it was called with.
>

If H UNCONDITIONALLY calls P, yes.

If H uses something to make itsself conditional NO.

If H emulates, that decision to abort can come later after emulating for
a while.

In your case, since we know your H WILL abort its emulation after a
finite time to return 0, the "recursive emulation" is not infinite but
finite.

In fact, based on your published definition of H, that when H(P,P) finds
P in P a call to H(P,P) then the TOTAL call / emulation tree of the
modiifed program (that actually TESTS the results, using

in main()
{ H(P,P);
P(P);
}

will have a trace of:

1) Main calls
2) H(P,P) which emulates
3) P(P) whics calls H(P,P)
4) which causes the H @ 2 to return 0 to Main @ 1
5) Main calls
6) P(P) calls
7) H(P,P) which emualates [just like 2]
8) P(P) which calls H(P,P) [just like 3]
9) which cause the H @ 7 to return 0 to P(P) @ 6 [just like 4]
10) P(P) then returns [showing answer at 4 & 9 is incorrect]
11) Main finishes.

Since this shwos the rule is incorrect, you can't use it as "proof" that
H is correct in deciding P(P) is infinitely recursive.

Your broken argument that H(P,P) doesn't represent P(P) just fails for
several reasons:

1) P is DEFINED to be asking about P(P), so if H(P,P) doesn't refer to
that, you wrote your P incorrectly.

2) The input to H is a representation of a program, and the only program
around that is CAN refer to is P(P), the behavior you are trying to
match to that input doesn't match the behavior of any program that we
have in existence.

Since correct emulation is DEFINED as an emulation that matches the
behavior of what it is emulating, and since P(P) does Halt, the correct
emulation of the input to H(P,P) is Halting, so whatever H did to decide
that it isn't must be incorrect logic or incorrect emulation.

On 7/22/22 6:25 AM, olcott wrote:
> On 7/22/2022 5:22 AM, Mikko wrote:
>> On 2022-07-22 03:20:48 +0000, olcott said:
>>
>>> *Infinite recursion / infinitely recursive emulation detection criteria*
>>>
>>> int H(ptr p, ptr i)
>>> {
>>>    p(i);
>>> }
>>>
>>> void P(ptr x)
>>> {
>>>    H(x, x);
>>>    return;
>>> }
>>>
>>> int main()
>>> {
>>>    H(P,P);
>>> }
>>>
>>> If the execution trace of function P() called by function H() shows:
>>> (1) Function H() is called twice in sequence from the same machine
>>> address of P().
>>> (2) With the same parameters to H().
>>> (3) With no control flow instructions between the invocation of P()
>>> and the call to H() from P().
>>>
>>> Then the function call from P() to H() is infinitely recursive.
>>
>> In the above code both H and P areobviously infinitely recursive.
>> P is infinitely recursive for all x and H as called by P and
>> whenever the first argument is P, in particular as called by main.
>>
>> Mikko
>>
>
> Great the question also asks does H know the P is infinitely recursive
> on the basis of it seeing the above criteria are met?
>

Any H with enough "smarts" to detect and report this condition, gives
that smarts to the P that calls it and makes it non-infinitly recursive.

We, as humans, can know that if H runs until it can conclusively prove
that its input is non-halting, then it will run forever and not answer.

If it makes the "mistake" of deciding in finite time, then it just
becomes wrong, as we, as smart humans (at least most of us) can see.

It is possible for H to "know" the fact, but it can not "report" the
fact, as teh reporting is what makes it wrong.

H "knowing" isn't the requriement, "reporting" is, and any H that
reports that P(P) is non-halting is incorrect by definition.

On 2022-07-22 10:25:56 +0000, olcott said:

> On 7/22/2022 5:22 AM, Mikko wrote:
>> On 2022-07-22 03:20:48 +0000, olcott said:
>>
>>> *Infinite recursion / infinitely recursive emulation detection criteria*
>>>
>>> int H(ptr p, ptr i)
>>> {
>>>    p(i);
>>> }
>>>
>>> void P(ptr x)
>>> {
>>>    H(x, x);
>>>    return;
>>> }
>>>
>>> int main()
>>> {
>>>    H(P,P);
>>> }
>>>
>>> If the execution trace of function P() called by function H() shows:
>>> (1) Function H() is called twice in sequence from the same machine
>>> address of P().
>>> (2) With the same parameters to H().
>>> (3) With no control flow instructions between the invocation of P() and
>>> the call to H() from P().
>>>
>>> Then the function call from P() to H() is infinitely recursive.
>>
>> In the above code both H and P areobviously infinitely recursive.
>> P is infinitely recursive for all x and H as called by P and
>> whenever the first argument is P, in particular as called by main.
>>
>> Mikko
>>
>
> Great the question also asks does H know the P is infinitely recursive
> on the basis of it seeing the above criteria are met?

As coded above, it doesn't. In order to find out it would need to examine
both P and itself but it doesn't.

Mikko

On 7/22/2022 7:22 AM, Mikko wrote:
> On 2022-07-22 10:25:56 +0000, olcott said:
>
>> On 7/22/2022 5:22 AM, Mikko wrote:
>>> On 2022-07-22 03:20:48 +0000, olcott said:
>>>
>>>> *Infinite recursion / infinitely recursive emulation detection
>>>> criteria*
>>>>
>>>> int H(ptr p, ptr i)
>>>> {
>>>>    p(i);
>>>> }
>>>>
>>>> void P(ptr x)
>>>> {
>>>>    H(x, x);
>>>>    return;
>>>> }
>>>>
>>>> int main()
>>>> {
>>>>    H(P,P);
>>>> }
>>>>
>>>> If the execution trace of function P() called by function H() shows:
>>>> (1) Function H() is called twice in sequence from the same machine
>>>> address of P().
>>>> (2) With the same parameters to H().
>>>> (3) With no control flow instructions between the invocation of P()
>>>> and the call to H() from P().
>>>>
>>>> Then the function call from P() to H() is infinitely recursive.
>>>
>>> In the above code both H and P areobviously infinitely recursive.
>>> P is infinitely recursive for all x and H as called by P and
>>> whenever the first argument is P, in particular as called by main.
>>>
>>> Mikko
>>>
>>
>> Great the question also asks does H know the P is infinitely recursive
>> on the basis of it seeing the above criteria are met?
>
> As coded above, it doesn't. In order to find out it would need to examine
> both P and itself but it doesn't.
>
> Mikko
>

If H is a simulating halt decider then it examines every detail of its
simulation of P.

This is the code for the whole system as a Microsoft solution and
compilible under the command line compiler (the way I do it).

https://www.liarparadox.org/2022_07_22.zip

--
Copyright 2022 Pete Olcott

"Talent hits a target no one else can hit;
Genius hits a target no one else can see."
Arthur Schopenhauer

On 7/22/22 8:26 AM, olcott wrote:
> On 7/22/2022 7:22 AM, Mikko wrote:
>> On 2022-07-22 10:25:56 +0000, olcott said:
>>
>>> On 7/22/2022 5:22 AM, Mikko wrote:
>>>> On 2022-07-22 03:20:48 +0000, olcott said:
>>>>
>>>>> *Infinite recursion / infinitely recursive emulation detection
>>>>> criteria*
>>>>>
>>>>> int H(ptr p, ptr i)
>>>>> {
>>>>>    p(i);
>>>>> }
>>>>>
>>>>> void P(ptr x)
>>>>> {
>>>>>    H(x, x);
>>>>>    return;
>>>>> }
>>>>>
>>>>> int main()
>>>>> {
>>>>>    H(P,P);
>>>>> }
>>>>>
>>>>> If the execution trace of function P() called by function H() shows:
>>>>> (1) Function H() is called twice in sequence from the same machine
>>>>> address of P().
>>>>> (2) With the same parameters to H().
>>>>> (3) With no control flow instructions between the invocation of P()
>>>>> and the call to H() from P().
>>>>>
>>>>> Then the function call from P() to H() is infinitely recursive.
>>>>
>>>> In the above code both H and P areobviously infinitely recursive.
>>>> P is infinitely recursive for all x and H as called by P and
>>>> whenever the first argument is P, in particular as called by main.
>>>>
>>>> Mikko
>>>>
>>>
>>> Great the question also asks does H know the P is infinitely
>>> recursive on the basis of it seeing the above criteria are met?
>>
>> As coded above, it doesn't. In order to find out it would need to examine
>> both P and itself but it doesn't.
>>
>> Mikko
>>
>
> If H is a simulating halt decider then it examines every detail of its
> simulation of P.
>
> This is the code for the whole system as a Microsoft solution and
> compilible under the command line compiler (the way I do it).
>
> https://www.liarparadox.org/2022_07_22.zip
>

Weasle wording issue, the correct answer isn't based on "its simulation
of P" but a "correct and complete simulation of P"

Your H uses an INCORRECT rule which presumes, incorrectly, that a call
to H(P,P) made inside the simulation of P(P) can never return, when in
fact, you have also shown that H(P,P) does return in finite time the
value of 0.

Your system isn't looking at the H that you have, but a hypothetical H
and determining that no H with this structure can ever prove that P(P)
halts, not whether P(P), with THIS H halts or not.

Wrong Question, you get the wrong answer.

On Thu, 21 Jul 2022 22:20:48 -0500
olcott <NoOne@NoWhere.com> wrote:

> *Infinite recursion / infinitely recursive emulation detection
> criteria*
>
> int H(ptr p, ptr i)
> {
> p(i);
> }
>
> void P(ptr x)
> {
> H(x, x);
> return;
> }
>
> int main()
> {
> H(P,P);
> }
>
> If the execution trace of function P() called by function H() shows:
> (1) Function H() is called twice in sequence from the same machine
> address of P().
> (2) With the same parameters to H().
> (3) With no control flow instructions between the invocation of P()
> and the call to H() from P().
>
> Then the function call from P() to H() is infinitely recursive.
> The exact same pattern applies when H() simulates its input with an
> x86 emulator.
>
> When H is an infinite recursion detector it simply matches the above
> criteria in its execution trace of P, aborts its simulation of its
> input and reports that its simulated input would never reach its
> "return" instruction.
>
> To avoid using static local memory for its stored execution trace H
> must know its own address and see itself called from P with the same
> arguments that it was called with.

I think the fundamental issue here is your blind spot involving the so
called "infinite recursion": you fail to recognize that the infinite
recursion isn't being created by P, it is being created by your halting
decider so it is your faulting decider which is at fault.

/Flibble

On 7/22/22 11:11 AM, Mr Flibble wrote:
> On Thu, 21 Jul 2022 22:20:48 -0500
> olcott <NoOne@NoWhere.com> wrote:
>
>> *Infinite recursion / infinitely recursive emulation detection
>> criteria*
>>
>> int H(ptr p, ptr i)
>> {
>> p(i);
>> }
>>
>> void P(ptr x)
>> {
>> H(x, x);
>> return;
>> }
>>
>> int main()
>> {
>> H(P,P);
>> }
>>
>> If the execution trace of function P() called by function H() shows:
>> (1) Function H() is called twice in sequence from the same machine
>> address of P().
>> (2) With the same parameters to H().
>> (3) With no control flow instructions between the invocation of P()
>> and the call to H() from P().
>>
>> Then the function call from P() to H() is infinitely recursive.
>> The exact same pattern applies when H() simulates its input with an
>> x86 emulator.
>>
>> When H is an infinite recursion detector it simply matches the above
>> criteria in its execution trace of P, aborts its simulation of its
>> input and reports that its simulated input would never reach its
>> "return" instruction.
>>
>> To avoid using static local memory for its stored execution trace H
>> must know its own address and see itself called from P with the same
>> arguments that it was called with.
>
> I think the fundamental issue here is your blind spot involving the so
> called "infinite recursion": you fail to recognize that the infinite
> recursion isn't being created by P, it is being created by your halting
> decider so it is your faulting decider which is at fault.
>
> /Flibble
>

And in fact, that Halting Decider FIXES the problem of potential
infinite recursion by committing itself to the wrong answer.

H can either not give the wrong answer, and by trying to follow that
track, get ITSELF stuck in infinite simulation and fail by not giving an
answer, or it can avoid that problem by using a shortcut to the
definition, that fails for this case and give the wrong answer.

Since you keep on claiming that your H gives the "correct" answer of
returning 0 (and that is what the code you recently published
implements) we know we are in the second case and H is just wrong
because YOU are trying to use a wrong implementation of the definition
of Halting.

Halting is about the machine itself, or something that is provably
equivalent. Your criteria fails to be equivalent in this case (so isn't
actually equivalent) so you get the wrong answer.

Your H may be "right" but only to the wrong problem, and is probably
wrong about the actual problem.

On 2022-07-22 12:26:58 +0000, olcott said:

> On 7/22/2022 7:22 AM, Mikko wrote:
>> On 2022-07-22 10:25:56 +0000, olcott said:
>>
>>> On 7/22/2022 5:22 AM, Mikko wrote:
>>>> On 2022-07-22 03:20:48 +0000, olcott said:
>>>>
>>>>> *Infinite recursion / infinitely recursive emulation detection criteria*
>>>>>
>>>>> int H(ptr p, ptr i)
>>>>> {
>>>>>    p(i);
>>>>> }
>>>>>
>>>>> void P(ptr x)
>>>>> {
>>>>>    H(x, x);
>>>>>    return;
>>>>> }
>>>>>
>>>>> int main()
>>>>> {
>>>>>    H(P,P);
>>>>> }
>>>>>
>>>>> If the execution trace of function P() called by function H() shows:
>>>>> (1) Function H() is called twice in sequence from the same machine
>>>>> address of P().
>>>>> (2) With the same parameters to H().
>>>>> (3) With no control flow instructions between the invocation of P() and
>>>>> the call to H() from P().
>>>>>
>>>>> Then the function call from P() to H() is infinitely recursive.
>>>>
>>>> In the above code both H and P areobviously infinitely recursive.
>>>> P is infinitely recursive for all x and H as called by P and
>>>> whenever the first argument is P, in particular as called by main.
>>>>
>>>> Mikko
>>>>
>>>
>>> Great the question also asks does H know the P is infinitely recursive
>>> on the basis of it seeing the above criteria are met?
>>
>> As coded above, it doesn't. In order to find out it would need to examine
>> both P and itself but it doesn't.
>>
>> Mikko
>>
>
> If H is a simulating halt decider then it examines every detail of its
> simulation of P.

The H above is not a simulating halt decider. If a simulating halt decider
is used in place of H the above answers are no longer valid.

If H is a decider of any kind,

void P(ptr x)
{    H(x, x);
   return;
}

int main()
{    H(P,P);
}

is not infinitely recursive.

Mikko

On 7/22/22 12:15 PM, Mikko wrote:
> On 2022-07-22 12:26:58 +0000, olcott said:
>
>> On 7/22/2022 7:22 AM, Mikko wrote:
>>> On 2022-07-22 10:25:56 +0000, olcott said:
>>>
>>>> On 7/22/2022 5:22 AM, Mikko wrote:
>>>>> On 2022-07-22 03:20:48 +0000, olcott said:
>>>>>
>>>>>> *Infinite recursion / infinitely recursive emulation detection
>>>>>> criteria*
>>>>>>
>>>>>> int H(ptr p, ptr i)
>>>>>> {
>>>>>>    p(i);
>>>>>> }
>>>>>>
>>>>>> void P(ptr x)
>>>>>> {
>>>>>>    H(x, x);
>>>>>>    return;
>>>>>> }
>>>>>>
>>>>>> int main()
>>>>>> {
>>>>>>    H(P,P);
>>>>>> }
>>>>>>
>>>>>> If the execution trace of function P() called by function H() shows:
>>>>>> (1) Function H() is called twice in sequence from the same machine
>>>>>> address of P().
>>>>>> (2) With the same parameters to H().
>>>>>> (3) With no control flow instructions between the invocation of
>>>>>> P() and the call to H() from P().
>>>>>>
>>>>>> Then the function call from P() to H() is infinitely recursive.
>>>>>
>>>>> In the above code both H and P areobviously infinitely recursive.
>>>>> P is infinitely recursive for all x and H as called by P and
>>>>> whenever the first argument is P, in particular as called by main.
>>>>>
>>>>> Mikko
>>>>>
>>>>
>>>> Great the question also asks does H know the P is infinitely
>>>> recursive on the basis of it seeing the above criteria are met?
>>>
>>> As coded above, it doesn't. In order to find out it would need to
>>> examine
>>> both P and itself but it doesn't.
>>>
>>> Mikko
>>>
>>
>> If H is a simulating halt decider then it examines every detail of its
>> simulation of P.
>
> The H above is not a simulating halt decider. If a simulating halt decider
> is used in place of H the above answers are no longer valid.
>
> If H is a decider of any kind,
>
> void P(ptr x)
> {
>    H(x, x);
>    return;
> }
>
> int main()
> {
>    H(P,P);
> }
>
> is not infinitely recursive.
>
> Mikko
>

Yes, BY DEFINITION, if H is a decider, and thus by DEFINITION ALWAYS
returns an answer in finite time, the P is provably Halting, so ANY Halt
Decider that decides that this P is non-halting, when H is actually a
decider, must be wrong.

On 7/22/2022 10:11 AM, Mr Flibble wrote:
> On Thu, 21 Jul 2022 22:20:48 -0500
> olcott <NoOne@NoWhere.com> wrote:
>
>> *Infinite recursion / infinitely recursive emulation detection
>> criteria*
>>
>> int H(ptr p, ptr i)
>> {
>> p(i);
>> }
>>
>> void P(ptr x)
>> {
>> H(x, x);
>> return;
>> }
>>
>> int main()
>> {
>> H(P,P);
>> }
>>
>> If the execution trace of function P() called by function H() shows:
>> (1) Function H() is called twice in sequence from the same machine
>> address of P().
>> (2) With the same parameters to H().
>> (3) With no control flow instructions between the invocation of P()
>> and the call to H() from P().
>>
>> Then the function call from P() to H() is infinitely recursive.
>> The exact same pattern applies when H() simulates its input with an
>> x86 emulator.
>>
>> When H is an infinite recursion detector it simply matches the above
>> criteria in its execution trace of P, aborts its simulation of its
>> input and reports that its simulated input would never reach its
>> "return" instruction.
>>
>> To avoid using static local memory for its stored execution trace H
>> must know its own address and see itself called from P with the same
>> arguments that it was called with.
>
> I think the fundamental issue here is your blind spot involving the so
> called "infinite recursion": you fail to recognize that the infinite
> recursion isn't being created by P, it is being created by your halting
> decider so it is your faulting decider which is at fault.
>
> /Flibble
>

If a simulating halt decider continues to correctly simulate its input
until it correctly matches a non-halting behavior pattern then this SHD
is necessarily correct when it aborts its simulation and reports
non-halting.

Disagreeing with this is just like disagreeing that dogs an cats are
animals, necessarily incorrect.

--
Copyright 2022 Pete Olcott

"Talent hits a target no one else can hit;
Genius hits a target no one else can see."
Arthur Schopenhauer

On 7/22/22 2:36 PM, olcott wrote:
> On 7/22/2022 10:11 AM, Mr Flibble wrote:
>> On Thu, 21 Jul 2022 22:20:48 -0500
>> olcott <NoOne@NoWhere.com> wrote:
>>
>>> *Infinite recursion / infinitely recursive emulation detection
>>> criteria*
>>>
>>> int H(ptr p, ptr i)
>>> {
>>>     p(i);
>>> }
>>>
>>> void P(ptr x)
>>> {
>>>     H(x, x);
>>>     return;
>>> }
>>>
>>> int main()
>>> {
>>>     H(P,P);
>>> }
>>>
>>> If the execution trace of function P() called by function H() shows:
>>> (1) Function H() is called twice in sequence from the same machine
>>> address of P().
>>> (2) With the same parameters to H().
>>> (3) With no control flow instructions between the invocation of P()
>>> and the call to H() from P().
>>>
>>> Then the function call from P() to H() is infinitely recursive.
>>> The exact same pattern applies when H() simulates its input with an
>>> x86 emulator.
>>>
>>> When H is an infinite recursion detector it simply matches the above
>>> criteria in its execution trace of P, aborts its simulation of its
>>> input and reports that its simulated input would never reach its
>>> "return" instruction.
>>>
>>> To avoid using static local memory for its stored execution trace H
>>> must know its own address and see itself called from P with the same
>>> arguments that it was called with.
>>
>> I think the fundamental issue here is your blind spot involving the so
>> called "infinite recursion": you fail to recognize that the infinite
>> recursion isn't being created by P, it is being created by your halting
>> decider so it is your faulting decider which is at fault.
>>
>> /Flibble
>>
>
> If a simulating halt decider continues to correctly simulate its input
> until it correctly matches a non-halting behavior pattern then this SHD
> is necessarily correct when it aborts its simulation and reports
> non-halting.
>
> Disagreeing with this is just like disagreeing that dogs an cats are
> animals, necessarily incorrect.
>
>

Yes, and if it does that for P(P), it will simulate FOREVER and fail to
decide.

If H EVER decides that its simultion of P(P) has indicated non-halting,
and stops its simulation and returns 0, then it will return 0 to all the
P(P)s that call it, and they will all Halt, thus showing that H was wrong.

Disagreeing with THAT is like calling your dog a cat.

On Friday, 22 July 2022 at 20:36:15 UTC+2, olcott wrote:
> If a simulating halt decider continues to correctly simulate its input
> until it correctly matches a non-halting behavior pattern then this SHD
> is necessarily correct when it aborts its simulation and reports
> non-halting.
>
> Disagreeing with this is just like disagreeing that dogs an cats are
> animals, necessarily incorrect.

Seems like your disagreement-decider has decided that I can't disagree with you.
Yet here I am, disagreeing with you - thus rendering your disagreement-decider wrong.

P is simulating H.
H is simulating P.

It's called Bisimulation. https://en.wikipedia.org/wiki/Bisimulation

On 7/22/2022 1:51 PM, Skep Dick wrote:
> On Friday, 22 July 2022 at 20:36:15 UTC+2, olcott wrote:
>> If a simulating halt decider continues to correctly simulate its input
>> until it correctly matches a non-halting behavior pattern then this SHD
>> is necessarily correct when it aborts its simulation and reports
>> non-halting.
>>
>> Disagreeing with this is just like disagreeing that dogs an cats are
>> animals, necessarily incorrect.
>
> Seems like your disagreement-decider has decided that I can't disagree with you.
> Yet here I am, disagreeing with you - thus rendering your disagreement-decider wrong.
>
> P is simulating H.
> H is simulating P.
>
> It's called Bisimulation. https://en.wikipedia.org/wiki/Bisimulation

First of all you have the facts incorrectly, only H is simulating.

--
Copyright 2022 Pete Olcott

"Talent hits a target no one else can hit;
Genius hits a target no one else can see."
Arthur Schopenhauer

On Friday, 22 July 2022 at 21:08:00 UTC+2, olcott wrote:
> First of all you have the facts incorrectly, only H is simulating.

Really?

So why does your code look like this...

int H(ptr p, ptr i)
{ p(i);
}

and not like this...

int H(ptr p, ptr i)
{ simulate(p(i));
}

On 7/22/2022 2:09 PM, Skep Dick wrote:
> On Friday, 22 July 2022 at 21:08:00 UTC+2, olcott wrote:
>> First of all you have the facts incorrectly, only H is simulating.
>
> Really?
>
> So why does your code look like this...
>
> int H(ptr p, ptr i)
> {
> p(i);
> }
>
> and not like this...
>
>
> int H(ptr p, ptr i)
> {
> simulate(p(i));
> }

That is a simplistic example to communicate the simplest possible case
of infinite recursion.

--
Copyright 2022 Pete Olcott

"Talent hits a target no one else can hit;
Genius hits a target no one else can see."
Arthur Schopenhauer

On Friday, 22 July 2022 at 21:14:43 UTC+2, olcott wrote:
> That is a simplistic example to communicate the simplest possible case
> of infinite recursion.

So what?

In your example P is calling H and H is calling P.
There is nothing to indicate that the one is using a different evaluation strategy from the other.

On 7/22/2022 2:17 PM, Skep Dick wrote:
> On Friday, 22 July 2022 at 21:14:43 UTC+2, olcott wrote:
>> That is a simplistic example to communicate the simplest possible case
>> of infinite recursion.
>
> So what?
>
> In your example P is calling H and H is calling P.
> There is nothing to indicate that the one is using a different evaluation strategy from the other.
>

That is the simplistic example, no simulation.

When simulating halt decider H(P,P) simulates its input then H can see
that when P calls H(P,P) this is a second invocation with the same
arguments with no control flow instructions inbetween the beginning of P
and the invocation of H(P,P) from P.

H can see that P is calling H because H knows its own machine address. H
already knows that it is simulating P and already knows its own arguments.

--
Copyright 2022 Pete Olcott

"Talent hits a target no one else can hit;
Genius hits a target no one else can see."
Arthur Schopenhauer

On Friday, 22 July 2022 at 21:26:38 UTC+2, olcott wrote:
> That is the simplistic example, no simulation.
So why are you calling it a "simulating decider" when it's obvious from your source code that H doesn't simulate P.

Your English doesn't correspond to your C.

> When simulating halt decider H(P,P) simulates its input then H can see
> that when P calls H(P,P) this is a second invocation with the same
> arguments
Where in your function H do you keep track on the number of times H has been invoked? I don't see that.

Again, your English doesn't correspond to your C.

> H can see that P is calling H because H knows its own machine address.
Again, your English doesn't correspond to your C.

Where in your implementation of H does it perform any address checking?

> already knows that it is simulating P and already knows its own arguments.
H doesn't know it's simulating P. Because it's not simulating P. It's calling P.

Your English doesn't correspond to your C.

On 7/22/2022 2:34 PM, Skep Dick wrote:
> On Friday, 22 July 2022 at 21:26:38 UTC+2, olcott wrote:
>> That is the simplistic example, no simulation.
> So why are you calling it a "simulating decider" when it's obvious from your source code that H doesn't simulate P.
>

I am explaining how a simulating halt decider recognizes that its input
specifies infinitely nested simulation step by step.

I do this by showing the criteria that humans use to recognize ordinary
infinite recursion between two functions.

Then I enhance the English (and not the C) to explain how the infinite
recursion criteria for humans is adapted so that H can recognize the
infinitely recursive simulation of its input.

When I show this in C it requires 5 pages of code. (pages 6-10)

*Halting problem proofs refuted on the basis of software engineering ?*
https://www.researchgate.net/publication/361701808_Halting_problem_proofs_refuted_on_the_basis_of_software_engineering

https://www.liarparadox.org/2022_07_22.zip
*This is the complete system that compiles under*

Microsoft Visual Studio Community 2017
https://visualstudio.microsoft.com/vs/older-downloads/

It has not been recently compiled under UBUNTU

--
Copyright 2022 Pete Olcott

"Talent hits a target no one else can hit;
Genius hits a target no one else can see."
Arthur Schopenhauer