Path: ...!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: HHH maps its input to the behavior specified by it --- never
 reaches its halt state
Date: Fri, 9 Aug 2024 17:42:45 +0200
Organization: A noiseless patient Spider
Lines: 146
Message-ID: <v95ddl$p7lr$1@dont-email.me>
References: <v8jh7m$30k55$1@dont-email.me> <v8kp6s$3c5h2$2@dont-email.me>
 <v8ld1f$3f6vr$5@dont-email.me> <v8ldl0$3ennf$1@dont-email.me>
 <v8lfb9$3g2jl$1@dont-email.me> <v8lgsr$3gadt$2@dont-email.me>
 <v8lhrr$3gkbk$1@dont-email.me> <v8n6un$3tv08$1@dont-email.me>
 <v8nums$1n09$6@dont-email.me> <v8vah7$29sva$1@dont-email.me>
 <v8vr7e$32fso$2@dont-email.me> <v91vc4$3qp1r$2@dont-email.me>
 <v92ge1$p1$2@dont-email.me> <v933m4$5kjd$1@dont-email.me>
 <v933u7$5r7u$4@dont-email.me> <v934sq$5kjd$2@dont-email.me>
 <v935mp$68mi$1@dont-email.me> <v94e12$jt3i$2@dont-email.me>
 <v95b65$p5rb$3@dont-email.me>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Fri, 09 Aug 2024 17:42:45 +0200 (CEST)
Injection-Info: dont-email.me; posting-host="a2f2e89941c746fa9cf7fa89a7f23217";
	logging-data="827067"; mail-complaints-to="abuse@eternal-september.org";	posting-account="U2FsdGVkX188pnkQrMzTUQ8XBpwpvzAc"
User-Agent: Mozilla Thunderbird
Cancel-Lock: sha1:Q/qZe6qDdE/oB2XSpAhFnk8lmSY=
Content-Language: en-GB
In-Reply-To: <v95b65$p5rb$3@dont-email.me>
Bytes: 7177

Op 09.aug.2024 om 17:04 schreef olcott:
> On 8/9/2024 1:46 AM, Fred. Zwarts wrote:
>> Op 08.aug.2024 om 21:18 schreef olcott:
>>> On 8/8/2024 2:04 PM, Fred. Zwarts wrote:
>>>> Op 08.aug.2024 om 20:48 schreef olcott:
>>>>> On 8/8/2024 1:44 PM, Fred. Zwarts wrote:
>>>>>> Op 08.aug.2024 om 15:15 schreef olcott:
>>>>>>> On 8/8/2024 3:24 AM, Fred. Zwarts wrote:
>>>>>>>> Op 07.aug.2024 om 15:01 schreef olcott:
>>>>>>>>> On 8/7/2024 3:16 AM, Fred. Zwarts wrote:
>>>>>>>>>> Op 04.aug.2024 om 15:11 schreef olcott:
>>>>>>>>>>> On 8/4/2024 1:26 AM, Fred. Zwarts wrote:
>>>>>>>>>>>> Op 03.aug.2024 om 17:20 schreef olcott:>>
>>>>>>>>>>>>> When you try to show how DDD simulated by HHH does
>>>>>>>>>>>>> reach its "return" instruction you must necessarily
>>>>>>>>>>>>> must fail unless you cheat by disagreeing with the
>>>>>>>>>>>>> semantics of C. That you fail to have a sufficient
>>>>>>>>>>>>> understanding of the semantics of C is less than no
>>>>>>>>>>>>> rebuttal what-so-ever.
>>>>>>>>>>>>
>>>>>>>>>>>> Fortunately that is not what I try, because I understand 
>>>>>>>>>>>> that HHH cannot possibly simulate itself correctly.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> void DDD()
>>>>>>>>>>> {
>>>>>>>>>>>    HHH(DDD);
>>>>>>>>>>>    return;
>>>>>>>>>>> }
>>>>>>>>>>>
>>>>>>>>>>> In other words when HHH simulates itself simulating DDD it
>>>>>>>>>>> is supposed to do something other than simulating itself
>>>>>>>>>>> simulating DDD ???  Do you expect it to make a cup of coffee?
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Is English too difficult for you. I said HHH cannot do it 
>>>>>>>>>> correctly.
>>>>>>>>>
>>>>>>>>> *According to an incorrect criteria of correct*
>>>>>>>>> You keep trying to get away with disagreeing with
>>>>>>>>> the semantics of the x86 language. *That is not allowed*
>>>>>>>>>
>>>>>>>> Again accusations without evidence.
>>>>>>>> We proved that HHH deviated from the semantics of the x86 
>>>>>>>> language by skipping the last few instructions of a halting 
>>>>>>>> program.
>>>>>>>
>>>>>>> void DDD()
>>>>>>> {
>>>>>>>    HHH(DDD);
>>>>>>>    return;
>>>>>>> }
>>>>>>>
>>>>>>> Each HHH of every HHH that can possibly exist definitely
>>>>>>> *emulates zero to infinity instructions correctly* In
>>>>>>> none of these cases does the emulated DDD ever reach
>>>>>>> its "return" instruction halt state.
>>>>>>>
>>>>>>> *There are no double-talk weasel words around this*
>>>>>>> *There are no double-talk weasel words around this*
>>>>>>> *There are no double-talk weasel words around this*
>>>>>>
>>>>>> Indeed. And this correctly proves that the simulation failed, not 
>>>>>> because of an instruction simulated incorrectly, but because 
>>>>>> instructions are skipped. 
>>>>>
>>>>> void Infinite_Recursion()
>>>>> {
>>>>>    Infinite_Recursion();
>>>>>    return;
>>>>> }
>>>>
>>>> Dreaming again of an infinite recursion?
>>>>
>>>>>
>>>>> The return instruction in both cases is unreachable code.
>>>>> DDD correctly emulated by HHH and Infinite_Recursion
>>>>> correctly emulated by HHH cannot reach the "return"
>>>>> instruction.
>>>>
>>>> It cannot reach it, because it was programmed to abort one cycle 
>>>> before the program would end.
>>>>
>>>
>>> *Maybe you have ADD like Richard has. I already said this above*
>>> When zero to infinity steps of DDD are correctly emulated by
>>> HHH no DDD ever reaches its own "return" instruction.
>>>
>>> Maybe the issue is that you don't know programming well enough
>>> to understand that this is true.
>>
>> Maybe you should try to learn English. I confirmed hat HHH cannot 
>> reach the end of the simulation of itself.
> 
> Yes and cups of coffee are made from ground coffee beans.
> Changing the subject is merely the dishonest dodge of the
> strawman deception.

So, why do you do it?

> 
>> Maybe you should learn to program. When the simulation of a halting 
>> program is unable to reach the end, it proves that the simulation is 
>> incorrect.
> 
> 
> void Infinite_Loop()
> {
>    HERE: goto HERE;
> }
> 
> The correct simulation of the above never halts.

Again a change of subject. We are talking about a halting program, which 
looks more like:

void Finite_Recursion (int N) {
   if (N > 0) Finite_Recursion (N - 1);
}

In the case of the HHH for which you have published a 'trace', we see 
that it halts after two recursions, not after infinite recursions.
Therefore, who is dishonest to change the subject to an infinite 
recursion? Who is using the straw-man deception? It is the one who 
claims that two equals infinity!

> 
>> Everybody with sufficient programming knowledge understands that a 
>> simulator cannot possibly simulate itself correctly up to the end, 
>> because either it does not halt, or it misses the last cycle, the 
>> final part of the simulation.
> 
> When a simulating termination analyzer is essentially called
> in infinite recursion it is smart enough to abort.
> 

Apparently, your decider is unable to correctly recognise an infinite 
recursion. It incorrectly thinks that N equals infinity.
A good programmer should know the difference between two and infinity.

We are not dreaming of the HHH that does not abort, but about the HHH 
that aborts. Dreams are no substitute for facts.
HHH is required to halt. So, when HHH aborts itself after N recursions, 
the simulated HHH has only one recursion to go.
So, it is correct to say that HHH cannot possibly simulate itself 
correctly up to the end.