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

*H is a computable function that correctly decides whether or not
elements in its domain reach their final state*

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.

When we analyize the computation int main(void) { P(P); } as if it was
in 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.

--
Copyright 2021 Pete Olcott

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

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);
> }

$ make olcott
cc olcott.c -o olcott
$ ./olcott
Segmentation fault: 11

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);
> }

$ make olcott
cc olcott.c -o olcott
$ ./olcott
Segmentation fault: 11

On 11/21/21 5:29 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);
> }
>
> *H is a computable function that correctly decides whether or not
> elements in its domain reach their final state*
>

Except that if the domain is Computation per Computation Theory, it doesn't

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

But that is not the Definition of 'Halting'.

If P(P) is being called the computation that H is deciding on by having
its input be P,P, then by the actual execution of this computation, we
find that P(P) does Halt for every P based on an H that returns and
answer for H(P,P), and you have even agreed to this.

The fact that the PARTIAL simulation/debug execution done by H of its
input does NOT reach this final state does NOT show this input does not
Halt.

If you want to claim that, then EVERY computation is 'non-halting', as
you just need to define an H that simulates for 0 instructions and then
aborts, and thus no input reaches its final state.

FAIL.

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

Except that we just showed that ALL P(P) that are base on an H(P,P) that
returns an answer will halt, so this statement is FALSE.

>
> When we analyize the computation int main(void) { P(P); } as if it was
> in 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.
>

Right, and the DEFINITION of the Halting Question is that H(P,I) needs
to say Halting if P(I) will halt, and non-halting if P(I) will never halt.

Since you just admited that these P(P) will halt, the claim that the
'input to H; ie that P,P which is supposed to represent P(P); does not
halt' is a LIE, or at best a deception based on using wrong definitions
(which are just politer words for what is still 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.
>

LIE.

EIther you need to accept that H(P,P) == 0 is WRONG, and your claim that
it is correct is a LIE; or that H(P,P) is just not answering the
question of the halting problem, and the claim that it is a counter
example is a LIE.

You can't get around this.

You basically sr LYING about what your proof says, as it is false to the
core based on using WRONG definitions.

All you have 'proved' is that you are totally ignorant about a topic you
are claiming to have great insight into, and you have basically WASTED
you life on trying to prove a LIE.