Rocksolid Light

Welcome to novaBBS (click a section below)

mail  files  register  newsreader  groups  login

Message-ID:  

Trying to establish voice contact ... please ____yell into keyboard.

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

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

<BsydnUepqLWJxj7_nZ2dnUU7_8zNnZ2d@giganews.com>

  copy mid

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

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

On 6/10/2022 9:47 AM, Mr Flibble wrote:
> On Fri, 10 Jun 2022 09:43:47 -0500
> olcott <NoOne@NoWhere.com> wrote:
>
>> On 6/10/2022 9:37 AM, Mr Flibble wrote:
>>> On Fri, 10 Jun 2022 09:32:47 -0500
>>> olcott <NoOne@NoWhere.com> wrote:
>>>
>>>> On 6/10/2022 9:21 AM, Mr Flibble wrote:
>>>>> On Fri, 10 Jun 2022 09:15:29 -0500
>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>
>>>>>> On 6/10/2022 9:03 AM, Mr Flibble wrote:
>>>>>>> On Fri, 10 Jun 2022 08:59:17 -0500
>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>
>>>>>>>> On 6/10/2022 8:51 AM, Mr Flibble wrote:
>>>>>>>>> On Fri, 10 Jun 2022 08:43:48 -0500
>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>
>>>>>>>>>> On 6/10/2022 8:35 AM, Mr Flibble wrote:
>>>>>>>>>>> On Fri, 10 Jun 2022 08:33:27 -0500
>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>
>>>>>>>>>>>> On 6/10/2022 8:29 AM, Mr Flibble wrote:
>>>>>>>>>>>>> On Fri, 10 Jun 2022 08:27:28 -0500
>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>>>
>>>>>>>>>>>>>> On 6/10/2022 8:23 AM, Mr Flibble wrote:
>>>>>>>>>>>>>>> On Fri, 10 Jun 2022 08:05:57 -0500
>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> On 6/10/2022 6:11 AM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>> On Thu, 9 Jun 2022 17:35:05 -0500
>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> On 6/9/2022 5:27 PM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>>>> On Thu, 9 Jun 2022 17:18:38 -0500
>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> On 6/9/2022 5:15 PM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>>>>>> On Thu, 9 Jun 2022 17:09:08 -0500
>>>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> On 6/9/2022 4:54 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 6/9/22 5:29 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 6/9/2022 4:13 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> On 6/9/22 5:00 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 6/9/2022 3:25 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 6/9/22 4:13 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 6/9/2022 2:57 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 6/9/22 3:52 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 6/9/2022 2:38 PM, Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 6/9/22 3:26 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 6/9/2022 1:12 PM, Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 6/9/22 1:55 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 6/9/2022 12:46 PM, Mr Flibble
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Thu, 9 Jun 2022 12:39:32 -0500
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 6/9/2022 12:28 PM, Mr Flibble
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Thu, 9 Jun 2022 12:15:24 -0500
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 6/9/2022 12:06 PM, Richard
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 6/9/22 12:54 PM, olcott
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 6/9/2022 11:34 AM, Richard
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 6/9/22 11:47 AM, olcott
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> void P(u32 x)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>      if (H(x, x))
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>        HERE: goto
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> HERE; return;
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>      P(P);
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> _P()
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012e7](01)  55
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> push ebp [000012e8](02)  8bec
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> mov ebp,esp [000012ea](03)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 8b4508 mov eax,[ebp+08]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012ed](01)  50 push eax
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012ee](03)  8b4d08 mov
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ecx,[ebp+08] [000012f1](01)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 51 push ecx [000012f2](05)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> e880feffff call 00001177 //
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> call H [000012f7](03) 83c408
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> add esp,+08 [000012fa](02)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 85c0 test eax,eax
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012fc](02) 7402 jz
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 00001300 [000012fe](02) ebfe
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> jmp 000012fe [00001300](01)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 5d pop ebp [00001301](01)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> c3 ret Size in bytes:(0027)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001301]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> _main()
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001307](01)  55
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> push ebp [00001308](02)  8bec
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> mov ebp,esp [0000130a](05)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 68e7120000 push 000012e7 //
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> push P [0000130f](05)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> e8d3ffffff call 000012e7 //
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> call P [00001314](03) 83c404
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> add esp,+04 [00001317](02)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 33c0 xor eax,eax
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001319](01) 5d pop ebp
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [0000131a](01) c3 ret Size in
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> bytes:(0020) [0000131a]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>     machine   stack
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> stack machine assembly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> address address data code
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> language ========  ========
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ======== =========
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> =============
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001307][00102190][00000000]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 55 push ebp
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001308][00102190][00000000]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 8bec mov ebp,esp
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [0000130a][0010218c][000012e7]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 68e7120000 push 000012e7 //
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> push P
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [0000130f][00102188][00001314]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> e8d3ffffff call 000012e7 //
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> call P
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012e7][00102184][00102190]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 55 push ebp // enter
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> executed P
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012e8][00102184][00102190]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 8bec mov ebp,esp
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012ea][00102184][00102190]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 8b4508 mov eax,[ebp+08]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012ed][00102180][000012e7]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 50 push eax // push P
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012ee][00102180][000012e7]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 8b4d08 mov ecx,[ebp+08]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012f1][0010217c][000012e7]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 51 push ecx // push P
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012f2][00102178][000012f7]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> e880feffff call 00001177 //
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> call H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Begin Local Halt Decider
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Simulation Execution Trace
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Stored at:212244
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012e7][00212230][00212234]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 55 push ebp // enter
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> emulated P
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012e8][00212230][00212234]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 8bec mov ebp,esp
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012ea][00212230][00212234]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 8b4508 mov eax,[ebp+08]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012ed][0021222c][000012e7]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 50 push eax      // push P
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012ee][0021222c][000012e7]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 8b4d08 mov ecx,[ebp+08]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012f1][00212228][000012e7]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 51 push ecx // push P
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012f2][00212224][000012f7]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> e880feffff call 00001177 //
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> call H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> So, by what instruction
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reference manual is a call
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 00001177 followedby the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> execution of the instruction
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> at 000012e7.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Your "CPU" is broken, or
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> emulation incorrect.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012e7][0025cc58][0025cc5c]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 55 push ebp      //
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> enter emulated P
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012e8][0025cc58][0025cc5c]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 8bec mov ebp,esp
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012ea][0025cc58][0025cc5c]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 8b4508 mov eax,[ebp+08]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012ed][0025cc54][000012e7]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 50 push eax      // push P
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012ee][0025cc54][000012e7]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 8b4d08 mov ecx,[ebp+08]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012f1][0025cc50][000012e7]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 51 push ecx // push P
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012f2][0025cc4c][000012f7]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> e880feffff call 00001177 //
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> call H Local Halt Decider:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Infinite Recursion Detected
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Simulation Stopped
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It is completely obvious that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> when H(P,P) correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> emulates its input that it
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> must emulate the first seven
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> instructions of P. Because
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the seventh instruction of P
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> repeats this process we know
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> with complete certainty that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the correct and complete
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> emulation of P by H would
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> never reach its final “ret”
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> instruction, thus never
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halts.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Problem, the 7th intruction
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> DOESN't "Just repeat the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> procedure", because that H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> always has the option to abort
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its simulation, just like this
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> onne did, and return to its P
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> and see it halt.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> THAT YOU ARE SIMPLY TOO STUPID
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> TO UNDERSTAND THIS IS NO ACTUAL
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> REBUTTAL AT ALL:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The partial correct x86
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> emulation of the input to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H(P,P) conclusively proves
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that the complete and correct
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> x86 emulation would never stop
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> running.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You SAY that, but you don't
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> answer the actual questions
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> about HOW.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> THAT YOU ARE SIMPLY TOO STUPID TO
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> UNDERSTAND THIS IS NO EVIDENCE
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> WHAT-SO-EVER THAT I DID NOT
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> COMPLETELY PROVE THAT THE CORRECT
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> PARTIAL EMULATION OF THE INPUT TO
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H(P,P) CONCLUSIVELY PROVES THAT
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> THE CORRECT AND COMPLETE X86
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> EMULATION OF THE INPUT TO H(P,P)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> WOULD NEVER STOP RUNNING.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It is completely obvious that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> when H(P,P) correctly emulates
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its input that it must emulate
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the first seven instructions of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> P. Because the seventh
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> instruction of P repeats this
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> process we know with complete
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> certainty that the correct and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> complete emulation of P by H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> would never reach its final
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> “ret” instruction, thus never
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halts.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If P should have halted (i.e. no
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> infinite loop) then your
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation detector, S (not H),
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> gets the answer wrong. You S is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> NOT a halting decider.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> THAT YOU ARE SIMPLY TOO STUPID TO
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> UNDERSTAND THIS IS NO ACTUAL
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> REBUTTAL AT ALL.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> _P()
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001352](01)  55
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> push ebp [00001353](02)  8bec
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> mov ebp,esp [00001355](03)  8b4508
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> mov eax,[ebp+08] [00001358](01)  50
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> push eax      // push P
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001359](03) 8b4d08 mov
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ecx,[ebp+08] [0000135c](01) 51 push
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ecx      // push P [0000135d](05)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> e840feffff call 000011a2 // call H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001362](03) 83c408 add esp,+08
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001365](02) 85c0 test eax,eax
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001367](02)  7402 jz 0000136b
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001369](02) ebfe jmp 00001369
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [0000136b](01)  5d pop ebp
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [0000136c](01)  c3 ret Size in
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> bytes:(0027) [0000136c]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It is completely obvious that when
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H(P,P) correctly emulates its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input that it must emulate the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> first seven instructions of P.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Because the seventh instruction of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> P repeats this process we know with
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> complete certainty that the correct
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> and complete emulation of P by H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> would never reach its final “ret”
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> instruction, thus never halts.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> We are going around and around and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> around in circles. I will try again:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If you replace the opcodes "EB FE"
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> at 00001369 with the opcodes "90 90"
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> then your H gets the answer wrong: P
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> should have halted.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> As I already said before this is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> merely your cluelessness that when
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H(P,P) is invoked the correct x86
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> emulation of the input to H(P,P)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> makes and code after [0000135d]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> unreachable.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Wrong, because when that H return the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> value 0, it will get there.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Like I said people that are dumber
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> than a box of rocks won't be able to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly understand this.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> When H(P,P) is invoked the correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> emulated input to H(P,P) cannot
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> possibly reach any instruction beyond
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [0000135d].
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> So, you are defining that you H(P,P)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> never returns because it is caught in
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the infinite rcursion.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Thats fine, just says it can't be the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly answering decider you claim it
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to be.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I have corrected you on this too many
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> times.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> How. You need to define what H(P,P)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> actually does.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> I have explained that too many times.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> To understand that H(P,P)==0 is correct we
>>>>>>>>>>>>>>>>>>>>>>>>>>>> only need to know that H performs a correct
>>>>>>>>>>>>>>>>>>>>>>>>>>>> x86 emulation of its input and then examine
>>>>>>>>>>>>>>>>>>>>>>>>>>>> the execution trace.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> And a CORRECT emulation of the code will
>>>>>>>>>>>>>>>>>>>>>>>>>>> Halt if H(P,P) returns 0, which it can only
>>>>>>>>>>>>>>>>>>>>>>>>>>> do if it does not actually do a correct
>>>>>>>>>>>>>>>>>>>>>>>>>>> emulation
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> The correctly emulated input to H(P,P) never
>>>>>>>>>>>>>>>>>>>>>>>>>> gets past its machine address [0000135d].
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> Only if H actually doesn't return 0. Yes, H
>>>>>>>>>>>>>>>>>>>>>>>>> can't correctly return 0 if it correctly
>>>>>>>>>>>>>>>>>>>>>>>>> emulates its input, but you can't drop that
>>>>>>>>>>>>>>>>>>>>>>>>> requirement.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> void P(u32 x)
>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>    if (H(x, x))
>>>>>>>>>>>>>>>>>>>>>>>>      HERE: goto HERE;
>>>>>>>>>>>>>>>>>>>>>>>>    return;
>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>    Output("Input_Halts = ", H((u32)P,
>>>>>>>>>>>>>>>>>>>>>>>> (u32)P)); }
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> When H returns 0 it does not returns 0 to P it
>>>>>>>>>>>>>>>>>>>>>>>> returns 0 to main().
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> But it also return 0 to the computation P(P),
>>>>>>>>>>>>>>>>>>>>>>> maybe not the copy that it is simulating, since
>>>>>>>>>>>>>>>>>>>>>>> it aborts that before it get to it,
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Finally you are not stupid or deceptive.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> If H never returns a value to P then H is not a
>>>>>>>>>>>>>>>>>>>>> halting decider; if H returns a value of 0 to
>>>>>>>>>>>>>>>>>>>>> main() when P halts then H is not a halting
>>>>>>>>>>>>>>>>>>>>> decider.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> H is not a halting decider; H is a simulation
>>>>>>>>>>>>>>>>>>>>> detector, S.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> In other words you are saying the infintely nested
>>>>>>>>>>>>>>>>>>>> emulation only excutes for a few steps and then it
>>>>>>>>>>>>>>>>>>>> stops on its own.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> I am saying that your H is not a halting decider; I
>>>>>>>>>>>>>>>>>>> am saying that your H is just a simulation
>>>>>>>>>>>>>>>>>>> detector, S.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> You are saying that you simply "don't believe in"
>>>>>>>>>>>>>>>>>> simulating halt deciders.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> You haven't got a simulating halt decider, what you
>>>>>>>>>>>>>>>>> have got is a simulation detector.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> It is an easily verified fact that H does correctly
>>>>>>>>>>>>>>>> decide the halt status of its input.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> void Infinite_Loop()
>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>> Output("Input_Halts = ", H0(Infinite_Loop));
>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> _Infinite_Loop()
>>>>>>>>>>>>>>>> [00001342](01) 55 push ebp
>>>>>>>>>>>>>>>> [00001343](02) 8bec mov ebp,esp
>>>>>>>>>>>>>>>> [00001345](02) ebfe jmp 00001345
>>>>>>>>>>>>>>>> [00001347](01) 5d pop ebp
>>>>>>>>>>>>>>>> [00001348](01) c3 ret
>>>>>>>>>>>>>>>> Size in bytes:(0007) [00001348]
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> _main()
>>>>>>>>>>>>>>>> [00001372](01) 55 push ebp
>>>>>>>>>>>>>>>> [00001373](02) 8bec mov ebp,esp
>>>>>>>>>>>>>>>> [00001375](05) 6842130000 push 00001342
>>>>>>>>>>>>>>>> [0000137a](05) e833fdffff call 000010b2
>>>>>>>>>>>>>>>> [0000137f](03) 83c404 add esp,+04
>>>>>>>>>>>>>>>> [00001382](01) 50 push eax
>>>>>>>>>>>>>>>> [00001383](05) 6823040000 push 00000423
>>>>>>>>>>>>>>>> [00001388](05) e8e5f0ffff call 00000472
>>>>>>>>>>>>>>>> [0000138d](03) 83c408 add esp,+08
>>>>>>>>>>>>>>>> [00001390](02) 33c0 xor eax,eax
>>>>>>>>>>>>>>>> [00001392](01) 5d pop ebp
>>>>>>>>>>>>>>>> [00001393](01) c3 ret
>>>>>>>>>>>>>>>> Size in bytes:(0034) [00001393]
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> machine stack stack machine
>>>>>>>>>>>>>>>> assembly address address data code
>>>>>>>>>>>>>>>> language ======== ======== ======== =========
>>>>>>>>>>>>>>>> ============= [00001372][0010228f][00000000] 55
>>>>>>>>>>>>>>>> push ebp [00001373][0010228f][00000000] 8bec mov
>>>>>>>>>>>>>>>> ebp,esp [00001375][0010228b][00001342] 6842130000 push
>>>>>>>>>>>>>>>> 00001342 // push _Infinite_Loop
>>>>>>>>>>>>>>>> [0000137a][00102287][0000137f] e833fdffff call 000010b2
>>>>>>>>>>>>>>>> // call H0
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Begin Local Halt Decider Simulation Execution Trace
>>>>>>>>>>>>>>>> Stored at:212343 [00001342][00212333][00212337] 55
>>>>>>>>>>>>>>>> push ebp [00001343][00212333][00212337] 8bec mov
>>>>>>>>>>>>>>>> ebp,esp [00001345][00212333][00212337] ebfe jmp
>>>>>>>>>>>>>>>> 00001345 [00001345][00212333][00212337] ebfe jmp
>>>>>>>>>>>>>>>> 00001345 Local Halt Decider: Infinite Loop Detected
>>>>>>>>>>>>>>>> Simulation Stopped
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> [0000137f][0010228f][00000000] 83c404 add esp,+04
>>>>>>>>>>>>>>>> [00001382][0010228b][00000000] 50 push eax
>>>>>>>>>>>>>>>> [00001383][00102287][00000423] 6823040000 push 00000423
>>>>>>>>>>>>>>>> [00001388][00102287][00000423] e8e5f0ffff call 00000472
>>>>>>>>>>>>>>>> Input_Halts = 0
>>>>>>>>>>>>>>>> [0000138d][0010228f][00000000] 83c408 add esp,+08
>>>>>>>>>>>>>>>> [00001390][0010228f][00000000] 33c0 xor eax,eax
>>>>>>>>>>>>>>>> [00001392][00102293][00100000] 5d pop ebp
>>>>>>>>>>>>>>>> [00001393][00102297][00000004] c3 ret
>>>>>>>>>>>>>>>> Number of Instructions Executed(680)
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> int Sum(int X, int Y)
>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>> return X + Y;
>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>> Output("Input_Halts = ", H2(Sum, 3, 4));
>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> _Sum()
>>>>>>>>>>>>>>>> [000012b6](01) 55 push ebp
>>>>>>>>>>>>>>>> [000012b7](02) 8bec mov ebp,esp
>>>>>>>>>>>>>>>> [000012b9](03) 8b4508 mov eax,[ebp+08]
>>>>>>>>>>>>>>>> [000012bc](03) 03450c add eax,[ebp+0c]
>>>>>>>>>>>>>>>> [000012bf](01) 5d pop ebp
>>>>>>>>>>>>>>>> [000012c0](01) c3 ret
>>>>>>>>>>>>>>>> Size in bytes:(0011) [000012c0]
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> _main()
>>>>>>>>>>>>>>>> [00001316](01) 55 push ebp
>>>>>>>>>>>>>>>> [00001317](02) 8bec mov ebp,esp
>>>>>>>>>>>>>>>> [00001319](02) 6a04 push +04
>>>>>>>>>>>>>>>> [0000131b](02) 6a03 push +03
>>>>>>>>>>>>>>>> [0000131d](05) 68b6120000 push 000012b6
>>>>>>>>>>>>>>>> [00001322](05) e85ffaffff call 00000d86
>>>>>>>>>>>>>>>> [00001327](03) 83c40c add esp,+0c
>>>>>>>>>>>>>>>> [0000132a](01) 50 push eax
>>>>>>>>>>>>>>>> [0000132b](05) 6807040000 push 00000407
>>>>>>>>>>>>>>>> [00001330](05) e821f1ffff call 00000456
>>>>>>>>>>>>>>>> [00001335](03) 83c408 add esp,+08
>>>>>>>>>>>>>>>> [00001338](02) 33c0 xor eax,eax
>>>>>>>>>>>>>>>> [0000133a](01) 5d pop ebp
>>>>>>>>>>>>>>>> [0000133b](01) c3 ret
>>>>>>>>>>>>>>>> Size in bytes:(0038) [0000133b]
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> machine stack stack machine
>>>>>>>>>>>>>>>> assembly address address data code
>>>>>>>>>>>>>>>> language ======== ======== ======== =========
>>>>>>>>>>>>>>>> ============= ...[00001316][001021d7][00000000] 55
>>>>>>>>>>>>>>>> push ebp ...[00001317][001021d7][00000000] 8bec
>>>>>>>>>>>>>>>> mov ebp,esp ...[00001319][001021d3][00000004]
>>>>>>>>>>>>>>>> 6a04 push +04 ...[0000131b][001021cf][00000003] 6a03
>>>>>>>>>>>>>>>> push +03 ...[0000131d][001021cb][000012b6]
>>>>>>>>>>>>>>>> 68b6120000 push 000012b6
>>>>>>>>>>>>>>>> ...[00001322][001021c7][00001327] e85ffaffff call
>>>>>>>>>>>>>>>> 00000d86
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Begin Local Halt Decider Simulation Execution Trace
>>>>>>>>>>>>>>>> Stored at:21228b ...[000012b6][00212273][00212277] 55
>>>>>>>>>>>>>>>> push ebp ...[000012b7][00212273][00212277] 8bec
>>>>>>>>>>>>>>>> mov ebp,esp ...[000012b9][00212273][00212277] 8b4508
>>>>>>>>>>>>>>>> mov eax,[ebp+08] ...[000012bc][00212273][00212277]
>>>>>>>>>>>>>>>> 03450c add eax,[ebp+0c]
>>>>>>>>>>>>>>>> ...[000012bf][00212277][00000e54] 5d pop ebp
>>>>>>>>>>>>>>>> ...[000012c0][0021227b][00000003] c3 ret
>>>>>>>>>>>>>>>> ...[00001327][001021d7][00000000] 83c40c add
>>>>>>>>>>>>>>>> esp,+0c ...[0000132a][001021d3][00000001] 50 push eax
>>>>>>>>>>>>>>>> ...[0000132b][001021cf][00000407] 6807040000 push
>>>>>>>>>>>>>>>> 00000407 ---[00001330][001021cf][00000407] e821f1ffff
>>>>>>>>>>>>>>>> call 00000456 Input_Halts = 1
>>>>>>>>>>>>>>>> ...[00001335][001021d7][00000000] 83c408 add
>>>>>>>>>>>>>>>> esp,+08 ...[00001338][001021d7][00000000] 33c0 xor
>>>>>>>>>>>>>>>> eax,eax ...[0000133a][001021db][00100000] 5d pop ebp
>>>>>>>>>>>>>>>> ...[0000133b][001021df][00000004] c3 ret Number of
>>>>>>>>>>>>>>>> Instructions Executed(660)
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> All you are showing here is that your H can decide the
>>>>>>>>>>>>>>> halt status of two trivial cases however you have not
>>>>>>>>>>>>>>> shown that H can decide the halt status of non-trivial
>>>>>>>>>>>>>>> cases.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> You said:
>>>>>>>>>>>>>> "You haven't got a simulating halt decider"
>>>>>>>>>>>>>> Apologize and we can move on.
>>>>>>>>>>>>>
>>>>>>>>>>>>> I posted four paragraphs but you ignored three of them.
>>>>>>>>>>>>> Lets try again.
>>>>>>>>>>>>
>>>>>>>>>>>> IF YOU DON'T APOLOGIZE THEN WE CANNOT MOVE ON !!!
>>>>>>>>>>>
>>>>>>>>>>> It seems I need to try again. Perhaps it will help if I
>>>>>>>>>>> combine the four paragraphs into a single paragraph:
>>>>>>>>>>>
>>>>>>>>>>> All you are showing here is that your H can decide the halt
>>>>>>>>>>> status of two trivial cases however you have not shown that
>>>>>>>>>>> H can decide the halt status of non-trivial cases.
>>>>>>>>>>
>>>>>>>>>> H is a halt decider for a subset of its inputs.
>>>>>>>>>> H is a halt decider for P.
>>>>>>>>>> When H is a halt decider for P all of the conventional
>>>>>>>>>> halting problem proofs have been refuted.
>>>>>>>>>
>>>>>>>>> For H to be a halt decider it needs to be a halt decider for
>>>>>>>>> all inputs not a subset.
>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>>> Publish the source code of your halt
>>>>>>>>>>> decider so we can see what classes of programs your H can
>>>>>>>>>>> decide. I am interested in deciding the halt status of
>>>>>>>>>>> programs containing non-trivial branching logic predicated
>>>>>>>>>>> on arbitrary program input.
>>>>>>>>>>
>>>>>>>>>> These are out-of-scope.
>>>>>>>>>
>>>>>>>>> You may assert this but that doesn't make your assertion true.
>>>>>>>>> If they are out-of-scope then your H is out of scope of the
>>>>>>>>> Halting Problem.
>>>>>>>>>>
>>>>>>>>>>> Crucially if your H cannot return an answer for an arbitrary
>>>>>>>>>>> non-halting program in finite time then it isn't a halt
>>>>>>>>>>> decider.
>>>>>>>>>>
>>>>>>>>>> One can either say that H is a halt decider for a subset of
>>>>>>>>>> its inputs or that H is a halt determiner. As long as H(P,P)
>>>>>>>>>> correctly decides its input all of the conventional HP proofs
>>>>>>>>>> have been refuted.
>>>>>>>>>
>>>>>>>>> If we are to make progress you need to publish the code of
>>>>>>>>> your infinite loop detector.
>>>>>>>>
>>>>>>>> If you can't understand 14 lines of code then this conclusively
>>>>>>>> proves that you won't understand hundreds of pages of code.
>>>>>>>>
>>>>>>>> Because people here are only interested in rebuttal and don't
>>>>>>>> give a rat's ass about an honest dialogue I make the price of a
>>>>>>>> continued dialogue key points of mutual agreement.
>>>>>>>>
>>>>>>>> If you don't understand that H(P,P)==0 is correct then
>>>>>>>> providing the source code will only provide the means for
>>>>>>>> denigration based on lack of comprehension. I absolutely will
>>>>>>>> not tolerate that.
>>>>>>>
>>>>>>> If we are to make progress you need to publish the source code
>>>>>>> of how your infinite loop detector works as your disassembly
>>>>>>> traces DO NOT provide that information.
>>>>>>>
>>>>>>> /Flibble
>>>>>>>
>>>>>>
>>>>>> I will not do that until many many points of mutual agreement
>>>>>> have occurred. Until many many points of mutual agreement have
>>>>>> occurred my assessment that my reviewers are lying cheating
>>>>>> bastards remains affirmed.
>>>>>
>>>>> At this point, as you refuse to provide evidence to the contrary,
>>>>> I conclude that the only case of non-halting behavior you can
>>>>> detect are the execution of the Intel x86 opcodes "EB FE". Being
>>>>> only able to detect a single case of non-halting behavior out of
>>>>> a total 2^n cases obviously does not qualify as a halting decider.
>>>>>
>>>>> You know what you must do to refute this conclusion: provide
>>>>> evidence in the form of source code.
>>>>>
>>>>> /Flibble
>>>>>
>>>>
>>>> That I prove that H(P,P)==0 by itself refutes the halting problem
>>>> proofs that claim that neither 0 nor 1 is correct.
>>>
>>> Your H gets the answer wrong if P would have halted as only your
>>
>> That people with shit for brains think that is gets the wrong answer
>> is no rebuttal at all.
>
> Shit for brains? Your insults are definitely increasing in intensity,
> have you checked your blood pressure recently?
>
> /Flibble
>

My proof has gotten down to the point that it is proven correct on the
basis of easily verified facts. Lying cheating bastards disagree with
these easily verified facts.

--
Copyright 2022 Pete Olcott

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

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

By: olcott on Thu, 9 Jun 2022

121olcott
server_pubkey.txt

rocksolid light 0.9.81
clearnet tor