Rocksolid Light

Welcome to novaBBS (click a section below)

mail  files  register  newsreader  groups  login

Message-ID:  

Lawrence Radiation Laboratory keeps all its data in an old gray trunk.

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

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=34140&group=comp.theory#34140

  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
>

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

--
Copyright 2022 Pete Olcott

"Talent hits a target no one else can hit;
Genius hits a target no one else can see."
Arthur Schopenhauer

SubjectRepliesAuthor
o No one has sufficiently addressed this H(P,P)==0

By: olcott on Thu, 9 Jun 2022

121olcott
server_pubkey.txt

rocksolid light 0.9.81
clearnet tor