On 2021-08-09 16:47, olcott wrote:
> On 8/9/2021 5:43 PM, André G. Isaak wrote:
>> On 2021-08-09 16:21, olcott wrote:
>>> On 8/9/2021 5:17 PM, André G. Isaak wrote:
>>>> On 2021-08-09 15:12, olcott wrote:
>>>>> On 8/9/2021 2:38 PM, André G. Isaak wrote:
>>>>>> On 2021-08-09 10:57, olcott wrote:
>>>>>>> On 8/8/2021 1:50 PM, André G. Isaak wrote:
>>>>>>>> On 2021-08-06 22:23, olcott wrote:
>>>>>>>>> On 8/6/2021 10:55 PM, André G. Isaak wrote:
>>>>>>>>>> On 2021-08-06 09:59, olcott wrote:
>>>>>>>>
>>>>>>>>>> Yes, but bear in mind that 'halting' refers to Turing Machines
>>>>>>>>>> operating on a specific input. It does not refer to
>>>>>>>>>> simulations or what happens inside a halting decider. It
>>>>>>>>>> refers *only* to actual computations, i.e. an actual Turing
>>>>>>>>>> Machine operating on an actual input string.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> So yet again you prove that you are totally clueless that pure
>>>>>>>>> simulations are computationally equivalent to direct executions ?
>>>>>>>>
>>>>>>>> Your H is not a pure simulator
>>>>>>>>
>>>>>>>
>>>>>>> // Simplified Linz Ĥ (Linz:1990:319)
>>>>>>> // Strachey(1965) CPL translated to C
>>>>>>> void P(u32 x)
>>>>>>> {
>>>>>>>    if (H(x, x))
>>>>>>>      HERE: goto HERE;
>>>>>>> }
>>>>>>>
>>>>>>> _P()
>>>>>>> [00000d02](01)  55          push ebp
>>>>>>> [00000d03](02)  8bec        mov ebp,esp
>>>>>>> [00000d05](03)  8b4508      mov eax,[ebp+08]
>>>>>>> [00000d08](01)  50          push eax       // push 2nd Param
>>>>>>> [00000d09](03)  8b4d08      mov ecx,[ebp+08]
>>>>>>> [00000d0c](01)  51          push ecx       // push 1st Param
>>>>>>> [00000d0d](05)  e870feffff  call 00000b82  // call H
>>>>>>> [00000d12](03)  83c408      add esp,+08
>>>>>>> [00000d15](02)  85c0        test eax,eax
>>>>>>> [00000d17](02)  7402        jz 00000d1b
>>>>>>> [00000d19](02)  ebfe        jmp 00000d19
>>>>>>> [00000d1b](01)  5d          pop ebp
>>>>>>> [00000d1c](01)  c3          ret
>>>>>>> Size in bytes:(0027) [00000d1c]
>>>>>>>
>>>>>>>      machine   stack     stack     machine     assembly
>>>>>>>      address   address   data      code        language
>>>>>>>      ========  ========  ========  =========   =============
>>>>>>> ...[00000d0d][00101829][00000d12] e870feffff  call 00000b82  //
>>>>>>> call H
>>>>>>>
>>>>>>> Begin Local Halt Decider Simulation at Machine Address:d02
>>>>>>> ...[00000d02][002118f1][002118f5] 55          push ebp
>>>>>>> ...[00000d03][002118f1][002118f5] 8bec        mov ebp,esp
>>>>>>> ...[00000d05][002118f1][002118f5] 8b4508      mov eax,[ebp+08]
>>>>>>> ...[00000d08][002118ed][00000d02] 50          push eax       //
>>>>>>> push P
>>>>>>> ...[00000d09][002118ed][00000d02] 8b4d08      mov ecx,[ebp+08]
>>>>>>> ...[00000d0c][002118e9][00000d02] 51          push ecx       //
>>>>>>> push P
>>>>>>> ...[00000d0d][002118e5][00000d12] e870feffff  call 00000b82  //
>>>>>>> call H
>>>>>>> ...[00000d02][0025c319][0025c31d] 55          push ebp
>>>>>>> ...[00000d03][0025c319][0025c31d] 8bec        mov ebp,esp
>>>>>>> ...[00000d05][0025c319][0025c31d] 8b4508      mov eax,[ebp+08]
>>>>>>> ...[00000d08][0025c315][00000d02] 50          push eax       //
>>>>>>> push P
>>>>>>> ...[00000d09][0025c315][00000d02] 8b4d08      mov ecx,[ebp+08]
>>>>>>> ...[00000d0c][0025c311][00000d02] 51          push ecx       //
>>>>>>> push P
>>>>>>> ...[00000d0d][0025c30d][00000d12] e870feffff  call 00000b82  //
>>>>>>> call H
>>>>>>> Local Halt Decider: Infinite Recursion Detected Simulation Stopped
>>>>>>>
>>>>>>> The fact that the execution trace of the simulation of P(P) on
>>>>>>> page 6 perfectly matches its source-code on page 5 conclusively
>>>>>>> proves that this execution trace performed by H is a pure
>>>>>>> simulation of P(P). There is no correct basis for disagreement,
>>>>>>> therefore anyone disagreeing either does not know the x86
>>>>>>> language or they are simply lying.
>>>>>>
>>>>>> You have a *partial trace* and *partial source code*. Neither
>>>>>> shows what happens at B82.
>>>>>>
>>>>>
>>>>> if int add(int x, int y) returns 5 on add(2,3) we know for sure
>>>>> that add was correct on that input.
>>>>
>>>> That is a poor analogy since 5 actually *is* the correct answer to 2+3.
>>>>
>>>> We know that P(P) *does* halt, which means that if H(P, P) returns
>>>> false we know for sure that H was *incorrect* on that input.
>>>
>>> P(P) only halts because H(P,P) correctly decides that its input never
>>> halts and aborts this input on that basis.
>>
>> X only halts because Y IMPLIES that X halts. That's basic logic.
>>
>> The definition of halting does not refer at all to the *reason* why a
>> particular computation halts.
>>
>
> The P that halts seems to contradict that H(P,P)==0 is correct yet it is
> verifiable that H(P,P)==0 is correct.

P(P) is either in the set of halting computations or it is not. It can't
be both.

Since halting is a property defined *solely* in terms of the behaviour
of the *actual* computation in question, we know that P(P) is in this
set. Therefore H(P, P) == 0 *cannot* be verifiably correct.

> That you keep ignoring this means that you are dishonest.

I am not ignoring this. I am asserting that it is false.

To consider your earlier poor analogy:

"if int add(int x, int y) returns 5 on add(2,3) we know for sure that
add was correct on that input."

The above as stated leaves out a critical piece. if int add(int x, int
y) returns 5 on add(2,3) we know for sure that add was correct on that
input *because* we know independently that 5 is actually the correct answer.

What you are claiming is more analogous to the claim that:

if int add(int x, int y) returns 9 on add(2,3) we know for sure that add
was correct on that input.

Which of course is rubbish if add(x, y) is purported to do what its name
suggests.

André

>> "The airplane crashed "only" because it ran out of fuel" IMPLIES that
>> the airplane crashed.
>>
>> "The man was arrested "only" because the police chief held a grudge"
>> IMPLIES that the man was arrested.
>>
>> Why you think that 'halting' works differently from these examples
>> remains a mystery.
>>
>> If you want to determine the correct answer to "does P(P) halt?", you
>> need look only at the behaviour of P(P), not at your traces. In fact,
>> you *shouldn't* look at anything other than the behaviour of P(P)
>> because halting is defined *entirely* in terms of the behaviour of P(P).
>>
>> If it is the case that P(P) "only" halts because H(P, P) returns
>> false, it still halts, which means that H(P, P) *incorrectly* returns
>> false.
>>
>>> Until you pay enough attention to see and acknowledge this I will
>>> simply assume that you are dishonest.
>>
>> As is the case with virtually all of your terms, I assume you also
>> have some private definition of 'dishonest'.

--
To email remove 'invalid' & replace 'gm' with well known Google mail
service.