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

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.

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 7:03 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)

Right, and a computation is said to be Non-Haling, if it will NEVER
reach a final state when it is run.

>
> [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.

LIE.

If H DOES abort is simulation/execution then the ACTUAL direct execution
or pure simulation of P(P) will Halt.

You are looking out the wrong window, the fact that H has aborted its
simulation of P does NOT mean that P will never reach its last
instruction AS A COMPUTATION.

You are NOT looking at the computation of P(P), but some strange partial
mixture that is hidden inside the behavior of H(P,P), and THAT can't be
a property of the Computation, as it will be different depending on
WHICH decider you are asking.

>
> [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.

LIE.

As we pointed above, P(P) DOES Halt for all H that happen to abort their
processing of P(P), so this statement fails.

>
> [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.

Since the DEFINITION of Halting is the behavior of the computation that
the input represents. YOU agreement that P(P) halts, just PROVES that
H(P,P) returning 0 is a wrong answer, and you claim otherwise is a LIE.

>
> [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.

It might have been 'decided', but it was decided incorrectly.

FAIL

>
> 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.

And, but the PROPER definition of Halting, every P(P) based on an H that
return 0 for H(P,P) does specifiy a value that is Halting.

If you are using some other defintion, then you are just talking about POOP.

>
> 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.
>

Nope, it is WRONG in the deduction if H does abort its simulation based
on that fact.

If H doesn't abort its simulation but just lets the execution continue,
then it fails to answer and even if it figured it out, that truth dies
with it.