Rocksolid Light

Welcome to novaBBS (click a section below)

mail  files  register  newsreader  groups  login

Message-ID:  

Counting in binary is just like counting in decimal -- if you are all thumbs. -- Glaser and Way


devel / comp.theory / No one has sufficiently addressed this H(P,P)==0

SubjectAuthor
* No one has sufficiently addressed this H(P,P)==0olcott
+* No one has sufficiently addressed this H(P,P)==0Mikko
|`* No one has sufficiently addressed this H(P,P)==0olcott
| `- No one has sufficiently addressed this H(P,P)==0Richard Damon
+* No one has sufficiently addressed this H(P,P)==0Richard Damon
|`* No one has sufficiently addressed this H(P,P)==0olcott
| `- No one has sufficiently addressed this H(P,P)==0Richard Damon
+* Proving that P(P) != the correct x86 emulation of the input to H(P,P)olcott
|`* Proving that P(P) != the correct x86 emulation of the input to H(P,P)Richard Damon
| `* Proving that P(P) != the correct x86 emulation of the input toolcott
|  `* Proving that P(P) != the correct x86 emulation of the input toRichard Damon
|   `* Proving that P(P) != the correct x86 emulation of the input toolcott
|    `* Proving that P(P) != the correct x86 emulation of the input toMr Flibble
|     `* Proving that P(P) != the correct x86 emulation of the input toolcott
|      `* Proving that P(P) != the correct x86 emulation of the input to H(P,P)Mr Flibble
|       `* Proving that P(P) != the correct x86 emulation of the input toolcott
|        `* Proving that P(P) != the correct x86 emulation of the input toRichard Damon
|         `* Proving that P(P) != the correct x86 emulation of the input toolcott
|          `* Proving that P(P) != the correct x86 emulation of the input toRichard Damon
|           `* Proving that P(P) != the correct x86 emulation of the input toolcott
|            `* Proving that P(P) != the correct x86 emulation of the input toRichard Damon
|             `* Proving that P(P) != the correct x86 emulation of the input toolcott
|              `* Proving that P(P) != the correct x86 emulation of the input toRichard Damon
|               `* Proving that P(P) != the correct x86 emulation of the input toolcott
|                `* Proving that P(P) != the correct x86 emulation of the input toRichard Damon
|                 `* Proving that P(P) != the correct x86 emulation of the input toolcott
|                  `* Proving that P(P) != the correct x86 emulation of the input toRichard Damon
|                   `* Proving that P(P) != the correct x86 emulation of the input toolcott
|                    +* Proving that P(P) != the correct x86 emulation of the input toMr Flibble
|                    |`* Proving that P(P) != the correct x86 emulation of the input toolcott
|                    | +* Proving that P(P) != the correct x86 emulation of the input to H(P,P)Mr Flibble
|                    | |`* Proving that P(P) != the correct x86 emulation of the input toolcott
|                    | | `* Proving that P(P) != the correct x86 emulation of the input toMr Flibble
|                    | |  `* Proving that P(P) != the correct x86 emulation of the input toolcott
|                    | |   +* Proving that P(P) != the correct x86 emulation of the input toMr Flibble
|                    | |   |`* Proving that P(P) != the correct x86 emulation of the input toolcott
|                    | |   | `* Proving that P(P) != the correct x86 emulation of the input toMr Flibble
|                    | |   |  +- Proving that P(P) != the correct x86 emulation of the input toolcott
|                    | |   |  `* Proving that P(P) != the correct x86 emulation of the input toolcott
|                    | |   |   +* Proving that P(P) != the correct x86 emulation of the input toMr Flibble
|                    | |   |   |`* Proving that P(P) != the correct x86 emulation of the input toolcott
|                    | |   |   | `* Proving that P(P) != the correct x86 emulation of the input toMr Flibble
|                    | |   |   |  `* Proving that P(P) != the correct x86 emulation of the input toolcott
|                    | |   |   |   +* Proving that P(P) != the correct x86 emulation of the input to H(P,P)Mr Flibble
|                    | |   |   |   |`* Proving that P(P) != the correct x86 emulation of the input toolcott
|                    | |   |   |   | +* Proving that P(P) != the correct x86 emulation of the input toMr Flibble
|                    | |   |   |   | |`* Proving that P(P) != the correct x86 emulation of the input toolcott
|                    | |   |   |   | | +* Proving that P(P) != the correct x86 emulation of the input to H(P,P)Mr Flibble
|                    | |   |   |   | | |+- Proving that P(P) != the correct x86 emulation of the input to H(P,P)Mr Flibble
|                    | |   |   |   | | |+* Proving that P(P) != the correct x86 emulation of the input toolcott
|                    | |   |   |   | | ||`* Proving that P(P) != the correct x86 emulation of the input to H(P,P)Mr Flibble
|                    | |   |   |   | | || `* Proving that P(P) != the correct x86 emulation of the input toolcott
|                    | |   |   |   | | ||  +* Proving that P(P) != the correct x86 emulation of the input to H(P,P)Mr Flibble
|                    | |   |   |   | | ||  |`* Proving that P(P) != the correct x86 emulation of the input toolcott
|                    | |   |   |   | | ||  | `* Proving that P(P) != the correct x86 emulation of the input to H(P,P)Mr Flibble
|                    | |   |   |   | | ||  |  +* Proving that P(P) != the correct x86 emulation of the input toolcott
|                    | |   |   |   | | ||  |  |`* Proving that P(P) != the correct x86 emulation of the input to H(P,P)Mr Flibble
|                    | |   |   |   | | ||  |  | `* Proving that P(P) != the correct x86 emulation of the input toolcott
|                    | |   |   |   | | ||  |  |  +* Proving that P(P) != the correct x86 emulation of the input to H(P,P)Mr Flibble
|                    | |   |   |   | | ||  |  |  |`* Proving that P(P) != the correct x86 emulation of the input toolcott
|                    | |   |   |   | | ||  |  |  | +* Proving that P(P) != the correct x86 emulation of the input toMr Flibble
|                    | |   |   |   | | ||  |  |  | |`* Proving that P(P) != the correct x86 emulation of the input toolcott
|                    | |   |   |   | | ||  |  |  | | +* Proving that P(P) != the correct x86 emulation of the input toMr Flibble
|                    | |   |   |   | | ||  |  |  | | |`* Proving that P(P) != the correct x86 emulation of the input toolcott
|                    | |   |   |   | | ||  |  |  | | | `* Proving that P(P) != the correct x86 emulation of the input toMr Flibble
|                    | |   |   |   | | ||  |  |  | | |  `* Proving that P(P) != the correct x86 emulation of the input toolcott
|                    | |   |   |   | | ||  |  |  | | |   +- Proving that P(P) != the correct x86 emulation of the input to H(P,P)Richard Damon
|                    | |   |   |   | | ||  |  |  | | |   `* Proving that P(P) != the correct x86 emulation of the input to H(P,P)Mr Flibble
|                    | |   |   |   | | ||  |  |  | | |    `* Proving that P(P) != the correct x86 emulation of the input toolcott
|                    | |   |   |   | | ||  |  |  | | |     +* Proving that P(P) != the correct x86 emulation of the input toMr Flibble
|                    | |   |   |   | | ||  |  |  | | |     |`* Proving that P(P) != the correct x86 emulation of the input toolcott
|                    | |   |   |   | | ||  |  |  | | |     | `* Proving that P(P) != the correct x86 emulation of the input toMr Flibble
|                    | |   |   |   | | ||  |  |  | | |     |  +* Proving that P(P) != the correct x86 emulation of the input toMr Flibble
|                    | |   |   |   | | ||  |  |  | | |     |  |`* Proving that P(P) != the correct x86 emulation of the input toolcott
|                    | |   |   |   | | ||  |  |  | | |     |  | `- Proving that P(P) != the correct x86 emulation of the input toRichard Damon
|                    | |   |   |   | | ||  |  |  | | |     |  `* Proving that P(P) != the correct x86 emulation of the input toolcott
|                    | |   |   |   | | ||  |  |  | | |     |   `* Proving that P(P) != the correct x86 emulation of the input toMr Flibble
|                    | |   |   |   | | ||  |  |  | | |     |    `* Proving that P(P) != the correct x86 emulation of the input toolcott
|                    | |   |   |   | | ||  |  |  | | |     |     `* Proving that P(P) != the correct x86 emulation of the input toMr Flibble
|                    | |   |   |   | | ||  |  |  | | |     |      `* Proving that P(P) != the correct x86 emulation of the input toolcott
|                    | |   |   |   | | ||  |  |  | | |     |       +- Proving that P(P) != the correct x86 emulation of the input toRichard Damon
|                    | |   |   |   | | ||  |  |  | | |     |       `* Proving that P(P) != the correct x86 emulation of the input toMr Flibble
|                    | |   |   |   | | ||  |  |  | | |     |        `* Proving that P(P) != the correct x86 emulation of the input toolcott
|                    | |   |   |   | | ||  |  |  | | |     |         +- Proving that P(P) != the correct x86 emulation of the input toMr Flibble
|                    | |   |   |   | | ||  |  |  | | |     |         `- Proving that P(P) != the correct x86 emulation of the input to H(P,P)Richard Damon
|                    | |   |   |   | | ||  |  |  | | |     `- Proving that P(P) != the correct x86 emulation of the input toRichard Damon
|                    | |   |   |   | | ||  |  |  | | `- Proving that P(P) != the correct x86 emulation of the input toRichard Damon
|                    | |   |   |   | | ||  |  |  | `- Proving that P(P) != the correct x86 emulation of the input toRichard Damon
|                    | |   |   |   | | ||  |  |  +* Proving that P(P) != the correct x86 emulation of the input toPython
|                    | |   |   |   | | ||  |  |  |`* Proving that P(P) != the correct x86 emulation of the input toolcott
|                    | |   |   |   | | ||  |  |  | `* Proving that P(P) != the correct x86 emulation of the input toPython
|                    | |   |   |   | | ||  |  |  |  `* Proving that P(P) != the correct x86 emulation of the input toolcott
|                    | |   |   |   | | ||  |  |  |   `- Proving that P(P) != the correct x86 emulation of the input toRichard Damon
|                    | |   |   |   | | ||  |  |  `- Proving that P(P) != the correct x86 emulation of the input toRichard Damon
|                    | |   |   |   | | ||  |  `- Proving that P(P) != the correct x86 emulation of the input to H(P,P)Dennis Bush
|                    | |   |   |   | | ||  `* Proving that P(P) != the correct x86 emulation of the input toPython
|                    | |   |   |   | | ||   `* Proving that P(P) != the correct x86 emulation of the input toolcott
|                    | |   |   |   | | ||    `* Proving that P(P) != the correct x86 emulation of the input to H(P,P)Mr Flibble
|                    | |   |   |   | | ||     `* Proving that P(P) != the correct x86 emulation of the input toolcott
|                    | |   |   |   | | ||      `* Proving that P(P) != the correct x86 emulation of the input toMr Flibble
|                    | |   |   |   | | ||       `- Proving that P(P) != the correct x86 emulation of the input toolcott
|                    | |   |   |   | | |`* Proving that P(P) != the correct x86 emulation of the input toolcott
|                    | |   |   |   | | `- Proving that P(P) != the correct x86 emulation of the input to H(P,P)Richard Damon
|                    | |   |   |   | `- Proving that P(P) != the correct x86 emulation of the input toRichard Damon
|                    | |   |   |   +- Proving that P(P) != the correct x86 emulation of the input toPython
|                    | |   |   |   `- Proving that P(P) != the correct x86 emulation of the input toRichard Damon
|                    | |   |   `- Proving that P(P) != the correct x86 emulation of the input toRichard Damon
|                    | |   `- Proving that P(P) != the correct x86 emulation of the input toRichard Damon
|                    | `* Proving that P(P) != the correct x86 emulation of the input toRichard Damon
|                    `* Proving that P(P) != the correct x86 emulation of the input toRichard Damon
+* Proving that P(P) != the correct x86 emulation of the input to H(P,P)Keith Thompson
`* Proving that P(P) != the correct x86 emulation of the input toolcott

Pages:12345
No one has sufficiently addressed this H(P,P)==0

<N8GdnUDJ0IRRxjz_nZ2dnUU7_8zNnZ2d@giganews.com>

 copy mid

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

 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: Wed, 08 Jun 2022 21:32:44 -0500
Date: Wed, 8 Jun 2022 21:32:43 -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
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
Content-Language: en-US
From: NoO...@NoWhere.com (olcott)
Subject: No one has sufficiently addressed this H(P,P)==0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Message-ID: <N8GdnUDJ0IRRxjz_nZ2dnUU7_8zNnZ2d@giganews.com>
Lines: 30
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-YweWpE+1syQBb9TIguLQwRxJ2lbeWI8tjk8D7lwYH+4s2CRf+MwRcGxgNSVQJ0QxZKYK3LqfgYj7d7F!SW/GrsMoEPeSHB75TEXPKOQk8UUwP7sOFthuuqvk2xKPqIbKyTm/Pp7gNxhOvt9ph+xGfGF6bS8F
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: 2207
 by: olcott - Thu, 9 Jun 2022 02:32 UTC

All fake rebuttals have been simply dismissing the verified facts
out-of-hand without showing any error. This is flat out dishonest.

That you really really don't believe what I am saying is no actual
rebuttal what-so-ever. Evaluating what I say using rhetoric instead of
reasoning is deceitful.

We have these three verified facts:

(1) A halt decider must compute the mapping from its input to an accept
reject state on the basis of the actual behavior specified by this input

(2) The ultimate measure of the behavior of the input to H(P,P) is the
correct x86 emulation of the input to H(P,P) by H.

(3) P(P) specifies entirely different behavior than the correct x86
emulation of the input to H(P,P) by H. This is verified by the provably
correct execution trace of each.

Therefore everyone that says that H must base its halt status decision
on the behavior of P(P) is conclusively proven wrong.

--
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: No one has sufficiently addressed this H(P,P)==0

<t7sg2m$rl2$1@dont-email.me>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!eternal-september.org!reader02.eternal-september.org!.POSTED!not-for-mail
From: mikko.le...@iki.fi (Mikko)
Newsgroups: comp.theory
Subject: Re: No one has sufficiently addressed this H(P,P)==0
Date: Thu, 9 Jun 2022 12:55:34 +0300
Organization: -
Lines: 30
Message-ID: <t7sg2m$rl2$1@dont-email.me>
References: <N8GdnUDJ0IRRxjz_nZ2dnUU7_8zNnZ2d@giganews.com>
MIME-Version: 1.0
Content-Type: text/plain; charset=iso-8859-1; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Info: reader02.eternal-september.org; posting-host="e7b273141289cb9a6bfadbc3c627d6dc";
logging-data="28322"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX1/G8H/HEopEc9ugJD6SEKGi"
User-Agent: Unison/2.2
Cancel-Lock: sha1:NRCkCXV5oP9W2KlymQa9FkzZ1+c=
 by: Mikko - Thu, 9 Jun 2022 09:55 UTC

On 2022-06-09 02:32:43 +0000, olcott said:

> All fake rebuttals have been simply dismissing the verified facts
> out-of-hand without showing any error. This is flat out dishonest.
>
> That you really really don't believe what I am saying is no actual
> rebuttal what-so-ever. Evaluating what I say using rhetoric instead of
> reasoning is deceitful.
>
> We have these three verified facts:
>
> (1) A halt decider must compute the mapping from its input to an accept
> reject state on the basis of the actual behavior specified by this input
>
> (2) The ultimate measure of the behavior of the input to H(P,P) is the
> correct x86 emulation of the input to H(P,P) by H.
>
> (3) P(P) specifies entirely different behavior than the correct x86
> emulation of the input to H(P,P) by H. This is verified by the provably
> correct execution trace of each.
>
> Therefore everyone that says that H must base its halt status decision
> on the behavior of P(P) is conclusively proven wrong.

It has been addressed more than sufficiently. If you think otherwise you
should read the responses again. If something remains unclear you may ask
specific questions.

Mikko

Re: No one has sufficiently addressed this H(P,P)==0

<ShkoK.116385$5fVf.20744@fx09.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Path: i2pn2.org!i2pn.org!aioe.org!news.uzoreto.com!tr2.eu1.usenetexpress.com!feeder.usenetexpress.com!tr1.iad1.usenetexpress.com!peer02.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx09.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: No one has sufficiently addressed this H(P,P)==0
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <N8GdnUDJ0IRRxjz_nZ2dnUU7_8zNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <N8GdnUDJ0IRRxjz_nZ2dnUU7_8zNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Lines: 53
Message-ID: <ShkoK.116385$5fVf.20744@fx09.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, 9 Jun 2022 06:52:33 -0400
X-Received-Bytes: 2964
 by: Richard Damon - Thu, 9 Jun 2022 10:52 UTC

On 6/8/22 10:32 PM, olcott wrote:
> All fake rebuttals have been simply dismissing the verified facts
> out-of-hand without showing any error. This is flat out dishonest.
>
> That you really really don't believe what I am saying is no actual
> rebuttal what-so-ever. Evaluating what I say using rhetoric instead of
> reasoning is deceitful.
>
> We have these three verified facts:
>
> (1) A halt decider must compute the mapping from its input to an accept
> reject state on the basis of the actual behavior specified by this input

And actual behavior of the input to a Halt decider, since it is a
representation of a computation, is what that computation does.
>
> (2) The ultimate measure of the behavior of the input to H(P,P) is the
> correct x86 emulation of the input to H(P,P) by H.
>

And correct emulation is defined by what that input would do if atually
Run, so the corrct emulation of the input to H(P,P) would be P(P).

> (3) P(P) specifies entirely different behavior than the correct x86
> emulation of the input to H(P,P) by H. This is verified by the provably
> correct execution trace of each.
>

Nope, doen't see where you get this. Read my responce to the previous
statement.

Please point out where they differ, and WHY they differ if one is a
CORRECT emulation of the other, and are based on the exact same code.

I think the key point is that you refuse to correctly emulate the call H
instruction, because you don't quite understand the meaning of what a
program is, or what correct emulation means.

> Therefore everyone that says that H must base its halt status decision
> on the behavior of P(P) is conclusively proven wrong.
>
>
>

Nope, until you can figure out how to exp[alin that last one, you are
proven to be a LIAR.

You like to make *claims* that things are obvious, when they are not
actually true. This is a sign that you don't really understand how
things actually work and are inserting your own misconceptions and
ignoring the actual behaviors.

Re: No one has sufficiently addressed this H(P,P)==0

<44idnfW-vMH8lD__nZ2dnUU7_8xh4p2d@giganews.com>

 copy mid

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

 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, 09 Jun 2022 09:53:21 -0500
Date: Thu, 9 Jun 2022 09:53:20 -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: No one has sufficiently addressed this H(P,P)==0
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <N8GdnUDJ0IRRxjz_nZ2dnUU7_8zNnZ2d@giganews.com>
<t7sg2m$rl2$1@dont-email.me>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <t7sg2m$rl2$1@dont-email.me>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Message-ID: <44idnfW-vMH8lD__nZ2dnUU7_8xh4p2d@giganews.com>
Lines: 42
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-TmfCnJgoFZG8pZvQwcsZJH4JwbyeqECjDx4BEr7pLm13uJ9mFRbHdC+Riq4gtTvHC3VdGrR6zAtgs8d!obgwCIDMi+EIkDGqi09iOxJvjHZW1IkBffnilepygkrYG3hZuYpMcom5fYgxG92nXR2hQxGTolHo
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: 2818
 by: olcott - Thu, 9 Jun 2022 14:53 UTC

On 6/9/2022 4:55 AM, Mikko wrote:
> On 2022-06-09 02:32:43 +0000, olcott said:
>
>> All fake rebuttals have been simply dismissing the verified facts
>> out-of-hand without showing any error. This is flat out dishonest.
>>
>> That you really really don't believe what I am saying is no actual
>> rebuttal what-so-ever. Evaluating what I say using rhetoric instead of
>> reasoning is deceitful.
>>
>> We have these three verified facts:
>>
>> (1) A halt decider must compute the mapping from its input to an
>> accept reject state on the basis of the actual behavior specified by
>> this input
>>
>> (2) The ultimate measure of the behavior of the input to H(P,P) is the
>> correct x86 emulation of the input to H(P,P) by H.
>>
>> (3) P(P) specifies entirely different behavior than the correct x86
>> emulation of the input to H(P,P) by H. This is verified by the
>> provably correct execution trace of each.
>>
>> Therefore everyone that says that H must base its halt status decision
>> on the behavior of P(P) is conclusively proven wrong.
>
> It has been addressed more than sufficiently. If you think otherwise you
> should read the responses again. If something remains unclear you may ask
> specific questions.
>
> Mikko
>

This is exactly the dishonest dodge prey that I expected.
All of the fake rebuttals were based on denying the verifiable facts.

--
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: No one has sufficiently addressed this H(P,P)==0

<14ooK.116388$5fVf.16932@fx09.iad>

 copy mid

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

 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!fx09.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: No one has sufficiently addressed this H(P,P)==0
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <N8GdnUDJ0IRRxjz_nZ2dnUU7_8zNnZ2d@giganews.com>
<t7sg2m$rl2$1@dont-email.me> <44idnfW-vMH8lD__nZ2dnUU7_8xh4p2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <44idnfW-vMH8lD__nZ2dnUU7_8xh4p2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Lines: 76
Message-ID: <14ooK.116388$5fVf.16932@fx09.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, 9 Jun 2022 11:10:53 -0400
X-Received-Bytes: 4226
 by: Richard Damon - Thu, 9 Jun 2022 15:10 UTC

On 6/9/22 10:53 AM, olcott wrote:
> On 6/9/2022 4:55 AM, Mikko wrote:
>> On 2022-06-09 02:32:43 +0000, olcott said:
>>
>>> All fake rebuttals have been simply dismissing the verified facts
>>> out-of-hand without showing any error. This is flat out dishonest.
>>>
>>> That you really really don't believe what I am saying is no actual
>>> rebuttal what-so-ever. Evaluating what I say using rhetoric instead
>>> of reasoning is deceitful.
>>>
>>> We have these three verified facts:
>>>
>>> (1) A halt decider must compute the mapping from its input to an
>>> accept reject state on the basis of the actual behavior specified by
>>> this input
>>>
>>> (2) The ultimate measure of the behavior of the input to H(P,P) is
>>> the correct x86 emulation of the input to H(P,P) by H.
>>>
>>> (3) P(P) specifies entirely different behavior than the correct x86
>>> emulation of the input to H(P,P) by H. This is verified by the
>>> provably correct execution trace of each.
>>>
>>> Therefore everyone that says that H must base its halt status
>>> decision on the behavior of P(P) is conclusively proven wrong.
>>
>> It has been addressed more than sufficiently. If you think otherwise you
>> should read the responses again. If something remains unclear you may ask
>> specific questions.
>>
>> Mikko
>>
>
> This is exactly the dishonest dodge prey that I expected.
> All of the fake rebuttals were based on denying the verifiable facts.
>

No, they are based on the ACTUALLY verifyable facts.

YOUR assertions are the ones that ignore the verifyable facts.

Unless you can point to the ACTUAL LOGICAL error that they make, and not
just revert back to you claims, based on WRONG definition, you are shown
to be the liar.

Other people say "This is wrong because of ..."

Your only reply is that "No, it is just obviously correct" and repeat
the "proof" that they were showing was based on incorrect
conditions/definitions.

All you have "proven" is that you don't understand what a proof actually
is. You seem to think that formal logic is just based on rhetorical
arguments, and he that shouts the loudest wins.

Sorry, but the rules are the rules, and claiming that some other rules
should apply, without actually showing the actual rules that make them
apply, are just fabrications and proof that you don't know what you are
talking about.

Yes, meaning of words are important, but it is the accepted TECHNICAL
meaning of the words, and you need to actually be able to show that
definition.

Like, Halting is defined in terms of the actions of a Machine, and thus,
it ISN'T based on a simulation, since that isn't the behavior of the
machine. Only when your simulation is defined/proven to actually behave
the same as the actual machine can you subsitute it.

That means that, if H is defined to be a Halt Decider, H(P,P) returning
0 can NOT be correct if P(P) Halts, as the MEANING of the input P,P is
the representation of the computation P(P), and if P(P) Halts (which is
does if H(P,P) returns 0) then a correct simuation of the input to H
must show it halts too. Anything else can not be a simulation that can
be used to define a correct answer.

Re: No one has sufficiently addressed this H(P,P)==0

<htednYn5gNTGjD__nZ2dnUU7_8zNnZ2d@giganews.com>

 copy mid

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

 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, 09 Jun 2022 10:27:23 -0500
Date: Thu, 9 Jun 2022 10: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: No one has sufficiently addressed this H(P,P)==0
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <N8GdnUDJ0IRRxjz_nZ2dnUU7_8zNnZ2d@giganews.com>
<ShkoK.116385$5fVf.20744@fx09.iad>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <ShkoK.116385$5fVf.20744@fx09.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Message-ID: <htednYn5gNTGjD__nZ2dnUU7_8zNnZ2d@giganews.com>
Lines: 96
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-CUucrrbZiggZir/zNQpWXLrie7qHS10g0gP2LQI0cW/Rs2SfaUGwtxF5xTzA7AnOp3eWH/5gwZurf6a!4KlLSY7Kt8fBwdSkR7wbehE+HkQECRh26aFy507YbEbVpkgj7O65WTdS+iJlb546rvWjNX2AFg5v
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: 5025
 by: olcott - Thu, 9 Jun 2022 15:27 UTC

On 6/9/2022 5:52 AM, Richard Damon wrote:
>
> On 6/8/22 10:32 PM, olcott wrote:
>> All fake rebuttals have been simply dismissing the verified facts
>> out-of-hand without showing any error. This is flat out dishonest.
>>
>> That you really really don't believe what I am saying is no actual
>> rebuttal what-so-ever. Evaluating what I say using rhetoric instead of
>> reasoning is deceitful.
>>
>> We have these three verified facts:
>>
>> (1) A halt decider must compute the mapping from its input to an
>> accept reject state on the basis of the actual behavior specified by
>> this input
>
> And actual behavior of the input to a Halt decider, since it is a
> representation of a computation, is what that computation does.

Computer science textbooks may say this, software engineering does not
agree. The input to a software function is a specific byte string.

>>
>> (2) The ultimate measure of the behavior of the input to H(P,P) is the
>> correct x86 emulation of the input to H(P,P) by H.
>>
>
> And correct emulation is defined by what that input would do if atually
> Run, so the corrct emulation of the input to H(P,P) would be P(P).
>

In software engineering the behavior of the input finite string of
machine code is correctly determined by its correct x86 emulation by H.

>> (3) P(P) specifies entirely different behavior than the correct x86
>> emulation of the input to H(P,P) by H. This is verified by the
>> provably correct execution trace of each.
>>
>
> Nope, doen't see where you get this. Read my responce to the previous
> statement.
>
> Please point out where they differ, and WHY they differ if one is a
> CORRECT emulation of the other, and are based on the exact same code.
>

I have done this several times you are simply not bright enough to
understand the execution traces.

> I think the key point is that you refuse to correctly emulate the call H
> instruction, because you don't quite understand the meaning of what a
> program is, or what correct emulation means.
>

When we have proof that H(P,P) derives this sequence
// H emulates the first seven instructions of P
....[00001352][0021233e][00212342] 55 push ebp // enter P
....[00001353][0021233e][00212342] 8bec mov ebp,esp
....[00001355][0021233e][00212342] 8b4508 mov eax,[ebp+08]
....[00001358][0021233a][00001352] 50 push eax // push P
....[00001359][0021233a][00001352] 8b4d08 mov ecx,[ebp+08]
....[0000135c][00212336][00001352] 51 push ecx // push P
....[0000135d][00212332][00001362] e840feffff call 000011a2 // call H

Then people that are not dumber than a box of rocks would know that line
seven above would repeat this sequence.

>
>> Therefore everyone that says that H must base its halt status decision
>> on the behavior of P(P) is conclusively proven wrong.
>>
>>
>>
>
> Nope, until you can figure out how to exp[alin that last one, you are
> proven to be a LIAR.
>

I have done this several times and you are simply not bright enough to
understand the execution traces.

> You like to make *claims* that things are obvious, when they are not
> actually true. This is a sign that you don't really understand how
> things actually work and are inserting your own misconceptions and
> ignoring the actual behaviors.

You are too stupid to understand that a partial x86 emulation of an
input does correctly predict that a complete emulation would never halt.
This makes you too stupid to understand what I am saying.

--
Copyright 2022 Pete Olcott

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

Proving that P(P) != the correct x86 emulation of the input to H(P,P)

<nvudncJwjNiNiz__nZ2dnUU7_81g4p2d@giganews.com>

 copy mid

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

 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, 09 Jun 2022 10:47:28 -0500
Date: Thu, 9 Jun 2022 10:47:27 -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: Proving that P(P) != the correct x86 emulation of the input to H(P,P)
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <N8GdnUDJ0IRRxjz_nZ2dnUU7_8zNnZ2d@giganews.com>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <N8GdnUDJ0IRRxjz_nZ2dnUU7_8zNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <nvudncJwjNiNiz__nZ2dnUU7_81g4p2d@giganews.com>
Lines: 87
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-ug0vu5yhlPVoNTEklhp2iy/RfRanEyUh7TFfuS8tCDjG8CVgSSpdseDyyaCkj5YECZoiQ/8T7MfjoGm!QTD/tcbjhlGyguy2U5HpXoHal7bga06Nkw+iFKq1+JujGOiNzswnSqQRL9DNxtNRFWZ55kvn//CZ
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: 5259
 by: olcott - Thu, 9 Jun 2022 15:47 UTC

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

int main()
{ P(P);
}

_P()
[000012e7](01) 55 push ebp
[000012e8](02) 8bec mov ebp,esp
[000012ea](03) 8b4508 mov eax,[ebp+08]
[000012ed](01) 50 push eax
[000012ee](03) 8b4d08 mov ecx,[ebp+08]
[000012f1](01) 51 push ecx
[000012f2](05) e880feffff call 00001177 // call H
[000012f7](03) 83c408 add esp,+08
[000012fa](02) 85c0 test eax,eax
[000012fc](02) 7402 jz 00001300
[000012fe](02) ebfe jmp 000012fe
[00001300](01) 5d pop ebp
[00001301](01) c3 ret
Size in bytes:(0027) [00001301]

_main()
[00001307](01) 55 push ebp
[00001308](02) 8bec mov ebp,esp
[0000130a](05) 68e7120000 push 000012e7 // push P
[0000130f](05) e8d3ffffff call 000012e7 // call P
[00001314](03) 83c404 add esp,+04
[00001317](02) 33c0 xor eax,eax
[00001319](01) 5d pop ebp
[0000131a](01) c3 ret
Size in bytes:(0020) [0000131a]

machine stack stack machine assembly
address address data code language
======== ======== ======== ========= =============
[00001307][00102190][00000000] 55 push ebp
[00001308][00102190][00000000] 8bec mov ebp,esp
[0000130a][0010218c][000012e7] 68e7120000 push 000012e7 // push P
[0000130f][00102188][00001314] e8d3ffffff call 000012e7 // call P
[000012e7][00102184][00102190] 55 push ebp // enter executed P
[000012e8][00102184][00102190] 8bec mov ebp,esp
[000012ea][00102184][00102190] 8b4508 mov eax,[ebp+08]
[000012ed][00102180][000012e7] 50 push eax // push P
[000012ee][00102180][000012e7] 8b4d08 mov ecx,[ebp+08]
[000012f1][0010217c][000012e7] 51 push ecx // push P
[000012f2][00102178][000012f7] e880feffff call 00001177 // call H

Begin Local Halt Decider Simulation Execution Trace Stored at:212244
[000012e7][00212230][00212234] 55 push ebp // enter emulated P
[000012e8][00212230][00212234] 8bec mov ebp,esp
[000012ea][00212230][00212234] 8b4508 mov eax,[ebp+08]
[000012ed][0021222c][000012e7] 50 push eax // push P
[000012ee][0021222c][000012e7] 8b4d08 mov ecx,[ebp+08]
[000012f1][00212228][000012e7] 51 push ecx // push P
[000012f2][00212224][000012f7] e880feffff call 00001177 // call H
[000012e7][0025cc58][0025cc5c] 55 push ebp // enter emulated P
[000012e8][0025cc58][0025cc5c] 8bec mov ebp,esp
[000012ea][0025cc58][0025cc5c] 8b4508 mov eax,[ebp+08]
[000012ed][0025cc54][000012e7] 50 push eax // push P
[000012ee][0025cc54][000012e7] 8b4d08 mov ecx,[ebp+08]
[000012f1][0025cc50][000012e7] 51 push ecx // push P
[000012f2][0025cc4c][000012f7] e880feffff call 00001177 // call H
Local Halt Decider: Infinite Recursion Detected Simulation Stopped

It is completely obvious that when H(P,P) correctly emulates its input
that it must emulate the first seven instructions of P. Because the
seventh instruction of P repeats this process we know with complete
certainty that the correct and complete emulation of P by H would never
reach its final “ret” instruction, thus never halts.

[000012f7][00102184][00102190] 83c408 add esp,+08
[000012fa][00102184][00102190] 85c0 test eax,eax
[000012fc][00102184][00102190] 7402 jz 00001300
[00001300][00102188][00001314] 5d pop ebp
[00001301][0010218c][000012e7] c3 ret // executed P halts
[00001314][00102190][00000000] 83c404 add esp,+04
[00001317][00102190][00000000] 33c0 xor eax,eax
[00001319][00102194][00100000] 5d pop ebp
[0000131a][00102198][00000000] c3 ret // main() halts
Number of Instructions Executed(15900)

Re: No one has sufficiently addressed this H(P,P)==0

<DdpoK.116971$5fVf.27640@fx09.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Path: i2pn2.org!rocksolid2!i2pn.org!aioe.org!news.uzoreto.com!tr1.eu1.usenetexpress.com!feeder.usenetexpress.com!tr3.iad1.usenetexpress.com!peer01.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx09.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: No one has sufficiently addressed this H(P,P)==0
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <N8GdnUDJ0IRRxjz_nZ2dnUU7_8zNnZ2d@giganews.com> <ShkoK.116385$5fVf.20744@fx09.iad> <htednYn5gNTGjD__nZ2dnUU7_8zNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <htednYn5gNTGjD__nZ2dnUU7_8zNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 164
Message-ID: <DdpoK.116971$5fVf.27640@fx09.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, 9 Jun 2022 12:29:23 -0400
X-Received-Bytes: 7276
 by: Richard Damon - Thu, 9 Jun 2022 16:29 UTC

On 6/9/22 11:27 AM, olcott wrote:
> On 6/9/2022 5:52 AM, Richard Damon wrote:
>>
>> On 6/8/22 10:32 PM, olcott wrote:
>>> All fake rebuttals have been simply dismissing the verified facts
>>> out-of-hand without showing any error. This is flat out dishonest.
>>>
>>> That you really really don't believe what I am saying is no actual
>>> rebuttal what-so-ever. Evaluating what I say using rhetoric instead
>>> of reasoning is deceitful.
>>>
>>> We have these three verified facts:
>>>
>>> (1) A halt decider must compute the mapping from its input to an
>>> accept reject state on the basis of the actual behavior specified by
>>> this input
>>
>> And actual behavior of the input to a Halt decider, since it is a
>> representation of a computation, is what that computation does.
>
> Computer science textbooks may say this, software engineering does not
> agree. The input to a software function is a specific byte string.

Do you have an ACTUAL reference for this?

A "Byte String" by itself has no behavior.

IF you mean the byte string as interpreated as x86 code, and the input
parameter, then what is the differce?

Remember, either the pointer doesn't limit the data accessed via that
pointer, and thus the "input" includes the bytes of the code of H, or
the byte string does limit the data accessed, and then the byte string
doesn't actually specify the behavior of a program as it reference data
that is not defined.

The "Byte Sequcence" can't reference "H by name", so you can't use that
in its interpretation.

>
>>>
>>> (2) The ultimate measure of the behavior of the input to H(P,P) is
>>> the correct x86 emulation of the input to H(P,P) by H.
>>>
>>
>> And correct emulation is defined by what that input would do if
>> atually Run, so the corrct emulation of the input to H(P,P) would be
>> P(P).
>>
>
> In software engineering the behavior of the input finite string of
> machine code is correctly determined by its correct x86 emulation by H.

Right, and that MUST include tracing through ALL the code that P uses,
including that of H.

If H can't trace through itself, then it fails to be able to be that
requried correct emualtor.

>
>>> (3) P(P) specifies entirely different behavior than the correct x86
>>> emulation of the input to H(P,P) by H. This is verified by the
>>> provably correct execution trace of each.
>>>
>>
>> Nope, doen't see where you get this. Read my responce to the previous
>> statement.
>>
>> Please point out where they differ, and WHY they differ if one is a
>> CORRECT emulation of the other, and are based on the exact same code.
>>
>
> I have done this several times you are simply not bright enough to
> understand the execution traces.

Nope, you don't provide a CORRECT emulation of the PROGRAM P, or what is
specified by the byte string you claim.

The CORRECT emulation either needs to "trap" for a reference of code
outside the provided byte string, or it needs to actually emulate the
code that the "call H" instruction jumps to.

THAT is the DEFINITION of "CORRECT EMULATION", as that is what the x86
processor does.

You are just playing deceitful word games with what you CLAIM
(incorrectly) to be a correct trace.

>
>> I think the key point is that you refuse to correctly emulate the call
>> H instruction, because you don't quite understand the meaning of what
>> a program is, or what correct emulation means.
>>
>
> When we have proof that H(P,P) derives this sequence
> // H emulates the first seven instructions of P
> ...[00001352][0021233e][00212342] 55         push ebp      // enter P
> ...[00001353][0021233e][00212342] 8bec       mov ebp,esp
> ...[00001355][0021233e][00212342] 8b4508     mov eax,[ebp+08]
> ...[00001358][0021233a][00001352] 50         push eax      // push P
> ...[00001359][0021233a][00001352] 8b4d08     mov ecx,[ebp+08]
> ...[0000135c][00212336][00001352] 51         push ecx      // push P
> ...[0000135d][00212332][00001362] e840feffff call 000011a2 // call H
>
> Then people that are not dumber than a box of rocks would know that line
> seven above would repeat this sequence.

Boy, are you being thick. EVERY aggress this is the first 7 instructions
emulated.

Where you err, is what is next.

A call 000011a2 instruction MUST be followed by the instruction that is
at 000011a2, or the emulation is NOT a "CORRECT EMULATION"

Please provide an relaible reference if you disagree.

Failure is just proof that you are a liar.

>
>>
>>> Therefore everyone that says that H must base its halt status
>>> decision on the behavior of P(P) is conclusively proven wrong.
>>>
>>>
>>>
>>
>> Nope, until you can figure out how to exp[alin that last one, you are
>> proven to be a LIAR.
>>
>
> I have done this several times and you are simply not bright enough to
> understand the execution traces.

Nope, you never do.

As above, you try to divert attention with a Red Herring of a piece that
there is no disagreement on, or you just repeat your claim.

You have NOT shown how the correct emuation of the next instruction is
NOT the emulation of the instruction at 000011a2.

>
>> You like to make *claims* that things are obvious, when they are not
>> actually true. This is a sign that you don't really understand how
>> things actually work and are inserting your own misconceptions and
>> ignoring the actual behaviors.
>
> You are too stupid to understand that a partial x86 emulation of an
> input does correctly predict that a complete emulation would never halt.
> This makes you too stupid to understand what I am saying.
>

It can for some machines, it doesn't for P, as is proven by the fact
that P(P) actually Halts if H(P,P) returns 0. Even you have agreed to this.

You can not show that something false is true, at least not if your
logic system has stayed consistent.

You claim that fact isn't applicable, but it is by the definition, and
unless you can give an ACTUAL PROOF (starting from the agreed
fundamental truths of Computation Theory), your claim is just a
statement of falsehood, and thus a LIE.

Re: Proving that P(P) != the correct x86 emulation of the input to H(P,P)

<bipoK.10513$Vxw.6751@fx07.iad>

 copy mid

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

 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!tr2.eu1.usenetexpress.com!feeder.usenetexpress.com!tr3.iad1.usenetexpress.com!peer01.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx07.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0) Gecko/20100101 Thunderbird/91.10.0
Subject: Re: Proving that P(P) != the correct x86 emulation of the input to H(P,P)
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <N8GdnUDJ0IRRxjz_nZ2dnUU7_8zNnZ2d@giganews.com> <nvudncJwjNiNiz__nZ2dnUU7_81g4p2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <nvudncJwjNiNiz__nZ2dnUU7_81g4p2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 117
Message-ID: <bipoK.10513$Vxw.6751@fx07.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, 9 Jun 2022 12:34:15 -0400
X-Received-Bytes: 6524
 by: Richard Damon - Thu, 9 Jun 2022 16:34 UTC

On 6/9/22 11:47 AM, olcott wrote:
> void P(u32 x)
> {
>   if (H(x, x))
>     HERE: goto HERE;
>   return;
> }
>
> int main()
> {
>   P(P);
> }
>
> _P()
> [000012e7](01)  55              push ebp
> [000012e8](02)  8bec            mov ebp,esp
> [000012ea](03)  8b4508          mov eax,[ebp+08]
> [000012ed](01)  50              push eax
> [000012ee](03)  8b4d08          mov ecx,[ebp+08]
> [000012f1](01)  51              push ecx
> [000012f2](05)  e880feffff      call 00001177 // call H
> [000012f7](03)  83c408          add esp,+08
> [000012fa](02)  85c0            test eax,eax
> [000012fc](02)  7402            jz 00001300
> [000012fe](02)  ebfe            jmp 000012fe
> [00001300](01)  5d              pop ebp
> [00001301](01)  c3              ret
> Size in bytes:(0027) [00001301]
>
> _main()
> [00001307](01)  55              push ebp
> [00001308](02)  8bec            mov ebp,esp
> [0000130a](05)  68e7120000      push 000012e7 // push P
> [0000130f](05)  e8d3ffffff      call 000012e7 // call P
> [00001314](03)  83c404          add esp,+04
> [00001317](02)  33c0            xor eax,eax
> [00001319](01)  5d              pop ebp
> [0000131a](01)  c3              ret
> Size in bytes:(0020) [0000131a]
>
>  machine   stack     stack     machine    assembly
>  address   address   data      code       language
>  ========  ========  ========  =========  =============
> [00001307][00102190][00000000] 55         push ebp
> [00001308][00102190][00000000] 8bec       mov ebp,esp
> [0000130a][0010218c][000012e7] 68e7120000 push 000012e7 // push P
> [0000130f][00102188][00001314] e8d3ffffff call 000012e7 // call P
> [000012e7][00102184][00102190] 55         push ebp      // enter executed P
> [000012e8][00102184][00102190] 8bec       mov ebp,esp
> [000012ea][00102184][00102190] 8b4508     mov eax,[ebp+08]
> [000012ed][00102180][000012e7] 50         push eax      // push P
> [000012ee][00102180][000012e7] 8b4d08     mov ecx,[ebp+08]
> [000012f1][0010217c][000012e7] 51         push ecx      // push P
> [000012f2][00102178][000012f7] e880feffff call 00001177 // call H
>
> Begin Local Halt Decider Simulation   Execution Trace Stored at:212244
> [000012e7][00212230][00212234] 55          push ebp      // enter
> emulated P
> [000012e8][00212230][00212234] 8bec        mov ebp,esp
> [000012ea][00212230][00212234] 8b4508      mov eax,[ebp+08]
> [000012ed][0021222c][000012e7] 50          push eax      // push P
> [000012ee][0021222c][000012e7] 8b4d08      mov ecx,[ebp+08]
> [000012f1][00212228][000012e7] 51          push ecx      // push P
> [000012f2][00212224][000012f7] e880feffff  call 00001177 // call H

So, by what instruction reference manual is a call 00001177 followedby
the execution of the instruction at 000012e7.

Your "CPU" is broken, or emulation incorrect.

FAIL.

> [000012e7][0025cc58][0025cc5c] 55          push ebp      // enter
> emulated P
> [000012e8][0025cc58][0025cc5c] 8bec        mov ebp,esp
> [000012ea][0025cc58][0025cc5c] 8b4508      mov eax,[ebp+08]
> [000012ed][0025cc54][000012e7] 50          push eax      // push P
> [000012ee][0025cc54][000012e7] 8b4d08      mov ecx,[ebp+08]
> [000012f1][0025cc50][000012e7] 51          push ecx      // push P
> [000012f2][0025cc4c][000012f7] e880feffff  call 00001177 // call H
> Local Halt Decider: Infinite Recursion Detected Simulation Stopped
>
> It is completely obvious that when H(P,P) correctly emulates its input
> that it must emulate the first seven instructions of P. Because the
> seventh instruction of P repeats this process we know with complete
> certainty that the correct and complete emulation of P by H would never
> reach its final “ret” instruction, thus never halts.

Problem, the 7th intruction DOESN't "Just repeat the procedure", because
that H always has the option to abort its simulation, just like this
onne did, and return to its P and see it halt.

All you have shown is that either:
H isn't a computation, not behaving the same for all copies given the
same input, and thus, by definition, nat a halt decider, or

H doesn't CORRECT analysis its simulation of its input.

>
> [000012f7][00102184][00102190] 83c408      add esp,+08
> [000012fa][00102184][00102190] 85c0        test eax,eax
> [000012fc][00102184][00102190] 7402        jz 00001300
> [00001300][00102188][00001314] 5d          pop ebp
> [00001301][0010218c][000012e7] c3          ret           // executed P
> halts
> [00001314][00102190][00000000] 83c404      add esp,+04
> [00001317][00102190][00000000] 33c0        xor eax,eax
> [00001319][00102194][00100000] 5d          pop ebp
> [0000131a][00102198][00000000] c3          ret          // main() halts
> Number of Instructions Executed(15900)

And thus at the end, your trace shows that P(P) Halted, and thus the
CORRECT answer for H(P,P) needs to be 1.

Your logic, as pointed out above, is UNSOUND.

YOU FAIL.

Re: Proving that P(P) != the correct x86 emulation of the input to H(P,P)

<jdydnWlvi_kquD__nZ2dnUU7_8zNnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Thu, 09 Jun 2022 11:54:15 -0500
Date: Thu, 9 Jun 2022 11:54:13 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.10.0
Subject: Re: Proving that P(P) != the correct x86 emulation of the input to
H(P,P)
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <N8GdnUDJ0IRRxjz_nZ2dnUU7_8zNnZ2d@giganews.com>
<nvudncJwjNiNiz__nZ2dnUU7_81g4p2d@giganews.com>
<bipoK.10513$Vxw.6751@fx07.iad>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <bipoK.10513$Vxw.6751@fx07.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <jdydnWlvi_kquD__nZ2dnUU7_8zNnZ2d@giganews.com>
Lines: 108
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-JXwDBG8SZZ4EYo7W1sXj1UckXdRjyqrOO38PlDyd3JDLK9y8OXX1KYuOSpgQbJDRsUGY6L5GiN+IdDB!hnr5rRMIBsP6jk8hWTQJZXTBPuUTiIe8IxEOSaqpW2ifI8nft2kezhv2k0E17bEY6DNyBZA1I7Re
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: 6348
 by: olcott - Thu, 9 Jun 2022 16:54 UTC

On 6/9/2022 11:34 AM, Richard Damon wrote:
> On 6/9/22 11:47 AM, olcott wrote:
>> void P(u32 x)
>> {
>>    if (H(x, x))
>>      HERE: goto HERE;
>>    return;
>> }
>>
>> int main()
>> {
>>    P(P);
>> }
>>
>> _P()
>> [000012e7](01)  55              push ebp
>> [000012e8](02)  8bec            mov ebp,esp
>> [000012ea](03)  8b4508          mov eax,[ebp+08]
>> [000012ed](01)  50              push eax
>> [000012ee](03)  8b4d08          mov ecx,[ebp+08]
>> [000012f1](01)  51              push ecx
>> [000012f2](05)  e880feffff      call 00001177 // call H
>> [000012f7](03)  83c408          add esp,+08
>> [000012fa](02)  85c0            test eax,eax
>> [000012fc](02)  7402            jz 00001300
>> [000012fe](02)  ebfe            jmp 000012fe
>> [00001300](01)  5d              pop ebp
>> [00001301](01)  c3              ret
>> Size in bytes:(0027) [00001301]
>>
>> _main()
>> [00001307](01)  55              push ebp
>> [00001308](02)  8bec            mov ebp,esp
>> [0000130a](05)  68e7120000      push 000012e7 // push P
>> [0000130f](05)  e8d3ffffff      call 000012e7 // call P
>> [00001314](03)  83c404          add esp,+04
>> [00001317](02)  33c0            xor eax,eax
>> [00001319](01)  5d              pop ebp
>> [0000131a](01)  c3              ret
>> Size in bytes:(0020) [0000131a]
>>
>>   machine   stack     stack     machine    assembly
>>   address   address   data      code       language
>>   ========  ========  ========  =========  =============
>> [00001307][00102190][00000000] 55         push ebp
>> [00001308][00102190][00000000] 8bec       mov ebp,esp
>> [0000130a][0010218c][000012e7] 68e7120000 push 000012e7 // push P
>> [0000130f][00102188][00001314] e8d3ffffff call 000012e7 // call P
>> [000012e7][00102184][00102190] 55         push ebp      // enter
>> executed P
>> [000012e8][00102184][00102190] 8bec       mov ebp,esp
>> [000012ea][00102184][00102190] 8b4508     mov eax,[ebp+08]
>> [000012ed][00102180][000012e7] 50         push eax      // push P
>> [000012ee][00102180][000012e7] 8b4d08     mov ecx,[ebp+08]
>> [000012f1][0010217c][000012e7] 51         push ecx      // push P
>> [000012f2][00102178][000012f7] e880feffff call 00001177 // call H
>>
>> Begin Local Halt Decider Simulation   Execution Trace Stored at:212244
>> [000012e7][00212230][00212234] 55          push ebp      // enter
>> emulated P
>> [000012e8][00212230][00212234] 8bec        mov ebp,esp
>> [000012ea][00212230][00212234] 8b4508      mov eax,[ebp+08]
>> [000012ed][0021222c][000012e7] 50          push eax      // push P
>> [000012ee][0021222c][000012e7] 8b4d08      mov ecx,[ebp+08]
>> [000012f1][00212228][000012e7] 51          push ecx      // push P
>> [000012f2][00212224][000012f7] e880feffff  call 00001177 // call H
>
> So, by what instruction reference manual is a call 00001177 followedby
> the execution of the instruction at 000012e7.
>
> Your "CPU" is broken, or emulation incorrect.
>
> FAIL.
>
>> [000012e7][0025cc58][0025cc5c] 55          push ebp      // enter
>> emulated P
>> [000012e8][0025cc58][0025cc5c] 8bec        mov ebp,esp
>> [000012ea][0025cc58][0025cc5c] 8b4508      mov eax,[ebp+08]
>> [000012ed][0025cc54][000012e7] 50          push eax      // push P
>> [000012ee][0025cc54][000012e7] 8b4d08      mov ecx,[ebp+08]
>> [000012f1][0025cc50][000012e7] 51          push ecx      // push P
>> [000012f2][0025cc4c][000012f7] e880feffff  call 00001177 // call H
>> Local Halt Decider: Infinite Recursion Detected Simulation Stopped
>>
>> It is completely obvious that when H(P,P) correctly emulates its input
>> that it must emulate the first seven instructions of P. Because the
>> seventh instruction of P repeats this process we know with complete
>> certainty that the correct and complete emulation of P by H would
>> never reach its final “ret” instruction, thus never halts.
>
> Problem, the 7th intruction DOESN't "Just repeat the procedure", because
> that H always has the option to abort its simulation, just like this
> onne did, and return to its P and see it halt.
>
THAT YOU ARE SIMPLY TOO STUPID TO UNDERSTAND THIS IS NO ACTUAL REBUTTAL
AT ALL:

The partial correct x86 emulation of the input to H(P,P) conclusively
proves that the complete and correct x86 emulation would never stop
running.

--
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: Proving that P(P) != the correct x86 emulation of the input to H(P,P)

<RMpoK.7650$x7oc.3519@fx01.iad>

 copy mid

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

 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!fx01.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.10.0
Subject: Re: Proving that P(P) != the correct x86 emulation of the input to
H(P,P)
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <N8GdnUDJ0IRRxjz_nZ2dnUU7_8zNnZ2d@giganews.com>
<nvudncJwjNiNiz__nZ2dnUU7_81g4p2d@giganews.com>
<bipoK.10513$Vxw.6751@fx07.iad>
<jdydnWlvi_kquD__nZ2dnUU7_8zNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <jdydnWlvi_kquD__nZ2dnUU7_8zNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 119
Message-ID: <RMpoK.7650$x7oc.3519@fx01.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, 9 Jun 2022 13:06:57 -0400
X-Received-Bytes: 6540
 by: Richard Damon - Thu, 9 Jun 2022 17:06 UTC

On 6/9/22 12:54 PM, olcott wrote:
> On 6/9/2022 11:34 AM, Richard Damon wrote:
>> On 6/9/22 11:47 AM, olcott wrote:
>>> void P(u32 x)
>>> {
>>>    if (H(x, x))
>>>      HERE: goto HERE;
>>>    return;
>>> }
>>>
>>> int main()
>>> {
>>>    P(P);
>>> }
>>>
>>> _P()
>>> [000012e7](01)  55              push ebp
>>> [000012e8](02)  8bec            mov ebp,esp
>>> [000012ea](03)  8b4508          mov eax,[ebp+08]
>>> [000012ed](01)  50              push eax
>>> [000012ee](03)  8b4d08          mov ecx,[ebp+08]
>>> [000012f1](01)  51              push ecx
>>> [000012f2](05)  e880feffff      call 00001177 // call H
>>> [000012f7](03)  83c408          add esp,+08
>>> [000012fa](02)  85c0            test eax,eax
>>> [000012fc](02)  7402            jz 00001300
>>> [000012fe](02)  ebfe            jmp 000012fe
>>> [00001300](01)  5d              pop ebp
>>> [00001301](01)  c3              ret
>>> Size in bytes:(0027) [00001301]
>>>
>>> _main()
>>> [00001307](01)  55              push ebp
>>> [00001308](02)  8bec            mov ebp,esp
>>> [0000130a](05)  68e7120000      push 000012e7 // push P
>>> [0000130f](05)  e8d3ffffff      call 000012e7 // call P
>>> [00001314](03)  83c404          add esp,+04
>>> [00001317](02)  33c0            xor eax,eax
>>> [00001319](01)  5d              pop ebp
>>> [0000131a](01)  c3              ret
>>> Size in bytes:(0020) [0000131a]
>>>
>>>   machine   stack     stack     machine    assembly
>>>   address   address   data      code       language
>>>   ========  ========  ========  =========  =============
>>> [00001307][00102190][00000000] 55         push ebp
>>> [00001308][00102190][00000000] 8bec       mov ebp,esp
>>> [0000130a][0010218c][000012e7] 68e7120000 push 000012e7 // push P
>>> [0000130f][00102188][00001314] e8d3ffffff call 000012e7 // call P
>>> [000012e7][00102184][00102190] 55         push ebp      // enter
>>> executed P
>>> [000012e8][00102184][00102190] 8bec       mov ebp,esp
>>> [000012ea][00102184][00102190] 8b4508     mov eax,[ebp+08]
>>> [000012ed][00102180][000012e7] 50         push eax      // push P
>>> [000012ee][00102180][000012e7] 8b4d08     mov ecx,[ebp+08]
>>> [000012f1][0010217c][000012e7] 51         push ecx      // push P
>>> [000012f2][00102178][000012f7] e880feffff call 00001177 // call H
>>>
>>> Begin Local Halt Decider Simulation   Execution Trace Stored at:212244
>>> [000012e7][00212230][00212234] 55          push ebp      // enter
>>> emulated P
>>> [000012e8][00212230][00212234] 8bec        mov ebp,esp
>>> [000012ea][00212230][00212234] 8b4508      mov eax,[ebp+08]
>>> [000012ed][0021222c][000012e7] 50          push eax      // push P
>>> [000012ee][0021222c][000012e7] 8b4d08      mov ecx,[ebp+08]
>>> [000012f1][00212228][000012e7] 51          push ecx      // push P
>>> [000012f2][00212224][000012f7] e880feffff  call 00001177 // call H
>>
>> So, by what instruction reference manual is a call 00001177 followedby
>> the execution of the instruction at 000012e7.
>>
>> Your "CPU" is broken, or emulation incorrect.
>>
>> FAIL.
>>
>>> [000012e7][0025cc58][0025cc5c] 55          push ebp      // enter
>>> emulated P
>>> [000012e8][0025cc58][0025cc5c] 8bec        mov ebp,esp
>>> [000012ea][0025cc58][0025cc5c] 8b4508      mov eax,[ebp+08]
>>> [000012ed][0025cc54][000012e7] 50          push eax      // push P
>>> [000012ee][0025cc54][000012e7] 8b4d08      mov ecx,[ebp+08]
>>> [000012f1][0025cc50][000012e7] 51          push ecx      // push P
>>> [000012f2][0025cc4c][000012f7] e880feffff  call 00001177 // call H
>>> Local Halt Decider: Infinite Recursion Detected Simulation Stopped
>>>
>>> It is completely obvious that when H(P,P) correctly emulates its
>>> input that it must emulate the first seven instructions of P. Because
>>> the seventh instruction of P repeats this process we know with
>>> complete certainty that the correct and complete emulation of P by H
>>> would never reach its final “ret” instruction, thus never halts.
>>
>> Problem, the 7th intruction DOESN't "Just repeat the procedure",
>> because that H always has the option to abort its simulation, just
>> like this onne did, and return to its P and see it halt.
>>
> THAT YOU ARE SIMPLY TOO STUPID TO UNDERSTAND THIS IS NO ACTUAL REBUTTAL
> AT ALL:
>
> The partial correct x86 emulation of the input to H(P,P) conclusively
> proves that the complete and correct x86 emulation would never stop
> running.
>
>

You SAY that, but you don't answer the actual questions about HOW.

This shows you are just an idiot, parroting ideas that you don't
actually understand.

It really looks like you have gaslighted yourself into believing your
own lies.

HOW is the correct simulation of a CALL 00001177 instruction not
followed by the instruction at 00001177 ?

If you can't explain that, you just prove that you don't understand what
you are saying.

the actual FACTS show you are wrong.

Re: Proving that P(P) != the correct x86 emulation of the input to H(P,P)

<xJKdnb8LMeMztz__nZ2dnUU7_83NnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Thu, 09 Jun 2022 12:15:26 -0500
Date: Thu, 9 Jun 2022 12:15:24 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.10.0
Subject: Re: Proving that P(P) != the correct x86 emulation of the input to
H(P,P)
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <N8GdnUDJ0IRRxjz_nZ2dnUU7_8zNnZ2d@giganews.com>
<nvudncJwjNiNiz__nZ2dnUU7_81g4p2d@giganews.com>
<bipoK.10513$Vxw.6751@fx07.iad>
<jdydnWlvi_kquD__nZ2dnUU7_8zNnZ2d@giganews.com>
<RMpoK.7650$x7oc.3519@fx01.iad>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <RMpoK.7650$x7oc.3519@fx01.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <xJKdnb8LMeMztz__nZ2dnUU7_83NnZ2d@giganews.com>
Lines: 129
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-XHb9SW07UlTH3iaRmQk5RXEsxBYhXKVGyTYIClkvWUTEJw4fqpH7bSOmYmeEOYn6a7zGgiegSFjlKJZ!hDhshhY1TNnM9GkN+OUs7zZ2R70iKuHXCrty5T7fshIPMxCDZdd2oLa973upykIS73oB7sbB5tJH
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: 7442
 by: olcott - Thu, 9 Jun 2022 17:15 UTC

On 6/9/2022 12:06 PM, Richard Damon wrote:
> On 6/9/22 12:54 PM, olcott wrote:
>> On 6/9/2022 11:34 AM, Richard Damon wrote:
>>> On 6/9/22 11:47 AM, olcott wrote:
>>>> void P(u32 x)
>>>> {
>>>>    if (H(x, x))
>>>>      HERE: goto HERE;
>>>>    return;
>>>> }
>>>>
>>>> int main()
>>>> {
>>>>    P(P);
>>>> }
>>>>
>>>> _P()
>>>> [000012e7](01)  55              push ebp
>>>> [000012e8](02)  8bec            mov ebp,esp
>>>> [000012ea](03)  8b4508          mov eax,[ebp+08]
>>>> [000012ed](01)  50              push eax
>>>> [000012ee](03)  8b4d08          mov ecx,[ebp+08]
>>>> [000012f1](01)  51              push ecx
>>>> [000012f2](05)  e880feffff      call 00001177 // call H
>>>> [000012f7](03)  83c408          add esp,+08
>>>> [000012fa](02)  85c0            test eax,eax
>>>> [000012fc](02)  7402            jz 00001300
>>>> [000012fe](02)  ebfe            jmp 000012fe
>>>> [00001300](01)  5d              pop ebp
>>>> [00001301](01)  c3              ret
>>>> Size in bytes:(0027) [00001301]
>>>>
>>>> _main()
>>>> [00001307](01)  55              push ebp
>>>> [00001308](02)  8bec            mov ebp,esp
>>>> [0000130a](05)  68e7120000      push 000012e7 // push P
>>>> [0000130f](05)  e8d3ffffff      call 000012e7 // call P
>>>> [00001314](03)  83c404          add esp,+04
>>>> [00001317](02)  33c0            xor eax,eax
>>>> [00001319](01)  5d              pop ebp
>>>> [0000131a](01)  c3              ret
>>>> Size in bytes:(0020) [0000131a]
>>>>
>>>>   machine   stack     stack     machine    assembly
>>>>   address   address   data      code       language
>>>>   ========  ========  ========  =========  =============
>>>> [00001307][00102190][00000000] 55         push ebp
>>>> [00001308][00102190][00000000] 8bec       mov ebp,esp
>>>> [0000130a][0010218c][000012e7] 68e7120000 push 000012e7 // push P
>>>> [0000130f][00102188][00001314] e8d3ffffff call 000012e7 // call P
>>>> [000012e7][00102184][00102190] 55         push ebp      // enter
>>>> executed P
>>>> [000012e8][00102184][00102190] 8bec       mov ebp,esp
>>>> [000012ea][00102184][00102190] 8b4508     mov eax,[ebp+08]
>>>> [000012ed][00102180][000012e7] 50         push eax      // push P
>>>> [000012ee][00102180][000012e7] 8b4d08     mov ecx,[ebp+08]
>>>> [000012f1][0010217c][000012e7] 51         push ecx      // push P
>>>> [000012f2][00102178][000012f7] e880feffff call 00001177 // call H
>>>>
>>>> Begin Local Halt Decider Simulation   Execution Trace Stored at:212244
>>>> [000012e7][00212230][00212234] 55          push ebp      // enter
>>>> emulated P
>>>> [000012e8][00212230][00212234] 8bec        mov ebp,esp
>>>> [000012ea][00212230][00212234] 8b4508      mov eax,[ebp+08]
>>>> [000012ed][0021222c][000012e7] 50          push eax      // push P
>>>> [000012ee][0021222c][000012e7] 8b4d08      mov ecx,[ebp+08]
>>>> [000012f1][00212228][000012e7] 51          push ecx      // push P
>>>> [000012f2][00212224][000012f7] e880feffff  call 00001177 // call H
>>>
>>> So, by what instruction reference manual is a call 00001177
>>> followedby the execution of the instruction at 000012e7.
>>>
>>> Your "CPU" is broken, or emulation incorrect.
>>>
>>> FAIL.
>>>
>>>> [000012e7][0025cc58][0025cc5c] 55          push ebp      // enter
>>>> emulated P
>>>> [000012e8][0025cc58][0025cc5c] 8bec        mov ebp,esp
>>>> [000012ea][0025cc58][0025cc5c] 8b4508      mov eax,[ebp+08]
>>>> [000012ed][0025cc54][000012e7] 50          push eax      // push P
>>>> [000012ee][0025cc54][000012e7] 8b4d08      mov ecx,[ebp+08]
>>>> [000012f1][0025cc50][000012e7] 51          push ecx      // push P
>>>> [000012f2][0025cc4c][000012f7] e880feffff  call 00001177 // call H
>>>> Local Halt Decider: Infinite Recursion Detected Simulation Stopped
>>>>
>>>> It is completely obvious that when H(P,P) correctly emulates its
>>>> input that it must emulate the first seven instructions of P.
>>>> Because the seventh instruction of P repeats this process we know
>>>> with complete certainty that the correct and complete emulation of P
>>>> by H would never reach its final “ret” instruction, thus never halts.
>>>
>>> Problem, the 7th intruction DOESN't "Just repeat the procedure",
>>> because that H always has the option to abort its simulation, just
>>> like this onne did, and return to its P and see it halt.
>>>
>> THAT YOU ARE SIMPLY TOO STUPID TO UNDERSTAND THIS IS NO ACTUAL
>> REBUTTAL AT ALL:
>>
>> The partial correct x86 emulation of the input to H(P,P) conclusively
>> proves that the complete and correct x86 emulation would never stop
>> running.
>>
>>
>
> You SAY that, but you don't answer the actual questions about HOW.
>

THAT YOU ARE SIMPLY TOO STUPID TO UNDERSTAND THIS IS NO EVIDENCE
WHAT-SO-EVER THAT I DID NOT COMPLETELY PROVE THAT THE CORRECT PARTIAL
EMULATION OF THE INPUT TO H(P,P) CONCLUSIVELY PROVES THAT THE CORRECT
AND COMPLETE X86 EMULATION OF THE INPUT TO H(P,P) WOULD NEVER STOP
RUNNING.

It is completely obvious that when H(P,P) correctly emulates its input
that it must emulate the first seven instructions of P. Because the
seventh instruction of P repeats this process we know with complete
certainty that the correct and complete emulation of P by H would never
reach its final “ret” instruction, thus never halts.

--
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: Proving that P(P) != the correct x86 emulation of the input to H(P,P)

<20220609182847.00007585@reddwarf.jmc>

 copy mid

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

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Path: i2pn2.org!i2pn.org!weretis.net!feeder8.news.weretis.net!news.uzoreto.com!news-out.netnews.com!news.alt.net!fdc2.netnews.com!peer02.ams1!peer.ams1.xlned.com!news.xlned.com!peer03.ams4!peer.am4.highwinds-media.com!news.highwinds-media.com!fx06.ams4.POSTED!not-for-mail
From: flib...@reddwarf.jmc (Mr Flibble)
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
Subject: Re: Proving that P(P) != the correct x86 emulation of the input to
H(P,P)
Message-ID: <20220609182847.00007585@reddwarf.jmc>
References: <N8GdnUDJ0IRRxjz_nZ2dnUU7_8zNnZ2d@giganews.com>
<nvudncJwjNiNiz__nZ2dnUU7_81g4p2d@giganews.com>
<bipoK.10513$Vxw.6751@fx07.iad>
<jdydnWlvi_kquD__nZ2dnUU7_8zNnZ2d@giganews.com>
<RMpoK.7650$x7oc.3519@fx01.iad>
<xJKdnb8LMeMztz__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: 179
X-Complaints-To: abuse@eweka.nl
NNTP-Posting-Date: Thu, 09 Jun 2022 17:28:47 UTC
Date: Thu, 9 Jun 2022 18:28:47 +0100
X-Received-Bytes: 9567
 by: Mr Flibble - Thu, 9 Jun 2022 17:28 UTC

On Thu, 9 Jun 2022 12:15:24 -0500
olcott <NoOne@NoWhere.com> wrote:

> On 6/9/2022 12:06 PM, Richard Damon wrote:
> > On 6/9/22 12:54 PM, olcott wrote:
> >> On 6/9/2022 11:34 AM, Richard Damon wrote:
> >>> On 6/9/22 11:47 AM, olcott wrote:
> >>>> void P(u32 x)
> >>>> {
> >>>>    if (H(x, x))
> >>>>      HERE: goto HERE;
> >>>>    return;
> >>>> }
> >>>>
> >>>> int main()
> >>>> {
> >>>>    P(P);
> >>>> }
> >>>>
> >>>> _P()
> >>>> [000012e7](01)  55              push ebp
> >>>> [000012e8](02)  8bec            mov ebp,esp
> >>>> [000012ea](03)  8b4508          mov eax,[ebp+08]
> >>>> [000012ed](01)  50              push eax
> >>>> [000012ee](03)  8b4d08          mov ecx,[ebp+08]
> >>>> [000012f1](01)  51              push ecx
> >>>> [000012f2](05)  e880feffff      call 00001177 // call H
> >>>> [000012f7](03)  83c408          add esp,+08
> >>>> [000012fa](02)  85c0            test eax,eax
> >>>> [000012fc](02)  7402            jz 00001300
> >>>> [000012fe](02)  ebfe            jmp 000012fe
> >>>> [00001300](01)  5d              pop ebp
> >>>> [00001301](01)  c3              ret
> >>>> Size in bytes:(0027) [00001301]
> >>>>
> >>>> _main()
> >>>> [00001307](01)  55              push ebp
> >>>> [00001308](02)  8bec            mov ebp,esp
> >>>> [0000130a](05)  68e7120000      push 000012e7 // push P
> >>>> [0000130f](05)  e8d3ffffff      call 000012e7 // call P
> >>>> [00001314](03)  83c404          add esp,+04
> >>>> [00001317](02)  33c0            xor eax,eax
> >>>> [00001319](01)  5d              pop ebp
> >>>> [0000131a](01)  c3              ret
> >>>> Size in bytes:(0020) [0000131a]
> >>>>
> >>>>   machine   stack     stack     machine    assembly
> >>>>   address   address   data      code       language
> >>>>   ========  ========  ========  =========  ============> >>>> [00001307][00102190][00000000] 55         push ebp
> >>>> [00001308][00102190][00000000] 8bec       mov ebp,esp
> >>>> [0000130a][0010218c][000012e7] 68e7120000 push 000012e7 // push P
> >>>> [0000130f][00102188][00001314] e8d3ffffff call 000012e7 // call P
> >>>> [000012e7][00102184][00102190] 55         push ebp      // enter
> >>>> executed P
> >>>> [000012e8][00102184][00102190] 8bec       mov ebp,esp
> >>>> [000012ea][00102184][00102190] 8b4508     mov eax,[ebp+08]
> >>>> [000012ed][00102180][000012e7] 50         push eax      // push P
> >>>> [000012ee][00102180][000012e7] 8b4d08     mov ecx,[ebp+08]
> >>>> [000012f1][0010217c][000012e7] 51         push ecx      // push P
> >>>> [000012f2][00102178][000012f7] e880feffff call 00001177 // call H
> >>>>
> >>>> Begin Local Halt Decider Simulation   Execution Trace Stored
> >>>> at:212244 [000012e7][00212230][00212234] 55          push ebp
> >>>>   // enter emulated P
> >>>> [000012e8][00212230][00212234] 8bec        mov ebp,esp
> >>>> [000012ea][00212230][00212234] 8b4508      mov eax,[ebp+08]
> >>>> [000012ed][0021222c][000012e7] 50          push eax      // push
> >>>> P [000012ee][0021222c][000012e7] 8b4d08      mov ecx,[ebp+08]
> >>>> [000012f1][00212228][000012e7] 51          push ecx      // push
> >>>> P [000012f2][00212224][000012f7] e880feffff  call 00001177 //
> >>>> call H
> >>>
> >>> So, by what instruction reference manual is a call 00001177
> >>> followedby the execution of the instruction at 000012e7.
> >>>
> >>> Your "CPU" is broken, or emulation incorrect.
> >>>
> >>> FAIL.
> >>>
> >>>> [000012e7][0025cc58][0025cc5c] 55          push ebp      //
> >>>> enter emulated P
> >>>> [000012e8][0025cc58][0025cc5c] 8bec        mov ebp,esp
> >>>> [000012ea][0025cc58][0025cc5c] 8b4508      mov eax,[ebp+08]
> >>>> [000012ed][0025cc54][000012e7] 50          push eax      // push
> >>>> P [000012ee][0025cc54][000012e7] 8b4d08      mov ecx,[ebp+08]
> >>>> [000012f1][0025cc50][000012e7] 51          push ecx      // push
> >>>> P [000012f2][0025cc4c][000012f7] e880feffff  call 00001177 //
> >>>> call H Local Halt Decider: Infinite Recursion Detected
> >>>> Simulation Stopped
> >>>>
> >>>> It is completely obvious that when H(P,P) correctly emulates its
> >>>> input that it must emulate the first seven instructions of P.
> >>>> Because the seventh instruction of P repeats this process we
> >>>> know with complete certainty that the correct and complete
> >>>> emulation of P by H would never reach its final “ret”
> >>>> instruction, thus never halts.
> >>>
> >>> Problem, the 7th intruction DOESN't "Just repeat the procedure",
> >>> because that H always has the option to abort its simulation,
> >>> just like this onne did, and return to its P and see it halt.
> >>>
> >> THAT YOU ARE SIMPLY TOO STUPID TO UNDERSTAND THIS IS NO ACTUAL
> >> REBUTTAL AT ALL:
> >>
> >> The partial correct x86 emulation of the input to H(P,P)
> >> conclusively proves that the complete and correct x86 emulation
> >> would never stop running.
> >>
> >>
> >
> > You SAY that, but you don't answer the actual questions about HOW.
> >
>
> THAT YOU ARE SIMPLY TOO STUPID TO UNDERSTAND THIS IS NO EVIDENCE
> WHAT-SO-EVER THAT I DID NOT COMPLETELY PROVE THAT THE CORRECT PARTIAL
> EMULATION OF THE INPUT TO H(P,P) CONCLUSIVELY PROVES THAT THE CORRECT
> AND COMPLETE X86 EMULATION OF THE INPUT TO H(P,P) WOULD NEVER STOP
> RUNNING.
>
> It is completely obvious that when H(P,P) correctly emulates its
> input that it must emulate the first seven instructions of P. Because
> the seventh instruction of P repeats this process we know with
> complete certainty that the correct and complete emulation of P by H
> would never reach its final “ret” instruction, thus never halts.

If P should have halted (i.e. no infinite loop) then your simulation
detector, S (not H), gets the answer wrong. You S is NOT a halting
decider.

/Flibble

Re: Proving that P(P) != the correct x86 emulation of the input to H(P,P)

<N-adnVHsgaLIrT__nZ2dnUU7_8xh4p2d@giganews.com>

 copy mid

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

 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, 09 Jun 2022 12:39:33 -0500
Date: Thu, 9 Jun 2022 12:39:32 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.10.0
Subject: Re: Proving that P(P) != the correct x86 emulation of the input to
H(P,P)
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <N8GdnUDJ0IRRxjz_nZ2dnUU7_8zNnZ2d@giganews.com>
<nvudncJwjNiNiz__nZ2dnUU7_81g4p2d@giganews.com>
<bipoK.10513$Vxw.6751@fx07.iad>
<jdydnWlvi_kquD__nZ2dnUU7_8zNnZ2d@giganews.com>
<RMpoK.7650$x7oc.3519@fx01.iad>
<xJKdnb8LMeMztz__nZ2dnUU7_83NnZ2d@giganews.com>
<20220609182847.00007585@reddwarf.jmc>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <20220609182847.00007585@reddwarf.jmc>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <N-adnVHsgaLIrT__nZ2dnUU7_8xh4p2d@giganews.com>
Lines: 166
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-MIGVTZ7qjO3DkZ1mFkD2uzRnL0xAsL4B10QNJrjRAKlfVq+pdnm2NLtrvhR7/DnsDN4Fvc5cJ1UZukf!Pvy8XetvDnerxLQDnSOa+6TfEInVULyJFublEZBr3Sz9xzwCBlSUh2O0vFOIx7r1/j2iI1tAszS3
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: 9189
 by: olcott - Thu, 9 Jun 2022 17:39 UTC

On 6/9/2022 12:28 PM, Mr Flibble wrote:
> On Thu, 9 Jun 2022 12:15:24 -0500
> olcott <NoOne@NoWhere.com> wrote:
>
>> On 6/9/2022 12:06 PM, Richard Damon wrote:
>>> On 6/9/22 12:54 PM, olcott wrote:
>>>> On 6/9/2022 11:34 AM, Richard Damon wrote:
>>>>> On 6/9/22 11:47 AM, olcott wrote:
>>>>>> void P(u32 x)
>>>>>> {
>>>>>>    if (H(x, x))
>>>>>>      HERE: goto HERE;
>>>>>>    return;
>>>>>> }
>>>>>>
>>>>>> int main()
>>>>>> {
>>>>>>    P(P);
>>>>>> }
>>>>>>
>>>>>> _P()
>>>>>> [000012e7](01)  55              push ebp
>>>>>> [000012e8](02)  8bec            mov ebp,esp
>>>>>> [000012ea](03)  8b4508          mov eax,[ebp+08]
>>>>>> [000012ed](01)  50              push eax
>>>>>> [000012ee](03)  8b4d08          mov ecx,[ebp+08]
>>>>>> [000012f1](01)  51              push ecx
>>>>>> [000012f2](05)  e880feffff      call 00001177 // call H
>>>>>> [000012f7](03)  83c408          add esp,+08
>>>>>> [000012fa](02)  85c0            test eax,eax
>>>>>> [000012fc](02)  7402            jz 00001300
>>>>>> [000012fe](02)  ebfe            jmp 000012fe
>>>>>> [00001300](01)  5d              pop ebp
>>>>>> [00001301](01)  c3              ret
>>>>>> Size in bytes:(0027) [00001301]
>>>>>>
>>>>>> _main()
>>>>>> [00001307](01)  55              push ebp
>>>>>> [00001308](02)  8bec            mov ebp,esp
>>>>>> [0000130a](05)  68e7120000      push 000012e7 // push P
>>>>>> [0000130f](05)  e8d3ffffff      call 000012e7 // call P
>>>>>> [00001314](03)  83c404          add esp,+04
>>>>>> [00001317](02)  33c0            xor eax,eax
>>>>>> [00001319](01)  5d              pop ebp
>>>>>> [0000131a](01)  c3              ret
>>>>>> Size in bytes:(0020) [0000131a]
>>>>>>
>>>>>>   machine   stack     stack     machine    assembly
>>>>>>   address   address   data      code       language
>>>>>>   ========  ========  ========  =========  =============
>>>>>> [00001307][00102190][00000000] 55         push ebp
>>>>>> [00001308][00102190][00000000] 8bec       mov ebp,esp
>>>>>> [0000130a][0010218c][000012e7] 68e7120000 push 000012e7 // push P
>>>>>> [0000130f][00102188][00001314] e8d3ffffff call 000012e7 // call P
>>>>>> [000012e7][00102184][00102190] 55         push ebp      // enter
>>>>>> executed P
>>>>>> [000012e8][00102184][00102190] 8bec       mov ebp,esp
>>>>>> [000012ea][00102184][00102190] 8b4508     mov eax,[ebp+08]
>>>>>> [000012ed][00102180][000012e7] 50         push eax      // push P
>>>>>> [000012ee][00102180][000012e7] 8b4d08     mov ecx,[ebp+08]
>>>>>> [000012f1][0010217c][000012e7] 51         push ecx      // push P
>>>>>> [000012f2][00102178][000012f7] e880feffff call 00001177 // call H
>>>>>>
>>>>>> Begin Local Halt Decider Simulation   Execution Trace Stored
>>>>>> at:212244 [000012e7][00212230][00212234] 55          push ebp
>>>>>>   // enter emulated P
>>>>>> [000012e8][00212230][00212234] 8bec        mov ebp,esp
>>>>>> [000012ea][00212230][00212234] 8b4508      mov eax,[ebp+08]
>>>>>> [000012ed][0021222c][000012e7] 50          push eax      // push
>>>>>> P [000012ee][0021222c][000012e7] 8b4d08      mov ecx,[ebp+08]
>>>>>> [000012f1][00212228][000012e7] 51          push ecx      // push
>>>>>> P [000012f2][00212224][000012f7] e880feffff  call 00001177 //
>>>>>> call H
>>>>>
>>>>> So, by what instruction reference manual is a call 00001177
>>>>> followedby the execution of the instruction at 000012e7.
>>>>>
>>>>> Your "CPU" is broken, or emulation incorrect.
>>>>>
>>>>> FAIL.
>>>>>
>>>>>> [000012e7][0025cc58][0025cc5c] 55          push ebp      //
>>>>>> enter emulated P
>>>>>> [000012e8][0025cc58][0025cc5c] 8bec        mov ebp,esp
>>>>>> [000012ea][0025cc58][0025cc5c] 8b4508      mov eax,[ebp+08]
>>>>>> [000012ed][0025cc54][000012e7] 50          push eax      // push
>>>>>> P [000012ee][0025cc54][000012e7] 8b4d08      mov ecx,[ebp+08]
>>>>>> [000012f1][0025cc50][000012e7] 51          push ecx      // push
>>>>>> P [000012f2][0025cc4c][000012f7] e880feffff  call 00001177 //
>>>>>> call H Local Halt Decider: Infinite Recursion Detected
>>>>>> Simulation Stopped
>>>>>>
>>>>>> It is completely obvious that when H(P,P) correctly emulates its
>>>>>> input that it must emulate the first seven instructions of P.
>>>>>> Because the seventh instruction of P repeats this process we
>>>>>> know with complete certainty that the correct and complete
>>>>>> emulation of P by H would never reach its final “ret”
>>>>>> instruction, thus never halts.
>>>>>
>>>>> Problem, the 7th intruction DOESN't "Just repeat the procedure",
>>>>> because that H always has the option to abort its simulation,
>>>>> just like this onne did, and return to its P and see it halt.
>>>>>
>>>> THAT YOU ARE SIMPLY TOO STUPID TO UNDERSTAND THIS IS NO ACTUAL
>>>> REBUTTAL AT ALL:
>>>>
>>>> The partial correct x86 emulation of the input to H(P,P)
>>>> conclusively proves that the complete and correct x86 emulation
>>>> would never stop running.
>>>>
>>>>
>>>
>>> You SAY that, but you don't answer the actual questions about HOW.
>>>
>>
>> THAT YOU ARE SIMPLY TOO STUPID TO UNDERSTAND THIS IS NO EVIDENCE
>> WHAT-SO-EVER THAT I DID NOT COMPLETELY PROVE THAT THE CORRECT PARTIAL
>> EMULATION OF THE INPUT TO H(P,P) CONCLUSIVELY PROVES THAT THE CORRECT
>> AND COMPLETE X86 EMULATION OF THE INPUT TO H(P,P) WOULD NEVER STOP
>> RUNNING.
>>
>> It is completely obvious that when H(P,P) correctly emulates its
>> input that it must emulate the first seven instructions of P. Because
>> the seventh instruction of P repeats this process we know with
>> complete certainty that the correct and complete emulation of P by H
>> would never reach its final “ret” instruction, thus never halts.
>
> If P should have halted (i.e. no infinite loop) then your simulation
> detector, S (not H), gets the answer wrong. You S is NOT a halting
> decider.
>
> /Flibble
>

THAT YOU ARE SIMPLY TOO STUPID TO UNDERSTAND THIS IS NO ACTUAL REBUTTAL
AT ALL.

_P()
[00001352](01) 55 push ebp
[00001353](02) 8bec mov ebp,esp
[00001355](03) 8b4508 mov eax,[ebp+08]
[00001358](01) 50 push eax // push P
[00001359](03) 8b4d08 mov ecx,[ebp+08]
[0000135c](01) 51 push ecx // push P
[0000135d](05) e840feffff call 000011a2 // call H
[00001362](03) 83c408 add esp,+08
[00001365](02) 85c0 test eax,eax
[00001367](02) 7402 jz 0000136b
[00001369](02) ebfe jmp 00001369
[0000136b](01) 5d pop ebp
[0000136c](01) c3 ret
Size in bytes:(0027) [0000136c]

It is completely obvious that when H(P,P) correctly emulates its input
that it must emulate the first seven instructions of P. Because the
seventh instruction of P repeats this process we know with complete
certainty that the correct and complete emulation of P by H would never
reach its final “ret” instruction, thus never halts.


Click here to read the complete article
Re: Proving that P(P) != the correct x86 emulation of the input to H(P,P)

<20220609184617.00002add@reddwarf.jmc>

 copy mid

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

 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!81.171.65.16.MISMATCH!peer03.ams4!peer.am4.highwinds-media.com!news.highwinds-media.com!fx06.ams4.POSTED!not-for-mail
From: flib...@reddwarf.jmc (Mr Flibble)
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
Subject: Re: Proving that P(P) != the correct x86 emulation of the input to H(P,P)
Message-ID: <20220609184617.00002add@reddwarf.jmc>
References: <N8GdnUDJ0IRRxjz_nZ2dnUU7_8zNnZ2d@giganews.com> <nvudncJwjNiNiz__nZ2dnUU7_81g4p2d@giganews.com> <bipoK.10513$Vxw.6751@fx07.iad> <jdydnWlvi_kquD__nZ2dnUU7_8zNnZ2d@giganews.com> <RMpoK.7650$x7oc.3519@fx01.iad> <xJKdnb8LMeMztz__nZ2dnUU7_83NnZ2d@giganews.com> <20220609182847.00007585@reddwarf.jmc> <N-adnVHsgaLIrT__nZ2dnUU7_8xh4p2d@giganews.com>
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: 223
X-Complaints-To: abuse@eweka.nl
NNTP-Posting-Date: Thu, 09 Jun 2022 17:46:17 UTC
Date: Thu, 9 Jun 2022 18:46:17 +0100
X-Received-Bytes: 11360
 by: Mr Flibble - Thu, 9 Jun 2022 17:46 UTC

On Thu, 9 Jun 2022 12:39:32 -0500
olcott <NoOne@NoWhere.com> wrote:

> On 6/9/2022 12:28 PM, Mr Flibble wrote:
> > On Thu, 9 Jun 2022 12:15:24 -0500
> > olcott <NoOne@NoWhere.com> wrote:
> >
> >> On 6/9/2022 12:06 PM, Richard Damon wrote:
> >>> On 6/9/22 12:54 PM, olcott wrote:
> >>>> On 6/9/2022 11:34 AM, Richard Damon wrote:
> >>>>> On 6/9/22 11:47 AM, olcott wrote:
> >>>>>> void P(u32 x)
> >>>>>> {
> >>>>>>    if (H(x, x))
> >>>>>>      HERE: goto HERE;
> >>>>>>    return;
> >>>>>> }
> >>>>>>
> >>>>>> int main()
> >>>>>> {
> >>>>>>    P(P);
> >>>>>> }
> >>>>>>
> >>>>>> _P()
> >>>>>> [000012e7](01)  55              push ebp
> >>>>>> [000012e8](02)  8bec            mov ebp,esp
> >>>>>> [000012ea](03)  8b4508          mov eax,[ebp+08]
> >>>>>> [000012ed](01)  50              push eax
> >>>>>> [000012ee](03)  8b4d08          mov ecx,[ebp+08]
> >>>>>> [000012f1](01)  51              push ecx
> >>>>>> [000012f2](05)  e880feffff      call 00001177 // call H
> >>>>>> [000012f7](03)  83c408          add esp,+08
> >>>>>> [000012fa](02)  85c0            test eax,eax
> >>>>>> [000012fc](02)  7402            jz 00001300
> >>>>>> [000012fe](02)  ebfe            jmp 000012fe
> >>>>>> [00001300](01)  5d              pop ebp
> >>>>>> [00001301](01)  c3              ret
> >>>>>> Size in bytes:(0027) [00001301]
> >>>>>>
> >>>>>> _main()
> >>>>>> [00001307](01)  55              push ebp
> >>>>>> [00001308](02)  8bec            mov ebp,esp
> >>>>>> [0000130a](05)  68e7120000      push 000012e7 // push P
> >>>>>> [0000130f](05)  e8d3ffffff      call 000012e7 // call P
> >>>>>> [00001314](03)  83c404          add esp,+04
> >>>>>> [00001317](02)  33c0            xor eax,eax
> >>>>>> [00001319](01)  5d              pop ebp
> >>>>>> [0000131a](01)  c3              ret
> >>>>>> Size in bytes:(0020) [0000131a]
> >>>>>>
> >>>>>>   machine   stack     stack     machine    assembly
> >>>>>>   address   address   data      code       language
> >>>>>>   ========  ========  ========  =========  ============> >>>>>> [00001307][00102190][00000000] 55         push ebp
> >>>>>> [00001308][00102190][00000000] 8bec       mov ebp,esp
> >>>>>> [0000130a][0010218c][000012e7] 68e7120000 push 000012e7 //
> >>>>>> push P [0000130f][00102188][00001314] e8d3ffffff call 000012e7
> >>>>>> // call P [000012e7][00102184][00102190] 55         push ebp
> >>>>>>    // enter executed P
> >>>>>> [000012e8][00102184][00102190] 8bec       mov ebp,esp
> >>>>>> [000012ea][00102184][00102190] 8b4508     mov eax,[ebp+08]
> >>>>>> [000012ed][00102180][000012e7] 50         push eax      //
> >>>>>> push P [000012ee][00102180][000012e7] 8b4d08     mov
> >>>>>> ecx,[ebp+08] [000012f1][0010217c][000012e7] 51         push
> >>>>>> ecx      // push P [000012f2][00102178][000012f7] e880feffff
> >>>>>> call 00001177 // call H
> >>>>>>
> >>>>>> Begin Local Halt Decider Simulation   Execution Trace Stored
> >>>>>> at:212244 [000012e7][00212230][00212234] 55          push ebp
> >>>>>>   // enter emulated P
> >>>>>> [000012e8][00212230][00212234] 8bec        mov ebp,esp
> >>>>>> [000012ea][00212230][00212234] 8b4508      mov eax,[ebp+08]
> >>>>>> [000012ed][0021222c][000012e7] 50          push eax      //
> >>>>>> push P [000012ee][0021222c][000012e7] 8b4d08      mov
> >>>>>> ecx,[ebp+08] [000012f1][00212228][000012e7] 51          push
> >>>>>> ecx      // push P [000012f2][00212224][000012f7] e880feffff
> >>>>>> call 00001177 // call H
> >>>>>
> >>>>> So, by what instruction reference manual is a call 00001177
> >>>>> followedby the execution of the instruction at 000012e7.
> >>>>>
> >>>>> Your "CPU" is broken, or emulation incorrect.
> >>>>>
> >>>>> FAIL.
> >>>>>
> >>>>>> [000012e7][0025cc58][0025cc5c] 55          push ebp      //
> >>>>>> enter emulated P
> >>>>>> [000012e8][0025cc58][0025cc5c] 8bec        mov ebp,esp
> >>>>>> [000012ea][0025cc58][0025cc5c] 8b4508      mov eax,[ebp+08]
> >>>>>> [000012ed][0025cc54][000012e7] 50          push eax      //
> >>>>>> push P [000012ee][0025cc54][000012e7] 8b4d08      mov
> >>>>>> ecx,[ebp+08] [000012f1][0025cc50][000012e7] 51          push
> >>>>>> ecx      // push P [000012f2][0025cc4c][000012f7] e880feffff
> >>>>>> call 00001177 // call H Local Halt Decider: Infinite Recursion
> >>>>>> Detected Simulation Stopped
> >>>>>>
> >>>>>> It is completely obvious that when H(P,P) correctly emulates
> >>>>>> its input that it must emulate the first seven instructions of
> >>>>>> P. Because the seventh instruction of P repeats this process we
> >>>>>> know with complete certainty that the correct and complete
> >>>>>> emulation of P by H would never reach its final “ret”
> >>>>>> instruction, thus never halts.
> >>>>>
> >>>>> Problem, the 7th intruction DOESN't "Just repeat the procedure",
> >>>>> because that H always has the option to abort its simulation,
> >>>>> just like this onne did, and return to its P and see it halt.
> >>>>>
> >>>> THAT YOU ARE SIMPLY TOO STUPID TO UNDERSTAND THIS IS NO ACTUAL
> >>>> REBUTTAL AT ALL:
> >>>>
> >>>> The partial correct x86 emulation of the input to H(P,P)
> >>>> conclusively proves that the complete and correct x86 emulation
> >>>> would never stop running.
> >>>>
> >>>>
> >>>
> >>> You SAY that, but you don't answer the actual questions about HOW.
> >>>
> >>
> >> THAT YOU ARE SIMPLY TOO STUPID TO UNDERSTAND THIS IS NO EVIDENCE
> >> WHAT-SO-EVER THAT I DID NOT COMPLETELY PROVE THAT THE CORRECT
> >> PARTIAL EMULATION OF THE INPUT TO H(P,P) CONCLUSIVELY PROVES THAT
> >> THE CORRECT AND COMPLETE X86 EMULATION OF THE INPUT TO H(P,P)
> >> WOULD NEVER STOP RUNNING.
> >>
> >> It is completely obvious that when H(P,P) correctly emulates its
> >> input that it must emulate the first seven instructions of P.
> >> Because the seventh instruction of P repeats this process we know
> >> with complete certainty that the correct and complete emulation of
> >> P by H would never reach its final “ret” instruction, thus never
> >> halts.
> >
> > If P should have halted (i.e. no infinite loop) then your simulation
> > detector, S (not H), gets the answer wrong. You S is NOT a halting
> > decider.
> >
> > /Flibble
> >
>
> THAT YOU ARE SIMPLY TOO STUPID TO UNDERSTAND THIS IS NO ACTUAL
> REBUTTAL AT ALL.
>
> _P()
> [00001352](01) 55 push ebp
> [00001353](02) 8bec mov ebp,esp
> [00001355](03) 8b4508 mov eax,[ebp+08]
> [00001358](01) 50 push eax // push P
> [00001359](03) 8b4d08 mov ecx,[ebp+08]
> [0000135c](01) 51 push ecx // push P
> [0000135d](05) e840feffff call 000011a2 // call H
> [00001362](03) 83c408 add esp,+08
> [00001365](02) 85c0 test eax,eax
> [00001367](02) 7402 jz 0000136b
> [00001369](02) ebfe jmp 00001369
> [0000136b](01) 5d pop ebp
> [0000136c](01) c3 ret
> Size in bytes:(0027) [0000136c]
>
> It is completely obvious that when H(P,P) correctly emulates its
> input that it must emulate the first seven instructions of P. Because
> the seventh instruction of P repeats this process we know with
> complete certainty that the correct and complete emulation of P by H
> would never reach its final “ret” instruction, thus never halts.


Click here to read the complete article
Re: Proving that P(P) != the correct x86 emulation of the input to H(P,P)

<eJ6dnaW1z8lnrj__nZ2dnUU7_83NnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!1.us.feeder.erje.net!feeder.erje.net!border1.nntp.dca1.giganews.com!nntp.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Thu, 09 Jun 2022 12:55:06 -0500
Date: Thu, 9 Jun 2022 12:55:04 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.10.0
Subject: Re: Proving that P(P) != the correct x86 emulation of the input to
H(P,P)
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <N8GdnUDJ0IRRxjz_nZ2dnUU7_8zNnZ2d@giganews.com>
<nvudncJwjNiNiz__nZ2dnUU7_81g4p2d@giganews.com>
<bipoK.10513$Vxw.6751@fx07.iad>
<jdydnWlvi_kquD__nZ2dnUU7_8zNnZ2d@giganews.com>
<RMpoK.7650$x7oc.3519@fx01.iad>
<xJKdnb8LMeMztz__nZ2dnUU7_83NnZ2d@giganews.com>
<20220609182847.00007585@reddwarf.jmc>
<N-adnVHsgaLIrT__nZ2dnUU7_8xh4p2d@giganews.com>
<20220609184617.00002add@reddwarf.jmc>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <20220609184617.00002add@reddwarf.jmc>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <eJ6dnaW1z8lnrj__nZ2dnUU7_83NnZ2d@giganews.com>
Lines: 212
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-XrIFWTN7qt7fzIZVj1kKgBqsApszgUmW0SeLmEvCvs//NWmoRTdHNnlNZtajTSjuNWLURhBu2UmJFOZ!ikuJ5wSELuA9KuGcPCiPgEKPig3FmwWvEl59I3ZVnmsMeb09vJ7ssuAaD3syT5rFE5mupSwwnSdz
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: 11444
 by: olcott - Thu, 9 Jun 2022 17:55 UTC

On 6/9/2022 12:46 PM, Mr Flibble wrote:
> On Thu, 9 Jun 2022 12:39:32 -0500
> olcott <NoOne@NoWhere.com> wrote:
>
>> On 6/9/2022 12:28 PM, Mr Flibble wrote:
>>> On Thu, 9 Jun 2022 12:15:24 -0500
>>> olcott <NoOne@NoWhere.com> wrote:
>>>
>>>> On 6/9/2022 12:06 PM, Richard Damon wrote:
>>>>> On 6/9/22 12:54 PM, olcott wrote:
>>>>>> On 6/9/2022 11:34 AM, Richard Damon wrote:
>>>>>>> On 6/9/22 11:47 AM, olcott wrote:
>>>>>>>> void P(u32 x)
>>>>>>>> {
>>>>>>>>    if (H(x, x))
>>>>>>>>      HERE: goto HERE;
>>>>>>>>    return;
>>>>>>>> }
>>>>>>>>
>>>>>>>> int main()
>>>>>>>> {
>>>>>>>>    P(P);
>>>>>>>> }
>>>>>>>>
>>>>>>>> _P()
>>>>>>>> [000012e7](01)  55              push ebp
>>>>>>>> [000012e8](02)  8bec            mov ebp,esp
>>>>>>>> [000012ea](03)  8b4508          mov eax,[ebp+08]
>>>>>>>> [000012ed](01)  50              push eax
>>>>>>>> [000012ee](03)  8b4d08          mov ecx,[ebp+08]
>>>>>>>> [000012f1](01)  51              push ecx
>>>>>>>> [000012f2](05)  e880feffff      call 00001177 // call H
>>>>>>>> [000012f7](03)  83c408          add esp,+08
>>>>>>>> [000012fa](02)  85c0            test eax,eax
>>>>>>>> [000012fc](02)  7402            jz 00001300
>>>>>>>> [000012fe](02)  ebfe            jmp 000012fe
>>>>>>>> [00001300](01)  5d              pop ebp
>>>>>>>> [00001301](01)  c3              ret
>>>>>>>> Size in bytes:(0027) [00001301]
>>>>>>>>
>>>>>>>> _main()
>>>>>>>> [00001307](01)  55              push ebp
>>>>>>>> [00001308](02)  8bec            mov ebp,esp
>>>>>>>> [0000130a](05)  68e7120000      push 000012e7 // push P
>>>>>>>> [0000130f](05)  e8d3ffffff      call 000012e7 // call P
>>>>>>>> [00001314](03)  83c404          add esp,+04
>>>>>>>> [00001317](02)  33c0            xor eax,eax
>>>>>>>> [00001319](01)  5d              pop ebp
>>>>>>>> [0000131a](01)  c3              ret
>>>>>>>> Size in bytes:(0020) [0000131a]
>>>>>>>>
>>>>>>>>   machine   stack     stack     machine    assembly
>>>>>>>>   address   address   data      code       language
>>>>>>>>   ========  ========  ========  =========  =============
>>>>>>>> [00001307][00102190][00000000] 55         push ebp
>>>>>>>> [00001308][00102190][00000000] 8bec       mov ebp,esp
>>>>>>>> [0000130a][0010218c][000012e7] 68e7120000 push 000012e7 //
>>>>>>>> push P [0000130f][00102188][00001314] e8d3ffffff call 000012e7
>>>>>>>> // call P [000012e7][00102184][00102190] 55         push ebp
>>>>>>>>    // enter executed P
>>>>>>>> [000012e8][00102184][00102190] 8bec       mov ebp,esp
>>>>>>>> [000012ea][00102184][00102190] 8b4508     mov eax,[ebp+08]
>>>>>>>> [000012ed][00102180][000012e7] 50         push eax      //
>>>>>>>> push P [000012ee][00102180][000012e7] 8b4d08     mov
>>>>>>>> ecx,[ebp+08] [000012f1][0010217c][000012e7] 51         push
>>>>>>>> ecx      // push P [000012f2][00102178][000012f7] e880feffff
>>>>>>>> call 00001177 // call H
>>>>>>>>
>>>>>>>> Begin Local Halt Decider Simulation   Execution Trace Stored
>>>>>>>> at:212244 [000012e7][00212230][00212234] 55          push ebp
>>>>>>>>   // enter emulated P
>>>>>>>> [000012e8][00212230][00212234] 8bec        mov ebp,esp
>>>>>>>> [000012ea][00212230][00212234] 8b4508      mov eax,[ebp+08]
>>>>>>>> [000012ed][0021222c][000012e7] 50          push eax      //
>>>>>>>> push P [000012ee][0021222c][000012e7] 8b4d08      mov
>>>>>>>> ecx,[ebp+08] [000012f1][00212228][000012e7] 51          push
>>>>>>>> ecx      // push P [000012f2][00212224][000012f7] e880feffff
>>>>>>>> call 00001177 // call H
>>>>>>>
>>>>>>> So, by what instruction reference manual is a call 00001177
>>>>>>> followedby the execution of the instruction at 000012e7.
>>>>>>>
>>>>>>> Your "CPU" is broken, or emulation incorrect.
>>>>>>>
>>>>>>> FAIL.
>>>>>>>
>>>>>>>> [000012e7][0025cc58][0025cc5c] 55          push ebp      //
>>>>>>>> enter emulated P
>>>>>>>> [000012e8][0025cc58][0025cc5c] 8bec        mov ebp,esp
>>>>>>>> [000012ea][0025cc58][0025cc5c] 8b4508      mov eax,[ebp+08]
>>>>>>>> [000012ed][0025cc54][000012e7] 50          push eax      //
>>>>>>>> push P [000012ee][0025cc54][000012e7] 8b4d08      mov
>>>>>>>> ecx,[ebp+08] [000012f1][0025cc50][000012e7] 51          push
>>>>>>>> ecx      // push P [000012f2][0025cc4c][000012f7] e880feffff
>>>>>>>> call 00001177 // call H Local Halt Decider: Infinite Recursion
>>>>>>>> Detected Simulation Stopped
>>>>>>>>
>>>>>>>> It is completely obvious that when H(P,P) correctly emulates
>>>>>>>> its input that it must emulate the first seven instructions of
>>>>>>>> P. Because the seventh instruction of P repeats this process we
>>>>>>>> know with complete certainty that the correct and complete
>>>>>>>> emulation of P by H would never reach its final “ret”
>>>>>>>> instruction, thus never halts.
>>>>>>>
>>>>>>> Problem, the 7th intruction DOESN't "Just repeat the procedure",
>>>>>>> because that H always has the option to abort its simulation,
>>>>>>> just like this onne did, and return to its P and see it halt.
>>>>>>>
>>>>>> THAT YOU ARE SIMPLY TOO STUPID TO UNDERSTAND THIS IS NO ACTUAL
>>>>>> REBUTTAL AT ALL:
>>>>>>
>>>>>> The partial correct x86 emulation of the input to H(P,P)
>>>>>> conclusively proves that the complete and correct x86 emulation
>>>>>> would never stop running.
>>>>>>
>>>>>>
>>>>>
>>>>> You SAY that, but you don't answer the actual questions about HOW.
>>>>>
>>>>
>>>> THAT YOU ARE SIMPLY TOO STUPID TO UNDERSTAND THIS IS NO EVIDENCE
>>>> WHAT-SO-EVER THAT I DID NOT COMPLETELY PROVE THAT THE CORRECT
>>>> PARTIAL EMULATION OF THE INPUT TO H(P,P) CONCLUSIVELY PROVES THAT
>>>> THE CORRECT AND COMPLETE X86 EMULATION OF THE INPUT TO H(P,P)
>>>> WOULD NEVER STOP RUNNING.
>>>>
>>>> It is completely obvious that when H(P,P) correctly emulates its
>>>> input that it must emulate the first seven instructions of P.
>>>> Because the seventh instruction of P repeats this process we know
>>>> with complete certainty that the correct and complete emulation of
>>>> P by H would never reach its final “ret” instruction, thus never
>>>> halts.
>>>
>>> If P should have halted (i.e. no infinite loop) then your simulation
>>> detector, S (not H), gets the answer wrong. You S is NOT a halting
>>> decider.
>>>
>>> /Flibble
>>>
>>
>> THAT YOU ARE SIMPLY TOO STUPID TO UNDERSTAND THIS IS NO ACTUAL
>> REBUTTAL AT ALL.
>>
>> _P()
>> [00001352](01) 55 push ebp
>> [00001353](02) 8bec mov ebp,esp
>> [00001355](03) 8b4508 mov eax,[ebp+08]
>> [00001358](01) 50 push eax // push P
>> [00001359](03) 8b4d08 mov ecx,[ebp+08]
>> [0000135c](01) 51 push ecx // push P
>> [0000135d](05) e840feffff call 000011a2 // call H
>> [00001362](03) 83c408 add esp,+08
>> [00001365](02) 85c0 test eax,eax
>> [00001367](02) 7402 jz 0000136b
>> [00001369](02) ebfe jmp 00001369
>> [0000136b](01) 5d pop ebp
>> [0000136c](01) c3 ret
>> Size in bytes:(0027) [0000136c]
>>
>> It is completely obvious that when H(P,P) correctly emulates its
>> input that it must emulate the first seven instructions of P. Because
>> the seventh instruction of P repeats this process we know with
>> complete certainty that the correct and complete emulation of P by H
>> would never reach its final “ret” instruction, thus never halts.
>
> We are going around and around and around in circles. I will try again:
>
> If you replace the opcodes "EB FE" at 00001369 with the opcodes "90 90"
> then your H gets the answer wrong: P should have halted.
>
> /Flibble
>


Click here to read the complete article
Re: Proving that P(P) != the correct x86 emulation of the input to H(P,P)

<vKqoK.75291$GTEb.17970@fx48.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Path: i2pn2.org!i2pn.org!usenet.blueworldhosting.com!feed1.usenet.blueworldhosting.com!peer02.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx48.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.10.0
Subject: Re: Proving that P(P) != the correct x86 emulation of the input to
H(P,P)
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <N8GdnUDJ0IRRxjz_nZ2dnUU7_8zNnZ2d@giganews.com>
<nvudncJwjNiNiz__nZ2dnUU7_81g4p2d@giganews.com>
<bipoK.10513$Vxw.6751@fx07.iad>
<jdydnWlvi_kquD__nZ2dnUU7_8zNnZ2d@giganews.com>
<RMpoK.7650$x7oc.3519@fx01.iad>
<xJKdnb8LMeMztz__nZ2dnUU7_83NnZ2d@giganews.com>
<20220609182847.00007585@reddwarf.jmc>
<N-adnVHsgaLIrT__nZ2dnUU7_8xh4p2d@giganews.com>
<20220609184617.00002add@reddwarf.jmc>
<eJ6dnaW1z8lnrj__nZ2dnUU7_83NnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <eJ6dnaW1z8lnrj__nZ2dnUU7_83NnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 244
Message-ID: <vKqoK.75291$GTEb.17970@fx48.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, 9 Jun 2022 14:12:42 -0400
X-Received-Bytes: 13166
 by: Richard Damon - Thu, 9 Jun 2022 18:12 UTC

On 6/9/22 1:55 PM, olcott wrote:
> On 6/9/2022 12:46 PM, Mr Flibble wrote:
>> On Thu, 9 Jun 2022 12:39:32 -0500
>> olcott <NoOne@NoWhere.com> wrote:
>>
>>> On 6/9/2022 12:28 PM, Mr Flibble wrote:
>>>> On Thu, 9 Jun 2022 12:15:24 -0500
>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>> On 6/9/2022 12:06 PM, Richard Damon wrote:
>>>>>> On 6/9/22 12:54 PM, olcott wrote:
>>>>>>> On 6/9/2022 11:34 AM, Richard Damon wrote:
>>>>>>>> On 6/9/22 11:47 AM, olcott wrote:
>>>>>>>>> void P(u32 x)
>>>>>>>>> {
>>>>>>>>>      if (H(x, x))
>>>>>>>>>        HERE: goto HERE;
>>>>>>>>>      return;
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> int main()
>>>>>>>>> {
>>>>>>>>>      P(P);
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> _P()
>>>>>>>>> [000012e7](01)  55              push ebp
>>>>>>>>> [000012e8](02)  8bec            mov ebp,esp
>>>>>>>>> [000012ea](03)  8b4508          mov eax,[ebp+08]
>>>>>>>>> [000012ed](01)  50              push eax
>>>>>>>>> [000012ee](03)  8b4d08          mov ecx,[ebp+08]
>>>>>>>>> [000012f1](01)  51              push ecx
>>>>>>>>> [000012f2](05)  e880feffff      call 00001177 // call H
>>>>>>>>> [000012f7](03)  83c408          add esp,+08
>>>>>>>>> [000012fa](02)  85c0            test eax,eax
>>>>>>>>> [000012fc](02)  7402            jz 00001300
>>>>>>>>> [000012fe](02)  ebfe            jmp 000012fe
>>>>>>>>> [00001300](01)  5d              pop ebp
>>>>>>>>> [00001301](01)  c3              ret
>>>>>>>>> Size in bytes:(0027) [00001301]
>>>>>>>>>
>>>>>>>>> _main()
>>>>>>>>> [00001307](01)  55              push ebp
>>>>>>>>> [00001308](02)  8bec            mov ebp,esp
>>>>>>>>> [0000130a](05)  68e7120000      push 000012e7 // push P
>>>>>>>>> [0000130f](05)  e8d3ffffff      call 000012e7 // call P
>>>>>>>>> [00001314](03)  83c404          add esp,+04
>>>>>>>>> [00001317](02)  33c0            xor eax,eax
>>>>>>>>> [00001319](01)  5d              pop ebp
>>>>>>>>> [0000131a](01)  c3              ret
>>>>>>>>> Size in bytes:(0020) [0000131a]
>>>>>>>>>
>>>>>>>>>     machine   stack     stack     machine    assembly
>>>>>>>>>     address   address   data      code       language
>>>>>>>>>     ========  ========  ========  =========  =============
>>>>>>>>> [00001307][00102190][00000000] 55         push ebp
>>>>>>>>> [00001308][00102190][00000000] 8bec       mov ebp,esp
>>>>>>>>> [0000130a][0010218c][000012e7] 68e7120000 push 000012e7 //
>>>>>>>>> push P [0000130f][00102188][00001314] e8d3ffffff call 000012e7
>>>>>>>>> // call P [000012e7][00102184][00102190] 55         push ebp
>>>>>>>>>     // enter executed P
>>>>>>>>> [000012e8][00102184][00102190] 8bec       mov ebp,esp
>>>>>>>>> [000012ea][00102184][00102190] 8b4508     mov eax,[ebp+08]
>>>>>>>>> [000012ed][00102180][000012e7] 50         push eax      //
>>>>>>>>> push P [000012ee][00102180][000012e7] 8b4d08     mov
>>>>>>>>> ecx,[ebp+08] [000012f1][0010217c][000012e7] 51         push
>>>>>>>>> ecx      // push P [000012f2][00102178][000012f7] e880feffff
>>>>>>>>> call 00001177 // call H
>>>>>>>>>
>>>>>>>>> Begin Local Halt Decider Simulation   Execution Trace Stored
>>>>>>>>> at:212244 [000012e7][00212230][00212234] 55          push ebp
>>>>>>>>>     // enter emulated P
>>>>>>>>> [000012e8][00212230][00212234] 8bec        mov ebp,esp
>>>>>>>>> [000012ea][00212230][00212234] 8b4508      mov eax,[ebp+08]
>>>>>>>>> [000012ed][0021222c][000012e7] 50          push eax      //
>>>>>>>>> push P [000012ee][0021222c][000012e7] 8b4d08      mov
>>>>>>>>> ecx,[ebp+08] [000012f1][00212228][000012e7] 51          push
>>>>>>>>> ecx      // push P [000012f2][00212224][000012f7] e880feffff
>>>>>>>>> call 00001177 // call H
>>>>>>>>
>>>>>>>> So, by what instruction reference manual is a call 00001177
>>>>>>>> followedby the execution of the instruction at 000012e7.
>>>>>>>>
>>>>>>>> Your "CPU" is broken, or emulation incorrect.
>>>>>>>>
>>>>>>>> FAIL.
>>>>>>>>> [000012e7][0025cc58][0025cc5c] 55          push ebp      //
>>>>>>>>> enter emulated P
>>>>>>>>> [000012e8][0025cc58][0025cc5c] 8bec        mov ebp,esp
>>>>>>>>> [000012ea][0025cc58][0025cc5c] 8b4508      mov eax,[ebp+08]
>>>>>>>>> [000012ed][0025cc54][000012e7] 50          push eax      //
>>>>>>>>> push P [000012ee][0025cc54][000012e7] 8b4d08      mov
>>>>>>>>> ecx,[ebp+08] [000012f1][0025cc50][000012e7] 51          push
>>>>>>>>> ecx      // push P [000012f2][0025cc4c][000012f7] e880feffff
>>>>>>>>> call 00001177 // call H Local Halt Decider: Infinite Recursion
>>>>>>>>> Detected Simulation Stopped
>>>>>>>>>
>>>>>>>>> It is completely obvious that when H(P,P) correctly emulates
>>>>>>>>> its input that it must emulate the first seven instructions of
>>>>>>>>> P. Because the seventh instruction of P repeats this process we
>>>>>>>>> know with complete certainty that the correct and complete
>>>>>>>>> emulation of P by H would never reach its final “ret”
>>>>>>>>> instruction, thus never halts.
>>>>>>>>
>>>>>>>> Problem, the 7th intruction DOESN't "Just repeat the procedure",
>>>>>>>> because that H always has the option to abort its simulation,
>>>>>>>> just like this onne did, and return to its P and see it halt.
>>>>>>> THAT YOU ARE SIMPLY TOO STUPID TO UNDERSTAND THIS IS NO ACTUAL
>>>>>>> REBUTTAL AT ALL:
>>>>>>>
>>>>>>> The partial correct x86 emulation of the input to H(P,P)
>>>>>>> conclusively proves that the complete and correct x86 emulation
>>>>>>> would never stop running.
>>>>>>>
>>>>>>
>>>>>> You SAY that, but you don't answer the actual questions about HOW.
>>>>>
>>>>> THAT YOU ARE SIMPLY TOO STUPID TO UNDERSTAND THIS IS NO EVIDENCE
>>>>> WHAT-SO-EVER THAT I DID NOT COMPLETELY PROVE THAT THE CORRECT
>>>>> PARTIAL EMULATION OF THE INPUT TO H(P,P) CONCLUSIVELY PROVES THAT
>>>>> THE CORRECT AND COMPLETE X86 EMULATION OF THE INPUT TO H(P,P)
>>>>> WOULD NEVER STOP RUNNING.
>>>>>
>>>>> It is completely obvious that when H(P,P) correctly emulates its
>>>>> input that it must emulate the first seven instructions of P.
>>>>> Because the seventh instruction of P repeats this process we know
>>>>> with complete certainty that the correct and complete emulation of
>>>>> P by H would never reach its final “ret” instruction, thus never
>>>>> halts.
>>>>
>>>> If P should have halted (i.e. no infinite loop) then your simulation
>>>> detector, S (not H), gets the answer wrong.  You S is NOT a halting
>>>> decider.
>>>>
>>>> /Flibble
>>>
>>> THAT YOU ARE SIMPLY TOO STUPID TO UNDERSTAND THIS IS NO ACTUAL
>>> REBUTTAL AT ALL.
>>>
>>> _P()
>>> [00001352](01)  55              push ebp
>>> [00001353](02)  8bec            mov ebp,esp
>>> [00001355](03)  8b4508          mov eax,[ebp+08]
>>> [00001358](01)  50              push eax      // push P
>>> [00001359](03)  8b4d08          mov ecx,[ebp+08]
>>> [0000135c](01)  51              push ecx      // push P
>>> [0000135d](05)  e840feffff      call 000011a2 // call H
>>> [00001362](03)  83c408          add esp,+08
>>> [00001365](02)  85c0            test eax,eax
>>> [00001367](02)  7402            jz 0000136b
>>> [00001369](02)  ebfe            jmp 00001369
>>> [0000136b](01)  5d              pop ebp
>>> [0000136c](01)  c3              ret
>>> Size in bytes:(0027) [0000136c]
>>>
>>> It is completely obvious that when H(P,P) correctly emulates its
>>> input that it must emulate the first seven instructions of P. Because
>>> the seventh instruction of P repeats this process we know with
>>> complete certainty that the correct and complete emulation of P by H
>>> would never reach its final “ret” instruction, thus never halts.
>>
>> We are going around and around and around in circles. I will try again:
>>
>> If you replace the opcodes "EB FE" at 00001369 with the opcodes "90 90"
>> then your H gets the answer wrong: P should have halted.
>>
>> /Flibble
>>
>
> As I already said before this is merely your cluelessness that when
> H(P,P) is invoked the correct x86 emulation of the input to H(P,P) makes
> and code after [0000135d] unreachable.


Click here to read the complete article
Re: Proving that P(P) != the correct x86 emulation of the input to H(P,P)

<BYGdnY7xlufi1D__nZ2dnUU7_8zNnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Thu, 09 Jun 2022 14:26:55 -0500
Date: Thu, 9 Jun 2022 14:26:53 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.10.0
Subject: Re: Proving that P(P) != the correct x86 emulation of the input to
H(P,P)
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <N8GdnUDJ0IRRxjz_nZ2dnUU7_8zNnZ2d@giganews.com>
<nvudncJwjNiNiz__nZ2dnUU7_81g4p2d@giganews.com>
<bipoK.10513$Vxw.6751@fx07.iad>
<jdydnWlvi_kquD__nZ2dnUU7_8zNnZ2d@giganews.com>
<RMpoK.7650$x7oc.3519@fx01.iad>
<xJKdnb8LMeMztz__nZ2dnUU7_83NnZ2d@giganews.com>
<20220609182847.00007585@reddwarf.jmc>
<N-adnVHsgaLIrT__nZ2dnUU7_8xh4p2d@giganews.com>
<20220609184617.00002add@reddwarf.jmc>
<eJ6dnaW1z8lnrj__nZ2dnUU7_83NnZ2d@giganews.com>
<vKqoK.75291$GTEb.17970@fx48.iad>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <vKqoK.75291$GTEb.17970@fx48.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <BYGdnY7xlufi1D__nZ2dnUU7_8zNnZ2d@giganews.com>
Lines: 190
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-TrgeNYZBzvCDPYgDvk0X0mUbjgZSQtvm6etbOuynlHP4+obmMt4MZMCvoYO9qn5ay3bcEefNr0p6HmO!6zpuqNQWHD21KqLSBiWQzEf7dpLHQKzgrwMpgPQbGj7+nHuHPjnNE8VxIzVezZzB7nI10rnG2n5A
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: 11288
 by: olcott - Thu, 9 Jun 2022 19:26 UTC

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


Click here to read the complete article
Re: Proving that P(P) != the correct x86 emulation of the input to H(P,P)

<J_roK.51524$ssF.13016@fx14.iad>

 copy mid

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

 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!fx14.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.10.0
Subject: Re: Proving that P(P) != the correct x86 emulation of the input to
H(P,P)
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <N8GdnUDJ0IRRxjz_nZ2dnUU7_8zNnZ2d@giganews.com>
<nvudncJwjNiNiz__nZ2dnUU7_81g4p2d@giganews.com>
<bipoK.10513$Vxw.6751@fx07.iad>
<jdydnWlvi_kquD__nZ2dnUU7_8zNnZ2d@giganews.com>
<RMpoK.7650$x7oc.3519@fx01.iad>
<xJKdnb8LMeMztz__nZ2dnUU7_83NnZ2d@giganews.com>
<20220609182847.00007585@reddwarf.jmc>
<N-adnVHsgaLIrT__nZ2dnUU7_8xh4p2d@giganews.com>
<20220609184617.00002add@reddwarf.jmc>
<eJ6dnaW1z8lnrj__nZ2dnUU7_83NnZ2d@giganews.com>
<vKqoK.75291$GTEb.17970@fx48.iad>
<BYGdnY7xlufi1D__nZ2dnUU7_8zNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <BYGdnY7xlufi1D__nZ2dnUU7_8zNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 216
Message-ID: <J_roK.51524$ssF.13016@fx14.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, 9 Jun 2022 15:38:16 -0400
X-Received-Bytes: 12231
 by: Richard Damon - Thu, 9 Jun 2022 19:38 UTC

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


Click here to read the complete article
Re: Proving that P(P) != the correct x86 emulation of the input to H(P,P)

<osadnc-FVvDu0j__nZ2dnUU7_81g4p2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Thu, 09 Jun 2022 14:52:18 -0500
Date: Thu, 9 Jun 2022 14:52:17 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.10.0
Subject: Re: Proving that P(P) != the correct x86 emulation of the input to
H(P,P)
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <N8GdnUDJ0IRRxjz_nZ2dnUU7_8zNnZ2d@giganews.com>
<nvudncJwjNiNiz__nZ2dnUU7_81g4p2d@giganews.com>
<bipoK.10513$Vxw.6751@fx07.iad>
<jdydnWlvi_kquD__nZ2dnUU7_8zNnZ2d@giganews.com>
<RMpoK.7650$x7oc.3519@fx01.iad>
<xJKdnb8LMeMztz__nZ2dnUU7_83NnZ2d@giganews.com>
<20220609182847.00007585@reddwarf.jmc>
<N-adnVHsgaLIrT__nZ2dnUU7_8xh4p2d@giganews.com>
<20220609184617.00002add@reddwarf.jmc>
<eJ6dnaW1z8lnrj__nZ2dnUU7_83NnZ2d@giganews.com>
<vKqoK.75291$GTEb.17970@fx48.iad>
<BYGdnY7xlufi1D__nZ2dnUU7_8zNnZ2d@giganews.com>
<J_roK.51524$ssF.13016@fx14.iad>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <J_roK.51524$ssF.13016@fx14.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <osadnc-FVvDu0j__nZ2dnUU7_81g4p2d@giganews.com>
Lines: 200
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-SWuyskwXaj50BiIjI7A247SR1Vn2nn+Ekqr+NgAXTIPtNLt6FWCnkBcalRpmdB4VI8mEQ371amBnLkU!v25JQDnOEZbhl8U9GZsYttdM1pzyT6tDyuDizRi8sA4enSu9pJG6qcbTvm/uFo0/p0+mx5a4Z/kU
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: 11885
 by: olcott - Thu, 9 Jun 2022 19:52 UTC

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


Click here to read the complete article
Re: Proving that P(P) != the correct x86 emulation of the input to H(P,P)

<vgsoK.21728$6P.2117@fx38.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Path: i2pn2.org!i2pn.org!weretis.net!feeder8.news.weretis.net!ecngs!feeder2.ecngs.de!178.20.174.213.MISMATCH!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!fx38.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.10.0
Subject: Re: Proving that P(P) != the correct x86 emulation of the input to
H(P,P)
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <N8GdnUDJ0IRRxjz_nZ2dnUU7_8zNnZ2d@giganews.com>
<nvudncJwjNiNiz__nZ2dnUU7_81g4p2d@giganews.com>
<bipoK.10513$Vxw.6751@fx07.iad>
<jdydnWlvi_kquD__nZ2dnUU7_8zNnZ2d@giganews.com>
<RMpoK.7650$x7oc.3519@fx01.iad>
<xJKdnb8LMeMztz__nZ2dnUU7_83NnZ2d@giganews.com>
<20220609182847.00007585@reddwarf.jmc>
<N-adnVHsgaLIrT__nZ2dnUU7_8xh4p2d@giganews.com>
<20220609184617.00002add@reddwarf.jmc>
<eJ6dnaW1z8lnrj__nZ2dnUU7_83NnZ2d@giganews.com>
<vKqoK.75291$GTEb.17970@fx48.iad>
<BYGdnY7xlufi1D__nZ2dnUU7_8zNnZ2d@giganews.com>
<J_roK.51524$ssF.13016@fx14.iad>
<osadnc-FVvDu0j__nZ2dnUU7_81g4p2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <osadnc-FVvDu0j__nZ2dnUU7_81g4p2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 217
Message-ID: <vgsoK.21728$6P.2117@fx38.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, 9 Jun 2022 15:57:14 -0400
X-Received-Bytes: 12417
 by: Richard Damon - Thu, 9 Jun 2022 19:57 UTC

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


Click here to read the complete article
Re: Proving that P(P) != the correct x86 emulation of the input to H(P,P)

<h_qdnb8cOfX0yT__nZ2dnUU7_83NnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Thu, 09 Jun 2022 15:13:29 -0500
Date: Thu, 9 Jun 2022 15:13:27 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.10.0
Subject: Re: Proving that P(P) != the correct x86 emulation of the input to
H(P,P)
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <N8GdnUDJ0IRRxjz_nZ2dnUU7_8zNnZ2d@giganews.com>
<nvudncJwjNiNiz__nZ2dnUU7_81g4p2d@giganews.com>
<bipoK.10513$Vxw.6751@fx07.iad>
<jdydnWlvi_kquD__nZ2dnUU7_8zNnZ2d@giganews.com>
<RMpoK.7650$x7oc.3519@fx01.iad>
<xJKdnb8LMeMztz__nZ2dnUU7_83NnZ2d@giganews.com>
<20220609182847.00007585@reddwarf.jmc>
<N-adnVHsgaLIrT__nZ2dnUU7_8xh4p2d@giganews.com>
<20220609184617.00002add@reddwarf.jmc>
<eJ6dnaW1z8lnrj__nZ2dnUU7_83NnZ2d@giganews.com>
<vKqoK.75291$GTEb.17970@fx48.iad>
<BYGdnY7xlufi1D__nZ2dnUU7_8zNnZ2d@giganews.com>
<J_roK.51524$ssF.13016@fx14.iad>
<osadnc-FVvDu0j__nZ2dnUU7_81g4p2d@giganews.com>
<vgsoK.21728$6P.2117@fx38.iad>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <vgsoK.21728$6P.2117@fx38.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <h_qdnb8cOfX0yT__nZ2dnUU7_83NnZ2d@giganews.com>
Lines: 227
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-MCsgb6SOzabQzMRmdylvKdvNX6ZoTo0d3OTu3yFDg1m7iWR9aKPApcbFQXurbhATGvLVSt4zT/6KJA2!RBVNALKIwfG97HTj+cofOMYUh1bluLTqBJO+hEJzh2qkt8lnSlCdGhlmiQ0cBhGm1IRfGGcgHCmB
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: 12998
 by: olcott - Thu, 9 Jun 2022 20:13 UTC

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


Click here to read the complete article
Re: Proving that P(P) != the correct x86 emulation of the input to H(P,P)

<CGsoK.16478$gjlb.2500@fx44.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Path: i2pn2.org!i2pn.org!news.neodome.net!news.uzoreto.com!news-out.netnews.com!news.alt.net!fdc2.netnews.com!feeder1.feed.usenet.farm!feed.usenet.farm!peer03.ams4!peer.am4.highwinds-media.com!peer02.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx44.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.10.0
Subject: Re: Proving that P(P) != the correct x86 emulation of the input to
H(P,P)
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <N8GdnUDJ0IRRxjz_nZ2dnUU7_8zNnZ2d@giganews.com>
<nvudncJwjNiNiz__nZ2dnUU7_81g4p2d@giganews.com>
<bipoK.10513$Vxw.6751@fx07.iad>
<jdydnWlvi_kquD__nZ2dnUU7_8zNnZ2d@giganews.com>
<RMpoK.7650$x7oc.3519@fx01.iad>
<xJKdnb8LMeMztz__nZ2dnUU7_83NnZ2d@giganews.com>
<20220609182847.00007585@reddwarf.jmc>
<N-adnVHsgaLIrT__nZ2dnUU7_8xh4p2d@giganews.com>
<20220609184617.00002add@reddwarf.jmc>
<eJ6dnaW1z8lnrj__nZ2dnUU7_83NnZ2d@giganews.com>
<vKqoK.75291$GTEb.17970@fx48.iad>
<BYGdnY7xlufi1D__nZ2dnUU7_8zNnZ2d@giganews.com>
<J_roK.51524$ssF.13016@fx14.iad>
<osadnc-FVvDu0j__nZ2dnUU7_81g4p2d@giganews.com>
<vgsoK.21728$6P.2117@fx38.iad>
<h_qdnb8cOfX0yT__nZ2dnUU7_83NnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <h_qdnb8cOfX0yT__nZ2dnUU7_83NnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 251
Message-ID: <CGsoK.16478$gjlb.2500@fx44.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, 9 Jun 2022 16:25:05 -0400
X-Received-Bytes: 13992
 by: Richard Damon - Thu, 9 Jun 2022 20:25 UTC

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


Click here to read the complete article
Re: Proving that P(P) != the correct x86 emulation of the input to H(P,P)

<-eidnS2VbJfywj__nZ2dnUU7_81g4p2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Path: i2pn2.org!i2pn.org!weretis.net!feeder8.news.weretis.net!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Thu, 09 Jun 2022 16:00:31 -0500
Date: Thu, 9 Jun 2022 16:00:30 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.10.0
Subject: Re: Proving that P(P) != the correct x86 emulation of the input to
H(P,P)
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <N8GdnUDJ0IRRxjz_nZ2dnUU7_8zNnZ2d@giganews.com>
<nvudncJwjNiNiz__nZ2dnUU7_81g4p2d@giganews.com>
<bipoK.10513$Vxw.6751@fx07.iad>
<jdydnWlvi_kquD__nZ2dnUU7_8zNnZ2d@giganews.com>
<RMpoK.7650$x7oc.3519@fx01.iad>
<xJKdnb8LMeMztz__nZ2dnUU7_83NnZ2d@giganews.com>
<20220609182847.00007585@reddwarf.jmc>
<N-adnVHsgaLIrT__nZ2dnUU7_8xh4p2d@giganews.com>
<20220609184617.00002add@reddwarf.jmc>
<eJ6dnaW1z8lnrj__nZ2dnUU7_83NnZ2d@giganews.com>
<vKqoK.75291$GTEb.17970@fx48.iad>
<BYGdnY7xlufi1D__nZ2dnUU7_8zNnZ2d@giganews.com>
<J_roK.51524$ssF.13016@fx14.iad>
<osadnc-FVvDu0j__nZ2dnUU7_81g4p2d@giganews.com>
<vgsoK.21728$6P.2117@fx38.iad>
<h_qdnb8cOfX0yT__nZ2dnUU7_83NnZ2d@giganews.com>
<CGsoK.16478$gjlb.2500@fx44.iad>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <CGsoK.16478$gjlb.2500@fx44.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <-eidnS2VbJfywj__nZ2dnUU7_81g4p2d@giganews.com>
Lines: 249
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-mfbu2+lzmOfZLMuuzKb9c6Iy+Y6ll5Y7hjUAw4LeKyJC6vomRbAANR059njX/VXsDE/tkAY4tSB4YBW!zcCwXLx1MN1CC9BXn1yZrIGyC5F+eqm426fhDg0ekrLRpw8OKJ+tuZYugyGz+DVwkahFGBUIqBLQ
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: 13976
 by: olcott - Thu, 9 Jun 2022 21:00 UTC

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


Click here to read the complete article
Re: Proving that P(P) != the correct x86 emulation of the input to H(P,P)

<PntoK.92394$J0r9.54835@fx11.iad>

 copy mid

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

 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!peer01.ams4!peer.am4.highwinds-media.com!peer03.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx11.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.10.0
Subject: Re: Proving that P(P) != the correct x86 emulation of the input to
H(P,P)
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <N8GdnUDJ0IRRxjz_nZ2dnUU7_8zNnZ2d@giganews.com>
<nvudncJwjNiNiz__nZ2dnUU7_81g4p2d@giganews.com>
<bipoK.10513$Vxw.6751@fx07.iad>
<jdydnWlvi_kquD__nZ2dnUU7_8zNnZ2d@giganews.com>
<RMpoK.7650$x7oc.3519@fx01.iad>
<xJKdnb8LMeMztz__nZ2dnUU7_83NnZ2d@giganews.com>
<20220609182847.00007585@reddwarf.jmc>
<N-adnVHsgaLIrT__nZ2dnUU7_8xh4p2d@giganews.com>
<20220609184617.00002add@reddwarf.jmc>
<eJ6dnaW1z8lnrj__nZ2dnUU7_83NnZ2d@giganews.com>
<vKqoK.75291$GTEb.17970@fx48.iad>
<BYGdnY7xlufi1D__nZ2dnUU7_8zNnZ2d@giganews.com>
<J_roK.51524$ssF.13016@fx14.iad>
<osadnc-FVvDu0j__nZ2dnUU7_81g4p2d@giganews.com>
<vgsoK.21728$6P.2117@fx38.iad>
<h_qdnb8cOfX0yT__nZ2dnUU7_83NnZ2d@giganews.com>
<CGsoK.16478$gjlb.2500@fx44.iad>
<-eidnS2VbJfywj__nZ2dnUU7_81g4p2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <-eidnS2VbJfywj__nZ2dnUU7_81g4p2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 263
Message-ID: <PntoK.92394$J0r9.54835@fx11.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Thu, 9 Jun 2022 17:13:19 -0400
X-Received-Bytes: 14500
 by: Richard Damon - Thu, 9 Jun 2022 21:13 UTC

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


Click here to read the complete article
Pages:12345
server_pubkey.txt

rocksolid light 0.9.7
clearnet tor