#include <stdint.h>
#include <stdio.h>
typedef int (*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; // Give P a last instruction at the "c" level
}

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

Computation that halts
a computation is said to halt whenever it enters a final state.
(Linz:1990:234)

Combinations of (H,P) having pathological self-reference (PSR)
H(P,P) simulates or executes its input and aborts or does
not abort its input and P(P) calls this same H(P,P) with itself.

We can think of the combinations of (H,P) as an enumerated sequence of
finite strings of C source-code. The above source code specifies the
H0(P0,P0) first element of this sequence.

Applying categorically exhaustive reasoning to the infinite set of
(Hn,Pn) pairs we examine the behavior of (Hn,Pn) pairs for each of the
four categories of behavior of Hn defined in the PSR set.

PSR set: When Hn(Pn, Pn) executes or simulates its input we can see that
this input never reaches its last instruction. When Hn(Pn, Pn) executes
or simulates its input and aborts this execution or simulation at some
point this input still never reaches its last instruction.

PSR subset A: When Hn(Pn, Pn) executes or simulates its input and aborts
this execution or simulation at some point this input still never
reaches its last instruction and Hn(Pn, Pn) halts.

PSR subset B: When Hn(Pn, Pn) executes or simulates its input and aborts
this execution or simulation at some point this input still never
reaches its last instruction and Hn(Pn, Pn) halts and Pn(Pn) called from
main() halts.

PSR subset C: For the subset of PSR subset A where Hn(Pn, Pn) returns 0
the returned halt status corresponds to the actual behavior of the input
to Hn(Pn, Pn).

PSR subset D: For the subset of PSR subset C where Hn(Pn, Pn) returns 0
on the basis that this input matched the infinite recursion behavior
pattern where this input calls H(P,P) again with its same input Hn is a
correct halt decider of Hn(Pn, Pn).

H is a computable function that accepts or rejects inputs in its domain
on the basis that these inputs specify a sequence of configurations that
reach their final state.

From Page (3) of this paper:
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

Same old lying error.

Since when Hn(Pn,Pn) returns 0, we can show that the direct execution of
Pn(Pn) will Halt, and you even have agreed to this fact.

And that the DEFINITION of the right answer for a Halting Decider is
based on this direct execution.

We Therefore PROVE that Hn(Pn,Pn) returning 0 is an INCORRECT ANSWER.

Thus, all you claims of Hn(Pn,Pn) returning 0 as correct are LIES based
on NOT looking at the actual problem that you claim to be solving but at
the behavior of some different computation.

H may be a perfect POOP decider, but only you seems to want to talk
about this POOP.

H just fails to be a HALT decider, and you are proved to be a LIAR.

On 11/23/21 11:21 AM, olcott wrote:
> #include <stdint.h>
> #include <stdio.h>
> typedef int (*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; // Give P a last instruction at the "c" level
> }
>
> int main(void)
> {
>   H(P, P);
> }
>
> Computation that halts
> a computation is said to halt whenever it enters a final state.
> (Linz:1990:234)
>
> Combinations of (H,P) having pathological self-reference (PSR)
>   H(P,P) simulates or executes its input and aborts or does
>   not abort its input and P(P) calls this same H(P,P) with itself.
>
> We can think of the combinations of (H,P) as an enumerated sequence of
> finite strings of C source-code. The above source code specifies the
> H0(P0,P0) first element of this sequence.
>
> Applying categorically exhaustive reasoning to the infinite set of
> (Hn,Pn) pairs we examine the behavior of (Hn,Pn) pairs for each of the
> four categories of behavior of Hn defined in the PSR set.
>
> PSR set: When Hn(Pn, Pn) executes or simulates its input we can see that
> this input never reaches its last instruction. When Hn(Pn, Pn) executes
> or simulates its input and aborts this execution or simulation at some
> point this input still never reaches its last instruction.
>
> PSR subset A: When Hn(Pn, Pn) executes or simulates its input and aborts
> this execution or simulation at some point this input still never
> reaches its last instruction and Hn(Pn, Pn) halts.
>
> PSR subset B: When Hn(Pn, Pn) executes or simulates its input and aborts
> this execution or simulation at some point this input still never
> reaches its last instruction and Hn(Pn, Pn) halts and Pn(Pn) called from
> main() halts.
>
> PSR subset C: For the subset of PSR subset A where Hn(Pn, Pn) returns 0
> the returned halt status corresponds to the actual behavior of the input
> to Hn(Pn, Pn).
>
> PSR subset D: For the subset of PSR subset C where Hn(Pn, Pn) returns 0
> on the basis that this input matched the infinite recursion behavior
> pattern where this input calls H(P,P) again with its same input Hn is a
> correct halt decider of Hn(Pn, Pn).
>
> H is a computable function that accepts or rejects inputs in its domain
> on the basis that these inputs specify a sequence of configurations that
> reach their final state.
>
> From Page (3) of this paper:
> Halting problem undecidability and infinitely nested simulation (V2)
>
> https://www.researchgate.net/publication/356105750_Halting_problem_undecidability_and_infinitely_nested_simulation_V2
>
>
>

On Tue, 23 Nov 2021 11:43:38 -0500
Richard Damon <Richard@Damon-Family.org> wrote:

> Same old lying error.
>
> Since when Hn(Pn,Pn) returns 0, we can show that the direct execution
> of Pn(Pn) will Halt, and you even have agreed to this fact.
>
> And that the DEFINITION of the right answer for a Halting Decider is
> based on this direct execution.
>
> We Therefore PROVE that Hn(Pn,Pn) returning 0 is an INCORRECT ANSWER.
>
> Thus, all you claims of Hn(Pn,Pn) returning 0 as correct are LIES
> based on NOT looking at the actual problem that you claim to be
> solving but at the behavior of some different computation.
>
> H may be a perfect POOP decider, but only you seems to want to talk
> about this POOP.
>
> H just fails to be a HALT decider, and you are proved to be a LIAR.

Are you triggered, dear?

/Flibble