On 11/12/2021 7:13 PM, Richard Damon wrote:
> On 11/12/21 7:52 PM, olcott wrote:
>> On 11/12/2021 6:39 PM, Richard Damon wrote:
>>>
>>> On 11/12/21 6:43 PM, olcott wrote:
>>>> 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.
>>>
>>> Whch just proves that H can not prove Halting. It does NOT prove
>>> non-halting, except for the case when H NEVER aborts, and it that
>>> case it never gives the answer.
>>>
>>
>> It proves no such thing.
>>
>> If the input to (the precisely specified) H(P,P) never halts then it
>> always correct for H to report that the input to this H(P,P) never halts.
>>
>
> WRONG. FIRST: ERROR OF CATEGORY. INPUTS DON'T HAVE A HALTING PROPERTY,
> only machines do.
>

If the correctly simulated or directly executed input to (the precisely
specified) H(P,P) never halts then it always correct for H to report
that the input to this H(P,P) never halts.

If X is a Y then it is always correct to say X is a Y.

> Only reasonable interpretations of this statement is either:
> 1) The behavior of Computation (Machine + Input) that this input
> represents,
> 2) The behavior of a UTM/pure simulation of this input (NOT a simulation
> that aborts its simulation).
>
> With That:
>
> If your precisely specified H(P,P) is one that returns 0 from the call
> to H(P,P) then it can easily be shown that P(P) for that H will halt.
>
> Yes, H doesn't see that halting because it aborts its simulation before
> it gets there, but the machine that the input represents does.
>
> Yes, P(P) is non-halting if H(P,P) doesn't return, but then H didn't
> give the needed answer so this case is not a counter example either.
>
>
> FAIL.
>

--
Copyright 2021 Pete Olcott

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