On 6/9/22 4:13 PM, olcott wrote:
> On 6/9/2022 2:57 PM, Richard Damon wrote:
>> On 6/9/22 3:52 PM, olcott wrote:
>>> On 6/9/2022 2:38 PM, Richard Damon wrote:
>>>>
>>>> On 6/9/22 3:26 PM, olcott wrote:
>>>>> On 6/9/2022 1:12 PM, Richard Damon wrote:
>>>>>> On 6/9/22 1:55 PM, olcott wrote:
>>>>>>> On 6/9/2022 12:46 PM, Mr Flibble wrote:
>>>>>>>> On Thu, 9 Jun 2022 12:39:32 -0500
>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>
>>>>>>>>> On 6/9/2022 12:28 PM, Mr Flibble wrote:
>>>>>>>>>> On Thu, 9 Jun 2022 12:15:24 -0500
>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>> On 6/9/2022 12:06 PM, Richard Damon wrote:
>>>>>>>>>>>> On 6/9/22 12:54 PM, olcott wrote:
>>>>>>>>>>>>> On 6/9/2022 11:34 AM, Richard Damon wrote:
>>>>>>>>>>>>>> On 6/9/22 11:47 AM, olcott wrote:
>>>>>>>>>>>>>>> void P(u32 x)
>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>      if (H(x, x))
>>>>>>>>>>>>>>>        HERE: goto HERE;
>>>>>>>>>>>>>>>      return;
>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>      P(P);
>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> _P()
>>>>>>>>>>>>>>> [000012e7](01)  55              push ebp
>>>>>>>>>>>>>>> [000012e8](02)  8bec            mov ebp,esp
>>>>>>>>>>>>>>> [000012ea](03)  8b4508          mov eax,[ebp+08]
>>>>>>>>>>>>>>> [000012ed](01)  50              push eax
>>>>>>>>>>>>>>> [000012ee](03)  8b4d08          mov ecx,[ebp+08]
>>>>>>>>>>>>>>> [000012f1](01)  51              push ecx
>>>>>>>>>>>>>>> [000012f2](05)  e880feffff      call 00001177 // call H
>>>>>>>>>>>>>>> [000012f7](03)  83c408          add esp,+08
>>>>>>>>>>>>>>> [000012fa](02)  85c0            test eax,eax
>>>>>>>>>>>>>>> [000012fc](02)  7402            jz 00001300
>>>>>>>>>>>>>>> [000012fe](02)  ebfe            jmp 000012fe
>>>>>>>>>>>>>>> [00001300](01)  5d              pop ebp
>>>>>>>>>>>>>>> [00001301](01)  c3              ret
>>>>>>>>>>>>>>> Size in bytes:(0027) [00001301]
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> _main()
>>>>>>>>>>>>>>> [00001307](01)  55              push ebp
>>>>>>>>>>>>>>> [00001308](02)  8bec            mov ebp,esp
>>>>>>>>>>>>>>> [0000130a](05)  68e7120000      push 000012e7 // push P
>>>>>>>>>>>>>>> [0000130f](05)  e8d3ffffff      call 000012e7 // call P
>>>>>>>>>>>>>>> [00001314](03)  83c404          add esp,+04
>>>>>>>>>>>>>>> [00001317](02)  33c0            xor eax,eax
>>>>>>>>>>>>>>> [00001319](01)  5d              pop ebp
>>>>>>>>>>>>>>> [0000131a](01)  c3              ret
>>>>>>>>>>>>>>> Size in bytes:(0020) [0000131a]
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>     machine   stack     stack     machine    assembly
>>>>>>>>>>>>>>>     address   address   data      code       language
>>>>>>>>>>>>>>>     ========  ========  ========  =========  =============
>>>>>>>>>>>>>>> [00001307][00102190][00000000] 55         push ebp
>>>>>>>>>>>>>>> [00001308][00102190][00000000] 8bec       mov ebp,esp
>>>>>>>>>>>>>>> [0000130a][0010218c][000012e7] 68e7120000 push 000012e7 //
>>>>>>>>>>>>>>> push P [0000130f][00102188][00001314] e8d3ffffff call
>>>>>>>>>>>>>>> 000012e7
>>>>>>>>>>>>>>> // call P [000012e7][00102184][00102190] 55         push ebp
>>>>>>>>>>>>>>>     // enter executed P
>>>>>>>>>>>>>>> [000012e8][00102184][00102190] 8bec       mov ebp,esp
>>>>>>>>>>>>>>> [000012ea][00102184][00102190] 8b4508     mov eax,[ebp+08]
>>>>>>>>>>>>>>> [000012ed][00102180][000012e7] 50         push eax      //
>>>>>>>>>>>>>>> push P [000012ee][00102180][000012e7] 8b4d08     mov
>>>>>>>>>>>>>>> ecx,[ebp+08] [000012f1][0010217c][000012e7] 51         push
>>>>>>>>>>>>>>> ecx      // push P [000012f2][00102178][000012f7] e880feffff
>>>>>>>>>>>>>>> call 00001177 // call H
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Begin Local Halt Decider Simulation   Execution Trace Stored
>>>>>>>>>>>>>>> at:212244 [000012e7][00212230][00212234] 55          push
>>>>>>>>>>>>>>> ebp
>>>>>>>>>>>>>>>     // enter emulated P
>>>>>>>>>>>>>>> [000012e8][00212230][00212234] 8bec        mov ebp,esp
>>>>>>>>>>>>>>> [000012ea][00212230][00212234] 8b4508      mov eax,[ebp+08]
>>>>>>>>>>>>>>> [000012ed][0021222c][000012e7] 50          push eax      //
>>>>>>>>>>>>>>> push P [000012ee][0021222c][000012e7] 8b4d08      mov
>>>>>>>>>>>>>>> ecx,[ebp+08] [000012f1][00212228][000012e7] 51          push
>>>>>>>>>>>>>>> ecx      // push P [000012f2][00212224][000012f7] e880feffff
>>>>>>>>>>>>>>> call 00001177 // call H
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> So, by what instruction reference manual is a call 00001177
>>>>>>>>>>>>>> followedby the execution of the instruction at 000012e7.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Your "CPU" is broken, or emulation incorrect.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>>>> [000012e7][0025cc58][0025cc5c] 55          push ebp      //
>>>>>>>>>>>>>>> enter emulated P
>>>>>>>>>>>>>>> [000012e8][0025cc58][0025cc5c] 8bec        mov ebp,esp
>>>>>>>>>>>>>>> [000012ea][0025cc58][0025cc5c] 8b4508      mov eax,[ebp+08]
>>>>>>>>>>>>>>> [000012ed][0025cc54][000012e7] 50          push eax      //
>>>>>>>>>>>>>>> push P [000012ee][0025cc54][000012e7] 8b4d08      mov
>>>>>>>>>>>>>>> ecx,[ebp+08] [000012f1][0025cc50][000012e7] 51          push
>>>>>>>>>>>>>>> ecx      // push P [000012f2][0025cc4c][000012f7] e880feffff
>>>>>>>>>>>>>>> call 00001177 // call H Local Halt Decider: Infinite
>>>>>>>>>>>>>>> Recursion
>>>>>>>>>>>>>>> Detected Simulation Stopped
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> It is completely obvious that when H(P,P) correctly emulates
>>>>>>>>>>>>>>> its input that it must emulate the first seven
>>>>>>>>>>>>>>> instructions of
>>>>>>>>>>>>>>> P. Because the seventh instruction of P repeats this
>>>>>>>>>>>>>>> process we
>>>>>>>>>>>>>>> know with complete certainty that the correct and complete
>>>>>>>>>>>>>>> emulation of P by H would never reach its final “ret”
>>>>>>>>>>>>>>> instruction, thus never halts.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Problem, the 7th intruction DOESN't "Just repeat the
>>>>>>>>>>>>>> procedure",
>>>>>>>>>>>>>> because that H always has the option to abort its simulation,
>>>>>>>>>>>>>> just like this onne did, and return to its P and see it halt.
>>>>>>>>>>>>> THAT YOU ARE SIMPLY TOO STUPID TO UNDERSTAND THIS IS NO ACTUAL
>>>>>>>>>>>>> REBUTTAL AT ALL:
>>>>>>>>>>>>>
>>>>>>>>>>>>> The partial correct x86 emulation of the input to H(P,P)
>>>>>>>>>>>>> conclusively proves that the complete and correct x86
>>>>>>>>>>>>> emulation
>>>>>>>>>>>>> would never stop running.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> You SAY that, but you don't answer the actual questions
>>>>>>>>>>>> about HOW.
>>>>>>>>>>>
>>>>>>>>>>> THAT YOU ARE SIMPLY TOO STUPID TO UNDERSTAND THIS IS NO EVIDENCE
>>>>>>>>>>> WHAT-SO-EVER THAT I DID NOT COMPLETELY PROVE THAT THE CORRECT
>>>>>>>>>>> PARTIAL EMULATION OF THE INPUT TO H(P,P) CONCLUSIVELY PROVES
>>>>>>>>>>> THAT
>>>>>>>>>>> THE CORRECT AND COMPLETE X86 EMULATION OF THE INPUT TO H(P,P)
>>>>>>>>>>> WOULD NEVER STOP RUNNING.
>>>>>>>>>>>
>>>>>>>>>>> It is completely obvious that when H(P,P) correctly emulates its
>>>>>>>>>>> input that it must emulate the first seven instructions of P.
>>>>>>>>>>> Because the seventh instruction of P repeats this process we
>>>>>>>>>>> know
>>>>>>>>>>> with complete certainty that the correct and complete
>>>>>>>>>>> emulation of
>>>>>>>>>>> P by H would never reach its final “ret” instruction, thus never
>>>>>>>>>>> halts.
>>>>>>>>>>
>>>>>>>>>> If P should have halted (i.e. no infinite loop) then your
>>>>>>>>>> simulation
>>>>>>>>>> detector, S (not H), gets the answer wrong.  You S is NOT a
>>>>>>>>>> halting
>>>>>>>>>> decider.
>>>>>>>>>>
>>>>>>>>>> /Flibble
>>>>>>>>>
>>>>>>>>> THAT YOU ARE SIMPLY TOO STUPID TO UNDERSTAND THIS IS NO ACTUAL
>>>>>>>>> REBUTTAL AT ALL.
>>>>>>>>>
>>>>>>>>> _P()
>>>>>>>>> [00001352](01)  55              push ebp
>>>>>>>>> [00001353](02)  8bec            mov ebp,esp
>>>>>>>>> [00001355](03)  8b4508          mov eax,[ebp+08]
>>>>>>>>> [00001358](01)  50              push eax      // push P
>>>>>>>>> [00001359](03)  8b4d08          mov ecx,[ebp+08]
>>>>>>>>> [0000135c](01)  51              push ecx      // push P
>>>>>>>>> [0000135d](05)  e840feffff      call 000011a2 // call H
>>>>>>>>> [00001362](03)  83c408          add esp,+08
>>>>>>>>> [00001365](02)  85c0            test eax,eax
>>>>>>>>> [00001367](02)  7402            jz 0000136b
>>>>>>>>> [00001369](02)  ebfe            jmp 00001369
>>>>>>>>> [0000136b](01)  5d              pop ebp
>>>>>>>>> [0000136c](01)  c3              ret
>>>>>>>>> Size in bytes:(0027) [0000136c]
>>>>>>>>>
>>>>>>>>> It is completely obvious that when H(P,P) correctly emulates its
>>>>>>>>> input that it must emulate the first seven instructions of P.
>>>>>>>>> Because
>>>>>>>>> the seventh instruction of P repeats this process we know with
>>>>>>>>> complete certainty that the correct and complete emulation of P
>>>>>>>>> by H
>>>>>>>>> would never reach its final “ret” instruction, thus never halts.
>>>>>>>>
>>>>>>>> We are going around and around and around in circles. I will try
>>>>>>>> again:
>>>>>>>>
>>>>>>>> If you replace the opcodes "EB FE" at 00001369 with the opcodes
>>>>>>>> "90 90"
>>>>>>>> then your H gets the answer wrong: P should have halted.
>>>>>>>>
>>>>>>>> /Flibble
>>>>>>>>
>>>>>>>
>>>>>>> As I already said before this is merely your cluelessness that
>>>>>>> when H(P,P) is invoked the correct x86 emulation of the input to
>>>>>>> H(P,P) makes and code after [0000135d] unreachable.
>>>>>>
>>>>>> Wrong, because when that H return the value 0, it will get there.
>>>>> Like I said people that are dumber than a box of rocks won't be
>>>>> able to correctly understand this.
>>>>>
>>>>> When H(P,P) is invoked the correctly emulated input to H(P,P)
>>>>> cannot possibly reach any instruction beyond [0000135d].
>>>>
>>>> So, you are defining that you H(P,P) never returns because it is
>>>> caught in the infinite rcursion.
>>>>
>>>> Thats fine, just says it can't be the correctly answering decider
>>>> you claim it to be.
>>>
>>> I have corrected you on this too many times.
>>>
>>
>> How. You need to define what H(P,P) actually does.
>
> I have explained that too many times.
>
> To understand that H(P,P)==0 is correct we only need to know that H
> performs a correct x86 emulation of its input and then examine the
> execution trace.

And a CORRECT emulation of the code will Halt if H(P,P) returns 0, which
it can only do if it does not actually do a correct emulation

>
> There is no sense explaining HOW H determines that H(P,P)==0 is correct
> until after there is a universal consensus that H(P,P)==0 is correct.
>

It is correct ONLY if H(P,P) doesn't return 0.

Note, by definition, a CORRECT emuluation never ends for a non-halting
input.

Thus, for H to say its input is non-halting, H can NOT have actually
done a correct emulation.

It might have been able to prove the input was non-halting from its
partial simulation, as you show with infinite loop, but its emulation is
not BY DEFINITION correct.

For P, once you stipulate that H(P,P) will return 0, we can actually
prove that the correct emulation of that input will Halt. so the return
value of 0 can not be correct.

To claim that H can do BOTH a correct emulation and return the value 0
means, in effect, that you are declairing that infinity is a finite
number. You are stuck in your own liar's paradox.

The fact that you refuse to see this, just shows the limitations of your
mental capability.