Path: ...!feeds.phibee-telecom.net!2.eu.feeder.erje.net!feeder.erje.net!eternal-september.org!feeder3.eternal-september.org!news.eternal-september.org!.POSTED!not-for-mail
From: "Fred. Zwarts" <F.Zwarts@HetNet.nl>
Newsgroups: comp.theory
Subject: Re: Because Olcott has made this error 500 times in the last three
 years...
Date: Sat, 27 Jul 2024 10:26:25 +0200
Organization: A noiseless patient Spider
Lines: 99
Message-ID: <v82avi$39v6n$2@dont-email.me>
References: <v7uvbq$2h6oq$1@dont-email.me> <v7vh4j$2ndo6$1@dont-email.me>
 <v807vd$2rabc$2@dont-email.me> <v809pm$2rou5$1@dont-email.me>
 <v80b35$2rabc$6@dont-email.me> <v80feq$2sh8c$1@dont-email.me>
 <v80hb5$2su8m$4@dont-email.me>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Sat, 27 Jul 2024 10:26:27 +0200 (CEST)
Injection-Info: dont-email.me; posting-host="5f623e9acbcbdce9334ab4c51e72f5f6";
	logging-data="3472599"; mail-complaints-to="abuse@eternal-september.org";	posting-account="U2FsdGVkX19RgUQoOL6b3iFrfCULy7iz"
User-Agent: Mozilla Thunderbird
Cancel-Lock: sha1:0+TAPdtExDyVIv6n4a93FIQY7ns=
Content-Language: en-GB
In-Reply-To: <v80hb5$2su8m$4@dont-email.me>
Bytes: 4666

Op 26.jul.2024 om 18:02 schreef olcott:
> On 7/26/2024 10:30 AM, Fred. Zwarts wrote:
>> Op 26.jul.2024 om 16:16 schreef olcott:
>>> On 7/26/2024 8:53 AM, Fred. Zwarts wrote:
>>>> Op 26.jul.2024 om 15:22 schreef olcott:
>>>>> On 7/26/2024 1:53 AM, Fred. Zwarts wrote:
>>>>>> Op 26.jul.2024 om 03:49 schreef olcott:
>>>>>>> If you understand the x86 language and can't tell how DDD
>>>>>>> emulated by HHH differs from DDD emulated by HHH1 by the
>>>>>>> following then you are probably lying about understanding
>>>>>>> the x86 language.
>>>>>>
>>>>>> We understand it perfectly. HHH cannot possibly simulate itself 
>>>>>> correctly.
>>>>>
>>>>> You are too stupid to know that a non-halting computation
>>>>> cannot be emulated to completion because completion does
>>>>> not exist.
>>>>
>>>> The non-halting behaviour is only in your dreams. It is irrelevant, 
>>>> because HHH halts when it aborts. Remember, HHH is simulating 
>>>> *itself*, a halting program, not another non-halting simulator that 
>>>> does not abort and does not halt.
>>>>
>>>
>>> typedef void (*ptr)();
>>> int HHH(ptr P);
>>>
>>> void DDD()
>>> {
>>>    HHH(DDD);
>>> }
>>>
>>> int main()
>>> {
>>>    DDD(DDD);
>>> }
>>>
>>> When we understand that HHH is accountable for the behavior of
>>> its input and not accountable for the behavior of the computation
>>> that itself is contained within then we understand that HHH(DDD)
>>> is necessarily correct to reject DDD as non-halting.
>>>
>>
>> We see that the only thing DDD does is calling HHH. So, HHH is fully 
>> accountable for the behaviour of DDD and its code is included in the 
>> program that must be simulated, otherwise the call from DDD to HHH 
>> would result in an error.
> 
> No decider is ever accountable for the behavior of the computation
> that itself is contained within.

Again repeating, without evidence, claims that have been proved to be 
wrong.

> 
> typedef void (*ptr)();
> int HHH(ptr P);
> 
> void DDD()
> {
>    HHH(DDD);
> }
> 
> int main()
> {
>    DDD(DDD);
> }

Do you ever learn from your errors?
Again the misleading and unneeded DDD. It is easy to eliminate DDD:

        int main() {
          return HHH(main);
        }

This has the same problem. This proves that the problem is not in DDD, 
but in HHH, which halts when it aborts the simulation, but it decides 
that the simulation of itself does not halt.
It shows that HHH cannot possibly simulate itself correctly.

> 
> HHH(DDD) is accountable for the behavior of its input and is
> not accountable for the behavior of the computation that itself
> is contained within: the directly executed DDD();

HHH should simulate DDD, which does nothing but calling HHH, therefore, 
HHH must simulate HHH, which is part of the code presented to HHH.
Therefore, HHH is accountable for a correct simulation of *itself*.
However, HHH cannot possibly simulate *itself* correctly.

The simulated HHH runs one cycle behind the simulating cycle in a 
correct simulation. So, when the simulating HHH aborts, the simulated 
HHH has only one cycle to go.
(Yes, we saw that you incorrectly modify the code of the simulated HHH, 
so that it no longer has the same behaviour as the simulating HHH, but 
that only invalidates your claim the HHH is a pure function simulating 
*itself*.)