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. 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.
Crucially if your H cannot return an answer for an arbitrary
non-halting program in finite time then it isn't a halt decider.

/Flibble