Rocksolid Light

Welcome to novaBBS (click a section below)

mail  files  register  newsreader  groups  login

Message-ID:  

A bug in the code is worth two in the documentation.


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

SubjectAuthor
* Anyone wanting an actual honestly dialogue on the proof that H(P,P)==0 is correcolcott
+* Anyone wanting an actual honestly dialogue on the proof thatRichard Damon
|`* Anyone wanting an actual honestly dialogue on the proof thatolcott
| `* Anyone wanting an actual honestly dialogue on the proof thatRichard Damon
|  `* Anyone wanting an actual honestly dialogue on the proof thatolcott
|   `* Anyone wanting an actual honestly dialogue on the proof that H(P,P)==0 is correcRichard Damon
|    `* Anyone wanting an actual honest dialogue on the proof that H(P,P)==0 is correctolcott
|     `* Anyone wanting an actual honest dialogue on the proof thatRichard Damon
|      `* Honest dialogue on the proof that H(P,P)==0 is correct [proof defined]olcott
|       +* Honest dialogue on the proof that H(P,P)==0 is correct [proofRichard Damon
|       |`* Honest dialogue on the proof that H(P,P)==0 is correct [proofolcott
|       | `- Honest dialogue on the proof that H(P,P)==0 is correct [proofRichard Damon
|       +* Honest dialogue on the proof that H(P,P)==0 is correct [proofRichard Damon
|       |`* Honest dialogue on the proof that H(P,P)==0 is correct [proof defined]olcott
|       | `- Honest dialogue on the proof that H(P,P)==0 is correct [proofRichard Damon
|       `* Honest dialogue on the proof that H(P,P)==0 is correct [proofAndré G. Isaak
|        `* Honest dialogue on the proof that H(P,P)==0 is correct [proofolcott
|         `* Honest dialogue on the proof that H(P,P)==0 is correct [proofAndré G. Isaak
|          `* Honest dialogue on the proof that H(P,P)==0 is correct [proofolcott
|           +* Honest dialogue on the proof that H(P,P)==0 is correct [proof defined]Malcolm McLean
|           |+* Honest dialogue on the proof that H(P,P)==0 is correct [proofolcott
|           ||+* Honest dialogue on the proof that H(P,P)==0 is correct [proofAndré G. Isaak
|           |||`* Honest dialogue on the proof that H(P,P)==0 is correct [proof defined]olcott
|           ||| +- Honest dialogue on the proof that H(P,P)==0 is correct [proof defined]olcott
|           ||| `- Honest dialogue on the proof that H(P,P)==0 is correct [proofRichard Damon
|           ||`* Honest dialogue on the proof that H(P,P)==0 is correct [proof defined]olcott
|           || `- Honest dialogue on the proof that H(P,P)==0 is correct [proofRichard Damon
|           |`* Honest dialogue on the proof that H(P,P)==0 is correct [proof defined]Ben Bacarisse
|           | +- Honest dialogue on the proof that H(P,P)==0 is correct [proof defined]olcott
|           | `* Honest dialogue on the proof that H(P,P)==0 is correct [proof defined]olcott
|           |  +- Honest dialogue on the proof that H(P,P)==0 is correct [proofRichard Damon
|           |  `* Honest dialogue on the proof that H(P,P)==0 is correct [proof defined]Malcolm McLean
|           |   `- Honest dialogue on the proof that H(P,P)==0 is correct [proofolcott
|           `* Honest dialogue on the proof that H(P,P)==0 is correct [proofAndré G. Isaak
|            `* Honest dialogue on the proof that H(P,P)==0 is correct [proof defined]olcott
|             +* Honest dialogue on the proof that H(P,P)==0 is correct [proofAndré G. Isaak
|             |`* Honest dialogue on the proof that H(P,P)==0 is correct [proof defined]olcott
|             | `* Honest dialogue on the proof that H(P,P)==0 is correct [proofAndré G. Isaak
|             |  `* Honest dialogue on the proof that H(P,P)==0 is correct [proof defined]olcott
|             |   +- Honest dialogue on the proof that H(P,P)==0 is correct [proofRichard Damon
|             |   `* Honest dialogue on the proof that H(P,P)==0 is correct [proofAndré G. Isaak
|             |    `* Honest dialogue on the proof that H(P,P)==0 is correct [proofolcott
|             |     +* Honest dialogue on the proof that H(P,P)==0 is correct [proofAndré G. Isaak
|             |     |`* Honest dialogue on the proof that H(P,P)==0 is correct [proofolcott
|             |     | +* Honest dialogue on the proof that H(P,P)==0 is correct [proofAndré G. Isaak
|             |     | |`* Honest dialogue on the proof that H(P,P)==0 is correct [proofolcott
|             |     | | `* Honest dialogue on the proof that H(P,P)==0 is correct [proofAndré G. Isaak
|             |     | |  `* Honest dialogue on the proof that H(P,P)==0 is correct [proof defined]olcott
|             |     | |   `* Honest dialogue on the proof that H(P,P)==0 is correct [proofAndré G. Isaak
|             |     | |    `* Honest dialogue on the proof that H(P,P)==0 is correct [proof defined]olcott
|             |     | |     +* Honest dialogue on the proof that H(P,P)==0 is correct [proofAndré G. Isaak
|             |     | |     |`* Honest dialogue on the proof that H(P,P)==0 is correct [proof defined]olcott
|             |     | |     | `- Honest dialogue on the proof that H(P,P)==0 is correct [proofRichard Damon
|             |     | |     `- Honest dialogue on the proof that H(P,P)==0 is correct [proof defined]Malcolm McLean
|             |     | `- Honest dialogue on the proof that H(P,P)==0 is correct [proofRichard Damon
|             |     `- Honest dialogue on the proof that H(P,P)==0 is correct [proofRichard Damon
|             `- Honest dialogue on the proof that H(P,P)==0 is correct [proofRichard Damon
`* Anyone wanting an actual honestly dialogue on the proof that H(P,P)==0 is correcAlan Mackenzie
 `* Honest dialogue on the proof that H(P,P)==0 is correctolcott
  +* Honest dialogue on the proof that H(P,P)==0 is correctAlan Mackenzie
  |`* Honest dialogue on the proof that H(P,P)==0 is correct [ easy asolcott
  | `* Honest dialogue on the proof that H(P,P)==0 is correct [ easy as 1,2,3 ]Alan Mackenzie
  |  `* Honest dialogue on the proof that H(P,P)==0 is correct [ easy asolcott
  |   `* Honest dialogue on the proof that H(P,P)==0 is correct [ easy as 1,2,3 ]Alan Mackenzie
  |    `* Honest dialogue on the proof that H(P,P)==0 is correct [ easy asolcott
  |     `* Honest dialogue on the proof that H(P,P)==0 is correct [ easy as 1,2,3 ]Alan Mackenzie
  |      `* Honest dialogue on the proof that H(P,P)==0 is correct [ easy asolcott
  |       `* Honest dialogue on the proof that H(P,P)==0 is correct [ easy as 1,2,3 ]Alan Mackenzie
  |        `* Honest dialogue on the proof that H(P,P)==0 is correct [ easy as 1,2,3 ]olcott
  |         `* Honest dialogue on the proof that H(P,P)==0 is correct [ easy as 1,2,3 ]Alan Mackenzie
  |          +- Honest dialogue on the proof that H(P,P)==0 is correct [ easy asolcott
  |          `- Honest dialogue on the proof that H(P,P)==0 is correct [ easy asolcott
  `- Honest dialogue on the proof that H(P,P)==0 is correctRichard Damon

Pages:123
Re: Honest dialogue on the proof that H(P,P)==0 is correct [ easy as 1,2,3 ]

<semvmc$2iij$1@news.muc.de>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder8.news.weretis.net!news-peer.in.tum.de!news.muc.de!.POSTED.news.muc.de!not-for-mail
From: acm...@muc.de (Alan Mackenzie)
Newsgroups: comp.theory
Subject: Re: Honest dialogue on the proof that H(P,P)==0 is correct [ easy as 1,2,3 ]
Date: Sat, 7 Aug 2021 21:58:36 -0000 (UTC)
Organization: muc.de e.V.
Message-ID: <semvmc$2iij$1@news.muc.de>
References: <HNidndugKOWGvpH8nZ2dnUU7-fXNnZ2d@giganews.com> <seltf3$2g9r$1@news.muc.de> <JOCdnfw1VaEaDZP8nZ2dnUU7-YPNnZ2d@giganews.com> <sem7cg$puv$1@news.muc.de> <q7ydnRnqSvJBO5P8nZ2dnUU7-avNnZ2d@giganews.com> <semc4h$27g8$1@news.muc.de> <Kqudna8HOpsQJZP8nZ2dnUU78fednZ2d@giganews.com> <semgka$27g8$2@news.muc.de> <8v6dnTrkQ_4qd5P8nZ2dnUU7-LfNnZ2d@giganews.com> <sems1k$27g8$3@news.muc.de> <8PmdnaQYrtbBapP8nZ2dnUU78IHNnZ2d@giganews.com>
Injection-Date: Sat, 7 Aug 2021 21:58:36 -0000 (UTC)
Injection-Info: news.muc.de; posting-host="news.muc.de:2001:608:1000::2";
logging-data="84563"; mail-complaints-to="news-admin@muc.de"
User-Agent: tin/2.4.5-20201224 ("Glen Albyn") (FreeBSD/12.2-RELEASE-p7 (amd64))
 by: Alan Mackenzie - Sat, 7 Aug 2021 21:58 UTC

[ Yet more malicious cross posting removed. ]

In comp.theory olcott <NoOne@nowhere.com> wrote:
> On 8/7/2021 3:56 PM, Alan Mackenzie wrote:
>> [ Malicious cross posting removed. ]

>> In comp.theory olcott <NoOne@nowhere.com> wrote:

[ .... ]

>>> Irrefutable is another word for correct.

>> It is not. They are different words with different meanings. Hint: in
>> English there are few pairs of words indeed with identical meanings.

[ .... ]

>>>> If you truly, honestly wanted review, you would post your source code.

>> No answer? You don't actually have source code for an H, do you?

There is no H, is there?

>>> The following code proves beyond all possible doubt ....

[ .... ]

>> Now come nothing but lies from you. You don't honestly think that dumped
>> object code from ~4 lines of C source can prove _anything_ "beyond all
>> possible doubt", surely? You are just lying.

> I am not the one that keeps deleting the code that proves that I am right.

It's not interesting. All it proves is that you've got a working
compiler, or alternatively you can hand compile a short fragment of code.
If you want to prove something more you need to do more than just dumping
a short block of compiled code. You need to give arguments.

> If you think that I am wrong then show how a pure simulation of the
> above code can possibly reach its final state of [00000d1c] when we know
> that and can verify that H acts as a pure simulator of P(P).

I don't think you are wrong, in whatever manner you mean. I know you are
wrong. I know you are a liar, and you haven't got any "H" written. H
isn't possible, as has been proven many times. You don't have anything
approaching an H. If you had, you would have said so in the course of
the last few posts. Hint: if you're going to be a successful liar,
you've got to lie all the time and consistently.

>>> .... that the pure simulation of P on its input P by H cannot possibly
>>> reach its final state of [00000d1c] whether or not H aborts this
>>> simulation. It seems that you are either in psychological denial or
>>> worse: (the opposite of an honest dialogue).

>> Until we know exactly what H does, and how, we can't have any honest
>> dialogue about it.

> We can see that H acts as a pure simulator of the above code from this
> execution trace of the simulation of P by H:

There is no H. You don't have an H, and have been lying about it for
ages.

[ .... ]

> --
> Copyright 2021 Pete Olcott

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

--
Alan Mackenzie (Nuremberg, Germany).

Re: Honest dialogue on the proof that H(P,P)==0 is correct [ easy as 1,2,3 ]

<64WdncfCqdFLkpL8nZ2dnUU7-W3NnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!aioe.org!feeder1.feed.usenet.farm!feed.usenet.farm!tr2.eu1.usenetexpress.com!feeder.usenetexpress.com!tr1.iad1.usenetexpress.com!border1.nntp.dca1.giganews.com!nntp.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Sat, 07 Aug 2021 17:57:26 -0500
Subject: Re: Honest dialogue on the proof that H(P,P)==0 is correct [ easy as 1,2,3 ]
Newsgroups: comp.theory
References: <HNidndugKOWGvpH8nZ2dnUU7-fXNnZ2d@giganews.com> <seltf3$2g9r$1@news.muc.de> <JOCdnfw1VaEaDZP8nZ2dnUU7-YPNnZ2d@giganews.com> <sem7cg$puv$1@news.muc.de> <q7ydnRnqSvJBO5P8nZ2dnUU7-avNnZ2d@giganews.com> <semc4h$27g8$1@news.muc.de> <Kqudna8HOpsQJZP8nZ2dnUU78fednZ2d@giganews.com> <semgka$27g8$2@news.muc.de> <8v6dnTrkQ_4qd5P8nZ2dnUU7-LfNnZ2d@giganews.com> <sems1k$27g8$3@news.muc.de> <8PmdnaQYrtbBapP8nZ2dnUU78IHNnZ2d@giganews.com> <semvmc$2iij$1@news.muc.de>
From: NoO...@NoWhere.com (olcott)
Date: Sat, 7 Aug 2021 17:57:25 -0500
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:78.0) Gecko/20100101 Thunderbird/78.12.0
MIME-Version: 1.0
In-Reply-To: <semvmc$2iij$1@news.muc.de>
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Language: en-US
Content-Transfer-Encoding: 7bit
Message-ID: <64WdncfCqdFLkpL8nZ2dnUU7-W3NnZ2d@giganews.com>
Lines: 123
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-KpFpX5ucn625+LTO/SjqMoWwIx+ARsreRERiGcYMqonrQ6njCZQy3d67mSAxjVmxFiUjfwvl26Ojj09!DvT63ZT7i17/R293F/dtIZ+MrHkaaIiBQ86SP5t7Zu2WBEs1fwBxg0W/QGq2zWRDgJ7Kzxa2Pw==
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: 6635
 by: olcott - Sat, 7 Aug 2021 22:57 UTC

On 8/7/2021 4:58 PM, Alan Mackenzie wrote:
> [ Yet more malicious cross posting removed. ]
>
> In comp.theory olcott <NoOne@nowhere.com> wrote:
>> On 8/7/2021 3:56 PM, Alan Mackenzie wrote:
>>> [ Malicious cross posting removed. ]
>
>>> In comp.theory olcott <NoOne@nowhere.com> wrote:
>
> [ .... ]
>
>>>> Irrefutable is another word for correct.
>
>>> It is not. They are different words with different meanings. Hint: in
>>> English there are few pairs of words indeed with identical meanings.
>
> [ .... ]
>
>>>>> If you truly, honestly wanted review, you would post your source code.
>
>>> No answer? You don't actually have source code for an H, do you?
>
> There is no H, is there?
>
>>>> The following code proves beyond all possible doubt ....
>
> [ .... ]
>
>>> Now come nothing but lies from you. You don't honestly think that dumped
>>> object code from ~4 lines of C source can prove _anything_ "beyond all
>>> possible doubt", surely? You are just lying.
>
>> I am not the one that keeps deleting the code that proves that I am right.
>
> It's not interesting. All it proves is that you've got a working
> compiler, or alternatively you can hand compile a short fragment of code.
> If you want to prove something more you need to do more than just dumping
> a short block of compiled code. You need to give arguments.
>
>> If you think that I am wrong then show how a pure simulation of the
>> above code can possibly reach its final state of [00000d1c] when we know
>> that and can verify that H acts as a pure simulator of P(P).
>
> I don't think you are wrong, in whatever manner you mean. I know you are
> wrong. I know you are a liar, and you haven't got any "H" written. H
> isn't possible, as has been proven many times. You don't have anything
> approaching an H. If you had, you would have said so in the course of
> the last few posts. Hint: if you're going to be a successful liar,
> you've got to lie all the time and consistently.
>

If you wanted an actual honest dialogue you would use logic and
reasoning to show exactly how the simulated P would reach its final
state of [00000d1c] when we know that H is a pure x86 emulator of P
until it makes its halt status decision.

On the other hand if you were a mere liar you would use all kinds of
subterfuge an rhetoric to avoid this direct challenge.

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

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

>>>> .... that the pure simulation of P on its input P by H cannot possibly
>>>> reach its final state of [00000d1c] whether or not H aborts this
>>>> simulation. It seems that you are either in psychological denial or
>>>> worse: (the opposite of an honest dialogue).
>
>>> Until we know exactly what H does, and how, we can't have any honest
>>> dialogue about it.
>
>> We can see that H acts as a pure simulator of the above code from this
>> execution trace of the simulation of P by H:
>
> There is no H. You don't have an H, and have been lying about it for
> ages.
>
> [ .... ]
>
>> --
>> Copyright 2021 Pete Olcott
>
>> "Great spirits have always encountered violent opposition from mediocre
>> minds." Einstein
>

--
Copyright 2021 Pete Olcott

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

Re: Honest dialogue on the proof that H(P,P)==0 is correct [proof defined]

<J0IPI.2381$6h1.994@fx39.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder8.news.weretis.net!feeder1.feed.usenet.farm!feed.usenet.farm!fdc3.netnews.com!news-out.netnews.com!news.alt.net!fdc2.netnews.com!peer01.ams1!peer.ams1.xlned.com!news.xlned.com!peer01.ams4!peer.am4.highwinds-media.com!peer01.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx39.iad.POSTED!not-for-mail
Subject: Re: Honest dialogue on the proof that H(P,P)==0 is correct [proof
defined]
Newsgroups: comp.theory
References: <HNidndugKOWGvpH8nZ2dnUU7-fXNnZ2d@giganews.com>
<Vs0PI.2099$xY.509@fx05.iad> <GLudnUM2eaoEC5H8nZ2dnUU7-evNnZ2d@giganews.com>
<5Z1PI.1823$6h1.1128@fx39.iad>
<r6idnXrkQsZ5JJH8nZ2dnUU7-V_NnZ2d@giganews.com> <qb9PI.22$uV3.2@fx18.iad>
<6radnYHwiMoYvpD8nZ2dnUU7-UPNnZ2d@giganews.com> <owaPI.297$uk4.251@fx20.iad>
<a82dnc_0ypriwZD8nZ2dnUU7-QHNnZ2d@giganews.com> <gxmPI.2323$805.954@fx43.iad>
<TaCdnU7ZFu4bmJP8nZ2dnUU7-LfNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:78.0)
Gecko/20100101 Thunderbird/78.12.0
MIME-Version: 1.0
In-Reply-To: <TaCdnU7ZFu4bmJP8nZ2dnUU7-LfNnZ2d@giganews.com>
Content-Type: text/plain; charset=utf-8
Content-Language: en-US
Content-Transfer-Encoding: 8bit
Lines: 115
Message-ID: <J0IPI.2381$6h1.994@fx39.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: Sat, 7 Aug 2021 23:16:54 -0400
X-Received-Bytes: 5171
 by: Richard Damon - Sun, 8 Aug 2021 03:16 UTC

On 8/7/21 12:01 AM, olcott wrote:
> On 8/6/2021 9:49 PM, Richard Damon wrote:
>> Pulling out one IMPORTANT arguement.
>>
>> On 8/6/21 10:59 AM, olcott wrote:
>>>
>>> The Halting problem does not pertain to the behavior of P, it only
>>> pertains the behavior of the input to P.
>>>
>>>       the Turing machine halting problem. Simply stated, the problem
>>>       is: given the description of a Turing machine M and an input w,
>>>       does M, when started in the initial configuration q0w, perform a
>>>       computation that eventually halts? (Linz:1990:317).
>>
>> READ THAT AGAIN,
>>
>> given the description of a Turing Machine M: Thus the input is the
>> description, and M is the actual Turing Machine that it is the
>> description of.
>>
>> Does M, ... perform a computation that eventually halts.
>>
>> Thus, it is the behavior of the ACTUAL Machine that matters.
>>
>
> It is the behavior of the machine that is input to H that matters.

Read it again.

Machibns are not inputs, descriptions are the input.

The Machine that the input to H is a desciption of is the Machine H^,
the exact same algorithm that is in the H^ that when run as the top
level machine is shown and admitted by you, to Halt.

> It is not the behavior of the machine executed in main() that matters.
> I prove that the input to H(P,P) never reaches its final state.

The are the SAME Machine. They are different instances, but ALL copies
of a given algorithm behave identically.

This is fundamental to the definition of a Computation and a Turing Machine.

If the Machine that the description of was given to H doesn't act
exactly the same as the H^(H^) called by main then you have an error in
your construction, and your whole argument is thus bogus.

PERIOD.

>
>
> // Simplified Linz Ĥ (Linz:1990:319)
> // Strachey(1965) CPL translated to C
>
> void P(u32 x)
> {
>   if (H(x, x))
>     HERE: goto HERE;
> }
>
> int main()
> {
>   P((u32)P);
> }
>
>> What is the input to H, it is the description of the Turing Machine P.
>> Thus what matter, the behavior of the ACTUAL Turing Machine P
>>
>
> Yes you are the only one that got this right.
>
>> Not, as you seem to want to try to claim, what happens inside the
>> partial simulation by H of the desciption of P.
>>
>
> Do you understand the x86 language well enough to see that a complete
> simulation of P keeps repeating ???

INBCOMPLETE simulation.

Your x86 is broken as call isn't working right.

Previously proven that it is incorrect.

>
> _P()
> [00000c25](01)  55          push ebp
> [00000c26](02)  8bec        mov ebp,esp
> [00000c28](03)  8b4508      mov eax,[ebp+08]
> [00000c2b](01)  50          push eax       // push P
> [00000c2c](03)  8b4d08      mov ecx,[ebp+08]
> [00000c2f](01)  51          push ecx       // push P
> [00000c30](05)  e820fdffff  call 00000955  // call H that simulates P
> [00000c35](03)  83c408      add esp,+08
> [00000c38](02)  85c0        test eax,eax
> [00000c3a](02)  7402        jz 00000c3e
> [00000c3c](02)  ebfe        jmp 00000c3c
> [00000c3e](01)  5d          pop ebp
> [00000c3f](01)  c3          ret
> Size in bytes:(0027) [00000c3f]
>
>
>> Can you understand those words????
>>
>>
>> FAIR WARING, if you repeat this claim without showing a REAL error in
>> this statement, I reserve the right to just point to this message and
>> point out that it has been disproven.
>>
>
> You got one key element correctly.
>

Your Rebutal is invalid, all you have done is effectively admit that
your system isn't constructed right.

Re: Honest dialogue on the proof that H(P,P)==0 is correct

<G3IPI.653$B8.165@fx19.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder8.news.weretis.net!feeder1.feed.usenet.farm!feed.usenet.farm!newsfeed.xs4all.nl!newsfeed8.news.xs4all.nl!news-out.netnews.com!news.alt.net!fdc2.netnews.com!peer01.ams1!peer.ams1.xlned.com!news.xlned.com!peer02.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx19.iad.POSTED!not-for-mail
Subject: Re: Honest dialogue on the proof that H(P,P)==0 is correct
Newsgroups: comp.theory
References: <HNidndugKOWGvpH8nZ2dnUU7-fXNnZ2d@giganews.com>
<seltf3$2g9r$1@news.muc.de> <JOCdnfw1VaEaDZP8nZ2dnUU7-YPNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:78.0)
Gecko/20100101 Thunderbird/78.12.0
MIME-Version: 1.0
In-Reply-To: <JOCdnfw1VaEaDZP8nZ2dnUU7-YPNnZ2d@giganews.com>
Content-Type: text/plain; charset=utf-8
Content-Language: en-US
Content-Transfer-Encoding: 8bit
Lines: 68
Message-ID: <G3IPI.653$B8.165@fx19.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: Sat, 7 Aug 2021 23:20:05 -0400
X-Received-Bytes: 4124
 by: Richard Damon - Sun, 8 Aug 2021 03:20 UTC

On 8/7/21 9:54 AM, olcott wrote:
> On 8/7/2021 7:14 AM, Alan Mackenzie wrote:
>> In comp.theory olcott <NoOne@nowhere.com> wrote:
>>> The x86utm operating system was created so that the halting problem
>>> could be examined concretely in the high level language of C. H is a
>>> function written in C that analyzes the x86 machine language execution
>>> trace of other functions written in C. H recognizes simple cases of
>>> infinite recursion and infinite loops. The conventional halting
>>> problem proof counter-example template is shown to simply be an input
>>> that does not halt.
>>
>>> H simulates its input with an x86 emulator until it determines that
>>> its input would never halt. As soon as H recognizes that its input
>>> would never halt it stops simulating this input and returns 0. For
>>> inputs that do halt H acts exactly as if it was an x86 emulator and
>>> simply runs its input to completion and then returns 1.
>>
>>>     In computability theory, the halting problem is the problem of
>>>     determining, from a description of an arbitrary computer program
>>>     and an input, whether the program will finish running, or continue
>>>     to run forever.  https://en.wikipedia.org/wiki/Halting_problem
>>
>>> Simulating partial halt decider H correctly decides that P(P) never
>>> halts (V2)
>>
>> If you wanted a truly honest debate about your "proof", you would make
>> the source code for H available, assuming it actually exists.
>>
>
> What the source-code does and how it does it can be fully proven
> entirely on the basis of what has been provided.
>
> That people insist on seeing the source-code only proves that they are
> not paying enough attention.
>
> The nested simulated calls never return whether or not they are aborted.
> The infinitely nested simulations never stop unless they are aborted.

Except that you have posted traces where the first call to H made by P
does return, and thus shows that P(P) is Halting.

Maybe your memory is faulty about this.

The is no infinitely nested simulation if H is able to give an answer.
Your infinity is something like 3, which is pretty far from infinity.

>
> _P()
> [00000d02](01)  55          push ebp
> [00000d03](02)  8bec        mov ebp,esp
> [00000d05](03)  8b4508      mov eax,[ebp+08]
> [00000d08](01)  50          push eax       // push P
> [00000d09](03)  8b4d08      mov ecx,[ebp+08]
> [00000d0c](01)  51          push ecx       // push P
> [00000d0d](05)  e870feffff  call 00000b82  // call H that emulates P
> [00000d12](03)  83c408      add esp,+08
> [00000d15](02)  85c0        test eax,eax
> [00000d17](02)  7402        jz 00000d1b
> [00000d19](02)  ebfe        jmp 00000d19
> [00000d1b](01)  5d          pop ebp
> [00000d1c](01)  c3          ret
> Size in bytes:(0027) [00000d1c]
>
> https://www.researchgate.net/publication/351947980_Halting_problem_undecidability_and_infinitely_nested_simulation
>
>
>

Re: Honest dialogue on the proof that H(P,P)==0 is correct [proof defined]

<k2JPI.3552$xY.3301@fx05.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!aioe.org!news.uzoreto.com!news-out.netnews.com!news.alt.net!fdc2.netnews.com!peer03.ams1!peer.ams1.xlned.com!news.xlned.com!peer01.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx05.iad.POSTED!not-for-mail
Subject: Re: Honest dialogue on the proof that H(P,P)==0 is correct [proof
defined]
Newsgroups: comp.theory
References: <HNidndugKOWGvpH8nZ2dnUU7-fXNnZ2d@giganews.com>
<Vs0PI.2099$xY.509@fx05.iad> <GLudnUM2eaoEC5H8nZ2dnUU7-evNnZ2d@giganews.com>
<5Z1PI.1823$6h1.1128@fx39.iad>
<r6idnXrkQsZ5JJH8nZ2dnUU7-V_NnZ2d@giganews.com> <qb9PI.22$uV3.2@fx18.iad>
<6radnYHwiMoYvpD8nZ2dnUU7-UPNnZ2d@giganews.com> <owaPI.297$uk4.251@fx20.iad>
<a82dnc_0ypriwZD8nZ2dnUU7-QHNnZ2d@giganews.com>
<7xmPI.10384$lK.4235@fx41.iad>
<WJOdnYLE8v7tnpP8nZ2dnUU7-XHNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:78.0)
Gecko/20100101 Thunderbird/78.12.0
MIME-Version: 1.0
In-Reply-To: <WJOdnYLE8v7tnpP8nZ2dnUU7-XHNnZ2d@giganews.com>
Content-Type: text/plain; charset=utf-8
Content-Language: en-US
Content-Transfer-Encoding: 8bit
Lines: 771
Message-ID: <k2JPI.3552$xY.3301@fx05.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: Sun, 8 Aug 2021 00:26:56 -0400
X-Received-Bytes: 29062
 by: Richard Damon - Sun, 8 Aug 2021 04:26 UTC

On 8/6/21 11:52 PM, olcott wrote:
> On 8/6/2021 9:49 PM, Richard Damon wrote:
>> On 8/6/21 10:59 AM, olcott wrote:
>>> On 8/6/2021 8:09 AM, Richard Damon wrote:
>>>> On 8/6/21 6:56 AM, olcott wrote:
>>>>> On 8/6/2021 6:38 AM, Richard Damon wrote:
>>>>>> On 8/5/21 11:26 PM, olcott wrote:
>>>>>>> On 8/5/2021 10:25 PM, Richard Damon wrote:
>>>>>>>> On 8/5/21 8:55 PM, olcott wrote:
>>>>>>>>
>>>>>>>>> I don't refuse to respond to rebuttals. I refuse to respond to
>>>>>>>>> you.
>>>>>>>>>
>>>>>>>>> I also refuse to respond to dishonest dodges, changing the
>>>>>>>>> subject to
>>>>>>>>> avoid addressing the point at hand.
>>>>>>>>>
>>>>>>>>> As soon as I prove my point people change the subject.
>>>>>>>>> It is counter-productive for me to tolerate this.
>>>>>>>>>
>>>>>>>>> void P(u32 x)
>>>>>>>>> {
>>>>>>>>>       if (H(x, x))
>>>>>>>>>         HERE: goto HERE;
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> It took fifty exchanges for you to pay enough attention to
>>>>>>>>> acknowledge
>>>>>>>>> that int main(){ P(P); } never halts when we assume that H is
>>>>>>>>> only a
>>>>>>>>> pure simulator.
>>>>>>>>>
>>>>>>>>
>>>>>>>> No, you refuse to responde to rebuttals from me because I present
>>>>>>>> rebuttals so clear that you can't come up with an answer to them.
>>>>>>>>
>>>>>>>
>>>>>>> All of your "rebuttals" are entirely anchored in your inability
>>>>>>> to pay
>>>>>>> attention.
>>>>>>>
>>>>>>
>>>>>> FALSE.
>>>>>>
>>>>>> You lack of responses shows you don't understand any of the theory
>>>>>> you
>>>>>> are talking about.
>>>>>>
>>>>>>>> What you call a 'dishonest dodge' is me pointing out that the Nth
>>>>>>>> time
>>>>>>>> you start an arguement, and are trying to misuse a terminology,
>>>>>>>> that I
>>>>>>>
>>>>>>> It does not freaking matter that I misuse terminology that is a
>>>>>>> freaking
>>>>>>> dishonest dodge. What matters is that my halt decider is correct.
>>>>>>>
>>>>>>
>>>>>> Only if you are misusing the word 'correct', or is it Halting.
>>>>>>
>>>>>> Misuse of terminology is Fundamentally wrong.
>>>>>
>>>>> I don't misuse those words. If I misuse terminology that it
>>>>> material to
>>>>> my proof then there is a problem.
>>>>
>>>> Yes, words like Turing Machine, or Halting, or Correct, or Equivalent,
>>>> or even Proof.
>>>>
>>>> You don't seem to really know what these are.
>>>>
>>>
>>> (1) Turing Machine, I use this term correctly no errors can be
>>> pointed out.
>>
>> No, you use the word, but claim things are equivalent that can not be.
>>
>> For instance, you claim that the Turing Machine for the H^ Machine
>> doesn't include a copy of the machine H, which it must.
>>
>>
>
> A RASP machine need not have any copy of its input.

WRONG.

Maybe we need to add Universal (as in Universl Simulator) to your list
of abused/misunderstood words.

Basic Software Engineering Principle, if a simulator is to be a
UNIVERSAL simulator, it must impose NO restrictions on the code of the
machine to be simulated, thus it can not require that machine to have a
copy of the simulator in it, thus the machine to be simulated needs to
be supplied in an independent virtual address space (yes, the
representation will be available to the simulator in its own address
space so it can get to it to simulate, but the simulated machine will
see a totally independent address space).

This implies at least a conceptual copy in H^, as it needs to take its
input from its own address space as its input, and create a new virtual
space to be run in.

A side effect of this is that your 'trick' of detecting recursion by
matching addresses doesn't work any more as there is no requirement that
the address of the simulator in its address space will when looked at in
the address space of the simulated machine also represents itself.

> A RASP machine is essentially a very simplified form of the x86
> language.

WRONG.

> https://en.wikipedia.org/wiki/Random-access_stored-program_machine

Compare that to the x86 execution model.

If the RASP is a simplified version of x86, then it shoud be easy to
write a simple cross translator that takes a RASP program and generates
x86 assembly code that it its equivalent. TRY IT (not writing a RASP
emulator, but translate RASP code inot x86 code).

Remember, in the RASP machine, each memory location is an arbitrary
precision number. A RASP machine is only as similar to an x86 machine as
8 is similar to infinity. Maybe you come from the tribe that can only
count to 3, and after that is 'many'.

There is ONE important simularity that is worth mentioning, unlike
Turing Machines where anything representable as a 'sub-machine' that can
be run will also be a true computation, RASP machines like x86, since
they intermix state with algorithm, do not guarantee that sub-machines
also represent a real computation, as they can hide state that breaks
this property.

This is one reason the Halting Problem is Stated in Terms of Turing
Machines, as that Computation Property is an important part of the
definition of the problem, The Halting Question is only applicable for
something that is a computation.

Also note, RASP machiines don't really have a separate 'input', a given
machine encodes both the algorithm and the input data together, so the
statement is a bit harder to form.

Unlike x86 machines though, a complete RASP machine will always be a
true computation, as it as all the information encoded in it to create
its answer, while x86 machines have the possiblity of interacting with
the external environment, and thus get data later, that needs to be
encapsulated as part of its input to make it a computation.

>
>>
>>
>>>
>>> (2) Halting, I may have adapted the original definition, or not.
>>> According to André the final state of a computation must be reached for
>>> a computation to be considered as having halted.
>>
>> Right,
>>
>>>
>>> (3) Equivalent, I have adapted the original definition to apply to
>>> subsets of computations.
>>
>> There is no 'adapted', things either ARE equivalent or they are not.
>>
>
> It is unconventional to even refer to a subset of computations as
> equivalent across two different machine architectures. None-the-less the
> x86 language is Turing equivalent for the subset of computations that do
> not require more memory than is available.
>

That just shows you don't understand what equivalence means. The whole
concept of Turing Equivalence is to talk about very different
architectures, and it is FULLY defined for this case.

Yes, the finiteness of the x86 says it can't replecate EVERY machine,
but that finiteness is easily quantified. The key is that for the
machihnes within the domain of the equivalence, how that works is
PRECISELY defined, and your model doesn't met it.

>> Your 'Equivalent' to the H^ Turing machine which takes a representaion,
>> and makes a copy, doesn't make a copy. This makes it not the equivalent,
>> especially since you then use an address comparison test to find that
>> they are the same machine which can't actually be done in a Turing
>> Machine (maybe you can show your great knowledge of Truing Machine by
>> showing how you could do this with a REAL Turing Machine).
>>
>>>
>>> (4) Correct means that the condition of a conditional expression is
>>> satisfied.
>>
>> Halting == Non-Haltign is Correct???
>>
>> You don't even seem to understand what is a valid premise.
>
> Premises are never valid, they are true or false.
> If you want an honest dialogue then you will accept this correction.


Click here to read the complete article
Re: Honest dialogue on the proof that H(P,P)==0 is correct [ easy as 1,2,3 ]

<seoiit$aq3$1@news.muc.de>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder8.news.weretis.net!news-peer.in.tum.de!news.muc.de!.POSTED.news.muc.de!not-for-mail
From: acm...@muc.de (Alan Mackenzie)
Newsgroups: comp.theory
Subject: Re: Honest dialogue on the proof that H(P,P)==0 is correct [ easy as 1,2,3 ]
Date: Sun, 8 Aug 2021 12:27:09 -0000 (UTC)
Organization: muc.de e.V.
Message-ID: <seoiit$aq3$1@news.muc.de>
References: <HNidndugKOWGvpH8nZ2dnUU7-fXNnZ2d@giganews.com> <JOCdnfw1VaEaDZP8nZ2dnUU7-YPNnZ2d@giganews.com> <sem7cg$puv$1@news.muc.de> <q7ydnRnqSvJBO5P8nZ2dnUU7-avNnZ2d@giganews.com> <semc4h$27g8$1@news.muc.de> <Kqudna8HOpsQJZP8nZ2dnUU78fednZ2d@giganews.com> <semgka$27g8$2@news.muc.de> <8v6dnTrkQ_4qd5P8nZ2dnUU7-LfNnZ2d@giganews.com> <sems1k$27g8$3@news.muc.de> <8PmdnaQYrtbBapP8nZ2dnUU78IHNnZ2d@giganews.com> <semvmc$2iij$1@news.muc.de> <64WdncfCqdFLkpL8nZ2dnUU7-W3NnZ2d@giganews.com>
Injection-Date: Sun, 8 Aug 2021 12:27:09 -0000 (UTC)
Injection-Info: news.muc.de; posting-host="news.muc.de:2001:608:1000::2";
logging-data="11075"; mail-complaints-to="news-admin@muc.de"
User-Agent: tin/2.4.5-20201224 ("Glen Albyn") (FreeBSD/12.2-RELEASE-p7 (amd64))
 by: Alan Mackenzie - Sun, 8 Aug 2021 12:27 UTC

olcott <NoOne@nowhere.com> wrote:

[ .... ]

> If you wanted an actual honest dialogue you would use logic and
> reasoning to show exactly how the simulated P would reach its final
> state of [00000d1c] when we know that H is a pure x86 emulator of P
> until it makes its halt status decision.

How dare you try to tell me how to conduct a dialogue. If I wanted an
actual honest dialogue, I wouldn't chose you as my dialogue partner. You
are not honest.

You have been lying about the existence of your H for a very long time.
But you are not a sufficiently consequent liar. There's something
stopping you from moving from implicitly asserting the existence of H to
barefaced lying about it.

So, i challenge you once more. Either assert the actual existence of
your H, or admit it does not exist.

> On the other hand if you were a mere liar you would use all kinds of
> subterfuge an rhetoric to avoid this direct challenge.

As I've said often enough before, I don't lie on Usenet, ever.

[ .... ]

> --
> Copyright 2021 Pete Olcott

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

--
Alan Mackenzie (Nuremberg, Germany).

Re: Honest dialogue on the proof that H(P,P)==0 is correct [proof defined]

<sep914$6pc$1@dont-email.me>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!eternal-september.org!reader02.eternal-september.org!.POSTED!not-for-mail
From: agis...@gm.invalid (André G. Isaak)
Newsgroups: comp.theory
Subject: Re: Honest dialogue on the proof that H(P,P)==0 is correct [proof
defined]
Date: Sun, 8 Aug 2021 12:50:10 -0600
Organization: Christians and Atheists United Against Creeping Agnosticism
Lines: 159
Message-ID: <sep914$6pc$1@dont-email.me>
References: <HNidndugKOWGvpH8nZ2dnUU7-fXNnZ2d@giganews.com>
<Vs0PI.2099$xY.509@fx05.iad> <GLudnUM2eaoEC5H8nZ2dnUU7-evNnZ2d@giganews.com>
<5Z1PI.1823$6h1.1128@fx39.iad>
<r6idnXrkQsZ5JJH8nZ2dnUU7-V_NnZ2d@giganews.com> <qb9PI.22$uV3.2@fx18.iad>
<6radnYHwiMoYvpD8nZ2dnUU7-UPNnZ2d@giganews.com> <owaPI.297$uk4.251@fx20.iad>
<a82dnc_0ypriwZD8nZ2dnUU7-QHNnZ2d@giganews.com> <sel07d$pcf$1@dont-email.me>
<DdCdnaOAJLE3l5P8nZ2dnUU7-enNnZ2d@giganews.com>
Mime-Version: 1.0
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Sun, 8 Aug 2021 18:50:13 -0000 (UTC)
Injection-Info: reader02.eternal-september.org; posting-host="bb9a4cf507cdc6bba556b41a0d65940a";
logging-data="6956"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX18FbJ8l5TMT/t8fDFTzgX2J"
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.14; rv:68.0)
Gecko/20100101 Thunderbird/68.12.1
Cancel-Lock: sha1:jOdEyNQXnAyGX6JWGEO/FN2K1Ik=
In-Reply-To: <DdCdnaOAJLE3l5P8nZ2dnUU7-enNnZ2d@giganews.com>
Content-Language: en-US
 by: André G. Isaak - Sun, 8 Aug 2021 18:50 UTC

On 2021-08-06 22:23, olcott wrote:
> On 8/6/2021 10:55 PM, André G. Isaak wrote:
>> On 2021-08-06 09:59, olcott wrote:

>> Yes, but bear in mind that 'halting' refers to Turing Machines
>> operating on a specific input. It does not refer to simulations or
>> what happens inside a halting decider. It refers *only* to actual
>> computations, i.e. an actual Turing Machine operating on an actual
>> input string.
>>
>
> So yet again you prove that you are totally clueless that pure
> simulations are computationally equivalent to direct executions ?

Your H is not a pure simulator

>>> (3) Equivalent, I have adapted the original definition to apply to
>>> subsets of computations.
>>
>> I have no idea what that's even supposed to mean.
>>
>>> (4) Correct means that the condition of a conditional expression is
>>> satisfied.
>>
>> Again, I have no idea what that's even supposed to mean.
>>
>>> (5) Proof, here is what I mean by proof, it is an adaptation of the
>>> sound deductive inference model such that valid inference must only
>>> include true preserving operations.
>>>
>>> By proof I mean the application of truth preserving inference steps
>>> to premises that are known to be true. Since mathematical logic has
>>> some inference steps that are not truth preserving these are ruled out.
>>> https://en.wikipedia.org/wiki/Principle_of_explosion
>>> https://en.wikipedia.org/wiki/Paradoxes_of_material_implication
>>>
>>> Validity and Soundness
>>> A deductive argument is said to be valid if and only if it takes a
>>> form that makes it impossible for the premises to be true and the
>>> conclusion nevertheless to be false. Otherwise, a deductive argument
>>> is said to be invalid.
>>>
>>> A deductive argument is sound if and only if it is both valid, and
>>> all of its premises are actually true. Otherwise, a deductive
>>> argument is unsound. https://iep.utm.edu/val-snd/
>>>
>>> // original definition of valid  (same as P → C)
>>>
>>> Material conditional
>>> p   q p → q
>>> T   T   T
>>> T   F   F
>>> F   T   T
>>> F   F   T
>>>
>>> Transforming the above to become truth preserving:
>>>
>>> The definition of valid is changed to:
>>> p   q   p [PROVES] q
>>> T   T        T
>>> T   F        F
>>> F   T        F
>>> F   F        F
>>
>> That is definitely *not* the definition of valid.
>>
>
> It might be simplest to call what I consider proof simply sound
> deductive inference.

Nothing you write above has anything to do with validity or sound
deductive inference.

The truth table you give above is for AND. Olympia is the capital of
Washington. Salem is the capital of Oregon. It is certainly *not* the
case the either of these statements can 'prove' the other, but according
to your table.

Salem is the capital of Oregon PROVES Olympia is the capital of Washington.

>>> A deductive argument is said to be valid if and only if it takes a form
>>> that the conclusion is only true if and only if the premises are true.
>>>
>>> All of the above is summed up as
>>> P [PROVES] C if and only if (True(P) ⊢ True(C) ∧ False(P) ⊢ False(C))
>>
>> Again, that is definitely *not* the definition of a proof.
>>
>>> modal operators are most often interpreted
>>> "□" for "Necessarily" and "◇" for "Possibly".
>>> https://en.wikipedia.org/wiki/Modal_logic
>>> (P [PROVES] C) ↔ (P ↔ □C)

So [PROVES] is your synomym for and and is now also equivalent to 'if
and only if'? You need to go back to logic 101.

And since P ⊢ C means something entirely different from P ⊢□C, you need
to justify how that '□' magically appears. But since you don't know what
it means that's going to be difficult for you.

>> Not only is that not the definition of proof, but your use of □ is
>> entirely meaningless above.
>>
>> You do realise that □ conveys absolutely *no* information unless you
>
> "□" for "Necessarily"

Gee thanks. I already new that. And once again that conveys absolutely
no information unless you explain what you mean by 'necessarily'. The
fact that you don't understand what is being asked here just confirms my
point that you have no idea what □ means and therefore shouldn't be
using it.

There are *many* different modal logics. In all of them □ is referred to
as a necessity operator, but it *means* entirely different things. You
can't just start throwing modal operators around unless you specify
*which* type of modal logic you are using.
>>
>> *All* of the errors which have been pointed out to you have been
>> errors in the actual argument.
>
> No you always make sure to avoid that part.
>
> This code proves that P has no escape from infinitely nested simulation.
> The escape that exists is not in P. In both cases escape/no escape P
> never reaches its final state of 0xc3f, therefore P never halts.

No, it does not. In P(P) P creates a simulation of P. That simulation is
eventually aborted and control returns to the outermost P which then halts.

Since your trace completely skips over the call to 955 that abort code
is not seen which means the the return of control to the outermost P is
also not seen.

There is *no* justification for not including the code of H in this trace.

> _P()
> [00000c25](01)  55          push ebp
> [00000c26](02)  8bec        mov ebp,esp
> [00000c28](03)  8b4508      mov eax,[ebp+08]
> [00000c2b](01)  50          push eax       // push P
> [00000c2c](03)  8b4d08      mov ecx,[ebp+08]
> [00000c2f](01)  51          push ecx       // push P
> [00000c30](05)  e820fdffff  call 00000955  // call H to simulate P
> [00000c35](03)  83c408      add esp,+08
> [00000c38](02)  85c0        test eax,eax
> [00000c3a](02)  7402        jz 00000c3e
> [00000c3c](02)  ebfe        jmp 00000c3c
> [00000c3e](01)  5d          pop ebp
> [00000c3f](01)  c3          ret
> Size in bytes:(0027) [00000c3f]

André

--
To email remove 'invalid' & replace 'gm' with well known Google mail
service.

Re: Honest dialogue on the proof that H(P,P)==0 is correct [proof defined]

<mdKdncO0j8L6w4z8nZ2dnUU7-S_NnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory comp.ai.philosophy comp.software-eng sci.math.symbolic
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.snarked.org!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Mon, 09 Aug 2021 11:57:11 -0500
Subject: Re: Honest dialogue on the proof that H(P,P)==0 is correct [proof
defined]
Newsgroups: comp.theory,comp.ai.philosophy,comp.software-eng,sci.math.symbolic
References: <HNidndugKOWGvpH8nZ2dnUU7-fXNnZ2d@giganews.com>
<Vs0PI.2099$xY.509@fx05.iad> <GLudnUM2eaoEC5H8nZ2dnUU7-evNnZ2d@giganews.com>
<5Z1PI.1823$6h1.1128@fx39.iad>
<r6idnXrkQsZ5JJH8nZ2dnUU7-V_NnZ2d@giganews.com> <qb9PI.22$uV3.2@fx18.iad>
<6radnYHwiMoYvpD8nZ2dnUU7-UPNnZ2d@giganews.com> <owaPI.297$uk4.251@fx20.iad>
<a82dnc_0ypriwZD8nZ2dnUU7-QHNnZ2d@giganews.com> <sel07d$pcf$1@dont-email.me>
<DdCdnaOAJLE3l5P8nZ2dnUU7-enNnZ2d@giganews.com> <sep914$6pc$1@dont-email.me>
From: NoO...@NoWhere.com (olcott)
Date: Mon, 9 Aug 2021 11:57:10 -0500
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:78.0) Gecko/20100101
Thunderbird/78.12.0
MIME-Version: 1.0
In-Reply-To: <sep914$6pc$1@dont-email.me>
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Language: en-US
Content-Transfer-Encoding: 8bit
Message-ID: <mdKdncO0j8L6w4z8nZ2dnUU7-S_NnZ2d@giganews.com>
Lines: 220
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-Gt4MQfEDhezofSWn2YNJLGeEsUFjK6Q3I32uNwyAakogChEU+x/KNs9B+eqNloNEoCAUwnMq5mGu4h4!AGLclol1jvlGHwNc+L040aGPcLcpIfIEYo7BlsmWQfV+jOedYRSL093i/hyrFTOf82oDduDrMQ==
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: 10819
 by: olcott - Mon, 9 Aug 2021 16:57 UTC

On 8/8/2021 1:50 PM, André G. Isaak wrote:
> On 2021-08-06 22:23, olcott wrote:
>> On 8/6/2021 10:55 PM, André G. Isaak wrote:
>>> On 2021-08-06 09:59, olcott wrote:
>
>>> Yes, but bear in mind that 'halting' refers to Turing Machines
>>> operating on a specific input. It does not refer to simulations or
>>> what happens inside a halting decider. It refers *only* to actual
>>> computations, i.e. an actual Turing Machine operating on an actual
>>> input string.
>>>
>>
>> So yet again you prove that you are totally clueless that pure
>> simulations are computationally equivalent to direct executions ?
>
> Your H is not a pure simulator
>

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

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

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

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

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

https://www.researchgate.net/publication/351947980_Halting_problem_undecidability_and_infinitely_nested_simulation

>>>> (3) Equivalent, I have adapted the original definition to apply to
>>>> subsets of computations.
>>>
>>> I have no idea what that's even supposed to mean.
>>>
>>>> (4) Correct means that the condition of a conditional expression is
>>>> satisfied.
>>>
>>> Again, I have no idea what that's even supposed to mean.
>>>
>>>> (5) Proof, here is what I mean by proof, it is an adaptation of the
>>>> sound deductive inference model such that valid inference must only
>>>> include true preserving operations.
>>>>
>>>> By proof I mean the application of truth preserving inference steps
>>>> to premises that are known to be true. Since mathematical logic has
>>>> some inference steps that are not truth preserving these are ruled out.
>>>> https://en.wikipedia.org/wiki/Principle_of_explosion
>>>> https://en.wikipedia.org/wiki/Paradoxes_of_material_implication
>>>>
>>>> Validity and Soundness
>>>> A deductive argument is said to be valid if and only if it takes a
>>>> form that makes it impossible for the premises to be true and the
>>>> conclusion nevertheless to be false. Otherwise, a deductive argument
>>>> is said to be invalid.
>>>>
>>>> A deductive argument is sound if and only if it is both valid, and
>>>> all of its premises are actually true. Otherwise, a deductive
>>>> argument is unsound. https://iep.utm.edu/val-snd/
>>>>
>>>> // original definition of valid  (same as P → C)
>>>>
>>>> Material conditional
>>>> p   q p → q
>>>> T   T   T
>>>> T   F   F
>>>> F   T   T
>>>> F   F   T
>>>>
>>>> Transforming the above to become truth preserving:
>>>>
>>>> The definition of valid is changed to:
>>>> p   q   p [PROVES] q
>>>> T   T        T
>>>> T   F        F
>>>> F   T        F
>>>> F   F        F
>>>
>>> That is definitely *not* the definition of valid.
>>>
>>
>> It might be simplest to call what I consider proof simply sound
>> deductive inference.
>
> Nothing you write above has anything to do with validity or sound
> deductive inference.
>
> The truth table you give above is for AND. Olympia is the capital of
> Washington. Salem is the capital of Oregon. It is certainly *not* the
> case the either of these statements can 'prove' the other, but according
> to your table.
>
> Salem is the capital of Oregon PROVES Olympia is the capital of Washington.
>
>>>> A deductive argument is said to be valid if and only if it takes a form
>>>> that the conclusion is only true if and only if the premises are true.
>>>>
>>>> All of the above is summed up as
>>>> P [PROVES] C if and only if (True(P) ⊢ True(C) ∧ False(P) ⊢ False(C))
>>>
>>> Again, that is definitely *not* the definition of a proof.
>>>
>>>> modal operators are most often interpreted
>>>> "□" for "Necessarily" and "◇" for "Possibly".
>>>> https://en.wikipedia.org/wiki/Modal_logic
>>>> (P [PROVES] C) ↔ (P ↔ □C)
>
> So [PROVES] is your synomym for and and is now also equivalent to 'if
> and only if'? You need to go back to logic 101.
>
> And since P ⊢ C means something entirely different from P ⊢□C, you need
> to justify how that '□' magically appears. But since you don't know what
> it means that's going to be difficult for you.
>
>>> Not only is that not the definition of proof, but your use of □ is
>>> entirely meaningless above.
>>>
>>> You do realise that □ conveys absolutely *no* information unless you
>>
>> "□" for "Necessarily"
>
> Gee thanks. I already new that. And once again that conveys absolutely
> no information unless you explain what you mean by 'necessarily'. The
> fact that you don't understand what is being asked here just confirms my
> point that you have no idea what □ means and therefore shouldn't be
> using it.
>
> There are *many* different modal logics. In all of them □ is referred to
> as a necessity operator, but it *means* entirely different things. You
> can't just start throwing modal operators around unless you specify
> *which* type of modal logic you are using.
>>>
>>> *All* of the errors which have been pointed out to you have been
>>> errors in the actual argument.
>>
>> No you always make sure to avoid that part.
>>
>> This code proves that P has no escape from infinitely nested simulation.
>> The escape that exists is not in P. In both cases escape/no escape P
>> never reaches its final state of 0xc3f, therefore P never halts.
>
> No, it does not. In P(P) P creates a simulation of P. That simulation is
> eventually aborted and control returns to the outermost P which then halts.
>
> Since your trace completely skips over the call to 955 that abort code
> is not seen which means the the return of control to the outermost P is
> also not seen.
>
> There is *no* justification for not including the code of H in this trace.
>
>> _P()
>> [00000c25](01)  55          push ebp
>> [00000c26](02)  8bec        mov ebp,esp
>> [00000c28](03)  8b4508      mov eax,[ebp+08]
>> [00000c2b](01)  50          push eax       // push P
>> [00000c2c](03)  8b4d08      mov ecx,[ebp+08]
>> [00000c2f](01)  51          push ecx       // push P
>> [00000c30](05)  e820fdffff  call 00000955  // call H to simulate P
>> [00000c35](03)  83c408      add esp,+08
>> [00000c38](02)  85c0        test eax,eax
>> [00000c3a](02)  7402        jz 00000c3e
>> [00000c3c](02)  ebfe        jmp 00000c3c
>> [00000c3e](01)  5d          pop ebp
>> [00000c3f](01)  c3          ret
>> Size in bytes:(0027) [00000c3f]
>
>
> André
>
>


Click here to read the complete article
Re: Honest dialogue on the proof that H(P,P)==0 is correct [proof defined]

<2cf7b09a-b3a2-4ede-b33f-c57a3736e9a7n@googlegroups.com>

 copy mid

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

 copy link   Newsgroups: comp.theory
X-Received: by 2002:a05:620a:88c:: with SMTP id b12mr6971083qka.483.1628530215214;
Mon, 09 Aug 2021 10:30:15 -0700 (PDT)
X-Received: by 2002:a25:81ce:: with SMTP id n14mr34670377ybm.32.1628530214925;
Mon, 09 Aug 2021 10:30:14 -0700 (PDT)
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.snarked.org!border2.nntp.dca1.giganews.com!nntp.giganews.com!news-out.google.com!nntp.google.com!postnews.google.com!google-groups.googlegroups.com!not-for-mail
Newsgroups: comp.theory
Date: Mon, 9 Aug 2021 10:30:14 -0700 (PDT)
In-Reply-To: <mdKdncO0j8L6w4z8nZ2dnUU7-S_NnZ2d@giganews.com>
Injection-Info: google-groups.googlegroups.com; posting-host=81.143.231.9; posting-account=Dz2zqgkAAADlK5MFu78bw3ab-BRFV4Qn
NNTP-Posting-Host: 81.143.231.9
References: <HNidndugKOWGvpH8nZ2dnUU7-fXNnZ2d@giganews.com>
<Vs0PI.2099$xY.509@fx05.iad> <GLudnUM2eaoEC5H8nZ2dnUU7-evNnZ2d@giganews.com>
<5Z1PI.1823$6h1.1128@fx39.iad> <r6idnXrkQsZ5JJH8nZ2dnUU7-V_NnZ2d@giganews.com>
<qb9PI.22$uV3.2@fx18.iad> <6radnYHwiMoYvpD8nZ2dnUU7-UPNnZ2d@giganews.com>
<owaPI.297$uk4.251@fx20.iad> <a82dnc_0ypriwZD8nZ2dnUU7-QHNnZ2d@giganews.com>
<sel07d$pcf$1@dont-email.me> <DdCdnaOAJLE3l5P8nZ2dnUU7-enNnZ2d@giganews.com>
<sep914$6pc$1@dont-email.me> <mdKdncO0j8L6w4z8nZ2dnUU7-S_NnZ2d@giganews.com>
User-Agent: G2/1.0
MIME-Version: 1.0
Message-ID: <2cf7b09a-b3a2-4ede-b33f-c57a3736e9a7n@googlegroups.com>
Subject: Re: Honest dialogue on the proof that H(P,P)==0 is correct [proof defined]
From: malcolm....@gmail.com (Malcolm McLean)
Injection-Date: Mon, 09 Aug 2021 17:30:15 +0000
Content-Type: text/plain; charset="UTF-8"
Content-Transfer-Encoding: quoted-printable
Lines: 86
 by: Malcolm McLean - Mon, 9 Aug 2021 17:30 UTC

On Monday, 9 August 2021 at 17:57:18 UTC+1, olcott wrote:
> On 8/8/2021 1:50 PM, André G. Isaak wrote:
> > On 2021-08-06 22:23, olcott wrote:
> >> On 8/6/2021 10:55 PM, André G. Isaak wrote:
> >>> On 2021-08-06 09:59, olcott wrote:
> >
> >>> Yes, but bear in mind that 'halting' refers to Turing Machines
> >>> operating on a specific input. It does not refer to simulations or
> >>> what happens inside a halting decider. It refers *only* to actual
> >>> computations, i.e. an actual Turing Machine operating on an actual
> >>> input string.
> >>>
> >>
> >> So yet again you prove that you are totally clueless that pure
> >> simulations are computationally equivalent to direct executions ?
> >
> > Your H is not a pure simulator
> >
> // Simplified Linz Ĥ (Linz:1990:319)
> // Strachey(1965) CPL translated to C
> void P(u32 x)
> {
> if (H(x, x))
> HERE: goto HERE;
> }
> _P()
> [00000d02](01) 55 push ebp
> [00000d03](02) 8bec mov ebp,esp
> [00000d05](03) 8b4508 mov eax,[ebp+08]
> [00000d08](01) 50 push eax // push 2nd Param
> [00000d09](03) 8b4d08 mov ecx,[ebp+08]
> [00000d0c](01) 51 push ecx // push 1st Param
> [00000d0d](05) e870feffff call 00000b82 // call H
> [00000d12](03) 83c408 add esp,+08
> [00000d15](02) 85c0 test eax,eax
> [00000d17](02) 7402 jz 00000d1b
> [00000d19](02) ebfe jmp 00000d19
> [00000d1b](01) 5d pop ebp
> [00000d1c](01) c3 ret
> Size in bytes:(0027) [00000d1c]
>
> machine stack stack machine assembly
> address address data code language
> ======== ======== ======== ========= =============
> ...[00000d0d][00101829][00000d12] e870feffff call 00000b82 // call H
> Begin Local Halt Decider Simulation at Machine Address:d02
> ...[00000d02][002118f1][002118f5] 55 push ebp
> ...[00000d03][002118f1][002118f5] 8bec mov ebp,esp
> ...[00000d05][002118f1][002118f5] 8b4508 mov eax,[ebp+08]
> ...[00000d08][002118ed][00000d02] 50 push eax // push P
> ...[00000d09][002118ed][00000d02] 8b4d08 mov ecx,[ebp+08]
> ...[00000d0c][002118e9][00000d02] 51 push ecx // push P
> ...[00000d0d][002118e5][00000d12] e870feffff call 00000b82 // call H
> ...[00000d02][0025c319][0025c31d] 55 push ebp
> ...[00000d03][0025c319][0025c31d] 8bec mov ebp,esp
> ...[00000d05][0025c319][0025c31d] 8b4508 mov eax,[ebp+08]
> ...[00000d08][0025c315][00000d02] 50 push eax // push P
> ...[00000d09][0025c315][00000d02] 8b4d08 mov ecx,[ebp+08]
> ...[00000d0c][0025c311][00000d02] 51 push ecx // push P
> ...[00000d0d][0025c30d][00000d12] e870feffff call 00000b82 // call H
> Local Halt Decider: Infinite Recursion Detected Simulation Stopped
> The fact that the execution trace of the simulation of P(P) on page 6
> perfectly matches its source-code on page 5 conclusively proves that
> this execution trace performed by H is a pure simulation of P(P). There
> is no correct basis for disagreement, therefore anyone disagreeing
> either does not know the x86 language or they are simply lying.
>
It's unclear to me exactly how H is a "simulator", given this execution trace.
Normally a simulator creates a virtual machine with a virtual address space
and virtual instructions. The execution trace of the simulator looks nothing
like the execution trace of the simulated code - basically the simulator does
a big switch on the op code of the virtual machine's instruction, then updates
memory and registers, with special rules for IO.

You don't seem to be using this model for H.

However iif P(P) halts, then any execution trace which shows it P(P) as non-halting
must have a mistake in it somewhere, either in the simulator or in the interpretation
of the trace.

Re: Honest dialogue on the proof that H(P,P)==0 is correct [proof defined]

<ses089$7io$1@dont-email.me>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!eternal-september.org!reader02.eternal-september.org!.POSTED!not-for-mail
From: agis...@gm.invalid (André G. Isaak)
Newsgroups: comp.theory
Subject: Re: Honest dialogue on the proof that H(P,P)==0 is correct [proof
defined]
Date: Mon, 9 Aug 2021 13:38:47 -0600
Organization: Christians and Atheists United Against Creeping Agnosticism
Lines: 84
Message-ID: <ses089$7io$1@dont-email.me>
References: <HNidndugKOWGvpH8nZ2dnUU7-fXNnZ2d@giganews.com>
<Vs0PI.2099$xY.509@fx05.iad> <GLudnUM2eaoEC5H8nZ2dnUU7-evNnZ2d@giganews.com>
<5Z1PI.1823$6h1.1128@fx39.iad>
<r6idnXrkQsZ5JJH8nZ2dnUU7-V_NnZ2d@giganews.com> <qb9PI.22$uV3.2@fx18.iad>
<6radnYHwiMoYvpD8nZ2dnUU7-UPNnZ2d@giganews.com> <owaPI.297$uk4.251@fx20.iad>
<a82dnc_0ypriwZD8nZ2dnUU7-QHNnZ2d@giganews.com> <sel07d$pcf$1@dont-email.me>
<DdCdnaOAJLE3l5P8nZ2dnUU7-enNnZ2d@giganews.com> <sep914$6pc$1@dont-email.me>
<mdKdncO0j8L6w4z8nZ2dnUU7-S_NnZ2d@giganews.com>
Mime-Version: 1.0
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Mon, 9 Aug 2021 19:38:49 -0000 (UTC)
Injection-Info: reader02.eternal-september.org; posting-host="339411d7247a67926e7083a4844c60bc";
logging-data="7768"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX1/s8U5BhkYB+PfY7jubQGyQ"
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.14; rv:68.0)
Gecko/20100101 Thunderbird/68.12.1
Cancel-Lock: sha1:Cop/9bLqXG+jkLSk3ciJy85pq/Q=
In-Reply-To: <mdKdncO0j8L6w4z8nZ2dnUU7-S_NnZ2d@giganews.com>
Content-Language: en-US
 by: André G. Isaak - Mon, 9 Aug 2021 19:38 UTC

On 2021-08-09 10:57, olcott wrote:
> On 8/8/2021 1:50 PM, André G. Isaak wrote:
>> On 2021-08-06 22:23, olcott wrote:
>>> On 8/6/2021 10:55 PM, André G. Isaak wrote:
>>>> On 2021-08-06 09:59, olcott wrote:
>>
>>>> Yes, but bear in mind that 'halting' refers to Turing Machines
>>>> operating on a specific input. It does not refer to simulations or
>>>> what happens inside a halting decider. It refers *only* to actual
>>>> computations, i.e. an actual Turing Machine operating on an actual
>>>> input string.
>>>>
>>>
>>> So yet again you prove that you are totally clueless that pure
>>> simulations are computationally equivalent to direct executions ?
>>
>> Your H is not a pure simulator
>>
>
> // Simplified Linz Ĥ (Linz:1990:319)
> // Strachey(1965) CPL translated to C
> void P(u32 x)
> {
>   if (H(x, x))
>     HERE: goto HERE;
> }
>
> _P()
> [00000d02](01)  55          push ebp
> [00000d03](02)  8bec        mov ebp,esp
> [00000d05](03)  8b4508      mov eax,[ebp+08]
> [00000d08](01)  50          push eax       // push 2nd Param
> [00000d09](03)  8b4d08      mov ecx,[ebp+08]
> [00000d0c](01)  51          push ecx       // push 1st Param
> [00000d0d](05)  e870feffff  call 00000b82  // call H
> [00000d12](03)  83c408      add esp,+08
> [00000d15](02)  85c0        test eax,eax
> [00000d17](02)  7402        jz 00000d1b
> [00000d19](02)  ebfe        jmp 00000d19
> [00000d1b](01)  5d          pop ebp
> [00000d1c](01)  c3          ret
> Size in bytes:(0027) [00000d1c]
>
>     machine   stack     stack     machine     assembly
>     address   address   data      code        language
>     ========  ========  ========  =========   =============
> ...[00000d0d][00101829][00000d12] e870feffff  call 00000b82  // call H
>
> Begin Local Halt Decider Simulation at Machine Address:d02
> ...[00000d02][002118f1][002118f5] 55          push ebp
> ...[00000d03][002118f1][002118f5] 8bec        mov ebp,esp
> ...[00000d05][002118f1][002118f5] 8b4508      mov eax,[ebp+08]
> ...[00000d08][002118ed][00000d02] 50          push eax       // push P
> ...[00000d09][002118ed][00000d02] 8b4d08      mov ecx,[ebp+08]
> ...[00000d0c][002118e9][00000d02] 51          push ecx       // push P
> ...[00000d0d][002118e5][00000d12] e870feffff  call 00000b82  // call H
> ...[00000d02][0025c319][0025c31d] 55          push ebp
> ...[00000d03][0025c319][0025c31d] 8bec        mov ebp,esp
> ...[00000d05][0025c319][0025c31d] 8b4508      mov eax,[ebp+08]
> ...[00000d08][0025c315][00000d02] 50          push eax       // push P
> ...[00000d09][0025c315][00000d02] 8b4d08      mov ecx,[ebp+08]
> ...[00000d0c][0025c311][00000d02] 51          push ecx       // push P
> ...[00000d0d][0025c30d][00000d12] e870feffff  call 00000b82  // call H
> Local Halt Decider: Infinite Recursion Detected Simulation Stopped
>
> The fact that the execution trace of the simulation of P(P) on page 6
> perfectly matches its source-code on page 5 conclusively proves that
> this execution trace performed by H is a pure simulation of P(P). There
> is no correct basis for disagreement, therefore anyone disagreeing
> either does not know the x86 language or they are simply lying.

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

Your trace ends with the cryptic message "Local Halt Decider: Infinite
Recursion Detected Simulation Stopped" which doesn't indicate *which*
invocation of H aborted *which* simulation and to where control was
transferred once that simulation was aborted.

Amdré

--
To email remove 'invalid' & replace 'gm' with well known Google mail
service.

Re: Honest dialogue on the proof that H(P,P)==0 is correct [proof defined]

<yIOdnSFYVobgGoz8nZ2dnUU7-SnNnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory comp.ai.philosophy comp.software-eng sci.math.symbolic
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.snarked.org!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Mon, 09 Aug 2021 14:52:29 -0500
Subject: Re: Honest dialogue on the proof that H(P,P)==0 is correct [proof
defined]
Newsgroups: comp.theory,comp.ai.philosophy,comp.software-eng,sci.math.symbolic
References: <HNidndugKOWGvpH8nZ2dnUU7-fXNnZ2d@giganews.com>
<Vs0PI.2099$xY.509@fx05.iad> <GLudnUM2eaoEC5H8nZ2dnUU7-evNnZ2d@giganews.com>
<5Z1PI.1823$6h1.1128@fx39.iad>
<r6idnXrkQsZ5JJH8nZ2dnUU7-V_NnZ2d@giganews.com> <qb9PI.22$uV3.2@fx18.iad>
<6radnYHwiMoYvpD8nZ2dnUU7-UPNnZ2d@giganews.com> <owaPI.297$uk4.251@fx20.iad>
<a82dnc_0ypriwZD8nZ2dnUU7-QHNnZ2d@giganews.com> <sel07d$pcf$1@dont-email.me>
<DdCdnaOAJLE3l5P8nZ2dnUU7-enNnZ2d@giganews.com> <sep914$6pc$1@dont-email.me>
<mdKdncO0j8L6w4z8nZ2dnUU7-S_NnZ2d@giganews.com>
<2cf7b09a-b3a2-4ede-b33f-c57a3736e9a7n@googlegroups.com>
From: NoO...@NoWhere.com (olcott)
Date: Mon, 9 Aug 2021 14:52:28 -0500
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:78.0) Gecko/20100101
Thunderbird/78.12.0
MIME-Version: 1.0
In-Reply-To: <2cf7b09a-b3a2-4ede-b33f-c57a3736e9a7n@googlegroups.com>
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Language: en-US
Content-Transfer-Encoding: 8bit
Message-ID: <yIOdnSFYVobgGoz8nZ2dnUU7-SnNnZ2d@giganews.com>
Lines: 99
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-K7oBmf+jiX0rYPQ44UdbSoxzedqc/IYuiu0tAHGHntsXcRzM6wHE8oSzOTJziblhu3jC82ncJWMUWIn!z4q13saofv+pjQGG4XKlm+zVrGJ4cdg4zHyI9kMFtlxRMdqHdQch61crL2bphUlKm6GyOZlKSw==
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: 6187
 by: olcott - Mon, 9 Aug 2021 19:52 UTC

On 8/9/2021 12:30 PM, Malcolm McLean wrote:
> On Monday, 9 August 2021 at 17:57:18 UTC+1, olcott wrote:
>> On 8/8/2021 1:50 PM, André G. Isaak wrote:
>>> On 2021-08-06 22:23, olcott wrote:
>>>> On 8/6/2021 10:55 PM, André G. Isaak wrote:
>>>>> On 2021-08-06 09:59, olcott wrote:
>>>
>>>>> Yes, but bear in mind that 'halting' refers to Turing Machines
>>>>> operating on a specific input. It does not refer to simulations or
>>>>> what happens inside a halting decider. It refers *only* to actual
>>>>> computations, i.e. an actual Turing Machine operating on an actual
>>>>> input string.
>>>>>
>>>>
>>>> So yet again you prove that you are totally clueless that pure
>>>> simulations are computationally equivalent to direct executions ?
>>>
>>> Your H is not a pure simulator
>>>
>> // Simplified Linz Ĥ (Linz:1990:319)
>> // Strachey(1965) CPL translated to C
>> void P(u32 x)
>> {
>> if (H(x, x))
>> HERE: goto HERE;
>> }
>> _P()
>> [00000d02](01) 55 push ebp
>> [00000d03](02) 8bec mov ebp,esp
>> [00000d05](03) 8b4508 mov eax,[ebp+08]
>> [00000d08](01) 50 push eax // push 2nd Param
>> [00000d09](03) 8b4d08 mov ecx,[ebp+08]
>> [00000d0c](01) 51 push ecx // push 1st Param
>> [00000d0d](05) e870feffff call 00000b82 // call H
>> [00000d12](03) 83c408 add esp,+08
>> [00000d15](02) 85c0 test eax,eax
>> [00000d17](02) 7402 jz 00000d1b
>> [00000d19](02) ebfe jmp 00000d19
>> [00000d1b](01) 5d pop ebp
>> [00000d1c](01) c3 ret
>> Size in bytes:(0027) [00000d1c]
>>
>> machine stack stack machine assembly
>> address address data code language
>> ======== ======== ======== ========= =============
>> ...[00000d0d][00101829][00000d12] e870feffff call 00000b82 // call H
>> Begin Local Halt Decider Simulation at Machine Address:d02
>> ...[00000d02][002118f1][002118f5] 55 push ebp
>> ...[00000d03][002118f1][002118f5] 8bec mov ebp,esp
>> ...[00000d05][002118f1][002118f5] 8b4508 mov eax,[ebp+08]
>> ...[00000d08][002118ed][00000d02] 50 push eax // push P
>> ...[00000d09][002118ed][00000d02] 8b4d08 mov ecx,[ebp+08]
>> ...[00000d0c][002118e9][00000d02] 51 push ecx // push P
>> ...[00000d0d][002118e5][00000d12] e870feffff call 00000b82 // call H
>> ...[00000d02][0025c319][0025c31d] 55 push ebp
>> ...[00000d03][0025c319][0025c31d] 8bec mov ebp,esp
>> ...[00000d05][0025c319][0025c31d] 8b4508 mov eax,[ebp+08]
>> ...[00000d08][0025c315][00000d02] 50 push eax // push P
>> ...[00000d09][0025c315][00000d02] 8b4d08 mov ecx,[ebp+08]
>> ...[00000d0c][0025c311][00000d02] 51 push ecx // push P
>> ...[00000d0d][0025c30d][00000d12] e870feffff call 00000b82 // call H
>> Local Halt Decider: Infinite Recursion Detected Simulation Stopped
>> The fact that the execution trace of the simulation of P(P) on page 6
>> perfectly matches its source-code on page 5 conclusively proves that
>> this execution trace performed by H is a pure simulation of P(P). There
>> is no correct basis for disagreement, therefore anyone disagreeing
>> either does not know the x86 language or they are simply lying.
>>
> It's unclear to me exactly how H is a "simulator", given this execution trace.

I don't see what could possibly be unclear about it to anyone knowing
the x86 language well enough. The trace shows exactly what P would do if
it was simulated by a pure simulator with itself as input.

> Normally a simulator creates a virtual machine with a virtual address space
> and virtual instructions. The execution trace of the simulator looks nothing
> like the execution trace of the simulated code - basically the simulator does
> a big switch on the op code of the virtual machine's instruction, then updates
> memory and registers, with special rules for IO.
>

Those details only serve to get people confused. The fact that the x86
code of P acts exactly as if it was simulated by a pure simulator proves
beyond all possible doubt that H does simulate P on input P as a pure
simulator.

> You don't seem to be using this model for H.
>
> However iif P(P) halts, then any execution trace which shows it P(P) as non-halting
> must have a mistake in it somewhere, either in the simulator or in the interpretation
> of the trace.
>

--
Copyright 2021 Pete Olcott

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

Re: Honest dialogue on the proof that H(P,P)==0 is correct [proof defined]

<ses2dr$jpf$1@dont-email.me>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!eternal-september.org!reader02.eternal-september.org!.POSTED!not-for-mail
From: agis...@gm.invalid (André G. Isaak)
Newsgroups: comp.theory
Subject: Re: Honest dialogue on the proof that H(P,P)==0 is correct [proof
defined]
Date: Mon, 9 Aug 2021 14:15:53 -0600
Organization: Christians and Atheists United Against Creeping Agnosticism
Lines: 26
Message-ID: <ses2dr$jpf$1@dont-email.me>
References: <HNidndugKOWGvpH8nZ2dnUU7-fXNnZ2d@giganews.com>
<Vs0PI.2099$xY.509@fx05.iad> <GLudnUM2eaoEC5H8nZ2dnUU7-evNnZ2d@giganews.com>
<5Z1PI.1823$6h1.1128@fx39.iad>
<r6idnXrkQsZ5JJH8nZ2dnUU7-V_NnZ2d@giganews.com> <qb9PI.22$uV3.2@fx18.iad>
<6radnYHwiMoYvpD8nZ2dnUU7-UPNnZ2d@giganews.com> <owaPI.297$uk4.251@fx20.iad>
<a82dnc_0ypriwZD8nZ2dnUU7-QHNnZ2d@giganews.com> <sel07d$pcf$1@dont-email.me>
<DdCdnaOAJLE3l5P8nZ2dnUU7-enNnZ2d@giganews.com> <sep914$6pc$1@dont-email.me>
<mdKdncO0j8L6w4z8nZ2dnUU7-S_NnZ2d@giganews.com>
<2cf7b09a-b3a2-4ede-b33f-c57a3736e9a7n@googlegroups.com>
<yIOdnSFYVobgGoz8nZ2dnUU7-SnNnZ2d@giganews.com>
Mime-Version: 1.0
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Mon, 9 Aug 2021 20:15:55 -0000 (UTC)
Injection-Info: reader02.eternal-september.org; posting-host="339411d7247a67926e7083a4844c60bc";
logging-data="20271"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX18FpEh5nCoyw2RTnfcCrSSd"
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.14; rv:68.0)
Gecko/20100101 Thunderbird/68.12.1
Cancel-Lock: sha1:DKJrBpGn27M9/ynMJgtKdhdq/Zo=
In-Reply-To: <yIOdnSFYVobgGoz8nZ2dnUU7-SnNnZ2d@giganews.com>
Content-Language: en-US
 by: André G. Isaak - Mon, 9 Aug 2021 20:15 UTC

On 2021-08-09 13:52, olcott wrote:
> On 8/9/2021 12:30 PM, Malcolm McLean wrote:

>> It's unclear to me exactly how H is a "simulator", given this
>> execution trace.
>
> I don't see what could possibly be unclear about it to anyone knowing
> the x86 language well enough. The trace shows exactly what P would do if
> it was simulated by a pure simulator with itself as input.

No, the trace appears to show what P would do if invoked *directly* with
itself as input, and in which P subsequently calls its input *directly*
rather than simulating it. This should be clear to anyone who knows the
x86 language well enough.

This discrepancy between what you claim your code does and what your
traces appear to show has been pointed out to you before and you've
never adequately explained what your code *really* does. Either your
'simulations' aren't really simulations or your 'x86 traces' aren't
actually x86 traces.

André

--
To email remove 'invalid' & replace 'gm' with well known Google mail
service.

Re: Honest dialogue on the proof that H(P,P)==0 is correct [proof defined]

<-4idnXdW5JWtB4z8nZ2dnUU7-W_NnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory comp.ai.philosophy comp.software-eng sci.math.symbolic
Path: i2pn2.org!i2pn.org!weretis.net!feeder8.news.weretis.net!feeder1.feed.usenet.farm!feed.usenet.farm!tr3.eu1.usenetexpress.com!feeder.usenetexpress.com!tr1.iad1.usenetexpress.com!border1.nntp.dca1.giganews.com!nntp.giganews.com!buffer1.nntp.dca1.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Mon, 09 Aug 2021 16:12:16 -0500
Subject: Re: Honest dialogue on the proof that H(P,P)==0 is correct [proof defined]
Newsgroups: comp.theory,comp.ai.philosophy,comp.software-eng,sci.math.symbolic
References: <HNidndugKOWGvpH8nZ2dnUU7-fXNnZ2d@giganews.com> <Vs0PI.2099$xY.509@fx05.iad> <GLudnUM2eaoEC5H8nZ2dnUU7-evNnZ2d@giganews.com> <5Z1PI.1823$6h1.1128@fx39.iad> <r6idnXrkQsZ5JJH8nZ2dnUU7-V_NnZ2d@giganews.com> <qb9PI.22$uV3.2@fx18.iad> <6radnYHwiMoYvpD8nZ2dnUU7-UPNnZ2d@giganews.com> <owaPI.297$uk4.251@fx20.iad> <a82dnc_0ypriwZD8nZ2dnUU7-QHNnZ2d@giganews.com> <sel07d$pcf$1@dont-email.me> <DdCdnaOAJLE3l5P8nZ2dnUU7-enNnZ2d@giganews.com> <sep914$6pc$1@dont-email.me> <mdKdncO0j8L6w4z8nZ2dnUU7-S_NnZ2d@giganews.com> <ses089$7io$1@dont-email.me>
From: NoO...@NoWhere.com (olcott)
Date: Mon, 9 Aug 2021 16:12:15 -0500
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:78.0) Gecko/20100101 Thunderbird/78.12.0
MIME-Version: 1.0
In-Reply-To: <ses089$7io$1@dont-email.me>
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Language: en-US
Content-Transfer-Encoding: 8bit
Message-ID: <-4idnXdW5JWtB4z8nZ2dnUU7-W_NnZ2d@giganews.com>
Lines: 107
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-nHjzLM/BmaFNBsqiwQGLCoaBsfC6s6roWEHhJAWy6aqKUohWZht0ZFOyNyfAUonlcXaORKYRezXCWPl!4pX8H7w/PjFAQOmchXsb4VsjscIcBBbklAMrW6IxPbU48MNpEaQ+VDpQZDZe62BulllV2ypnJw==
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: 6675
 by: olcott - Mon, 9 Aug 2021 21:12 UTC

On 8/9/2021 2:38 PM, André G. Isaak wrote:
> On 2021-08-09 10:57, olcott wrote:
>> On 8/8/2021 1:50 PM, André G. Isaak wrote:
>>> On 2021-08-06 22:23, olcott wrote:
>>>> On 8/6/2021 10:55 PM, André G. Isaak wrote:
>>>>> On 2021-08-06 09:59, olcott wrote:
>>>
>>>>> Yes, but bear in mind that 'halting' refers to Turing Machines
>>>>> operating on a specific input. It does not refer to simulations or
>>>>> what happens inside a halting decider. It refers *only* to actual
>>>>> computations, i.e. an actual Turing Machine operating on an actual
>>>>> input string.
>>>>>
>>>>
>>>> So yet again you prove that you are totally clueless that pure
>>>> simulations are computationally equivalent to direct executions ?
>>>
>>> Your H is not a pure simulator
>>>
>>
>> // Simplified Linz Ĥ (Linz:1990:319)
>> // Strachey(1965) CPL translated to C
>> void P(u32 x)
>> {
>>    if (H(x, x))
>>      HERE: goto HERE;
>> }
>>
>> _P()
>> [00000d02](01)  55          push ebp
>> [00000d03](02)  8bec        mov ebp,esp
>> [00000d05](03)  8b4508      mov eax,[ebp+08]
>> [00000d08](01)  50          push eax       // push 2nd Param
>> [00000d09](03)  8b4d08      mov ecx,[ebp+08]
>> [00000d0c](01)  51          push ecx       // push 1st Param
>> [00000d0d](05)  e870feffff  call 00000b82  // call H
>> [00000d12](03)  83c408      add esp,+08
>> [00000d15](02)  85c0        test eax,eax
>> [00000d17](02)  7402        jz 00000d1b
>> [00000d19](02)  ebfe        jmp 00000d19
>> [00000d1b](01)  5d          pop ebp
>> [00000d1c](01)  c3          ret
>> Size in bytes:(0027) [00000d1c]
>>
>>      machine   stack     stack     machine     assembly
>>      address   address   data      code        language
>>      ========  ========  ========  =========   =============
>> ...[00000d0d][00101829][00000d12] e870feffff  call 00000b82  // call H
>>
>> Begin Local Halt Decider Simulation at Machine Address:d02
>> ...[00000d02][002118f1][002118f5] 55          push ebp
>> ...[00000d03][002118f1][002118f5] 8bec        mov ebp,esp
>> ...[00000d05][002118f1][002118f5] 8b4508      mov eax,[ebp+08]
>> ...[00000d08][002118ed][00000d02] 50          push eax       // push P
>> ...[00000d09][002118ed][00000d02] 8b4d08      mov ecx,[ebp+08]
>> ...[00000d0c][002118e9][00000d02] 51          push ecx       // push P
>> ...[00000d0d][002118e5][00000d12] e870feffff  call 00000b82  // call H
>> ...[00000d02][0025c319][0025c31d] 55          push ebp
>> ...[00000d03][0025c319][0025c31d] 8bec        mov ebp,esp
>> ...[00000d05][0025c319][0025c31d] 8b4508      mov eax,[ebp+08]
>> ...[00000d08][0025c315][00000d02] 50          push eax       // push P
>> ...[00000d09][0025c315][00000d02] 8b4d08      mov ecx,[ebp+08]
>> ...[00000d0c][0025c311][00000d02] 51          push ecx       // push P
>> ...[00000d0d][0025c30d][00000d12] e870feffff  call 00000b82  // call H
>> Local Halt Decider: Infinite Recursion Detected Simulation Stopped
>>
>> The fact that the execution trace of the simulation of P(P) on page 6
>> perfectly matches its source-code on page 5 conclusively proves that
>> this execution trace performed by H is a pure simulation of P(P).
>> There is no correct basis for disagreement, therefore anyone
>> disagreeing either does not know the x86 language or they are simply
>> lying.
>
> You have a *partial trace* and *partial source code*. Neither shows what
> happens at B82.
>

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

If every line of the execution trace of the simulation of P on input P
behaves exactly as its x86 source-code specifies that it must behave
then we know with 100% perfectly justified logical certainty that H did
perform a pure simulation of P on input P.

Do you care about the truth or will you continue to argue when you know
that you are wrong?

> Your trace ends with the cryptic message "Local Halt Decider: Infinite
> Recursion Detected Simulation Stopped" which doesn't indicate *which*
> invocation of H aborted *which* simulation and to where control was
> transferred once that simulation was aborted.
>
> Amdré
>

All that matters it that it is perfectly obvious to anyone knowing the
x86 language well enough that the input to H does specifies infinitely
nested simulation. This proves that whatever H aborted whichever P was
correct in its never halting decision.

--
Copyright 2021 Pete Olcott

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

Re: Honest dialogue on the proof that H(P,P)==0 is correct [proof defined]

<-4idnXZW5JUQB4z8nZ2dnUU7-W9QAAAA@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!aioe.org!feeder1.feed.usenet.farm!feed.usenet.farm!tr1.eu1.usenetexpress.com!feeder.usenetexpress.com!tr3.iad1.usenetexpress.com!border1.nntp.dca1.giganews.com!nntp.giganews.com!buffer1.nntp.dca1.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Mon, 09 Aug 2021 16:13:49 -0500
Subject: Re: Honest dialogue on the proof that H(P,P)==0 is correct [proof defined]
Newsgroups: comp.theory
References: <HNidndugKOWGvpH8nZ2dnUU7-fXNnZ2d@giganews.com> <Vs0PI.2099$xY.509@fx05.iad> <GLudnUM2eaoEC5H8nZ2dnUU7-evNnZ2d@giganews.com> <5Z1PI.1823$6h1.1128@fx39.iad> <r6idnXrkQsZ5JJH8nZ2dnUU7-V_NnZ2d@giganews.com> <qb9PI.22$uV3.2@fx18.iad> <6radnYHwiMoYvpD8nZ2dnUU7-UPNnZ2d@giganews.com> <owaPI.297$uk4.251@fx20.iad> <a82dnc_0ypriwZD8nZ2dnUU7-QHNnZ2d@giganews.com> <sel07d$pcf$1@dont-email.me> <DdCdnaOAJLE3l5P8nZ2dnUU7-enNnZ2d@giganews.com> <sep914$6pc$1@dont-email.me> <mdKdncO0j8L6w4z8nZ2dnUU7-S_NnZ2d@giganews.com> <2cf7b09a-b3a2-4ede-b33f-c57a3736e9a7n@googlegroups.com> <yIOdnSFYVobgGoz8nZ2dnUU7-SnNnZ2d@giganews.com> <ses2dr$jpf$1@dont-email.me>
From: NoO...@NoWhere.com (olcott)
Date: Mon, 9 Aug 2021 16:13:49 -0500
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:78.0) Gecko/20100101 Thunderbird/78.12.0
MIME-Version: 1.0
In-Reply-To: <ses2dr$jpf$1@dont-email.me>
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Language: en-US
Content-Transfer-Encoding: 8bit
Message-ID: <-4idnXZW5JUQB4z8nZ2dnUU7-W9QAAAA@giganews.com>
Lines: 39
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-WQMh+Rc75tDvqDTya60QMeqMoAgF6tjb4qJPF93IeXp3slGFyex6EF8zg6eHadZdjlgB/ZuHLaTIkeT!mQmYtfZrIqHa3MEYgB99+VSAKyICG3D2ykFbZu2VzNGhB598vktxdXZ5MiFL6UHpjYiI83Hz+Q==
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: 3383
 by: olcott - Mon, 9 Aug 2021 21:13 UTC

On 8/9/2021 3:15 PM, André G. Isaak wrote:
> On 2021-08-09 13:52, olcott wrote:
>> On 8/9/2021 12:30 PM, Malcolm McLean wrote:
>
>>> It's unclear to me exactly how H is a "simulator", given this
>>> execution trace.
>>
>> I don't see what could possibly be unclear about it to anyone knowing
>> the x86 language well enough. The trace shows exactly what P would do
>> if it was simulated by a pure simulator with itself as input.
>
> No, the trace appears to show what P would do if invoked *directly* with
> itself as input, and in which P subsequently calls its input *directly*
> rather than simulating it. This should be clear to anyone who knows the
> x86 language well enough.
>

Because H only acts as a pure simulator of its input until after its
halt status decision has been made it has no behavior that can possibly
effect the behavior of its input. Because of this H screens out its own
address range in every execution trace that it examines. This is why we
never see any instructions of H in any execution trace after an input
calls H.

> This discrepancy between what you claim your code does and what your
> traces appear to show has been pointed out to you before and you've
> never adequately explained what your code *really* does. Either your
> 'simulations' aren't really simulations or your 'x86 traces' aren't
> actually x86 traces.
>
> André
>

--
Copyright 2021 Pete Olcott

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

Re: Honest dialogue on the proof that H(P,P)==0 is correct [proof defined]

<FMednRmbkIieAYz8nZ2dnUU7-emdnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!paganini.bofh.team!news.dns-netz.com!news.freedyn.net!newsfeed.xs4all.nl!newsfeed9.news.xs4all.nl!tr2.eu1.usenetexpress.com!feeder.usenetexpress.com!tr3.iad1.usenetexpress.com!border1.nntp.dca1.giganews.com!nntp.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Mon, 09 Aug 2021 16:20:03 -0500
Subject: Re: Honest dialogue on the proof that H(P,P)==0 is correct [proof defined]
Newsgroups: comp.theory
References: <HNidndugKOWGvpH8nZ2dnUU7-fXNnZ2d@giganews.com> <Vs0PI.2099$xY.509@fx05.iad> <GLudnUM2eaoEC5H8nZ2dnUU7-evNnZ2d@giganews.com> <5Z1PI.1823$6h1.1128@fx39.iad> <r6idnXrkQsZ5JJH8nZ2dnUU7-V_NnZ2d@giganews.com> <qb9PI.22$uV3.2@fx18.iad> <6radnYHwiMoYvpD8nZ2dnUU7-UPNnZ2d@giganews.com> <owaPI.297$uk4.251@fx20.iad> <a82dnc_0ypriwZD8nZ2dnUU7-QHNnZ2d@giganews.com> <sel07d$pcf$1@dont-email.me> <DdCdnaOAJLE3l5P8nZ2dnUU7-enNnZ2d@giganews.com> <sep914$6pc$1@dont-email.me> <mdKdncO0j8L6w4z8nZ2dnUU7-S_NnZ2d@giganews.com> <2cf7b09a-b3a2-4ede-b33f-c57a3736e9a7n@googlegroups.com> <yIOdnSFYVobgGoz8nZ2dnUU7-SnNnZ2d@giganews.com> <ses2dr$jpf$1@dont-email.me> <-4idnXZW5JUQB4z8nZ2dnUU7-W9QAAAA@giganews.com>
From: NoO...@NoWhere.com (olcott)
Date: Mon, 9 Aug 2021 16:20:03 -0500
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:78.0) Gecko/20100101 Thunderbird/78.12.0
MIME-Version: 1.0
In-Reply-To: <-4idnXZW5JUQB4z8nZ2dnUU7-W9QAAAA@giganews.com>
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Language: en-US
Content-Transfer-Encoding: 8bit
Message-ID: <FMednRmbkIieAYz8nZ2dnUU7-emdnZ2d@giganews.com>
Lines: 50
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-sneojlfG30phkLxWdkpWh70Cry4JlJ9JR19eIUBhT5cvxrEyiqqZQyeVlvOpm/iHcQ0meElSWRoR6Sp!LxGi/2WZ8IN746E2T2lE+Wi9Ff8T8l3bNBQagIQRPX8sDuMi83slIOvEebilCrbL3/l0UrtVMA==
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: 3796
 by: olcott - Mon, 9 Aug 2021 21:20 UTC

On 8/9/2021 4:13 PM, olcott wrote:
> On 8/9/2021 3:15 PM, André G. Isaak wrote:
>> On 2021-08-09 13:52, olcott wrote:
>>> On 8/9/2021 12:30 PM, Malcolm McLean wrote:
>>
>>>> It's unclear to me exactly how H is a "simulator", given this
>>>> execution trace.
>>>
>>> I don't see what could possibly be unclear about it to anyone knowing
>>> the x86 language well enough. The trace shows exactly what P would do
>>> if it was simulated by a pure simulator with itself as input.
>>
>> No, the trace appears to show what P would do if invoked *directly*
>> with itself as input, and in which P subsequently calls its input
>> *directly* rather than simulating it. This should be clear to anyone
>> who knows the x86 language well enough.
>>
>
> Because H only acts as a pure simulator of its input until after its
> halt status decision has been made it has no behavior that can possibly
> effect the behavior of its input. Because of this H screens out its own
> address range in every execution trace that it examines. This is why we
> never see any instructions of H in any execution trace after an input
> calls H.

An additional 396 pages of execution trace proves that H does correctly
emulate itself. For people that get hopelessly lost unable to understand
seven lines of code after months of discussion these extra 396 pages of
execution trace would not help.

>
>> This discrepancy between what you claim your code does and what your
>> traces appear to show has been pointed out to you before and you've
>> never adequately explained what your code *really* does. Either your
>> 'simulations' aren't really simulations or your 'x86 traces' aren't
>> actually x86 traces.
>>
>> André
>>
>
>

--
Copyright 2021 Pete Olcott

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

Re: Honest dialogue on the proof that H(P,P)==0 is correct [proof defined]

<q6mdnffhc4WHPYz8nZ2dnUU7-InNnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory comp.ai.philosophy comp.software-eng sci.math.symbolic
Path: i2pn2.org!i2pn.org!weretis.net!feeder8.news.weretis.net!feeder1.feed.usenet.farm!feed.usenet.farm!tr2.eu1.usenetexpress.com!feeder.usenetexpress.com!tr3.iad1.usenetexpress.com!border1.nntp.dca1.giganews.com!nntp.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Mon, 09 Aug 2021 16:37:30 -0500
Subject: Re: Honest dialogue on the proof that H(P,P)==0 is correct [proof defined]
Newsgroups: comp.theory,comp.ai.philosophy,comp.software-eng,sci.math.symbolic
References: <HNidndugKOWGvpH8nZ2dnUU7-fXNnZ2d@giganews.com> <Vs0PI.2099$xY.509@fx05.iad> <GLudnUM2eaoEC5H8nZ2dnUU7-evNnZ2d@giganews.com> <5Z1PI.1823$6h1.1128@fx39.iad> <r6idnXrkQsZ5JJH8nZ2dnUU7-V_NnZ2d@giganews.com> <qb9PI.22$uV3.2@fx18.iad> <6radnYHwiMoYvpD8nZ2dnUU7-UPNnZ2d@giganews.com> <owaPI.297$uk4.251@fx20.iad> <a82dnc_0ypriwZD8nZ2dnUU7-QHNnZ2d@giganews.com> <sel07d$pcf$1@dont-email.me> <DdCdnaOAJLE3l5P8nZ2dnUU7-enNnZ2d@giganews.com> <sep914$6pc$1@dont-email.me> <mdKdncO0j8L6w4z8nZ2dnUU7-S_NnZ2d@giganews.com> <2cf7b09a-b3a2-4ede-b33f-c57a3736e9a7n@googlegroups.com> <yIOdnSFYVobgGoz8nZ2dnUU7-SnNnZ2d@giganews.com>
From: NoO...@NoWhere.com (olcott)
Date: Mon, 9 Aug 2021 16:37:29 -0500
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:78.0) Gecko/20100101 Thunderbird/78.12.0
MIME-Version: 1.0
In-Reply-To: <yIOdnSFYVobgGoz8nZ2dnUU7-SnNnZ2d@giganews.com>
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Language: en-US
Content-Transfer-Encoding: 8bit
Message-ID: <q6mdnffhc4WHPYz8nZ2dnUU7-InNnZ2d@giganews.com>
Lines: 130
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-plqN2GfYe4NcgebR2aiAdAxL1K5bxT8JRY//rQiiMehbF8ngXSq3ALthodiTbFcVdsFo2voJ9L3qZ7f!DmV6oEe9f7Z2QcVENoxgS8XYyG4+LAMbPtPVIp9Q3THkURP0zOaOLufn7RLSlv21/6rgeHsugA==
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: 7440
 by: olcott - Mon, 9 Aug 2021 21:37 UTC

On 8/9/2021 2:52 PM, olcott wrote:
> On 8/9/2021 12:30 PM, Malcolm McLean wrote:
>> On Monday, 9 August 2021 at 17:57:18 UTC+1, olcott wrote:
>>> On 8/8/2021 1:50 PM, André G. Isaak wrote:
>>>> On 2021-08-06 22:23, olcott wrote:
>>>>> On 8/6/2021 10:55 PM, André G. Isaak wrote:
>>>>>> On 2021-08-06 09:59, olcott wrote:
>>>>
>>>>>> Yes, but bear in mind that 'halting' refers to Turing Machines
>>>>>> operating on a specific input. It does not refer to simulations or
>>>>>> what happens inside a halting decider. It refers *only* to actual
>>>>>> computations, i.e. an actual Turing Machine operating on an actual
>>>>>> input string.
>>>>>>
>>>>>
>>>>> So yet again you prove that you are totally clueless that pure
>>>>> simulations are computationally equivalent to direct executions ?
>>>>
>>>> Your H is not a pure simulator
>>>>
>>> // Simplified Linz Ĥ (Linz:1990:319)
>>> // Strachey(1965) CPL translated to C
>>> void P(u32 x)
>>> {
>>> if (H(x, x))
>>> HERE: goto HERE;
>>> }
>>> _P()
>>> [00000d02](01) 55 push ebp
>>> [00000d03](02) 8bec mov ebp,esp
>>> [00000d05](03) 8b4508 mov eax,[ebp+08]
>>> [00000d08](01) 50 push eax // push 2nd Param
>>> [00000d09](03) 8b4d08 mov ecx,[ebp+08]
>>> [00000d0c](01) 51 push ecx // push 1st Param
>>> [00000d0d](05) e870feffff call 00000b82 // call H
>>> [00000d12](03) 83c408 add esp,+08
>>> [00000d15](02) 85c0 test eax,eax
>>> [00000d17](02) 7402 jz 00000d1b
>>> [00000d19](02) ebfe jmp 00000d19
>>> [00000d1b](01) 5d pop ebp
>>> [00000d1c](01) c3 ret
>>> Size in bytes:(0027) [00000d1c]
>>>
>>> machine stack stack machine assembly
>>> address address data code language
>>> ======== ======== ======== ========= =============
>>> ...[00000d0d][00101829][00000d12] e870feffff call 00000b82 // call H
>>> Begin Local Halt Decider Simulation at Machine Address:d02
>>> ...[00000d02][002118f1][002118f5] 55 push ebp
>>> ...[00000d03][002118f1][002118f5] 8bec mov ebp,esp
>>> ...[00000d05][002118f1][002118f5] 8b4508 mov eax,[ebp+08]
>>> ...[00000d08][002118ed][00000d02] 50 push eax // push P
>>> ...[00000d09][002118ed][00000d02] 8b4d08 mov ecx,[ebp+08]
>>> ...[00000d0c][002118e9][00000d02] 51 push ecx // push P
>>> ...[00000d0d][002118e5][00000d12] e870feffff call 00000b82 // call H
>>> ...[00000d02][0025c319][0025c31d] 55 push ebp
>>> ...[00000d03][0025c319][0025c31d] 8bec mov ebp,esp
>>> ...[00000d05][0025c319][0025c31d] 8b4508 mov eax,[ebp+08]
>>> ...[00000d08][0025c315][00000d02] 50 push eax // push P
>>> ...[00000d09][0025c315][00000d02] 8b4d08 mov ecx,[ebp+08]
>>> ...[00000d0c][0025c311][00000d02] 51 push ecx // push P
>>> ...[00000d0d][0025c30d][00000d12] e870feffff call 00000b82 // call H
>>> Local Halt Decider: Infinite Recursion Detected Simulation Stopped
>>> The fact that the execution trace of the simulation of P(P) on page 6
>>> perfectly matches its source-code on page 5 conclusively proves that
>>> this execution trace performed by H is a pure simulation of P(P). There
>>> is no correct basis for disagreement, therefore anyone disagreeing
>>> either does not know the x86 language or they are simply lying.
>>>
>> It's unclear to me exactly how H is a "simulator", given this
>> execution trace.
>
> I don't see what could possibly be unclear about it to anyone knowing
> the x86 language well enough. The trace shows exactly what P would do if
> it was simulated by a pure simulator with itself as input.
>

Since everyone is finding it next to impossible to understand what the
behavior of seven lines of code would be while H acts as a pure
simulator of its input adding thousands of more lines of code cannot
possibly help their understanding:

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

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

>> Normally a simulator creates a virtual machine with a virtual address
>> space
>> and virtual instructions. The execution trace of the simulator looks
>> nothing
>> like the execution trace of the simulated code - basically the
>> simulator does
>> a big switch on the op code of the virtual machine's instruction, then
>> updates
>> memory and registers, with special rules for IO.
>>
>
> Those details only serve to get people confused. The fact that the x86
> code of P acts exactly as if it was simulated by a pure simulator proves
> beyond all possible doubt that H does simulate P on input P as a pure
> simulator.
>
>> You don't seem to be using this model for H.
>>
>> However iif P(P) halts, then any execution trace which shows it P(P)
>> as non-halting
>> must have a mistake in it somewhere, either in the simulator or in the
>> interpretation
>> of the trace.
>>
>
>

--
Copyright 2021 Pete Olcott

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

Re: Honest dialogue on the proof that H(P,P)==0 is correct [proof defined]

<ses9ha$37f$1@dont-email.me>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!eternal-september.org!reader02.eternal-september.org!.POSTED!not-for-mail
From: agis...@gm.invalid (André G. Isaak)
Newsgroups: comp.theory
Subject: Re: Honest dialogue on the proof that H(P,P)==0 is correct [proof
defined]
Date: Mon, 9 Aug 2021 16:17:12 -0600
Organization: Christians and Atheists United Against Creeping Agnosticism
Lines: 128
Message-ID: <ses9ha$37f$1@dont-email.me>
References: <HNidndugKOWGvpH8nZ2dnUU7-fXNnZ2d@giganews.com>
<Vs0PI.2099$xY.509@fx05.iad> <GLudnUM2eaoEC5H8nZ2dnUU7-evNnZ2d@giganews.com>
<5Z1PI.1823$6h1.1128@fx39.iad>
<r6idnXrkQsZ5JJH8nZ2dnUU7-V_NnZ2d@giganews.com> <qb9PI.22$uV3.2@fx18.iad>
<6radnYHwiMoYvpD8nZ2dnUU7-UPNnZ2d@giganews.com> <owaPI.297$uk4.251@fx20.iad>
<a82dnc_0ypriwZD8nZ2dnUU7-QHNnZ2d@giganews.com> <sel07d$pcf$1@dont-email.me>
<DdCdnaOAJLE3l5P8nZ2dnUU7-enNnZ2d@giganews.com> <sep914$6pc$1@dont-email.me>
<mdKdncO0j8L6w4z8nZ2dnUU7-S_NnZ2d@giganews.com> <ses089$7io$1@dont-email.me>
<-4idnXdW5JWtB4z8nZ2dnUU7-W_NnZ2d@giganews.com>
Mime-Version: 1.0
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Mon, 9 Aug 2021 22:17:14 -0000 (UTC)
Injection-Info: reader02.eternal-september.org; posting-host="422ca2f1478ddd861649480f9de299e8";
logging-data="3311"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX18zKoKO3Uz0X1V2sDUoNatw"
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.14; rv:68.0)
Gecko/20100101 Thunderbird/68.12.1
Cancel-Lock: sha1:4WE5xjMBRC3Ho7PYBkSkxQREkDs=
In-Reply-To: <-4idnXdW5JWtB4z8nZ2dnUU7-W_NnZ2d@giganews.com>
Content-Language: en-US
 by: André G. Isaak - Mon, 9 Aug 2021 22:17 UTC

On 2021-08-09 15:12, olcott wrote:
> On 8/9/2021 2:38 PM, André G. Isaak wrote:
>> On 2021-08-09 10:57, olcott wrote:
>>> On 8/8/2021 1:50 PM, André G. Isaak wrote:
>>>> On 2021-08-06 22:23, olcott wrote:
>>>>> On 8/6/2021 10:55 PM, André G. Isaak wrote:
>>>>>> On 2021-08-06 09:59, olcott wrote:
>>>>
>>>>>> Yes, but bear in mind that 'halting' refers to Turing Machines
>>>>>> operating on a specific input. It does not refer to simulations or
>>>>>> what happens inside a halting decider. It refers *only* to actual
>>>>>> computations, i.e. an actual Turing Machine operating on an actual
>>>>>> input string.
>>>>>>
>>>>>
>>>>> So yet again you prove that you are totally clueless that pure
>>>>> simulations are computationally equivalent to direct executions ?
>>>>
>>>> Your H is not a pure simulator
>>>>
>>>
>>> // Simplified Linz Ĥ (Linz:1990:319)
>>> // Strachey(1965) CPL translated to C
>>> void P(u32 x)
>>> {
>>>    if (H(x, x))
>>>      HERE: goto HERE;
>>> }
>>>
>>> _P()
>>> [00000d02](01)  55          push ebp
>>> [00000d03](02)  8bec        mov ebp,esp
>>> [00000d05](03)  8b4508      mov eax,[ebp+08]
>>> [00000d08](01)  50          push eax       // push 2nd Param
>>> [00000d09](03)  8b4d08      mov ecx,[ebp+08]
>>> [00000d0c](01)  51          push ecx       // push 1st Param
>>> [00000d0d](05)  e870feffff  call 00000b82  // call H
>>> [00000d12](03)  83c408      add esp,+08
>>> [00000d15](02)  85c0        test eax,eax
>>> [00000d17](02)  7402        jz 00000d1b
>>> [00000d19](02)  ebfe        jmp 00000d19
>>> [00000d1b](01)  5d          pop ebp
>>> [00000d1c](01)  c3          ret
>>> Size in bytes:(0027) [00000d1c]
>>>
>>>      machine   stack     stack     machine     assembly
>>>      address   address   data      code        language
>>>      ========  ========  ========  =========   =============
>>> ...[00000d0d][00101829][00000d12] e870feffff  call 00000b82  // call H
>>>
>>> Begin Local Halt Decider Simulation at Machine Address:d02
>>> ...[00000d02][002118f1][002118f5] 55          push ebp
>>> ...[00000d03][002118f1][002118f5] 8bec        mov ebp,esp
>>> ...[00000d05][002118f1][002118f5] 8b4508      mov eax,[ebp+08]
>>> ...[00000d08][002118ed][00000d02] 50          push eax       // push P
>>> ...[00000d09][002118ed][00000d02] 8b4d08      mov ecx,[ebp+08]
>>> ...[00000d0c][002118e9][00000d02] 51          push ecx       // push P
>>> ...[00000d0d][002118e5][00000d12] e870feffff  call 00000b82  // call H
>>> ...[00000d02][0025c319][0025c31d] 55          push ebp
>>> ...[00000d03][0025c319][0025c31d] 8bec        mov ebp,esp
>>> ...[00000d05][0025c319][0025c31d] 8b4508      mov eax,[ebp+08]
>>> ...[00000d08][0025c315][00000d02] 50          push eax       // push P
>>> ...[00000d09][0025c315][00000d02] 8b4d08      mov ecx,[ebp+08]
>>> ...[00000d0c][0025c311][00000d02] 51          push ecx       // push P
>>> ...[00000d0d][0025c30d][00000d12] e870feffff  call 00000b82  // call H
>>> Local Halt Decider: Infinite Recursion Detected Simulation Stopped
>>>
>>> The fact that the execution trace of the simulation of P(P) on page 6
>>> perfectly matches its source-code on page 5 conclusively proves that
>>> this execution trace performed by H is a pure simulation of P(P).
>>> There is no correct basis for disagreement, therefore anyone
>>> disagreeing either does not know the x86 language or they are simply
>>> lying.
>>
>> You have a *partial trace* and *partial source code*. Neither shows
>> what happens at B82.
>>
>
> if int add(int x, int y) returns 5 on add(2,3) we know for sure that add
> was correct on that input.

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

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

> If every line of the execution trace of the simulation of P on input P
> behaves exactly as its x86 source-code specifies that it must behave
> then we know with 100% perfectly justified logical certainty that H did
> perform a pure simulation of P on input P.
>
> Do you care about the truth or will you continue to argue when you know
> that you are wrong?
>
>> Your trace ends with the cryptic message "Local Halt Decider: Infinite
>> Recursion Detected Simulation Stopped" which doesn't indicate *which*
>> invocation of H aborted *which* simulation and to where control was
>> transferred once that simulation was aborted.
>>
>> Amdré
>>
>
> All that matters it that it is perfectly obvious to anyone knowing the
> x86 language well enough that the input to H does specifies infinitely
> nested simulation. This proves that whatever H aborted whichever P was
> correct in its never halting decision.

No. It doesn't.

When you run P(P), which is the computation which H(P, P) is being asked
about, the outermost P *can't* be aborted because it isn't being
simulated. The H which it contains aborts the simulation being run
inside the outermost P and then returns control to the outermost P at
which point the computation halts.

When you run H(P, P) it is crucial that control be similarly returned to
the outermost P and *not* the outermost H or else it is not accurately
simulating what P(P) does. However, the fact that your H returns false
makes it clear that when you run H(P, P) your halt decider aborts the
*outermost* P and then returns control to the outermost H rather than
the outermost P. This *doesn't* match what goes on inside P(P) which
means your simulation is *not* pure.

André

--
To email remove 'invalid' & replace 'gm' with well known Google mail
service.

Re: Honest dialogue on the proof that H(P,P)==0 is correct [proof defined]

<bcWdne-_8KvrN4z8nZ2dnUU7-dnNnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory comp.ai.philosophy comp.software-eng sci.math.symbolic
Path: i2pn2.org!i2pn.org!paganini.bofh.team!news.dns-netz.com!news.freedyn.net!newsfeed.xs4all.nl!newsfeed9.news.xs4all.nl!tr2.eu1.usenetexpress.com!feeder.usenetexpress.com!tr3.iad1.usenetexpress.com!border1.nntp.dca1.giganews.com!nntp.giganews.com!buffer1.nntp.dca1.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Mon, 09 Aug 2021 17:21:42 -0500
Subject: Re: Honest dialogue on the proof that H(P,P)==0 is correct [proof defined]
Newsgroups: comp.theory,comp.ai.philosophy,comp.software-eng,sci.math.symbolic
References: <HNidndugKOWGvpH8nZ2dnUU7-fXNnZ2d@giganews.com> <Vs0PI.2099$xY.509@fx05.iad> <GLudnUM2eaoEC5H8nZ2dnUU7-evNnZ2d@giganews.com> <5Z1PI.1823$6h1.1128@fx39.iad> <r6idnXrkQsZ5JJH8nZ2dnUU7-V_NnZ2d@giganews.com> <qb9PI.22$uV3.2@fx18.iad> <6radnYHwiMoYvpD8nZ2dnUU7-UPNnZ2d@giganews.com> <owaPI.297$uk4.251@fx20.iad> <a82dnc_0ypriwZD8nZ2dnUU7-QHNnZ2d@giganews.com> <sel07d$pcf$1@dont-email.me> <DdCdnaOAJLE3l5P8nZ2dnUU7-enNnZ2d@giganews.com> <sep914$6pc$1@dont-email.me> <mdKdncO0j8L6w4z8nZ2dnUU7-S_NnZ2d@giganews.com> <ses089$7io$1@dont-email.me> <-4idnXdW5JWtB4z8nZ2dnUU7-W_NnZ2d@giganews.com> <ses9ha$37f$1@dont-email.me>
From: NoO...@NoWhere.com (olcott)
Date: Mon, 9 Aug 2021 17:21:41 -0500
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:78.0) Gecko/20100101 Thunderbird/78.12.0
MIME-Version: 1.0
In-Reply-To: <ses9ha$37f$1@dont-email.me>
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Language: en-US
Content-Transfer-Encoding: 8bit
Message-ID: <bcWdne-_8KvrN4z8nZ2dnUU7-dnNnZ2d@giganews.com>
Lines: 101
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-vqWEdeWK5G9MAwsc60bM4fdbCSN0mzPPmSUpHEYw/2KgsaNCugvA4LtSWaVWbGPxvcs6jRs8GZRYwoE!cVN3eSr5byu67HqIAHIgGXW6XdppAU/yGDvp3RGweY6itpHzvk2R1OC1N+FnaH5zjKKr6CKrvw==
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: 6648
 by: olcott - Mon, 9 Aug 2021 22:21 UTC

On 8/9/2021 5:17 PM, André G. Isaak wrote:
> On 2021-08-09 15:12, olcott wrote:
>> On 8/9/2021 2:38 PM, André G. Isaak wrote:
>>> On 2021-08-09 10:57, olcott wrote:
>>>> On 8/8/2021 1:50 PM, André G. Isaak wrote:
>>>>> On 2021-08-06 22:23, olcott wrote:
>>>>>> On 8/6/2021 10:55 PM, André G. Isaak wrote:
>>>>>>> On 2021-08-06 09:59, olcott wrote:
>>>>>
>>>>>>> Yes, but bear in mind that 'halting' refers to Turing Machines
>>>>>>> operating on a specific input. It does not refer to simulations
>>>>>>> or what happens inside a halting decider. It refers *only* to
>>>>>>> actual computations, i.e. an actual Turing Machine operating on
>>>>>>> an actual input string.
>>>>>>>
>>>>>>
>>>>>> So yet again you prove that you are totally clueless that pure
>>>>>> simulations are computationally equivalent to direct executions ?
>>>>>
>>>>> Your H is not a pure simulator
>>>>>
>>>>
>>>> // Simplified Linz Ĥ (Linz:1990:319)
>>>> // Strachey(1965) CPL translated to C
>>>> void P(u32 x)
>>>> {
>>>>    if (H(x, x))
>>>>      HERE: goto HERE;
>>>> }
>>>>
>>>> _P()
>>>> [00000d02](01)  55          push ebp
>>>> [00000d03](02)  8bec        mov ebp,esp
>>>> [00000d05](03)  8b4508      mov eax,[ebp+08]
>>>> [00000d08](01)  50          push eax       // push 2nd Param
>>>> [00000d09](03)  8b4d08      mov ecx,[ebp+08]
>>>> [00000d0c](01)  51          push ecx       // push 1st Param
>>>> [00000d0d](05)  e870feffff  call 00000b82  // call H
>>>> [00000d12](03)  83c408      add esp,+08
>>>> [00000d15](02)  85c0        test eax,eax
>>>> [00000d17](02)  7402        jz 00000d1b
>>>> [00000d19](02)  ebfe        jmp 00000d19
>>>> [00000d1b](01)  5d          pop ebp
>>>> [00000d1c](01)  c3          ret
>>>> Size in bytes:(0027) [00000d1c]
>>>>
>>>>      machine   stack     stack     machine     assembly
>>>>      address   address   data      code        language
>>>>      ========  ========  ========  =========   =============
>>>> ...[00000d0d][00101829][00000d12] e870feffff  call 00000b82  // call H
>>>>
>>>> Begin Local Halt Decider Simulation at Machine Address:d02
>>>> ...[00000d02][002118f1][002118f5] 55          push ebp
>>>> ...[00000d03][002118f1][002118f5] 8bec        mov ebp,esp
>>>> ...[00000d05][002118f1][002118f5] 8b4508      mov eax,[ebp+08]
>>>> ...[00000d08][002118ed][00000d02] 50          push eax       // push P
>>>> ...[00000d09][002118ed][00000d02] 8b4d08      mov ecx,[ebp+08]
>>>> ...[00000d0c][002118e9][00000d02] 51          push ecx       // push P
>>>> ...[00000d0d][002118e5][00000d12] e870feffff  call 00000b82  // call H
>>>> ...[00000d02][0025c319][0025c31d] 55          push ebp
>>>> ...[00000d03][0025c319][0025c31d] 8bec        mov ebp,esp
>>>> ...[00000d05][0025c319][0025c31d] 8b4508      mov eax,[ebp+08]
>>>> ...[00000d08][0025c315][00000d02] 50          push eax       // push P
>>>> ...[00000d09][0025c315][00000d02] 8b4d08      mov ecx,[ebp+08]
>>>> ...[00000d0c][0025c311][00000d02] 51          push ecx       // push P
>>>> ...[00000d0d][0025c30d][00000d12] e870feffff  call 00000b82  // call H
>>>> Local Halt Decider: Infinite Recursion Detected Simulation Stopped
>>>>
>>>> The fact that the execution trace of the simulation of P(P) on page
>>>> 6 perfectly matches its source-code on page 5 conclusively proves
>>>> that this execution trace performed by H is a pure simulation of
>>>> P(P). There is no correct basis for disagreement, therefore anyone
>>>> disagreeing either does not know the x86 language or they are simply
>>>> lying.
>>>
>>> You have a *partial trace* and *partial source code*. Neither shows
>>> what happens at B82.
>>>
>>
>> if int add(int x, int y) returns 5 on add(2,3) we know for sure that
>> add was correct on that input.
>
> That is a poor analogy since 5 actually *is* the correct answer to 2+3.
>
> We know that P(P) *does* halt, which means that if H(P, P) returns false
> we know for sure that H was *incorrect* on that input.

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

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

https://www.researchgate.net/publication/351947980_Halting_problem_undecidability_and_infinitely_nested_simulation

--
Copyright 2021 Pete Olcott

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

Re: Honest dialogue on the proof that H(P,P)==0 is correct [ easy as 1,2,3 ]

<bcWdne6_8KteN4z8nZ2dnUU7-dlQAAAA@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.snarked.org!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Mon, 09 Aug 2021 17:22:58 -0500
Subject: Re: Honest dialogue on the proof that H(P,P)==0 is correct [ easy as
1,2,3 ]
Newsgroups: comp.theory
References: <HNidndugKOWGvpH8nZ2dnUU7-fXNnZ2d@giganews.com>
<JOCdnfw1VaEaDZP8nZ2dnUU7-YPNnZ2d@giganews.com> <sem7cg$puv$1@news.muc.de>
<q7ydnRnqSvJBO5P8nZ2dnUU7-avNnZ2d@giganews.com> <semc4h$27g8$1@news.muc.de>
<Kqudna8HOpsQJZP8nZ2dnUU78fednZ2d@giganews.com> <semgka$27g8$2@news.muc.de>
<8v6dnTrkQ_4qd5P8nZ2dnUU7-LfNnZ2d@giganews.com> <sems1k$27g8$3@news.muc.de>
<8PmdnaQYrtbBapP8nZ2dnUU78IHNnZ2d@giganews.com> <semvmc$2iij$1@news.muc.de>
<64WdncfCqdFLkpL8nZ2dnUU7-W3NnZ2d@giganews.com> <seoiit$aq3$1@news.muc.de>
From: NoO...@NoWhere.com (olcott)
Date: Mon, 9 Aug 2021 17:22:58 -0500
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:78.0) Gecko/20100101
Thunderbird/78.12.0
MIME-Version: 1.0
In-Reply-To: <seoiit$aq3$1@news.muc.de>
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Language: en-US
Content-Transfer-Encoding: 7bit
Message-ID: <bcWdne6_8KteN4z8nZ2dnUU7-dlQAAAA@giganews.com>
Lines: 48
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-pqhTsY3vaFjdMbghimSuObfhghOBImQmeiWFmIJw6u2pmWaWwvVq3FkY+kmW1/KkWPi2C04mvyhOpHH!rxT0qtS8srOZj0aQ1kDfUHUVEzRyHyZAlVzgls6+OXY/c3553LJA/4bKBhW/nmIujVh1Ky+MVQ==
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: 3124
 by: olcott - Mon, 9 Aug 2021 22:22 UTC

On 8/8/2021 7:27 AM, Alan Mackenzie wrote:
> olcott <NoOne@nowhere.com> wrote:
>
> [ .... ]
>
>> If you wanted an actual honest dialogue you would use logic and
>> reasoning to show exactly how the simulated P would reach its final
>> state of [00000d1c] when we know that H is a pure x86 emulator of P
>> until it makes its halt status decision.
>

Things a liar would say:
> How dare you try to tell me how to conduct a dialogue.

> If I wanted an
> actual honest dialogue, I wouldn't chose you as my dialogue partner. You
> are not honest.
>
> You have been lying about the existence of your H for a very long time.
> But you are not a sufficiently consequent liar. There's something
> stopping you from moving from implicitly asserting the existence of H to
> barefaced lying about it.
>
> So, i challenge you once more. Either assert the actual existence of
> your H, or admit it does not exist.
>
>> On the other hand if you were a mere liar you would use all kinds of
>> subterfuge an rhetoric to avoid this direct challenge.
>
> As I've said often enough before, I don't lie on Usenet, ever.
>
> [ .... ]
>
>> --
>> Copyright 2021 Pete Olcott
>
>> "Great spirits have always encountered violent opposition from mediocre
>> minds." Einstein
>

--
Copyright 2021 Pete Olcott

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

Re: Honest dialogue on the proof that H(P,P)==0 is correct [proof defined]

<87h7fyjlwq.fsf@bsb.me.uk>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!eternal-september.org!reader02.eternal-september.org!.POSTED!not-for-mail
From: ben.use...@bsb.me.uk (Ben Bacarisse)
Newsgroups: comp.theory
Subject: Re: Honest dialogue on the proof that H(P,P)==0 is correct [proof defined]
Date: Mon, 09 Aug 2021 23:25:25 +0100
Organization: A noiseless patient Spider
Lines: 44
Message-ID: <87h7fyjlwq.fsf@bsb.me.uk>
References: <HNidndugKOWGvpH8nZ2dnUU7-fXNnZ2d@giganews.com>
<Vs0PI.2099$xY.509@fx05.iad>
<GLudnUM2eaoEC5H8nZ2dnUU7-evNnZ2d@giganews.com>
<5Z1PI.1823$6h1.1128@fx39.iad>
<r6idnXrkQsZ5JJH8nZ2dnUU7-V_NnZ2d@giganews.com>
<qb9PI.22$uV3.2@fx18.iad>
<6radnYHwiMoYvpD8nZ2dnUU7-UPNnZ2d@giganews.com>
<owaPI.297$uk4.251@fx20.iad>
<a82dnc_0ypriwZD8nZ2dnUU7-QHNnZ2d@giganews.com>
<sel07d$pcf$1@dont-email.me>
<DdCdnaOAJLE3l5P8nZ2dnUU7-enNnZ2d@giganews.com>
<sep914$6pc$1@dont-email.me>
<mdKdncO0j8L6w4z8nZ2dnUU7-S_NnZ2d@giganews.com>
<2cf7b09a-b3a2-4ede-b33f-c57a3736e9a7n@googlegroups.com>
Mime-Version: 1.0
Content-Type: text/plain
Injection-Info: reader02.eternal-september.org; posting-host="c680e65fd59a99ca142b0397b84a17d1";
logging-data="31523"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX1/Fjak6Wkl2hY4AkEdTKIV2zbKRBS9saj4="
Cancel-Lock: sha1:koUxvb8ipt4Uk6ci7657dGdL+9o=
sha1:fTT0NqpPocOx9yu133QoxpKnbPs=
X-BSB-Auth: 1.bd677b68629bb06ebbe5.20210809232525BST.87h7fyjlwq.fsf@bsb.me.uk
 by: Ben Bacarisse - Mon, 9 Aug 2021 22:25 UTC

Malcolm McLean <malcolm.arthur.mclean@gmail.com> writes:

> It's unclear to me exactly how H is a "simulator", given this
> execution trace. Normally a simulator creates a virtual machine with
> a virtual address space and virtual instructions. The execution trace
> of the simulator looks nothing like the execution trace of the
> simulated code - basically the simulator does a big switch on the op
> code of the virtual machine's instruction, then updates memory and
> registers, with special rules for IO.

He makes the same mistake about TMs as well. Because the classic
construction of H^ from H used in proofs like Linz's makes H^ duplicate
the input string (into a pair, if the that needs to be specially
encoded) and then "behave like H", he thinks that if H is a UTM the
resulting endless looping causes the input to be endlessly duplicated.
He's even started to give these copies names: <H^[1]> and <H^[2]> etc.

But this is because he's never studied, much less written, a UTM. The
UTM has to use the tape to encode the sate and the tape of the TM being
simulated, and that means the neat fiction of endless copies of the
encoding of UTM^ (i.e. <UTM^>) does not occur. The execution is
endless, but the strings on the tape are way more complex than he
thinks. He reads Linz's notation in a sort of metaphorical way, whereas
it is intended to show exactly what's on the tape.

I've glossed over this as best I can because he loves people getting
bogged down in the details whereas he's been clear that his plan is
wrong for the simplest, high-level reasons.

> You don't seem to be using this model for H.

Indeed. I've thought for some time that he has not been able invoke the
x86 emulator he's found inline as a nested instance. My guess is that
his H just calls its argument function and the "detection" of the
recursion (which is now, of course, a reality) occurs outside. He
probably just thinks that it /could/ be brought into H without making
any difference. Part of the evidence for this comes from his briefly
talking about the "OS as the halt decider".

The game would be up if he ever published H, hence the need to keep it
secret.

--
Ben.

Re: Honest dialogue on the proof that H(P,P)==0 is correct [proof defined]

<sesb21$h6$1@dont-email.me>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!eternal-september.org!reader02.eternal-september.org!.POSTED!not-for-mail
From: agis...@gm.invalid (André G. Isaak)
Newsgroups: comp.theory
Subject: Re: Honest dialogue on the proof that H(P,P)==0 is correct [proof
defined]
Date: Mon, 9 Aug 2021 16:43:12 -0600
Organization: Christians and Atheists United Against Creeping Agnosticism
Lines: 124
Message-ID: <sesb21$h6$1@dont-email.me>
References: <HNidndugKOWGvpH8nZ2dnUU7-fXNnZ2d@giganews.com>
<Vs0PI.2099$xY.509@fx05.iad> <GLudnUM2eaoEC5H8nZ2dnUU7-evNnZ2d@giganews.com>
<5Z1PI.1823$6h1.1128@fx39.iad>
<r6idnXrkQsZ5JJH8nZ2dnUU7-V_NnZ2d@giganews.com> <qb9PI.22$uV3.2@fx18.iad>
<6radnYHwiMoYvpD8nZ2dnUU7-UPNnZ2d@giganews.com> <owaPI.297$uk4.251@fx20.iad>
<a82dnc_0ypriwZD8nZ2dnUU7-QHNnZ2d@giganews.com> <sel07d$pcf$1@dont-email.me>
<DdCdnaOAJLE3l5P8nZ2dnUU7-enNnZ2d@giganews.com> <sep914$6pc$1@dont-email.me>
<mdKdncO0j8L6w4z8nZ2dnUU7-S_NnZ2d@giganews.com> <ses089$7io$1@dont-email.me>
<-4idnXdW5JWtB4z8nZ2dnUU7-W_NnZ2d@giganews.com> <ses9ha$37f$1@dont-email.me>
<bcWdne-_8KvrN4z8nZ2dnUU7-dnNnZ2d@giganews.com>
Mime-Version: 1.0
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Mon, 9 Aug 2021 22:43:13 -0000 (UTC)
Injection-Info: reader02.eternal-september.org; posting-host="422ca2f1478ddd861649480f9de299e8";
logging-data="550"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX18K9HFZKBuhsmoi0za0fgJL"
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.14; rv:68.0)
Gecko/20100101 Thunderbird/68.12.1
Cancel-Lock: sha1:Emx3Haofd5GHmkKBjR5235U85vk=
In-Reply-To: <bcWdne-_8KvrN4z8nZ2dnUU7-dnNnZ2d@giganews.com>
Content-Language: en-US
 by: André G. Isaak - Mon, 9 Aug 2021 22:43 UTC

On 2021-08-09 16:21, olcott wrote:
> On 8/9/2021 5:17 PM, André G. Isaak wrote:
>> On 2021-08-09 15:12, olcott wrote:
>>> On 8/9/2021 2:38 PM, André G. Isaak wrote:
>>>> On 2021-08-09 10:57, olcott wrote:
>>>>> On 8/8/2021 1:50 PM, André G. Isaak wrote:
>>>>>> On 2021-08-06 22:23, olcott wrote:
>>>>>>> On 8/6/2021 10:55 PM, André G. Isaak wrote:
>>>>>>>> On 2021-08-06 09:59, olcott wrote:
>>>>>>
>>>>>>>> Yes, but bear in mind that 'halting' refers to Turing Machines
>>>>>>>> operating on a specific input. It does not refer to simulations
>>>>>>>> or what happens inside a halting decider. It refers *only* to
>>>>>>>> actual computations, i.e. an actual Turing Machine operating on
>>>>>>>> an actual input string.
>>>>>>>>
>>>>>>>
>>>>>>> So yet again you prove that you are totally clueless that pure
>>>>>>> simulations are computationally equivalent to direct executions ?
>>>>>>
>>>>>> Your H is not a pure simulator
>>>>>>
>>>>>
>>>>> // Simplified Linz Ĥ (Linz:1990:319)
>>>>> // Strachey(1965) CPL translated to C
>>>>> void P(u32 x)
>>>>> {
>>>>>    if (H(x, x))
>>>>>      HERE: goto HERE;
>>>>> }
>>>>>
>>>>> _P()
>>>>> [00000d02](01)  55          push ebp
>>>>> [00000d03](02)  8bec        mov ebp,esp
>>>>> [00000d05](03)  8b4508      mov eax,[ebp+08]
>>>>> [00000d08](01)  50          push eax       // push 2nd Param
>>>>> [00000d09](03)  8b4d08      mov ecx,[ebp+08]
>>>>> [00000d0c](01)  51          push ecx       // push 1st Param
>>>>> [00000d0d](05)  e870feffff  call 00000b82  // call H
>>>>> [00000d12](03)  83c408      add esp,+08
>>>>> [00000d15](02)  85c0        test eax,eax
>>>>> [00000d17](02)  7402        jz 00000d1b
>>>>> [00000d19](02)  ebfe        jmp 00000d19
>>>>> [00000d1b](01)  5d          pop ebp
>>>>> [00000d1c](01)  c3          ret
>>>>> Size in bytes:(0027) [00000d1c]
>>>>>
>>>>>      machine   stack     stack     machine     assembly
>>>>>      address   address   data      code        language
>>>>>      ========  ========  ========  =========   =============
>>>>> ...[00000d0d][00101829][00000d12] e870feffff  call 00000b82  // call H
>>>>>
>>>>> Begin Local Halt Decider Simulation at Machine Address:d02
>>>>> ...[00000d02][002118f1][002118f5] 55          push ebp
>>>>> ...[00000d03][002118f1][002118f5] 8bec        mov ebp,esp
>>>>> ...[00000d05][002118f1][002118f5] 8b4508      mov eax,[ebp+08]
>>>>> ...[00000d08][002118ed][00000d02] 50          push eax       // push P
>>>>> ...[00000d09][002118ed][00000d02] 8b4d08      mov ecx,[ebp+08]
>>>>> ...[00000d0c][002118e9][00000d02] 51          push ecx       // push P
>>>>> ...[00000d0d][002118e5][00000d12] e870feffff  call 00000b82  // call H
>>>>> ...[00000d02][0025c319][0025c31d] 55          push ebp
>>>>> ...[00000d03][0025c319][0025c31d] 8bec        mov ebp,esp
>>>>> ...[00000d05][0025c319][0025c31d] 8b4508      mov eax,[ebp+08]
>>>>> ...[00000d08][0025c315][00000d02] 50          push eax       // push P
>>>>> ...[00000d09][0025c315][00000d02] 8b4d08      mov ecx,[ebp+08]
>>>>> ...[00000d0c][0025c311][00000d02] 51          push ecx       // push P
>>>>> ...[00000d0d][0025c30d][00000d12] e870feffff  call 00000b82  // call H
>>>>> Local Halt Decider: Infinite Recursion Detected Simulation Stopped
>>>>>
>>>>> The fact that the execution trace of the simulation of P(P) on page
>>>>> 6 perfectly matches its source-code on page 5 conclusively proves
>>>>> that this execution trace performed by H is a pure simulation of
>>>>> P(P). There is no correct basis for disagreement, therefore anyone
>>>>> disagreeing either does not know the x86 language or they are
>>>>> simply lying.
>>>>
>>>> You have a *partial trace* and *partial source code*. Neither shows
>>>> what happens at B82.
>>>>
>>>
>>> if int add(int x, int y) returns 5 on add(2,3) we know for sure that
>>> add was correct on that input.
>>
>> That is a poor analogy since 5 actually *is* the correct answer to 2+3.
>>
>> We know that P(P) *does* halt, which means that if H(P, P) returns
>> false we know for sure that H was *incorrect* on that input.
>
> P(P) only halts because H(P,P) correctly decides that its input never
> halts and aborts this input on that basis.

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

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

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

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

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

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

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

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

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

André

--
To email remove 'invalid' & replace 'gm' with well known Google mail
service.

Re: Honest dialogue on the proof that H(P,P)==0 is correct [proof defined]

<55SdneGopb-TLYz8nZ2dnUU7-UHNnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory comp.ai.philosophy comp.software-eng sci.math.symbolic
Path: i2pn2.org!i2pn.org!paganini.bofh.team!news.dns-netz.com!news.freedyn.net!newsfeed.xs4all.nl!newsfeed7.news.xs4all.nl!tr3.eu1.usenetexpress.com!feeder.usenetexpress.com!tr3.iad1.usenetexpress.com!border1.nntp.dca1.giganews.com!nntp.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Mon, 09 Aug 2021 17:45:34 -0500
Subject: Re: Honest dialogue on the proof that H(P,P)==0 is correct [proof defined]
Newsgroups: comp.theory,comp.ai.philosophy,comp.software-eng,sci.math.symbolic
References: <HNidndugKOWGvpH8nZ2dnUU7-fXNnZ2d@giganews.com> <Vs0PI.2099$xY.509@fx05.iad> <GLudnUM2eaoEC5H8nZ2dnUU7-evNnZ2d@giganews.com> <5Z1PI.1823$6h1.1128@fx39.iad> <r6idnXrkQsZ5JJH8nZ2dnUU7-V_NnZ2d@giganews.com> <qb9PI.22$uV3.2@fx18.iad> <6radnYHwiMoYvpD8nZ2dnUU7-UPNnZ2d@giganews.com> <owaPI.297$uk4.251@fx20.iad> <a82dnc_0ypriwZD8nZ2dnUU7-QHNnZ2d@giganews.com> <sel07d$pcf$1@dont-email.me> <DdCdnaOAJLE3l5P8nZ2dnUU7-enNnZ2d@giganews.com> <sep914$6pc$1@dont-email.me> <mdKdncO0j8L6w4z8nZ2dnUU7-S_NnZ2d@giganews.com> <2cf7b09a-b3a2-4ede-b33f-c57a3736e9a7n@googlegroups.com> <87h7fyjlwq.fsf@bsb.me.uk>
From: NoO...@NoWhere.com (olcott)
Date: Mon, 9 Aug 2021 17:45:33 -0500
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:78.0) Gecko/20100101 Thunderbird/78.12.0
MIME-Version: 1.0
In-Reply-To: <87h7fyjlwq.fsf@bsb.me.uk>
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Language: en-US
Content-Transfer-Encoding: 7bit
Message-ID: <55SdneGopb-TLYz8nZ2dnUU7-UHNnZ2d@giganews.com>
Lines: 115
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-o9G8brj/FjNnrG/nq/nb4Fq58y6D9+eanskk0kRvzZstPYe4+81ML1cMNLcHgjA3osplHscmWlbf3fA!WPP13qATsCqG2ZsZ2JUqjxOqF4XqgeJSkMiNFZuiwaH3IhpXjS2i/zp5k9BPSbSBvEKBRCqP0Q==
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: 7580
 by: olcott - Mon, 9 Aug 2021 22:45 UTC

On 8/9/2021 5:25 PM, Ben Bacarisse wrote:
> Malcolm McLean <malcolm.arthur.mclean@gmail.com> writes:
>
>> It's unclear to me exactly how H is a "simulator", given this
>> execution trace. Normally a simulator creates a virtual machine with
>> a virtual address space and virtual instructions. The execution trace
>> of the simulator looks nothing like the execution trace of the
>> simulated code - basically the simulator does a big switch on the op
>> code of the virtual machine's instruction, then updates memory and
>> registers, with special rules for IO.
>
> He makes the same mistake about TMs as well. Because the classic
> construction of H^ from H used in proofs like Linz's makes H^ duplicate
> the input string (into a pair, if the that needs to be specially
> encoded) and then "behave like H", he thinks that if H is a UTM the
> resulting endless looping causes the input to be endlessly duplicated.
> He's even started to give these copies names: <H^[1]> and <H^[2]> etc.
>
> But this is because he's never studied, much less written, a UTM. The
> UTM has to use the tape to encode the sate and the tape of the TM being
> simulated, and that means the neat fiction of endless copies of the
> encoding of UTM^ (i.e. <UTM^>) does not occur. The execution is
> endless, but the strings on the tape are way more complex than he
> thinks. He reads Linz's notation in a sort of metaphorical way, whereas
> it is intended to show exactly what's on the tape.
>
> I've glossed over this as best I can because he loves people getting
> bogged down in the details whereas he's been clear that his plan is
> wrong for the simplest, high-level reasons.
>
>> You don't seem to be using this model for H.
>
> Indeed. I've thought for some time that he has not been able invoke the
> x86 emulator he's found inline as a nested instance. My guess is that
> his H just calls its argument function and the "detection" of the
> recursion (which is now, of course, a reality) occurs outside. He
> probably just thinks that it /could/ be brought into H without making
> any difference. Part of the evidence for this comes from his briefly
> talking about the "OS as the halt decider".
>
> The game would be up if he ever published H, hence the need to keep it
> secret.
>
You cannot even possibly post any hypothetical scenario that could
possibly refute the analysis shown below.

It is just like I am saying that we know that int add(int y, int x) is
correct on input (2,3) because add(2,3) returns 5 and you say that we do
not know that add(2,3)==5 is correct.

*You have no place to hide from this correct reasoning*

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

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

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

Because H only acts as a pure simulator of its input until after its
halt status decision has been made it has no behavior that can possibly
effect the behavior of its input. Because of this H screens out its own
address range in every execution trace that it examines. This is why we
never see any instructions of H in any execution trace after an input
calls H.

It is obvious that the execution trace of the simulation of P perfectly
acts as if H was its pure simulator thus proving that H does perform its
pure simulation of P on input P correctly.

The only possible "rebuttals" to this are double-talk and irrelevant
rhetoric. Anyone knowing the x86 language moderately well will confirm
that a pure simulation of P on input P is correctly performed by H
because the behavior of P on input P is exactly as its x86 source-code
specifies.

https://www.researchgate.net/publication/351947980_Halting_problem_undecidability_and_infinitely_nested_simulation

--
Copyright 2021 Pete Olcott

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

Re: Honest dialogue on the proof that H(P,P)==0 is correct [proof defined]

<55SdneCopb8ELYz8nZ2dnUU7-UGdnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!aioe.org!feeder1.feed.usenet.farm!feed.usenet.farm!newsfeed.xs4all.nl!newsfeed7.news.xs4all.nl!fdc2.netnews.com!news-out.netnews.com!news.alt.net!fdc3.netnews.com!feeder.usenetexpress.com!tr1.iad1.usenetexpress.com!border1.nntp.dca1.giganews.com!nntp.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Mon, 09 Aug 2021 17:47:53 -0500
Subject: Re: Honest dialogue on the proof that H(P,P)==0 is correct [proof defined]
Newsgroups: comp.theory
References: <HNidndugKOWGvpH8nZ2dnUU7-fXNnZ2d@giganews.com> <Vs0PI.2099$xY.509@fx05.iad> <GLudnUM2eaoEC5H8nZ2dnUU7-evNnZ2d@giganews.com> <5Z1PI.1823$6h1.1128@fx39.iad> <r6idnXrkQsZ5JJH8nZ2dnUU7-V_NnZ2d@giganews.com> <qb9PI.22$uV3.2@fx18.iad> <6radnYHwiMoYvpD8nZ2dnUU7-UPNnZ2d@giganews.com> <owaPI.297$uk4.251@fx20.iad> <a82dnc_0ypriwZD8nZ2dnUU7-QHNnZ2d@giganews.com> <sel07d$pcf$1@dont-email.me> <DdCdnaOAJLE3l5P8nZ2dnUU7-enNnZ2d@giganews.com> <sep914$6pc$1@dont-email.me> <mdKdncO0j8L6w4z8nZ2dnUU7-S_NnZ2d@giganews.com> <ses089$7io$1@dont-email.me> <-4idnXdW5JWtB4z8nZ2dnUU7-W_NnZ2d@giganews.com> <ses9ha$37f$1@dont-email.me> <bcWdne-_8KvrN4z8nZ2dnUU7-dnNnZ2d@giganews.com> <sesb21$h6$1@dont-email.me>
From: NoO...@NoWhere.com (olcott)
Date: Mon, 9 Aug 2021 17:47:53 -0500
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:78.0) Gecko/20100101 Thunderbird/78.12.0
MIME-Version: 1.0
In-Reply-To: <sesb21$h6$1@dont-email.me>
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Language: en-US
Content-Transfer-Encoding: 8bit
Message-ID: <55SdneCopb8ELYz8nZ2dnUU7-UGdnZ2d@giganews.com>
Lines: 141
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-lPy1FNk07dzRz++7PtV1KBpQaNTC3QNxfzgRGhAHUhRD2lgeT9fosvwayRluDbNupsYzNuYPypgAp+l!V/mIuRJAtzFhOumwTtx5jspKUfpju1yinguOEFdo3gJrqYx2oqvYAWcAxoBErODcMt2zdk2i3A==
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: 8152
 by: olcott - Mon, 9 Aug 2021 22:47 UTC

On 8/9/2021 5:43 PM, André G. Isaak wrote:
> On 2021-08-09 16:21, olcott wrote:
>> On 8/9/2021 5:17 PM, André G. Isaak wrote:
>>> On 2021-08-09 15:12, olcott wrote:
>>>> On 8/9/2021 2:38 PM, André G. Isaak wrote:
>>>>> On 2021-08-09 10:57, olcott wrote:
>>>>>> On 8/8/2021 1:50 PM, André G. Isaak wrote:
>>>>>>> On 2021-08-06 22:23, olcott wrote:
>>>>>>>> On 8/6/2021 10:55 PM, André G. Isaak wrote:
>>>>>>>>> On 2021-08-06 09:59, olcott wrote:
>>>>>>>
>>>>>>>>> Yes, but bear in mind that 'halting' refers to Turing Machines
>>>>>>>>> operating on a specific input. It does not refer to simulations
>>>>>>>>> or what happens inside a halting decider. It refers *only* to
>>>>>>>>> actual computations, i.e. an actual Turing Machine operating on
>>>>>>>>> an actual input string.
>>>>>>>>>
>>>>>>>>
>>>>>>>> So yet again you prove that you are totally clueless that pure
>>>>>>>> simulations are computationally equivalent to direct executions ?
>>>>>>>
>>>>>>> Your H is not a pure simulator
>>>>>>>
>>>>>>
>>>>>> // Simplified Linz Ĥ (Linz:1990:319)
>>>>>> // Strachey(1965) CPL translated to C
>>>>>> void P(u32 x)
>>>>>> {
>>>>>>    if (H(x, x))
>>>>>>      HERE: goto HERE;
>>>>>> }
>>>>>>
>>>>>> _P()
>>>>>> [00000d02](01)  55          push ebp
>>>>>> [00000d03](02)  8bec        mov ebp,esp
>>>>>> [00000d05](03)  8b4508      mov eax,[ebp+08]
>>>>>> [00000d08](01)  50          push eax       // push 2nd Param
>>>>>> [00000d09](03)  8b4d08      mov ecx,[ebp+08]
>>>>>> [00000d0c](01)  51          push ecx       // push 1st Param
>>>>>> [00000d0d](05)  e870feffff  call 00000b82  // call H
>>>>>> [00000d12](03)  83c408      add esp,+08
>>>>>> [00000d15](02)  85c0        test eax,eax
>>>>>> [00000d17](02)  7402        jz 00000d1b
>>>>>> [00000d19](02)  ebfe        jmp 00000d19
>>>>>> [00000d1b](01)  5d          pop ebp
>>>>>> [00000d1c](01)  c3          ret
>>>>>> Size in bytes:(0027) [00000d1c]
>>>>>>
>>>>>>      machine   stack     stack     machine     assembly
>>>>>>      address   address   data      code        language
>>>>>>      ========  ========  ========  =========   =============
>>>>>> ...[00000d0d][00101829][00000d12] e870feffff  call 00000b82  //
>>>>>> call H
>>>>>>
>>>>>> Begin Local Halt Decider Simulation at Machine Address:d02
>>>>>> ...[00000d02][002118f1][002118f5] 55          push ebp
>>>>>> ...[00000d03][002118f1][002118f5] 8bec        mov ebp,esp
>>>>>> ...[00000d05][002118f1][002118f5] 8b4508      mov eax,[ebp+08]
>>>>>> ...[00000d08][002118ed][00000d02] 50          push eax       //
>>>>>> push P
>>>>>> ...[00000d09][002118ed][00000d02] 8b4d08      mov ecx,[ebp+08]
>>>>>> ...[00000d0c][002118e9][00000d02] 51          push ecx       //
>>>>>> push P
>>>>>> ...[00000d0d][002118e5][00000d12] e870feffff  call 00000b82  //
>>>>>> call H
>>>>>> ...[00000d02][0025c319][0025c31d] 55          push ebp
>>>>>> ...[00000d03][0025c319][0025c31d] 8bec        mov ebp,esp
>>>>>> ...[00000d05][0025c319][0025c31d] 8b4508      mov eax,[ebp+08]
>>>>>> ...[00000d08][0025c315][00000d02] 50          push eax       //
>>>>>> push P
>>>>>> ...[00000d09][0025c315][00000d02] 8b4d08      mov ecx,[ebp+08]
>>>>>> ...[00000d0c][0025c311][00000d02] 51          push ecx       //
>>>>>> push P
>>>>>> ...[00000d0d][0025c30d][00000d12] e870feffff  call 00000b82  //
>>>>>> call H
>>>>>> Local Halt Decider: Infinite Recursion Detected Simulation Stopped
>>>>>>
>>>>>> The fact that the execution trace of the simulation of P(P) on
>>>>>> page 6 perfectly matches its source-code on page 5 conclusively
>>>>>> proves that this execution trace performed by H is a pure
>>>>>> simulation of P(P). There is no correct basis for disagreement,
>>>>>> therefore anyone disagreeing either does not know the x86 language
>>>>>> or they are simply lying.
>>>>>
>>>>> You have a *partial trace* and *partial source code*. Neither shows
>>>>> what happens at B82.
>>>>>
>>>>
>>>> if int add(int x, int y) returns 5 on add(2,3) we know for sure that
>>>> add was correct on that input.
>>>
>>> That is a poor analogy since 5 actually *is* the correct answer to 2+3.
>>>
>>> We know that P(P) *does* halt, which means that if H(P, P) returns
>>> false we know for sure that H was *incorrect* on that input.
>>
>> P(P) only halts because H(P,P) correctly decides that its input never
>> halts and aborts this input on that basis.
>
> X only halts because Y IMPLIES that X halts. That's basic logic.
>
> The definition of halting does not refer at all to the *reason* why a
> particular computation halts.
>

The P that halts seems to contradict that H(P,P)==0 is correct yet it is
verifiable that H(P,P)==0 is correct. That you keep ignoring this means
that you are dishonest.

> "The airplane crashed "only" because it ran out of fuel" IMPLIES that
> the airplane crashed.
>
> "The man was arrested "only" because the police chief held a grudge"
> IMPLIES that the man was arrested.
>
> Why you think that 'halting' works differently from these examples
> remains a mystery.
>
> If you want to determine the correct answer to "does P(P) halt?", you
> need look only at the behaviour of P(P), not at your traces. In fact,
> you *shouldn't* look at anything other than the behaviour of P(P)
> because halting is defined *entirely* in terms of the behaviour of P(P).
>
> If it is the case that P(P) "only" halts because H(P, P) returns false,
> it still halts, which means that H(P, P) *incorrectly* returns false.
>
>> Until you pay enough attention to see and acknowledge this I will
>> simply assume that you are dishonest.
>
> As is the case with virtually all of your terms, I assume you also have
> some private definition of 'dishonest'.
>
> André
>

--
Copyright 2021 Pete Olcott

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

Re: Honest dialogue on the proof that H(P,P)==0 is correct [proof defined]

<_hkQI.27729$EF2.10115@fx47.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!paganini.bofh.team!news.dns-netz.com!news.freedyn.net!newsreader4.netcologne.de!news.netcologne.de!peer01.ams1!peer.ams1.xlned.com!news.xlned.com!peer01.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx47.iad.POSTED!not-for-mail
Subject: Re: Honest dialogue on the proof that H(P,P)==0 is correct [proof
defined]
Newsgroups: comp.theory
References: <HNidndugKOWGvpH8nZ2dnUU7-fXNnZ2d@giganews.com>
<Vs0PI.2099$xY.509@fx05.iad> <GLudnUM2eaoEC5H8nZ2dnUU7-evNnZ2d@giganews.com>
<5Z1PI.1823$6h1.1128@fx39.iad>
<r6idnXrkQsZ5JJH8nZ2dnUU7-V_NnZ2d@giganews.com> <qb9PI.22$uV3.2@fx18.iad>
<6radnYHwiMoYvpD8nZ2dnUU7-UPNnZ2d@giganews.com> <owaPI.297$uk4.251@fx20.iad>
<a82dnc_0ypriwZD8nZ2dnUU7-QHNnZ2d@giganews.com> <sel07d$pcf$1@dont-email.me>
<DdCdnaOAJLE3l5P8nZ2dnUU7-enNnZ2d@giganews.com> <sep914$6pc$1@dont-email.me>
<mdKdncO0j8L6w4z8nZ2dnUU7-S_NnZ2d@giganews.com>
<2cf7b09a-b3a2-4ede-b33f-c57a3736e9a7n@googlegroups.com>
<yIOdnSFYVobgGoz8nZ2dnUU7-SnNnZ2d@giganews.com> <ses2dr$jpf$1@dont-email.me>
<-4idnXZW5JUQB4z8nZ2dnUU7-W9QAAAA@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:78.0)
Gecko/20100101 Thunderbird/78.12.0
MIME-Version: 1.0
In-Reply-To: <-4idnXZW5JUQB4z8nZ2dnUU7-W9QAAAA@giganews.com>
Content-Type: text/plain; charset=utf-8
Content-Language: en-US
Content-Transfer-Encoding: 8bit
Lines: 45
Message-ID: <_hkQI.27729$EF2.10115@fx47.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Mon, 9 Aug 2021 21:06:03 -0400
X-Received-Bytes: 3488
 by: Richard Damon - Tue, 10 Aug 2021 01:06 UTC

On 8/9/21 5:13 PM, olcott wrote:
> On 8/9/2021 3:15 PM, André G. Isaak wrote:
>> On 2021-08-09 13:52, olcott wrote:
>>> On 8/9/2021 12:30 PM, Malcolm McLean wrote:
>>
>>>> It's unclear to me exactly how H is a "simulator", given this
>>>> execution trace.
>>>
>>> I don't see what could possibly be unclear about it to anyone knowing
>>> the x86 language well enough. The trace shows exactly what P would do
>>> if it was simulated by a pure simulator with itself as input.
>>
>> No, the trace appears to show what P would do if invoked *directly*
>> with itself as input, and in which P subsequently calls its input
>> *directly* rather than simulating it. This should be clear to anyone
>> who knows the x86 language well enough.
>>
>
> Because H only acts as a pure simulator of its input until after its
> halt status decision has been made it has no behavior that can possibly
> effect the behavior of its input. Because of this H screens out its own
> address range in every execution trace that it examines. This is why we
> never see any instructions of H in any execution trace after an input
> calls H.

So, a bank robber who had been a perfectly honest citizen, until he
robbed the bank, is a perfectly honest citizen?

Once H has aborted it simulation, it PROVES that is isn't, ane never was
a pure simulator, as a pure simulator is one that NEVER aborts its
simulation and will ALWAYS run its input to its completion or continue
running forever it the machine is non-halting.

>
>> This discrepancy between what you claim your code does and what your
>> traces appear to show has been pointed out to you before and you've
>> never adequately explained what your code *really* does. Either your
>> 'simulations' aren't really simulations or your 'x86 traces' aren't
>> actually x86 traces.
>>
>> André
>>
>
>

Re: Honest dialogue on the proof that H(P,P)==0 is correct [proof defined]

<ejkQI.27730$EF2.12174@fx47.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder8.news.weretis.net!feeder1.feed.usenet.farm!feed.usenet.farm!peer01.ams4!peer.am4.highwinds-media.com!peer03.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx47.iad.POSTED!not-for-mail
Subject: Re: Honest dialogue on the proof that H(P,P)==0 is correct [proof
defined]
Newsgroups: comp.theory
References: <HNidndugKOWGvpH8nZ2dnUU7-fXNnZ2d@giganews.com>
<Vs0PI.2099$xY.509@fx05.iad> <GLudnUM2eaoEC5H8nZ2dnUU7-evNnZ2d@giganews.com>
<5Z1PI.1823$6h1.1128@fx39.iad>
<r6idnXrkQsZ5JJH8nZ2dnUU7-V_NnZ2d@giganews.com> <qb9PI.22$uV3.2@fx18.iad>
<6radnYHwiMoYvpD8nZ2dnUU7-UPNnZ2d@giganews.com> <owaPI.297$uk4.251@fx20.iad>
<a82dnc_0ypriwZD8nZ2dnUU7-QHNnZ2d@giganews.com> <sel07d$pcf$1@dont-email.me>
<DdCdnaOAJLE3l5P8nZ2dnUU7-enNnZ2d@giganews.com> <sep914$6pc$1@dont-email.me>
<mdKdncO0j8L6w4z8nZ2dnUU7-S_NnZ2d@giganews.com>
<2cf7b09a-b3a2-4ede-b33f-c57a3736e9a7n@googlegroups.com>
<yIOdnSFYVobgGoz8nZ2dnUU7-SnNnZ2d@giganews.com>
<q6mdnffhc4WHPYz8nZ2dnUU7-InNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:78.0)
Gecko/20100101 Thunderbird/78.12.0
MIME-Version: 1.0
In-Reply-To: <q6mdnffhc4WHPYz8nZ2dnUU7-InNnZ2d@giganews.com>
Content-Type: text/plain; charset=utf-8
Content-Language: en-US
Content-Transfer-Encoding: 8bit
Lines: 130
Message-ID: <ejkQI.27730$EF2.12174@fx47.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Mon, 9 Aug 2021 21:07:23 -0400
X-Received-Bytes: 7342
 by: Richard Damon - Tue, 10 Aug 2021 01:07 UTC

On 8/9/21 5:37 PM, olcott wrote:
> On 8/9/2021 2:52 PM, olcott wrote:
>> On 8/9/2021 12:30 PM, Malcolm McLean wrote:
>>> On Monday, 9 August 2021 at 17:57:18 UTC+1, olcott wrote:
>>>> On 8/8/2021 1:50 PM, André G. Isaak wrote:
>>>>> On 2021-08-06 22:23, olcott wrote:
>>>>>> On 8/6/2021 10:55 PM, André G. Isaak wrote:
>>>>>>> On 2021-08-06 09:59, olcott wrote:
>>>>>
>>>>>>> Yes, but bear in mind that 'halting' refers to Turing Machines
>>>>>>> operating on a specific input. It does not refer to simulations or
>>>>>>> what happens inside a halting decider. It refers *only* to actual
>>>>>>> computations, i.e. an actual Turing Machine operating on an actual
>>>>>>> input string.
>>>>>>>
>>>>>>
>>>>>> So yet again you prove that you are totally clueless that pure
>>>>>> simulations are computationally equivalent to direct executions ?
>>>>>
>>>>> Your H is not a pure simulator
>>>>>
>>>> // Simplified Linz Ĥ (Linz:1990:319)
>>>> // Strachey(1965) CPL translated to C
>>>> void P(u32 x)
>>>> {
>>>> if (H(x, x))
>>>> HERE: goto HERE;
>>>> }
>>>> _P()
>>>> [00000d02](01) 55 push ebp
>>>> [00000d03](02) 8bec mov ebp,esp
>>>> [00000d05](03) 8b4508 mov eax,[ebp+08]
>>>> [00000d08](01) 50 push eax // push 2nd Param
>>>> [00000d09](03) 8b4d08 mov ecx,[ebp+08]
>>>> [00000d0c](01) 51 push ecx // push 1st Param
>>>> [00000d0d](05) e870feffff call 00000b82 // call H
>>>> [00000d12](03) 83c408 add esp,+08
>>>> [00000d15](02) 85c0 test eax,eax
>>>> [00000d17](02) 7402 jz 00000d1b
>>>> [00000d19](02) ebfe jmp 00000d19
>>>> [00000d1b](01) 5d pop ebp
>>>> [00000d1c](01) c3 ret
>>>> Size in bytes:(0027) [00000d1c]
>>>>
>>>> machine stack stack machine assembly
>>>> address address data code language
>>>> ======== ======== ======== ========= =============
>>>> ...[00000d0d][00101829][00000d12] e870feffff call 00000b82 // call H
>>>> Begin Local Halt Decider Simulation at Machine Address:d02
>>>> ...[00000d02][002118f1][002118f5] 55 push ebp
>>>> ...[00000d03][002118f1][002118f5] 8bec mov ebp,esp
>>>> ...[00000d05][002118f1][002118f5] 8b4508 mov eax,[ebp+08]
>>>> ...[00000d08][002118ed][00000d02] 50 push eax // push P
>>>> ...[00000d09][002118ed][00000d02] 8b4d08 mov ecx,[ebp+08]
>>>> ...[00000d0c][002118e9][00000d02] 51 push ecx // push P
>>>> ...[00000d0d][002118e5][00000d12] e870feffff call 00000b82 // call H
>>>> ...[00000d02][0025c319][0025c31d] 55 push ebp
>>>> ...[00000d03][0025c319][0025c31d] 8bec mov ebp,esp
>>>> ...[00000d05][0025c319][0025c31d] 8b4508 mov eax,[ebp+08]
>>>> ...[00000d08][0025c315][00000d02] 50 push eax // push P
>>>> ...[00000d09][0025c315][00000d02] 8b4d08 mov ecx,[ebp+08]
>>>> ...[00000d0c][0025c311][00000d02] 51 push ecx // push P
>>>> ...[00000d0d][0025c30d][00000d12] e870feffff call 00000b82 // call H
>>>> Local Halt Decider: Infinite Recursion Detected Simulation Stopped
>>>> The fact that the execution trace of the simulation of P(P) on page 6
>>>> perfectly matches its source-code on page 5 conclusively proves that
>>>> this execution trace performed by H is a pure simulation of P(P). There
>>>> is no correct basis for disagreement, therefore anyone disagreeing
>>>> either does not know the x86 language or they are simply lying.
>>>>
>>> It's unclear to me exactly how H is a "simulator", given this
>>> execution trace.
>>
>> I don't see what could possibly be unclear about it to anyone knowing
>> the x86 language well enough. The trace shows exactly what P would do
>> if it was simulated by a pure simulator with itself as input.
>>
>
> Since everyone is finding it next to impossible to understand what the
> behavior of seven lines of code would be while H acts as a pure
> simulator of its input adding thousands of more lines of code cannot
> possibly help their understanding:

A Pure Simulator until is NOT a pure simulator. PERIOD.

>
>     machine   stack     stack     machine     assembly
>     address   address   data      code        language
>     ========  ========  ========  =========   =============
> ...[00000d0d][00101829][00000d12] e870feffff  call 00000b82  // call H
>
> Begin Local Halt Decider Simulation at Machine Address:d02
> ...[00000d02][002118f1][002118f5] 55          push ebp
> ...[00000d03][002118f1][002118f5] 8bec        mov ebp,esp
> ...[00000d05][002118f1][002118f5] 8b4508      mov eax,[ebp+08]
> ...[00000d08][002118ed][00000d02] 50          push eax       // push P
> ...[00000d09][002118ed][00000d02] 8b4d08      mov ecx,[ebp+08]
> ...[00000d0c][002118e9][00000d02] 51          push ecx       // push P
> ...[00000d0d][002118e5][00000d12] e870feffff  call 00000b82  // call H
>
>
>>> Normally a simulator creates a virtual machine with a virtual address
>>> space
>>> and virtual instructions. The execution trace of the simulator looks
>>> nothing
>>> like the execution trace of the simulated code - basically the
>>> simulator does
>>> a big switch on the op code of the virtual machine's instruction,
>>> then updates
>>> memory and registers, with special rules for IO.
>>>
>>
>> Those details only serve to get people confused. The fact that the x86
>> code of P acts exactly as if it was simulated by a pure simulator
>> proves beyond all possible doubt that H does simulate P on input P as
>> a pure simulator.
>>
>>> You don't seem to be using this model for H.
>>>
>>> However iif P(P) halts, then any execution trace which shows it P(P)
>>> as non-halting
>>> must have a mistake in it somewhere, either in the simulator or in
>>> the interpretation
>>> of the trace.
>>>
>>
>>
>
>

Pages:123
server_pubkey.txt

rocksolid light 0.9.7
clearnet tor