#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
For every H of H(P,P) where P(P) calls this same H(P,P) and H simulates
or executes its input and aborts or does not abort its input.

[PSR_set] ∀{H,P} ∊ PSR_set (Input_Never_Halts( H(P,P) ))
[PSR_subset_A] ∃{H,P} ∊ PSR_set (Halts( H(P,P) ))
[PSR_subset_B] ∃{H,P} ∊ PSR_set (Halts( P(P) ))

[PSR_subset_C] The subset of the PSR_subset_A where H returns 0 on the
basis that H correctly detects that its input never halts (reaches its
final instruction). 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.

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.
H is a correct decider and H has a correct halt deciding basis.

*(see page 3)*
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/22/21 4:16 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, THE COMPUTATION enters a final state, and non-halting is the
COMPUTATION NEVER enters such a final state even in unbounded steps.

>
> [PSR_set] Combinations of H/P having pathological self-reference
> For every H of H(P,P) where P(P) calls this same H(P,P) and H simulates
> or executes its input and aborts or does not abort its input.
>
> [PSR_set] ∀{H,P} ∊ PSR_set (Input_Never_Halts(  H(P,P)  ))

Input_Never_Halts has not been defined. BAD LOGIC.

The NAME of this propery is a category error, as 'Inputs' don't halt.
By your definition above, it is COMPUTATIONS that Halt, so the only
reasonable interpreation of this statement would be

Input_Never_Halts( H(P,P) ) === The Computation P(P) will NEVER Halt
when run as a computation.

Thus, this above set only contains those H that NEVER return a value as
otherwise P(P) will Halt.

> [PSR_subset_A] ∃{H,P} ∊ PSR_set  (Halts(  H(P,P)  ))
> [PSR_subset_B] ∃{H,P} ∊ PSR_set  (Halts(  P(P)  ))

Again, Halts has not been defined, but if you mean the computation halts
by the above defintion, then Fine, these subsets are not subsets of the
PSR_set, as they have no elements in common, and PSR_subset_A and
PSR_subset_B are identical, as P(P) will halt iff H(P,P) halts (Note,
your P is no longer the Linz P, as it doesn't loop if H returns 1).

>
> [PSR_subset_C] The subset of the PSR_subset_A where H returns 0 on the
> basis that H correctly detects that its input never halts (reaches its
> final instruction). 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.

This is an empty set by the strict definition as H NEVER CORREDCTLY
detects that its input never halts.

It might detect that it will never be able to simulate the input to a
final state, but that is something different.

>
> 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.
> H is a correct decider and H has a correct halt deciding basis.

It may be a correct POOP decider, but it fails at being a Halt Decider,
because it isn't using the actual halt criteria to validate its decision.

Going back to the window metaphore you used before. H is looking out the
wrong window.

It NEEDS to look out the window of the COMPUTATION that it was given the
represntation of, and see what that does, instead it looks out the poor
copy of that which it creates by its simulation.

When it aborts its simulation, it effectively builds a brick wall that
blocks its sight to the goal it is trying to reach.

>
> *(see page 3)*
> Halting problem undecidability and infinitely nested simulation V2
>
> https://www.researchgate.net/publication/356105750_Halting_problem_undecidability_and_infinitely_nested_simulation_V2
>

You keep giving the same argument and try to change peripheral things to
hide you error, but you still FAIL to address the core errors in your
arguement.

You are just a bad LIAR who has been caught in his lie and are squirming
to try to justify the error. You Can't

You are DOOMED to fail on this path.

Remember the DEFINITION of Halting is based on the ACTUAL machine that
has it representation given to H.

Any claim of something else is just a LIE.

You are a FAILURE.