On 6/9/22 6:09 PM, olcott wrote:
> On 6/9/2022 4:54 PM, Richard Damon wrote:
>> On 6/9/22 5:29 PM, olcott wrote:
>>> On 6/9/2022 4:13 PM, Richard Damon wrote:
>>>>
>>>> On 6/9/22 5:00 PM, olcott wrote:
>>>>> On 6/9/2022 3:25 PM, Richard Damon wrote:
>>>>>> 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
>>>>>>
>>>>>
>>>>> The correctly emulated input to H(P,P) never gets past its machine
>>>>> address [0000135d].
>>>>>
>>>>>
>>>>
>>>> Only if H actually doesn't return 0. Yes, H can't correctly return 0
>>>> if it correctly emulates its input, but you can't drop that
>>>> requirement.
>>>
>>> void P(u32 x)
>>> {
>>>    if (H(x, x))
>>>      HERE: goto HERE;
>>>    return;
>>> }
>>>
>>> int main()
>>> {
>>>    Output("Input_Halts = ", H((u32)P, (u32)P));
>>> }
>>>
>>> When H returns 0 it does not returns 0 to P it returns 0 to main().
>>
>> But it also return 0 to the computation P(P), maybe not the copy that
>> it is simulating, since it aborts that before it get to it,
>
> Finally you are not stupid or deceptive.
>
>
>

So, you agree that your H(P,P) that returns a 0, claiming it to be
correct, also returns that 0 to P(P) and thus P(P) Halts, and thus
H(P,P) is INCORRECT in saying that its input represents a non-halting
computation?