#include <stdint.h>
typedef void (*ptr)();

int H(ptr x, ptr y)
{ x(y); // direct execution of P(P)
return 1;
}

// Minimal essence of Linz(1990) Ĥ
// and Strachey(1965) P
int P(ptr x)
{ H(x, x);
return 1;
}

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

Of every possible H that can possibly exist from H[0]...H[N]
(a) Called from the above P.
(b) Simulates or Executes its input.
(c) Aborts this input at some point or not.

No P ever returns any value, thus P never halts.

To create a halt decider H(P,P) H merely needs to see that P is calling
H with the same parameters that H was called with, this specifying
infinite recursion.

This would be an (a), (b1), (c1) instance of the above set of every
possible H.

Halting problem undecidability and infinitely nested simulation (V2)

https://www.researchgate.net/publication/356105750_Halting_problem_undecidability_and_infinitely_nested_simulation_V2

--
Copyright 2021 Pete Olcott

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

On 11/16/2021 5:45 PM, Richard Damon wrote:
> On 11/16/21 9:35 AM, olcott wrote:
>> On 11/16/2021 5:55 AM, Richard Damon wrote:
>>> On 11/15/21 11:41 PM, olcott wrote:
>>>> On 11/15/2021 9:52 PM, Richard Damon wrote:
>>>>> On 11/15/21 10:39 PM, olcott wrote:
>>>>>> On 11/15/2021 8:54 PM, Richard Damon wrote:
>>>>>>> On 11/15/21 9:28 PM, olcott wrote:
>>>>>>>> #include <stdint.h>
>>>>>>>> typedef void (*ptr)();
>>>>>>>>
>>>>>>>> int H(ptr x, ptr y)
>>>>>>>> {
>>>>>>>>    x(y);  // direct execution of P(P)
>>>>>>>>    return 1;
>>>>>>>> }
>>>>>>>>
>>>>>>>> // Minimal essence of Linz(1990) Ĥ
>>>>>>>> // and Strachey(1965) P
>>>>>>>> int P(ptr x)
>>>>>>>> {
>>>>>>>>    H(x, x);
>>>>>>>>    return 1;
>>>>>>>> }
>>>>>>>>
>>>>>>>> int main(void)
>>>>>>>> {
>>>>>>>>    H(P, P);
>>>>>>>> }
>>>>>>>>
>>>>>>>> Of every possible H that can possibly exist from H[0]...H[N]
>>>>>>>> (a) Called from the above P.
>>>>>>>> (b) Simulates or Executes its input.
>>>>>>>> (c) Aborts this input at some point or not.
>>>>>>>>
>>>>>>>> No P ever returns any value, thus P never halts.
>>>>>>>
>>>>>>> But, when you run that P as the top level machine,
>>>>>>
>>>>>> The you create the strawman error that simlply dodges what I
>>>>>> actually said and forms a rebuttal on the basis of something else
>>>>>> entirely.
>>>>>>
>>>>>> The input to H(P,P) never halts for any H that meets (a)(b)(c).
>>>>>>
>>>>>
>>>>> No, YOUR definition of Halting was if the input is directly
>>>>> executed or purely simulated Halts, then the input is Halting.
>>>>
>>>>
>>>> Glossary of Terms
>>>>
>>>> computation
>>>> The sequence of configurations leading to a halt state will be
>>>> called a computation.  (Linz:1990:238)
>>>>
>>>> computation that halts
>>>> a computation is said to halt whenever it enters a final state.
>>>> (Linz:1990:234)
>>>
>>>
>>> And beig NON-Halting is not halting when allowed to run for unbounded
>>> steps.
>>>
>>> In other words we need to actually run the computation until it
>>> halts, or actually show that it will never halt if it was allowed to
>>> run to completion.
>>>
>>> You don't do this test.
>>>
>>>>
>>>> for every H that meets (a)(b)(c)
>>>> execute/no abort
>>>> simulate/no abort
>>>> execute/abort
>>>> simulate/abort
>>>>
>>>> The input to H(P,P) never reaches its final state.
>>>
>>> Except it does, when we check THAT INPUT as its actual computation,
>>> that is being directly running the machine it represents or giving
>>> that same input to a pure simulator.
>>>
>>
>> Every possible H that can possibly exist called from the
>> above P Simulates or Executes its input and Aborts or
>> does not abort this input.
>>
>> Possible types of H (called by P) and the behavior of P
>> (a) execute/no abort   (shown above)
>> (b) simulate/no abort  (never gets past first line of P)
>> (c) execute/abort      (never gets past first line of P)
>> (d) simulate/abort     (never gets past first line of P)
>
>
> Right, in (a) and (b), then you are correcct that P(P) is non-halting,
> but those H's never return the answers.
>
> For (c) and (d), that H isn't a pure simulation so it doesn't reveal the
> right behavior.
>

In no case of (a)(b)(c)(d) does P reach its final instruction therefore
in every case of (a)(b)(c)(d) H(P,P)==0 is the correct return value for
H whether or not H actually returns any value at all.

Whom-so-ever does not agree with this is:
(a) Insufficiently technically competent.
(b) Dishonest

--
Copyright 2021 Pete Olcott "Talent hits a target no one else can hit;
Genius hits a target no one else can see." Arthur Schopenhauer

On 11/16/2021 7:57 PM, Richard Damon wrote:
>
> On 11/16/21 7:47 PM, olcott wrote:
>> On 11/16/2021 5:45 PM, Richard Damon wrote:
>>> On 11/16/21 9:35 AM, olcott wrote:
>>>> On 11/16/2021 5:55 AM, Richard Damon wrote:
>>>>> On 11/15/21 11:41 PM, olcott wrote:
>>>>>> On 11/15/2021 9:52 PM, Richard Damon wrote:
>>>>>>> On 11/15/21 10:39 PM, olcott wrote:
>>>>>>>> On 11/15/2021 8:54 PM, Richard Damon wrote:
>>>>>>>>> On 11/15/21 9:28 PM, olcott wrote:
>>>>>>>>>> #include <stdint.h>
>>>>>>>>>> typedef void (*ptr)();
>>>>>>>>>>
>>>>>>>>>> int H(ptr x, ptr y)
>>>>>>>>>> {
>>>>>>>>>>    x(y);  // direct execution of P(P)
>>>>>>>>>>    return 1;
>>>>>>>>>> }
>>>>>>>>>>
>>>>>>>>>> // Minimal essence of Linz(1990) Ĥ
>>>>>>>>>> // and Strachey(1965) P
>>>>>>>>>> int P(ptr x)
>>>>>>>>>> {
>>>>>>>>>>    H(x, x);
>>>>>>>>>>    return 1;
>>>>>>>>>> }
>>>>>>>>>>
>>>>>>>>>> int main(void)
>>>>>>>>>> {
>>>>>>>>>>    H(P, P);
>>>>>>>>>> }
>>>>>>>>>>
>>>>>>>>>> Of every possible H that can possibly exist from H[0]...H[N]
>>>>>>>>>> (a) Called from the above P.
>>>>>>>>>> (b) Simulates or Executes its input.
>>>>>>>>>> (c) Aborts this input at some point or not.
>>>>>>>>>>
>>>>>>>>>> No P ever returns any value, thus P never halts.
>>>>>>>>>
>>>>>>>>> But, when you run that P as the top level machine,
>>>>>>>>
>>>>>>>> The you create the strawman error that simlply dodges what I
>>>>>>>> actually said and forms a rebuttal on the basis of something
>>>>>>>> else entirely.
>>>>>>>>
>>>>>>>> The input to H(P,P) never halts for any H that meets (a)(b)(c).
>>>>>>>>
>>>>>>>
>>>>>>> No, YOUR definition of Halting was if the input is directly
>>>>>>> executed or purely simulated Halts, then the input is Halting.
>>>>>>
>>>>>>
>>>>>> Glossary of Terms
>>>>>>
>>>>>> computation
>>>>>> The sequence of configurations leading to a halt state will be
>>>>>> called a computation.  (Linz:1990:238)
>>>>>>
>>>>>> computation that halts
>>>>>> a computation is said to halt whenever it enters a final state.
>>>>>> (Linz:1990:234)
>>>>>
>>>>>
>>>>> And beig NON-Halting is not halting when allowed to run for
>>>>> unbounded steps.
>>>>>
>>>>> In other words we need to actually run the computation until it
>>>>> halts, or actually show that it will never halt if it was allowed
>>>>> to run to completion.
>>>>>
>>>>> You don't do this test.
>>>>>
>>>>>>
>>>>>> for every H that meets (a)(b)(c)
>>>>>> execute/no abort
>>>>>> simulate/no abort
>>>>>> execute/abort
>>>>>> simulate/abort
>>>>>>
>>>>>> The input to H(P,P) never reaches its final state.
>>>>>
>>>>> Except it does, when we check THAT INPUT as its actual computation,
>>>>> that is being directly running the machine it represents or giving
>>>>> that same input to a pure simulator.
>>>>>
>>>>
>>>> Every possible H that can possibly exist called from the
>>>> above P Simulates or Executes its input and Aborts or
>>>> does not abort this input.
>>>>
>>>> Possible types of H (called by P) and the behavior of P
>>>> (a) execute/no abort   (shown above)
>>>> (b) simulate/no abort  (never gets past first line of P)
>>>> (c) execute/abort      (never gets past first line of P)
>>>> (d) simulate/abort     (never gets past first line of P)
>>>
>>>
>>> Right, in (a) and (b), then you are correcct that P(P) is
>>> non-halting, but those H's never return the answers.
>>>
>>> For (c) and (d), that H isn't a pure simulation so it doesn't reveal
>>> the right behavior.
>>>
>>
>> In no case of (a)(b)(c)(d) does P reach its final instruction
>> therefore in every case of (a)(b)(c)(d) H(P,P)==0 is the correct
>> return value for H whether or not H actually returns any value at all.
>>
>> Whom-so-ever does not agree with this is:
>> (a) Insufficiently technically competent.
>> (b) Dishonest
>>
>
> Except that it does, when measure by the criteria that you actually
> defined!!
>
> Simple trace of Pd(Pd),
>
> Pd(Pd) calls Hd(Pd,Pd)
When main() calls H(P,P)
which simulates or executes its input and
aborts or does not abort its input
where P calls H(P,P)
P never reaches its last instruction.

For the every element of the sequences of instructions that I specified
P never reaches its last instruction this is a verified fact.

That you refer to main() calling P(P) is the well known dishonest dodge
called the strawman error.

A straw man (sometimes written as strawman) is a form of argument and an
informal fallacy of having the impression of refuting an argument,
whereas the real subject of the argument was not addressed or refuted,
but instead replaced with a false one.
https://en.wikipedia.org/wiki/Straw_man

--
Copyright 2021 Pete Olcott "Talent hits a target no one else can hit;
Genius hits a target no one else can see." Arthur Schopenhauer