Rocksolid Light

Welcome to novaBBS (click a section below)

mail  files  register  newsreader  groups  login

Message-ID:  

Whom computers would destroy, they must first drive mad.


computers / comp.ai.philosophy / Re: Competent software engineers will agree that H(P,P)==0 is correct [ Jeff is incompetent or dishonest ]

SubjectAuthor
* Re: Competent software engineers will agree that H(P,P)==0 is correctolcott
+* Re: Competent software engineers will agree that H(P,P)==0 is correctolcott
|`* Re: Competent software engineers will agree that H(P,P)==0 is correctolcott
| +- Re: Competent software engineers will agree that H(P,P)==0 is correctRichard Damon
| +* Re: Competent software engineers will agree that H(P,P)==0 is correctolcott
| |`* Re: Competent software engineers will agree that H(P,P)==0 is correctolcott
| | `- Re: Competent software engineers will agree that H(P,P)==0 is correctolcott
| +* Re: Competent software engineers will agree that H(P,P)==0 is correctolcott
| |`- Re: Competent software engineers will agree that H(P,P)==0 is correct [ ridiculoRichard Damon
| `* Re: Competent software engineers will agree that H(P,P)==0 is correctolcott
|  `- Re: Competent software engineers will agree that H(P,P)==0 is correctRichard Damon
`- Re: Competent software engineers will agree that H(P,P)==0 is correctRichard Damon

1
Re: Competent software engineers will agree that H(P,P)==0 is correct [ ridiculously stupid ]

<xPednXQm6dCN1gP_nZ2dnUU7_83NnZ2d@giganews.com>

 copy mid

https://www.novabbs.com/computers/article-flat.php?id=9165&group=comp.ai.philosophy#9165

 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: Mon, 06 Jun 2022 13:44:31 -0500
Date: Mon, 6 Jun 2022 13:44:30 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.9.1
Subject: Re: Competent software engineers will agree that H(P,P)==0 is correct
[ ridiculously stupid ]
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <N5-dnal-trqPgQP_nZ2dnUU7_83NnZ2d@giganews.com>
<d25678aa-3764-4027-9076-c6b372e290e7n@googlegroups.com>
<875yldljuz.fsf@bsb.me.uk>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <875yldljuz.fsf@bsb.me.uk>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Message-ID: <xPednXQm6dCN1gP_nZ2dnUU7_83NnZ2d@giganews.com>
Lines: 39
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-MXn5nSeo1rxTDcVxQAOEbvzDnnwbDXA+A7QkxumgDShG7uo1wCJnKbGeReINT3XiSJvQONeuwpdwL//!e9qvx6JavX+LUzz2boqpvvDKljEve76x4ozxA9FD18ohABJIPdLf55B8QKqcib1A0xrYMzbWWlBr
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: 2724
 by: olcott - Mon, 6 Jun 2022 18:44 UTC

On 6/6/2022 1:36 PM, Ben wrote:
> wij <wyniijj2@gmail.com> writes:
>
>> Students of average level understand Halting decider cannot exist, as olcott
>> has demonstrated for years (no 'correct' H exists).
>>
>> If H does not exist, what dose "H(P,P)==0" mean?
>
> H as specified in, say, Linz does not exist. But PO's H does and so P
> (which should really be called something like H_Hat) also exists.
> That's why H is wrong about the "halting" of P(P).
>
> Another way to write the proof is to show that every Turing machine gets
> at least one instance wrong -- i.e. that no TM computes the halting
> function. PO's H is just an example of that, and he even tells us that
> it gets the instance representing P(P) wrong.
>

int sum(int x, int y)
{ return x + y;
}

H(P,P) must return 0 because the actual behavior specified by the actual
input never halts.

To say that H(P,P) must return a value based on an entirely different
sequence of instructions than are specified by its input is as
ridiculously stupid as requiring sum(3,4) to return any integer besides 7.

Since Ben is not ridiculously stupid it makes no sense that he forms
ridiculously stupid conclusions.

--
Copyright 2022 Pete Olcott

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

Re: Competent software engineers will agree that H(P,P)==0 is correct [ ridiculously stupid ]

<rPGdnfeuXbccxAP_nZ2dnUU7_83NnZ2d@giganews.com>

 copy mid

https://www.novabbs.com/computers/article-flat.php?id=9166&group=comp.ai.philosophy#9166

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic comp.ai.philosophy
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: Mon, 06 Jun 2022 14:46:09 -0500
Date: Mon, 6 Jun 2022 14:46:07 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.9.1
Subject: Re: Competent software engineers will agree that H(P,P)==0 is correct
[ ridiculously stupid ]
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,comp.ai.philosophy
References: <N5-dnal-trqPgQP_nZ2dnUU7_83NnZ2d@giganews.com>
<d25678aa-3764-4027-9076-c6b372e290e7n@googlegroups.com>
<875yldljuz.fsf@bsb.me.uk> <xPednXQm6dCN1gP_nZ2dnUU7_83NnZ2d@giganews.com>
<261ca1dc-df02-4fc5-8dee-9abb4c2df3b2n@googlegroups.com>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <261ca1dc-df02-4fc5-8dee-9abb4c2df3b2n@googlegroups.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <rPGdnfeuXbccxAP_nZ2dnUU7_83NnZ2d@giganews.com>
Lines: 60
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-5wyHidsbKOTRZHNcCtfFWZro1azxOH59vWzGsgLt0bR9o3Z9NgHeAPJLnE+XiJHKOJXT6/XaRjwy+KF!0f9Z+2uHJa32RaTITTgM9zya7D7927XWLO7jUJlyKxkSL2BrV1S89K4TQZefprOKEprCPJUpE7xD
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: 3581
 by: olcott - Mon, 6 Jun 2022 19:46 UTC

On 6/6/2022 2:16 PM, wij wrote:
>> H(P,P) must return 0 because the actual behavior specified by the actual
>> input never halts.
>
> The true answer is derived from the real H, not you.
>
> A proof that "H(P,P)==0 is correct" without showing what the H is is a garbage proof, unconditionally.

YOU DON'T SEEM TO BE ABLE TO COMPREHEND THIS
As long as we know that int sum(int x, int y) returns the sum of its
arguments we know that sum(3,4)==7 without seeing the source-code of sum().

The following conclusively proves that H(P,P)==0 is the correct value
for H to return in the same way that we know that sum(3, 4) == 7.

That it does not show the detailed steps of how H derives this correct
return value is no rebuttal what-so-ever to the assertion that H(P,P)==0
is correct.

void P(u32 x)
{ if (H(x, x))
HERE: goto HERE;
return;
}

int main()
{ Output("Input_Halts = ", H((u32)P, (u32)P));
}

_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 can know with complete
certainty that the emulated P never reaches its final “ret” instruction,
thus never halts.

--
Copyright 2022 Pete Olcott

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

Re: Competent software engineers will agree that H(P,P)==0 is correct [ ridiculously stupid ]

<xfKdnWrLjLAfEwP_nZ2dnUU7_83NnZ2d@giganews.com>

 copy mid

https://www.novabbs.com/computers/article-flat.php?id=9169&group=comp.ai.philosophy#9169

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Path: i2pn2.org!i2pn.org!eternal-september.org!reader02.eternal-september.org!border1.nntp.dca1.giganews.com!nntp.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Mon, 06 Jun 2022 18:32:18 -0500
Date: Mon, 6 Jun 2022 18:32:16 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.9.1
Subject: Re: Competent software engineers will agree that H(P,P)==0 is correct
[ ridiculously stupid ]
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <N5-dnal-trqPgQP_nZ2dnUU7_83NnZ2d@giganews.com>
<d25678aa-3764-4027-9076-c6b372e290e7n@googlegroups.com>
<875yldljuz.fsf@bsb.me.uk> <xPednXQm6dCN1gP_nZ2dnUU7_83NnZ2d@giganews.com>
<261ca1dc-df02-4fc5-8dee-9abb4c2df3b2n@googlegroups.com>
<rPGdnfeuXbccxAP_nZ2dnUU7_83NnZ2d@giganews.com>
<69069406-766e-4af8-8d49-c5807bdb252bn@googlegroups.com>
<hb2dneeH5er97gP_nZ2dnUU7_83NnZ2d@giganews.com>
<dcf85979-1534-4baf-8483-9c621cc3c445n@googlegroups.com>
<u4adnRq7Cbsq5gP_nZ2dnUU7_8zNnZ2d@giganews.com>
<8424a12e-023b-47bf-a0e5-33b8292a1030n@googlegroups.com>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <8424a12e-023b-47bf-a0e5-33b8292a1030n@googlegroups.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Message-ID: <xfKdnWrLjLAfEwP_nZ2dnUU7_83NnZ2d@giganews.com>
Lines: 58
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-czWCwZecbTfWTGzo2lGOWMitbNPS8keHgrRGmgoKxnVUOLDXsagwprYilZjcw9v4NpngFn3ThWOvPft!WRI3zPFVMPfz+l4FH3R+QB/lCZPy2PT/3nTN2sB8CO3rIHHGGTh6Ag1o/I/Wy8AWkb09zHLnvvPG
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: 4135
 by: olcott - Mon, 6 Jun 2022 23:32 UTC

On 6/6/2022 5:36 PM, wij wrote:
>>> reviewers need to see exactly the 'jack shit' how H is defined.
>> Reviewers may need to see exactly how H is defined to determine that
>> H(P,P) does correctly determine the halt status of its input.
>
> Reviewers absolutely need to see exactly how H is defined to determine that
> H(P,P) does correctly determine the halt status of its input.
>
>> Reviewers DO NOT NEED TO SEE EXACTLY HOW H IS DEFINED TO KNOW THAT
>> H(P,P)==0 IS THE CORRECT HALT STATUS VALUE FOR THE "IMPOSSIBLE" INPUT.
>
> What do you expect reviewers to say about H while H is not shown (empty)?
> Reviewers cannot deduce any answer from empty declaration (no contents).
>

It may be that reviewers on this forum are far too stupid to have any
idea that an x86 emulator emulates x86 machine code.

This is not typically the case. Every competent reviewer can easily
determine that within the hypothesis that:

H(P,P) correctly emulates its input with an x86 emulator

that the correctly emulated input to H(P,P) would never reach its "ret"
instruction.

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

>>> Declaration/stipulation and implement/proof are two different things.
>>> You boasted long ago that you have implemented H. Where is it?
>>> Are you suggesting/admitting GUR is correct (no correct Halting decider can exist)?
>> You are "GUR" growling at me?
>> I have conclusively proved that H(P,P)==0 is correct.
>
> The real H cannot exist (by GUR, and proved by the absence of POOH).

--
Copyright 2022 Pete Olcott

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

Re: Competent software engineers will agree that H(P,P)==0 is correct [ ridiculously stupid ]

<KyxnK.8517$CBlb.3877@fx42.iad>

 copy mid

https://www.novabbs.com/computers/article-flat.php?id=9171&group=comp.ai.philosophy#9171

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Path: i2pn2.org!i2pn.org!usenet.blueworldhosting.com!feed1.usenet.blueworldhosting.com!peer02.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx42.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: Competent software engineers will agree that H(P,P)==0 is correct
[ ridiculously stupid ]
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <N5-dnal-trqPgQP_nZ2dnUU7_83NnZ2d@giganews.com>
<d25678aa-3764-4027-9076-c6b372e290e7n@googlegroups.com>
<875yldljuz.fsf@bsb.me.uk> <xPednXQm6dCN1gP_nZ2dnUU7_83NnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <xPednXQm6dCN1gP_nZ2dnUU7_83NnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 51
Message-ID: <KyxnK.8517$CBlb.3877@fx42.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: Mon, 6 Jun 2022 21:08:57 -0400
X-Received-Bytes: 2933
 by: Richard Damon - Tue, 7 Jun 2022 01:08 UTC

On 6/6/22 2:44 PM, olcott wrote:
> On 6/6/2022 1:36 PM, Ben wrote:
>> wij <wyniijj2@gmail.com> writes:
>>
>>> Students of average level understand Halting decider cannot exist, as
>>> olcott
>>> has demonstrated for years (no 'correct' H exists).
>>>
>>> If H does not exist, what dose "H(P,P)==0" mean?
>>
>> H as specified in, say, Linz does not exist.  But PO's H does and so P
>> (which should really be called something like H_Hat) also exists.
>> That's why H is wrong about the "halting" of P(P).
>>
>> Another way to write the proof is to show that every Turing machine gets
>> at least one instance wrong -- i.e. that no TM computes the halting
>> function.  PO's H is just an example of that, and he even tells us that
>> it gets the instance representing P(P) wrong.
>>
>
> int sum(int x, int y)
> {
>   return x + y;
> }
>
> H(P,P) must return 0 because the actual behavior specified by the actual
> input never halts.

Nope. P(P) Halts if H(P,P) returns 0. PROVEN.

>
> To say that H(P,P) must return a value based on an entirely different
> sequence of instructions than are specified by its input is as
> ridiculously stupid as requiring sum(3,4) to return any integer besides 7.

Nope, since the sequence of instructions that are specified as the
input, which MUST also include all the instructions of H and everything
that H calls, DO specify that behavior, as shown by the direct execution
of it, then that IS what that input specifies.

In fact, if you exclude the code for H from the input, then the input no
longer specifies a computation, and thus is proven to NOT be the input
defined by Linz, so you are just shown to be lying about what you are doing.

>
> Since Ben is not ridiculously stupid it makes no sense that he forms
> ridiculously stupid conclusions.
>

Re: Competent software engineers will agree that H(P,P)==0 is correct [ ridiculously stupid ]

<uBxnK.8518$CBlb.3358@fx42.iad>

 copy mid

https://www.novabbs.com/computers/article-flat.php?id=9172&group=comp.ai.philosophy#9172

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Path: i2pn2.org!i2pn.org!usenet.blueworldhosting.com!feed1.usenet.blueworldhosting.com!peer02.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx42.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: Competent software engineers will agree that H(P,P)==0 is correct
[ ridiculously stupid ]
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <N5-dnal-trqPgQP_nZ2dnUU7_83NnZ2d@giganews.com>
<d25678aa-3764-4027-9076-c6b372e290e7n@googlegroups.com>
<875yldljuz.fsf@bsb.me.uk> <xPednXQm6dCN1gP_nZ2dnUU7_83NnZ2d@giganews.com>
<261ca1dc-df02-4fc5-8dee-9abb4c2df3b2n@googlegroups.com>
<rPGdnfeuXbccxAP_nZ2dnUU7_83NnZ2d@giganews.com>
<69069406-766e-4af8-8d49-c5807bdb252bn@googlegroups.com>
<hb2dneeH5er97gP_nZ2dnUU7_83NnZ2d@giganews.com>
<dcf85979-1534-4baf-8483-9c621cc3c445n@googlegroups.com>
<u4adnRq7Cbsq5gP_nZ2dnUU7_8zNnZ2d@giganews.com>
<8424a12e-023b-47bf-a0e5-33b8292a1030n@googlegroups.com>
<xfKdnWrLjLAfEwP_nZ2dnUU7_83NnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <xfKdnWrLjLAfEwP_nZ2dnUU7_83NnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 72
Message-ID: <uBxnK.8518$CBlb.3358@fx42.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: Mon, 6 Jun 2022 21:11:54 -0400
X-Received-Bytes: 4473
 by: Richard Damon - Tue, 7 Jun 2022 01:11 UTC

On 6/6/22 7:32 PM, olcott wrote:
> On 6/6/2022 5:36 PM, wij wrote:
>>>> reviewers need to see exactly the 'jack shit' how H is defined.
>>> Reviewers may need to see exactly how H is defined to determine that
>>> H(P,P) does correctly determine the halt status of its input.
>>
>> Reviewers absolutely need to see exactly how H is defined to determine
>> that
>>   H(P,P) does correctly determine the halt status of its input.
>>
>>> Reviewers DO NOT NEED TO SEE EXACTLY HOW H IS DEFINED TO KNOW THAT
>>> H(P,P)==0 IS THE CORRECT HALT STATUS VALUE FOR THE "IMPOSSIBLE" INPUT.
>>
>> What do you expect reviewers to say about H while H is not shown (empty)?
>> Reviewers cannot deduce any answer from empty declaration (no contents).
>>
>
> It may be that reviewers on this forum are far too stupid  to have any
> idea that an x86 emulator emulates x86 machine code.

Right, and the DEFINITION of a CALL instruction in x86 assembly is to
push the return address on the stack and continue execution at the
specified address, thus the trace must continue there.

Note, x86 assembly has not concept of User/System code that switches
with a simple call instruction

>
> This is not typically the case. Every competent reviewer can easily
> determine that within the hypothesis that:
>
> H(P,P) correctly emulates its input with an x86 emulator

Not if it aborts.

>
> that the correctly emulated input to H(P,P) would never reach its "ret"
> instruction.

Only because an H that does correctly emulate its input will never stop
its emulation, and thus never answers for non-halting inputs, and thus
fails to be a Halt Decider.

>
> _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]
>
>
>>>> Declaration/stipulation and implement/proof are two different things.
>>>> You boasted long ago that you have implemented H. Where is it?
>>>> Are you suggesting/admitting GUR is correct (no correct Halting
>>>> decider can exist)?
>>> You are "GUR" growling at me?
>>> I have conclusively proved that H(P,P)==0 is correct.
>>
>> The real H cannot exist (by GUR, and proved by the absence of POOH).
>
>

Re: Competent software engineers will agree that H(P,P)==0 is correct [ ridiculously stupid ]

<06ydnXFznIYW_QL_nZ2dnUU7_83NnZ2d@giganews.com>

 copy mid

https://www.novabbs.com/computers/article-flat.php?id=9176&group=comp.ai.philosophy#9176

 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: Tue, 07 Jun 2022 09:28:27 -0500
Date: Tue, 7 Jun 2022 09:28:26 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.9.1
Subject: Re: Competent software engineers will agree that H(P,P)==0 is correct
[ ridiculously stupid ]
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <N5-dnal-trqPgQP_nZ2dnUU7_83NnZ2d@giganews.com>
<d25678aa-3764-4027-9076-c6b372e290e7n@googlegroups.com>
<875yldljuz.fsf@bsb.me.uk> <xPednXQm6dCN1gP_nZ2dnUU7_83NnZ2d@giganews.com>
<261ca1dc-df02-4fc5-8dee-9abb4c2df3b2n@googlegroups.com>
<rPGdnfeuXbccxAP_nZ2dnUU7_83NnZ2d@giganews.com>
<69069406-766e-4af8-8d49-c5807bdb252bn@googlegroups.com>
<hb2dneeH5er97gP_nZ2dnUU7_83NnZ2d@giganews.com>
<dcf85979-1534-4baf-8483-9c621cc3c445n@googlegroups.com>
<u4adnRq7Cbsq5gP_nZ2dnUU7_8zNnZ2d@giganews.com>
<8424a12e-023b-47bf-a0e5-33b8292a1030n@googlegroups.com>
<xfKdnWrLjLAfEwP_nZ2dnUU7_83NnZ2d@giganews.com>
<d9e212e6-18cd-41c1-a176-e26b8c17243an@googlegroups.com>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <d9e212e6-18cd-41c1-a176-e26b8c17243an@googlegroups.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Message-ID: <06ydnXFznIYW_QL_nZ2dnUU7_83NnZ2d@giganews.com>
Lines: 41
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-6V1ngT3pKR1znn8nOfFmJhvi4UEca/iDwbefSCJfW3WMLXA4Zk1yJupuDZ9NqA0JwS9jkQ/sx7CT3J9!+l4DjmHjrjIEqDUJwaz7MIUzMyCim1PBbJH8BFDW/YbjH5JEz4f84DPfkxnVDJx4x7DoGk9xdjSa
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: 3645
 by: olcott - Tue, 7 Jun 2022 14:28 UTC

On 6/7/2022 8:38 AM, wij wrote:
> On Tuesday, 7 June 2022 at 07:32:26 UTC+8, olcott wrote:
>> On 6/6/2022 5:36 PM, wij wrote:
>>>>> reviewers need to see exactly the 'jack shit' how H is defined.
>>>> Reviewers may need to see exactly how H is defined to determine that
>>>> H(P,P) does correctly determine the halt status of its input.
>>>
>>> Reviewers absolutely need to see exactly how H is defined to determine that
>>> H(P,P) does correctly determine the halt status of its input.
>>>
>>>> Reviewers DO NOT NEED TO SEE EXACTLY HOW H IS DEFINED TO KNOW THAT
>>>> H(P,P)==0 IS THE CORRECT HALT STATUS VALUE FOR THE "IMPOSSIBLE" INPUT.
>>>
>>> What do you expect reviewers to say about H while H is not shown (empty)?
>>> Reviewers cannot deduce any answer from empty declaration (no contents).
>>>
>> It may be that reviewers on this forum are far too stupid to have any
>> idea that an x86 emulator emulates x86 machine code.
>>
>> This is not typically the case. Every competent reviewer can easily
>> determine that within the hypothesis that:
>> H(P,P) correctly emulates its input with an x86 emulator
>> that the correctly emulated input to H(P,P) would never reach its "ret"
>> instruction.
>
> Everybody (including you) understands "the correctly emulated input to H(P,P)
> would never reach its "ret" instruction."

Never reaching its "ret" instruction means that it never halts.

> Therefore, the HONEST answer is "H(P,P) is undecidable."

How the Hell can you possibly construe correctly decided as undecidable?

--
Copyright 2022 Pete Olcott

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

Re: Competent software engineers will agree that H(P,P)==0 is correct [ ridiculously stupid ]

<cpCdnT0Rb8Sq8AL_nZ2dnUU7_8xh4p2d@giganews.com>

 copy mid

https://www.novabbs.com/computers/article-flat.php?id=9177&group=comp.ai.philosophy#9177

 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!border1.nntp.dca1.giganews.com!nntp.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Tue, 07 Jun 2022 10:22:31 -0500
Date: Tue, 7 Jun 2022 10:22:30 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.9.1
Subject: Re: Competent software engineers will agree that H(P,P)==0 is correct
[ ridiculously stupid ]
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <N5-dnal-trqPgQP_nZ2dnUU7_83NnZ2d@giganews.com>
<d25678aa-3764-4027-9076-c6b372e290e7n@googlegroups.com>
<875yldljuz.fsf@bsb.me.uk> <xPednXQm6dCN1gP_nZ2dnUU7_83NnZ2d@giganews.com>
<261ca1dc-df02-4fc5-8dee-9abb4c2df3b2n@googlegroups.com>
<rPGdnfeuXbccxAP_nZ2dnUU7_83NnZ2d@giganews.com>
<69069406-766e-4af8-8d49-c5807bdb252bn@googlegroups.com>
<hb2dneeH5er97gP_nZ2dnUU7_83NnZ2d@giganews.com>
<dcf85979-1534-4baf-8483-9c621cc3c445n@googlegroups.com>
<u4adnRq7Cbsq5gP_nZ2dnUU7_8zNnZ2d@giganews.com>
<8424a12e-023b-47bf-a0e5-33b8292a1030n@googlegroups.com>
<xfKdnWrLjLAfEwP_nZ2dnUU7_83NnZ2d@giganews.com>
<adfae03d-9836-432f-a90e-c950f1981ecdn@googlegroups.com>
<87ilpced9o.fsf@bsb.me.uk>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <87ilpced9o.fsf@bsb.me.uk>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <cpCdnT0Rb8Sq8AL_nZ2dnUU7_8xh4p2d@giganews.com>
Lines: 114
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-tHgAe4Uul5vnmYEVJF/EUKjRgkkQ1vaK5n9mgmBfhihjzrr7Lxl6bPH5Uy8NZR4ENyTGDktDN7eZQhL!H4vcT2gGu/d0etcoqW3jqCO0TjBwHzsrDkFhlHO62BDu2MSdlg/Avn5TeegXmsueQSiX39AE/QHi
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: 6129
X-Received-Bytes: 6220
 by: olcott - Tue, 7 Jun 2022 15:22 UTC

On 6/7/2022 9:53 AM, Ben wrote:
> Malcolm McLean <malcolm.arthur.mclean@gmail.com> writes:
>
>> On Tuesday, 7 June 2022 at 00:32:26 UTC+1, olcott wrote:
>
>>> This is not typically the case. Every competent reviewer can easily
>>> determine that within the hypothesis that:
>>> H(P,P) correctly emulates its input with an x86 emulator
>>> that the correctly emulated input to H(P,P) would never reach its "ret"
>>> instruction.
>>> _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]
>>>
>> You can't tell from that that "ret" is never reached. It depends what is in H.
>>
>> You say that H emulates P(P).
>
> He is very studiously avoiding saying that! Obviously that's what
> /should/ be simulated, because H(X,Y) should tell us about X(Y), but
> then H(P,P) == 0 would be even more obviously wrong.
>
> That's what the new unexplained mantra is all about. "The correct
> simulation of the input to H(P,P)" can mean whatever PO wants it to
> mean.

LIAR LIAR PANTS ON FIRE !!!
As I have said many hundreds of times H perform and x86 emulation of its
input. This only has a single 100% precise meaning. That you say that I
am vague about this can only be a God damned lie and not any sort of
honest mistake.

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 can know with complete
certainty that the emulated P never reaches its final “ret” instruction,
thus never halts.

> For that reason I can't see why anyone thinks he's wrong about
> it. It's not the halting problem, but it could only be wrong if he told
> us it should do something it isn't doing.
>

H computes the mapping from its input finite strings to its accept or
reject state on the basis of the actual behavior specified by the actual
input as measured by the correct x86 emulation or UTM simulation of this
input by H.

>> In fact, according to you, H returns 0 (non-halting) because it detects that
>> otherwise the nested simulations will go on forever. That's correct. However,
>> in aborting the simulation, it makes it not true that the nested simulations
>> will go on forever. That's the part you've failed to understand.
>

computation that halts … the Turing machine will halt whenever it enters
a final state. (Linz:1990:234)

That the correct and complete x86 emulation of the input to H(P,P) or
Infinite_Loop wold never stop running conclusively proves that these
inputs specify a non-halting sequence of x86 instructions.

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]

> He understands that very well. I can provide all sorts of quotes to
> attest to that. His plan is just to find some words that will keep the
> conversation going.
>

Since you know that

(1) Deciders in computer science compute the mapping from their inputs
to an accept or reject state.

(2) P(P) is not an input to H

Why do you persist in the deception that H must compute the halt status
of P(P) ? (Can only parrot textbook authors with no actual
understanding of the underlying relationships involved).

--
Copyright 2022 Pete Olcott

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

Re: Competent software engineers will agree that H(P,P)==0 is correct [ ridiculously stupid ]

<LIidnbJDiOUYHwL_nZ2dnUU7_8zNnZ2d@giganews.com>

 copy mid

https://www.novabbs.com/computers/article-flat.php?id=9178&group=comp.ai.philosophy#9178

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Path: i2pn2.org!i2pn.org!usenet.blueworldhosting.com!feed1.usenet.blueworldhosting.com!3.us.feeder.erje.net!feeder.erje.net!border1.nntp.dca1.giganews.com!nntp.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Tue, 07 Jun 2022 11:53:25 -0500
Date: Tue, 7 Jun 2022 11:53:24 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.9.1
Subject: Re: Competent software engineers will agree that H(P,P)==0 is correct
[ ridiculously stupid ]
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <N5-dnal-trqPgQP_nZ2dnUU7_83NnZ2d@giganews.com>
<d25678aa-3764-4027-9076-c6b372e290e7n@googlegroups.com>
<875yldljuz.fsf@bsb.me.uk> <xPednXQm6dCN1gP_nZ2dnUU7_83NnZ2d@giganews.com>
<261ca1dc-df02-4fc5-8dee-9abb4c2df3b2n@googlegroups.com>
<rPGdnfeuXbccxAP_nZ2dnUU7_83NnZ2d@giganews.com>
<69069406-766e-4af8-8d49-c5807bdb252bn@googlegroups.com>
<hb2dneeH5er97gP_nZ2dnUU7_83NnZ2d@giganews.com>
<dcf85979-1534-4baf-8483-9c621cc3c445n@googlegroups.com>
<u4adnRq7Cbsq5gP_nZ2dnUU7_8zNnZ2d@giganews.com>
<8424a12e-023b-47bf-a0e5-33b8292a1030n@googlegroups.com>
<xfKdnWrLjLAfEwP_nZ2dnUU7_83NnZ2d@giganews.com>
<d9e212e6-18cd-41c1-a176-e26b8c17243an@googlegroups.com>
<06ydnXFznIYW_QL_nZ2dnUU7_83NnZ2d@giganews.com>
<fe811ca6-f740-4c88-abd6-a2f57b44d22fn@googlegroups.com>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <fe811ca6-f740-4c88-abd6-a2f57b44d22fn@googlegroups.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Message-ID: <LIidnbJDiOUYHwL_nZ2dnUU7_8zNnZ2d@giganews.com>
Lines: 74
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-jKr90UVdPI4LVsqTqnjIR7ZIMFL5L74NrHS3CpSyLLXfsROJ5jPaJv9RgTDPOhHyDXDwolKOItmbqBz!0dt2o1gkYPD+DQ/KehqagBd3srlD4k1QW8WDx5TMaoWM7IJQYL7HtRwWrxZqUfU7LiBG47XEJBCq
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: 5088
 by: olcott - Tue, 7 Jun 2022 16:53 UTC

On 6/7/2022 11:32 AM, wij wrote:
> On Tuesday, 7 June 2022 at 22:28:35 UTC+8, olcott wrote:
>> On 6/7/2022 8:38 AM, wij wrote:
>>> On Tuesday, 7 June 2022 at 07:32:26 UTC+8, olcott wrote:
>>>> On 6/6/2022 5:36 PM, wij wrote:
>>>>>>> reviewers need to see exactly the 'jack shit' how H is defined.
>>>>>> Reviewers may need to see exactly how H is defined to determine that
>>>>>> H(P,P) does correctly determine the halt status of its input.
>>>>>
>>>>> Reviewers absolutely need to see exactly how H is defined to determine that
>>>>> H(P,P) does correctly determine the halt status of its input.
>>>>>
>>>>>> Reviewers DO NOT NEED TO SEE EXACTLY HOW H IS DEFINED TO KNOW THAT
>>>>>> H(P,P)==0 IS THE CORRECT HALT STATUS VALUE FOR THE "IMPOSSIBLE" INPUT.
>>>>>
>>>>> What do you expect reviewers to say about H while H is not shown (empty)?
>>>>> Reviewers cannot deduce any answer from empty declaration (no contents).
>>>>>
>>>> It may be that reviewers on this forum are far too stupid to have any
>>>> idea that an x86 emulator emulates x86 machine code.
>>>>
>>>> This is not typically the case. Every competent reviewer can easily
>>>> determine that within the hypothesis that:
>>>> H(P,P) correctly emulates its input with an x86 emulator
>>>> that the correctly emulated input to H(P,P) would never reach its "ret"
>>>> instruction.
>>>
>>> Everybody (including you) understands "the correctly emulated input to H(P,P)
>>> would never reach its "ret" instruction."
>> Never reaching its "ret" instruction means that it never halts.
>>> Therefore, the HONEST answer is "H(P,P) is undecidable."
>> How the Hell can you possibly construe correctly decided as undecidable?
>> --
>> Copyright 2022 Pete Olcott
>>
>> "Talent hits a target no one else can hit;
>> Genius hits a target no one else can see."
>> Arthur Schopenhauer
>
> Simply because that is what it is -- As you mentioned, "the correctly emulated input to H(P,P)
> would never reach its "ret" instruction." -- I.e. H(P,P) is undecidable (never halts).
>
> What the Hell can you possibly be honest to say H(P,P)==0 while observed and testified that
> the "H(P,P) would never reach its "ret" instruction"?

That is the kind of confusion that you get when you only glance at a
couple of my words before spouting off a rebuttal.

the correctly emulated input to H(P,P)
correctly emulated input to H(P,P)
correctly emulated input to H(P,P)
correctly emulated input to H(P,P)
correctly emulated input to H(P,P)
would never reach its "ret" instruction

thus conclusively proving that H(P,P)==0 is correct.

That you "interpreted"
correctly emulated input to H(P,P) never halts
as meaning that H never halts is ridiculously stupid.

> In the circumstance of no evidence (no definition of H),
> What the Hell can you possibly conclude "H(P,P)==0" is correct?

--
Copyright 2022 Pete Olcott

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

Re: Competent software engineers will agree that H(P,P)==0 is correct [ Jeff is incompetent or dishonest ]

<_KCdnbSMT6E-FQL_nZ2dnUU7_8zNnZ2d@giganews.com>

 copy mid

https://www.novabbs.com/computers/article-flat.php?id=9179&group=comp.ai.philosophy#9179

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic comp.ai.philosophy
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: Tue, 07 Jun 2022 12:19:31 -0500
Date: Tue, 7 Jun 2022 12:19:30 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.9.1
Subject: Re: Competent software engineers will agree that H(P,P)==0 is correct
[ Jeff is incompetent or dishonest ]
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,comp.ai.philosophy
References: <N5-dnal-trqPgQP_nZ2dnUU7_83NnZ2d@giganews.com>
<d25678aa-3764-4027-9076-c6b372e290e7n@googlegroups.com>
<875yldljuz.fsf@bsb.me.uk> <xPednXQm6dCN1gP_nZ2dnUU7_83NnZ2d@giganews.com>
<261ca1dc-df02-4fc5-8dee-9abb4c2df3b2n@googlegroups.com>
<rPGdnfeuXbccxAP_nZ2dnUU7_83NnZ2d@giganews.com>
<69069406-766e-4af8-8d49-c5807bdb252bn@googlegroups.com>
<hb2dneeH5er97gP_nZ2dnUU7_83NnZ2d@giganews.com>
<dcf85979-1534-4baf-8483-9c621cc3c445n@googlegroups.com>
<u4adnRq7Cbsq5gP_nZ2dnUU7_8zNnZ2d@giganews.com>
<8424a12e-023b-47bf-a0e5-33b8292a1030n@googlegroups.com>
<xfKdnWrLjLAfEwP_nZ2dnUU7_83NnZ2d@giganews.com>
<adfae03d-9836-432f-a90e-c950f1981ecdn@googlegroups.com>
<87ilpced9o.fsf@bsb.me.uk> <t7o0hm$p8i$1@dont-email.me>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <t7o0hm$p8i$1@dont-email.me>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <_KCdnbSMT6E-FQL_nZ2dnUU7_8zNnZ2d@giganews.com>
Lines: 115
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-SN2cR3h3s0cmfVE53feyhy7A2RegWHdj5sIQmELyRJaVrPj5NORmzVjZ8k20axYBf/OlQils8l/cLih!Qw87SFXBOzkmJqXfhAH8y24PoS5iav+QnkgoOQRa94aqaDWuPfMfzW8hvcbvqZR8z0svyJjtnZVU
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: 6487
 by: olcott - Tue, 7 Jun 2022 17:19 UTC

On 6/7/2022 12:05 PM, Jeff Barnett wrote:
> On 6/7/2022 8:53 AM, Ben wrote:
>> Malcolm McLean <malcolm.arthur.mclean@gmail.com> writes:
>>
>>> On Tuesday, 7 June 2022 at 00:32:26 UTC+1, olcott wrote:
>>
>>>> This is not typically the case. Every competent reviewer can easily
>>>> determine that within the hypothesis that:
>>>> H(P,P) correctly emulates its input with an x86 emulator
>>>> that the correctly emulated input to H(P,P) would never reach its "ret"
>>>> instruction.
>>>> _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]
>>>>
>>> You can't tell from that that "ret" is never reached. It depends what
>>> is in H.
>>>
>>> You say that H emulates P(P).
>>
>> He is very studiously avoiding saying that!  Obviously that's what
>> /should/ be simulated, because H(X,Y) should tell us about X(Y), but
>> then H(P,P) == 0 would be even more obviously wrong.
>>
>> That's what the new unexplained mantra is all about.  "The correct
>> simulation of the input to H(P,P)" can mean whatever PO wants it to
>> mean.  For that reason I can't see why anyone thinks he's wrong about
>> it.  It's not the halting problem, but it could only be wrong if he told
>> us it should do something it isn't doing.
>
> It may be the case that I have misjudged the Sire of POOP all this time.
> A feature of engineering software products today is not implementing or
> testing to a specification. In fact there usually isn't a spec anywhere

This is a 100% complete specification required to correctly determine
that the correctly emulated input to H(P,P) never reaches its "ret"
instruction, thus never halts.

That you imply that it is not a complete specification proves that you
are incompetent or dishonest or both.

void P(u32 x)
{ if (H(x, x))
HERE: goto HERE;
return;
}

int main()
{ Output("Input_Halts = ", H((u32)P, (u32)P));
}

_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 can know with complete
certainty that the emulated P never reaches its final “ret” instruction,
thus never halts.

> in sight. That's how M$ as well as other software vendors avoid fixing
> obvious mistakes. Since the spec doesn't exist, how can you know if it's
> an error. I'm guessing that this style of development contributed to PO
> not being able to hold a job (and all the projects we know about were
> failures). It's the modern way and PO was there first. Let's all raise
> our cups and shout hooray for Pete!
>
>>> In fact, according to you, H returns 0 (non-halting) because it
>>> detects that
>>> otherwise the nested simulations will go on forever. That's correct.
>>> However,
>>> in aborting the simulation, it makes it not true that the nested
>>> simulations
>>> will go on forever. That's the part you've failed to understand.
>>
>> He understands that very well.  I can provide all sorts of quotes to
>> attest to that.  His plan is just to find some words that will keep the
>> conversation going.--
> Jeff Barnett

--
Copyright 2022 Pete Olcott

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

Re: Competent software engineers will agree that H(P,P)==0 is correct [ ridiculously stupid ]

<NeedndptW-NoEAL_nZ2dnUU7_83NnZ2d@giganews.com>

 copy mid

https://www.novabbs.com/computers/article-flat.php?id=9180&group=comp.ai.philosophy#9180

 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: Tue, 07 Jun 2022 12:42:13 -0500
Date: Tue, 7 Jun 2022 12:42:12 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.9.1
Subject: Re: Competent software engineers will agree that H(P,P)==0 is correct
[ ridiculously stupid ]
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <N5-dnal-trqPgQP_nZ2dnUU7_83NnZ2d@giganews.com>
<d25678aa-3764-4027-9076-c6b372e290e7n@googlegroups.com>
<875yldljuz.fsf@bsb.me.uk> <xPednXQm6dCN1gP_nZ2dnUU7_83NnZ2d@giganews.com>
<261ca1dc-df02-4fc5-8dee-9abb4c2df3b2n@googlegroups.com>
<rPGdnfeuXbccxAP_nZ2dnUU7_83NnZ2d@giganews.com>
<69069406-766e-4af8-8d49-c5807bdb252bn@googlegroups.com>
<hb2dneeH5er97gP_nZ2dnUU7_83NnZ2d@giganews.com>
<dcf85979-1534-4baf-8483-9c621cc3c445n@googlegroups.com>
<u4adnRq7Cbsq5gP_nZ2dnUU7_8zNnZ2d@giganews.com>
<8424a12e-023b-47bf-a0e5-33b8292a1030n@googlegroups.com>
<xfKdnWrLjLAfEwP_nZ2dnUU7_83NnZ2d@giganews.com>
<d9e212e6-18cd-41c1-a176-e26b8c17243an@googlegroups.com>
<06ydnXFznIYW_QL_nZ2dnUU7_83NnZ2d@giganews.com>
<fe811ca6-f740-4c88-abd6-a2f57b44d22fn@googlegroups.com>
<LIidnbJDiOUYHwL_nZ2dnUU7_8zNnZ2d@giganews.com>
<612d2ed4-41fe-42f1-b62b-c0168343720en@googlegroups.com>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <612d2ed4-41fe-42f1-b62b-c0168343720en@googlegroups.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Message-ID: <NeedndptW-NoEAL_nZ2dnUU7_83NnZ2d@giganews.com>
Lines: 87
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-43mrHz9oMOeLcMHiHrKAC5vyOETE5/PVLhzrl7xdt/GW2EUROGFlxPVmVTV20RGL7F96Fiz4DuZ0hfO!TrgVi9uiNnlsDyoV1BJEIzG/RIruPDgjAOp1+MJ/Tzhx9wsRS9Nd1u6ArCdBXlT96XA1Acvz38IQ
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: 6140
 by: olcott - Tue, 7 Jun 2022 17:42 UTC

On 6/7/2022 12:30 PM, wij wrote:
> On Wednesday, 8 June 2022 at 00:53:32 UTC+8, olcott wrote:
>> On 6/7/2022 11:32 AM, wij wrote:
>>> On Tuesday, 7 June 2022 at 22:28:35 UTC+8, olcott wrote:
>>>> On 6/7/2022 8:38 AM, wij wrote:
>>>>> On Tuesday, 7 June 2022 at 07:32:26 UTC+8, olcott wrote:
>>>>>> On 6/6/2022 5:36 PM, wij wrote:
>>>>>>>>> reviewers need to see exactly the 'jack shit' how H is defined.
>>>>>>>> Reviewers may need to see exactly how H is defined to determine that
>>>>>>>> H(P,P) does correctly determine the halt status of its input.
>>>>>>>
>>>>>>> Reviewers absolutely need to see exactly how H is defined to determine that
>>>>>>> H(P,P) does correctly determine the halt status of its input.
>>>>>>>
>>>>>>>> Reviewers DO NOT NEED TO SEE EXACTLY HOW H IS DEFINED TO KNOW THAT
>>>>>>>> H(P,P)==0 IS THE CORRECT HALT STATUS VALUE FOR THE "IMPOSSIBLE" INPUT.
>>>>>>>
>>>>>>> What do you expect reviewers to say about H while H is not shown (empty)?
>>>>>>> Reviewers cannot deduce any answer from empty declaration (no contents).
>>>>>>>
>>>>>> It may be that reviewers on this forum are far too stupid to have any
>>>>>> idea that an x86 emulator emulates x86 machine code.
>>>>>>
>>>>>> This is not typically the case. Every competent reviewer can easily
>>>>>> determine that within the hypothesis that:
>>>>>> H(P,P) correctly emulates its input with an x86 emulator
>>>>>> that the correctly emulated input to H(P,P) would never reach its "ret"
>>>>>> instruction.
>>>>>
>>>>> Everybody (including you) understands "the correctly emulated input to H(P,P)
>>>>> would never reach its "ret" instruction."
>>>> Never reaching its "ret" instruction means that it never halts.
>>>>> Therefore, the HONEST answer is "H(P,P) is undecidable."
>>>> How the Hell can you possibly construe correctly decided as undecidable?
>>>> --
>>>> Copyright 2022 Pete Olcott
>>>>
>>>> "Talent hits a target no one else can hit;
>>>> Genius hits a target no one else can see."
>>>> Arthur Schopenhauer
>>>
>>> Simply because that is what it is -- As you mentioned, "the correctly emulated input to H(P,P)
>>> would never reach its "ret" instruction." -- I.e. H(P,P) is undecidable (never halts).
>>>
>>> What the Hell can you possibly be honest to say H(P,P)==0 while observed and testified that
>>> the "H(P,P) would never reach its "ret" instruction"?
>> That is the kind of confusion that you get when you only glance at a
>> couple of my words before spouting off a rebuttal.
>> the correctly emulated input to H(P,P)
>> correctly emulated input to H(P,P)
>> correctly emulated input to H(P,P)
>> correctly emulated input to H(P,P)
>> correctly emulated input to H(P,P)
>> would never reach its "ret" instruction
>> thus conclusively proving that H(P,P)==0 is correct.
>>
>> That you "interpreted"
>> correctly emulated input to H(P,P) never halts
>> as meaning that H never halts is ridiculously stupid.
>>> In the circumstance of no evidence (no definition of H),
>>> What the Hell can you possibly conclude "H(P,P)==0" is correct?
>> --
>> Copyright 2022 Pete Olcott
>>
>> "Talent hits a target no one else can hit;
>> Genius hits a target no one else can see."
>> Arthur Schopenhauer
>
> Just curious, why you are so desperate to disprove the HP? Anything good to you?

That question is like asking a cancer researcher why they bother to look
for a cure for cancer rather than just sitting home drinking beer.

That the HP is correctly refuted refutes the Tarski undefinability
theorem by proxy thus establishes the basis for mathematically
formalizing the notion of conceptual truth.

This enables Davidson's truth conditional semantics to be anchored in a
formal definition of true. This provides an enormously better roadmap to
strong AI.

--
Copyright 2022 Pete Olcott

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

Re: Competent software engineers will agree that H(P,P)==0 is correct [ ridiculously stupid ]

<e9RnK.54671$X_i.26651@fx18.iad>

 copy mid

https://www.novabbs.com/computers/article-flat.php?id=9181&group=comp.ai.philosophy#9181

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Path: i2pn2.org!i2pn.org!weretis.net!feeder8.news.weretis.net!news.uzoreto.com!feeder1.feed.usenet.farm!feed.usenet.farm!tr3.eu1.usenetexpress.com!feeder.usenetexpress.com!tr2.iad1.usenetexpress.com!peer02.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx18.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: Competent software engineers will agree that H(P,P)==0 is correct [ ridiculously stupid ]
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <N5-dnal-trqPgQP_nZ2dnUU7_83NnZ2d@giganews.com> <d25678aa-3764-4027-9076-c6b372e290e7n@googlegroups.com> <875yldljuz.fsf@bsb.me.uk> <xPednXQm6dCN1gP_nZ2dnUU7_83NnZ2d@giganews.com> <261ca1dc-df02-4fc5-8dee-9abb4c2df3b2n@googlegroups.com> <rPGdnfeuXbccxAP_nZ2dnUU7_83NnZ2d@giganews.com> <69069406-766e-4af8-8d49-c5807bdb252bn@googlegroups.com> <hb2dneeH5er97gP_nZ2dnUU7_83NnZ2d@giganews.com> <dcf85979-1534-4baf-8483-9c621cc3c445n@googlegroups.com> <u4adnRq7Cbsq5gP_nZ2dnUU7_8zNnZ2d@giganews.com> <8424a12e-023b-47bf-a0e5-33b8292a1030n@googlegroups.com> <xfKdnWrLjLAfEwP_nZ2dnUU7_83NnZ2d@giganews.com> <adfae03d-9836-432f-a90e-c950f1981ecdn@googlegroups.com> <87ilpced9o.fsf@bsb.me.uk> <cpCdnT0Rb8Sq8AL_nZ2dnUU7_8xh4p2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <cpCdnT0Rb8Sq8AL_nZ2dnUU7_8xh4p2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 173
Message-ID: <e9RnK.54671$X_i.26651@fx18.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: Tue, 7 Jun 2022 19:27:05 -0400
X-Received-Bytes: 8044
 by: Richard Damon - Tue, 7 Jun 2022 23:27 UTC

On 6/7/22 11:22 AM, olcott wrote:
> On 6/7/2022 9:53 AM, Ben wrote:
>> Malcolm McLean <malcolm.arthur.mclean@gmail.com> writes:
>>
>>> On Tuesday, 7 June 2022 at 00:32:26 UTC+1, olcott wrote:
>>
>>>> This is not typically the case. Every competent reviewer can easily
>>>> determine that within the hypothesis that:
>>>> H(P,P) correctly emulates its input with an x86 emulator
>>>> that the correctly emulated input to H(P,P) would never reach its "ret"
>>>> instruction.
>>>> _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]
>>>>
>>> You can't tell from that that "ret" is never reached. It depends what
>>> is in H.
>>>
>>> You say that H emulates P(P).
>>
>> He is very studiously avoiding saying that!  Obviously that's what
>> /should/ be simulated, because H(X,Y) should tell us about X(Y), but
>> then H(P,P) == 0 would be even more obviously wrong.
>>
>> That's what the new unexplained mantra is all about.  "The correct
>> simulation of the input to H(P,P)" can mean whatever PO wants it to
>> mean.
>
> LIAR LIAR PANTS ON FIRE !!!
> As I have said many hundreds of times H perform and x86 emulation of its
> input. This only has a single 100% precise meaning. That you say that I
> am vague about this can only be a God damned lie and not any sort of
> honest mistake.

And, will you clearly state if this means it is emulating the machine P
with input P or something different, and if something different, what it is,

You have been VERY evasive about defining it exactly.

The ONLY correct definition of "emulation" that applies to a Halt
Decider is the results of a UTM.

>
> 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 can know with complete
> certainty that the emulated P never reaches its final “ret” instruction,
> thus never halts.

Nope, because the 7th instruction does NOT "just repeat the processees".

Not unless you agree that the DEFINITION of H(P,P) is EXACTLY equivalent
to doing a P(P), and thus, H can't return an answer if P(P) doesn't halt.

You need to look at your actual definitions.

>
>> For that reason I can't see why anyone thinks he's wrong about
>> it.  It's not the halting problem, but it could only be wrong if he told
>> us it should do something it isn't doing.
>>
>
> H computes the mapping from its input finite strings to its accept or
> reject state on the basis of the actual behavior specified by the actual
> input as measured by the correct x86 emulation or UTM simulation of this
> input by H.

And if H ACTUALLY does this, it can never answer for a non-halting
computation, as if H DOES actually simulate like a UTM, that is the
behavior you have shown is genetated.

Even if H only answers based on what a UTM would do, it is proven that
its answer is wrong, as UTM(P,P) Halts if H(P,P) returns 0, as you have
shown.

Note UTM(P,P) gives the exact same result as P(P), which is shown to
Halt if H(P,P) returns 0.

Thus, by this last definition you just gave, you are admitting that
H(P,P) returning 0 can NEVER be the correct answer for the P built on
that H.

>
>>> In fact, according to you, H returns 0 (non-halting) because it
>>> detects that
>>> otherwise the nested simulations will go on forever. That's correct.
>>> However,
>>> in aborting the simulation, it makes it not true that the nested
>>> simulations
>>> will go on forever. That's the part you've failed to understand.
>>
>
> computation that halts … the Turing machine will halt whenever it enters
> a final state. (Linz:1990:234)

Right, the TURING MACHINE, not some partial simulation of it.

>
> That the correct and complete x86 emulation of the input to H(P,P) or
> Infinite_Loop wold never stop running conclusively proves that these
> inputs specify a non-halting sequence of x86 instructions.

Nope, the correct and complete x86 emulation of the input to H(P,P) is
identical to P(P) (By DEFINITON) and that Halts if H(P,P) returns 0.

Your comments about infinite loop are just herring with red sauce, and
show you are running out of lies to try to justify what you are claiming.

>
> 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]
>
>> He understands that very well.  I can provide all sorts of quotes to
>> attest to that.  His plan is just to find some words that will keep the
>> conversation going.
>>
>
> Since you know that
>
> (1) Deciders in computer science compute the mapping from their inputs
> to an accept or reject state.
>
> (2) P(P) is not an input to H

WRONG. In your case, it actually IS, as the ACTUAL PROGRAM P IS the
input given to H. (since P is just x86 code).

Even with Turing Machines, it is by the means of Representation, or you
are just trying to define that a Halt Decider, OR a UTM is just
impossible by definition.

>
> Why do you persist in the deception that H must compute the halt status
> of P(P) ?  (Can only parrot textbook authors with no actual
> understanding of the underlying relationships involved).
>
>

Becase that is the DEFINITION of a Halt Decider.

All you are showing is that H is some sort of decider, but unless the
mapping matches the actual Halting Function, it can't be a Halt Decider.

You FAIL.

Re: Competent software engineers will agree that H(P,P)==0 is correct [ Jeff is incompetent or dishonest ]

<ypSnK.54925$X_i.51842@fx18.iad>

 copy mid

https://www.novabbs.com/computers/article-flat.php?id=9182&group=comp.ai.philosophy#9182

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic comp.ai.philosophy
Path: i2pn2.org!i2pn.org!aioe.org!feeder1.feed.usenet.farm!feed.usenet.farm!peer01.ams4!peer.am4.highwinds-media.com!peer02.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx18.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: Competent software engineers will agree that H(P,P)==0 is correct
[ Jeff is incompetent or dishonest ]
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,comp.ai.philosophy
References: <N5-dnal-trqPgQP_nZ2dnUU7_83NnZ2d@giganews.com>
<d25678aa-3764-4027-9076-c6b372e290e7n@googlegroups.com>
<875yldljuz.fsf@bsb.me.uk> <xPednXQm6dCN1gP_nZ2dnUU7_83NnZ2d@giganews.com>
<261ca1dc-df02-4fc5-8dee-9abb4c2df3b2n@googlegroups.com>
<rPGdnfeuXbccxAP_nZ2dnUU7_83NnZ2d@giganews.com>
<69069406-766e-4af8-8d49-c5807bdb252bn@googlegroups.com>
<hb2dneeH5er97gP_nZ2dnUU7_83NnZ2d@giganews.com>
<dcf85979-1534-4baf-8483-9c621cc3c445n@googlegroups.com>
<u4adnRq7Cbsq5gP_nZ2dnUU7_8zNnZ2d@giganews.com>
<8424a12e-023b-47bf-a0e5-33b8292a1030n@googlegroups.com>
<xfKdnWrLjLAfEwP_nZ2dnUU7_83NnZ2d@giganews.com>
<adfae03d-9836-432f-a90e-c950f1981ecdn@googlegroups.com>
<87ilpced9o.fsf@bsb.me.uk> <t7o0hm$p8i$1@dont-email.me>
<_KCdnbSMT6E-FQL_nZ2dnUU7_8zNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <_KCdnbSMT6E-FQL_nZ2dnUU7_8zNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 154
Message-ID: <ypSnK.54925$X_i.51842@fx18.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: Tue, 7 Jun 2022 20:52:45 -0400
X-Received-Bytes: 8279
 by: Richard Damon - Wed, 8 Jun 2022 00:52 UTC

On 6/7/22 1:19 PM, olcott wrote:
> On 6/7/2022 12:05 PM, Jeff Barnett wrote:
>> On 6/7/2022 8:53 AM, Ben wrote:
>>> Malcolm McLean <malcolm.arthur.mclean@gmail.com> writes:
>>>
>>>> On Tuesday, 7 June 2022 at 00:32:26 UTC+1, olcott wrote:
>>>
>>>>> This is not typically the case. Every competent reviewer can easily
>>>>> determine that within the hypothesis that:
>>>>> H(P,P) correctly emulates its input with an x86 emulator
>>>>> that the correctly emulated input to H(P,P) would never reach its
>>>>> "ret"
>>>>> instruction.
>>>>> _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]
>>>>>
>>>> You can't tell from that that "ret" is never reached. It depends
>>>> what is in H.
>>>>
>>>> You say that H emulates P(P).
>>>
>>> He is very studiously avoiding saying that!  Obviously that's what
>>> /should/ be simulated, because H(X,Y) should tell us about X(Y), but
>>> then H(P,P) == 0 would be even more obviously wrong.
>>>
>>> That's what the new unexplained mantra is all about.  "The correct
>>> simulation of the input to H(P,P)" can mean whatever PO wants it to
>>> mean.  For that reason I can't see why anyone thinks he's wrong about
>>> it.  It's not the halting problem, but it could only be wrong if he told
>>> us it should do something it isn't doing.
>>
>> It may be the case that I have misjudged the Sire of POOP all this
>> time. A feature of engineering software products today is not
>> implementing or testing to a specification. In fact there usually
>> isn't a spec anywhere
>
> This is a 100% complete specification required to correctly determine
> that the correctly emulated input to H(P,P) never reaches its "ret"
> instruction, thus never halts.

Nope, FAIL. In fact, the fact that you claim that H(P,P) returns 0
correct, means you have stipulated that H(P,P) returns 0, (you can't
stipulate being correct) and it can be shown that IF H(P,P) returns 0,
that in fact, the correct emulation of the input to H(P,P), which IS the
program P(P) does Halt.

Any claim otherwise is just a lie.

>
> That you imply that it is not a complete specification proves that you
> are incompetent or dishonest or both.
>

Because it isn't complete, because it seems to be using terms in an
ambigous manner.

To claim the specification is complete, without any extra clarification
of defintions, means that you are just accepting the standard definitions.

That means that the correct simulation of the input to a Halt Decider is
EXACTLY equivalent to running the program specifed by that input, in
otehr words that H(P,P) return 0 is ONLY correct if P(P) never halt, for
tghe P built on that H.

THis is proved to be a false statement.

> void P(u32 x)
> {
>   if (H(x, x))
>     HERE: goto HERE;
>   return;
> }
>
> int main()
> {
>   Output("Input_Halts = ", H((u32)P, (u32)P));
> }
>
> _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 can know with complete
> certainty that the emulated P never reaches its final “ret” instruction,
> thus never halts.

Maybe it is obvious to you, but to smart people it is obvious that this
ONLY happens for the case where H(P,P) does actually correctly emulated
its input, which means it NEVER aborts that emulation, and thus never
returns the answer, so it does NOT correctly return 0.

It is also clear that the 7th instruction does NOT "repeat this process"
unless H just UNCONDITIONALLY simulates its input (which does make it a
correct simulator, but not a decider). The problem is that what you
ACTUALLY seem to be describing is that the call to H starts a
CONDITIONAL simulation that will be stopped when H thinks the input is
non-halting. This conditionalaity allows it to return an answer, but
also means that the assumption your logic makes that it creates an
infinite process can be incorrect.

Incorrect assumptions lead to UNSOUND logic, so you FAIL.

>
>
>> in sight. That's how M$ as well as other software vendors avoid fixing
>> obvious mistakes. Since the spec doesn't exist, how can you know if
>> it's an error. I'm guessing that this style of development contributed
>> to PO not being able to hold a job (and all the projects we know about
>> were failures). It's the modern way and PO was there first. Let's all
>> raise our cups and shout hooray for Pete!
>>
>>>> In fact, according to you, H returns 0 (non-halting) because it
>>>> detects that
>>>> otherwise the nested simulations will go on forever. That's correct.
>>>> However,
>>>> in aborting the simulation, it makes it not true that the nested
>>>> simulations
>>>> will go on forever. That's the part you've failed to understand.
>>>
>>> He understands that very well.  I can provide all sorts of quotes to
>>> attest to that.  His plan is just to find some words that will keep the
>>> conversation going.--
>> Jeff Barnett
>
>

1
server_pubkey.txt

rocksolid light 0.9.7
clearnet tor