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

> On 6/10/2022 9:37 AM, Mr Flibble wrote:
> > On Fri, 10 Jun 2022 09:32:47 -0500
> > olcott <NoOne@NoWhere.com> wrote:
> >
> >> On 6/10/2022 9:21 AM, Mr Flibble wrote:
> >>> On Fri, 10 Jun 2022 09:15:29 -0500
> >>> olcott <NoOne@NoWhere.com> wrote:
> >>>
> >>>> On 6/10/2022 9:03 AM, Mr Flibble wrote:
> >>>>> On Fri, 10 Jun 2022 08:59:17 -0500
> >>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>
> >>>>>> On 6/10/2022 8:51 AM, Mr Flibble wrote:
> >>>>>>> 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.
> >>>>>>
> >>>>>> If you can't understand 14 lines of code then this conclusively
> >>>>>> proves that you won't understand hundreds of pages of code.
> >>>>>>
> >>>>>> Because people here are only interested in rebuttal and don't
> >>>>>> give a rat's ass about an honest dialogue I make the price of a
> >>>>>> continued dialogue key points of mutual agreement.
> >>>>>>
> >>>>>> If you don't understand that H(P,P)==0 is correct then
> >>>>>> providing the source code will only provide the means for
> >>>>>> denigration based on lack of comprehension. I absolutely will
> >>>>>> not tolerate that.
> >>>>>
> >>>>> If we are to make progress you need to publish the source code
> >>>>> of how your infinite loop detector works as your disassembly
> >>>>> traces DO NOT provide that information.
> >>>>>
> >>>>> /Flibble
> >>>>>
> >>>>
> >>>> I will not do that until many many points of mutual agreement
> >>>> have occurred. Until many many points of mutual agreement have
> >>>> occurred my assessment that my reviewers are lying cheating
> >>>> bastards remains affirmed.
> >>>
> >>> At this point, as you refuse to provide evidence to the contrary,
> >>> I conclude that the only case of non-halting behavior you can
> >>> detect are the execution of the Intel x86 opcodes "EB FE". Being
> >>> only able to detect a single case of non-halting behavior out of
> >>> a total 2^n cases obviously does not qualify as a halting decider.
> >>>
> >>> You know what you must do to refute this conclusion: provide
> >>> evidence in the form of source code.
> >>>
> >>> /Flibble
> >>>
> >>
> >> That I prove that H(P,P)==0 by itself refutes the halting problem
> >> proofs that claim that neither 0 nor 1 is correct.
> >
> > Your H gets the answer wrong if P would have halted as only your
>
> That people with shit for brains think that is gets the wrong answer
> is no rebuttal at all.

Shit for brains? Your insults are definitely increasing in intensity,
have you checked your blood pressure recently?

/Flibble