XPost: comp.theory, sci.logic, sci.math

#include <stdint.h>
typedef void (*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);
}

For every possible 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.

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

Of the infinite set of definitions of H specified above those that
return 0 are correct halt deciders for their input.

--
Copyright 2021 Pete Olcott

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

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

XPost: comp.theory, sci.logic, sci.math

On 11/18/2021 7:00 AM, Mr Flibble wrote:

On Thu, 18 Nov 2021 06:29:26 -0500
Richard Damon <[email protected]> wrote:

On 11/17/21 10:48 PM, olcott wrote:

For every possible 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.

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

No, you LIE.

Halting is DEFINED by the behavior of the actual computation.

H(P,P) is supposed to say what P(P) will do.

No,

H(P,I) is supposed to say what P(H(P(H(P(H(P(...

i.e. it is infinite recursion due to a category error; H(P,I) as
defined is INVALID. The halting problem as defined is INVALID.

/Flibble

I made the "impossible" inputs decidable.

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

(1) H(P,P) simply executes its input:
main() calls H(P,P) that calls P(P) that calls H(P,P)...
(2) H(P,P) simulates its input.
(3) H(P,P) executes its input** and aborts this execution at some point.
**(a debugger could be used).
(4) H(P,P) simulates its input and aborts this simulation at some point.

For every possible 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.

The above defines all of the combinations of H/P having pathological self-reference.

Cases (3) and (4) define the subset of these where the behavior of
H(P,P) diverges for the behavior of P(P).



--
Copyright 2021 Pete Olcott

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

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

XPost: comp.theory, sci.logic, sci.math

On 11/18/2021 7:00 AM, Mr Flibble wrote:

On Thu, 18 Nov 2021 06:29:26 -0500
Richard Damon <[email protected]> wrote:

On 11/17/21 10:48 PM, olcott wrote:

For every possible 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.

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

No, you LIE.

Halting is DEFINED by the behavior of the actual computation.

H(P,P) is supposed to say what P(P) will do.

No,

H(P,I) is supposed to say what P(H(P(H(P(H(P(...

i.e. it is infinite recursion due to a category error; H(P,I) as
defined is INVALID. The halting problem as defined is INVALID.

/Flibble

It is not actually invalid, I used to think that back in 2004.
The HP has the same form of the Liar Paradox and the Liar Paradox is
invalid making it not a truth bearer.

[Halting Problem Final Conclusion]
comp.theory
Peter Olcott
Sep 5, 2004, 11:21:57 AM

The Liar Paradox can be shown to be nothing more than
a incorrectly formed statement because of its pathological
self-reference. The Halting Problem can only exist because
of this same sort of pathological self-reference. https://groups.google.com/g/comp.theory/c/RO9Z9eCabeE/m/Ka8-xS2rdEEJ

The HP input is merely infinitely nested simulation that is correctly
decided as not halting.

--
Copyright 2021 Pete Olcott

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

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

XPost: comp.theory, sci.logic, sci.math

On 11/18/2021 10:55 AM, Ben Bacarisse wrote:

Mr Flibble <[email protected]> writes:

On Thu, 18 Nov 2021 06:29:26 -0500
Richard Damon <[email protected]> wrote:

H(P,P) is supposed to say what P(P) will do.

No,

So what arguments does one pass to H to find out is P(P) halts?

This is the same code that you modified.

If it's
not P and P, what is it? (Of course it is P and P, that's why PO says
that H(P,P) == 0 is correct /despite/ the fact that P(P) halts.)

P(P) is the strawman error in that it is an entirely different claim
than the one that I am making.

My claim only refers to the sets of sequences of x86 instructions
(defined below) such that the H/P combinations have pathological
self-reference relative to each other.

For every possible 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.

halt decider (Olcott 2021)
A halt decider accepts or rejects inputs on the basis of the actual
behavior of the direct execution or simulation of these inputs.

To create a halt decider H(P,P) H merely needs to see that P is calling
H with the same parameters that H 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

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

XPost: comp.theory, sci.logic, sci.math

On 11/18/2021 3:57 PM, Mr Flibble wrote:

On Thu, 18 Nov 2021 16:55:24 +0000
Ben Bacarisse <[email protected]> wrote:

Mr Flibble <[email protected]> writes:

On Thu, 18 Nov 2021 06:29:26 -0500
Richard Damon <[email protected]> wrote:

H(P,P) is supposed to say what P(P) will do.

No,

So what arguments does one pass to H to find out is P(P) halts? If
it's not P and P, what is it? (Of course it is P and P, that's why
PO says that H(P,P) == 0 is correct /despite/ the fact that P(P)
halts.)

Any P that doesn't reference H.

/Flibble

This is the pathological self-reference set of combinations of H/P:
For every possible 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.

This is the halt deciding criteria that correctly decides that set:
halt decider (Olcott 2021) A halt decider accepts or rejects inputs on
the basis of the actual behavior of the direct execution or simulation
of these inputs.

It took me 16,000 hours since 2004 to boil it down to that.
All of my 18,459 messages are still out in comp.theory

My most recent paper on this subject (of four)
Halting problem undecidability and infinitely nested simulation (V2)
November 2021 PL Olcott

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

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

XPost: comp.theory, sci.logic, sci.math

On 11/18/2021 4:27 PM, Ben Bacarisse wrote:

Mr Flibble <[email protected]> writes:

On Thu, 18 Nov 2021 16:55:24 +0000
Ben Bacarisse <[email protected]> wrote:

Mr Flibble <[email protected]> writes:

On Thu, 18 Nov 2021 06:29:26 -0500
Richard Damon <[email protected]> wrote:

H(P,P) is supposed to say what P(P) will do.

No,

So what arguments does one pass to H to find out is P(P) halts? If
it's not P and P, what is it? (Of course it is P and P, that's why
PO says that H(P,P) == 0 is correct /despite/ the fact that P(P)
halts.)

Any P that doesn't reference H.

Not an answer. What arguments does one pass to H to find out if P(P) -- that's the P that has been posted numerous times -- halts?

Page(3) explains exactly how the set of pathological combinations of H/P
are correctly decided as not halting:

For every possible 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.

Halt Decider (Olcott 2021) A halt decider accepts or rejects inputs on
the basis of the actual behavior of the direct execution or simulation
of these inputs.


My most recent paper
Halting problem undecidability and infinitely nested simulation (V2)
November 2021 PL Olcott

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

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)