On 8/9/2021 8:47 PM, André G. Isaak wrote:
> 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.
>

_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

We can see that the above is a pure simulation of P on input P.
We can see that the above cannot possibly stop running unless H aborts
its simulation of P on input P.

We can see that even if H does aborts its simulation of P on input P
that P never reaches its final state, thus never halts even though its
stops running.

Until you acknowledge these things or prove that the above P does reach
its final state you are simply a liar. Proving that a different P
reaches its final state is a dishonest dodge, thus also dishonest.
I am only interested in an honest dialogue.

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

--
Copyright 2021 Pete Olcott

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