On Fri, 10 Jun 2022 15:37:27 +0100
Mr Flibble <flibble@reddwarf.jmc> 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
> simulation doesn't execute the rest of P after P invokes H; the rest
> of P *is* executed in the halting problem proofs.

By that I actually meant: the rest of P *is* taken into consideration in
the halting problem proofs as only a simulating decider actually
EXECUTES P.

/Flibble