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

On 11/12/2021 5:13 PM, Richard Damon wrote:

On 11/12/21 5:53 PM, olcott wrote:

On 11/12/2021 4:36 PM, Richard Damon wrote:

On 11/12/21 5:24 PM, olcott wrote:

On 11/12/2021 4:13 PM, Richard Damon wrote:

On 11/12/21 5:07 PM, olcott wrote:

On 11/12/2021 4:00 PM, Richard Damon wrote:

On 11/12/21 3:11 PM, olcott wrote:

#include <stdint.h>
typedef void (*ptr)();

int H(ptr x, ptr y)
{
   x(y);
   return 1;
}

// Minimal essence of Linz(1990) Ĥ
// and Strachey(1965) P (see below)
void P(ptr x)
{
   H(x, x);
}

int main(void)
{
   H(P, P);
}

It is obvious that the direct execution of the above code never >>>>>>>> halts because it is infinitely recursive. It is equally obvious >>>>>>>> that when H performs a correct pure simulation of its input
(instead of directly executing it) that its input never halts. >>>>>>>>
_P()
[00001a5e](01)  55              push ebp
[00001a5f](02)  8bec            mov ebp,esp
[00001a61](03)  8b4508          mov eax,[ebp+08]
[00001a64](01)  50              push eax        // push P
[00001a65](03)  8b4d08          mov ecx,[ebp+08]
[00001a68](01)  51              push ecx        // push P
[00001a69](05)  e810000000      call 00001a7e   // call H >>>>>>>> [00001a6e](03)  83c408          add esp,+08
[00001a71](01)  5d              pop ebp
[00001a72](01)  c3              ret
Size in bytes:(0021) [00001a72]

Because there is nothing that H can possibly do to cause or
enable P to reach its final state at 1a72 we correctly conclude >>>>>>>> that the input to H(P,P) never halts.

Wrong. IF H does abort and return 0 then the ACTUAL running of P >>>>>>> will reach that address, and the actual running of P is what
matters.

All you have shown is that it is impossible for H to PROVE that P >>>>>>> will be halting, not that P isn't Halting.

I have shown that P always specifies infinite recursion whether or >>>>>> not this infinite recursion is aborted, therefore H(P,P)==0 is
always correct.

No, you haven't.

You logic makes the unsound step of FIRST assuming that H never
aborts its operation, and THEN has H do an abort.

If you DO have a valid proof that P(P) is non-halting when H(P,P)
return 0 then you have just proved you logic system to be
inconsistent as it can also be proved the if H(P,P) returns 0, that
P(P) halts.

A system that can prove a statement and its complement is
inconsestent, and logically worthless.

All rebuttals must take this form:
Find an invocation of H(P,P) at machine address 00001a7e such that >>>>>> the simulation or execution of (the exact byte sequence of) P
reaches its final address of 00001a72.

If no rebuttals exist this conclusively proves that H(P,P)==0 for
every H in the unverse.

WRONG CRITERIA.

Just proves you are looking at POOP.

The REAL halting problems asks what P(P) actually does.

I proven beyond all possible doubt that the real P is infinitely
recursive in my latest example where H directly executes its input

Yes, *IF* H just directly executes its input, then P(P) will be
non-Halting,

The ultimate measure of the halt status of an input is its behavior
when directly executed.

but H(P,P) never returns 0, so it is not a counter example.

The fact that for every possible H that can possibly exist at at
machine address 00001a7e the simulation or execution of (the exact
byte sequence of) P never reaches its final address of 00001a72
conclusively proves that the input to H(P,P) never halts.

The input to H(P,P) never halts therefore when H returns 0 it is
always correct.

No, you have a fundamental error in your logic,

FIRST, as has been explained before, but you just ignorantly ignore,
'inputs' do not have behavior, and as such do not halt or be
non-halting. Halting is a property of COMPUTATIONS, not inputs. Thus
your statement is proved conclusively FALSE because it makes an error in category (Maybe you don't understand these terms, but repeatedly
ignoring them doesn't help your cause).

Because the simulated or executed input to every H(P,P) invoked at
machine address 00001a7e with the byte sequence of the machine code of P
as its input never reaches the final address of P at 00001a72 it is
always correct for this H(P,P) to return 0.

All rebuttals must take this form:
Find an invocation of H(P,P) at machine address 00001a7e such that the simulation or execution of (the exact byte sequence of) P reaches its
final address of 00001a72.

Now that I have finally made my claim 100% perfectly precise when any
fake "rebuttal" side steps this claim with the strawman error (dishonest
dodge) it is very easy to tell.

--
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre
minds." Einstein

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