On Fri, 10 Jun 2022 08:43:48 -0500
olcott <NoOne@NoWhere.com> wrote:

> On 6/10/2022 8:35 AM, Mr Flibble wrote:
> > On Fri, 10 Jun 2022 08:33:27 -0500
> > olcott <NoOne@NoWhere.com> wrote:
> >
> >> On 6/10/2022 8:29 AM, Mr Flibble wrote:
> >>> On Fri, 10 Jun 2022 08:27:28 -0500
> >>> olcott <NoOne@NoWhere.com> wrote:
> >>>
> >>>> On 6/10/2022 8:23 AM, Mr Flibble wrote:
> >>>>> On Fri, 10 Jun 2022 08:05:57 -0500
> >>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>
> >>>>>> On 6/10/2022 6:11 AM, Mr Flibble wrote:
> >>>>>>> On Thu, 9 Jun 2022 17:35:05 -0500
> >>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>
> >>>>>>>> On 6/9/2022 5:27 PM, Mr Flibble wrote:
> >>>>>>>>> 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
> >>>>>>>>>
> >>>>>>>>
> >>>>>>>> You are saying that you simply "don't believe in" simulating
> >>>>>>>> halt deciders.
> >>>>>>>
> >>>>>>> You haven't got a simulating halt decider, what you have got
> >>>>>>> is a simulation detector.
> >>>>>>>
> >>>>>>> /Flibble
> >>>>>>>
> >>>>>>
> >>>>>> It is an easily verified fact that H does correctly decide the
> >>>>>> halt status of its input.
> >>>>>>
> >>>>>> void Infinite_Loop()
> >>>>>> {
> >>>>>> HERE: goto HERE;
> >>>>>> }
> >>>>>>
> >>>>>> int main()
> >>>>>> {
> >>>>>> Output("Input_Halts = ", H0(Infinite_Loop));
> >>>>>> }
> >>>>>>
> >>>>>> _Infinite_Loop()
> >>>>>> [00001342](01) 55 push ebp
> >>>>>> [00001343](02) 8bec mov ebp,esp
> >>>>>> [00001345](02) ebfe jmp 00001345
> >>>>>> [00001347](01) 5d pop ebp
> >>>>>> [00001348](01) c3 ret
> >>>>>> Size in bytes:(0007) [00001348]
> >>>>>>
> >>>>>> _main()
> >>>>>> [00001372](01) 55 push ebp
> >>>>>> [00001373](02) 8bec mov ebp,esp
> >>>>>> [00001375](05) 6842130000 push 00001342
> >>>>>> [0000137a](05) e833fdffff call 000010b2
> >>>>>> [0000137f](03) 83c404 add esp,+04
> >>>>>> [00001382](01) 50 push eax
> >>>>>> [00001383](05) 6823040000 push 00000423
> >>>>>> [00001388](05) e8e5f0ffff call 00000472
> >>>>>> [0000138d](03) 83c408 add esp,+08
> >>>>>> [00001390](02) 33c0 xor eax,eax
> >>>>>> [00001392](01) 5d pop ebp
> >>>>>> [00001393](01) c3 ret
> >>>>>> Size in bytes:(0034) [00001393]
> >>>>>>
> >>>>>> machine stack stack machine assembly
> >>>>>> address address data code language
> >>>>>> ======== ======== ======== ========= ============> >>>>>> [00001372][0010228f][00000000] 55 push ebp
> >>>>>> [00001373][0010228f][00000000] 8bec mov ebp,esp
> >>>>>> [00001375][0010228b][00001342] 6842130000 push 00001342 // push
> >>>>>> _Infinite_Loop
> >>>>>> [0000137a][00102287][0000137f] e833fdffff call 000010b2 // call
> >>>>>> H0
> >>>>>>
> >>>>>> Begin Local Halt Decider Simulation Execution Trace Stored
> >>>>>> at:212343 [00001342][00212333][00212337] 55 push ebp
> >>>>>> [00001343][00212333][00212337] 8bec mov ebp,esp
> >>>>>> [00001345][00212333][00212337] ebfe jmp 00001345
> >>>>>> [00001345][00212333][00212337] ebfe jmp 00001345
> >>>>>> Local Halt Decider: Infinite Loop Detected Simulation Stopped
> >>>>>>
> >>>>>> [0000137f][0010228f][00000000] 83c404 add esp,+04
> >>>>>> [00001382][0010228b][00000000] 50 push eax
> >>>>>> [00001383][00102287][00000423] 6823040000 push 00000423
> >>>>>> [00001388][00102287][00000423] e8e5f0ffff call 00000472
> >>>>>> Input_Halts = 0
> >>>>>> [0000138d][0010228f][00000000] 83c408 add esp,+08
> >>>>>> [00001390][0010228f][00000000] 33c0 xor eax,eax
> >>>>>> [00001392][00102293][00100000] 5d pop ebp
> >>>>>> [00001393][00102297][00000004] c3 ret
> >>>>>> Number of Instructions Executed(680)
> >>>>>>
> >>>>>> int Sum(int X, int Y)
> >>>>>> {
> >>>>>> return X + Y;
> >>>>>> }
> >>>>>>
> >>>>>> int main()
> >>>>>> {
> >>>>>> Output("Input_Halts = ", H2(Sum, 3, 4));
> >>>>>> }
> >>>>>>
> >>>>>> _Sum()
> >>>>>> [000012b6](01) 55 push ebp
> >>>>>> [000012b7](02) 8bec mov ebp,esp
> >>>>>> [000012b9](03) 8b4508 mov eax,[ebp+08]
> >>>>>> [000012bc](03) 03450c add eax,[ebp+0c]
> >>>>>> [000012bf](01) 5d pop ebp
> >>>>>> [000012c0](01) c3 ret
> >>>>>> Size in bytes:(0011) [000012c0]
> >>>>>>
> >>>>>> _main()
> >>>>>> [00001316](01) 55 push ebp
> >>>>>> [00001317](02) 8bec mov ebp,esp
> >>>>>> [00001319](02) 6a04 push +04
> >>>>>> [0000131b](02) 6a03 push +03
> >>>>>> [0000131d](05) 68b6120000 push 000012b6
> >>>>>> [00001322](05) e85ffaffff call 00000d86
> >>>>>> [00001327](03) 83c40c add esp,+0c
> >>>>>> [0000132a](01) 50 push eax
> >>>>>> [0000132b](05) 6807040000 push 00000407
> >>>>>> [00001330](05) e821f1ffff call 00000456
> >>>>>> [00001335](03) 83c408 add esp,+08
> >>>>>> [00001338](02) 33c0 xor eax,eax
> >>>>>> [0000133a](01) 5d pop ebp
> >>>>>> [0000133b](01) c3 ret
> >>>>>> Size in bytes:(0038) [0000133b]
> >>>>>>
> >>>>>> machine stack stack machine assembly
> >>>>>> address address data code language
> >>>>>> ======== ======== ======== ========= ============> >>>>>> ...[00001316][001021d7][00000000] 55 push ebp
> >>>>>> ...[00001317][001021d7][00000000] 8bec mov ebp,esp
> >>>>>> ...[00001319][001021d3][00000004] 6a04 push +04
> >>>>>> ...[0000131b][001021cf][00000003] 6a03 push +03
> >>>>>> ...[0000131d][001021cb][000012b6] 68b6120000 push 000012b6
> >>>>>> ...[00001322][001021c7][00001327] e85ffaffff call 00000d86
> >>>>>>
> >>>>>> Begin Local Halt Decider Simulation Execution Trace Stored
> >>>>>> at:21228b ...[000012b6][00212273][00212277] 55
> >>>>>> push ebp ...[000012b7][00212273][00212277] 8bec mov
> >>>>>> ebp,esp ...[000012b9][00212273][00212277] 8b4508 mov
> >>>>>> eax,[ebp+08] ...[000012bc][00212273][00212277] 03450c
> >>>>>> add eax,[ebp+0c] ...[000012bf][00212277][00000e54] 5d
> >>>>>> pop ebp ...[000012c0][0021227b][00000003] c3
> >>>>>> ret ...[00001327][001021d7][00000000] 83c40c add
> >>>>>> esp,+0c ...[0000132a][001021d3][00000001] 50 push
> >>>>>> eax ...[0000132b][001021cf][00000407] 6807040000 push
> >>>>>> 00000407 ---[00001330][001021cf][00000407] e821f1ffff
> >>>>>> call 00000456 Input_Halts = 1
> >>>>>> ...[00001335][001021d7][00000000] 83c408 add esp,+08
> >>>>>> ...[00001338][001021d7][00000000] 33c0 xor eax,eax
> >>>>>> ...[0000133a][001021db][00100000] 5d pop ebp
> >>>>>> ...[0000133b][001021df][00000004] c3 ret
> >>>>>> Number of Instructions Executed(660)
> >>>>>
> >>>>> All you are showing here is that your H can decide the halt
> >>>>> status of two trivial cases however you have not shown that H
> >>>>> can decide the halt status of non-trivial cases.
> >>>>>
> >>>>
> >>>> You said:
> >>>> "You haven't got a simulating halt decider"
> >>>> Apologize and we can move on.
> >>>
> >>> I posted four paragraphs but you ignored three of them. Lets try
> >>> again.
> >>
> >> IF YOU DON'T APOLOGIZE THEN WE CANNOT MOVE ON !!!
> >
> > It seems I need to try again. Perhaps it will help if I combine the
> > four paragraphs into a single paragraph:
> >
> > All you are showing here is that your H can decide the halt status
> > of two trivial cases however you have not shown that H can decide
> > the halt status of non-trivial cases.
>
> H is a halt decider for a subset of its inputs.
> H is a halt decider for P.
> When H is a halt decider for P all of the conventional halting
> problem proofs have been refuted.

For H to be a halt decider it needs to be a halt decider for all inputs
not a subset.

>
> > Publish the source code of your halt
> > decider so we can see what classes of programs your H can decide. I
> > am interested in deciding the halt status of programs containing
> > non-trivial branching logic predicated on arbitrary program input.
>
> These are out-of-scope.

You may assert this but that doesn't make your assertion true. If they
are out-of-scope then your H is out of scope of the Halting Problem.

>
> > Crucially if your H cannot return an answer for an arbitrary
> > non-halting program in finite time then it isn't a halt decider.
>
> One can either say that H is a halt decider for a subset of its
> inputs or that H is a halt determiner. As long as H(P,P) correctly
> decides its input all of the conventional HP proofs have been refuted.

If we are to make progress you need to publish the code of your
infinite loop detector. I suspect that you refuse to do this as you
know it is either a trivial pattern matcher or relies on machine state
(i.e. CPU registers and RAM) being unchanged during emulation of a
program loop which is an naively erroneous approach.

/Flibble