On 11/12/21 8:42 PM, olcott wrote:
> 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.

Except that, BY DEFINITION, if H has aborted its simulation/direct
execution of its input, then it has NOT correctly simulated it.

Thus, the only machines that meet your premise, are machines that will
never abort the simulation/execution of P, and it has been shown that
these machine will never return the, in THIS case, correct value of 0.

ERGO, you proof fails.

You can not show a precisely specified H that actually does CORRECTLY
SIMULATE its input which it claims to be non-halting, and also return a
value. This is because BY DEFINITION, it takes infinite time to
correctly simulate a non-halting computation, and you can't do both
return an answer in finite time and still spend an infinite time to do
the correct simulation.

Your proposition is only true if H is a member of the empty set.

FAIL.

>
>
>> 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.
>>
>
>