Rocksolid Light

Welcome to novaBBS (click a section below)

mail  files  register  newsreader  groups  login

Message-ID:  

You are in a maze of little twisting passages, all different.


devel / comp.theory / Re: olcott, it's really simple [ succinct summation ]

SubjectAuthor
* olcott, it's really simpleMr Flibble
+* olcott, it's really simpleolcott
|+* olcott, it's really simpleMr Flibble
||`* olcott, it's really simpleolcott
|| +* olcott, it's really simpleMr Flibble
|| |`* olcott, it's really simpleolcott
|| | `* olcott, it's really simpleMr Flibble
|| |  `* olcott, it's really simpleolcott
|| |   `* olcott, it's really simpleMr Flibble
|| |    `* olcott, it's really simpleolcott
|| |     `* olcott, it's really simpleMr Flibble
|| |      `* olcott, it's really simpleolcott
|| |       `* olcott, it's really simpleMr Flibble
|| |        `- olcott, it's really simpleolcott
|| `- olcott, it's really simpleRichard Damon
|`- olcott, it's really simpleRichard Damon
`* olcott, it's really simpleBen Bacarisse
 +* olcott, it's really simpleolcott
 |`- olcott, it's really simpleRichard Damon
 +- olcott, it's really simple (tiny typo)olcott
 `* olcott, it's really simple [ succinct summation ]olcott
  `- olcott, it's really simple [ succinct summation ]Richard Damon

1
olcott, it's really simple

<20220616181727.000072da@reddwarf.jmc>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!aioe.org!news.uzoreto.com!news-out.netnews.com!news.alt.net!fdc2.netnews.com!peer03.ams1!peer.ams1.xlned.com!news.xlned.com!peer02.ams4!peer.am4.highwinds-media.com!news.highwinds-media.com!fx01.ams4.POSTED!not-for-mail
From: flib...@reddwarf.jmc (Mr Flibble)
Newsgroups: comp.theory
Subject: olcott, it's really simple
Message-ID: <20220616181727.000072da@reddwarf.jmc>
Organization: Jupiter Mining Corp
X-Newsreader: Claws Mail 3.17.8 (GTK+ 2.24.33; x86_64-w64-mingw32)
MIME-Version: 1.0
Content-Type: text/plain; charset=US-ASCII
Content-Transfer-Encoding: 7bit
Lines: 25
X-Complaints-To: abuse@eweka.nl
NNTP-Posting-Date: Thu, 16 Jun 2022 17:17:26 UTC
Date: Thu, 16 Jun 2022 18:17:27 +0100
X-Received-Bytes: 1131
 by: Mr Flibble - Thu, 16 Jun 2022 17:17 UTC

Given olcott's code,

#include <stdint.h>
typedef void (*ptr)();

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

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

and olcott's assertion that H is a pure function and H(P,P) == 0,
then, P should halt as H should also return 0 to P (pure functions
ALWAYS return the same result for the same arguments with no side
effects). P doesn't halt so H is erroneous; olcott, it's really that
simple.

/Flibble

Re: olcott, it's really simple

<_qudne-jFfaZ9jb_nZ2dnUU7_83NnZ2d@giganews.com>

 copy mid

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

 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: Thu, 16 Jun 2022 12:40:20 -0500
Date: Thu, 16 Jun 2022 12:40:19 -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: olcott, it's really simple
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <20220616181727.000072da@reddwarf.jmc>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <20220616181727.000072da@reddwarf.jmc>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <_qudne-jFfaZ9jb_nZ2dnUU7_83NnZ2d@giganews.com>
Lines: 63
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-z2chtBUepgO80VeEPyFXGr0GxoAnycH1OTQ6P2H1YO4GuPcRJ6C06lk/VcN+LJKdsswnYBCRF/YvnyN!Tsqx6JGMVGv0GkDO1gJNX0AhQ66GVc0zxbsjE2OmqDRsb5z4wFVOgtD+1PbO35vvuY0VP2mxXdDh
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: 3085
 by: olcott - Thu, 16 Jun 2022 17:40 UTC

On 6/16/2022 12:17 PM, Mr Flibble wrote:
> Given olcott's code,
>
> #include <stdint.h>
> typedef void (*ptr)();
>
> void P(ptr x)
> {
> if (H(x, x))
> HERE: goto HERE;
> return;
> }
>
> int main()
> {
> Output("Input_Halts = ", H(P, P));
> }
>
> and olcott's assertion that H is a pure function and H(P,P) == 0,
> then, P should halt as H should also return 0 to P (pure functions
> ALWAYS return the same result for the same arguments with no side
> effects). P doesn't halt so H is erroneous; olcott, it's really that
> simple.
>
> /Flibble
>

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

Any competent software engineer will see that the correct and complete
x86 emulation of the input to H(P,P) will never reach its "ret"
instruction (the final state of P).

When H(P,P) aborts the x86 emulation of its input on this basis and
returns 0 to main competent software engineers will know that this does
not cause P to reach its "ret" instruction.

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

Linz, Peter 1990. An Introduction to Formal Languages and Automata.
Lexington/Toronto: D. C. Heath and Company. (317-320)

--
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: olcott, it's really simple

<20220616190213.000076a0@reddwarf.jmc>

 copy mid

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

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Path: i2pn2.org!i2pn.org!aioe.org!news.uzoreto.com!news-out.netnews.com!news.alt.net!fdc2.netnews.com!peer01.ams1!peer.ams1.xlned.com!news.xlned.com!peer02.ams4!peer.am4.highwinds-media.com!news.highwinds-media.com!fx01.ams4.POSTED!not-for-mail
From: flib...@reddwarf.jmc (Mr Flibble)
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
Subject: Re: olcott, it's really simple
Message-ID: <20220616190213.000076a0@reddwarf.jmc>
References: <20220616181727.000072da@reddwarf.jmc>
<_qudne-jFfaZ9jb_nZ2dnUU7_83NnZ2d@giganews.com>
Organization: Jupiter Mining Corp
X-Newsreader: Claws Mail 3.17.8 (GTK+ 2.24.33; x86_64-w64-mingw32)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: quoted-printable
Lines: 65
X-Complaints-To: abuse@eweka.nl
NNTP-Posting-Date: Thu, 16 Jun 2022 18:02:13 UTC
Date: Thu, 16 Jun 2022 19:02:13 +0100
X-Received-Bytes: 2849
 by: Mr Flibble - Thu, 16 Jun 2022 18:02 UTC

On Thu, 16 Jun 2022 12:40:19 -0500
olcott <NoOne@NoWhere.com> wrote:

> On 6/16/2022 12:17 PM, Mr Flibble wrote:
> > Given olcott's code,
> >
> > #include <stdint.h>
> > typedef void (*ptr)();
> >
> > void P(ptr x)
> > {
> > if (H(x, x))
> > HERE: goto HERE;
> > return;
> > }
> >
> > int main()
> > {
> > Output("Input_Halts = ", H(P, P));
> > }
> >
> > and olcott's assertion that H is a pure function and H(P,P) == 0,
> > then, P should halt as H should also return 0 to P (pure functions
> > ALWAYS return the same result for the same arguments with no side
> > effects). P doesn't halt so H is erroneous; olcott, it's really that
> > simple.
> >
> > /Flibble
> >
>
> _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]
>
> Any competent software engineer will see that the correct and
> complete x86 emulation of the input to H(P,P) will never reach its
> "ret" instruction (the final state of P).
>
> When H(P,P) aborts the x86 emulation of its input on this basis and
> returns 0 to main competent software engineers will know that this
> does not cause P to reach its "ret" instruction.
>
> computation that halts … the Turing machine will halt whenever it
> enters a final state. (Linz:1990:234)
>
> Linz, Peter 1990. An Introduction to Formal Languages and Automata.
> Lexington/Toronto: D. C. Heath and Company. (317-320)
It would be better if you actually addressed the content of people's
posts. Your H is erroneous.

/Flibble

Re: olcott, it's really simple

<xf-dnSnE0tX_7Db_nZ2dnUU7_83NnZ2d@giganews.com>

 copy mid

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

 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, 16 Jun 2022 13:07:30 -0500
Date: Thu, 16 Jun 2022 13:07:29 -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: olcott, it's really simple
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <20220616181727.000072da@reddwarf.jmc>
<_qudne-jFfaZ9jb_nZ2dnUU7_83NnZ2d@giganews.com>
<20220616190213.000076a0@reddwarf.jmc>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <20220616190213.000076a0@reddwarf.jmc>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Message-ID: <xf-dnSnE0tX_7Db_nZ2dnUU7_83NnZ2d@giganews.com>
Lines: 72
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-YwVdV0EFDLdK1qnxt2tvvKg6fwY9BD3CeOJqpVfXnPeIoWI2VL6tx934Q22JptWQTghNeFZftJPujrN!a3/j6qZ9d7D4GmZxDP8aWcPosnhzt9AwjarJ9/8eJRAt8m/mtDdOjuufXYFIQrpcWJNN3g4GWEjv
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: 3601
 by: olcott - Thu, 16 Jun 2022 18:07 UTC

On 6/16/2022 1:02 PM, Mr Flibble wrote:
> On Thu, 16 Jun 2022 12:40:19 -0500
> olcott <NoOne@NoWhere.com> wrote:
>
> It would be better if you actually addressed the content of people's
> posts. Your H is erroneous.
>
> /Flibble
>

Competent software engineers will agree that
the following proves that H(P,P)==0 is correct.

#include <stdint.h>
typedef void (*ptr)();

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

int main()
{ Output("Input_Halts = ", H(P, 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]

(1) It is an easily verified fact that when we assume that H is only an
x86 emulator that the correctly emulated P never reaches its "ret"
instruction it remains stuck in repeated cycles of emulation.

(2) It is an easily verified fact that if H has been adapted to
correctly detect (in a finite number of steps) that the correct and
complete x86 emulation of its input would never each its "ret"
instruction that H could abort its emulation and return 0 to report this.

(3) When the halt status criteria is defined as correctly determining
whether or not an x86 emulated input would ever reach its "ret"
instruction then it becomes an easily verified fact H(P,P) could
correctly reject its input as non-halting.

Correct deductive inference proves that all of these things are true
without any need what-so-ever to see either the source-code or the
execution trace of H.

The one thing that is not proved is whether or not an actual encoded
H(P,P) does indeed correctly determine that its input would never reach
its "ret" instruction as a pure function of its inputs.

--
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: olcott, it's really simple

<20220616191138.0000441c@reddwarf.jmc>

 copy mid

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

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Path: i2pn2.org!i2pn.org!weretis.net!feeder8.news.weretis.net!feeder1.feed.usenet.farm!feed.usenet.farm!peer01.ams4!peer.am4.highwinds-media.com!news.highwinds-media.com!fx01.ams4.POSTED!not-for-mail
From: flib...@reddwarf.jmc (Mr Flibble)
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
Subject: Re: olcott, it's really simple
Message-ID: <20220616191138.0000441c@reddwarf.jmc>
References: <20220616181727.000072da@reddwarf.jmc>
<_qudne-jFfaZ9jb_nZ2dnUU7_83NnZ2d@giganews.com>
<20220616190213.000076a0@reddwarf.jmc>
<xf-dnSnE0tX_7Db_nZ2dnUU7_83NnZ2d@giganews.com>
Organization: Jupiter Mining Corp
X-Newsreader: Claws Mail 3.17.8 (GTK+ 2.24.33; x86_64-w64-mingw32)
MIME-Version: 1.0
Content-Type: text/plain; charset=US-ASCII
Content-Transfer-Encoding: 7bit
Lines: 74
X-Complaints-To: abuse@eweka.nl
NNTP-Posting-Date: Thu, 16 Jun 2022 18:11:38 UTC
Date: Thu, 16 Jun 2022 19:11:38 +0100
X-Received-Bytes: 3191
 by: Mr Flibble - Thu, 16 Jun 2022 18:11 UTC

On Thu, 16 Jun 2022 13:07:29 -0500
olcott <NoOne@NoWhere.com> wrote:

> On 6/16/2022 1:02 PM, Mr Flibble wrote:
> > On Thu, 16 Jun 2022 12:40:19 -0500
> > olcott <NoOne@NoWhere.com> wrote:
> >
> > It would be better if you actually addressed the content of people's
> > posts. Your H is erroneous.
> >
> > /Flibble
> >
>
> Competent software engineers will agree that
> the following proves that H(P,P)==0 is correct.
>
> #include <stdint.h>
> typedef void (*ptr)();
>
> void P(ptr x)
> {
> if (H(x, x))
> HERE: goto HERE;
> return;
> }
>
> int main()
> {
> Output("Input_Halts = ", H(P, 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]
>
> (1) It is an easily verified fact that when we assume that H is only
> an x86 emulator that the correctly emulated P never reaches its "ret"
> instruction it remains stuck in repeated cycles of emulation.
>
> (2) It is an easily verified fact that if H has been adapted to
> correctly detect (in a finite number of steps) that the correct and
> complete x86 emulation of its input would never each its "ret"
> instruction that H could abort its emulation and return 0 to report
> this.
>
> (3) When the halt status criteria is defined as correctly determining
> whether or not an x86 emulated input would ever reach its "ret"
> instruction then it becomes an easily verified fact H(P,P) could
> correctly reject its input as non-halting.
>
> Correct deductive inference proves that all of these things are true
> without any need what-so-ever to see either the source-code or the
> execution trace of H.
>
> The one thing that is not proved is whether or not an actual encoded
> H(P,P) does indeed correctly determine that its input would never
> reach its "ret" instruction as a pure function of its inputs.
Nope. If H(P,P) == 0 then P should halt.

/Flibble

Re: olcott, it's really simple

<-qadnWtnS6In6Tb_nZ2dnUU7_83NnZ2d@giganews.com>

 copy mid

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

 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: Thu, 16 Jun 2022 13:21:46 -0500
Date: Thu, 16 Jun 2022 13:21:45 -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: olcott, it's really simple
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <20220616181727.000072da@reddwarf.jmc>
<_qudne-jFfaZ9jb_nZ2dnUU7_83NnZ2d@giganews.com>
<20220616190213.000076a0@reddwarf.jmc>
<xf-dnSnE0tX_7Db_nZ2dnUU7_83NnZ2d@giganews.com>
<20220616191138.0000441c@reddwarf.jmc>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <20220616191138.0000441c@reddwarf.jmc>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Message-ID: <-qadnWtnS6In6Tb_nZ2dnUU7_83NnZ2d@giganews.com>
Lines: 92
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-XYb9cTFD25bukuZUwQQe2j3jpgyt3kETY1fvxumJvbjXeIHhEL0NLwlw7tN+lazEk+QzGlsyPvFGeMF!VCNeNbkSxKtLnEWGxyFC0Mk3FM9K9tawbiZ0vT0wUTuVn06AJlzR/H3JhHGi2qewzk6iLwu9xGEL
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: 4484
 by: olcott - Thu, 16 Jun 2022 18:21 UTC

On 6/16/2022 1:11 PM, Mr Flibble wrote:
> On Thu, 16 Jun 2022 13:07:29 -0500
> olcott <NoOne@NoWhere.com> wrote:
>
>> On 6/16/2022 1:02 PM, Mr Flibble wrote:
>>> On Thu, 16 Jun 2022 12:40:19 -0500
>>> olcott <NoOne@NoWhere.com> wrote:
>>>
>>> It would be better if you actually addressed the content of people's
>>> posts. Your H is erroneous.
>>>
>>> /Flibble
>>>
>>
>> Competent software engineers will agree that
>> the following proves that H(P,P)==0 is correct.
>>
>> #include <stdint.h>
>> typedef void (*ptr)();
>>
>> void P(ptr x)
>> {
>> if (H(x, x))
>> HERE: goto HERE;
>> return;
>> }
>>
>> int main()
>> {
>> Output("Input_Halts = ", H(P, 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]
>>
>> (1) It is an easily verified fact that when we assume that H is only
>> an x86 emulator that the correctly emulated P never reaches its "ret"
>> instruction it remains stuck in repeated cycles of emulation.
>>
>> (2) It is an easily verified fact that if H has been adapted to
>> correctly detect (in a finite number of steps) that the correct and
>> complete x86 emulation of its input would never each its "ret"
>> instruction that H could abort its emulation and return 0 to report
>> this.
>>
>> (3) When the halt status criteria is defined as correctly determining
>> whether or not an x86 emulated input would ever reach its "ret"
>> instruction then it becomes an easily verified fact H(P,P) could
>> correctly reject its input as non-halting.
>>
>> Correct deductive inference proves that all of these things are true
>> without any need what-so-ever to see either the source-code or the
>> execution trace of H.
>>
>> The one thing that is not proved is whether or not an actual encoded
>> H(P,P) does indeed correctly determine that its input would never
>> reach its "ret" instruction as a pure function of its inputs.
>
> Nope. If H(P,P) == 0 then P should halt.
>
> /Flibble
>

Competent software engineers would understand that H(P,P)==0 is correct
and be unable to find any software engineering mistakes.

It is an easily verified fact that the correct and complete x86
emulation of the input to H(P,P) by H cannot possibly reach its "ret"
instruction.

Since this is the criterion measure for returning 0 then H(P,P)==0 has
been proven to be correct on the basis of software engineering.

--
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: olcott, it's really simple

<20220616192237.000071c0@reddwarf.jmc>

 copy mid

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

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Path: i2pn2.org!i2pn.org!aioe.org!feeder1.feed.usenet.farm!feed.usenet.farm!peer03.ams4!peer.am4.highwinds-media.com!news.highwinds-media.com!fx01.ams4.POSTED!not-for-mail
From: flib...@reddwarf.jmc (Mr Flibble)
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
Subject: Re: olcott, it's really simple
Message-ID: <20220616192237.000071c0@reddwarf.jmc>
References: <20220616181727.000072da@reddwarf.jmc>
<_qudne-jFfaZ9jb_nZ2dnUU7_83NnZ2d@giganews.com>
<20220616190213.000076a0@reddwarf.jmc>
<xf-dnSnE0tX_7Db_nZ2dnUU7_83NnZ2d@giganews.com>
<20220616191138.0000441c@reddwarf.jmc>
<-qadnWtnS6In6Tb_nZ2dnUU7_83NnZ2d@giganews.com>
Organization: Jupiter Mining Corp
X-Newsreader: Claws Mail 3.17.8 (GTK+ 2.24.33; x86_64-w64-mingw32)
MIME-Version: 1.0
Content-Type: text/plain; charset=US-ASCII
Content-Transfer-Encoding: 7bit
Lines: 95
X-Complaints-To: abuse@eweka.nl
NNTP-Posting-Date: Thu, 16 Jun 2022 18:22:37 UTC
Date: Thu, 16 Jun 2022 19:22:37 +0100
X-Received-Bytes: 4131
 by: Mr Flibble - Thu, 16 Jun 2022 18:22 UTC

On Thu, 16 Jun 2022 13:21:45 -0500
olcott <NoOne@NoWhere.com> wrote:

> On 6/16/2022 1:11 PM, Mr Flibble wrote:
> > On Thu, 16 Jun 2022 13:07:29 -0500
> > olcott <NoOne@NoWhere.com> wrote:
> >
> >> On 6/16/2022 1:02 PM, Mr Flibble wrote:
> >>> On Thu, 16 Jun 2022 12:40:19 -0500
> >>> olcott <NoOne@NoWhere.com> wrote:
> >>>
> >>> It would be better if you actually addressed the content of
> >>> people's posts. Your H is erroneous.
> >>>
> >>> /Flibble
> >>>
> >>
> >> Competent software engineers will agree that
> >> the following proves that H(P,P)==0 is correct.
> >>
> >> #include <stdint.h>
> >> typedef void (*ptr)();
> >>
> >> void P(ptr x)
> >> {
> >> if (H(x, x))
> >> HERE: goto HERE;
> >> return;
> >> }
> >>
> >> int main()
> >> {
> >> Output("Input_Halts = ", H(P, 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]
> >>
> >> (1) It is an easily verified fact that when we assume that H is
> >> only an x86 emulator that the correctly emulated P never reaches
> >> its "ret" instruction it remains stuck in repeated cycles of
> >> emulation.
> >>
> >> (2) It is an easily verified fact that if H has been adapted to
> >> correctly detect (in a finite number of steps) that the correct and
> >> complete x86 emulation of its input would never each its "ret"
> >> instruction that H could abort its emulation and return 0 to report
> >> this.
> >>
> >> (3) When the halt status criteria is defined as correctly
> >> determining whether or not an x86 emulated input would ever reach
> >> its "ret" instruction then it becomes an easily verified fact
> >> H(P,P) could correctly reject its input as non-halting.
> >>
> >> Correct deductive inference proves that all of these things are
> >> true without any need what-so-ever to see either the source-code
> >> or the execution trace of H.
> >>
> >> The one thing that is not proved is whether or not an actual
> >> encoded H(P,P) does indeed correctly determine that its input
> >> would never reach its "ret" instruction as a pure function of its
> >> inputs.
> >
> > Nope. If H(P,P) == 0 then P should halt.
> >
> > /Flibble
> >
>
> Competent software engineers would understand that H(P,P)==0 is
> correct and be unable to find any software engineering mistakes.
>
> It is an easily verified fact that the correct and complete x86
> emulation of the input to H(P,P) by H cannot possibly reach its "ret"
> instruction.
>
> Since this is the criterion measure for returning 0 then H(P,P)==0
> has been proven to be correct on the basis of software engineering.
Nope. If H(P,P) == 0 then P should halt.

/Flibble

Re: olcott, it's really simple

<5rednfSRKMZP6Db_nZ2dnUU7_8zNnZ2d@giganews.com>

 copy mid

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

 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: Thu, 16 Jun 2022 13:26:26 -0500
Date: Thu, 16 Jun 2022 13:26:25 -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: olcott, it's really simple
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <20220616181727.000072da@reddwarf.jmc>
<_qudne-jFfaZ9jb_nZ2dnUU7_83NnZ2d@giganews.com>
<20220616190213.000076a0@reddwarf.jmc>
<xf-dnSnE0tX_7Db_nZ2dnUU7_83NnZ2d@giganews.com>
<20220616191138.0000441c@reddwarf.jmc>
<-qadnWtnS6In6Tb_nZ2dnUU7_83NnZ2d@giganews.com>
<20220616192237.000071c0@reddwarf.jmc>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <20220616192237.000071c0@reddwarf.jmc>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Message-ID: <5rednfSRKMZP6Db_nZ2dnUU7_8zNnZ2d@giganews.com>
Lines: 107
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-gsuJ2+AD8OyVLbdj8ECQsP2hFdZk58ct3bhchUZD/Dmvpud/VZLM03ow5M5519UIgyq8i9Xffs/H808!OCnD1d9aakAy0AkpZBMWDrAU17h0EJFQBkyE4LHrr/TXgQXWbeAOzicGbfp412W44VCqlxOZP5+B
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: 5125
 by: olcott - Thu, 16 Jun 2022 18:26 UTC

On 6/16/2022 1:22 PM, Mr Flibble wrote:
> On Thu, 16 Jun 2022 13:21:45 -0500
> olcott <NoOne@NoWhere.com> wrote:
>
>> On 6/16/2022 1:11 PM, Mr Flibble wrote:
>>> On Thu, 16 Jun 2022 13:07:29 -0500
>>> olcott <NoOne@NoWhere.com> wrote:
>>>
>>>> On 6/16/2022 1:02 PM, Mr Flibble wrote:
>>>>> On Thu, 16 Jun 2022 12:40:19 -0500
>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>
>>>>> It would be better if you actually addressed the content of
>>>>> people's posts. Your H is erroneous.
>>>>>
>>>>> /Flibble
>>>>>
>>>>
>>>> Competent software engineers will agree that
>>>> the following proves that H(P,P)==0 is correct.
>>>>
>>>> #include <stdint.h>
>>>> typedef void (*ptr)();
>>>>
>>>> void P(ptr x)
>>>> {
>>>> if (H(x, x))
>>>> HERE: goto HERE;
>>>> return;
>>>> }
>>>>
>>>> int main()
>>>> {
>>>> Output("Input_Halts = ", H(P, 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]
>>>>
>>>> (1) It is an easily verified fact that when we assume that H is
>>>> only an x86 emulator that the correctly emulated P never reaches
>>>> its "ret" instruction it remains stuck in repeated cycles of
>>>> emulation.
>>>>
>>>> (2) It is an easily verified fact that if H has been adapted to
>>>> correctly detect (in a finite number of steps) that the correct and
>>>> complete x86 emulation of its input would never each its "ret"
>>>> instruction that H could abort its emulation and return 0 to report
>>>> this.
>>>>
>>>> (3) When the halt status criteria is defined as correctly
>>>> determining whether or not an x86 emulated input would ever reach
>>>> its "ret" instruction then it becomes an easily verified fact
>>>> H(P,P) could correctly reject its input as non-halting.
>>>>
>>>> Correct deductive inference proves that all of these things are
>>>> true without any need what-so-ever to see either the source-code
>>>> or the execution trace of H.
>>>>
>>>> The one thing that is not proved is whether or not an actual
>>>> encoded H(P,P) does indeed correctly determine that its input
>>>> would never reach its "ret" instruction as a pure function of its
>>>> inputs.
>>>
>>> Nope. If H(P,P) == 0 then P should halt.
>>>
>>> /Flibble
>>>
>>
>> Competent software engineers would understand that H(P,P)==0 is
>> correct and be unable to find any software engineering mistakes.
>>
>> It is an easily verified fact that the correct and complete x86
>> emulation of the input to H(P,P) by H cannot possibly reach its "ret"
>> instruction.
>>
>> Since this is the criterion measure for returning 0 then H(P,P)==0
>> has been proven to be correct on the basis of software engineering.
>
> Nope. If H(P,P) == 0 then P should halt.
>
> /Flibble
>

People that are not competent software engineers and people that prefer
rebuttal to truth will avoid addressing the above irrefutably correct
reasoning.

--
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: olcott, it's really simple

<20220616193015.0000737c@reddwarf.jmc>

 copy mid

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

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Path: i2pn2.org!i2pn.org!weretis.net!feeder8.news.weretis.net!feeder1.feed.usenet.farm!feed.usenet.farm!peer01.ams4!peer.am4.highwinds-media.com!news.highwinds-media.com!fx01.ams4.POSTED!not-for-mail
From: flib...@reddwarf.jmc (Mr Flibble)
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
Subject: Re: olcott, it's really simple
Message-ID: <20220616193015.0000737c@reddwarf.jmc>
References: <20220616181727.000072da@reddwarf.jmc>
<_qudne-jFfaZ9jb_nZ2dnUU7_83NnZ2d@giganews.com>
<20220616190213.000076a0@reddwarf.jmc>
<xf-dnSnE0tX_7Db_nZ2dnUU7_83NnZ2d@giganews.com>
<20220616191138.0000441c@reddwarf.jmc>
<-qadnWtnS6In6Tb_nZ2dnUU7_83NnZ2d@giganews.com>
<20220616192237.000071c0@reddwarf.jmc>
<5rednfSRKMZP6Db_nZ2dnUU7_8zNnZ2d@giganews.com>
Organization: Jupiter Mining Corp
X-Newsreader: Claws Mail 3.17.8 (GTK+ 2.24.33; x86_64-w64-mingw32)
MIME-Version: 1.0
Content-Type: text/plain; charset=US-ASCII
Content-Transfer-Encoding: 7bit
Lines: 109
X-Complaints-To: abuse@eweka.nl
NNTP-Posting-Date: Thu, 16 Jun 2022 18:30:15 UTC
Date: Thu, 16 Jun 2022 19:30:15 +0100
X-Received-Bytes: 4827
 by: Mr Flibble - Thu, 16 Jun 2022 18:30 UTC

On Thu, 16 Jun 2022 13:26:25 -0500
olcott <NoOne@NoWhere.com> wrote:

> On 6/16/2022 1:22 PM, Mr Flibble wrote:
> > On Thu, 16 Jun 2022 13:21:45 -0500
> > olcott <NoOne@NoWhere.com> wrote:
> >
> >> On 6/16/2022 1:11 PM, Mr Flibble wrote:
> >>> On Thu, 16 Jun 2022 13:07:29 -0500
> >>> olcott <NoOne@NoWhere.com> wrote:
> >>>
> >>>> On 6/16/2022 1:02 PM, Mr Flibble wrote:
> >>>>> On Thu, 16 Jun 2022 12:40:19 -0500
> >>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>
> >>>>> It would be better if you actually addressed the content of
> >>>>> people's posts. Your H is erroneous.
> >>>>>
> >>>>> /Flibble
> >>>>>
> >>>>
> >>>> Competent software engineers will agree that
> >>>> the following proves that H(P,P)==0 is correct.
> >>>>
> >>>> #include <stdint.h>
> >>>> typedef void (*ptr)();
> >>>>
> >>>> void P(ptr x)
> >>>> {
> >>>> if (H(x, x))
> >>>> HERE: goto HERE;
> >>>> return;
> >>>> }
> >>>>
> >>>> int main()
> >>>> {
> >>>> Output("Input_Halts = ", H(P, 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]
> >>>>
> >>>> (1) It is an easily verified fact that when we assume that H is
> >>>> only an x86 emulator that the correctly emulated P never reaches
> >>>> its "ret" instruction it remains stuck in repeated cycles of
> >>>> emulation.
> >>>>
> >>>> (2) It is an easily verified fact that if H has been adapted to
> >>>> correctly detect (in a finite number of steps) that the correct
> >>>> and complete x86 emulation of its input would never each its
> >>>> "ret" instruction that H could abort its emulation and return 0
> >>>> to report this.
> >>>>
> >>>> (3) When the halt status criteria is defined as correctly
> >>>> determining whether or not an x86 emulated input would ever reach
> >>>> its "ret" instruction then it becomes an easily verified fact
> >>>> H(P,P) could correctly reject its input as non-halting.
> >>>>
> >>>> Correct deductive inference proves that all of these things are
> >>>> true without any need what-so-ever to see either the source-code
> >>>> or the execution trace of H.
> >>>>
> >>>> The one thing that is not proved is whether or not an actual
> >>>> encoded H(P,P) does indeed correctly determine that its input
> >>>> would never reach its "ret" instruction as a pure function of its
> >>>> inputs.
> >>>
> >>> Nope. If H(P,P) == 0 then P should halt.
> >>>
> >>> /Flibble
> >>>
> >>
> >> Competent software engineers would understand that H(P,P)==0 is
> >> correct and be unable to find any software engineering mistakes.
> >>
> >> It is an easily verified fact that the correct and complete x86
> >> emulation of the input to H(P,P) by H cannot possibly reach its
> >> "ret" instruction.
> >>
> >> Since this is the criterion measure for returning 0 then H(P,P)==0
> >> has been proven to be correct on the basis of software
> >> engineering.
> >
> > Nope. If H(P,P) == 0 then P should halt.
> >
> > /Flibble
> >
>
> People that are not competent software engineers and people that
> prefer rebuttal to truth will avoid addressing the above irrefutably
> correct reasoning.
Your reasoning is incorrect. If H(P,P) == 0 then P should halt.

/Flibble

Re: olcott, it's really simple

<5rednfeRKMaD6jb_nZ2dnUU7_8xh4p2d@giganews.com>

 copy mid

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

 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: Thu, 16 Jun 2022 13:31:58 -0500
Date: Thu, 16 Jun 2022 13:31:57 -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: olcott, it's really simple
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <20220616181727.000072da@reddwarf.jmc>
<_qudne-jFfaZ9jb_nZ2dnUU7_83NnZ2d@giganews.com>
<20220616190213.000076a0@reddwarf.jmc>
<xf-dnSnE0tX_7Db_nZ2dnUU7_83NnZ2d@giganews.com>
<20220616191138.0000441c@reddwarf.jmc>
<-qadnWtnS6In6Tb_nZ2dnUU7_83NnZ2d@giganews.com>
<20220616192237.000071c0@reddwarf.jmc>
<5rednfSRKMZP6Db_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220616193015.0000737c@reddwarf.jmc>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <20220616193015.0000737c@reddwarf.jmc>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Message-ID: <5rednfeRKMaD6jb_nZ2dnUU7_8xh4p2d@giganews.com>
Lines: 124
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-Oj4de02ySbULI9KUuyat6e3925EG2oZhjWOf/8zK/cmziOkhkhrUACAaQYsi5JRvvGXV+Bukd0PAJSq!VC4GU1bq4jX4uV8mqKvIW9JJhLUjO43WjUzzkFsp7zeCSBM2R+Jw3CqW/a4Axp1eaYJ5x0Ir959U
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: 5848
 by: olcott - Thu, 16 Jun 2022 18:31 UTC

On 6/16/2022 1:30 PM, Mr Flibble wrote:
> On Thu, 16 Jun 2022 13:26:25 -0500
> olcott <NoOne@NoWhere.com> wrote:
>
>> On 6/16/2022 1:22 PM, Mr Flibble wrote:
>>> On Thu, 16 Jun 2022 13:21:45 -0500
>>> olcott <NoOne@NoWhere.com> wrote:
>>>
>>>> On 6/16/2022 1:11 PM, Mr Flibble wrote:
>>>>> On Thu, 16 Jun 2022 13:07:29 -0500
>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>
>>>>>> On 6/16/2022 1:02 PM, Mr Flibble wrote:
>>>>>>> On Thu, 16 Jun 2022 12:40:19 -0500
>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>
>>>>>>> It would be better if you actually addressed the content of
>>>>>>> people's posts. Your H is erroneous.
>>>>>>>
>>>>>>> /Flibble
>>>>>>>
>>>>>>
>>>>>> Competent software engineers will agree that
>>>>>> the following proves that H(P,P)==0 is correct.
>>>>>>
>>>>>> #include <stdint.h>
>>>>>> typedef void (*ptr)();
>>>>>>
>>>>>> void P(ptr x)
>>>>>> {
>>>>>> if (H(x, x))
>>>>>> HERE: goto HERE;
>>>>>> return;
>>>>>> }
>>>>>>
>>>>>> int main()
>>>>>> {
>>>>>> Output("Input_Halts = ", H(P, 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]
>>>>>>
>>>>>> (1) It is an easily verified fact that when we assume that H is
>>>>>> only an x86 emulator that the correctly emulated P never reaches
>>>>>> its "ret" instruction it remains stuck in repeated cycles of
>>>>>> emulation.
>>>>>>
>>>>>> (2) It is an easily verified fact that if H has been adapted to
>>>>>> correctly detect (in a finite number of steps) that the correct
>>>>>> and complete x86 emulation of its input would never each its
>>>>>> "ret" instruction that H could abort its emulation and return 0
>>>>>> to report this.
>>>>>>
>>>>>> (3) When the halt status criteria is defined as correctly
>>>>>> determining whether or not an x86 emulated input would ever reach
>>>>>> its "ret" instruction then it becomes an easily verified fact
>>>>>> H(P,P) could correctly reject its input as non-halting.
>>>>>>
>>>>>> Correct deductive inference proves that all of these things are
>>>>>> true without any need what-so-ever to see either the source-code
>>>>>> or the execution trace of H.
>>>>>>
>>>>>> The one thing that is not proved is whether or not an actual
>>>>>> encoded H(P,P) does indeed correctly determine that its input
>>>>>> would never reach its "ret" instruction as a pure function of its
>>>>>> inputs.
>>>>>
>>>>> Nope. If H(P,P) == 0 then P should halt.
>>>>>
>>>>> /Flibble
>>>>>
>>>>
>>>> Competent software engineers would understand that H(P,P)==0 is
>>>> correct and be unable to find any software engineering mistakes.
>>>>
>>>> It is an easily verified fact that the correct and complete x86
>>>> emulation of the input to H(P,P) by H cannot possibly reach its
>>>> "ret" instruction.
>>>>
>>>> Since this is the criterion measure for returning 0 then H(P,P)==0
>>>> has been proven to be correct on the basis of software
>>>> engineering.
>>>
>>> Nope. If H(P,P) == 0 then P should halt.
>>>
>>> /Flibble
>>>
>>
>> People that are not competent software engineers and people that
>> prefer rebuttal to truth will avoid addressing the above irrefutably
>> correct reasoning.
>
> Your reasoning is incorrect. If H(P,P) == 0 then P should halt.
>
> /Flibble
>

Which one of these are you:

People that are not competent software engineers and people that
prefer rebuttal to truth will avoid addressing the above irrefutably
correct reasoning.

--
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: olcott, it's really simple

<20220616193259.000065b6@reddwarf.jmc>

 copy mid

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

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Path: i2pn2.org!rocksolid2!i2pn.org!aioe.org!news.uzoreto.com!feeder.usenetexpress.com!tr2.eu1.usenetexpress.com!81.171.65.14.MISMATCH!peer02.ams4!peer.am4.highwinds-media.com!news.highwinds-media.com!fx07.ams4.POSTED!not-for-mail
From: flib...@reddwarf.jmc (Mr Flibble)
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
Subject: Re: olcott, it's really simple
Message-ID: <20220616193259.000065b6@reddwarf.jmc>
References: <20220616181727.000072da@reddwarf.jmc> <_qudne-jFfaZ9jb_nZ2dnUU7_83NnZ2d@giganews.com> <20220616190213.000076a0@reddwarf.jmc> <xf-dnSnE0tX_7Db_nZ2dnUU7_83NnZ2d@giganews.com> <20220616191138.0000441c@reddwarf.jmc> <-qadnWtnS6In6Tb_nZ2dnUU7_83NnZ2d@giganews.com> <20220616192237.000071c0@reddwarf.jmc> <5rednfSRKMZP6Db_nZ2dnUU7_8zNnZ2d@giganews.com> <20220616193015.0000737c@reddwarf.jmc> <5rednfeRKMaD6jb_nZ2dnUU7_8xh4p2d@giganews.com>
Organization: Jupiter Mining Corp
X-Newsreader: Claws Mail 3.17.8 (GTK+ 2.24.33; x86_64-w64-mingw32)
MIME-Version: 1.0
Content-Type: text/plain; charset=US-ASCII
Content-Transfer-Encoding: 7bit
Lines: 124
X-Complaints-To: abuse@eweka.nl
NNTP-Posting-Date: Thu, 16 Jun 2022 18:32:59 UTC
Date: Thu, 16 Jun 2022 19:32:59 +0100
X-Received-Bytes: 5585
 by: Mr Flibble - Thu, 16 Jun 2022 18:32 UTC

On Thu, 16 Jun 2022 13:31:57 -0500
olcott <NoOne@NoWhere.com> wrote:

> On 6/16/2022 1:30 PM, Mr Flibble wrote:
> > On Thu, 16 Jun 2022 13:26:25 -0500
> > olcott <NoOne@NoWhere.com> wrote:
> >
> >> On 6/16/2022 1:22 PM, Mr Flibble wrote:
> >>> On Thu, 16 Jun 2022 13:21:45 -0500
> >>> olcott <NoOne@NoWhere.com> wrote:
> >>>
> >>>> On 6/16/2022 1:11 PM, Mr Flibble wrote:
> >>>>> On Thu, 16 Jun 2022 13:07:29 -0500
> >>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>
> >>>>>> On 6/16/2022 1:02 PM, Mr Flibble wrote:
> >>>>>>> On Thu, 16 Jun 2022 12:40:19 -0500
> >>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>
> >>>>>>> It would be better if you actually addressed the content of
> >>>>>>> people's posts. Your H is erroneous.
> >>>>>>>
> >>>>>>> /Flibble
> >>>>>>>
> >>>>>>
> >>>>>> Competent software engineers will agree that
> >>>>>> the following proves that H(P,P)==0 is correct.
> >>>>>>
> >>>>>> #include <stdint.h>
> >>>>>> typedef void (*ptr)();
> >>>>>>
> >>>>>> void P(ptr x)
> >>>>>> {
> >>>>>> if (H(x, x))
> >>>>>> HERE: goto HERE;
> >>>>>> return;
> >>>>>> }
> >>>>>>
> >>>>>> int main()
> >>>>>> {
> >>>>>> Output("Input_Halts = ", H(P, 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]
> >>>>>>
> >>>>>> (1) It is an easily verified fact that when we assume that H is
> >>>>>> only an x86 emulator that the correctly emulated P never
> >>>>>> reaches its "ret" instruction it remains stuck in repeated
> >>>>>> cycles of emulation.
> >>>>>>
> >>>>>> (2) It is an easily verified fact that if H has been adapted to
> >>>>>> correctly detect (in a finite number of steps) that the correct
> >>>>>> and complete x86 emulation of its input would never each its
> >>>>>> "ret" instruction that H could abort its emulation and return 0
> >>>>>> to report this.
> >>>>>>
> >>>>>> (3) When the halt status criteria is defined as correctly
> >>>>>> determining whether or not an x86 emulated input would ever
> >>>>>> reach its "ret" instruction then it becomes an easily verified
> >>>>>> fact H(P,P) could correctly reject its input as non-halting.
> >>>>>>
> >>>>>> Correct deductive inference proves that all of these things are
> >>>>>> true without any need what-so-ever to see either the
> >>>>>> source-code or the execution trace of H.
> >>>>>>
> >>>>>> The one thing that is not proved is whether or not an actual
> >>>>>> encoded H(P,P) does indeed correctly determine that its input
> >>>>>> would never reach its "ret" instruction as a pure function of
> >>>>>> its inputs.
> >>>>>
> >>>>> Nope. If H(P,P) == 0 then P should halt.
> >>>>>
> >>>>> /Flibble
> >>>>>
> >>>>
> >>>> Competent software engineers would understand that H(P,P)==0 is
> >>>> correct and be unable to find any software engineering mistakes.
> >>>>
> >>>> It is an easily verified fact that the correct and complete x86
> >>>> emulation of the input to H(P,P) by H cannot possibly reach its
> >>>> "ret" instruction.
> >>>>
> >>>> Since this is the criterion measure for returning 0 then
> >>>> H(P,P)==0 has been proven to be correct on the basis of software
> >>>> engineering.
> >>>
> >>> Nope. If H(P,P) == 0 then P should halt.
> >>>
> >>> /Flibble
> >>>
> >>
> >> People that are not competent software engineers and people that
> >> prefer rebuttal to truth will avoid addressing the above
> >> irrefutably correct reasoning.
> >
> > Your reasoning is incorrect. If H(P,P) == 0 then P should halt.
> >
> > /Flibble
> >
>
> Which one of these are you:
>
> People that are not competent software engineers and people that
> prefer rebuttal to truth will avoid addressing the above irrefutably
> correct reasoning.
Your reasoning is incorrect. If H(P,P) == 0 then P should halt.

/Flibble

Re: olcott, it's really simple

<s96dnfmXwIap5zb_nZ2dnUU7_8zNnZ2d@giganews.com>

 copy mid

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

 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, 16 Jun 2022 13:45:08 -0500
Date: Thu, 16 Jun 2022 13:45:07 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.10.0
Subject: Re: olcott, it's really simple
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <20220616181727.000072da@reddwarf.jmc>
<_qudne-jFfaZ9jb_nZ2dnUU7_83NnZ2d@giganews.com>
<20220616190213.000076a0@reddwarf.jmc>
<xf-dnSnE0tX_7Db_nZ2dnUU7_83NnZ2d@giganews.com>
<20220616191138.0000441c@reddwarf.jmc>
<-qadnWtnS6In6Tb_nZ2dnUU7_83NnZ2d@giganews.com>
<20220616192237.000071c0@reddwarf.jmc>
<5rednfSRKMZP6Db_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220616193015.0000737c@reddwarf.jmc>
<5rednfeRKMaD6jb_nZ2dnUU7_8xh4p2d@giganews.com>
<20220616193259.000065b6@reddwarf.jmc>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <20220616193259.000065b6@reddwarf.jmc>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Message-ID: <s96dnfmXwIap5zb_nZ2dnUU7_8zNnZ2d@giganews.com>
Lines: 143
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-aNVLGfrRsnilDk0YHTCh8Wl7YlL64jChF4nkVVgh2YvVcbVKGxCW3iO/CEQ557IS73sC/hnRw1GC++L!DtZCE8nBETUpv15q0rtGMRPnM1uTN9hgyS7RFe6Xy8eLNqtlwzdLtQ46lwL6FFzgbf7ERCIXGWte
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: 6825
 by: olcott - Thu, 16 Jun 2022 18:45 UTC

On 6/16/2022 1:32 PM, Mr Flibble wrote:
> On Thu, 16 Jun 2022 13:31:57 -0500
> olcott <NoOne@NoWhere.com> wrote:
>
>> On 6/16/2022 1:30 PM, Mr Flibble wrote:
>>> On Thu, 16 Jun 2022 13:26:25 -0500
>>> olcott <NoOne@NoWhere.com> wrote:
>>>
>>>> On 6/16/2022 1:22 PM, Mr Flibble wrote:
>>>>> On Thu, 16 Jun 2022 13:21:45 -0500
>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>
>>>>>> On 6/16/2022 1:11 PM, Mr Flibble wrote:
>>>>>>> On Thu, 16 Jun 2022 13:07:29 -0500
>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>
>>>>>>>> On 6/16/2022 1:02 PM, Mr Flibble wrote:
>>>>>>>>> On Thu, 16 Jun 2022 12:40:19 -0500
>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>
>>>>>>>>> It would be better if you actually addressed the content of
>>>>>>>>> people's posts. Your H is erroneous.
>>>>>>>>>
>>>>>>>>> /Flibble
>>>>>>>>>
>>>>>>>>
>>>>>>>> Competent software engineers will agree that
>>>>>>>> the following proves that H(P,P)==0 is correct.
>>>>>>>>
>>>>>>>> #include <stdint.h>
>>>>>>>> typedef void (*ptr)();
>>>>>>>>
>>>>>>>> void P(ptr x)
>>>>>>>> {
>>>>>>>> if (H(x, x))
>>>>>>>> HERE: goto HERE;
>>>>>>>> return;
>>>>>>>> }
>>>>>>>>
>>>>>>>> int main()
>>>>>>>> {
>>>>>>>> Output("Input_Halts = ", H(P, 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]
>>>>>>>>
>>>>>>>> (1) It is an easily verified fact that when we assume that H is
>>>>>>>> only an x86 emulator that the correctly emulated P never
>>>>>>>> reaches its "ret" instruction it remains stuck in repeated
>>>>>>>> cycles of emulation.
>>>>>>>>
>>>>>>>> (2) It is an easily verified fact that if H has been adapted to
>>>>>>>> correctly detect (in a finite number of steps) that the correct
>>>>>>>> and complete x86 emulation of its input would never each its
>>>>>>>> "ret" instruction that H could abort its emulation and return 0
>>>>>>>> to report this.
>>>>>>>>
>>>>>>>> (3) When the halt status criteria is defined as correctly
>>>>>>>> determining whether or not an x86 emulated input would ever
>>>>>>>> reach its "ret" instruction then it becomes an easily verified
>>>>>>>> fact H(P,P) could correctly reject its input as non-halting.
>>>>>>>>
>>>>>>>> Correct deductive inference proves that all of these things are
>>>>>>>> true without any need what-so-ever to see either the
>>>>>>>> source-code or the execution trace of H.
>>>>>>>>
>>>>>>>> The one thing that is not proved is whether or not an actual
>>>>>>>> encoded H(P,P) does indeed correctly determine that its input
>>>>>>>> would never reach its "ret" instruction as a pure function of
>>>>>>>> its inputs.
>>>>>>>
>>>>>>> Nope. If H(P,P) == 0 then P should halt.
>>>>>>>
>>>>>>> /Flibble
>>>>>>>
>>>>>>
>>>>>> Competent software engineers would understand that H(P,P)==0 is
>>>>>> correct and be unable to find any software engineering mistakes.
>>>>>>
>>>>>> It is an easily verified fact that the correct and complete x86
>>>>>> emulation of the input to H(P,P) by H cannot possibly reach its
>>>>>> "ret" instruction.
>>>>>>
>>>>>> Since this is the criterion measure for returning 0 then
>>>>>> H(P,P)==0 has been proven to be correct on the basis of software
>>>>>> engineering.
>>>>>
>>>>> Nope. If H(P,P) == 0 then P should halt.
>>>>>
>>>>> /Flibble
>>>>>
>>>>
>>>> People that are not competent software engineers and people that
>>>> prefer rebuttal to truth will avoid addressing the above
>>>> irrefutably correct reasoning.
>>>
>>> Your reasoning is incorrect. If H(P,P) == 0 then P should halt.
>>>
>>> /Flibble
>>>
>>
>> Which one of these are you:
>>
>> People that are not competent software engineers and people that
>> prefer rebuttal to truth will avoid addressing the above irrefutably
>> correct reasoning.
>
> Your reasoning is incorrect. If H(P,P) == 0 then P should halt.
>
> /Flibble
>

Since my reasoning is trivially proven to be correct:

It is an easily verified fact that the correct and complete x86
emulation of the input to H(P,P) by H cannot possibly reach its
"ret" instruction.

H returns 0 whenever the complete and correct x86 emulation of its input
would never reach the "ret" instruction of this input.

Every possible rebuttal is simultaneously proven to be incorrect.

--
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: olcott, it's really simple

<20220616194935.00001de9@reddwarf.jmc>

 copy mid

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

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Path: i2pn2.org!i2pn.org!weretis.net!feeder8.news.weretis.net!feeder1.feed.usenet.farm!feed.usenet.farm!peer01.ams4!peer.am4.highwinds-media.com!news.highwinds-media.com!fx05.ams4.POSTED!not-for-mail
From: flib...@reddwarf.jmc (Mr Flibble)
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
Subject: Re: olcott, it's really simple
Message-ID: <20220616194935.00001de9@reddwarf.jmc>
References: <20220616181727.000072da@reddwarf.jmc>
<_qudne-jFfaZ9jb_nZ2dnUU7_83NnZ2d@giganews.com>
<20220616190213.000076a0@reddwarf.jmc>
<xf-dnSnE0tX_7Db_nZ2dnUU7_83NnZ2d@giganews.com>
<20220616191138.0000441c@reddwarf.jmc>
<-qadnWtnS6In6Tb_nZ2dnUU7_83NnZ2d@giganews.com>
<20220616192237.000071c0@reddwarf.jmc>
<5rednfSRKMZP6Db_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220616193015.0000737c@reddwarf.jmc>
<5rednfeRKMaD6jb_nZ2dnUU7_8xh4p2d@giganews.com>
<20220616193259.000065b6@reddwarf.jmc>
<s96dnfmXwIap5zb_nZ2dnUU7_8zNnZ2d@giganews.com>
Organization: Jupiter Mining Corp
X-Newsreader: Claws Mail 3.17.8 (GTK+ 2.24.33; x86_64-w64-mingw32)
MIME-Version: 1.0
Content-Type: text/plain; charset=US-ASCII
Content-Transfer-Encoding: 7bit
Lines: 146
X-Complaints-To: abuse@eweka.nl
NNTP-Posting-Date: Thu, 16 Jun 2022 18:49:35 UTC
Date: Thu, 16 Jun 2022 19:49:35 +0100
X-Received-Bytes: 6609
 by: Mr Flibble - Thu, 16 Jun 2022 18:49 UTC

On Thu, 16 Jun 2022 13:45:07 -0500
olcott <NoOne@NoWhere.com> wrote:

> On 6/16/2022 1:32 PM, Mr Flibble wrote:
> > On Thu, 16 Jun 2022 13:31:57 -0500
> > olcott <NoOne@NoWhere.com> wrote:
> >
> >> On 6/16/2022 1:30 PM, Mr Flibble wrote:
> >>> On Thu, 16 Jun 2022 13:26:25 -0500
> >>> olcott <NoOne@NoWhere.com> wrote:
> >>>
> >>>> On 6/16/2022 1:22 PM, Mr Flibble wrote:
> >>>>> On Thu, 16 Jun 2022 13:21:45 -0500
> >>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>
> >>>>>> On 6/16/2022 1:11 PM, Mr Flibble wrote:
> >>>>>>> On Thu, 16 Jun 2022 13:07:29 -0500
> >>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>
> >>>>>>>> On 6/16/2022 1:02 PM, Mr Flibble wrote:
> >>>>>>>>> On Thu, 16 Jun 2022 12:40:19 -0500
> >>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>>
> >>>>>>>>> It would be better if you actually addressed the content of
> >>>>>>>>> people's posts. Your H is erroneous.
> >>>>>>>>>
> >>>>>>>>> /Flibble
> >>>>>>>>>
> >>>>>>>>
> >>>>>>>> Competent software engineers will agree that
> >>>>>>>> the following proves that H(P,P)==0 is correct.
> >>>>>>>>
> >>>>>>>> #include <stdint.h>
> >>>>>>>> typedef void (*ptr)();
> >>>>>>>>
> >>>>>>>> void P(ptr x)
> >>>>>>>> {
> >>>>>>>> if (H(x, x))
> >>>>>>>> HERE: goto HERE;
> >>>>>>>> return;
> >>>>>>>> }
> >>>>>>>>
> >>>>>>>> int main()
> >>>>>>>> {
> >>>>>>>> Output("Input_Halts = ", H(P, 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]
> >>>>>>>>
> >>>>>>>> (1) It is an easily verified fact that when we assume that H
> >>>>>>>> is only an x86 emulator that the correctly emulated P never
> >>>>>>>> reaches its "ret" instruction it remains stuck in repeated
> >>>>>>>> cycles of emulation.
> >>>>>>>>
> >>>>>>>> (2) It is an easily verified fact that if H has been adapted
> >>>>>>>> to correctly detect (in a finite number of steps) that the
> >>>>>>>> correct and complete x86 emulation of its input would never
> >>>>>>>> each its "ret" instruction that H could abort its emulation
> >>>>>>>> and return 0 to report this.
> >>>>>>>>
> >>>>>>>> (3) When the halt status criteria is defined as correctly
> >>>>>>>> determining whether or not an x86 emulated input would ever
> >>>>>>>> reach its "ret" instruction then it becomes an easily
> >>>>>>>> verified fact H(P,P) could correctly reject its input as
> >>>>>>>> non-halting.
> >>>>>>>>
> >>>>>>>> Correct deductive inference proves that all of these things
> >>>>>>>> are true without any need what-so-ever to see either the
> >>>>>>>> source-code or the execution trace of H.
> >>>>>>>>
> >>>>>>>> The one thing that is not proved is whether or not an actual
> >>>>>>>> encoded H(P,P) does indeed correctly determine that its input
> >>>>>>>> would never reach its "ret" instruction as a pure function of
> >>>>>>>> its inputs.
> >>>>>>>
> >>>>>>> Nope. If H(P,P) == 0 then P should halt.
> >>>>>>>
> >>>>>>> /Flibble
> >>>>>>>
> >>>>>>
> >>>>>> Competent software engineers would understand that H(P,P)==0 is
> >>>>>> correct and be unable to find any software engineering
> >>>>>> mistakes.
> >>>>>>
> >>>>>> It is an easily verified fact that the correct and complete x86
> >>>>>> emulation of the input to H(P,P) by H cannot possibly reach its
> >>>>>> "ret" instruction.
> >>>>>>
> >>>>>> Since this is the criterion measure for returning 0 then
> >>>>>> H(P,P)==0 has been proven to be correct on the basis of
> >>>>>> software engineering.
> >>>>>
> >>>>> Nope. If H(P,P) == 0 then P should halt.
> >>>>>
> >>>>> /Flibble
> >>>>>
> >>>>
> >>>> People that are not competent software engineers and people that
> >>>> prefer rebuttal to truth will avoid addressing the above
> >>>> irrefutably correct reasoning.
> >>>
> >>> Your reasoning is incorrect. If H(P,P) == 0 then P should halt.
> >>>
> >>> /Flibble
> >>>
> >>
> >> Which one of these are you:
> >>
> >> People that are not competent software engineers and people that
> >> prefer rebuttal to truth will avoid addressing the above
> >> irrefutably correct reasoning.
> >
> > Your reasoning is incorrect. If H(P,P) == 0 then P should halt.
> >
> > /Flibble
> >
>
> Since my reasoning is trivially proven to be correct:
>
> It is an easily verified fact that the correct and complete x86
> emulation of the input to H(P,P) by H cannot possibly reach its
> "ret" instruction.
>
> H returns 0 whenever the complete and correct x86 emulation of its
> input would never reach the "ret" instruction of this input.
>
> Every possible rebuttal is simultaneously proven to be incorrect.
Nope. If H(P,P) == 0 then P should halt.

/Flibble

Re: olcott, it's really simple

<MNidnbMzi_kx4zb_nZ2dnUU7_83NnZ2d@giganews.com>

 copy mid

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

 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, 16 Jun 2022 14:04:12 -0500
Date: Thu, 16 Jun 2022 14:04:11 -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: olcott, it's really simple
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <20220616181727.000072da@reddwarf.jmc>
<_qudne-jFfaZ9jb_nZ2dnUU7_83NnZ2d@giganews.com>
<20220616190213.000076a0@reddwarf.jmc>
<xf-dnSnE0tX_7Db_nZ2dnUU7_83NnZ2d@giganews.com>
<20220616191138.0000441c@reddwarf.jmc>
<-qadnWtnS6In6Tb_nZ2dnUU7_83NnZ2d@giganews.com>
<20220616192237.000071c0@reddwarf.jmc>
<5rednfSRKMZP6Db_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220616193015.0000737c@reddwarf.jmc>
<5rednfeRKMaD6jb_nZ2dnUU7_8xh4p2d@giganews.com>
<20220616193259.000065b6@reddwarf.jmc>
<s96dnfmXwIap5zb_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220616194935.00001de9@reddwarf.jmc>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <20220616194935.00001de9@reddwarf.jmc>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Message-ID: <MNidnbMzi_kx4zb_nZ2dnUU7_83NnZ2d@giganews.com>
Lines: 171
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-7YxdPcezP92Voon70CzkGbV6hzlJ0wjipfa5YDdKlx7PuSGzIWGk19ZMQRrG09r2jCE9Exln9h6o2F0!obqMDah4Uit0NjIrtjaEbFkvwrSk7724DU5qLCAA+LVRZBigo3oS78wEy7i2+X5WrfFdjETK2pIY
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: 7999
 by: olcott - Thu, 16 Jun 2022 19:04 UTC

On 6/16/2022 1:49 PM, Mr Flibble wrote:
> On Thu, 16 Jun 2022 13:45:07 -0500
> olcott <NoOne@NoWhere.com> wrote:
>
>> On 6/16/2022 1:32 PM, Mr Flibble wrote:
>>> On Thu, 16 Jun 2022 13:31:57 -0500
>>> olcott <NoOne@NoWhere.com> wrote:
>>>
>>>> On 6/16/2022 1:30 PM, Mr Flibble wrote:
>>>>> On Thu, 16 Jun 2022 13:26:25 -0500
>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>
>>>>>> On 6/16/2022 1:22 PM, Mr Flibble wrote:
>>>>>>> On Thu, 16 Jun 2022 13:21:45 -0500
>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>
>>>>>>>> On 6/16/2022 1:11 PM, Mr Flibble wrote:
>>>>>>>>> On Thu, 16 Jun 2022 13:07:29 -0500
>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>
>>>>>>>>>> On 6/16/2022 1:02 PM, Mr Flibble wrote:
>>>>>>>>>>> On Thu, 16 Jun 2022 12:40:19 -0500
>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>
>>>>>>>>>>> It would be better if you actually addressed the content of
>>>>>>>>>>> people's posts. Your H is erroneous.
>>>>>>>>>>>
>>>>>>>>>>> /Flibble
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Competent software engineers will agree that
>>>>>>>>>> the following proves that H(P,P)==0 is correct.
>>>>>>>>>>
>>>>>>>>>> #include <stdint.h>
>>>>>>>>>> typedef void (*ptr)();
>>>>>>>>>>
>>>>>>>>>> void P(ptr x)
>>>>>>>>>> {
>>>>>>>>>> if (H(x, x))
>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>> return;
>>>>>>>>>> }
>>>>>>>>>>
>>>>>>>>>> int main()
>>>>>>>>>> {
>>>>>>>>>> Output("Input_Halts = ", H(P, 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]
>>>>>>>>>>
>>>>>>>>>> (1) It is an easily verified fact that when we assume that H
>>>>>>>>>> is only an x86 emulator that the correctly emulated P never
>>>>>>>>>> reaches its "ret" instruction it remains stuck in repeated
>>>>>>>>>> cycles of emulation.
>>>>>>>>>>
>>>>>>>>>> (2) It is an easily verified fact that if H has been adapted
>>>>>>>>>> to correctly detect (in a finite number of steps) that the
>>>>>>>>>> correct and complete x86 emulation of its input would never
>>>>>>>>>> each its "ret" instruction that H could abort its emulation
>>>>>>>>>> and return 0 to report this.
>>>>>>>>>>
>>>>>>>>>> (3) When the halt status criteria is defined as correctly
>>>>>>>>>> determining whether or not an x86 emulated input would ever
>>>>>>>>>> reach its "ret" instruction then it becomes an easily
>>>>>>>>>> verified fact H(P,P) could correctly reject its input as
>>>>>>>>>> non-halting.
>>>>>>>>>>
>>>>>>>>>> Correct deductive inference proves that all of these things
>>>>>>>>>> are true without any need what-so-ever to see either the
>>>>>>>>>> source-code or the execution trace of H.
>>>>>>>>>>
>>>>>>>>>> The one thing that is not proved is whether or not an actual
>>>>>>>>>> encoded H(P,P) does indeed correctly determine that its input
>>>>>>>>>> would never reach its "ret" instruction as a pure function of
>>>>>>>>>> its inputs.
>>>>>>>>>
>>>>>>>>> Nope. If H(P,P) == 0 then P should halt.
>>>>>>>>>
>>>>>>>>> /Flibble
>>>>>>>>>
>>>>>>>>
>>>>>>>> Competent software engineers would understand that H(P,P)==0 is
>>>>>>>> correct and be unable to find any software engineering
>>>>>>>> mistakes.
>>>>>>>>
>>>>>>>> It is an easily verified fact that the correct and complete x86
>>>>>>>> emulation of the input to H(P,P) by H cannot possibly reach its
>>>>>>>> "ret" instruction.
>>>>>>>>
>>>>>>>> Since this is the criterion measure for returning 0 then
>>>>>>>> H(P,P)==0 has been proven to be correct on the basis of
>>>>>>>> software engineering.
>>>>>>>
>>>>>>> Nope. If H(P,P) == 0 then P should halt.
>>>>>>>
>>>>>>> /Flibble
>>>>>>>
>>>>>>
>>>>>> People that are not competent software engineers and people that
>>>>>> prefer rebuttal to truth will avoid addressing the above
>>>>>> irrefutably correct reasoning.
>>>>>
>>>>> Your reasoning is incorrect. If H(P,P) == 0 then P should halt.
>>>>>
>>>>> /Flibble
>>>>>
>>>>
>>>> Which one of these are you:
>>>>
>>>> People that are not competent software engineers and people that
>>>> prefer rebuttal to truth will avoid addressing the above
>>>> irrefutably correct reasoning.
>>>
>>> Your reasoning is incorrect. If H(P,P) == 0 then P should halt.
>>>
>>> /Flibble
>>>
>>
>> Since my reasoning is trivially proven to be correct:
>>
>> It is an easily verified fact that the correct and complete x86
>> emulation of the input to H(P,P) by H cannot possibly reach its
>> "ret" instruction.
>>
>> H returns 0 whenever the complete and correct x86 emulation of its
>> input would never reach the "ret" instruction of this input.
>>
>> Every possible rebuttal is simultaneously proven to be incorrect.
>
> Nope. If H(P,P) == 0 then P should halt.
>
> /Flibble
>

(X) It is an easily verified fact that the correct and complete x86
emulation of the input to H(P,P) by H cannot possibly reach its "ret"
instruction.

(Y) H returns 0 whenever the correct and complete x86 emulation of its
input would never reach the "ret" instruction of this input.

(Z) H(P,P)==0 is correct

When (X & Y) proves Z and we know X & Y then Z is proved.

Even you can understand that there is no escape from this last line.
Failing to acknowledge the correctness of this last line is sufficient
evidence of dishonesty.


Click here to read the complete article
Re: olcott, it's really simple

<871qvoju7d.fsf@bsb.me.uk>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!eternal-september.org!reader02.eternal-september.org!.POSTED!not-for-mail
From: ben.use...@bsb.me.uk (Ben Bacarisse)
Newsgroups: comp.theory
Subject: Re: olcott, it's really simple
Date: Thu, 16 Jun 2022 20:15:34 +0100
Organization: A noiseless patient Spider
Lines: 40
Message-ID: <871qvoju7d.fsf@bsb.me.uk>
References: <20220616181727.000072da@reddwarf.jmc>
MIME-Version: 1.0
Content-Type: text/plain
Injection-Info: reader02.eternal-september.org; posting-host="d663ac5e7616b86ff0edb8f58f87a3a8";
logging-data="26660"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX1+MPO9MObKaOr6GPzjtSLJ0XQVAbXD7hBg="
Cancel-Lock: sha1:SW5Ynr2gegqs0OybaFWdsv25hto=
sha1:dvazqMLfGtkbb4J1/nsg4lG/2Fg=
X-BSB-Auth: 1.b2ec1e225647f15990fa.20220616201534BST.871qvoju7d.fsf@bsb.me.uk
 by: Ben Bacarisse - Thu, 16 Jun 2022 19:15 UTC

Mr Flibble <flibble@reddwarf.jmc> writes:

> Given olcott's code,
>
> #include <stdint.h>
> typedef void (*ptr)();
>
> void P(ptr x)
> {
> if (H(x, x))
> HERE: goto HERE;
> return;
> }
>
> int main()
> {
> Output("Input_Halts = ", H(P, P));
> }
>
> and olcott's assertion that H is a pure function and H(P,P) == 0,
> then, P should halt as H should also return 0 to P

You mean P(P) should halt, and it does. PO does not dispute this fact.
Not only has he posted a trace of P(P) halting, he has clearly stated
that H(P,P) == 0 "is the correct answer even though P(P) halts".[1]

> (pure functions
> ALWAYS return the same result for the same arguments with no side
> effects). P doesn't halt so H is erroneous; olcott, it's really that
> simple.

Except that he is now just asserting that H(P,P) == 0 is correct about
something else (the "correct simulation of the input to H(P,P)") and the
mistakes in that irrelevant statement are keeping him supplied with the
attention he craves. You might consider not giving him what he wants.

[1] Message-ID: <c8idnbFAF6C8QuP8nZ2dnUU7-avNnZ2d@giganews.com>

--
Ben.

Re: olcott, it's really simple

<5cidnY_T_9aHGTb_nZ2dnUU7_83NnZ2d@giganews.com>

 copy mid

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

 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: Thu, 16 Jun 2022 14:27:22 -0500
Date: Thu, 16 Jun 2022 14:27:21 -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: olcott, it's really simple
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <20220616181727.000072da@reddwarf.jmc> <871qvoju7d.fsf@bsb.me.uk>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <871qvoju7d.fsf@bsb.me.uk>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <5cidnY_T_9aHGTb_nZ2dnUU7_83NnZ2d@giganews.com>
Lines: 59
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-I2s+M5mMkD6OubmZ/ThdC8hyyi3Xik5WBzd9/m3pjGKyAM1QhRfTTk0HaccXAGW9LsrCKLMB3rfXtc3!+P0AUohWMHfF3S81eaLjzSyJZdlXeVKai+IPy7Bk0yDJVeOdQUbz6sup9nMNidWXPk0P6P0zBAhA
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: 3151
 by: olcott - Thu, 16 Jun 2022 19:27 UTC

On 6/16/2022 2:15 PM, Ben Bacarisse wrote:
> Mr Flibble <flibble@reddwarf.jmc> writes:
>
>> Given olcott's code,
>>
>> #include <stdint.h>
>> typedef void (*ptr)();
>>
>> void P(ptr x)
>> {
>> if (H(x, x))
>> HERE: goto HERE;
>> return;
>> }
>>
>> int main()
>> {
>> Output("Input_Halts = ", H(P, P));
>> }
>>
>> and olcott's assertion that H is a pure function and H(P,P) == 0,
>> then, P should halt as H should also return 0 to P
>
> You mean P(P) should halt, and it does. PO does not dispute this fact.
> Not only has he posted a trace of P(P) halting, he has clearly stated
> that H(P,P) == 0 "is the correct answer even though P(P) halts".[1]
>
>> (pure functions
>> ALWAYS return the same result for the same arguments with no side
>> effects). P doesn't halt so H is erroneous; olcott, it's really that
>> simple.
>
> Except that he is now just asserting that H(P,P) == 0 is correct about
> something else (the "correct simulation of the input to H(P,P)") and the
> mistakes in that irrelevant statement are keeping him supplied with the
> attention he craves. You might consider not giving him what he wants.
>
> [1] Message-ID: <c8idnbFAF6C8QuP8nZ2dnUU7-avNnZ2d@giganews.com>
>

When a simulating halt decider rejects all inputs as non-halting
whenever it correctly detects that its correct and complete simulation
of its input would never reach the final state of this input that all
inputs (including pathological inputs) are decided correctly.

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

Linz, Peter 1990. An Introduction to Formal Languages and Automata.
Lexington/Toronto: D. C. Heath and Company. (317-320)

--
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: olcott, it's really simple (tiny typo)

<x_mdnepfHNbYLTb_nZ2dnUU7_81g4p2d@giganews.com>

 copy mid

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

 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!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Thu, 16 Jun 2022 17:35:49 -0500
Date: Thu, 16 Jun 2022 17:35:48 -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: olcott, it's really simple (tiny typo)
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <20220616181727.000072da@reddwarf.jmc> <871qvoju7d.fsf@bsb.me.uk>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <871qvoju7d.fsf@bsb.me.uk>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <x_mdnepfHNbYLTb_nZ2dnUU7_81g4p2d@giganews.com>
Lines: 58
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-WPu5F3FdW0O7yE/F0qlGV6YOwfNhagu10pEcpCaS0lSgCip0vgS6jM2Sztos8gS2Ygdib/5adkB8cDh!Twzw6y8mWjsSS6OtdWGIFpZ9M2ZokyUZXJZ9dJvi9LEVRxyvfPrUtklzwWkEGoXogOecspzeUjNz
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: 3161
X-Received-Bytes: 3283
 by: olcott - Thu, 16 Jun 2022 22:35 UTC

On 6/16/2022 2:15 PM, Ben Bacarisse wrote:
> Mr Flibble <flibble@reddwarf.jmc> writes:
>
>> Given olcott's code,
>>
>> #include <stdint.h>
>> typedef void (*ptr)();
>>
>> void P(ptr x)
>> {
>> if (H(x, x))
>> HERE: goto HERE;
>> return;
>> }
>>
>> int main()
>> {
>> Output("Input_Halts = ", H(P, P));
>> }
>>
>> and olcott's assertion that H is a pure function and H(P,P) == 0,
>> then, P should halt as H should also return 0 to P
>
> You mean P(P) should halt, and it does. PO does not dispute this fact.
> Not only has he posted a trace of P(P) halting, he has clearly stated
> that H(P,P) == 0 "is the correct answer even though P(P) halts".[1]
>
>> (pure functions
>> ALWAYS return the same result for the same arguments with no side
>> effects). P doesn't halt so H is erroneous; olcott, it's really that
>> simple.
>
> Except that he is now just asserting that H(P,P) == 0 is correct about
> something else (the "correct simulation of the input to H(P,P)") and the
> mistakes in that irrelevant statement are keeping him supplied with the
> attention he craves. You might consider not giving him what he wants.
>
> [1] Message-ID: <c8idnbFAF6C8QuP8nZ2dnUU7-avNnZ2d@giganews.com>
>

When a simulating halt decider rejects all inputs as non-halting
whenever it correctly detects that its correct and complete simulation
of its input would never reach the final state of this input then all
inputs (including pathological inputs) are decided correctly.

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

Linz, Peter 1990. An Introduction to Formal Languages and Automata.
Lexington/Toronto: D. C. Heath and Company. (317-320)

--
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: olcott, it's really simple [ succinct summation ]

<8dWdnZYgV_8eTjb_nZ2dnUU7_8zNnZ2d@giganews.com>

 copy mid

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

 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, 16 Jun 2022 20:06:11 -0500
Date: Thu, 16 Jun 2022 20:06:09 -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: olcott, it's really simple [ succinct summation ]
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <20220616181727.000072da@reddwarf.jmc> <871qvoju7d.fsf@bsb.me.uk>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <871qvoju7d.fsf@bsb.me.uk>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <8dWdnZYgV_8eTjb_nZ2dnUU7_8zNnZ2d@giganews.com>
Lines: 58
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-JV0ZnaJR1CHtsVV6zpM8JwVX4CnzOMmbx3j2o+BZjuBwQK3Q/RXWCWOwpcmmRkm0/MSX4zZSKeBhc3c!+FUvibs5ZlrDV7v9jBOkEVZnNcyDKOABce+PShEXooadWnfLfB9KxSIBm7QY703wn05ZTQQESkJK
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: 3180
 by: olcott - Fri, 17 Jun 2022 01:06 UTC

On 6/16/2022 2:15 PM, Ben Bacarisse wrote:
> Mr Flibble <flibble@reddwarf.jmc> writes:
>
>> Given olcott's code,
>>
>> #include <stdint.h>
>> typedef void (*ptr)();
>>
>> void P(ptr x)
>> {
>> if (H(x, x))
>> HERE: goto HERE;
>> return;
>> }
>>
>> int main()
>> {
>> Output("Input_Halts = ", H(P, P));
>> }
>>
>> and olcott's assertion that H is a pure function and H(P,P) == 0,
>> then, P should halt as H should also return 0 to P
>
> You mean P(P) should halt, and it does. PO does not dispute this fact.
> Not only has he posted a trace of P(P) halting, he has clearly stated
> that H(P,P) == 0 "is the correct answer even though P(P) halts".[1]
>
>> (pure functions
>> ALWAYS return the same result for the same arguments with no side
>> effects). P doesn't halt so H is erroneous; olcott, it's really that
>> simple.
>
> Except that he is now just asserting that H(P,P) == 0 is correct about
> something else (the "correct simulation of the input to H(P,P)") and the
> mistakes in that irrelevant statement are keeping him supplied with the
> attention he craves. You might consider not giving him what he wants.
>
> [1] Message-ID: <c8idnbFAF6C8QuP8nZ2dnUU7-avNnZ2d@giganews.com>
>

When a simulating halt decider rejects all inputs as non-halting
whenever it correctly detects that its correct and complete simulation
of its input would never reach the final state of this input then all
[these] inputs (including pathological inputs) are decided correctly.

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

Linz, Peter 1990. An Introduction to Formal Languages and Automata.
Lexington/Toronto: D. C. Heath and Company. (317-320)

--
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: olcott, it's really simple

<YcRqK.5394$9j2.1234@fx33.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Path: i2pn2.org!i2pn.org!aioe.org!news.uzoreto.com!feeder.usenetexpress.com!tr3.eu1.usenetexpress.com!feeder1.feed.usenet.farm!feed.usenet.farm!peer02.ams4!peer.am4.highwinds-media.com!peer01.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx33.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: olcott, it's really simple
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <20220616181727.000072da@reddwarf.jmc> <_qudne-jFfaZ9jb_nZ2dnUU7_83NnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <_qudne-jFfaZ9jb_nZ2dnUU7_83NnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 87
Message-ID: <YcRqK.5394$9j2.1234@fx33.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: Thu, 16 Jun 2022 21:58:16 -0400
X-Received-Bytes: 3712
 by: Richard Damon - Fri, 17 Jun 2022 01:58 UTC

On 6/16/22 1:40 PM, olcott wrote:
> On 6/16/2022 12:17 PM, Mr Flibble wrote:
>> Given olcott's code,
>>
>> #include <stdint.h>
>> typedef void (*ptr)();
>>
>> void P(ptr x)
>> {
>>     if (H(x, x))
>>       HERE: goto HERE;
>>     return;
>> }
>>
>> int main()
>> {
>>     Output("Input_Halts = ", H(P, P));
>> }
>>
>> and olcott's assertion that H is a pure function and H(P,P) == 0,
>> then, P should halt as H should also return 0 to P (pure functions
>> ALWAYS return the same result for the same arguments with no side
>> effects). P doesn't halt so H is erroneous; olcott, it's really that
>> simple.
>>
>> /Flibble
>>
>
> _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]
>
> Any competent software engineer will see that the correct and complete
> x86 emulation of the input to H(P,P) will never reach its "ret"
> instruction (the final state of P).

So, does H do a compete and correct emulation, or does it abort its
simulation to give an answer?

The fact that you seem to claim that when H is called by main, it aborts
and returns an answer, but when H is called by the simulated P it
doesn't, just proves that H isn't the pure function you claim, or H's
emulaiton isn't correct.

>
> When H(P,P) aborts the x86 emulation of its input on this basis and
> returns 0 to main competent software engineers will know that this does
> not cause P to reach its "ret" instruction.

You mean that not all calls of H(P,P) do the same thing? Then H isn't
the pure function you claim.

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

Right, we look at the TURING MACHINE, that is the actual function P (not
H;s emulation of it) and that seems to Halt becahse H should return the
value 0 to it.

>
> Linz, Peter 1990. An Introduction to Formal Languages and Automata.
> Lexington/Toronto: D. C. Heath and Company. (317-320)
>

So, which statement of yours is the LIE?

Is H not actually a pure function, or

Does H not accurately emulate its input, or

Is P not actualy built as required?

One of these has to be wrong.

Re: olcott, it's really simple

<zhRqK.173141$JVi.147142@fx17.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Path: i2pn2.org!i2pn.org!aioe.org!feeder1.feed.usenet.farm!feed.usenet.farm!peer02.ams4!peer.am4.highwinds-media.com!peer03.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx17.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: olcott, it's really simple
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <20220616181727.000072da@reddwarf.jmc>
<_qudne-jFfaZ9jb_nZ2dnUU7_83NnZ2d@giganews.com>
<20220616190213.000076a0@reddwarf.jmc>
<xf-dnSnE0tX_7Db_nZ2dnUU7_83NnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <xf-dnSnE0tX_7Db_nZ2dnUU7_83NnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 88
Message-ID: <zhRqK.173141$JVi.147142@fx17.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: Thu, 16 Jun 2022 22:03:11 -0400
X-Received-Bytes: 4067
 by: Richard Damon - Fri, 17 Jun 2022 02:03 UTC

On 6/16/22 2:07 PM, olcott wrote:
> On 6/16/2022 1:02 PM, Mr Flibble wrote:
>> On Thu, 16 Jun 2022 12:40:19 -0500
>> olcott <NoOne@NoWhere.com> wrote:
>>
>> It would be better if you actually addressed the content of people's
>> posts.  Your H is erroneous.
>>
>> /Flibble
>>
>
> Competent software engineers will agree that
> the following proves that H(P,P)==0 is correct.
>
> #include <stdint.h>
> typedef void (*ptr)();
>
> void P(ptr x)
> {
>   if (H(x, x))
>     HERE: goto HERE;
>   return;
> }
>
> int main()
> {
>   Output("Input_Halts = ", H(P, 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]
>
> (1) It is an easily verified fact that when we assume that H is only an
> x86 emulator that the correctly emulated P never reaches its "ret"
> instruction it remains stuck in repeated cycles of emulation.

This ONLY applies if H is actually the pure emulator that you talk about.

>
> (2) It is an easily verified fact that if H has been adapted to
> correctly detect (in a finite number of steps) that the correct and
> complete x86 emulation of its input would never each its "ret"
> instruction that H could abort its emulation and return 0 to report this.

Yes, buyt ONLY if H is that pure emulator that NEVER aborts is emulation.

>
> (3) When the halt status criteria is defined as correctly determining
> whether or not an x86 emulated input would ever reach its "ret"
> instruction then it becomes an easily verified fact H(P,P) could
> correctly reject its input as non-halting.
>

Except that to reject the input, your H has not NOT be that pure
emulation, thus if H acts as in (3), then it can't use the logic of (1)
or (2), since those both were based on the stipulation that H did a
complete and correct emulation and NEVER aborted.

FALSE PREMISE, UNSOUND logic.

> Correct deductive inference proves that all of these things are true
> without any need what-so-ever to see either the source-code or the
> execution trace of H.

Nope. You have been told this many times, so your continued repeating of
it just shows either ignorance or just being a pathological liar.

>
> The one thing that is not proved is whether or not an actual encoded
> H(P,P) does indeed correctly determine that its input would never reach
> its "ret" instruction as a pure function of its inputs.
>

Right, because it CAN'T.

Re: olcott, it's really simple

<rmRqK.7178$Sf2.3862@fx34.iad>

 copy mid

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

 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!border1.nntp.dca1.giganews.com!nntp.giganews.com!peer01.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx34.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: olcott, it's really simple
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <20220616181727.000072da@reddwarf.jmc> <871qvoju7d.fsf@bsb.me.uk>
<5cidnY_T_9aHGTb_nZ2dnUU7_83NnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <5cidnY_T_9aHGTb_nZ2dnUU7_83NnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 73
Message-ID: <rmRqK.7178$Sf2.3862@fx34.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: Thu, 16 Jun 2022 22:08:23 -0400
X-Received-Bytes: 3754
X-Original-Bytes: 3621
 by: Richard Damon - Fri, 17 Jun 2022 02:08 UTC

On 6/16/22 3:27 PM, olcott wrote:
> On 6/16/2022 2:15 PM, Ben Bacarisse wrote:
>> Mr Flibble <flibble@reddwarf.jmc> writes:
>>
>>> Given olcott's code,
>>>
>>> #include <stdint.h>
>>> typedef void (*ptr)();
>>>
>>> void P(ptr x)
>>> {
>>>     if (H(x, x))
>>>       HERE: goto HERE;
>>>     return;
>>> }
>>>
>>> int main()
>>> {
>>>     Output("Input_Halts = ", H(P, P));
>>> }
>>>
>>> and olcott's assertion that H is a pure function and H(P,P) == 0,
>>> then, P should halt as H should also return 0 to P
>>
>> You mean P(P) should halt, and it does.  PO does not dispute this fact.
>> Not only has he posted a trace of P(P) halting, he has clearly stated
>> that H(P,P) == 0 "is the correct answer even though P(P) halts".[1]
>>
>>> (pure functions
>>> ALWAYS return the same result for the same arguments with no side
>>> effects). P doesn't halt so H is erroneous; olcott, it's really that
>>> simple.
>>
>> Except that he is now just asserting that H(P,P) == 0 is correct about
>> something else (the "correct simulation of the input to H(P,P)") and the
>> mistakes in that irrelevant statement are keeping him supplied with the
>> attention he craves.  You might consider not giving him what he wants.
>>
>> [1] Message-ID: <c8idnbFAF6C8QuP8nZ2dnUU7-avNnZ2d@giganews.com>
>>
>
> When a simulating halt decider rejects all inputs as non-halting
> whenever it correctly detects that its correct and complete simulation
> of its input would never reach the final state of this input that all
> inputs (including pathological inputs) are decided correctly.
>
> *computation that halts* … the Turing machine will halt whenever it
> enters a final state. (Linz:1990:234)
>
> Linz, Peter 1990. An Introduction to Formal Languages and Automata.
> Lexington/Toronto: D. C. Heath and Company. (317-320)
>
>
>

It needs to be CORRECT in its detection, and it isn't if "its" correct
and complete simulation of its input would never reach the final state
unless it actually DOES that.

If H DOES a complete emulation of its input P, then it never answers and
fails.

If H DOES abort its emulation, it doesn't actually do a complete and
correct emulation, so your definition isn't applicable, and when we look
at the ACTUAL complete and correct emulation, we see it halts, so H was
wrong.

Note, you quoteing Linz on a computation that Halts actually shows that
your criterion is incorrect, as it never references a "simultion" or
"emulation" of the machine, but the machine it self, thus, since even
you agree that P(P) will halt if H(P,P) returns 0, Linz definition says
P(P) is a Halting computaiton in that case, so H(P,P) returning 0 is
incorrect for something actually claiming to be a Halting Decider.

Re: olcott, it's really simple [ succinct summation ]

<joRqK.7179$Sf2.3064@fx34.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Path: i2pn2.org!i2pn.org!usenet.blueworldhosting.com!feed1.usenet.blueworldhosting.com!peer01.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx34.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: olcott, it's really simple [ succinct summation ]
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <20220616181727.000072da@reddwarf.jmc> <871qvoju7d.fsf@bsb.me.uk>
<8dWdnZYgV_8eTjb_nZ2dnUU7_8zNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <8dWdnZYgV_8eTjb_nZ2dnUU7_8zNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 61
Message-ID: <joRqK.7179$Sf2.3064@fx34.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: Thu, 16 Jun 2022 22:10:22 -0400
X-Received-Bytes: 3211
 by: Richard Damon - Fri, 17 Jun 2022 02:10 UTC

On 6/16/22 9:06 PM, olcott wrote:
> On 6/16/2022 2:15 PM, Ben Bacarisse wrote:
>> Mr Flibble <flibble@reddwarf.jmc> writes:
>>
>>> Given olcott's code,
>>>
>>> #include <stdint.h>
>>> typedef void (*ptr)();
>>>
>>> void P(ptr x)
>>> {
>>>     if (H(x, x))
>>>       HERE: goto HERE;
>>>     return;
>>> }
>>>
>>> int main()
>>> {
>>>     Output("Input_Halts = ", H(P, P));
>>> }
>>>
>>> and olcott's assertion that H is a pure function and H(P,P) == 0,
>>> then, P should halt as H should also return 0 to P
>>
>> You mean P(P) should halt, and it does.  PO does not dispute this fact.
>> Not only has he posted a trace of P(P) halting, he has clearly stated
>> that H(P,P) == 0 "is the correct answer even though P(P) halts".[1]
>>
>>> (pure functions
>>> ALWAYS return the same result for the same arguments with no side
>>> effects). P doesn't halt so H is erroneous; olcott, it's really that
>>> simple.
>>
>> Except that he is now just asserting that H(P,P) == 0 is correct about
>> something else (the "correct simulation of the input to H(P,P)") and the
>> mistakes in that irrelevant statement are keeping him supplied with the
>> attention he craves.  You might consider not giving him what he wants.
>>
>> [1] Message-ID: <c8idnbFAF6C8QuP8nZ2dnUU7-avNnZ2d@giganews.com>
>>
>
> When a simulating halt decider rejects all inputs as non-halting
> whenever it correctly detects that its correct and complete simulation
> of its input would never reach the final state of this input then all
> [these] inputs (including pathological inputs) are decided correctly.
>
> *computation that halts* … the Turing machine will halt whenever it
> enters a final state. (Linz:1990:234)
>
> Linz, Peter 1990. An Introduction to Formal Languages and Automata.
> Lexington/Toronto: D. C. Heath and Company. (317-320)
>
>

Wrong, you can't talk about H's correcgt and complete emulation of its
input unless it actually does that. Until you can show how H does an
infinite number of steps of emulation in finite time to return the
answer, you are claiming an inpossibility.

Yes, if infinity was a finite number, all sorts of strange things can
happen, but it isn't.

1
server_pubkey.txt

rocksolid light 0.9.7
clearnet tor