On 6/9/22 6:37 PM, olcott wrote:
> On 6/9/2022 5:33 PM, Richard Damon wrote:
>> On 6/9/22 6:18 PM, olcott wrote:
>>> On 6/9/2022 5:15 PM, Mr Flibble wrote:
>>>> On Thu, 9 Jun 2022 17:09:08 -0500
>>>> olcott <NoOne@NoWhere.com> 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.
>>>>
>>>> If H never returns a value to P then H is not a halting decider; if H
>>>> returns a value of 0 to main() when P halts then H is not a halting
>>>> decider.
>>>>
>>>> H is not a halting decider; H is a simulation detector, S.
>>>>
>>>> /Flibble
>>>>
>>>
>>> In other words you are saying the infintely nested emulation only
>>> excutes for a few steps and then it stops on its own.
>>>
>>
>> No, the "infinitely nested emulation" halts when the first H(P,P) that
>> P(P) called aborts it simulation.
>
> When I tell you that an input only halts when it reaches its final state
> and I tell you this many hundreds of times because you are a God damned
> liar you pretend that I never said this.
>

Right, and when H(P,P) returns 0, the P that called it reaches its final
state/the ret instrucion.

The key is that the CORRECT simulation doesn't stop running just because
H aborts it simulation.