#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)

[PSR set] Combinations of H/P having pathological self-reference
Every H of H(P,P) invoked from main() where P(P) calls this same H(P,P)
and H simulates or executes its input and aborts or does not abort its
input P never reaches its last instruction.

[PSR subset] Because we know that the input to H(P,P) never halts for
the whole PSR set and a subset of these H/P combinations aborts the
execution or simulation of its input then we know that for this entire
PSR subset the input to H(P,P) never halts and H(P,P) halts.

[PSR subset + P(P) set] Appending the computation int main(void) { P(P);
} to the PSR subset on the basis of the exact same H/P pairs that are in
this subset we find that this P(P) halts while the input to its
corresponding H(P,P) never halts.

[Decidable_PSR subset] The subset of the PSR subset where H returns 0 on
the basis that H correctly detects that P specifies infinite recursion
defines the decidable domain of function H.

(a) Math function H: maps specified sequences of configurations in its
domain to {0,1}
(b) int H(ptr x, ptr y) maps sequences of configurations specified by
(x,y) to {0,1}.
(c) TM H maps sequences of configurations specified on its tape to H.qn
and H.qy.
on the basis of whether or not this sequence of configurations reaches
its final state.

Because there is no way to separately distinguish the independent
computation P(P) from a UTM simulation of (P,P) to any math function C
function or TM decider the simulation of the input to H must always be a
correct basis.

The above H could detect that its simulated P is calling H(P,P) with the
same parameters that it was called with, thus specifying infinite
recursion.

--
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/21/21 6:49 PM, 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)
>
> [PSR set] Combinations of H/P having pathological self-reference
> Every H of H(P,P) invoked from main() where P(P) calls this same H(P,P)
> and H simulates or executes its input and aborts or does not abort its
> input P never reaches its last instruction.

WRONG. If H(P,P) returns 0 then P(P) Halts.

You have been told this many times, so this is a clear LIE.

>
> [PSR subset] Because we know that the input to H(P,P) never halts for
> the whole PSR set and a subset of these H/P combinations aborts the
> execution or simulation of its input then we know that for this entire
> PSR subset the input to H(P,P) never halts and H(P,P) halts.

WRONG

>
> [PSR subset + P(P) set] Appending the computation int main(void) { P(P);
> } to the PSR subset on the basis of the exact same H/P pairs that are in
> this subset we find that this P(P) halts while the input to its
> corresponding H(P,P) never halts.

WRONG.

>
> [Decidable_PSR subset] The subset of the PSR subset where H returns 0 on
> the basis that H correctly detects that P specifies infinite recursion
> defines the decidable domain of function H.
>

WRONG.

> (a) Math function H: maps specified sequences of configurations in its
> domain to {0,1}
> (b) int H(ptr x, ptr y) maps sequences of configurations specified by
> (x,y) to {0,1}.
> (c) TM H maps sequences of configurations specified on its tape to H.qn
> and H.qy.
> on the basis of whether or not this sequence of configurations reaches
> its final state.

Needs to be on the basis of if the input when directly run or simulated
with a REAL PURE UTM will reach a halting state in finite time or
continue infinitely.

Sounds like you are just talking POOP and looking out the wrong window.

>
> Because there is no way to separately distinguish the independent
> computation P(P) from a UTM simulation of (P,P) to any math function C
> function or TM decider the simulation of the input to H must always be a
> correct basis.

You may not be able to tell direct execution from a UTM, but you can
tell the diffence between a UTM and an H that aborts its simulation, as
the sequence of steps in P end on a non-halting state. With a UTM, the
trace will ONLY end on a halting state, and if it doesn't reach one, it
doesn't stop.

>
> The above H could detect that its simulated P is calling H(P,P) with the
> same parameters that it was called with, thus specifying infinite
> recursion.
>

Only true if the H doesn't then abort its simulation, and dies with the
knowledge that its input is non-halting and doesn't give the answer.

If H aborts its simulation, then BY DEFINITION, so will the H that it
sees, and thus H needs to see what happens when that H returns with
whatever answer H is going to commit to returning. The IS NO infinite
recursion.

FAIL.