Rocksolid Light

Welcome to novaBBS (click a section below)

mail  files  register  newsreader  groups  login

Message-ID:  

We have a equal opportunity Calculus class -- it's fully integrated.

devel / comp.theory / 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
+* No one has sufficiently addressed this H(P,P)==0Mikko
|`* No one has sufficiently addressed this H(P,P)==0olcott
| `- No one has sufficiently addressed this H(P,P)==0Richard Damon
+* No one has sufficiently addressed this H(P,P)==0Richard Damon
|`* No one has sufficiently addressed this H(P,P)==0olcott
| `- 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
|`* Proving that P(P) != the correct x86 emulation of the input to H(P,P)Richard Damon
| `* Proving that P(P) != the correct x86 emulation of the input toolcott
|  `* Proving that P(P) != the correct x86 emulation of the input toRichard Damon
|   `* Proving that P(P) != the correct x86 emulation of the input toolcott
|    `* Proving that P(P) != the correct x86 emulation of the input toMr Flibble
|     `* Proving that P(P) != the correct x86 emulation of the input toolcott
|      `* Proving that P(P) != the correct x86 emulation of the input to H(P,P)Mr Flibble
|       `* Proving that P(P) != the correct x86 emulation of the input toolcott
|        `* Proving that P(P) != the correct x86 emulation of the input toRichard Damon
|         `* Proving that P(P) != the correct x86 emulation of the input toolcott
|          `* Proving that P(P) != the correct x86 emulation of the input toRichard Damon
|           `* Proving that P(P) != the correct x86 emulation of the input toolcott
|            `* Proving that P(P) != the correct x86 emulation of the input toRichard Damon
|             `* Proving that P(P) != the correct x86 emulation of the input toolcott
|              `* Proving that P(P) != the correct x86 emulation of the input toRichard Damon
|               `* Proving that P(P) != the correct x86 emulation of the input toolcott
|                `* Proving that P(P) != the correct x86 emulation of the input toRichard Damon
|                 `* Proving that P(P) != the correct x86 emulation of the input toolcott
|                  `* Proving that P(P) != the correct x86 emulation of the input toRichard Damon
|                   `* Proving that P(P) != the correct x86 emulation of the input toolcott
|                    +* Proving that P(P) != the correct x86 emulation of the input toMr Flibble
|                    |`* Proving that P(P) != the correct x86 emulation of the input toolcott
|                    | +* Proving that P(P) != the correct x86 emulation of the input to H(P,P)Mr Flibble
|                    | |`* Proving that P(P) != the correct x86 emulation of the input toolcott
|                    | | `* Proving that P(P) != the correct x86 emulation of the input toMr Flibble
|                    | |  `* Proving that P(P) != the correct x86 emulation of the input toolcott
|                    | |   +* Proving that P(P) != the correct x86 emulation of the input toMr Flibble
|                    | |   |`* Proving that P(P) != the correct x86 emulation of the input toolcott
|                    | |   | `* Proving that P(P) != the correct x86 emulation of the input toMr Flibble
|                    | |   |  +- Proving that P(P) != the correct x86 emulation of the input toolcott
|                    | |   |  `* Proving that P(P) != the correct x86 emulation of the input toolcott
|                    | |   |   +* Proving that P(P) != the correct x86 emulation of the input toMr Flibble
|                    | |   |   |`* Proving that P(P) != the correct x86 emulation of the input toolcott
|                    | |   |   | `* Proving that P(P) != the correct x86 emulation of the input toMr Flibble
|                    | |   |   |  `* Proving that P(P) != the correct x86 emulation of the input toolcott
|                    | |   |   |   +* Proving that P(P) != the correct x86 emulation of the input to H(P,P)Mr Flibble
|                    | |   |   |   |`* Proving that P(P) != the correct x86 emulation of the input toolcott
|                    | |   |   |   | +* Proving that P(P) != the correct x86 emulation of the input toMr Flibble
|                    | |   |   |   | |`* Proving that P(P) != the correct x86 emulation of the input toolcott
|                    | |   |   |   | | +* Proving that P(P) != the correct x86 emulation of the input to H(P,P)Mr Flibble
|                    | |   |   |   | | |+- Proving that P(P) != the correct x86 emulation of the input to H(P,P)Mr Flibble
|                    | |   |   |   | | |+* Proving that P(P) != the correct x86 emulation of the input toolcott
|                    | |   |   |   | | ||`* Proving that P(P) != the correct x86 emulation of the input to H(P,P)Mr Flibble
|                    | |   |   |   | | || `* Proving that P(P) != the correct x86 emulation of the input toolcott
|                    | |   |   |   | | ||  +* Proving that P(P) != the correct x86 emulation of the input to H(P,P)Mr Flibble
|                    | |   |   |   | | ||  |`* Proving that P(P) != the correct x86 emulation of the input toolcott
|                    | |   |   |   | | ||  | `* Proving that P(P) != the correct x86 emulation of the input to H(P,P)Mr Flibble
|                    | |   |   |   | | ||  |  +* Proving that P(P) != the correct x86 emulation of the input toolcott
|                    | |   |   |   | | ||  |  |`* Proving that P(P) != the correct x86 emulation of the input to H(P,P)Mr Flibble
|                    | |   |   |   | | ||  |  | `* Proving that P(P) != the correct x86 emulation of the input toolcott
|                    | |   |   |   | | ||  |  |  +* Proving that P(P) != the correct x86 emulation of the input to H(P,P)Mr Flibble
|                    | |   |   |   | | ||  |  |  |`* Proving that P(P) != the correct x86 emulation of the input toolcott
|                    | |   |   |   | | ||  |  |  | +* Proving that P(P) != the correct x86 emulation of the input toMr Flibble
|                    | |   |   |   | | ||  |  |  | |`* Proving that P(P) != the correct x86 emulation of the input toolcott
|                    | |   |   |   | | ||  |  |  | | +* Proving that P(P) != the correct x86 emulation of the input toMr Flibble
|                    | |   |   |   | | ||  |  |  | | |`* Proving that P(P) != the correct x86 emulation of the input toolcott
|                    | |   |   |   | | ||  |  |  | | | `* Proving that P(P) != the correct x86 emulation of the input toMr Flibble
|                    | |   |   |   | | ||  |  |  | | |  `* Proving that P(P) != the correct x86 emulation of the input toolcott
|                    | |   |   |   | | ||  |  |  | | |   +- Proving that P(P) != the correct x86 emulation of the input to H(P,P)Richard Damon
|                    | |   |   |   | | ||  |  |  | | |   `* Proving that P(P) != the correct x86 emulation of the input to H(P,P)Mr Flibble
|                    | |   |   |   | | ||  |  |  | | |    `* Proving that P(P) != the correct x86 emulation of the input toolcott
|                    | |   |   |   | | ||  |  |  | | |     +* Proving that P(P) != the correct x86 emulation of the input toMr Flibble
|                    | |   |   |   | | ||  |  |  | | |     |`* Proving that P(P) != the correct x86 emulation of the input toolcott
|                    | |   |   |   | | ||  |  |  | | |     | `* Proving that P(P) != the correct x86 emulation of the input toMr Flibble
|                    | |   |   |   | | ||  |  |  | | |     |  +* Proving that P(P) != the correct x86 emulation of the input toMr Flibble
|                    | |   |   |   | | ||  |  |  | | |     |  |`* Proving that P(P) != the correct x86 emulation of the input toolcott
|                    | |   |   |   | | ||  |  |  | | |     |  | `- Proving that P(P) != the correct x86 emulation of the input toRichard Damon
|                    | |   |   |   | | ||  |  |  | | |     |  `* Proving that P(P) != the correct x86 emulation of the input toolcott
|                    | |   |   |   | | ||  |  |  | | |     |   `* Proving that P(P) != the correct x86 emulation of the input toMr Flibble
|                    | |   |   |   | | ||  |  |  | | |     |    `* Proving that P(P) != the correct x86 emulation of the input toolcott
|                    | |   |   |   | | ||  |  |  | | |     |     `* Proving that P(P) != the correct x86 emulation of the input toMr Flibble
|                    | |   |   |   | | ||  |  |  | | |     |      `* Proving that P(P) != the correct x86 emulation of the input toolcott
|                    | |   |   |   | | ||  |  |  | | |     |       +- Proving that P(P) != the correct x86 emulation of the input toRichard Damon
|                    | |   |   |   | | ||  |  |  | | |     |       `* Proving that P(P) != the correct x86 emulation of the input toMr Flibble
|                    | |   |   |   | | ||  |  |  | | |     |        `* Proving that P(P) != the correct x86 emulation of the input toolcott
|                    | |   |   |   | | ||  |  |  | | |     |         +- Proving that P(P) != the correct x86 emulation of the input toMr Flibble
|                    | |   |   |   | | ||  |  |  | | |     |         `- Proving that P(P) != the correct x86 emulation of the input to H(P,P)Richard Damon
|                    | |   |   |   | | ||  |  |  | | |     `- Proving that P(P) != the correct x86 emulation of the input toRichard Damon
|                    | |   |   |   | | ||  |  |  | | `- Proving that P(P) != the correct x86 emulation of the input toRichard Damon
|                    | |   |   |   | | ||  |  |  | `- Proving that P(P) != the correct x86 emulation of the input toRichard Damon
|                    | |   |   |   | | ||  |  |  +* Proving that P(P) != the correct x86 emulation of the input toPython
|                    | |   |   |   | | ||  |  |  |`* Proving that P(P) != the correct x86 emulation of the input toolcott
|                    | |   |   |   | | ||  |  |  | `* Proving that P(P) != the correct x86 emulation of the input toPython
|                    | |   |   |   | | ||  |  |  |  `* Proving that P(P) != the correct x86 emulation of the input toolcott
|                    | |   |   |   | | ||  |  |  |   `- Proving that P(P) != the correct x86 emulation of the input toRichard Damon
|                    | |   |   |   | | ||  |  |  `- Proving that P(P) != the correct x86 emulation of the input toRichard Damon
|                    | |   |   |   | | ||  |  `- Proving that P(P) != the correct x86 emulation of the input to H(P,P)Dennis Bush
|                    | |   |   |   | | ||  `* Proving that P(P) != the correct x86 emulation of the input toPython
|                    | |   |   |   | | ||   `* Proving that P(P) != the correct x86 emulation of the input toolcott
|                    | |   |   |   | | ||    `* Proving that P(P) != the correct x86 emulation of the input to H(P,P)Mr Flibble
|                    | |   |   |   | | ||     `* Proving that P(P) != the correct x86 emulation of the input toolcott
|                    | |   |   |   | | ||      `* Proving that P(P) != the correct x86 emulation of the input toMr Flibble
|                    | |   |   |   | | ||       `- Proving that P(P) != the correct x86 emulation of the input toolcott
|                    | |   |   |   | | |`* Proving that P(P) != the correct x86 emulation of the input toolcott
|                    | |   |   |   | | `- Proving that P(P) != the correct x86 emulation of the input to H(P,P)Richard Damon
|                    | |   |   |   | `- Proving that P(P) != the correct x86 emulation of the input toRichard Damon
|                    | |   |   |   +- Proving that P(P) != the correct x86 emulation of the input toPython
|                    | |   |   |   `- Proving that P(P) != the correct x86 emulation of the input toRichard Damon
|                    | |   |   `- Proving that P(P) != the correct x86 emulation of the input toRichard Damon
|                    | |   `- Proving that P(P) != the correct x86 emulation of the input toRichard Damon
|                    | `* Proving that P(P) != the correct x86 emulation of the input toRichard Damon
|                    `* Proving that P(P) != the correct x86 emulation of the input toRichard Damon
+* Proving that P(P) != the correct x86 emulation of the input to H(P,P)Keith Thompson
`* Proving that P(P) != the correct x86 emulation of the input toolcott

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

<56OdnYEQJIev-z__nZ2dnUU7_83NnZ2d@giganews.com>

  copy mid

https://www.novabbs.com/devel/article-flat.php?id=34075&group=comp.theory#34075

  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: Thu, 09 Jun 2022 16:29:22 -0500
Date: Thu, 9 Jun 2022 16:29:20 -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>
<nvudncJwjNiNiz__nZ2dnUU7_81g4p2d@giganews.com>
<bipoK.10513$Vxw.6751@fx07.iad>
<jdydnWlvi_kquD__nZ2dnUU7_8zNnZ2d@giganews.com>
<RMpoK.7650$x7oc.3519@fx01.iad>
<xJKdnb8LMeMztz__nZ2dnUU7_83NnZ2d@giganews.com>
<20220609182847.00007585@reddwarf.jmc>
<N-adnVHsgaLIrT__nZ2dnUU7_8xh4p2d@giganews.com>
<20220609184617.00002add@reddwarf.jmc>
<eJ6dnaW1z8lnrj__nZ2dnUU7_83NnZ2d@giganews.com>
<vKqoK.75291$GTEb.17970@fx48.iad>
<BYGdnY7xlufi1D__nZ2dnUU7_8zNnZ2d@giganews.com>
<J_roK.51524$ssF.13016@fx14.iad>
<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>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <PntoK.92394$J0r9.54835@fx11.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <56OdnYEQJIev-z__nZ2dnUU7_83NnZ2d@giganews.com>
Lines: 278
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-OoZAwMuw8aASgxFBZvHp55leu8BeMqoMuAYMmTqjEnICkn3Ie3OF9zDOK7qwutI/BVTng9tTQ5k1NzY!V/0fxpaqxCaLu2GO+TOgsq299ML3FrWheWmmN+Aj9dJm1ZdYW8Xnf7HwQbZDuVveoofLJ65eGhR6
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: 15117
 by: olcott - Thu, 9 Jun 2022 21:29 UTC

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.


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

<7_toK.131290$JVi.111799@fx17.iad>

  copy mid

https://www.novabbs.com/devel/article-flat.php?id=34076&group=comp.theory#34076

  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!fx17.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>
<nvudncJwjNiNiz__nZ2dnUU7_81g4p2d@giganews.com>
<bipoK.10513$Vxw.6751@fx07.iad>
<jdydnWlvi_kquD__nZ2dnUU7_8zNnZ2d@giganews.com>
<RMpoK.7650$x7oc.3519@fx01.iad>
<xJKdnb8LMeMztz__nZ2dnUU7_83NnZ2d@giganews.com>
<20220609182847.00007585@reddwarf.jmc>
<N-adnVHsgaLIrT__nZ2dnUU7_8xh4p2d@giganews.com>
<20220609184617.00002add@reddwarf.jmc>
<eJ6dnaW1z8lnrj__nZ2dnUU7_83NnZ2d@giganews.com>
<vKqoK.75291$GTEb.17970@fx48.iad>
<BYGdnY7xlufi1D__nZ2dnUU7_8zNnZ2d@giganews.com>
<J_roK.51524$ssF.13016@fx14.iad>
<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>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <56OdnYEQJIev-z__nZ2dnUU7_83NnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 301
Message-ID: <7_toK.131290$JVi.111799@fx17.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: Thu, 9 Jun 2022 17:54:11 -0400
X-Received-Bytes: 16283
 by: Richard Damon - Thu, 9 Jun 2022 21:54 UTC

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


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

<qp-dndDi7NIb8j__nZ2dnUU7_8zNnZ2d@giganews.com>

  copy mid

https://www.novabbs.com/devel/article-flat.php?id=34078&group=comp.theory#34078

  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: Thu, 09 Jun 2022 17:09:10 -0500
Date: Thu, 9 Jun 2022 17:09:08 -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>
<nvudncJwjNiNiz__nZ2dnUU7_81g4p2d@giganews.com>
<bipoK.10513$Vxw.6751@fx07.iad>
<jdydnWlvi_kquD__nZ2dnUU7_8zNnZ2d@giganews.com>
<RMpoK.7650$x7oc.3519@fx01.iad>
<xJKdnb8LMeMztz__nZ2dnUU7_83NnZ2d@giganews.com>
<20220609182847.00007585@reddwarf.jmc>
<N-adnVHsgaLIrT__nZ2dnUU7_8xh4p2d@giganews.com>
<20220609184617.00002add@reddwarf.jmc>
<eJ6dnaW1z8lnrj__nZ2dnUU7_83NnZ2d@giganews.com>
<vKqoK.75291$GTEb.17970@fx48.iad>
<BYGdnY7xlufi1D__nZ2dnUU7_8zNnZ2d@giganews.com>
<J_roK.51524$ssF.13016@fx14.iad>
<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>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <7_toK.131290$JVi.111799@fx17.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <qp-dndDi7NIb8j__nZ2dnUU7_8zNnZ2d@giganews.com>
Lines: 294
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-0QeQdjq//ftKBBXsn0qENN56SDv8rR5WI6nDMGgFgZRcG2tYCA0Bdlgbxp6iwq6l0wKz9dMac22CxT6!qGKICX7CWllwC08/QDFWlvM5+TJugGEtuGhi91MRnEr3M/4Wd/TVsLiSWS5V0CWf1xOjMxueEvyl
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: 16144
 by: olcott - Thu, 9 Jun 2022 22:09 UTC

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,


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

<20220609231524.000077bb@reddwarf.jmc>

  copy mid

https://www.novabbs.com/devel/article-flat.php?id=34079&group=comp.theory#34079

  copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Path: i2pn2.org!i2pn.org!aioe.org!feeder1.feed.usenet.farm!feed.usenet.farm!news.uzoreto.com!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!fx02.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: <20220609231524.000077bb@reddwarf.jmc>
References: <N8GdnUDJ0IRRxjz_nZ2dnUU7_8zNnZ2d@giganews.com>
<nvudncJwjNiNiz__nZ2dnUU7_81g4p2d@giganews.com>
<bipoK.10513$Vxw.6751@fx07.iad>
<jdydnWlvi_kquD__nZ2dnUU7_8zNnZ2d@giganews.com>
<RMpoK.7650$x7oc.3519@fx01.iad>
<xJKdnb8LMeMztz__nZ2dnUU7_83NnZ2d@giganews.com>
<20220609182847.00007585@reddwarf.jmc>
<N-adnVHsgaLIrT__nZ2dnUU7_8xh4p2d@giganews.com>
<20220609184617.00002add@reddwarf.jmc>
<eJ6dnaW1z8lnrj__nZ2dnUU7_83NnZ2d@giganews.com>
<vKqoK.75291$GTEb.17970@fx48.iad>
<BYGdnY7xlufi1D__nZ2dnUU7_8zNnZ2d@giganews.com>
<J_roK.51524$ssF.13016@fx14.iad>
<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>
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: 351
X-Complaints-To: abuse@eweka.nl
NNTP-Posting-Date: Thu, 09 Jun 2022 22:15:24 UTC
Date: Thu, 9 Jun 2022 23:15:24 +0100
X-Received-Bytes: 18948
 by: Mr Flibble - Thu, 9 Jun 2022 22:15 UTC

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.


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

<HjuoK.76731$ntj.3856@fx15.iad>

  copy mid

https://www.novabbs.com/devel/article-flat.php?id=34080&group=comp.theory#34080

  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!fx15.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>
<nvudncJwjNiNiz__nZ2dnUU7_81g4p2d@giganews.com>
<bipoK.10513$Vxw.6751@fx07.iad>
<jdydnWlvi_kquD__nZ2dnUU7_8zNnZ2d@giganews.com>
<RMpoK.7650$x7oc.3519@fx01.iad>
<xJKdnb8LMeMztz__nZ2dnUU7_83NnZ2d@giganews.com>
<20220609182847.00007585@reddwarf.jmc>
<N-adnVHsgaLIrT__nZ2dnUU7_8xh4p2d@giganews.com>
<20220609184617.00002add@reddwarf.jmc>
<eJ6dnaW1z8lnrj__nZ2dnUU7_83NnZ2d@giganews.com>
<vKqoK.75291$GTEb.17970@fx48.iad>
<BYGdnY7xlufi1D__nZ2dnUU7_8zNnZ2d@giganews.com>
<J_roK.51524$ssF.13016@fx14.iad>
<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>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <qp-dndDi7NIb8j__nZ2dnUU7_8zNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 300
Message-ID: <HjuoK.76731$ntj.3856@fx15.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: Thu, 9 Jun 2022 18:17:11 -0400
X-Received-Bytes: 16373
 by: Richard Damon - Thu, 9 Jun 2022 22:17 UTC

On 6/9/22 6:09 PM, olcott 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.
>
>
>


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

<MZGdnQUbkcpd7D__nZ2dnUU7_8xh4p2d@giganews.com>

  copy mid

https://www.novabbs.com/devel/article-flat.php?id=34081&group=comp.theory#34081

  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: Thu, 09 Jun 2022 17:18:40 -0500
Date: Thu, 9 Jun 2022 17:18:38 -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>
<nvudncJwjNiNiz__nZ2dnUU7_81g4p2d@giganews.com>
<bipoK.10513$Vxw.6751@fx07.iad>
<jdydnWlvi_kquD__nZ2dnUU7_8zNnZ2d@giganews.com>
<RMpoK.7650$x7oc.3519@fx01.iad>
<xJKdnb8LMeMztz__nZ2dnUU7_83NnZ2d@giganews.com>
<20220609182847.00007585@reddwarf.jmc>
<N-adnVHsgaLIrT__nZ2dnUU7_8xh4p2d@giganews.com>
<20220609184617.00002add@reddwarf.jmc>
<eJ6dnaW1z8lnrj__nZ2dnUU7_83NnZ2d@giganews.com>
<vKqoK.75291$GTEb.17970@fx48.iad>
<BYGdnY7xlufi1D__nZ2dnUU7_8zNnZ2d@giganews.com>
<J_roK.51524$ssF.13016@fx14.iad>
<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>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <20220609231524.000077bb@reddwarf.jmc>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <MZGdnQUbkcpd7D__nZ2dnUU7_8xh4p2d@giganews.com>
Lines: 313
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-81zjQwFHXe7/1/djsjKDt8snZD6PQnqkpVacnHrezH8uC77pGf2aO0rkgKgBN0H81VsCMVOspg80qB6!jPkCbkARE0HdZY85Gkz8YbYd09Tma9OKll7ABz4zpOduRvXM4y77XHc2TZ2v/RcMPYx2U7h6Vdk3
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: 17191
 by: olcott - Thu, 9 Jun 2022 22:18 UTC

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
>


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

<20220609232712.000066f9@reddwarf.jmc>

  copy mid

https://www.novabbs.com/devel/article-flat.php?id=34082&group=comp.theory#34082

  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!tr2.eu1.usenetexpress.com!feeder1.feed.usenet.farm!feed.usenet.farm!news-out.netnews.com!news.alt.net!fdc2.netnews.com!peer02.ams1!peer.ams1.xlned.com!news.xlned.com!peer03.ams4!peer.am4.highwinds-media.com!news.highwinds-media.com!fx02.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: <20220609232712.000066f9@reddwarf.jmc>
References: <N8GdnUDJ0IRRxjz_nZ2dnUU7_8zNnZ2d@giganews.com> <jdydnWlvi_kquD__nZ2dnUU7_8zNnZ2d@giganews.com> <RMpoK.7650$x7oc.3519@fx01.iad> <xJKdnb8LMeMztz__nZ2dnUU7_83NnZ2d@giganews.com> <20220609182847.00007585@reddwarf.jmc> <N-adnVHsgaLIrT__nZ2dnUU7_8xh4p2d@giganews.com> <20220609184617.00002add@reddwarf.jmc> <eJ6dnaW1z8lnrj__nZ2dnUU7_83NnZ2d@giganews.com> <vKqoK.75291$GTEb.17970@fx48.iad> <BYGdnY7xlufi1D__nZ2dnUU7_8zNnZ2d@giganews.com> <J_roK.51524$ssF.13016@fx14.iad> <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>
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: 360
X-Complaints-To: abuse@eweka.nl
NNTP-Posting-Date: Thu, 09 Jun 2022 22:27:12 UTC
Date: Thu, 9 Jun 2022 23:27:12 +0100
X-Received-Bytes: 19522
 by: Mr Flibble - Thu, 9 Jun 2022 22:27 UTC

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.

Click here to read the complete article

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

<9zuoK.44320$elob.20576@fx43.iad>

  copy mid

https://www.novabbs.com/devel/article-flat.php?id=34083&group=comp.theory#34083

  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!fx43.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>
<bipoK.10513$Vxw.6751@fx07.iad>
<jdydnWlvi_kquD__nZ2dnUU7_8zNnZ2d@giganews.com>
<RMpoK.7650$x7oc.3519@fx01.iad>
<xJKdnb8LMeMztz__nZ2dnUU7_83NnZ2d@giganews.com>
<20220609182847.00007585@reddwarf.jmc>
<N-adnVHsgaLIrT__nZ2dnUU7_8xh4p2d@giganews.com>
<20220609184617.00002add@reddwarf.jmc>
<eJ6dnaW1z8lnrj__nZ2dnUU7_83NnZ2d@giganews.com>
<vKqoK.75291$GTEb.17970@fx48.iad>
<BYGdnY7xlufi1D__nZ2dnUU7_8zNnZ2d@giganews.com>
<J_roK.51524$ssF.13016@fx14.iad>
<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>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <MZGdnQUbkcpd7D__nZ2dnUU7_8xh4p2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 306
Message-ID: <9zuoK.44320$elob.20576@fx43.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: Thu, 9 Jun 2022 18:33:41 -0400
X-Received-Bytes: 17068
 by: Richard Damon - Thu, 9 Jun 2022 22:33 UTC

On 6/9/22 6:18 PM, olcott 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.
>


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

<87ydnf0LL4nG6D__nZ2dnUU7_8xh4p2d@giganews.com>

  copy mid

https://www.novabbs.com/devel/article-flat.php?id=34084&group=comp.theory#34084

  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: Thu, 09 Jun 2022 17:34:03 -0500
Date: Thu, 9 Jun 2022 17:34:01 -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>
<nvudncJwjNiNiz__nZ2dnUU7_81g4p2d@giganews.com>
<bipoK.10513$Vxw.6751@fx07.iad>
<jdydnWlvi_kquD__nZ2dnUU7_8zNnZ2d@giganews.com>
<RMpoK.7650$x7oc.3519@fx01.iad>
<xJKdnb8LMeMztz__nZ2dnUU7_83NnZ2d@giganews.com>
<20220609182847.00007585@reddwarf.jmc>
<N-adnVHsgaLIrT__nZ2dnUU7_8xh4p2d@giganews.com>
<20220609184617.00002add@reddwarf.jmc>
<eJ6dnaW1z8lnrj__nZ2dnUU7_83NnZ2d@giganews.com>
<vKqoK.75291$GTEb.17970@fx48.iad>
<BYGdnY7xlufi1D__nZ2dnUU7_8zNnZ2d@giganews.com>
<J_roK.51524$ssF.13016@fx14.iad>
<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>
<HjuoK.76731$ntj.3856@fx15.iad>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <HjuoK.76731$ntj.3856@fx15.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <87ydnf0LL4nG6D__nZ2dnUU7_8xh4p2d@giganews.com>
Lines: 317
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-oITtPFhTxqCSTYUeWRzHE7YUTP+hALNCZyOOC9XljaCyyMY+UOny4eVnEiILtC2sdnsbIVZjdG4UIFq!BwoYY6GTdOS69DGwnZsP6QITyomMZdk+GpWMTd5V6RP6xSt1nd08n584MnzZRHBqYzUnXUWlkgHY
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: 17535
 by: olcott - Thu, 9 Jun 2022 22:34 UTC

On 6/9/2022 5:17 PM, Richard Damon wrote:
> On 6/9/22 6:09 PM, olcott 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.
>>
>>
>>
>
> So, you agree that your H(P,P) that returns a 0, claiming it to be
> correct, also returns that 0 to P(P) and thus P(P) Halts, and thus
> H(P,P) is INCORRECT in saying that its input represents a non-halting
> computation?


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

<87ydnfwLL4kG6D__nZ2dnUU7_8xh4p2d@giganews.com>

  copy mid

https://www.novabbs.com/devel/article-flat.php?id=34085&group=comp.theory#34085

  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: Thu, 09 Jun 2022 17:35:07 -0500
Date: Thu, 9 Jun 2022 17:35:05 -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>
<jdydnWlvi_kquD__nZ2dnUU7_8zNnZ2d@giganews.com>
<RMpoK.7650$x7oc.3519@fx01.iad>
<xJKdnb8LMeMztz__nZ2dnUU7_83NnZ2d@giganews.com>
<20220609182847.00007585@reddwarf.jmc>
<N-adnVHsgaLIrT__nZ2dnUU7_8xh4p2d@giganews.com>
<20220609184617.00002add@reddwarf.jmc>
<eJ6dnaW1z8lnrj__nZ2dnUU7_83NnZ2d@giganews.com>
<vKqoK.75291$GTEb.17970@fx48.iad>
<BYGdnY7xlufi1D__nZ2dnUU7_8zNnZ2d@giganews.com>
<J_roK.51524$ssF.13016@fx14.iad>
<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>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <20220609232712.000066f9@reddwarf.jmc>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <87ydnfwLL4kG6D__nZ2dnUU7_8xh4p2d@giganews.com>
Lines: 326
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-A5R/yQL9xiwSE6sJtKxdc3Y+p6FZWJaq1xr+puS9eLAbUGh/W7ZzZa3Lfi0wcM8csQm4o5Y1JMM4jVU!R0I6WONuPy7RV2bIZWI6psap/2bjnduFuhMF0CKv9Ee3h7j33X8idd3z4GCrhCgPXiVUHNLs8D+k
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: 18060
 by: olcott - Thu, 9 Jun 2022 22:35 UTC

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
>


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

<87ydnf8LL4nc6z__nZ2dnUU7_8xh4p2d@giganews.com>

  copy mid

https://www.novabbs.com/devel/article-flat.php?id=34086&group=comp.theory#34086

  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: Thu, 09 Jun 2022 17:37:52 -0500
Date: Thu, 9 Jun 2022 17:37:51 -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>
<jdydnWlvi_kquD__nZ2dnUU7_8zNnZ2d@giganews.com>
<RMpoK.7650$x7oc.3519@fx01.iad>
<xJKdnb8LMeMztz__nZ2dnUU7_83NnZ2d@giganews.com>
<20220609182847.00007585@reddwarf.jmc>
<N-adnVHsgaLIrT__nZ2dnUU7_8xh4p2d@giganews.com>
<20220609184617.00002add@reddwarf.jmc>
<eJ6dnaW1z8lnrj__nZ2dnUU7_83NnZ2d@giganews.com>
<vKqoK.75291$GTEb.17970@fx48.iad>
<BYGdnY7xlufi1D__nZ2dnUU7_8zNnZ2d@giganews.com>
<J_roK.51524$ssF.13016@fx14.iad>
<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>
<9zuoK.44320$elob.20576@fx43.iad>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <9zuoK.44320$elob.20576@fx43.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <87ydnf8LL4nc6z__nZ2dnUU7_8xh4p2d@giganews.com>
Lines: 318
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-jBm1/YLwvHm51fvBf0TdbJM7u7TahxD0ypOd1BDoX2lO+yWmQ0puVrtQdKDFAhXdq4NnxK7X9ox5h+Y!B+O1dOpbfXltyIKaAcDRidHVdA2rmIgbH7+HNaoPP/FTYzzS1/x0bJBp3QZv0EcyLsMPfhmfDs5N
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: 18105
 by: olcott - Thu, 9 Jun 2022 22:37 UTC

On 6/9/2022 5:33 PM, Richard Damon wrote:
> On 6/9/22 6:18 PM, olcott 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.
>>
>
> No, the "infinitely nested emulation" halts when the first H(P,P) that
> P(P) called aborts it simulation.


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

<05voK.44321$elob.18447@fx43.iad>

  copy mid

https://www.novabbs.com/devel/article-flat.php?id=34090&group=comp.theory#34090

  copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Path: i2pn2.org!i2pn.org!aioe.org!news.uzoreto.com!tr2.eu1.usenetexpress.com!feeder.usenetexpress.com!tr3.iad1.usenetexpress.com!peer02.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx43.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> <RMpoK.7650$x7oc.3519@fx01.iad> <xJKdnb8LMeMztz__nZ2dnUU7_83NnZ2d@giganews.com> <20220609182847.00007585@reddwarf.jmc> <N-adnVHsgaLIrT__nZ2dnUU7_8xh4p2d@giganews.com> <20220609184617.00002add@reddwarf.jmc> <eJ6dnaW1z8lnrj__nZ2dnUU7_83NnZ2d@giganews.com> <vKqoK.75291$GTEb.17970@fx48.iad> <BYGdnY7xlufi1D__nZ2dnUU7_8zNnZ2d@giganews.com> <J_roK.51524$ssF.13016@fx14.iad> <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> <9zuoK.44320$elob.20576@fx43.iad> <87ydnf8LL4nc6z__nZ2dnUU7_8xh4p2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <87ydnf8LL4nc6z__nZ2dnUU7_8xh4p2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 319
Message-ID: <05voK.44321$elob.18447@fx43.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: Thu, 9 Jun 2022 19:09:47 -0400
X-Received-Bytes: 18173
 by: Richard Damon - Thu, 9 Jun 2022 23:09 UTC

On 6/9/22 6:37 PM, olcott wrote:
> On 6/9/2022 5:33 PM, Richard Damon wrote:
>> On 6/9/22 6:18 PM, olcott 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.
>>>
>>
>> No, the "infinitely nested emulation" halts when the first H(P,P) that
>> P(P) called aborts it simulation.
>
> When I tell you that an input only halts when it reaches its final state
> and I tell you this many hundreds of times because you are a God damned
> liar you pretend that I never said this.
>


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

<K7voK.131452$vAW9.20223@fx10.iad>

  copy mid

https://www.novabbs.com/devel/article-flat.php?id=34091&group=comp.theory#34091

  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!fx10.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>
<bipoK.10513$Vxw.6751@fx07.iad>
<jdydnWlvi_kquD__nZ2dnUU7_8zNnZ2d@giganews.com>
<RMpoK.7650$x7oc.3519@fx01.iad>
<xJKdnb8LMeMztz__nZ2dnUU7_83NnZ2d@giganews.com>
<20220609182847.00007585@reddwarf.jmc>
<N-adnVHsgaLIrT__nZ2dnUU7_8xh4p2d@giganews.com>
<20220609184617.00002add@reddwarf.jmc>
<eJ6dnaW1z8lnrj__nZ2dnUU7_83NnZ2d@giganews.com>
<vKqoK.75291$GTEb.17970@fx48.iad>
<BYGdnY7xlufi1D__nZ2dnUU7_8zNnZ2d@giganews.com>
<J_roK.51524$ssF.13016@fx14.iad>
<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>
<HjuoK.76731$ntj.3856@fx15.iad>
<87ydnf0LL4nG6D__nZ2dnUU7_8xh4p2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <87ydnf0LL4nG6D__nZ2dnUU7_8xh4p2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 327
Message-ID: <K7voK.131452$vAW9.20223@fx10.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: Thu, 9 Jun 2022 19:12:41 -0400
X-Received-Bytes: 17831
 by: Richard Damon - Thu, 9 Jun 2022 23:12 UTC

On 6/9/22 6:34 PM, olcott wrote:
> On 6/9/2022 5:17 PM, Richard Damon wrote:
>> On 6/9/22 6:09 PM, olcott 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.
>>>
>>>
>>>
>>
>> So, you agree that your H(P,P) that returns a 0, claiming it to be
>> correct, also returns that 0 to P(P) and thus P(P) Halts, and thus
>> H(P,P) is INCORRECT in saying that its input represents a non-halting
>> computation?
>
> That you are waaaay too stupid to understand that I correctly proved
> that P(P) and the correct simulatuon of the input to H(P,P) actually
> have different halting behavior is no actual 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)

<NMGdnbkodLpB4z__nZ2dnUU7_8xh4p2d@giganews.com>

  copy mid

https://www.novabbs.com/devel/article-flat.php?id=34092&group=comp.theory#34092

  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: Thu, 09 Jun 2022 18:14:36 -0500
Date: Thu, 9 Jun 2022 18:14:35 -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>
<xJKdnb8LMeMztz__nZ2dnUU7_83NnZ2d@giganews.com>
<20220609182847.00007585@reddwarf.jmc>
<N-adnVHsgaLIrT__nZ2dnUU7_8xh4p2d@giganews.com>
<20220609184617.00002add@reddwarf.jmc>
<eJ6dnaW1z8lnrj__nZ2dnUU7_83NnZ2d@giganews.com>
<vKqoK.75291$GTEb.17970@fx48.iad>
<BYGdnY7xlufi1D__nZ2dnUU7_8zNnZ2d@giganews.com>
<J_roK.51524$ssF.13016@fx14.iad>
<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>
<9zuoK.44320$elob.20576@fx43.iad>
<87ydnf8LL4nc6z__nZ2dnUU7_8xh4p2d@giganews.com>
<05voK.44321$elob.18447@fx43.iad>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <05voK.44321$elob.18447@fx43.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <NMGdnbkodLpB4z__nZ2dnUU7_8xh4p2d@giganews.com>
Lines: 339
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-TsJRT2+9Xh1TXYyWMHGuDnBvMQTNmK5hN3EA7Rvv7VWstRxloLwDNovFKtYLXAd8tKKkYrzcipKGK5A!H4XTzBuFws0orNNZP1muzuHyIoGYaQ69sOYISC0yngLYNP6NTTT8nwpNichLpARE5tB4Nez/wnyn
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: 19138
 by: olcott - Thu, 9 Jun 2022 23:14 UTC

On 6/9/2022 6:09 PM, Richard Damon wrote:
> On 6/9/22 6:37 PM, olcott wrote:
>> On 6/9/2022 5:33 PM, Richard Damon wrote:
>>> On 6/9/22 6:18 PM, olcott 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.
>>>>
>>>
>>> No, the "infinitely nested emulation" halts when the first H(P,P)
>>> that P(P) called aborts it simulation.
>>
>> When I tell you that an input only halts when it reaches its final
>> state and I tell you this many hundreds of times because you are a God
>> damned liar you pretend that I never said this.
>>
>
> Right, and when H(P,P) returns 0, the P that called it reaches its final
> state/the ret instrucion.


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

<zcvoK.131453$vAW9.89813@fx10.iad>

  copy mid

https://www.novabbs.com/devel/article-flat.php?id=34093&group=comp.theory#34093

  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!fx10.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>
<20220609182847.00007585@reddwarf.jmc>
<N-adnVHsgaLIrT__nZ2dnUU7_8xh4p2d@giganews.com>
<20220609184617.00002add@reddwarf.jmc>
<eJ6dnaW1z8lnrj__nZ2dnUU7_83NnZ2d@giganews.com>
<vKqoK.75291$GTEb.17970@fx48.iad>
<BYGdnY7xlufi1D__nZ2dnUU7_8zNnZ2d@giganews.com>
<J_roK.51524$ssF.13016@fx14.iad>
<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>
<9zuoK.44320$elob.20576@fx43.iad>
<87ydnf8LL4nc6z__nZ2dnUU7_8xh4p2d@giganews.com>
<05voK.44321$elob.18447@fx43.iad>
<NMGdnbkodLpB4z__nZ2dnUU7_8xh4p2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <NMGdnbkodLpB4z__nZ2dnUU7_8xh4p2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 348
Message-ID: <zcvoK.131453$vAW9.89813@fx10.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: Thu, 9 Jun 2022 19:17:51 -0400
X-Received-Bytes: 19349
 by: Richard Damon - Thu, 9 Jun 2022 23:17 UTC

On 6/9/22 7:14 PM, olcott wrote:
> On 6/9/2022 6:09 PM, Richard Damon wrote:
>> On 6/9/22 6:37 PM, olcott wrote:
>>> On 6/9/2022 5:33 PM, Richard Damon wrote:
>>>> On 6/9/22 6:18 PM, olcott 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.
>>>>>
>>>>
>>>> No, the "infinitely nested emulation" halts when the first H(P,P)
>>>> that P(P) called aborts it simulation.
>>>
>>> When I tell you that an input only halts when it reaches its final
>>> state and I tell you this many hundreds of times because you are a
>>> God damned liar you pretend that I never said this.
>>>
>>
>> Right, and when H(P,P) returns 0, the P that called it reaches its
>> final state/the ret instrucion.
>
> YOU GOD DAMNED LIAR main() calls H(P,P) and H returns to main()
>
> void P(u32 x)
> {
>   if (H(x, x))
>     HERE: goto HERE;
>   return;
> }
>
> int main()
> {
>   Output("Input_Halts = ", H((u32)P, (u32)P));
> }
>
>


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

<20220610121102.00007ec0@reddwarf.jmc>

  copy mid

https://www.novabbs.com/devel/article-flat.php?id=34096&group=comp.theory#34096

  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!peer02.ams4!peer.am4.highwinds-media.com!news.highwinds-media.com!fx02.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: <20220610121102.00007ec0@reddwarf.jmc>
References: <N8GdnUDJ0IRRxjz_nZ2dnUU7_8zNnZ2d@giganews.com>
<xJKdnb8LMeMztz__nZ2dnUU7_83NnZ2d@giganews.com>
<20220609182847.00007585@reddwarf.jmc>
<N-adnVHsgaLIrT__nZ2dnUU7_8xh4p2d@giganews.com>
<20220609184617.00002add@reddwarf.jmc>
<eJ6dnaW1z8lnrj__nZ2dnUU7_83NnZ2d@giganews.com>
<vKqoK.75291$GTEb.17970@fx48.iad>
<BYGdnY7xlufi1D__nZ2dnUU7_8zNnZ2d@giganews.com>
<J_roK.51524$ssF.13016@fx14.iad>
<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>
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: 364
X-Complaints-To: abuse@eweka.nl
NNTP-Posting-Date: Fri, 10 Jun 2022 11:11:01 UTC
Date: Fri, 10 Jun 2022 12:11:02 +0100
X-Received-Bytes: 19797
 by: Mr Flibble - Fri, 10 Jun 2022 11:11 UTC

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.

Click here to read the complete article

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

<M7GdnWgvGYAr3D7_nZ2dnUU7_8zNnZ2d@giganews.com>

  copy mid

https://www.novabbs.com/devel/article-flat.php?id=34098&group=comp.theory#34098

  copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!1.us.feeder.erje.net!feeder.erje.net!border1.nntp.dca1.giganews.com!nntp.giganews.com!buffer1.nntp.dca1.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Fri, 10 Jun 2022 08:05:58 -0500
Date: Fri, 10 Jun 2022 08:05:57 -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>
<xJKdnb8LMeMztz__nZ2dnUU7_83NnZ2d@giganews.com>
<20220609182847.00007585@reddwarf.jmc>
<N-adnVHsgaLIrT__nZ2dnUU7_8xh4p2d@giganews.com>
<20220609184617.00002add@reddwarf.jmc>
<eJ6dnaW1z8lnrj__nZ2dnUU7_83NnZ2d@giganews.com>
<vKqoK.75291$GTEb.17970@fx48.iad>
<BYGdnY7xlufi1D__nZ2dnUU7_8zNnZ2d@giganews.com>
<J_roK.51524$ssF.13016@fx14.iad>
<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>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <20220610121102.00007ec0@reddwarf.jmc>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <M7GdnWgvGYAr3D7_nZ2dnUU7_8zNnZ2d@giganews.com>
Lines: 467
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-s7dh1JPJ361/bBd+JuA91eQ4vUG1SsY1JXp6g7kY4EzZzRkjlQl9lXO1x0Ic3KluUKTgYrovlzOFcCu!aWAJJVPVnFZycuY7trUTnYLmwI7NczpdS/jW1eC0DadWMjqQZW4/pxFY19IcmX7xFVq+R4+Tg2vF
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: 23713
 by: olcott - Fri, 10 Jun 2022 13:05 UTC

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
>


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

<20220610142323.0000220d@reddwarf.jmc>

  copy mid

https://www.novabbs.com/devel/article-flat.php?id=34099&group=comp.theory#34099

  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!news-out.netnews.com!news.alt.net!fdc2.netnews.com!peer01.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: <20220610142323.0000220d@reddwarf.jmc>
References: <N8GdnUDJ0IRRxjz_nZ2dnUU7_8zNnZ2d@giganews.com>
<N-adnVHsgaLIrT__nZ2dnUU7_8xh4p2d@giganews.com>
<20220609184617.00002add@reddwarf.jmc>
<eJ6dnaW1z8lnrj__nZ2dnUU7_83NnZ2d@giganews.com>
<vKqoK.75291$GTEb.17970@fx48.iad>
<BYGdnY7xlufi1D__nZ2dnUU7_8zNnZ2d@giganews.com>
<J_roK.51524$ssF.13016@fx14.iad>
<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>
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: 511
X-Complaints-To: abuse@eweka.nl
NNTP-Posting-Date: Fri, 10 Jun 2022 13:23:23 UTC
Date: Fri, 10 Jun 2022 14:23:23 +0100
X-Received-Bytes: 26498
 by: Mr Flibble - Fri, 10 Jun 2022 13:23 UTC

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)


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

<btSdnYCX8rZc2z7_nZ2dnUU7_8xh4p2d@giganews.com>

  copy mid

https://www.novabbs.com/devel/article-flat.php?id=34100&group=comp.theory#34100

  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 08:27:29 -0500
Date: Fri, 10 Jun 2022 08:27:28 -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>
<N-adnVHsgaLIrT__nZ2dnUU7_8xh4p2d@giganews.com>
<20220609184617.00002add@reddwarf.jmc>
<eJ6dnaW1z8lnrj__nZ2dnUU7_83NnZ2d@giganews.com>
<vKqoK.75291$GTEb.17970@fx48.iad>
<BYGdnY7xlufi1D__nZ2dnUU7_8zNnZ2d@giganews.com>
<J_roK.51524$ssF.13016@fx14.iad>
<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>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <20220610142323.0000220d@reddwarf.jmc>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <btSdnYCX8rZc2z7_nZ2dnUU7_8xh4p2d@giganews.com>
Lines: 496
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-VVIRW7y3O5SED1Z7DAsav6UWdDs9dgqeNr/ok/7JlqOEwZrJSr2jLTj9bVQQuZzoyCmhspqw50HvHtW!Jf96dWhwiY9ikgg9E31MH8eI39Ln8JkAXbcsjh1CgA+6QCHacDVhFM2R0p+VmsGzbZhDjaTzu1Y2
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: 25618
 by: olcott - Fri, 10 Jun 2022 13:27 UTC

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


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

<20220610142959.0000420e@reddwarf.jmc>

  copy mid

https://www.novabbs.com/devel/article-flat.php?id=34101&group=comp.theory#34101

  copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Path: i2pn2.org!i2pn.org!aioe.org!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: <20220610142959.0000420e@reddwarf.jmc>
References: <N8GdnUDJ0IRRxjz_nZ2dnUU7_8zNnZ2d@giganews.com>
<eJ6dnaW1z8lnrj__nZ2dnUU7_83NnZ2d@giganews.com>
<vKqoK.75291$GTEb.17970@fx48.iad>
<BYGdnY7xlufi1D__nZ2dnUU7_8zNnZ2d@giganews.com>
<J_roK.51524$ssF.13016@fx14.iad>
<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>
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: 532
X-Complaints-To: abuse@eweka.nl
NNTP-Posting-Date: Fri, 10 Jun 2022 13:29:58 UTC
Date: Fri, 10 Jun 2022 14:29:59 +0100
X-Received-Bytes: 27915
 by: Mr Flibble - Fri, 10 Jun 2022 13:29 UTC

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.


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

<8PSdnZBSIaRW2j7_nZ2dnUU7_81g4p2d@giganews.com>

  copy mid

https://www.novabbs.com/devel/article-flat.php?id=34102&group=comp.theory#34102

  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 08:31:54 -0500
Date: Fri, 10 Jun 2022 08:31: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>
<eJ6dnaW1z8lnrj__nZ2dnUU7_83NnZ2d@giganews.com>
<vKqoK.75291$GTEb.17970@fx48.iad>
<BYGdnY7xlufi1D__nZ2dnUU7_8zNnZ2d@giganews.com>
<J_roK.51524$ssF.13016@fx14.iad>
<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>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <20220610142959.0000420e@reddwarf.jmc>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <8PSdnZBSIaRW2j7_nZ2dnUU7_81g4p2d@giganews.com>
Lines: 516
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-lNkUX4TDFRsbLOJ6zqo7FJE+amR/XPob4w/TjsKxMrbAVwrJlusMTu23PX5avvPnPeABDrIAwopPp1V!uygeoWnC2wyioFnffI1Ul+8kNhUKMVrKG0xjo7B5kBt91ZtIsRWit0hYHuNO7eoiSM6bEifDs7dM
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: 27204
 by: olcott - Fri, 10 Jun 2022 13:31 UTC

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


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

<8PSdnZNSIaS11T7_nZ2dnUU7_81g4p2d@giganews.com>

  copy mid

https://www.novabbs.com/devel/article-flat.php?id=34103&group=comp.theory#34103

  copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!1.us.feeder.erje.net!feeder.erje.net!border1.nntp.dca1.giganews.com!nntp.giganews.com!buffer1.nntp.dca1.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Fri, 10 Jun 2022 08:33:28 -0500
Date: Fri, 10 Jun 2022 08:33:27 -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>
<eJ6dnaW1z8lnrj__nZ2dnUU7_83NnZ2d@giganews.com>
<vKqoK.75291$GTEb.17970@fx48.iad>
<BYGdnY7xlufi1D__nZ2dnUU7_8zNnZ2d@giganews.com>
<J_roK.51524$ssF.13016@fx14.iad>
<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>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <20220610142959.0000420e@reddwarf.jmc>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <8PSdnZNSIaS11T7_nZ2dnUU7_81g4p2d@giganews.com>
Lines: 516
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-Z6xlqKRcsO8FrrTPUiIudRRgTLI3UbVqkDcM1YlRfykv70M64mD0Y/0FCiedtJg7GhgYfXMpDEC8/Gp!3WWL03VTTU15BYDUcnCdpC3josUJ4exHdZuhZQjrLbOPDjoDmpPLT2EvBIYFWUDdvrCWCscXEOiY
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: 27209
 by: olcott - Fri, 10 Jun 2022 13:33 UTC

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


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

<1MHoK.92441$J0r9.90191@fx11.iad>

  copy mid

https://www.novabbs.com/devel/article-flat.php?id=34104&group=comp.theory#34104

  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!fx11.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>
<20220609182847.00007585@reddwarf.jmc>
<N-adnVHsgaLIrT__nZ2dnUU7_8xh4p2d@giganews.com>
<20220609184617.00002add@reddwarf.jmc>
<eJ6dnaW1z8lnrj__nZ2dnUU7_83NnZ2d@giganews.com>
<vKqoK.75291$GTEb.17970@fx48.iad>
<BYGdnY7xlufi1D__nZ2dnUU7_8zNnZ2d@giganews.com>
<J_roK.51524$ssF.13016@fx14.iad>
<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>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <M7GdnWgvGYAr3D7_nZ2dnUU7_8zNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 462
Message-ID: <1MHoK.92441$J0r9.90191@fx11.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 09:34:53 -0400
X-Received-Bytes: 24804
 by: Richard Damon - Fri, 10 Jun 2022 13:34 UTC

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


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

<20220610143549.000053e6@reddwarf.jmc>

  copy mid

https://www.novabbs.com/devel/article-flat.php?id=34105&group=comp.theory#34105

  copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Path: i2pn2.org!i2pn.org!aioe.org!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: <20220610143549.000053e6@reddwarf.jmc>
References: <N8GdnUDJ0IRRxjz_nZ2dnUU7_8zNnZ2d@giganews.com>
<BYGdnY7xlufi1D__nZ2dnUU7_8zNnZ2d@giganews.com>
<J_roK.51524$ssF.13016@fx14.iad>
<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>
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: 540
X-Complaints-To: abuse@eweka.nl
NNTP-Posting-Date: Fri, 10 Jun 2022 13:35:49 UTC
Date: Fri, 10 Jun 2022 14:35:49 +0100
X-Received-Bytes: 29229
 by: Mr Flibble - Fri, 10 Jun 2022 13:35 UTC

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


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

<nKGdnQ8wUuAI1z7_nZ2dnUU7_83NnZ2d@giganews.com>

  copy mid

https://www.novabbs.com/devel/article-flat.php?id=34106&group=comp.theory#34106

  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!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Fri, 10 Jun 2022 08:43:49 -0500
Date: Fri, 10 Jun 2022 08:43:48 -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>
<BYGdnY7xlufi1D__nZ2dnUU7_8zNnZ2d@giganews.com>
<J_roK.51524$ssF.13016@fx14.iad>
<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>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <20220610143549.000053e6@reddwarf.jmc>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <nKGdnQ8wUuAI1z7_nZ2dnUU7_83NnZ2d@giganews.com>
Lines: 537
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-dsdKG/EXJ9EWgxHgKpyHTUwFIOtadBUsBR/FPeCwZuA1IREdn6h2QL07fTtvwms2KSp3Zi6mka/CymJ!CnWnpXohuasg3qxYDbj5gtBS1CfCnwWuRZfo2CgF5qF006PE/NLG+MO3MnTR27SlR877UvcJM9c0
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: 28934
 by: olcott - Fri, 10 Jun 2022 13:43 UTC

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.


Click here to read the complete article
Pages:12345
server_pubkey.txt

rocksolid light 0.9.8
clearnet tor