Rocksolid Light

Welcome to novaBBS (click a section below)

mail  files  register  newsreader  groups  login

Message-ID:  

"The medium is the massage." -- Crazy Nigel

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)

<uN2dnX22NLTxxD7_nZ2dnUU7_8xh4p2d@giganews.com>

  copy mid

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

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

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

That people with shit for brains think that is gets the wrong answer is
no rebuttal at all.

When I explain all of the details of how the answer is correct people
with shit for brains simply disagree without pointing to any error in my
reasoning.

> simulation doesn't execute the rest of P after P invokes H; the rest of
> P *is* executed in the halting problem proofs.
>
> /Flibble
>

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