Rocksolid Light

Welcome to novaBBS (click a section below)

mail  files  register  newsreader  groups  login

Message-ID:  

Logic doesn't apply to the real world. -- Marvin Minsky

computers / comp.ai.philosophy / Re: Proving that P(P) != the correct x86 emulation of the input to H(P,P)

SubjectAuthor
* No one has sufficiently addressed this H(P,P)==0olcott
+* Re: No one has sufficiently addressed this H(P,P)==0Richard Damon
|`* Re: No one has sufficiently addressed this H(P,P)==0olcott
| `- Re: No one has sufficiently addressed this H(P,P)==0Richard Damon
+* Re: No one has sufficiently addressed this H(P,P)==0olcott
|`- Re: No one has sufficiently addressed this H(P,P)==0Richard Damon
`* Proving that P(P) != the correct x86 emulation of the input to H(P,P)olcott
 `* Re: Proving that P(P) != the correct x86 emulation of the input to H(P,P)Richard Damon
  `* Re: Proving that P(P) != the correct x86 emulation of the input toolcott
   `* Re: Proving that P(P) != the correct x86 emulation of the input toRichard Damon
    `* Re: Proving that P(P) != the correct x86 emulation of the input toolcott
     `* Re: Proving that P(P) != the correct x86 emulation of the input toMr Flibble
      `* Re: Proving that P(P) != the correct x86 emulation of the input toolcott
       `* Re: Proving that P(P) != the correct x86 emulation of the input to H(P,P)Mr Flibble
        `* Re: Proving that P(P) != the correct x86 emulation of the input toolcott
         `* Re: Proving that P(P) != the correct x86 emulation of the input toRichard Damon
          `* Re: Proving that P(P) != the correct x86 emulation of the input toolcott
           `* Re: Proving that P(P) != the correct x86 emulation of the input toRichard Damon
            `* Re: Proving that P(P) != the correct x86 emulation of the input toolcott
             `* Re: Proving that P(P) != the correct x86 emulation of the input toRichard Damon
              `* Re: Proving that P(P) != the correct x86 emulation of the input toolcott
               `* Re: Proving that P(P) != the correct x86 emulation of the input toRichard Damon
                `* Re: Proving that P(P) != the correct x86 emulation of the input toolcott
                 `* Re: Proving that P(P) != the correct x86 emulation of the input toRichard Damon
                  `* Re: Proving that P(P) != the correct x86 emulation of the input toolcott
                   `* Re: Proving that P(P) != the correct x86 emulation of the input toRichard Damon
                    `* Re: Proving that P(P) != the correct x86 emulation of the input toolcott
                     +* Re: Proving that P(P) != the correct x86 emulation of the input toMr Flibble
                     |`* Re: Proving that P(P) != the correct x86 emulation of the input toolcott
                     | +* Re: Proving that P(P) != the correct x86 emulation of the input to H(P,P)Mr Flibble
                     | |`* Re: Proving that P(P) != the correct x86 emulation of the input toolcott
                     | | `* Re: Proving that P(P) != the correct x86 emulation of the input toMr Flibble
                     | |  `* Re: Proving that P(P) != the correct x86 emulation of the input toolcott
                     | |   +* Re: Proving that P(P) != the correct x86 emulation of the input toMr Flibble
                     | |   |`* Re: Proving that P(P) != the correct x86 emulation of the input toolcott
                     | |   | `* Re: Proving that P(P) != the correct x86 emulation of the input toMr Flibble
                     | |   |  +- Re: Proving that P(P) != the correct x86 emulation of the input toolcott
                     | |   |  `* Re: Proving that P(P) != the correct x86 emulation of the input toolcott
                     | |   |   +* Re: Proving that P(P) != the correct x86 emulation of the input toMr Flibble
                     | |   |   |`* Re: Proving that P(P) != the correct x86 emulation of the input toolcott
                     | |   |   | `* Re: Proving that P(P) != the correct x86 emulation of the input toMr Flibble
                     | |   |   |  `* Re: Proving that P(P) != the correct x86 emulation of the input toolcott
                     | |   |   |   +* Re: Proving that P(P) != the correct x86 emulation of the input to H(P,P)Mr Flibble
                     | |   |   |   |`* Re: Proving that P(P) != the correct x86 emulation of the input toolcott
                     | |   |   |   | +* Re: Proving that P(P) != the correct x86 emulation of the input toMr Flibble
                     | |   |   |   | |`* Re: Proving that P(P) != the correct x86 emulation of the input toolcott
                     | |   |   |   | | +* Re: Proving that P(P) != the correct x86 emulation of the input to H(P,P)Mr Flibble
                     | |   |   |   | | |+- Re: Proving that P(P) != the correct x86 emulation of the input to H(P,P)Mr Flibble
                     | |   |   |   | | |+* Re: Proving that P(P) != the correct x86 emulation of the input toolcott
                     | |   |   |   | | ||`* Re: Proving that P(P) != the correct x86 emulation of the input to H(P,P)Mr Flibble
                     | |   |   |   | | || `* Re: Proving that P(P) != the correct x86 emulation of the input toolcott
                     | |   |   |   | | ||  `* Re: Proving that P(P) != the correct x86 emulation of the input to H(P,P)Mr Flibble
                     | |   |   |   | | ||   `* Re: Proving that P(P) != the correct x86 emulation of the input toolcott
                     | |   |   |   | | ||    `* Re: Proving that P(P) != the correct x86 emulation of the input to H(P,P)Mr Flibble
                     | |   |   |   | | ||     `* Re: Proving that P(P) != the correct x86 emulation of the input toolcott
                     | |   |   |   | | ||      `* Re: Proving that P(P) != the correct x86 emulation of the input to H(P,P)Mr Flibble
                     | |   |   |   | | ||       `* Re: Proving that P(P) != the correct x86 emulation of the input toolcott
                     | |   |   |   | | ||        +* Re: Proving that P(P) != the correct x86 emulation of the input to H(P,P)Mr Flibble
                     | |   |   |   | | ||        |`* Re: Proving that P(P) != the correct x86 emulation of the input toolcott
                     | |   |   |   | | ||        | +* Re: Proving that P(P) != the correct x86 emulation of the input toMr Flibble
                     | |   |   |   | | ||        | |`* Re: Proving that P(P) != the correct x86 emulation of the input toolcott
                     | |   |   |   | | ||        | | +* Re: Proving that P(P) != the correct x86 emulation of the input toMr Flibble
                     | |   |   |   | | ||        | | |`* Re: Proving that P(P) != the correct x86 emulation of the input toolcott
                     | |   |   |   | | ||        | | | `* Re: Proving that P(P) != the correct x86 emulation of the input toMr Flibble
                     | |   |   |   | | ||        | | |  `* Re: Proving that P(P) != the correct x86 emulation of the input toolcott
                     | |   |   |   | | ||        | | |   +- Re: Proving that P(P) != the correct x86 emulation of the input to H(P,P)Richard Damon
                     | |   |   |   | | ||        | | |   `* Re: Proving that P(P) != the correct x86 emulation of the input to H(P,P)Mr Flibble
                     | |   |   |   | | ||        | | |    `* Re: Proving that P(P) != the correct x86 emulation of the input toolcott
                     | |   |   |   | | ||        | | |     +* Re: Proving that P(P) != the correct x86 emulation of the input toMr Flibble
                     | |   |   |   | | ||        | | |     |`* Re: Proving that P(P) != the correct x86 emulation of the input toolcott
                     | |   |   |   | | ||        | | |     | `* Re: Proving that P(P) != the correct x86 emulation of the input toMr Flibble
                     | |   |   |   | | ||        | | |     |  +* Re: Proving that P(P) != the correct x86 emulation of the input toMr Flibble
                     | |   |   |   | | ||        | | |     |  |`* Re: Proving that P(P) != the correct x86 emulation of the input toolcott
                     | |   |   |   | | ||        | | |     |  | `- Re: Proving that P(P) != the correct x86 emulation of the input toRichard Damon
                     | |   |   |   | | ||        | | |     |  `* Re: Proving that P(P) != the correct x86 emulation of the input toolcott
                     | |   |   |   | | ||        | | |     |   `* Re: Proving that P(P) != the correct x86 emulation of the input toMr Flibble
                     | |   |   |   | | ||        | | |     |    `* Re: Proving that P(P) != the correct x86 emulation of the input toolcott
                     | |   |   |   | | ||        | | |     |     `* Re: Proving that P(P) != the correct x86 emulation of the input toMr Flibble
                     | |   |   |   | | ||        | | |     |      `* Re: Proving that P(P) != the correct x86 emulation of the input toolcott
                     | |   |   |   | | ||        | | |     |       +- Re: Proving that P(P) != the correct x86 emulation of the input toRichard Damon
                     | |   |   |   | | ||        | | |     |       `* Re: Proving that P(P) != the correct x86 emulation of the input toMr Flibble
                     | |   |   |   | | ||        | | |     |        `* Re: Proving that P(P) != the correct x86 emulation of the input toolcott
                     | |   |   |   | | ||        | | |     |         +- Re: Proving that P(P) != the correct x86 emulation of the input toMr Flibble
                     | |   |   |   | | ||        | | |     |         `- Re: Proving that P(P) != the correct x86 emulation of the input to H(P,P)Richard Damon
                     | |   |   |   | | ||        | | |     `- Re: Proving that P(P) != the correct x86 emulation of the input toRichard Damon
                     | |   |   |   | | ||        | | `- Re: Proving that P(P) != the correct x86 emulation of the input toRichard Damon
                     | |   |   |   | | ||        | `- Re: Proving that P(P) != the correct x86 emulation of the input toRichard Damon
                     | |   |   |   | | ||        `- Re: Proving that P(P) != the correct x86 emulation of the input toRichard Damon
                     | |   |   |   | | |`* Re: Proving that P(P) != the correct x86 emulation of the input toolcott
                     | |   |   |   | | | `- Re: Proving that P(P) != the correct x86 emulation of the input toRichard Damon
                     | |   |   |   | | `- Re: Proving that P(P) != the correct x86 emulation of the input to H(P,P)Richard Damon
                     | |   |   |   | `- Re: Proving that P(P) != the correct x86 emulation of the input toRichard Damon
                     | |   |   |   `- Re: Proving that P(P) != the correct x86 emulation of the input toRichard Damon
                     | |   |   `- Re: Proving that P(P) != the correct x86 emulation of the input toRichard Damon
                     | |   `- Re: Proving that P(P) != the correct x86 emulation of the input toRichard Damon
                     | `* Re: Proving that P(P) != the correct x86 emulation of the input toRichard Damon
                     |  `* Re: Proving that P(P) != the correct x86 emulation of the input toolcott
                     |   `* Re: Proving that P(P) != the correct x86 emulation of the input to H(P,P)Richard Damon
                     |    `* Re: Proving that P(P) != the correct x86 emulation of the input toolcott
                     |     `- Re: Proving that P(P) != the correct x86 emulation of the input toRichard Damon
                     `* Re: Proving that P(P) != the correct x86 emulation of the input toRichard Damon

Pages:12345
Re: Proving that P(P) != the correct x86 emulation of the input to H(P,P)

<20220610145124.00006b36@reddwarf.jmc>

  copy mid

https://www.novabbs.com/computers/article-flat.php?id=9292&group=comp.ai.philosophy#9292

  copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Path: i2pn2.org!i2pn.org!weretis.net!feeder8.news.weretis.net!feeder1.feed.usenet.farm!feed.usenet.farm!peer02.ams4!peer.am4.highwinds-media.com!news.highwinds-media.com!fx14.ams4.POSTED!not-for-mail
From: flib...@reddwarf.jmc (Mr Flibble)
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
Subject: Re: Proving that P(P) != the correct x86 emulation of the input to
H(P,P)
Message-ID: <20220610145124.00006b36@reddwarf.jmc>
References: <N8GdnUDJ0IRRxjz_nZ2dnUU7_8zNnZ2d@giganews.com>
<osadnc-FVvDu0j__nZ2dnUU7_81g4p2d@giganews.com>
<vgsoK.21728$6P.2117@fx38.iad>
<h_qdnb8cOfX0yT__nZ2dnUU7_83NnZ2d@giganews.com>
<CGsoK.16478$gjlb.2500@fx44.iad>
<-eidnS2VbJfywj__nZ2dnUU7_81g4p2d@giganews.com>
<PntoK.92394$J0r9.54835@fx11.iad>
<56OdnYEQJIev-z__nZ2dnUU7_83NnZ2d@giganews.com>
<7_toK.131290$JVi.111799@fx17.iad>
<qp-dndDi7NIb8j__nZ2dnUU7_8zNnZ2d@giganews.com>
<20220609231524.000077bb@reddwarf.jmc>
<MZGdnQUbkcpd7D__nZ2dnUU7_8xh4p2d@giganews.com>
<20220609232712.000066f9@reddwarf.jmc>
<87ydnfwLL4kG6D__nZ2dnUU7_8xh4p2d@giganews.com>
<20220610121102.00007ec0@reddwarf.jmc>
<M7GdnWgvGYAr3D7_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220610142323.0000220d@reddwarf.jmc>
<btSdnYCX8rZc2z7_nZ2dnUU7_8xh4p2d@giganews.com>
<20220610142959.0000420e@reddwarf.jmc>
<8PSdnZNSIaS11T7_nZ2dnUU7_81g4p2d@giganews.com>
<20220610143549.000053e6@reddwarf.jmc>
<nKGdnQ8wUuAI1z7_nZ2dnUU7_83NnZ2d@giganews.com>
Organization: Jupiter Mining Corp
X-Newsreader: Claws Mail 3.17.8 (GTK+ 2.24.33; x86_64-w64-mingw32)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: quoted-printable
Lines: 579
X-Complaints-To: abuse@eweka.nl
NNTP-Posting-Date: Fri, 10 Jun 2022 13:51:23 UTC
Date: Fri, 10 Jun 2022 14:51:24 +0100
X-Received-Bytes: 31320
 by: Mr Flibble - Fri, 10 Jun 2022 13:51 UTC

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.


Click here to read the complete article
Re: Proving that P(P) != the correct x86 emulation of the input to H(P,P)

<oIKdneD0eqar0z7_nZ2dnUU7_83NnZ2d@giganews.com>

  copy mid

https://www.novabbs.com/computers/article-flat.php?id=9293&group=comp.ai.philosophy#9293

  copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Fri, 10 Jun 2022 08:59:18 -0500
Date: Fri, 10 Jun 2022 08:59:17 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.10.0
Subject: Re: Proving that P(P) != the correct x86 emulation of the input to
H(P,P)
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <N8GdnUDJ0IRRxjz_nZ2dnUU7_8zNnZ2d@giganews.com>
<osadnc-FVvDu0j__nZ2dnUU7_81g4p2d@giganews.com>
<vgsoK.21728$6P.2117@fx38.iad>
<h_qdnb8cOfX0yT__nZ2dnUU7_83NnZ2d@giganews.com>
<CGsoK.16478$gjlb.2500@fx44.iad>
<-eidnS2VbJfywj__nZ2dnUU7_81g4p2d@giganews.com>
<PntoK.92394$J0r9.54835@fx11.iad>
<56OdnYEQJIev-z__nZ2dnUU7_83NnZ2d@giganews.com>
<7_toK.131290$JVi.111799@fx17.iad>
<qp-dndDi7NIb8j__nZ2dnUU7_8zNnZ2d@giganews.com>
<20220609231524.000077bb@reddwarf.jmc>
<MZGdnQUbkcpd7D__nZ2dnUU7_8xh4p2d@giganews.com>
<20220609232712.000066f9@reddwarf.jmc>
<87ydnfwLL4kG6D__nZ2dnUU7_8xh4p2d@giganews.com>
<20220610121102.00007ec0@reddwarf.jmc>
<M7GdnWgvGYAr3D7_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220610142323.0000220d@reddwarf.jmc>
<btSdnYCX8rZc2z7_nZ2dnUU7_8xh4p2d@giganews.com>
<20220610142959.0000420e@reddwarf.jmc>
<8PSdnZNSIaS11T7_nZ2dnUU7_81g4p2d@giganews.com>
<20220610143549.000053e6@reddwarf.jmc>
<nKGdnQ8wUuAI1z7_nZ2dnUU7_83NnZ2d@giganews.com>
<20220610145124.00006b36@reddwarf.jmc>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <20220610145124.00006b36@reddwarf.jmc>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <oIKdneD0eqar0z7_nZ2dnUU7_83NnZ2d@giganews.com>
Lines: 575
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-ld8y2CZuq+uLrvVRtxzW3F51CUDTXhk7LsVrzITInkkfr8SzngDTn8X/hNeFAF+aiYXLAQ+AyfEIxNn!yWo7jjpArxo/GPZh9MeVDqJ59YLKauxykpbBVTJQ8xK8ixmT76SE8IjXDtTF1fb+sqGGHMFDvWSV
X-Complaints-To: abuse@giganews.com
X-DMCA-Notifications: http://www.giganews.com/info/dmca.html
X-Abuse-and-DMCA-Info: Please be sure to forward a copy of ALL headers
X-Abuse-and-DMCA-Info: Otherwise we will be unable to process your complaint properly
X-Postfilter: 1.3.40
X-Original-Bytes: 31349
 by: olcott - Fri, 10 Jun 2022 13:59 UTC

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.


Click here to read the complete article
Re: Proving that P(P) != the correct x86 emulation of the input to H(P,P)

<20220610150318.0000143d@reddwarf.jmc>

  copy mid

https://www.novabbs.com/computers/article-flat.php?id=9294&group=comp.ai.philosophy#9294

  copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Path: i2pn2.org!i2pn.org!usenet.goja.nl.eu.org!3.eu.feeder.erje.net!feeder.erje.net!news.uzoreto.com!feeder.usenetexpress.com!tr2.eu1.usenetexpress.com!81.171.65.14.MISMATCH!peer02.ams4!peer.am4.highwinds-media.com!news.highwinds-media.com!fx14.ams4.POSTED!not-for-mail
From: flib...@reddwarf.jmc (Mr Flibble)
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
Subject: Re: Proving that P(P) != the correct x86 emulation of the input to H(P,P)
Message-ID: <20220610150318.0000143d@reddwarf.jmc>
References: <N8GdnUDJ0IRRxjz_nZ2dnUU7_8zNnZ2d@giganews.com> <h_qdnb8cOfX0yT__nZ2dnUU7_83NnZ2d@giganews.com> <CGsoK.16478$gjlb.2500@fx44.iad> <-eidnS2VbJfywj__nZ2dnUU7_81g4p2d@giganews.com> <PntoK.92394$J0r9.54835@fx11.iad> <56OdnYEQJIev-z__nZ2dnUU7_83NnZ2d@giganews.com> <7_toK.131290$JVi.111799@fx17.iad> <qp-dndDi7NIb8j__nZ2dnUU7_8zNnZ2d@giganews.com> <20220609231524.000077bb@reddwarf.jmc> <MZGdnQUbkcpd7D__nZ2dnUU7_8xh4p2d@giganews.com> <20220609232712.000066f9@reddwarf.jmc> <87ydnfwLL4kG6D__nZ2dnUU7_8xh4p2d@giganews.com> <20220610121102.00007ec0@reddwarf.jmc> <M7GdnWgvGYAr3D7_nZ2dnUU7_8zNnZ2d@giganews.com> <20220610142323.0000220d@reddwarf.jmc> <btSdnYCX8rZc2z7_nZ2dnUU7_8xh4p2d@giganews.com> <20220610142959.0000420e@reddwarf.jmc> <8PSdnZNSIaS11T7_nZ2dnUU7_81g4p2d@giganews.com> <20220610143549.000053e6@reddwarf.jmc> <nKGdnQ8wUuAI1z7_nZ2dnUU7_83NnZ2d@giganews.com> <20220610145124.00006b36@reddwarf.jmc> <oIKdneD0eqar0z7_nZ2dnUU7_83NnZ2d@giganews.com>
Organization: Jupiter Mining Corp
X-Newsreader: Claws Mail 3.17.8 (GTK+ 2.24.33; x86_64-w64-mingw32)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: quoted-printable
Lines: 603
X-Complaints-To: abuse@eweka.nl
NNTP-Posting-Date: Fri, 10 Jun 2022 14:03:18 UTC
Date: Fri, 10 Jun 2022 15:03:18 +0100
X-Received-Bytes: 32925
 by: Mr Flibble - Fri, 10 Jun 2022 14:03 UTC

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.


Click here to read the complete article
Re: Proving that P(P) != the correct x86 emulation of the input to H(P,P)

<FIudncIf4s6fzz7_nZ2dnUU7_8xh4p2d@giganews.com>

  copy mid

https://www.novabbs.com/computers/article-flat.php?id=9295&group=comp.ai.philosophy#9295

  copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Path: i2pn2.org!i2pn.org!usenet.blueworldhosting.com!feed1.usenet.blueworldhosting.com!peer02.iad!feed-me.highwinds-media.com!news.highwinds-media.com!border1.nntp.dca1.giganews.com!nntp.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Fri, 10 Jun 2022 09:15:30 -0500
Date: Fri, 10 Jun 2022 09:15:29 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.10.0
Subject: Re: Proving that P(P) != the correct x86 emulation of the input to
H(P,P)
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <N8GdnUDJ0IRRxjz_nZ2dnUU7_8zNnZ2d@giganews.com>
<CGsoK.16478$gjlb.2500@fx44.iad>
<-eidnS2VbJfywj__nZ2dnUU7_81g4p2d@giganews.com>
<PntoK.92394$J0r9.54835@fx11.iad>
<56OdnYEQJIev-z__nZ2dnUU7_83NnZ2d@giganews.com>
<7_toK.131290$JVi.111799@fx17.iad>
<qp-dndDi7NIb8j__nZ2dnUU7_8zNnZ2d@giganews.com>
<20220609231524.000077bb@reddwarf.jmc>
<MZGdnQUbkcpd7D__nZ2dnUU7_8xh4p2d@giganews.com>
<20220609232712.000066f9@reddwarf.jmc>
<87ydnfwLL4kG6D__nZ2dnUU7_8xh4p2d@giganews.com>
<20220610121102.00007ec0@reddwarf.jmc>
<M7GdnWgvGYAr3D7_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220610142323.0000220d@reddwarf.jmc>
<btSdnYCX8rZc2z7_nZ2dnUU7_8xh4p2d@giganews.com>
<20220610142959.0000420e@reddwarf.jmc>
<8PSdnZNSIaS11T7_nZ2dnUU7_81g4p2d@giganews.com>
<20220610143549.000053e6@reddwarf.jmc>
<nKGdnQ8wUuAI1z7_nZ2dnUU7_83NnZ2d@giganews.com>
<20220610145124.00006b36@reddwarf.jmc>
<oIKdneD0eqar0z7_nZ2dnUU7_83NnZ2d@giganews.com>
<20220610150318.0000143d@reddwarf.jmc>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <20220610150318.0000143d@reddwarf.jmc>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <FIudncIf4s6fzz7_nZ2dnUU7_8xh4p2d@giganews.com>
Lines: 590
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-4ym1xRl3T4jyR/Jcs71lixjr6lOdE250CxIsFiXmH92nruhiL1kQVUn6PSolhhxh5yhOh6qZrxjBsn7!uVXEhfZ/S4U6K0WK5VRhPnN003uInjwvr21AX9lce7sTW1x9Yqeh6dpoVwnlaejDURg7RA6V2L/H
X-Complaints-To: abuse@giganews.com
X-DMCA-Notifications: http://www.giganews.com/info/dmca.html
X-Abuse-and-DMCA-Info: Please be sure to forward a copy of ALL headers
X-Abuse-and-DMCA-Info: Otherwise we will be unable to process your complaint properly
X-Postfilter: 1.3.40
X-Original-Bytes: 32794
X-Received-Bytes: 32887
 by: olcott - Fri, 10 Jun 2022 14:15 UTC

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
>


Click here to read the complete article
Re: Proving that P(P) != the correct x86 emulation of the input to H(P,P)

<hqIoK.75970$GTEb.6466@fx48.iad>

  copy mid

https://www.novabbs.com/computers/article-flat.php?id=9296&group=comp.ai.philosophy#9296

  copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Path: i2pn2.org!i2pn.org!usenet.blueworldhosting.com!feed1.usenet.blueworldhosting.com!peer03.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx48.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.10.0
Subject: Re: Proving that P(P) != the correct x86 emulation of the input to
H(P,P)
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <N8GdnUDJ0IRRxjz_nZ2dnUU7_8zNnZ2d@giganews.com>
<vgsoK.21728$6P.2117@fx38.iad>
<h_qdnb8cOfX0yT__nZ2dnUU7_83NnZ2d@giganews.com>
<CGsoK.16478$gjlb.2500@fx44.iad>
<-eidnS2VbJfywj__nZ2dnUU7_81g4p2d@giganews.com>
<PntoK.92394$J0r9.54835@fx11.iad>
<56OdnYEQJIev-z__nZ2dnUU7_83NnZ2d@giganews.com>
<7_toK.131290$JVi.111799@fx17.iad>
<qp-dndDi7NIb8j__nZ2dnUU7_8zNnZ2d@giganews.com>
<20220609231524.000077bb@reddwarf.jmc>
<MZGdnQUbkcpd7D__nZ2dnUU7_8xh4p2d@giganews.com>
<20220609232712.000066f9@reddwarf.jmc>
<87ydnfwLL4kG6D__nZ2dnUU7_8xh4p2d@giganews.com>
<20220610121102.00007ec0@reddwarf.jmc>
<M7GdnWgvGYAr3D7_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220610142323.0000220d@reddwarf.jmc>
<btSdnYCX8rZc2z7_nZ2dnUU7_8xh4p2d@giganews.com>
<20220610142959.0000420e@reddwarf.jmc>
<8PSdnZNSIaS11T7_nZ2dnUU7_81g4p2d@giganews.com>
<20220610143549.000053e6@reddwarf.jmc>
<nKGdnQ8wUuAI1z7_nZ2dnUU7_83NnZ2d@giganews.com>
<20220610145124.00006b36@reddwarf.jmc>
<oIKdneD0eqar0z7_nZ2dnUU7_83NnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <oIKdneD0eqar0z7_nZ2dnUU7_83NnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 590
Message-ID: <hqIoK.75970$GTEb.6466@fx48.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Fri, 10 Jun 2022 10:19:54 -0400
X-Received-Bytes: 33302
 by: Richard Damon - Fri, 10 Jun 2022 14:19 UTC

On 6/10/22 9:59 AM, olcott 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.


Click here to read the complete article
Re: Proving that P(P) != the correct x86 emulation of the input to H(P,P)

<20220610152154.000014c7@reddwarf.jmc>

  copy mid

https://www.novabbs.com/computers/article-flat.php?id=9297&group=comp.ai.philosophy#9297

  copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Path: i2pn2.org!i2pn.org!weretis.net!feeder8.news.weretis.net!feeder1.feed.usenet.farm!feed.usenet.farm!peer01.ams4!peer.am4.highwinds-media.com!news.highwinds-media.com!fx14.ams4.POSTED!not-for-mail
From: flib...@reddwarf.jmc (Mr Flibble)
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
Subject: Re: Proving that P(P) != the correct x86 emulation of the input to
H(P,P)
Message-ID: <20220610152154.000014c7@reddwarf.jmc>
References: <N8GdnUDJ0IRRxjz_nZ2dnUU7_8zNnZ2d@giganews.com>
<PntoK.92394$J0r9.54835@fx11.iad>
<56OdnYEQJIev-z__nZ2dnUU7_83NnZ2d@giganews.com>
<7_toK.131290$JVi.111799@fx17.iad>
<qp-dndDi7NIb8j__nZ2dnUU7_8zNnZ2d@giganews.com>
<20220609231524.000077bb@reddwarf.jmc>
<MZGdnQUbkcpd7D__nZ2dnUU7_8xh4p2d@giganews.com>
<20220609232712.000066f9@reddwarf.jmc>
<87ydnfwLL4kG6D__nZ2dnUU7_8xh4p2d@giganews.com>
<20220610121102.00007ec0@reddwarf.jmc>
<M7GdnWgvGYAr3D7_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220610142323.0000220d@reddwarf.jmc>
<btSdnYCX8rZc2z7_nZ2dnUU7_8xh4p2d@giganews.com>
<20220610142959.0000420e@reddwarf.jmc>
<8PSdnZNSIaS11T7_nZ2dnUU7_81g4p2d@giganews.com>
<20220610143549.000053e6@reddwarf.jmc>
<nKGdnQ8wUuAI1z7_nZ2dnUU7_83NnZ2d@giganews.com>
<20220610145124.00006b36@reddwarf.jmc>
<oIKdneD0eqar0z7_nZ2dnUU7_83NnZ2d@giganews.com>
<20220610150318.0000143d@reddwarf.jmc>
<FIudncIf4s6fzz7_nZ2dnUU7_8xh4p2d@giganews.com>
Organization: Jupiter Mining Corp
X-Newsreader: Claws Mail 3.17.8 (GTK+ 2.24.33; x86_64-w64-mingw32)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: quoted-printable
Lines: 629
X-Complaints-To: abuse@eweka.nl
NNTP-Posting-Date: Fri, 10 Jun 2022 14:21:54 UTC
Date: Fri, 10 Jun 2022 15:21:54 +0100
X-Received-Bytes: 35100
 by: Mr Flibble - Fri, 10 Jun 2022 14:21 UTC

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.

Click here to read the complete article

Re: Proving that P(P) != the correct x86 emulation of the input to H(P,P)

<EOydndJCqYmMyz7_nZ2dnUU7_83NnZ2d@giganews.com>

  copy mid

https://www.novabbs.com/computers/article-flat.php?id=9298&group=comp.ai.philosophy#9298

  copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Fri, 10 Jun 2022 09:32:49 -0500
Date: Fri, 10 Jun 2022 09:32:47 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.10.0
Subject: Re: Proving that P(P) != the correct x86 emulation of the input to
H(P,P)
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <N8GdnUDJ0IRRxjz_nZ2dnUU7_8zNnZ2d@giganews.com>
<PntoK.92394$J0r9.54835@fx11.iad>
<56OdnYEQJIev-z__nZ2dnUU7_83NnZ2d@giganews.com>
<7_toK.131290$JVi.111799@fx17.iad>
<qp-dndDi7NIb8j__nZ2dnUU7_8zNnZ2d@giganews.com>
<20220609231524.000077bb@reddwarf.jmc>
<MZGdnQUbkcpd7D__nZ2dnUU7_8xh4p2d@giganews.com>
<20220609232712.000066f9@reddwarf.jmc>
<87ydnfwLL4kG6D__nZ2dnUU7_8xh4p2d@giganews.com>
<20220610121102.00007ec0@reddwarf.jmc>
<M7GdnWgvGYAr3D7_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220610142323.0000220d@reddwarf.jmc>
<btSdnYCX8rZc2z7_nZ2dnUU7_8xh4p2d@giganews.com>
<20220610142959.0000420e@reddwarf.jmc>
<8PSdnZNSIaS11T7_nZ2dnUU7_81g4p2d@giganews.com>
<20220610143549.000053e6@reddwarf.jmc>
<nKGdnQ8wUuAI1z7_nZ2dnUU7_83NnZ2d@giganews.com>
<20220610145124.00006b36@reddwarf.jmc>
<oIKdneD0eqar0z7_nZ2dnUU7_83NnZ2d@giganews.com>
<20220610150318.0000143d@reddwarf.jmc>
<FIudncIf4s6fzz7_nZ2dnUU7_8xh4p2d@giganews.com>
<20220610152154.000014c7@reddwarf.jmc>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <20220610152154.000014c7@reddwarf.jmc>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <EOydndJCqYmMyz7_nZ2dnUU7_83NnZ2d@giganews.com>
Lines: 619
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-XpaVzMLw4jFO3EJNVD1yz13/2NQdw1gJmbqazHN47MpmWCuhHxvc6cQYo0U3dOIFTC2H2QZfIMi1IM4!iLsvdbme4F3VDNARRJcCh34OO2snsp9g3Q95pLvSi6QdTyxHgoHFOLd0K2Z6zdXDMckgr5JNXgqv
X-Complaints-To: abuse@giganews.com
X-DMCA-Notifications: http://www.giganews.com/info/dmca.html
X-Abuse-and-DMCA-Info: Please be sure to forward a copy of ALL headers
X-Abuse-and-DMCA-Info: Otherwise we will be unable to process your complaint properly
X-Postfilter: 1.3.40
X-Original-Bytes: 34986
 by: olcott - Fri, 10 Jun 2022 14:32 UTC

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
>


Click here to read the complete article
Re: Proving that P(P) != the correct x86 emulation of the input to H(P,P)

<FEIoK.108375$45E8.27922@fx47.iad>

  copy mid

https://www.novabbs.com/computers/article-flat.php?id=9299&group=comp.ai.philosophy#9299

  copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Path: i2pn2.org!i2pn.org!paganini.bofh.team!pasdenom.info!nntpfeed.proxad.net!proxad.net!feeder1-1.proxad.net!193.141.40.65.MISMATCH!npeer.as286.net!npeer-ng0.as286.net!peer02.ams1!peer.ams1.xlned.com!news.xlned.com!peer01.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx47.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.10.0
Subject: Re: Proving that P(P) != the correct x86 emulation of the input to
H(P,P)
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <N8GdnUDJ0IRRxjz_nZ2dnUU7_8zNnZ2d@giganews.com>
<-eidnS2VbJfywj__nZ2dnUU7_81g4p2d@giganews.com>
<PntoK.92394$J0r9.54835@fx11.iad>
<56OdnYEQJIev-z__nZ2dnUU7_83NnZ2d@giganews.com>
<7_toK.131290$JVi.111799@fx17.iad>
<qp-dndDi7NIb8j__nZ2dnUU7_8zNnZ2d@giganews.com>
<20220609231524.000077bb@reddwarf.jmc>
<MZGdnQUbkcpd7D__nZ2dnUU7_8xh4p2d@giganews.com>
<20220609232712.000066f9@reddwarf.jmc>
<87ydnfwLL4kG6D__nZ2dnUU7_8xh4p2d@giganews.com>
<20220610121102.00007ec0@reddwarf.jmc>
<M7GdnWgvGYAr3D7_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220610142323.0000220d@reddwarf.jmc>
<btSdnYCX8rZc2z7_nZ2dnUU7_8xh4p2d@giganews.com>
<20220610142959.0000420e@reddwarf.jmc>
<8PSdnZNSIaS11T7_nZ2dnUU7_81g4p2d@giganews.com>
<20220610143549.000053e6@reddwarf.jmc>
<nKGdnQ8wUuAI1z7_nZ2dnUU7_83NnZ2d@giganews.com>
<20220610145124.00006b36@reddwarf.jmc>
<oIKdneD0eqar0z7_nZ2dnUU7_83NnZ2d@giganews.com>
<20220610150318.0000143d@reddwarf.jmc>
<FIudncIf4s6fzz7_nZ2dnUU7_8xh4p2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <FIudncIf4s6fzz7_nZ2dnUU7_8xh4p2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Lines: 49
Message-ID: <FEIoK.108375$45E8.27922@fx47.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Fri, 10 Jun 2022 10:35:17 -0400
X-Received-Bytes: 4103
 by: Richard Damon - Fri, 10 Jun 2022 14:35 UTC

On 6/10/22 10:15 AM, olcott wrote:
> On 6/10/2022 9:03 AM, Mr Flibble wrote:

>> 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.
>

Peter, your problem is that the burden of proof is on your shoulders.

You don't get to et the ground rules on what needs to happen for people
to accept your results.

You are free to ignorantly believe that you have discovered something
and keep it to yourself.

You are NOT free to insist that other believe you unless you are willing
to actually show a proof to the established standards.

It is clear that you are unwilling to do that, and lable as "Rebuttal
Mode" people just asking for a proof that meets the established standards.

All this does is prove that you are unwilling, and almost certainly
unable, to actual prove your results to the established standards.

All your calling everyone else as being "incompetent" is doing is
showing how disingenuous you are, how much you have a lack of
understanding of what Truth actually is.

In many ways I pity you, you appear to have destroyed your life and your
reputation by latching on to an incorrect idea and not letting yourself
see your mistake. It is even possible (but in no sense proven) that such
a mental conflict might be a contributor to the disease that is killing
your body. (Mental processes do have power over the physical).

Hopefully, at some point something will sink in and you will come to
your senses. Until then, try to think about what you are showing the
world about yourself, if you really want your legacy to be that of a
person who refused to look at actual facts and definitions, but insisted
that his own OPINIONS must be true, then continue on your course, as you
are doing a great job at that.

Re: Proving that P(P) != the correct x86 emulation of the input to H(P,P)

<20220610153727.000015ca@reddwarf.jmc>

  copy mid

https://www.novabbs.com/computers/article-flat.php?id=9300&group=comp.ai.philosophy#9300

  copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Path: i2pn2.org!i2pn.org!news.neodome.net!news.uzoreto.com!feeder.usenetexpress.com!tr1.eu1.usenetexpress.com!feeder1.feed.usenet.farm!feed.usenet.farm!peer03.ams4!peer.am4.highwinds-media.com!news.highwinds-media.com!fx14.ams4.POSTED!not-for-mail
From: flib...@reddwarf.jmc (Mr Flibble)
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
Subject: Re: Proving that P(P) != the correct x86 emulation of the input to H(P,P)
Message-ID: <20220610153727.000015ca@reddwarf.jmc>
References: <N8GdnUDJ0IRRxjz_nZ2dnUU7_8zNnZ2d@giganews.com> <7_toK.131290$JVi.111799@fx17.iad> <qp-dndDi7NIb8j__nZ2dnUU7_8zNnZ2d@giganews.com> <20220609231524.000077bb@reddwarf.jmc> <MZGdnQUbkcpd7D__nZ2dnUU7_8xh4p2d@giganews.com> <20220609232712.000066f9@reddwarf.jmc> <87ydnfwLL4kG6D__nZ2dnUU7_8xh4p2d@giganews.com> <20220610121102.00007ec0@reddwarf.jmc> <M7GdnWgvGYAr3D7_nZ2dnUU7_8zNnZ2d@giganews.com> <20220610142323.0000220d@reddwarf.jmc> <btSdnYCX8rZc2z7_nZ2dnUU7_8xh4p2d@giganews.com> <20220610142959.0000420e@reddwarf.jmc> <8PSdnZNSIaS11T7_nZ2dnUU7_81g4p2d@giganews.com> <20220610143549.000053e6@reddwarf.jmc> <nKGdnQ8wUuAI1z7_nZ2dnUU7_83NnZ2d@giganews.com> <20220610145124.00006b36@reddwarf.jmc> <oIKdneD0eqar0z7_nZ2dnUU7_83NnZ2d@giganews.com> <20220610150318.0000143d@reddwarf.jmc> <FIudncIf4s6fzz7_nZ2dnUU7_8xh4p2d@giganews.com> <20220610152154.000014c7@reddwarf.jmc> <EOydndJCqYmMyz7_nZ2dnUU7_83NnZ2d@giganews.com>
Organization: Jupiter Mining Corp
X-Newsreader: Claws Mail 3.17.8 (GTK+ 2.24.33; x86_64-w64-mingw32)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: quoted-printable
Lines: 656
X-Complaints-To: abuse@eweka.nl
NNTP-Posting-Date: Fri, 10 Jun 2022 14:37:27 UTC
Date: Fri, 10 Jun 2022 15:37:27 +0100
X-Received-Bytes: 37146
 by: Mr Flibble - Fri, 10 Jun 2022 14:37 UTC

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.

Click here to read the complete article

Re: Proving that P(P) != the correct x86 emulation of the input to H(P,P)

<20220610154152.000002ca@reddwarf.jmc>

  copy mid

https://www.novabbs.com/computers/article-flat.php?id=9301&group=comp.ai.philosophy#9301

  copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Path: i2pn2.org!i2pn.org!usenet.goja.nl.eu.org!3.eu.feeder.erje.net!feeder.erje.net!news.uzoreto.com!feeder.usenetexpress.com!tr1.eu1.usenetexpress.com!feeder1.feed.usenet.farm!feed.usenet.farm!news-out.netnews.com!news.alt.net!fdc2.netnews.com!peer03.ams1!peer.ams1.xlned.com!news.xlned.com!peer01.ams4!peer.am4.highwinds-media.com!news.highwinds-media.com!fx14.ams4.POSTED!not-for-mail
From: flib...@reddwarf.jmc (Mr Flibble)
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
Subject: Re: Proving that P(P) != the correct x86 emulation of the input to H(P,P)
Message-ID: <20220610154152.000002ca@reddwarf.jmc>
References: <N8GdnUDJ0IRRxjz_nZ2dnUU7_8zNnZ2d@giganews.com> <7_toK.131290$JVi.111799@fx17.iad> <qp-dndDi7NIb8j__nZ2dnUU7_8zNnZ2d@giganews.com> <20220609231524.000077bb@reddwarf.jmc> <MZGdnQUbkcpd7D__nZ2dnUU7_8xh4p2d@giganews.com> <20220609232712.000066f9@reddwarf.jmc> <87ydnfwLL4kG6D__nZ2dnUU7_8xh4p2d@giganews.com> <20220610121102.00007ec0@reddwarf.jmc> <M7GdnWgvGYAr3D7_nZ2dnUU7_8zNnZ2d@giganews.com> <20220610142323.0000220d@reddwarf.jmc> <btSdnYCX8rZc2z7_nZ2dnUU7_8xh4p2d@giganews.com> <20220610142959.0000420e@reddwarf.jmc> <8PSdnZNSIaS11T7_nZ2dnUU7_81g4p2d@giganews.com> <20220610143549.000053e6@reddwarf.jmc> <nKGdnQ8wUuAI1z7_nZ2dnUU7_83NnZ2d@giganews.com> <20220610145124.00006b36@reddwarf.jmc> <oIKdneD0eqar0z7_nZ2dnUU7_83NnZ2d@giganews.com> <20220610150318.0000143d@reddwarf.jmc> <FIudncIf4s6fzz7_nZ2dnUU7_8xh4p2d@giganews.com> <20220610152154.000014c7@reddwarf.jmc> <EOydndJCqYmMyz7_nZ2dnUU7_83NnZ2d@giganews.com> <20220610153727.000015ca@reddwarf.jmc>
Organization: Jupiter Mining Corp
X-Newsreader: Claws Mail 3.17.8 (GTK+ 2.24.33; x86_64-w64-mingw32)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: quoted-printable
Lines: 680
X-Complaints-To: abuse@eweka.nl
NNTP-Posting-Date: Fri, 10 Jun 2022 14:41:52 UTC
Date: Fri, 10 Jun 2022 15:41:52 +0100
X-Received-Bytes: 39289
 by: Mr Flibble - Fri, 10 Jun 2022 14:41 UTC

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.


Click here to read the complete article
Re: Proving that P(P) != the correct x86 emulation of the input to H(P,P)

<uN2dnUK2NLQ5xT7_nZ2dnUU7_8xh4p2d@giganews.com>

  copy mid

https://www.novabbs.com/computers/article-flat.php?id=9302&group=comp.ai.philosophy#9302

  copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Path: i2pn2.org!i2pn.org!usenet.blueworldhosting.com!feed1.usenet.blueworldhosting.com!peer02.iad!feed-me.highwinds-media.com!news.highwinds-media.com!border1.nntp.dca1.giganews.com!nntp.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Fri, 10 Jun 2022 09:43:48 -0500
Date: Fri, 10 Jun 2022 09:43:47 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.10.0
Subject: Re: Proving that P(P) != the correct x86 emulation of the input to
H(P,P)
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <N8GdnUDJ0IRRxjz_nZ2dnUU7_8zNnZ2d@giganews.com>
<7_toK.131290$JVi.111799@fx17.iad>
<qp-dndDi7NIb8j__nZ2dnUU7_8zNnZ2d@giganews.com>
<20220609231524.000077bb@reddwarf.jmc>
<MZGdnQUbkcpd7D__nZ2dnUU7_8xh4p2d@giganews.com>
<20220609232712.000066f9@reddwarf.jmc>
<87ydnfwLL4kG6D__nZ2dnUU7_8xh4p2d@giganews.com>
<20220610121102.00007ec0@reddwarf.jmc>
<M7GdnWgvGYAr3D7_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220610142323.0000220d@reddwarf.jmc>
<btSdnYCX8rZc2z7_nZ2dnUU7_8xh4p2d@giganews.com>
<20220610142959.0000420e@reddwarf.jmc>
<8PSdnZNSIaS11T7_nZ2dnUU7_81g4p2d@giganews.com>
<20220610143549.000053e6@reddwarf.jmc>
<nKGdnQ8wUuAI1z7_nZ2dnUU7_83NnZ2d@giganews.com>
<20220610145124.00006b36@reddwarf.jmc>
<oIKdneD0eqar0z7_nZ2dnUU7_83NnZ2d@giganews.com>
<20220610150318.0000143d@reddwarf.jmc>
<FIudncIf4s6fzz7_nZ2dnUU7_8xh4p2d@giganews.com>
<20220610152154.000014c7@reddwarf.jmc>
<EOydndJCqYmMyz7_nZ2dnUU7_83NnZ2d@giganews.com>
<20220610153727.000015ca@reddwarf.jmc>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <20220610153727.000015ca@reddwarf.jmc>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <uN2dnUK2NLQ5xT7_nZ2dnUU7_8xh4p2d@giganews.com>
Lines: 649
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-bqagl7RqbgnOomC9Z2ohLryioN91T8pE9XUOveogn2BOJOLHgEwW1zGBdbEL9DqOoPDYpArAPGKSmnb!R+henP2uRZp7C3wUF2994P/MnUNzuKYxyPx3QwV8977187CvpTdUuBXGtIh/fFqZ5L0mCxNL+tB6
X-Complaints-To: abuse@giganews.com
X-DMCA-Notifications: http://www.giganews.com/info/dmca.html
X-Abuse-and-DMCA-Info: Please be sure to forward a copy of ALL headers
X-Abuse-and-DMCA-Info: Otherwise we will be unable to process your complaint properly
X-Postfilter: 1.3.40
X-Original-Bytes: 37093
X-Received-Bytes: 37186
 by: olcott - Fri, 10 Jun 2022 14:43 UTC

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


Click here to read the complete article
Re: Proving that P(P) != the correct x86 emulation of the input to H(P,P)

<uN2dnX22NLTxxD7_nZ2dnUU7_8xh4p2d@giganews.com>

  copy mid

https://www.novabbs.com/computers/article-flat.php?id=9303&group=comp.ai.philosophy#9303

  copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Fri, 10 Jun 2022 09:47:08 -0500
Date: Fri, 10 Jun 2022 09:47:07 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.10.0
Subject: Re: Proving that P(P) != the correct x86 emulation of the input to
H(P,P)
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <N8GdnUDJ0IRRxjz_nZ2dnUU7_8zNnZ2d@giganews.com>
<7_toK.131290$JVi.111799@fx17.iad>
<qp-dndDi7NIb8j__nZ2dnUU7_8zNnZ2d@giganews.com>
<20220609231524.000077bb@reddwarf.jmc>
<MZGdnQUbkcpd7D__nZ2dnUU7_8xh4p2d@giganews.com>
<20220609232712.000066f9@reddwarf.jmc>
<87ydnfwLL4kG6D__nZ2dnUU7_8xh4p2d@giganews.com>
<20220610121102.00007ec0@reddwarf.jmc>
<M7GdnWgvGYAr3D7_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220610142323.0000220d@reddwarf.jmc>
<btSdnYCX8rZc2z7_nZ2dnUU7_8xh4p2d@giganews.com>
<20220610142959.0000420e@reddwarf.jmc>
<8PSdnZNSIaS11T7_nZ2dnUU7_81g4p2d@giganews.com>
<20220610143549.000053e6@reddwarf.jmc>
<nKGdnQ8wUuAI1z7_nZ2dnUU7_83NnZ2d@giganews.com>
<20220610145124.00006b36@reddwarf.jmc>
<oIKdneD0eqar0z7_nZ2dnUU7_83NnZ2d@giganews.com>
<20220610150318.0000143d@reddwarf.jmc>
<FIudncIf4s6fzz7_nZ2dnUU7_8xh4p2d@giganews.com>
<20220610152154.000014c7@reddwarf.jmc>
<EOydndJCqYmMyz7_nZ2dnUU7_83NnZ2d@giganews.com>
<20220610153727.000015ca@reddwarf.jmc>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <20220610153727.000015ca@reddwarf.jmc>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <uN2dnX22NLTxxD7_nZ2dnUU7_8xh4p2d@giganews.com>
Lines: 653
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-PQNmWyrKlLFT24udlEDHbTFyIYYQrgVC9ESv2NglMZti/cUqKmY96se5mZO30xBYbSklh483sgzt1o7!Ew+fJ3PQyt0wMhLxhckdv58YzcFOYrCJqO7SlBJs/XwPJXxVJHpB0TK2rxTFFHpoQCATvX7+y7FP
X-Complaints-To: abuse@giganews.com
X-DMCA-Notifications: http://www.giganews.com/info/dmca.html
X-Abuse-and-DMCA-Info: Please be sure to forward a copy of ALL headers
X-Abuse-and-DMCA-Info: Otherwise we will be unable to process your complaint properly
X-Postfilter: 1.3.40
X-Original-Bytes: 37254
 by: olcott - Fri, 10 Jun 2022 14:47 UTC

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


Click here to read the complete article
Re: Proving that P(P) != the correct x86 emulation of the input to H(P,P)

<20220610154757.00001577@reddwarf.jmc>

  copy mid

https://www.novabbs.com/computers/article-flat.php?id=9304&group=comp.ai.philosophy#9304

  copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Path: i2pn2.org!i2pn.org!weretis.net!feeder8.news.weretis.net!feeder1.feed.usenet.farm!feed.usenet.farm!feeder.usenetexpress.com!tr1.eu1.usenetexpress.com!81.171.65.13.MISMATCH!peer01.ams4!peer.am4.highwinds-media.com!news.highwinds-media.com!fx14.ams4.POSTED!not-for-mail
From: flib...@reddwarf.jmc (Mr Flibble)
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
Subject: Re: Proving that P(P) != the correct x86 emulation of the input to H(P,P)
Message-ID: <20220610154757.00001577@reddwarf.jmc>
References: <N8GdnUDJ0IRRxjz_nZ2dnUU7_8zNnZ2d@giganews.com> <20220609231524.000077bb@reddwarf.jmc> <MZGdnQUbkcpd7D__nZ2dnUU7_8xh4p2d@giganews.com> <20220609232712.000066f9@reddwarf.jmc> <87ydnfwLL4kG6D__nZ2dnUU7_8xh4p2d@giganews.com> <20220610121102.00007ec0@reddwarf.jmc> <M7GdnWgvGYAr3D7_nZ2dnUU7_8zNnZ2d@giganews.com> <20220610142323.0000220d@reddwarf.jmc> <btSdnYCX8rZc2z7_nZ2dnUU7_8xh4p2d@giganews.com> <20220610142959.0000420e@reddwarf.jmc> <8PSdnZNSIaS11T7_nZ2dnUU7_81g4p2d@giganews.com> <20220610143549.000053e6@reddwarf.jmc> <nKGdnQ8wUuAI1z7_nZ2dnUU7_83NnZ2d@giganews.com> <20220610145124.00006b36@reddwarf.jmc> <oIKdneD0eqar0z7_nZ2dnUU7_83NnZ2d@giganews.com> <20220610150318.0000143d@reddwarf.jmc> <FIudncIf4s6fzz7_nZ2dnUU7_8xh4p2d@giganews.com> <20220610152154.000014c7@reddwarf.jmc> <EOydndJCqYmMyz7_nZ2dnUU7_83NnZ2d@giganews.com> <20220610153727.000015ca@reddwarf.jmc> <uN2dnUK2NLQ5xT7_nZ2dnUU7_8xh4p2d@giganews.com>
Organization: Jupiter Mining Corp
X-Newsreader: Claws Mail 3.17.8 (GTK+ 2.24.33; x86_64-w64-mingw32)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: quoted-printable
Lines: 680
X-Complaints-To: abuse@eweka.nl
NNTP-Posting-Date: Fri, 10 Jun 2022 14:47:56 UTC
Date: Fri, 10 Jun 2022 15:47:57 +0100
X-Received-Bytes: 39043
 by: Mr Flibble - Fri, 10 Jun 2022 14:47 UTC

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.


Click here to read the complete article
Re: Proving that P(P) != the correct x86 emulation of the input to H(P,P)

<BsydnUepqLWJxj7_nZ2dnUU7_8zNnZ2d@giganews.com>

  copy mid

https://www.novabbs.com/computers/article-flat.php?id=9305&group=comp.ai.philosophy#9305

  copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Fri, 10 Jun 2022 09:54:11 -0500
Date: Fri, 10 Jun 2022 09:54:10 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.10.0
Subject: Re: Proving that P(P) != the correct x86 emulation of the input to
H(P,P)
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <N8GdnUDJ0IRRxjz_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220609231524.000077bb@reddwarf.jmc>
<MZGdnQUbkcpd7D__nZ2dnUU7_8xh4p2d@giganews.com>
<20220609232712.000066f9@reddwarf.jmc>
<87ydnfwLL4kG6D__nZ2dnUU7_8xh4p2d@giganews.com>
<20220610121102.00007ec0@reddwarf.jmc>
<M7GdnWgvGYAr3D7_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220610142323.0000220d@reddwarf.jmc>
<btSdnYCX8rZc2z7_nZ2dnUU7_8xh4p2d@giganews.com>
<20220610142959.0000420e@reddwarf.jmc>
<8PSdnZNSIaS11T7_nZ2dnUU7_81g4p2d@giganews.com>
<20220610143549.000053e6@reddwarf.jmc>
<nKGdnQ8wUuAI1z7_nZ2dnUU7_83NnZ2d@giganews.com>
<20220610145124.00006b36@reddwarf.jmc>
<oIKdneD0eqar0z7_nZ2dnUU7_83NnZ2d@giganews.com>
<20220610150318.0000143d@reddwarf.jmc>
<FIudncIf4s6fzz7_nZ2dnUU7_8xh4p2d@giganews.com>
<20220610152154.000014c7@reddwarf.jmc>
<EOydndJCqYmMyz7_nZ2dnUU7_83NnZ2d@giganews.com>
<20220610153727.000015ca@reddwarf.jmc>
<uN2dnUK2NLQ5xT7_nZ2dnUU7_8xh4p2d@giganews.com>
<20220610154757.00001577@reddwarf.jmc>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <20220610154757.00001577@reddwarf.jmc>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <BsydnUepqLWJxj7_nZ2dnUU7_8zNnZ2d@giganews.com>
Lines: 669
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-mRvlf1CXpjCGtqxs/DJjrx/9evBnxLNzGyVOApyZWMlPag2BlJcuuiQwVDu+j0Aznfahcxbf6HeDSL7!3ZEWGf9zbjbzjYZLgVsa30x/kfd0n9M987s5l2La9RQHZ9ycqj/9/q1Mx70W/f154K7+YrHkGRhF
X-Complaints-To: abuse@giganews.com
X-DMCA-Notifications: http://www.giganews.com/info/dmca.html
X-Abuse-and-DMCA-Info: Please be sure to forward a copy of ALL headers
X-Abuse-and-DMCA-Info: Otherwise we will be unable to process your complaint properly
X-Postfilter: 1.3.40
X-Original-Bytes: 39099
 by: olcott - Fri, 10 Jun 2022 14:54 UTC

On 6/10/2022 9:47 AM, Mr Flibble wrote:
> 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
>


Click here to read the complete article
Re: Proving that P(P) != the correct x86 emulation of the input to H(P,P)

<20220610160615.00007726@reddwarf.jmc>

  copy mid

https://www.novabbs.com/computers/article-flat.php?id=9306&group=comp.ai.philosophy#9306

  copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Path: i2pn2.org!i2pn.org!news.neodome.net!feeder1.feed.usenet.farm!feed.usenet.farm!feeder.usenetexpress.com!tr1.eu1.usenetexpress.com!81.171.65.16.MISMATCH!peer03.ams4!peer.am4.highwinds-media.com!news.highwinds-media.com!fx14.ams4.POSTED!not-for-mail
From: flib...@reddwarf.jmc (Mr Flibble)
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
Subject: Re: Proving that P(P) != the correct x86 emulation of the input to H(P,P)
Message-ID: <20220610160615.00007726@reddwarf.jmc>
References: <N8GdnUDJ0IRRxjz_nZ2dnUU7_8zNnZ2d@giganews.com> <20220609232712.000066f9@reddwarf.jmc> <87ydnfwLL4kG6D__nZ2dnUU7_8xh4p2d@giganews.com> <20220610121102.00007ec0@reddwarf.jmc> <M7GdnWgvGYAr3D7_nZ2dnUU7_8zNnZ2d@giganews.com> <20220610142323.0000220d@reddwarf.jmc> <btSdnYCX8rZc2z7_nZ2dnUU7_8xh4p2d@giganews.com> <20220610142959.0000420e@reddwarf.jmc> <8PSdnZNSIaS11T7_nZ2dnUU7_81g4p2d@giganews.com> <20220610143549.000053e6@reddwarf.jmc> <nKGdnQ8wUuAI1z7_nZ2dnUU7_83NnZ2d@giganews.com> <20220610145124.00006b36@reddwarf.jmc> <oIKdneD0eqar0z7_nZ2dnUU7_83NnZ2d@giganews.com> <20220610150318.0000143d@reddwarf.jmc> <FIudncIf4s6fzz7_nZ2dnUU7_8xh4p2d@giganews.com> <20220610152154.000014c7@reddwarf.jmc> <EOydndJCqYmMyz7_nZ2dnUU7_83NnZ2d@giganews.com> <20220610153727.000015ca@reddwarf.jmc> <uN2dnUK2NLQ5xT7_nZ2dnUU7_8xh4p2d@giganews.com> <20220610154757.00001577@reddwarf.jmc> <BsydnUepqLWJxj7_nZ2dnUU7_8zNnZ2d@giganews.com>
Organization: Jupiter Mining Corp
X-Newsreader: Claws Mail 3.17.8 (GTK+ 2.24.33; x86_64-w64-mingw32)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: quoted-printable
Lines: 710
X-Complaints-To: abuse@eweka.nl
NNTP-Posting-Date: Fri, 10 Jun 2022 15:06:15 UTC
Date: Fri, 10 Jun 2022 16:06:15 +0100
X-Received-Bytes: 41502
 by: Mr Flibble - Fri, 10 Jun 2022 15:06 UTC

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

> On 6/10/2022 9:47 AM, Mr Flibble wrote:
> > 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
> >
>
> My proof has gotten down to the point that it is proven correct on
> the basis of easily verified facts. Lying cheating bastards disagree
> with these easily verified facts.

Click here to read the complete article

Re: Proving that P(P) != the correct x86 emulation of the input to H(P,P)

<zp6dneOPmo60_T7_nZ2dnUU7_83NnZ2d@giganews.com>

  copy mid

https://www.novabbs.com/computers/article-flat.php?id=9307&group=comp.ai.philosophy#9307

  copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Fri, 10 Jun 2022 10:15:53 -0500
Date: Fri, 10 Jun 2022 10:15:52 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.10.0
Subject: Re: Proving that P(P) != the correct x86 emulation of the input to
H(P,P)
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <N8GdnUDJ0IRRxjz_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220609232712.000066f9@reddwarf.jmc>
<87ydnfwLL4kG6D__nZ2dnUU7_8xh4p2d@giganews.com>
<20220610121102.00007ec0@reddwarf.jmc>
<M7GdnWgvGYAr3D7_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220610142323.0000220d@reddwarf.jmc>
<btSdnYCX8rZc2z7_nZ2dnUU7_8xh4p2d@giganews.com>
<20220610142959.0000420e@reddwarf.jmc>
<8PSdnZNSIaS11T7_nZ2dnUU7_81g4p2d@giganews.com>
<20220610143549.000053e6@reddwarf.jmc>
<nKGdnQ8wUuAI1z7_nZ2dnUU7_83NnZ2d@giganews.com>
<20220610145124.00006b36@reddwarf.jmc>
<oIKdneD0eqar0z7_nZ2dnUU7_83NnZ2d@giganews.com>
<20220610150318.0000143d@reddwarf.jmc>
<FIudncIf4s6fzz7_nZ2dnUU7_8xh4p2d@giganews.com>
<20220610152154.000014c7@reddwarf.jmc>
<EOydndJCqYmMyz7_nZ2dnUU7_83NnZ2d@giganews.com>
<20220610153727.000015ca@reddwarf.jmc>
<uN2dnUK2NLQ5xT7_nZ2dnUU7_8xh4p2d@giganews.com>
<20220610154757.00001577@reddwarf.jmc>
<BsydnUepqLWJxj7_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220610160615.00007726@reddwarf.jmc>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <20220610160615.00007726@reddwarf.jmc>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <zp6dneOPmo60_T7_nZ2dnUU7_83NnZ2d@giganews.com>
Lines: 708
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-lAR5e9dKN081p1PgEOYQI+bwQ0I7mnOeg9s33151HF1ovWLbQ0yI/eaSyBKS4n7cLbYeQvO3kJa0h0u!j/SoRAaWAZyHCrkHYXiClpnVn1igC5I41Vqg2hbmyHfyZ+fKmWab10VyXs6ifPaCnIT04X6r4b/F
X-Complaints-To: abuse@giganews.com
X-DMCA-Notifications: http://www.giganews.com/info/dmca.html
X-Abuse-and-DMCA-Info: Please be sure to forward a copy of ALL headers
X-Abuse-and-DMCA-Info: Otherwise we will be unable to process your complaint properly
X-Postfilter: 1.3.40
X-Original-Bytes: 41784
 by: olcott - Fri, 10 Jun 2022 15:15 UTC

On 6/10/2022 10:06 AM, Mr Flibble wrote:
> On Fri, 10 Jun 2022 09:54:10 -0500
> olcott <NoOne@NoWhere.com> wrote:
>
>> On 6/10/2022 9:47 AM, Mr Flibble wrote:
>>> 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
>>>
>>
>> My proof has gotten down to the point that it is proven correct on
>> the basis of easily verified facts. Lying cheating bastards disagree
>> with these easily verified facts.
>
> Why don't you just take a step back for a minute and consider what if
> you are wrong and there isn't actually a grand conspiracy of liars
> acting against you?


Click here to read the complete article
Re: Proving that P(P) != the correct x86 emulation of the input to H(P,P)

<20220610161958.00006f0a@reddwarf.jmc>

  copy mid

https://www.novabbs.com/computers/article-flat.php?id=9308&group=comp.ai.philosophy#9308

  copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Path: i2pn2.org!i2pn.org!weretis.net!feeder8.news.weretis.net!news.uzoreto.com!feeder.usenetexpress.com!tr1.eu1.usenetexpress.com!81.171.65.13.MISMATCH!peer01.ams4!peer.am4.highwinds-media.com!news.highwinds-media.com!fx14.ams4.POSTED!not-for-mail
From: flib...@reddwarf.jmc (Mr Flibble)
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
Subject: Re: Proving that P(P) != the correct x86 emulation of the input to H(P,P)
Message-ID: <20220610161958.00006f0a@reddwarf.jmc>
References: <N8GdnUDJ0IRRxjz_nZ2dnUU7_8zNnZ2d@giganews.com> <20220610121102.00007ec0@reddwarf.jmc> <M7GdnWgvGYAr3D7_nZ2dnUU7_8zNnZ2d@giganews.com> <20220610142323.0000220d@reddwarf.jmc> <btSdnYCX8rZc2z7_nZ2dnUU7_8xh4p2d@giganews.com> <20220610142959.0000420e@reddwarf.jmc> <8PSdnZNSIaS11T7_nZ2dnUU7_81g4p2d@giganews.com> <20220610143549.000053e6@reddwarf.jmc> <nKGdnQ8wUuAI1z7_nZ2dnUU7_83NnZ2d@giganews.com> <20220610145124.00006b36@reddwarf.jmc> <oIKdneD0eqar0z7_nZ2dnUU7_83NnZ2d@giganews.com> <20220610150318.0000143d@reddwarf.jmc> <FIudncIf4s6fzz7_nZ2dnUU7_8xh4p2d@giganews.com> <20220610152154.000014c7@reddwarf.jmc> <EOydndJCqYmMyz7_nZ2dnUU7_83NnZ2d@giganews.com> <20220610153727.000015ca@reddwarf.jmc> <uN2dnUK2NLQ5xT7_nZ2dnUU7_8xh4p2d@giganews.com> <20220610154757.00001577@reddwarf.jmc> <BsydnUepqLWJxj7_nZ2dnUU7_8zNnZ2d@giganews.com> <20220610160615.00007726@reddwarf.jmc> <zp6dneOPmo60_T7_nZ2dnUU7_83NnZ2d@giganews.com>
Organization: Jupiter Mining Corp
X-Newsreader: Claws Mail 3.17.8 (GTK+ 2.24.33; x86_64-w64-mingw32)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: quoted-printable
Lines: 768
X-Complaints-To: abuse@eweka.nl
NNTP-Posting-Date: Fri, 10 Jun 2022 15:19:57 UTC
Date: Fri, 10 Jun 2022 16:19:58 +0100
X-Received-Bytes: 44163
 by: Mr Flibble - Fri, 10 Jun 2022 15:19 UTC

On Fri, 10 Jun 2022 10:15:52 -0500
olcott <NoOne@NoWhere.com> wrote:

> On 6/10/2022 10:06 AM, Mr Flibble wrote:
> > On Fri, 10 Jun 2022 09:54:10 -0500
> > olcott <NoOne@NoWhere.com> wrote:
> >
> >> On 6/10/2022 9:47 AM, Mr Flibble wrote:
> >>> 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
> >>>
> >>
> >> My proof has gotten down to the point that it is proven correct on
> >> the basis of easily verified facts. Lying cheating bastards
> >> disagree with these easily verified facts.
> >
> > Why don't you just take a step back for a minute and consider what
> > if you are wrong and there isn't actually a grand conspiracy of
> > liars acting against you?
>
> When I say that H(P,P)==0 on the basis of the actual behavior of the
> actual input all of the rebuttals are of the form that H is wrong on
> the basis of the behavior of a non-input.


Click here to read the complete article
Re: Proving that P(P) != the correct x86 emulation of the input to H(P,P)

<8ZudnX-C1a3u_j7_nZ2dnUU7_8zNnZ2d@giganews.com>

  copy mid

https://www.novabbs.com/computers/article-flat.php?id=9309&group=comp.ai.philosophy#9309

  copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Path: i2pn2.org!rocksolid2!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Fri, 10 Jun 2022 10:29:55 -0500
Date: Fri, 10 Jun 2022 10:29:54 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.10.0
Subject: Re: Proving that P(P) != the correct x86 emulation of the input to
H(P,P)
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <N8GdnUDJ0IRRxjz_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220610121102.00007ec0@reddwarf.jmc>
<M7GdnWgvGYAr3D7_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220610142323.0000220d@reddwarf.jmc>
<btSdnYCX8rZc2z7_nZ2dnUU7_8xh4p2d@giganews.com>
<20220610142959.0000420e@reddwarf.jmc>
<8PSdnZNSIaS11T7_nZ2dnUU7_81g4p2d@giganews.com>
<20220610143549.000053e6@reddwarf.jmc>
<nKGdnQ8wUuAI1z7_nZ2dnUU7_83NnZ2d@giganews.com>
<20220610145124.00006b36@reddwarf.jmc>
<oIKdneD0eqar0z7_nZ2dnUU7_83NnZ2d@giganews.com>
<20220610150318.0000143d@reddwarf.jmc>
<FIudncIf4s6fzz7_nZ2dnUU7_8xh4p2d@giganews.com>
<20220610152154.000014c7@reddwarf.jmc>
<EOydndJCqYmMyz7_nZ2dnUU7_83NnZ2d@giganews.com>
<20220610153727.000015ca@reddwarf.jmc>
<uN2dnUK2NLQ5xT7_nZ2dnUU7_8xh4p2d@giganews.com>
<20220610154757.00001577@reddwarf.jmc>
<BsydnUepqLWJxj7_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220610160615.00007726@reddwarf.jmc>
<zp6dneOPmo60_T7_nZ2dnUU7_83NnZ2d@giganews.com>
<20220610161958.00006f0a@reddwarf.jmc>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <20220610161958.00006f0a@reddwarf.jmc>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <8ZudnX-C1a3u_j7_nZ2dnUU7_8zNnZ2d@giganews.com>
Lines: 739
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-0MtEig6nepg7sw2+Z4+bBfemcLDLdqImokMtHrt7QYJKp/b081TbSG7vr0d1ZejgWX1yJ5qUOhSDJ/l!VLu0HX8H0CJ/FdqXP+u6z6tl5zRo+NSAKAL1ZX4PtO5gfO/Uud7rIHvP7WiVatq7DRO/6NQwB1vv
X-Complaints-To: abuse@giganews.com
X-DMCA-Notifications: http://www.giganews.com/info/dmca.html
X-Abuse-and-DMCA-Info: Please be sure to forward a copy of ALL headers
X-Abuse-and-DMCA-Info: Otherwise we will be unable to process your complaint properly
X-Postfilter: 1.3.40
X-Original-Bytes: 44349
 by: olcott - Fri, 10 Jun 2022 15:29 UTC

On 6/10/2022 10:19 AM, Mr Flibble wrote:
> On Fri, 10 Jun 2022 10:15:52 -0500
> olcott <NoOne@NoWhere.com> wrote:
>
>> On 6/10/2022 10:06 AM, Mr Flibble wrote:
>>> On Fri, 10 Jun 2022 09:54:10 -0500
>>> olcott <NoOne@NoWhere.com> wrote:
>>>
>>>> On 6/10/2022 9:47 AM, Mr Flibble wrote:
>>>>> 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
>>>>>
>>>>
>>>> My proof has gotten down to the point that it is proven correct on
>>>> the basis of easily verified facts. Lying cheating bastards
>>>> disagree with these easily verified facts.
>>>
>>> Why don't you just take a step back for a minute and consider what
>>> if you are wrong and there isn't actually a grand conspiracy of
>>> liars acting against you?
>>
>> When I say that H(P,P)==0 on the basis of the actual behavior of the
>> actual input all of the rebuttals are of the form that H is wrong on
>> the basis of the behavior of a non-input.
>
> A halting P isn't non-input though; your H gets the answer wrong if
> P would have halted after calling H and H isn't a recursive call into a
> simulator.
>
> /Flibble
>


Click here to read the complete article
Re: Proving that P(P) != the correct x86 emulation of the input to H(P,P)

<20220610163735.000057bc@reddwarf.jmc>

  copy mid

https://www.novabbs.com/computers/article-flat.php?id=9310&group=comp.ai.philosophy#9310

  copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Path: i2pn2.org!i2pn.org!weretis.net!feeder8.news.weretis.net!feeder1.feed.usenet.farm!feed.usenet.farm!feeder.usenetexpress.com!tr1.eu1.usenetexpress.com!81.171.65.13.MISMATCH!peer01.ams4!peer.am4.highwinds-media.com!news.highwinds-media.com!fx14.ams4.POSTED!not-for-mail
From: flib...@reddwarf.jmc (Mr Flibble)
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
Subject: Re: Proving that P(P) != the correct x86 emulation of the input to H(P,P)
Message-ID: <20220610163735.000057bc@reddwarf.jmc>
References: <N8GdnUDJ0IRRxjz_nZ2dnUU7_8zNnZ2d@giganews.com> <20220610142323.0000220d@reddwarf.jmc> <btSdnYCX8rZc2z7_nZ2dnUU7_8xh4p2d@giganews.com> <20220610142959.0000420e@reddwarf.jmc> <8PSdnZNSIaS11T7_nZ2dnUU7_81g4p2d@giganews.com> <20220610143549.000053e6@reddwarf.jmc> <nKGdnQ8wUuAI1z7_nZ2dnUU7_83NnZ2d@giganews.com> <20220610145124.00006b36@reddwarf.jmc> <oIKdneD0eqar0z7_nZ2dnUU7_83NnZ2d@giganews.com> <20220610150318.0000143d@reddwarf.jmc> <FIudncIf4s6fzz7_nZ2dnUU7_8xh4p2d@giganews.com> <20220610152154.000014c7@reddwarf.jmc> <EOydndJCqYmMyz7_nZ2dnUU7_83NnZ2d@giganews.com> <20220610153727.000015ca@reddwarf.jmc> <uN2dnUK2NLQ5xT7_nZ2dnUU7_8xh4p2d@giganews.com> <20220610154757.00001577@reddwarf.jmc> <BsydnUepqLWJxj7_nZ2dnUU7_8zNnZ2d@giganews.com> <20220610160615.00007726@reddwarf.jmc> <zp6dneOPmo60_T7_nZ2dnUU7_83NnZ2d@giganews.com> <20220610161958.00006f0a@reddwarf.jmc> <8ZudnX-C1a3u_j7_nZ2dnUU7_8zNnZ2d@giganews.com>
Organization: Jupiter Mining Corp
X-Newsreader: Claws Mail 3.17.8 (GTK+ 2.24.33; x86_64-w64-mingw32)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: quoted-printable
Lines: 818
X-Complaints-To: abuse@eweka.nl
NNTP-Posting-Date: Fri, 10 Jun 2022 15:37:34 UTC
Date: Fri, 10 Jun 2022 16:37:35 +0100
X-Received-Bytes: 47454
 by: Mr Flibble - Fri, 10 Jun 2022 15:37 UTC

On Fri, 10 Jun 2022 10:29:54 -0500
olcott <NoOne@NoWhere.com> wrote:

> On 6/10/2022 10:19 AM, Mr Flibble wrote:
> > On Fri, 10 Jun 2022 10:15:52 -0500
> > olcott <NoOne@NoWhere.com> wrote:
> >
> >> On 6/10/2022 10:06 AM, Mr Flibble wrote:
> >>> On Fri, 10 Jun 2022 09:54:10 -0500
> >>> olcott <NoOne@NoWhere.com> wrote:
> >>>
> >>>> On 6/10/2022 9:47 AM, Mr Flibble wrote:
> >>>>> 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
> >>>>>
> >>>>
> >>>> My proof has gotten down to the point that it is proven correct
> >>>> on the basis of easily verified facts. Lying cheating bastards
> >>>> disagree with these easily verified facts.
> >>>
> >>> Why don't you just take a step back for a minute and consider what
> >>> if you are wrong and there isn't actually a grand conspiracy of
> >>> liars acting against you?
> >>
> >> When I say that H(P,P)==0 on the basis of the actual behavior of
> >> the actual input all of the rebuttals are of the form that H is
> >> wrong on the basis of the behavior of a non-input.
> >
> > A halting P isn't non-input though; your H gets the answer wrong if
> > P would have halted after calling H and H isn't a recursive call
> > into a simulator.
> >
> > /Flibble
> >
>
> You don't even understand the simple concept of unreachable code.


Click here to read the complete article
Re: Proving that P(P) != the correct x86 emulation of the input to H(P,P)

<5YSdncjj4qcd-z7_nZ2dnUU7_8zNnZ2d@giganews.com>

  copy mid

https://www.novabbs.com/computers/article-flat.php?id=9311&group=comp.ai.philosophy#9311

  copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Fri, 10 Jun 2022 10:42:56 -0500
Date: Fri, 10 Jun 2022 10:42:55 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.10.0
Subject: Re: Proving that P(P) != the correct x86 emulation of the input to
H(P,P)
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <N8GdnUDJ0IRRxjz_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220610142323.0000220d@reddwarf.jmc>
<btSdnYCX8rZc2z7_nZ2dnUU7_8xh4p2d@giganews.com>
<20220610142959.0000420e@reddwarf.jmc>
<8PSdnZNSIaS11T7_nZ2dnUU7_81g4p2d@giganews.com>
<20220610143549.000053e6@reddwarf.jmc>
<nKGdnQ8wUuAI1z7_nZ2dnUU7_83NnZ2d@giganews.com>
<20220610145124.00006b36@reddwarf.jmc>
<oIKdneD0eqar0z7_nZ2dnUU7_83NnZ2d@giganews.com>
<20220610150318.0000143d@reddwarf.jmc>
<FIudncIf4s6fzz7_nZ2dnUU7_8xh4p2d@giganews.com>
<20220610152154.000014c7@reddwarf.jmc>
<EOydndJCqYmMyz7_nZ2dnUU7_83NnZ2d@giganews.com>
<20220610153727.000015ca@reddwarf.jmc>
<uN2dnUK2NLQ5xT7_nZ2dnUU7_8xh4p2d@giganews.com>
<20220610154757.00001577@reddwarf.jmc>
<BsydnUepqLWJxj7_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220610160615.00007726@reddwarf.jmc>
<zp6dneOPmo60_T7_nZ2dnUU7_83NnZ2d@giganews.com>
<20220610161958.00006f0a@reddwarf.jmc>
<8ZudnX-C1a3u_j7_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220610163735.000057bc@reddwarf.jmc>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <20220610163735.000057bc@reddwarf.jmc>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <5YSdncjj4qcd-z7_nZ2dnUU7_8zNnZ2d@giganews.com>
Lines: 787
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-Odfvlc2eFt8L7MgcG2nwYAlq5X8vyqw7Ry3PUs5QBYN/rBptn2/piwDz5lVwqGW2pDarlL+N38Tn1lY!6T0juQfdle6fcEop4FNUjyGIsnsP5T2oHddefvhtyZPAJANU4I1yZnEgWX5ELTb3jPQGOnnXn3p6
X-Complaints-To: abuse@giganews.com
X-DMCA-Notifications: http://www.giganews.com/info/dmca.html
X-Abuse-and-DMCA-Info: Please be sure to forward a copy of ALL headers
X-Abuse-and-DMCA-Info: Otherwise we will be unable to process your complaint properly
X-Postfilter: 1.3.40
X-Original-Bytes: 47568
 by: olcott - Fri, 10 Jun 2022 15:42 UTC

On 6/10/2022 10:37 AM, Mr Flibble wrote:
> On Fri, 10 Jun 2022 10:29:54 -0500
> olcott <NoOne@NoWhere.com> wrote:
>
>> On 6/10/2022 10:19 AM, Mr Flibble wrote:
>>> On Fri, 10 Jun 2022 10:15:52 -0500
>>> olcott <NoOne@NoWhere.com> wrote:
>>>
>>>> On 6/10/2022 10:06 AM, Mr Flibble wrote:
>>>>> On Fri, 10 Jun 2022 09:54:10 -0500
>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>
>>>>>> On 6/10/2022 9:47 AM, Mr Flibble wrote:
>>>>>>> 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
>>>>>>>
>>>>>>
>>>>>> My proof has gotten down to the point that it is proven correct
>>>>>> on the basis of easily verified facts. Lying cheating bastards
>>>>>> disagree with these easily verified facts.
>>>>>
>>>>> Why don't you just take a step back for a minute and consider what
>>>>> if you are wrong and there isn't actually a grand conspiracy of
>>>>> liars acting against you?
>>>>
>>>> When I say that H(P,P)==0 on the basis of the actual behavior of
>>>> the actual input all of the rebuttals are of the form that H is
>>>> wrong on the basis of the behavior of a non-input.
>>>
>>> A halting P isn't non-input though; your H gets the answer wrong if
>>> P would have halted after calling H and H isn't a recursive call
>>> into a simulator.
>>>
>>> /Flibble
>>>
>>
>> You don't even understand the simple concept of unreachable code.
>
> I do though.


Click here to read the complete article
Re: Proving that P(P) != the correct x86 emulation of the input to H(P,P)

<rEJoK.22451$6P.20114@fx38.iad>

  copy mid

https://www.novabbs.com/computers/article-flat.php?id=9312&group=comp.ai.philosophy#9312

  copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Path: i2pn2.org!i2pn.org!aioe.org!news.uzoreto.com!feeder.usenetexpress.com!tr3.eu1.usenetexpress.com!feeder1.feed.usenet.farm!feed.usenet.farm!peer02.ams4!peer.am4.highwinds-media.com!peer01.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx38.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0) Gecko/20100101 Thunderbird/91.10.0
Subject: Re: Proving that P(P) != the correct x86 emulation of the input to H(P,P)
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <N8GdnUDJ0IRRxjz_nZ2dnUU7_8zNnZ2d@giganews.com> <56OdnYEQJIev-z__nZ2dnUU7_83NnZ2d@giganews.com> <7_toK.131290$JVi.111799@fx17.iad> <qp-dndDi7NIb8j__nZ2dnUU7_8zNnZ2d@giganews.com> <20220609231524.000077bb@reddwarf.jmc> <MZGdnQUbkcpd7D__nZ2dnUU7_8xh4p2d@giganews.com> <20220609232712.000066f9@reddwarf.jmc> <87ydnfwLL4kG6D__nZ2dnUU7_8xh4p2d@giganews.com> <20220610121102.00007ec0@reddwarf.jmc> <M7GdnWgvGYAr3D7_nZ2dnUU7_8zNnZ2d@giganews.com> <20220610142323.0000220d@reddwarf.jmc> <btSdnYCX8rZc2z7_nZ2dnUU7_8xh4p2d@giganews.com> <20220610142959.0000420e@reddwarf.jmc> <8PSdnZNSIaS11T7_nZ2dnUU7_81g4p2d@giganews.com> <20220610143549.000053e6@reddwarf.jmc> <nKGdnQ8wUuAI1z7_nZ2dnUU7_83NnZ2d@giganews.com> <20220610145124.00006b36@reddwarf.jmc> <oIKdneD0eqar0z7_nZ2dnUU7_83NnZ2d@giganews.com> <20220610150318.0000143d@reddwarf.jmc> <FIudncIf4s6fzz7_nZ2dnUU7_8xh4p2d@giganews.com> <20220610152154.000014c7@reddwarf.jmc> <EOydndJCqYmMyz7_nZ2dnUU7_83NnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <EOydndJCqYmMyz7_nZ2dnUU7_83NnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Lines: 55
Message-ID: <rEJoK.22451$6P.20114@fx38.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Fri, 10 Jun 2022 11:43:19 -0400
X-Received-Bytes: 4477
 by: Richard Damon - Fri, 10 Jun 2022 15:43 UTC

On 6/10/22 10:32 AM, olcott wrote:

> That I prove that H(P,P)==0 by itself refutes the halting problem proofs
> that claim that neither 0 nor 1 is correct.
>

Except that the fact that P(P) Halts if H(P,P) returns 0 (stipulated to
be a rejection), and the DEFINITION of a Halting Decider is that a
Halting Decider accepts a representation of a Halting Computation and
reject only representations of non-halting computation.

A Halting Decider also needs to be able to be given a representation of
ANY computation.

Since H rejected the natural representation of the computation P(P) and
that computation halts, H failed to meet the definiton of a Halt Decider.

Thus, your proof is proved incorrect, or the logic system you used
inconsistent. The errors in the proof have been pointed out, and you
just refuese to look at them.

Since you logic introduces assumptions and definition not part of the
standard Field of Computation Theory, any inconsistency needs to be
presumed to come from those, and thus also show your proof is incorrect.

In other words, you have FAILED at your goal.

Note, you seem to misunderstand the meaning of the Halting Property, it
isn't that neither 0 or 1 is correct, as ALWAYS one of them WILL be
correct, it is just that the correct answer will never be the answer
that H itself gives.

If H(P,P) returns 0, then 1 would be correct as P(P) for the P built on
that H will halt, and if H(P,P) returns 1, then 0 would be correct as
the P(P) for the P built from THAT H will go into an infinite loop.

If H(P,P) fails to decide and not return, then 0 would be correct, but
not given by H.

Depending on WHICH version of your H is the one you are actually talking
about at a given time, we are either in the 1st or 3rd case, and you
logic conflates the two. If your H does give an answer, by the
construction of P, it will be wrong, and if H fails to answer, it fails
to meet the definition of a decider.

Because H needs to be a definite algorithm, it will always do exactly
the same thing when given the same input, so it is impossible for P to
see the 3rd case, while an independently asked H acts in the first.

You don't seem to accept this, but it IS a proven property, and you need
to show the flaw in that prove to be able to claim it happens, either by
showing an actual definite algorithm that does it (disproof by example)
or show a flaw in the basic proof (which you don't seem to understand).

Re: Proving that P(P) != the correct x86 emulation of the input to H(P,P)

<lIJoK.57237$X_i.54825@fx18.iad>

  copy mid

https://www.novabbs.com/computers/article-flat.php?id=9313&group=comp.ai.philosophy#9313

  copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Path: i2pn2.org!i2pn.org!usenet.blueworldhosting.com!feed1.usenet.blueworldhosting.com!peer02.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx18.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.10.0
Subject: Re: Proving that P(P) != the correct x86 emulation of the input to
H(P,P)
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <N8GdnUDJ0IRRxjz_nZ2dnUU7_8zNnZ2d@giganews.com>
<qp-dndDi7NIb8j__nZ2dnUU7_8zNnZ2d@giganews.com>
<20220609231524.000077bb@reddwarf.jmc>
<MZGdnQUbkcpd7D__nZ2dnUU7_8xh4p2d@giganews.com>
<20220609232712.000066f9@reddwarf.jmc>
<87ydnfwLL4kG6D__nZ2dnUU7_8xh4p2d@giganews.com>
<20220610121102.00007ec0@reddwarf.jmc>
<M7GdnWgvGYAr3D7_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220610142323.0000220d@reddwarf.jmc>
<btSdnYCX8rZc2z7_nZ2dnUU7_8xh4p2d@giganews.com>
<20220610142959.0000420e@reddwarf.jmc>
<8PSdnZNSIaS11T7_nZ2dnUU7_81g4p2d@giganews.com>
<20220610143549.000053e6@reddwarf.jmc>
<nKGdnQ8wUuAI1z7_nZ2dnUU7_83NnZ2d@giganews.com>
<20220610145124.00006b36@reddwarf.jmc>
<oIKdneD0eqar0z7_nZ2dnUU7_83NnZ2d@giganews.com>
<20220610150318.0000143d@reddwarf.jmc>
<FIudncIf4s6fzz7_nZ2dnUU7_8xh4p2d@giganews.com>
<20220610152154.000014c7@reddwarf.jmc>
<EOydndJCqYmMyz7_nZ2dnUU7_83NnZ2d@giganews.com>
<20220610153727.000015ca@reddwarf.jmc>
<uN2dnX22NLTxxD7_nZ2dnUU7_8xh4p2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <uN2dnX22NLTxxD7_nZ2dnUU7_8xh4p2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Lines: 22
Message-ID: <lIJoK.57237$X_i.54825@fx18.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Fri, 10 Jun 2022 11:47:29 -0400
X-Received-Bytes: 2808
 by: Richard Damon - Fri, 10 Jun 2022 15:47 UTC

On 6/10/22 10:47 AM, olcott wrote:
>
> That people with shit for brains think that is gets the wrong answer is
> no rebuttal at all.
>
> When I explain all of the details of how the answer is correct people
> with shit for brains simply disagree without pointing to any error in my
> reasoning.

Except that your logic works just as well in reverse. How do YOU know
that YOU aren't the one with shit for brains, and the problem is you
just can't tell the truth.

The obvious fact is that when you try to "explain" the details of your
answer, you need to avoid going into the actual details that actually
show what is happening, and stay at high level "obvious" observations.

It is a well established fact that these sorts of obviousl observations
have been the source for a great many flaws in logic in the past.

If you "proof" can't survive going into actual details, it isn't
actually a proof.

Re: Proving that P(P) != the correct x86 emulation of the input to H(P,P)

<20220610164734.00001fca@reddwarf.jmc>

  copy mid

https://www.novabbs.com/computers/article-flat.php?id=9314&group=comp.ai.philosophy#9314

  copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Path: i2pn2.org!i2pn.org!weretis.net!feeder8.news.weretis.net!news.uzoreto.com!feeder.usenetexpress.com!tr1.eu1.usenetexpress.com!81.171.65.13.MISMATCH!peer01.ams4!peer.am4.highwinds-media.com!news.highwinds-media.com!fx14.ams4.POSTED!not-for-mail
From: flib...@reddwarf.jmc (Mr Flibble)
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
Subject: Re: Proving that P(P) != the correct x86 emulation of the input to H(P,P)
Message-ID: <20220610164734.00001fca@reddwarf.jmc>
References: <N8GdnUDJ0IRRxjz_nZ2dnUU7_8zNnZ2d@giganews.com> <20220610142959.0000420e@reddwarf.jmc> <8PSdnZNSIaS11T7_nZ2dnUU7_81g4p2d@giganews.com> <20220610143549.000053e6@reddwarf.jmc> <nKGdnQ8wUuAI1z7_nZ2dnUU7_83NnZ2d@giganews.com> <20220610145124.00006b36@reddwarf.jmc> <oIKdneD0eqar0z7_nZ2dnUU7_83NnZ2d@giganews.com> <20220610150318.0000143d@reddwarf.jmc> <FIudncIf4s6fzz7_nZ2dnUU7_8xh4p2d@giganews.com> <20220610152154.000014c7@reddwarf.jmc> <EOydndJCqYmMyz7_nZ2dnUU7_83NnZ2d@giganews.com> <20220610153727.000015ca@reddwarf.jmc> <uN2dnUK2NLQ5xT7_nZ2dnUU7_8xh4p2d@giganews.com> <20220610154757.00001577@reddwarf.jmc> <BsydnUepqLWJxj7_nZ2dnUU7_8zNnZ2d@giganews.com> <20220610160615.00007726@reddwarf.jmc> <zp6dneOPmo60_T7_nZ2dnUU7_83NnZ2d@giganews.com> <20220610161958.00006f0a@reddwarf.jmc> <8ZudnX-C1a3u_j7_nZ2dnUU7_8zNnZ2d@giganews.com> <20220610163735.000057bc@reddwarf.jmc> <5YSdncjj4qcd-z7_nZ2dnUU7_8zNnZ2d@giganews.com>
Organization: Jupiter Mining Corp
X-Newsreader: Claws Mail 3.17.8 (GTK+ 2.24.33; x86_64-w64-mingw32)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: quoted-printable
Lines: 881
X-Complaints-To: abuse@eweka.nl
NNTP-Posting-Date: Fri, 10 Jun 2022 15:47:33 UTC
Date: Fri, 10 Jun 2022 16:47:34 +0100
X-Received-Bytes: 51677
 by: Mr Flibble - Fri, 10 Jun 2022 15:47 UTC

On Fri, 10 Jun 2022 10:42:55 -0500
olcott <NoOne@NoWhere.com> wrote:

> On 6/10/2022 10:37 AM, Mr Flibble wrote:
> > On Fri, 10 Jun 2022 10:29:54 -0500
> > olcott <NoOne@NoWhere.com> wrote:
> >
> >> On 6/10/2022 10:19 AM, Mr Flibble wrote:
> >>> On Fri, 10 Jun 2022 10:15:52 -0500
> >>> olcott <NoOne@NoWhere.com> wrote:
> >>>
> >>>> On 6/10/2022 10:06 AM, Mr Flibble wrote:
> >>>>> On Fri, 10 Jun 2022 09:54:10 -0500
> >>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>
> >>>>>> On 6/10/2022 9:47 AM, Mr Flibble wrote:
> >>>>>>> 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
> >>>>>>>
> >>>>>>
> >>>>>> My proof has gotten down to the point that it is proven correct
> >>>>>> on the basis of easily verified facts. Lying cheating bastards
> >>>>>> disagree with these easily verified facts.
> >>>>>
> >>>>> Why don't you just take a step back for a minute and consider
> >>>>> what if you are wrong and there isn't actually a grand
> >>>>> conspiracy of liars acting against you?
> >>>>
> >>>> When I say that H(P,P)==0 on the basis of the actual behavior of
> >>>> the actual input all of the rebuttals are of the form that H is
> >>>> wrong on the basis of the behavior of a non-input.
> >>>
> >>> A halting P isn't non-input though; your H gets the answer wrong
> >>> if P would have halted after calling H and H isn't a recursive
> >>> call into a simulator.
> >>>
> >>> /Flibble
> >>>
> >>
> >> You don't even understand the simple concept of unreachable code.
> >
> > I do though.
>
> You have proven that you do not even understand the simple concept of
> unreachable code. https://en.wikipedia.org/wiki/Unreachable_code
>
> >
> >>
> >> It is an easily verified fact that the actual behavior of the
> >> actual input to H(P,P) conclusively proves that it never reaches
> >> its "ret" instruction thus never halts.
> >
> > Unless P is a program which halts after calling H.
> >
> >>
> >> The complete and correct x86 emulation of the input to H(P,P) by H
> >> would never stop running.
> >
> > Not if P halts, i.e. invokes the decider but doesn't then
> > pathologically flip the result.
> >
> > /Flibble
> >
>
> Because you can't even understand the concept of unreachable code you
> are totally unqualified to review my work.

Click here to read the complete article

Re: Proving that P(P) != the correct x86 emulation of the input to H(P,P)

<3-6dndSSYsy29D7_nZ2dnUU7_83NnZ2d@giganews.com>

  copy mid

https://www.novabbs.com/computers/article-flat.php?id=9315&group=comp.ai.philosophy#9315

  copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Fri, 10 Jun 2022 10:54:19 -0500
Date: Fri, 10 Jun 2022 10:54:18 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.10.0
Subject: Re: Proving that P(P) != the correct x86 emulation of the input to
H(P,P)
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <N8GdnUDJ0IRRxjz_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220610142959.0000420e@reddwarf.jmc>
<8PSdnZNSIaS11T7_nZ2dnUU7_81g4p2d@giganews.com>
<20220610143549.000053e6@reddwarf.jmc>
<nKGdnQ8wUuAI1z7_nZ2dnUU7_83NnZ2d@giganews.com>
<20220610145124.00006b36@reddwarf.jmc>
<oIKdneD0eqar0z7_nZ2dnUU7_83NnZ2d@giganews.com>
<20220610150318.0000143d@reddwarf.jmc>
<FIudncIf4s6fzz7_nZ2dnUU7_8xh4p2d@giganews.com>
<20220610152154.000014c7@reddwarf.jmc>
<EOydndJCqYmMyz7_nZ2dnUU7_83NnZ2d@giganews.com>
<20220610153727.000015ca@reddwarf.jmc>
<uN2dnUK2NLQ5xT7_nZ2dnUU7_8xh4p2d@giganews.com>
<20220610154757.00001577@reddwarf.jmc>
<BsydnUepqLWJxj7_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220610160615.00007726@reddwarf.jmc>
<zp6dneOPmo60_T7_nZ2dnUU7_83NnZ2d@giganews.com>
<20220610161958.00006f0a@reddwarf.jmc>
<8ZudnX-C1a3u_j7_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220610163735.000057bc@reddwarf.jmc>
<5YSdncjj4qcd-z7_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220610164734.00001fca@reddwarf.jmc>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <20220610164734.00001fca@reddwarf.jmc>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <3-6dndSSYsy29D7_nZ2dnUU7_83NnZ2d@giganews.com>
Lines: 866
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-rOy+x2uQ5Ga1YgEJWN6Ba7+j3iqIKolPYpA97DqRARctELnfmE/H55ebfT0+5CTbCTkAJRuzNEvaBQg!I3P6xCxn1NLeMk4IA75mVQpoYMaRgu5ufgZM8gyS5ncP7Xu14wyeEwxbEti3yC+5Nc4spc9VpJCP
X-Complaints-To: abuse@giganews.com
X-DMCA-Notifications: http://www.giganews.com/info/dmca.html
X-Abuse-and-DMCA-Info: Please be sure to forward a copy of ALL headers
X-Abuse-and-DMCA-Info: Otherwise we will be unable to process your complaint properly
X-Postfilter: 1.3.40
X-Original-Bytes: 52425
 by: olcott - Fri, 10 Jun 2022 15:54 UTC

On 6/10/2022 10:47 AM, Mr Flibble wrote:
> On Fri, 10 Jun 2022 10:42:55 -0500
> olcott <NoOne@NoWhere.com> wrote:
>
>> On 6/10/2022 10:37 AM, Mr Flibble wrote:
>>> On Fri, 10 Jun 2022 10:29:54 -0500
>>> olcott <NoOne@NoWhere.com> wrote:
>>>
>>>> On 6/10/2022 10:19 AM, Mr Flibble wrote:
>>>>> On Fri, 10 Jun 2022 10:15:52 -0500
>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>
>>>>>> On 6/10/2022 10:06 AM, Mr Flibble wrote:
>>>>>>> On Fri, 10 Jun 2022 09:54:10 -0500
>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>
>>>>>>>> On 6/10/2022 9:47 AM, Mr Flibble wrote:
>>>>>>>>> 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
>>>>>>>>>
>>>>>>>>
>>>>>>>> My proof has gotten down to the point that it is proven correct
>>>>>>>> on the basis of easily verified facts. Lying cheating bastards
>>>>>>>> disagree with these easily verified facts.
>>>>>>>
>>>>>>> Why don't you just take a step back for a minute and consider
>>>>>>> what if you are wrong and there isn't actually a grand
>>>>>>> conspiracy of liars acting against you?
>>>>>>
>>>>>> When I say that H(P,P)==0 on the basis of the actual behavior of
>>>>>> the actual input all of the rebuttals are of the form that H is
>>>>>> wrong on the basis of the behavior of a non-input.
>>>>>
>>>>> A halting P isn't non-input though; your H gets the answer wrong
>>>>> if P would have halted after calling H and H isn't a recursive
>>>>> call into a simulator.
>>>>>
>>>>> /Flibble
>>>>>
>>>>
>>>> You don't even understand the simple concept of unreachable code.
>>>
>>> I do though.
>>
>> You have proven that you do not even understand the simple concept of
>> unreachable code. https://en.wikipedia.org/wiki/Unreachable_code
>>
>>>
>>>>
>>>> It is an easily verified fact that the actual behavior of the
>>>> actual input to H(P,P) conclusively proves that it never reaches
>>>> its "ret" instruction thus never halts.
>>>
>>> Unless P is a program which halts after calling H.
>>>
>>>>
>>>> The complete and correct x86 emulation of the input to H(P,P) by H
>>>> would never stop running.
>>>
>>> Not if P halts, i.e. invokes the decider but doesn't then
>>> pathologically flip the result.
>>>
>>> /Flibble
>>>
>>
>> Because you can't even understand the concept of unreachable code you
>> are totally unqualified to review my work.
>
> I do though ergo I am totally qualified to review your work.
>
> The parts of P that are unreachable when P is invoked by your
> simulation bollocks are not unreachable when considered by a sane halt
> decider (which is what the halting problem proofs you are attempting to
> refute consider).
>
> /Flibble
>


Click here to read the complete article
Re: Proving that P(P) != the correct x86 emulation of the input to H(P,P)

<20220610165719.00000b46@reddwarf.jmc>

  copy mid

https://www.novabbs.com/computers/article-flat.php?id=9316&group=comp.ai.philosophy#9316

  copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Path: i2pn2.org!i2pn.org!usenet.blueworldhosting.com!feed1.usenet.blueworldhosting.com!peer03.iad!feed-me.highwinds-media.com!peer03.ams1!peer.ams1.xlned.com!news.xlned.com!peer03.ams4!peer.am4.highwinds-media.com!news.highwinds-media.com!fx14.ams4.POSTED!not-for-mail
From: flib...@reddwarf.jmc (Mr Flibble)
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
Subject: Re: Proving that P(P) != the correct x86 emulation of the input to
H(P,P)
Message-ID: <20220610165719.00000b46@reddwarf.jmc>
References: <N8GdnUDJ0IRRxjz_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220610143549.000053e6@reddwarf.jmc>
<nKGdnQ8wUuAI1z7_nZ2dnUU7_83NnZ2d@giganews.com>
<20220610145124.00006b36@reddwarf.jmc>
<oIKdneD0eqar0z7_nZ2dnUU7_83NnZ2d@giganews.com>
<20220610150318.0000143d@reddwarf.jmc>
<FIudncIf4s6fzz7_nZ2dnUU7_8xh4p2d@giganews.com>
<20220610152154.000014c7@reddwarf.jmc>
<EOydndJCqYmMyz7_nZ2dnUU7_83NnZ2d@giganews.com>
<20220610153727.000015ca@reddwarf.jmc>
<uN2dnUK2NLQ5xT7_nZ2dnUU7_8xh4p2d@giganews.com>
<20220610154757.00001577@reddwarf.jmc>
<BsydnUepqLWJxj7_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220610160615.00007726@reddwarf.jmc>
<zp6dneOPmo60_T7_nZ2dnUU7_83NnZ2d@giganews.com>
<20220610161958.00006f0a@reddwarf.jmc>
<8ZudnX-C1a3u_j7_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220610163735.000057bc@reddwarf.jmc>
<5YSdncjj4qcd-z7_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220610164734.00001fca@reddwarf.jmc>
<3-6dndSSYsy29D7_nZ2dnUU7_83NnZ2d@giganews.com>
Organization: Jupiter Mining Corp
X-Newsreader: Claws Mail 3.17.8 (GTK+ 2.24.33; x86_64-w64-mingw32)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: quoted-printable
Lines: 951
X-Complaints-To: abuse@eweka.nl
NNTP-Posting-Date: Fri, 10 Jun 2022 15:57:19 UTC
Date: Fri, 10 Jun 2022 16:57:19 +0100
X-Received-Bytes: 56299
 by: Mr Flibble - Fri, 10 Jun 2022 15:57 UTC

On Fri, 10 Jun 2022 10:54:18 -0500
olcott <NoOne@NoWhere.com> wrote:

> On 6/10/2022 10:47 AM, Mr Flibble wrote:
> > On Fri, 10 Jun 2022 10:42:55 -0500
> > olcott <NoOne@NoWhere.com> wrote:
> >
> >> On 6/10/2022 10:37 AM, Mr Flibble wrote:
> >>> On Fri, 10 Jun 2022 10:29:54 -0500
> >>> olcott <NoOne@NoWhere.com> wrote:
> >>>
> >>>> On 6/10/2022 10:19 AM, Mr Flibble wrote:
> >>>>> On Fri, 10 Jun 2022 10:15:52 -0500
> >>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>
> >>>>>> On 6/10/2022 10:06 AM, Mr Flibble wrote:
> >>>>>>> On Fri, 10 Jun 2022 09:54:10 -0500
> >>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>
> >>>>>>>> On 6/10/2022 9:47 AM, Mr Flibble wrote:
> >>>>>>>>> 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
> >>>>>>>>>
> >>>>>>>>
> >>>>>>>> My proof has gotten down to the point that it is proven
> >>>>>>>> correct on the basis of easily verified facts. Lying
> >>>>>>>> cheating bastards disagree with these easily verified facts.
> >>>>>>>>
> >>>>>>>
> >>>>>>> Why don't you just take a step back for a minute and consider
> >>>>>>> what if you are wrong and there isn't actually a grand
> >>>>>>> conspiracy of liars acting against you?
> >>>>>>
> >>>>>> When I say that H(P,P)==0 on the basis of the actual behavior
> >>>>>> of the actual input all of the rebuttals are of the form that
> >>>>>> H is wrong on the basis of the behavior of a non-input.
> >>>>>
> >>>>> A halting P isn't non-input though; your H gets the answer wrong
> >>>>> if P would have halted after calling H and H isn't a recursive
> >>>>> call into a simulator.
> >>>>>
> >>>>> /Flibble
> >>>>>
> >>>>
> >>>> You don't even understand the simple concept of unreachable
> >>>> code.
> >>>
> >>> I do though.
> >>
> >> You have proven that you do not even understand the simple concept
> >> of unreachable code.
> >> https://en.wikipedia.org/wiki/Unreachable_code
> >>>
> >>>>
> >>>> It is an easily verified fact that the actual behavior of the
> >>>> actual input to H(P,P) conclusively proves that it never reaches
> >>>> its "ret" instruction thus never halts.
> >>>
> >>> Unless P is a program which halts after calling H.
> >>>
> >>>>
> >>>> The complete and correct x86 emulation of the input to H(P,P) by
> >>>> H would never stop running.
> >>>
> >>> Not if P halts, i.e. invokes the decider but doesn't then
> >>> pathologically flip the result.
> >>>
> >>> /Flibble
> >>>
> >>
> >> Because you can't even understand the concept of unreachable code
> >> you are totally unqualified to review my work.
> >
> > I do though ergo I am totally qualified to review your work.
> >
> > The parts of P that are unreachable when P is invoked by your
> > simulation bollocks are not unreachable when considered by a sane
> > halt decider (which is what the halting problem proofs you are
> > attempting to refute consider).
> >
> > /Flibble
> >
>
> _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]
>
> That you believe that the correctly emulated input to H(P,P) can ever
> get past the machine address of [000012f2] conclusively proves that
> you are totally incompetent to review my work.
>
> Some of your replies refer to changing the opcodes in the unreachable
> part of the code.

Click here to read the complete article

Pages:12345
server_pubkey.txt

rocksolid light 0.9.81
clearnet tor