Rocksolid Light

Welcome to novaBBS (click a section below)

mail  files  register  newsreader  groups  login

Message-ID:  

Real Users never use the Help key.


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)

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

  copy mid

https://www.novabbs.com/computers/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.

No, because is is shown that P(P) Halts, and thus H(P,P) is wrong.

For a Halt Decider, the ONLY behavior of "the input" that matters is
what the computation it represents does when independently run.

The real problem seems more to be that H doesn't actually exist as
actual Computation in your system (it uses features that aren't
available for other computations)

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

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