Rocksolid Light

Welcome to novaBBS (click a section below)

mail  files  register  newsreader  groups  login

Message-ID:  

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

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)

<87ydnf8LL4nc6z__nZ2dnUU7_8xh4p2d@giganews.com>

  copy mid

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

  copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Thu, 09 Jun 2022 17:37:52 -0500
Date: Thu, 9 Jun 2022 17:37:51 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.10.0
Subject: Re: Proving that P(P) != the correct x86 emulation of the input to
H(P,P)
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <N8GdnUDJ0IRRxjz_nZ2dnUU7_8zNnZ2d@giganews.com>
<jdydnWlvi_kquD__nZ2dnUU7_8zNnZ2d@giganews.com>
<RMpoK.7650$x7oc.3519@fx01.iad>
<xJKdnb8LMeMztz__nZ2dnUU7_83NnZ2d@giganews.com>
<20220609182847.00007585@reddwarf.jmc>
<N-adnVHsgaLIrT__nZ2dnUU7_8xh4p2d@giganews.com>
<20220609184617.00002add@reddwarf.jmc>
<eJ6dnaW1z8lnrj__nZ2dnUU7_83NnZ2d@giganews.com>
<vKqoK.75291$GTEb.17970@fx48.iad>
<BYGdnY7xlufi1D__nZ2dnUU7_8zNnZ2d@giganews.com>
<J_roK.51524$ssF.13016@fx14.iad>
<osadnc-FVvDu0j__nZ2dnUU7_81g4p2d@giganews.com>
<vgsoK.21728$6P.2117@fx38.iad>
<h_qdnb8cOfX0yT__nZ2dnUU7_83NnZ2d@giganews.com>
<CGsoK.16478$gjlb.2500@fx44.iad>
<-eidnS2VbJfywj__nZ2dnUU7_81g4p2d@giganews.com>
<PntoK.92394$J0r9.54835@fx11.iad>
<56OdnYEQJIev-z__nZ2dnUU7_83NnZ2d@giganews.com>
<7_toK.131290$JVi.111799@fx17.iad>
<qp-dndDi7NIb8j__nZ2dnUU7_8zNnZ2d@giganews.com>
<20220609231524.000077bb@reddwarf.jmc>
<MZGdnQUbkcpd7D__nZ2dnUU7_8xh4p2d@giganews.com>
<9zuoK.44320$elob.20576@fx43.iad>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <9zuoK.44320$elob.20576@fx43.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <87ydnf8LL4nc6z__nZ2dnUU7_8xh4p2d@giganews.com>
Lines: 318
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-jBm1/YLwvHm51fvBf0TdbJM7u7TahxD0ypOd1BDoX2lO+yWmQ0puVrtQdKDFAhXdq4NnxK7X9ox5h+Y!B+O1dOpbfXltyIKaAcDRidHVdA2rmIgbH7+HNaoPP/FTYzzS1/x0bJBp3QZv0EcyLsMPfhmfDs5N
X-Complaints-To: abuse@giganews.com
X-DMCA-Notifications: http://www.giganews.com/info/dmca.html
X-Abuse-and-DMCA-Info: Please be sure to forward a copy of ALL headers
X-Abuse-and-DMCA-Info: Otherwise we will be unable to process your complaint properly
X-Postfilter: 1.3.40
X-Original-Bytes: 18105
 by: olcott - Thu, 9 Jun 2022 22:37 UTC

On 6/9/2022 5:33 PM, Richard Damon wrote:
> On 6/9/22 6:18 PM, olcott wrote:
>> On 6/9/2022 5:15 PM, Mr Flibble wrote:
>>> On Thu, 9 Jun 2022 17:09:08 -0500
>>> olcott <NoOne@NoWhere.com> wrote:
>>>
>>>> On 6/9/2022 4:54 PM, Richard Damon wrote:
>>>>> On 6/9/22 5:29 PM, olcott wrote:
>>>>>> On 6/9/2022 4:13 PM, Richard Damon wrote:
>>>>>>>
>>>>>>> On 6/9/22 5:00 PM, olcott wrote:
>>>>>>>> On 6/9/2022 3:25 PM, Richard Damon wrote:
>>>>>>>>> On 6/9/22 4:13 PM, olcott wrote:
>>>>>>>>>> On 6/9/2022 2:57 PM, Richard Damon wrote:
>>>>>>>>>>> On 6/9/22 3:52 PM, olcott wrote:
>>>>>>>>>>>> On 6/9/2022 2:38 PM, Richard Damon wrote:
>>>>>>>>>>>>>
>>>>>>>>>>>>> On 6/9/22 3:26 PM, olcott wrote:
>>>>>>>>>>>>>> On 6/9/2022 1:12 PM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 6/9/22 1:55 PM, olcott wrote:
>>>>>>>>>>>>>>>> On 6/9/2022 12:46 PM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>> On Thu, 9 Jun 2022 12:39:32 -0500
>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>>>>>>>> On 6/9/2022 12:28 PM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>>>> On Thu, 9 Jun 2022 12:15:24 -0500
>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>>>>>>>>>> On 6/9/2022 12:06 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>> On 6/9/22 12:54 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>> On 6/9/2022 11:34 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 6/9/22 11:47 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>> void P(u32 x)
>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>       if (H(x, x))
>>>>>>>>>>>>>>>>>>>>>>>>         HERE: goto HERE;
>>>>>>>>>>>>>>>>>>>>>>>>       return;
>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>       P(P);
>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> _P()
>>>>>>>>>>>>>>>>>>>>>>>> [000012e7](01)  55              push ebp
>>>>>>>>>>>>>>>>>>>>>>>> [000012e8](02)  8bec            mov ebp,esp
>>>>>>>>>>>>>>>>>>>>>>>> [000012ea](03)  8b4508          mov eax,[ebp+08]
>>>>>>>>>>>>>>>>>>>>>>>> [000012ed](01)  50              push eax
>>>>>>>>>>>>>>>>>>>>>>>> [000012ee](03)  8b4d08          mov ecx,[ebp+08]
>>>>>>>>>>>>>>>>>>>>>>>> [000012f1](01)  51              push ecx
>>>>>>>>>>>>>>>>>>>>>>>> [000012f2](05)  e880feffff      call 00001177 //
>>>>>>>>>>>>>>>>>>>>>>>> call H [000012f7](03)  83c408          add
>>>>>>>>>>>>>>>>>>>>>>>> esp,+08 [000012fa](02)  85c0            test
>>>>>>>>>>>>>>>>>>>>>>>> eax,eax [000012fc](02)  7402            jz
>>>>>>>>>>>>>>>>>>>>>>>> 00001300 [000012fe](02)  ebfe            jmp
>>>>>>>>>>>>>>>>>>>>>>>> 000012fe [00001300](01)  5d              pop ebp
>>>>>>>>>>>>>>>>>>>>>>>> [00001301](01)  c3              ret
>>>>>>>>>>>>>>>>>>>>>>>> Size in bytes:(0027) [00001301]
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> _main()
>>>>>>>>>>>>>>>>>>>>>>>> [00001307](01)  55              push ebp
>>>>>>>>>>>>>>>>>>>>>>>> [00001308](02)  8bec            mov ebp,esp
>>>>>>>>>>>>>>>>>>>>>>>> [0000130a](05)  68e7120000      push 000012e7 //
>>>>>>>>>>>>>>>>>>>>>>>> push P [0000130f](05)  e8d3ffffff      call
>>>>>>>>>>>>>>>>>>>>>>>> 000012e7 // call P [00001314](03)  83c404
>>>>>>>>>>>>>>>>>>>>>>>>    add esp,+04 [00001317](02)  33c0
>>>>>>>>>>>>>>>>>>>>>>>> xor eax,eax [00001319](01)  5d              pop
>>>>>>>>>>>>>>>>>>>>>>>> ebp [0000131a](01)  c3              ret
>>>>>>>>>>>>>>>>>>>>>>>> Size in bytes:(0020) [0000131a]
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>      machine   stack     stack     machine
>>>>>>>>>>>>>>>>>>>>>>>> assembly address   address   data      code
>>>>>>>>>>>>>>>>>>>>>>>>   language ========  ========  ========
>>>>>>>>>>>>>>>>>>>>>>>> ========= =============
>>>>>>>>>>>>>>>>>>>>>>>> [00001307][00102190][00000000] 55         push
>>>>>>>>>>>>>>>>>>>>>>>> ebp [00001308][00102190][00000000] 8bec
>>>>>>>>>>>>>>>>>>>>>>>> mov ebp,esp [0000130a][0010218c][000012e7]
>>>>>>>>>>>>>>>>>>>>>>>> 68e7120000 push 000012e7 //
>>>>>>>>>>>>>>>>>>>>>>>> push P [0000130f][00102188][00001314] e8d3ffffff
>>>>>>>>>>>>>>>>>>>>>>>> call 000012e7
>>>>>>>>>>>>>>>>>>>>>>>> // call P [000012e7][00102184][00102190] 55 push
>>>>>>>>>>>>>>>>>>>>>>>> ebp // enter executed P
>>>>>>>>>>>>>>>>>>>>>>>> [000012e8][00102184][00102190] 8bec       mov
>>>>>>>>>>>>>>>>>>>>>>>> ebp,esp [000012ea][00102184][00102190] 8b4508
>>>>>>>>>>>>>>>>>>>>>>>>   mov eax,[ebp+08]
>>>>>>>>>>>>>>>>>>>>>>>> [000012ed][00102180][000012e7] 50         push
>>>>>>>>>>>>>>>>>>>>>>>> eax      //
>>>>>>>>>>>>>>>>>>>>>>>> push P [000012ee][00102180][000012e7] 8b4d08
>>>>>>>>>>>>>>>>>>>>>>>> mov ecx,[ebp+08] [000012f1][0010217c][000012e7]
>>>>>>>>>>>>>>>>>>>>>>>> 51 push ecx      // push P
>>>>>>>>>>>>>>>>>>>>>>>> [000012f2][00102178][000012f7] e880feffff
>>>>>>>>>>>>>>>>>>>>>>>> call 00001177 // call H
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> Begin Local Halt Decider Simulation   Execution
>>>>>>>>>>>>>>>>>>>>>>>> Trace Stored
>>>>>>>>>>>>>>>>>>>>>>>> at:212244 [000012e7][00212230][00212234] 55 push
>>>>>>>>>>>>>>>>>>>>>>>> ebp // enter emulated P
>>>>>>>>>>>>>>>>>>>>>>>> [000012e8][00212230][00212234] 8bec        mov
>>>>>>>>>>>>>>>>>>>>>>>> ebp,esp [000012ea][00212230][00212234] 8b4508
>>>>>>>>>>>>>>>>>>>>>>>>    mov eax,[ebp+08]
>>>>>>>>>>>>>>>>>>>>>>>> [000012ed][0021222c][000012e7] 50          push
>>>>>>>>>>>>>>>>>>>>>>>> eax      //
>>>>>>>>>>>>>>>>>>>>>>>> push P [000012ee][0021222c][000012e7] 8b4d08
>>>>>>>>>>>>>>>>>>>>>>>>   mov ecx,[ebp+08] [000012f1][00212228][000012e7]
>>>>>>>>>>>>>>>>>>>>>>>> 51 push ecx      // push P
>>>>>>>>>>>>>>>>>>>>>>>> [000012f2][00212224][000012f7] e880feffff
>>>>>>>>>>>>>>>>>>>>>>>> call 00001177 // call H
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> So, by what instruction reference manual is a
>>>>>>>>>>>>>>>>>>>>>>> call 00001177
>>>>>>>>>>>>>>>>>>>>>>> followedby the execution of the instruction at
>>>>>>>>>>>>>>>>>>>>>>> 000012e7.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> Your "CPU" is broken, or emulation incorrect.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>>>>>>>>>>>>> [000012e7][0025cc58][0025cc5c] 55          push
>>>>>>>>>>>>>>>>>>>>>>>> ebp      //
>>>>>>>>>>>>>>>>>>>>>>>> enter emulated P
>>>>>>>>>>>>>>>>>>>>>>>> [000012e8][0025cc58][0025cc5c] 8bec        mov
>>>>>>>>>>>>>>>>>>>>>>>> ebp,esp [000012ea][0025cc58][0025cc5c] 8b4508
>>>>>>>>>>>>>>>>>>>>>>>>    mov eax,[ebp+08]
>>>>>>>>>>>>>>>>>>>>>>>> [000012ed][0025cc54][000012e7] 50          push
>>>>>>>>>>>>>>>>>>>>>>>> eax      //
>>>>>>>>>>>>>>>>>>>>>>>> push P [000012ee][0025cc54][000012e7] 8b4d08
>>>>>>>>>>>>>>>>>>>>>>>>   mov ecx,[ebp+08] [000012f1][0025cc50][000012e7]
>>>>>>>>>>>>>>>>>>>>>>>> 51 push ecx      // push P
>>>>>>>>>>>>>>>>>>>>>>>> [000012f2][0025cc4c][000012f7] e880feffff
>>>>>>>>>>>>>>>>>>>>>>>> call 00001177 // call H Local Halt Decider:
>>>>>>>>>>>>>>>>>>>>>>>> Infinite Recursion
>>>>>>>>>>>>>>>>>>>>>>>> Detected Simulation Stopped
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> It is completely obvious that when H(P,P)
>>>>>>>>>>>>>>>>>>>>>>>> correctly emulates
>>>>>>>>>>>>>>>>>>>>>>>> its input that it must emulate the first seven
>>>>>>>>>>>>>>>>>>>>>>>> instructions of
>>>>>>>>>>>>>>>>>>>>>>>> P. Because the seventh instruction of P repeats
>>>>>>>>>>>>>>>>>>>>>>>> this process we
>>>>>>>>>>>>>>>>>>>>>>>> know with complete certainty that the correct
>>>>>>>>>>>>>>>>>>>>>>>> and complete
>>>>>>>>>>>>>>>>>>>>>>>> emulation of P by H would never reach its final
>>>>>>>>>>>>>>>>>>>>>>>> “ret” instruction, thus never halts.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> Problem, the 7th intruction DOESN't "Just repeat
>>>>>>>>>>>>>>>>>>>>>>> the procedure",
>>>>>>>>>>>>>>>>>>>>>>> because that H always has the option to abort its
>>>>>>>>>>>>>>>>>>>>>>> simulation,
>>>>>>>>>>>>>>>>>>>>>>> just like this onne did, and return to its P and
>>>>>>>>>>>>>>>>>>>>>>> see it halt.
>>>>>>>>>>>>>>>>>>>>>> THAT YOU ARE SIMPLY TOO STUPID TO UNDERSTAND THIS
>>>>>>>>>>>>>>>>>>>>>> IS NO ACTUAL
>>>>>>>>>>>>>>>>>>>>>> REBUTTAL AT ALL:
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> The partial correct x86 emulation of the input to
>>>>>>>>>>>>>>>>>>>>>> H(P,P) conclusively proves that the complete and
>>>>>>>>>>>>>>>>>>>>>> correct x86 emulation
>>>>>>>>>>>>>>>>>>>>>> would never stop running.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> You SAY that, but you don't answer the actual
>>>>>>>>>>>>>>>>>>>>> questions about HOW.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> THAT YOU ARE SIMPLY TOO STUPID TO UNDERSTAND THIS IS
>>>>>>>>>>>>>>>>>>>> NO EVIDENCE
>>>>>>>>>>>>>>>>>>>> WHAT-SO-EVER THAT I DID NOT COMPLETELY PROVE THAT
>>>>>>>>>>>>>>>>>>>> THE CORRECT
>>>>>>>>>>>>>>>>>>>> PARTIAL EMULATION OF THE INPUT TO H(P,P)
>>>>>>>>>>>>>>>>>>>> CONCLUSIVELY PROVES THAT
>>>>>>>>>>>>>>>>>>>> THE CORRECT AND COMPLETE X86 EMULATION OF THE INPUT
>>>>>>>>>>>>>>>>>>>> TO H(P,P)
>>>>>>>>>>>>>>>>>>>> WOULD NEVER STOP RUNNING.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> It is completely obvious that when H(P,P) correctly
>>>>>>>>>>>>>>>>>>>> emulates its
>>>>>>>>>>>>>>>>>>>> input that it must emulate the first seven
>>>>>>>>>>>>>>>>>>>> instructions of P.
>>>>>>>>>>>>>>>>>>>> Because the seventh instruction of P repeats this
>>>>>>>>>>>>>>>>>>>> process we know
>>>>>>>>>>>>>>>>>>>> with complete certainty that the correct and
>>>>>>>>>>>>>>>>>>>> complete emulation of
>>>>>>>>>>>>>>>>>>>> P by H would never reach its final “ret”
>>>>>>>>>>>>>>>>>>>> instruction, thus never
>>>>>>>>>>>>>>>>>>>> halts.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> If P should have halted (i.e. no infinite loop) then
>>>>>>>>>>>>>>>>>>> your simulation
>>>>>>>>>>>>>>>>>>> detector, S (not H), gets the answer wrong.  You S is
>>>>>>>>>>>>>>>>>>> NOT a halting
>>>>>>>>>>>>>>>>>>> decider.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> THAT YOU ARE SIMPLY TOO STUPID TO UNDERSTAND THIS IS
>>>>>>>>>>>>>>>>>> NO ACTUAL
>>>>>>>>>>>>>>>>>> REBUTTAL AT ALL.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> _P()
>>>>>>>>>>>>>>>>>> [00001352](01)  55              push ebp
>>>>>>>>>>>>>>>>>> [00001353](02)  8bec            mov ebp,esp
>>>>>>>>>>>>>>>>>> [00001355](03)  8b4508          mov eax,[ebp+08]
>>>>>>>>>>>>>>>>>> [00001358](01)  50              push eax      // push P
>>>>>>>>>>>>>>>>>> [00001359](03)  8b4d08          mov ecx,[ebp+08]
>>>>>>>>>>>>>>>>>> [0000135c](01)  51              push ecx      // push P
>>>>>>>>>>>>>>>>>> [0000135d](05)  e840feffff      call 000011a2 // call H
>>>>>>>>>>>>>>>>>> [00001362](03)  83c408          add esp,+08
>>>>>>>>>>>>>>>>>> [00001365](02)  85c0            test eax,eax
>>>>>>>>>>>>>>>>>> [00001367](02)  7402            jz 0000136b
>>>>>>>>>>>>>>>>>> [00001369](02)  ebfe            jmp 00001369
>>>>>>>>>>>>>>>>>> [0000136b](01)  5d              pop ebp
>>>>>>>>>>>>>>>>>> [0000136c](01)  c3              ret
>>>>>>>>>>>>>>>>>> Size in bytes:(0027) [0000136c]
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> It is completely obvious that when H(P,P) correctly
>>>>>>>>>>>>>>>>>> emulates its
>>>>>>>>>>>>>>>>>> input that it must emulate the first seven
>>>>>>>>>>>>>>>>>> instructions of P. Because
>>>>>>>>>>>>>>>>>> the seventh instruction of P repeats this process we
>>>>>>>>>>>>>>>>>> know with
>>>>>>>>>>>>>>>>>> complete certainty that the correct and complete
>>>>>>>>>>>>>>>>>> emulation of P by H
>>>>>>>>>>>>>>>>>> would never reach its final “ret” instruction, thus
>>>>>>>>>>>>>>>>>> never halts.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> We are going around and around and around in circles. I
>>>>>>>>>>>>>>>>> will try again:
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> If you replace the opcodes "EB FE" at 00001369 with the
>>>>>>>>>>>>>>>>> opcodes "90 90"
>>>>>>>>>>>>>>>>> then your H gets the answer wrong: P should have halted.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> As I already said before this is merely your
>>>>>>>>>>>>>>>> cluelessness that when H(P,P) is invoked the correct x86
>>>>>>>>>>>>>>>> emulation of the input to H(P,P) makes and code after
>>>>>>>>>>>>>>>> [0000135d] unreachable.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Wrong, because when that H return the value 0, it will
>>>>>>>>>>>>>>> get there.
>>>>>>>>>>>>>> Like I said people that are dumber than a box of rocks
>>>>>>>>>>>>>> won't be able to correctly understand this.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> When H(P,P) is invoked the correctly emulated input to
>>>>>>>>>>>>>> H(P,P) cannot possibly reach any instruction beyond
>>>>>>>>>>>>>> [0000135d].
>>>>>>>>>>>>>
>>>>>>>>>>>>> So, you are defining that you H(P,P) never returns because
>>>>>>>>>>>>> it is caught in the infinite rcursion.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Thats fine, just says it can't be the correctly answering
>>>>>>>>>>>>> decider you claim it to be.
>>>>>>>>>>>>
>>>>>>>>>>>> I have corrected you on this too many times.
>>>>>>>>>>>
>>>>>>>>>>> How. You need to define what H(P,P) actually does.
>>>>>>>>>>
>>>>>>>>>> I have explained that too many times.
>>>>>>>>>>
>>>>>>>>>> To understand that H(P,P)==0 is correct we only need to know
>>>>>>>>>> that H performs a correct x86 emulation of its input and then
>>>>>>>>>> examine the execution trace.
>>>>>>>>>
>>>>>>>>> And a CORRECT emulation of the code will Halt if H(P,P) returns
>>>>>>>>> 0, which it can only do if it does not actually do a correct
>>>>>>>>> emulation
>>>>>>>>
>>>>>>>> The correctly emulated input to H(P,P) never gets past its
>>>>>>>> machine address [0000135d].
>>>>>>>>
>>>>>>>
>>>>>>> Only if H actually doesn't return 0. Yes, H can't correctly
>>>>>>> return 0 if it correctly emulates its input, but you can't drop
>>>>>>> that requirement.
>>>>>>
>>>>>> void P(u32 x)
>>>>>> {
>>>>>>     if (H(x, x))
>>>>>>       HERE: goto HERE;
>>>>>>     return;
>>>>>> }
>>>>>>
>>>>>> int main()
>>>>>> {
>>>>>>     Output("Input_Halts = ", H((u32)P, (u32)P));
>>>>>> }
>>>>>>
>>>>>> When H returns 0 it does not returns 0 to P it returns 0 to
>>>>>> main().
>>>>>
>>>>> But it also return 0 to the computation P(P), maybe not the copy
>>>>> that it is simulating, since it aborts that before it get to it,
>>>>
>>>> Finally you are not stupid or deceptive.
>>>
>>> If H never returns a value to P then H is not a halting decider; if H
>>> returns a value of 0 to main() when P halts then H is not a halting
>>> decider.
>>>
>>> H is not a halting decider; H is a simulation detector, S.
>>>
>>> /Flibble
>>>
>>
>> In other words you are saying the infintely nested emulation only
>> excutes for a few steps and then it stops on its own.
>>
>
> No, the "infinitely nested emulation" halts when the first H(P,P) that
> P(P) called aborts it simulation.

When I tell you that an input only halts when it reaches its final state
and I tell you this many hundreds of times because you are a God damned
liar you pretend that I never said this.

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