On Thu, 9 Jun 2022 17:18:38 -0500
olcott <NoOne@NoWhere.com> 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.
I am saying that your H is not a halting decider; I am saying that your
H is just a simulation detector, S.

/Flibble