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.

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