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.

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.