Rocksolid Light

Welcome to novaBBS (click a section below)

mail  files  register  nodelist  faq  login

Let the machine do the dirty work. -- "Elements of Programming Style", Kernighan and Ritchie


computers / comp.ai.philosophy / Re: Honest dialogue on the proof that H(P,P)==0 is correct [proof defined]

Subject: Re: Honest dialogue on the proof that H(P,P)==0 is correct [proof defined]
From: olcott
Newsgroups: comp.theory, comp.ai.philosophy, comp.software-eng, sci.math.symbolic
Date: Tue, 10 Aug 2021 15:07 UTC
References: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.snarked.org!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Tue, 10 Aug 2021 10:07:15 -0500
Subject: Re: Honest dialogue on the proof that H(P,P)==0 is correct [proof
defined]
Newsgroups: comp.theory,comp.ai.philosophy,comp.software-eng,sci.math.symbolic
References: <HNidndugKOWGvpH8nZ2dnUU7-fXNnZ2d@giganews.com>
<Vs0PI.2099$xY.509@fx05.iad> <GLudnUM2eaoEC5H8nZ2dnUU7-evNnZ2d@giganews.com>
<5Z1PI.1823$6h1.1128@fx39.iad>
<r6idnXrkQsZ5JJH8nZ2dnUU7-V_NnZ2d@giganews.com> <qb9PI.22$uV3.2@fx18.iad>
<6radnYHwiMoYvpD8nZ2dnUU7-UPNnZ2d@giganews.com> <owaPI.297$uk4.251@fx20.iad>
<a82dnc_0ypriwZD8nZ2dnUU7-QHNnZ2d@giganews.com> <sel07d$pcf$1@dont-email.me>
<DdCdnaOAJLE3l5P8nZ2dnUU7-enNnZ2d@giganews.com> <sep914$6pc$1@dont-email.me>
<mdKdncO0j8L6w4z8nZ2dnUU7-S_NnZ2d@giganews.com> <ses089$7io$1@dont-email.me>
<-4idnXdW5JWtB4z8nZ2dnUU7-W_NnZ2d@giganews.com> <ses9ha$37f$1@dont-email.me>
<bcWdne-_8KvrN4z8nZ2dnUU7-dnNnZ2d@giganews.com> <sesb21$h6$1@dont-email.me>
<55SdneCopb8ELYz8nZ2dnUU7-UGdnZ2d@giganews.com> <seslrh$abb$1@dont-email.me>
From: NoO...@NoWhere.com (olcott)
Date: Tue, 10 Aug 2021 10:07:13 -0500
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:78.0) Gecko/20100101
Thunderbird/78.12.0
MIME-Version: 1.0
In-Reply-To: <seslrh$abb$1@dont-email.me>
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Language: en-US
Content-Transfer-Encoding: 8bit
Message-ID: <7K2dnTQBLqm-C4_8nZ2dnUU7-f3NnZ2d@giganews.com>
Lines: 229
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-EJOnq8thBMvAEiQBrvGby7YjJnovHLYYSoqeiFYYTFKRBuq0s/L8uaZcq5gyFai5KdCVI7WsxM3qoC7!rAb4iUpBy/RwcRZz6kXbGcrAzxMYfsoJfUBarG/MMCpGvecljLswFC0wK/0+oAnEvKB27BPJ7g==
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: 12231
View all headers
On 8/9/2021 8:47 PM, André G. Isaak wrote:
On 2021-08-09 16:47, olcott wrote:
On 8/9/2021 5:43 PM, André G. Isaak wrote:
On 2021-08-09 16:21, olcott wrote:
On 8/9/2021 5:17 PM, André G. Isaak wrote:
On 2021-08-09 15:12, olcott wrote:
On 8/9/2021 2:38 PM, André G. Isaak wrote:
On 2021-08-09 10:57, olcott wrote:
On 8/8/2021 1:50 PM, André G. Isaak wrote:
On 2021-08-06 22:23, olcott wrote:
On 8/6/2021 10:55 PM, André G. Isaak wrote:
On 2021-08-06 09:59, olcott wrote:

Yes, but bear in mind that 'halting' refers to Turing Machines operating on a specific input. It does not refer to simulations or what happens inside a halting decider. It refers *only* to actual computations, i.e. an actual Turing Machine operating on an actual input string.


So yet again you prove that you are totally clueless that pure simulations are computationally equivalent to direct executions ?

Your H is not a pure simulator


// Simplified Linz Ĥ (Linz:1990:319)
// Strachey(1965) CPL translated to C
void P(u32 x)
{
   if (H(x, x))
     HERE: goto HERE;
}

_P()
[00000d02](01)  55          push ebp
[00000d03](02)  8bec        mov ebp,esp
[00000d05](03)  8b4508      mov eax,[ebp+08]
[00000d08](01)  50          push eax       // push 2nd Param
[00000d09](03)  8b4d08      mov ecx,[ebp+08]
[00000d0c](01)  51          push ecx       // push 1st Param
[00000d0d](05)  e870feffff  call 00000b82  // call H
[00000d12](03)  83c408      add esp,+08
[00000d15](02)  85c0        test eax,eax
[00000d17](02)  7402        jz 00000d1b
[00000d19](02)  ebfe        jmp 00000d19
[00000d1b](01)  5d          pop ebp
[00000d1c](01)  c3          ret
Size in bytes:(0027) [00000d1c]

     machine   stack     stack     machine     assembly
     address   address   data      code        language
     ========  ========  ========  =========   =============
...[00000d0d][00101829][00000d12] e870feffff  call 00000b82  // call H

Begin Local Halt Decider Simulation at Machine Address:d02
...[00000d02][002118f1][002118f5] 55          push ebp
...[00000d03][002118f1][002118f5] 8bec        mov ebp,esp
...[00000d05][002118f1][002118f5] 8b4508      mov eax,[ebp+08]
...[00000d08][002118ed][00000d02] 50          push eax       // push P
...[00000d09][002118ed][00000d02] 8b4d08      mov ecx,[ebp+08]
...[00000d0c][002118e9][00000d02] 51          push ecx       // push P
...[00000d0d][002118e5][00000d12] e870feffff  call 00000b82  // call H
...[00000d02][0025c319][0025c31d] 55          push ebp
...[00000d03][0025c319][0025c31d] 8bec        mov ebp,esp
...[00000d05][0025c319][0025c31d] 8b4508      mov eax,[ebp+08]
...[00000d08][0025c315][00000d02] 50          push eax       // push P
...[00000d09][0025c315][00000d02] 8b4d08      mov ecx,[ebp+08]
...[00000d0c][0025c311][00000d02] 51          push ecx       // push P
...[00000d0d][0025c30d][00000d12] e870feffff  call 00000b82  // call H
Local Halt Decider: Infinite Recursion Detected Simulation Stopped

The fact that the execution trace of the simulation of P(P) on page 6 perfectly matches its source-code on page 5 conclusively proves that this execution trace performed by H is a pure simulation of P(P). There is no correct basis for disagreement, therefore anyone disagreeing either does not know the x86 language or they are simply lying.

You have a *partial trace* and *partial source code*. Neither shows what happens at B82.


if int add(int x, int y) returns 5 on add(2,3) we know for sure that add was correct on that input.

That is a poor analogy since 5 actually *is* the correct answer to 2+3.

We know that P(P) *does* halt, which means that if H(P, P) returns false we know for sure that H was *incorrect* on that input.

P(P) only halts because H(P,P) correctly decides that its input never halts and aborts this input on that basis.

X only halts because Y IMPLIES that X halts. That's basic logic.

The definition of halting does not refer at all to the *reason* why a particular computation halts.


The P that halts seems to contradict that H(P,P)==0 is correct yet it is verifiable that H(P,P)==0 is correct.

P(P) is either in the set of halting computations or it is not. It can't be both.

Since halting is a property defined *solely* in terms of the behaviour of the *actual* computation in question, we know that P(P) is in this set. Therefore H(P, P) == 0 *cannot* be verifiably correct.

That you keep ignoring this means that you are dishonest.

I am not ignoring this. I am asserting that it is false.




_P()
[00000d02](01)  55          push ebp
[00000d03](02)  8bec        mov ebp,esp
[00000d05](03)  8b4508      mov eax,[ebp+08]
[00000d08](01)  50          push eax       // push 2nd Param
[00000d09](03)  8b4d08      mov ecx,[ebp+08]
[00000d0c](01)  51          push ecx       // push 1st Param
[00000d0d](05)  e870feffff  call 00000b82  // call H
[00000d12](03)  83c408      add esp,+08
[00000d15](02)  85c0        test eax,eax
[00000d17](02)  7402        jz 00000d1b
[00000d19](02)  ebfe        jmp 00000d19
[00000d1b](01)  5d          pop ebp
[00000d1c](01)  c3          ret
Size in bytes:(0027) [00000d1c]

     machine   stack     stack     machine     assembly
     address   address   data      code        language
     ========  ========  ========  =========   =============
....[00000d0d][00101829][00000d12] e870feffff  call 00000b82  // call H

Begin Local Halt Decider Simulation at Machine Address:d02
....[00000d02][002118f1][002118f5] 55          push ebp
....[00000d03][002118f1][002118f5] 8bec        mov ebp,esp
....[00000d05][002118f1][002118f5] 8b4508      mov eax,[ebp+08]
....[00000d08][002118ed][00000d02] 50          push eax       // push P
....[00000d09][002118ed][00000d02] 8b4d08      mov ecx,[ebp+08]
....[00000d0c][002118e9][00000d02] 51          push ecx       // push P
....[00000d0d][002118e5][00000d12] e870feffff  call 00000b82  // call H
....[00000d02][0025c319][0025c31d] 55          push ebp
....[00000d03][0025c319][0025c31d] 8bec        mov ebp,esp
....[00000d05][0025c319][0025c31d] 8b4508      mov eax,[ebp+08]
....[00000d08][0025c315][00000d02] 50          push eax       // push P
....[00000d09][0025c315][00000d02] 8b4d08      mov ecx,[ebp+08]
....[00000d0c][0025c311][00000d02] 51          push ecx       // push P
....[00000d0d][0025c30d][00000d12] e870feffff  call 00000b82  // call H
Local Halt Decider: Infinite Recursion Detected Simulation Stopped

We can see that the above is a pure simulation of P on input P.
We can see that the above cannot possibly stop running unless H aborts its simulation of P on input P.

We can see that even if H does aborts its simulation of P on input P that P never reaches its final state, thus never halts even though its stops running.

Until you acknowledge these things or prove that the above P does reach its final state you are simply a liar. Proving that a different P reaches its final state is a dishonest dodge, thus also dishonest.
I am only interested in an honest dialogue.

To consider your earlier poor analogy:

"if int add(int x, int y) returns 5 on add(2,3) we know for sure that add was correct on that input."

The above as stated leaves out a critical piece. if int add(int x, int y) returns 5 on add(2,3) we know for sure that add was correct on that input *because* we know independently that 5 is actually the correct answer.

What you are claiming is more analogous to the claim that:

if int add(int x, int y) returns 9 on add(2,3) we know for sure that add was correct on that input.

Which of course is rubbish if add(x, y) is purported to do what its name suggests.

André

"The airplane crashed "only" because it ran out of fuel" IMPLIES that the airplane crashed.

"The man was arrested "only" because the police chief held a grudge" IMPLIES that the man was arrested.

Why you think that 'halting' works differently from these examples remains a mystery.

If you want to determine the correct answer to "does P(P) halt?", you need look only at the behaviour of P(P), not at your traces. In fact, you *shouldn't* look at anything other than the behaviour of P(P) because halting is defined *entirely* in terms of the behaviour of P(P).

If it is the case that P(P) "only" halts because H(P, P) returns false, it still halts, which means that H(P, P) *incorrectly* returns false.

Until you pay enough attention to see and acknowledge this I will simply assume that you are dishonest.

As is the case with virtually all of your terms, I assume you also have some private definition of 'dishonest'.





--
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre minds." Einstein


SubjectRepliesAuthor
o Anyone wanting an actual honestly dialogue on the proof that H(P,P)==0

By: olcott on Thu, 5 Aug 2021

15olcott
rocksolid light 0.7.2
clearneti2ptor