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: Infinite set of HHH/DDD pairs --- truisms
Date: Tue, 23 Jul 2024 20:55:16 +0200
Organization: A noiseless patient Spider
Lines: 192
Message-ID: <v7ouak$1auqf$1@dont-email.me>
References: <v644pn$29t4h$3@dont-email.me> <v6vvid$24jd$1@dont-email.me>
 <v70mih$61d8$3@dont-email.me> <v72i9m$jne3$1@dont-email.me>
 <v7367p$mjis$8@dont-email.me> <v755m4$15kf6$1@dont-email.me>
 <v75vl9$19j7l$7@dont-email.me> <v77p77$1nm3r$1@dont-email.me>
 <v78fa7$1rc43$2@dont-email.me> <v7agsg$2am9u$1@dont-email.me>
 <v7b4l2$2e2aq$2@dont-email.me> <v7d9el$2tp5s$1@dont-email.me>
 <v7dtqt$30pvh$6@dont-email.me> <v7fu0f$3ff7c$1@dont-email.me>
 <v7ge24$3hlc2$4@dont-email.me> <v7ikut$1l1s$1@dont-email.me>
 <v7j3mp$3o7r$4@dont-email.me> <v7l3kg$ifhl$1@dont-email.me>
 <v7lped$luh0$2@dont-email.me>
 <bc974139b83c0d9c3a42faeb83bb81ff27ed3547@i2pn2.org>
 <v7lskj$luh0$6@dont-email.me> <v7m5sj$ogs3$1@dont-email.me>
 <v7m8hp$p0um$1@dont-email.me> <v7mc0r$pfs5$1@dont-email.me>
 <v7mdj1$pi02$2@dont-email.me> <v7novk$145ge$1@dont-email.me>
 <v7ognf$17h8r$10@dont-email.me> <v7omoi$19980$1@dont-email.me>
 <v7oqob$1aat4$1@dont-email.me> <v7ors4$1acir$1@dont-email.me>
 <v7os6c$1aat4$3@dont-email.me>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Tue, 23 Jul 2024 20:55:17 +0200 (CEST)
Injection-Info: dont-email.me; posting-host="750343008117602c3df088561f270b09";
	logging-data="1407823"; mail-complaints-to="abuse@eternal-september.org";	posting-account="U2FsdGVkX1+mGUlbIdxjeQ3OL55NV7Za"
User-Agent: Mozilla Thunderbird
Cancel-Lock: sha1:ReR6w+0oVYv1cNQJ/5nOJ43cQbk=
In-Reply-To: <v7os6c$1aat4$3@dont-email.me>
Content-Language: en-GB
Bytes: 10198

Op 23.jul.2024 om 20:18 schreef olcott:
> On 7/23/2024 1:13 PM, Fred. Zwarts wrote:
>> Op 23.jul.2024 om 19:54 schreef olcott:
>>> On 7/23/2024 11:46 AM, Fred. Zwarts wrote:
>>>> Op 23.jul.2024 om 17:03 schreef olcott:
>>>>> On 7/23/2024 3:17 AM, Fred. Zwarts wrote:
>>>>>> Op 22.jul.2024 om 21:57 schreef olcott:
>>>>>>> On 7/22/2024 2:30 PM, Fred. Zwarts wrote:
>>>>>>>> Op 22.jul.2024 om 20:31 schreef olcott:
>>>>>>>>> On 7/22/2024 12:45 PM, Fred. Zwarts wrote:
>>>>>>>>>> Op 22.jul.2024 om 17:08 schreef olcott:
>>>>>>>>>>> On 7/22/2024 9:32 AM, joes wrote:
>>>>>>>>>>>> Am Mon, 22 Jul 2024 09:13:33 -0500 schrieb olcott:
>>>>>>>>>>>>> On 7/22/2024 3:01 AM, Mikko wrote:
>>>>>>>>>>>>>> On 2024-07-21 13:50:17 +0000, olcott said:
>>>>>>>>>>>>>>> On 7/21/2024 4:38 AM, Mikko wrote:
>>>>>>>>>>>>>>>> On 2024-07-20 13:28:36 +0000, olcott said:
>>>>>>>>>>>>>>>>> On 7/20/2024 3:54 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>> On 2024-07-19 14:39:25 +0000, olcott said:
>>>>>>>>>>>>>>>>>>> On 7/19/2024 3:51 AM, Mikko wrote:
>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Anyway you did not say that some HHHᵢ can simulate the
>>>>>>>>>>>>>>>>>> corresponding DDDᵢ to its termination. And each DDDᵢ does
>>>>>>>>>>>>>>>>>> terminate, whether simulated or not.
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>>>>> Then DDD correctly simulated by any pure function HHH 
>>>>>>>>>>>>>>> cannot possibly
>>>>>>>>>>>>>>> reach its own return instruction and halt, therefore 
>>>>>>>>>>>>>>> every HHH is
>>>>>>>>>>>>>>> correct to reject its DDD as non-halting.
>>>>>>>>>>>>>> That does not follow. It is never correct to reject a halting
>>>>>>>>>>>>>> comoputation as non-halting.
>>>>>>>>>>>>> In each of the above instances DDD never reaches its return 
>>>>>>>>>>>>> instruction
>>>>>>>>>>>>> and halts. This proves that HHH is correct to report that 
>>>>>>>>>>>>> its DDD never
>>>>>>>>>>>>> halts.
>>>>>>>>>>>> It can't return if the simulation of it is aborted.
>>>>>>>>>>>>
>>>>>>>>>>>>> Within the hypothetical scenario where DDD is correctly 
>>>>>>>>>>>>> emulated by its
>>>>>>>>>>>>> HHH and this HHH never aborts its simulation neither DDD 
>>>>>>>>>>>>> nor HHH ever
>>>>>>>>>>>>> stops running.
>>>>>>>>>>>> In actuality HHH DOES abort simulating.
>>>>>>>>>>>>
>>>>>>>>>>>>> This conclusively proves that HHH is required to abort the 
>>>>>>>>>>>>> simulation of
>>>>>>>>>>>>> its corresponding DDD as required by the design spec that 
>>>>>>>>>>>>> every partial
>>>>>>>>>>>>> halt decider must halt and is otherwise not any kind of 
>>>>>>>>>>>>> decider at all.
>>>>>>>>>>>> Like Fred recognised a while ago, you are arguing as if HHH 
>>>>>>>>>>>> didn't abort.
>>>>>>>>>>>>
>>>>>>>>>>>>> That HHH is required to abort its simulation of DDD 
>>>>>>>>>>>>> conclusively proves
>>>>>>>>>>>>> that this DDD never halts.
>>>>>>>>>>>> You've got it the wrong way around.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> I am talking about hypothetical possible ways that HHH could 
>>>>>>>>>>> be encoded.
>>>>>>>>>>> (a) HHH(DDD) is encoded to abort its simulation.
>>>>>>>>>>> (b) HHH(DDD) is encoded to never abort its simulation.
>>>>>>>>>>>
>>>>>>>>>>> Therefore (a) is correct and (b) is incorrect according to the
>>>>>>>>>>> design requirements for HHH that it must halt.
>>>>>>>>>>
>>>>>>>>>> Both are incorrect. An HHH, when encoded to abort does not 
>>>>>>>>>> need to be aborted when simulated, because it already halts on 
>>>>>>>>>> its own.
>>>>>>>>>
>>>>>>>>> You must have attention deficit disorder.
>>>>>>>>> (a) At least one HHH aborts.
>>>>>>>>> (b) No HHH ever aborts.
>>>>>>>>>
>>>>>>>>> Every X has property Y or not, there is no inbetween.
>>>>>>>>
>>>>>>>> Do you have difficulty reading and writing English?
>>>>>>>>
>>>>>>>> If every X has property Y or not, then it is clear that every 
>>>>>>>> HHH abort or not. 
>>>>>>>
>>>>>>> Sure and when we start a race with a single file line of
>>>>>>> people that are 15 feet apart and everyone goes the same
>>>>>>> speed then everyone will reach the finish line, eventually.
>>>>>>>
>>>>>>> When the first HHH that reaches the finish line stops
>>>>>>> simulating its input then no other HHH can possibly reach
>>>>>>> the finish line because nothing is simulating them.
>>>>>>
>>>>>> Exactly! That is the error in HHH. It stops simulating before the 
>>>>>> other HHH could reach the finish line. 
>>>>>
>>>>> So you don't even know how foot races work.
>>>>>
>>>>> The winner of the race is not supposed to wait
>>>>> so that everyone crosses the finish line at once.
>>>>
>>>> But do you know how foot races work? When the winner reaches the 
>>>> finish, the other players do not disappear. They do not halt either. 
>>>> They continue until they also reach the finish line.
>>>>
>>>>>
>>>>> Also with HHH(DDD) there are infinite instances
>>>>> in the race. Waiting for the last one to finish
>>>>> waits forever. The first one to cross the finish
>>>>> line ends the race. Every other instance is
>>>>> immediately incapacitated
>>>> You don't have to wait for the last one of an infinite number. It is 
>>>> sufficient to wait for the first simulated HHH, because that one 
>>>> aborts and halts 
>>>
>>> Since HHH is the exact same machine code then when the first one waits
>>> for the second one the second one waits for the third on and on forever.
>>>
>>
>> Indeed! Exactly! You are almost at the finish.
> 
> *THIS SEEMS PERMANENTLY TOO DIFFICULT FOR YOU TO UNDERSTAND*

Irrelevant nonsense ignores, because olcott seems to have difficulties 
with reading and writing English.

> 
> Unless the first one aborts none of them ever aborts and HHH
> itself never stops running. Therefore is is correct and necessary
> for the first HHH to abort.

But then it fails at another point. When it aborts, it aborts too soon, 
before the simulated HHH, that also aborts, would halt.

> 
>> If HHH aborts after N cycles then only HHH that aborts after M cycles 
>> does a correct simulation, when M > N.
>> No HHH can possibly simulate *itself* correctly. Other HHH *can* do a 
>> correct simulation when M > N.
>> What HHH should do, is different from what it does, because that is 
>> how HHH is coded.
>> When you change the code, also the requirement changes when it has to 
>> simulate *itself* correctly. No matter how far you increase N, it 
>> never reaches N+1. It always aborts one cycle too early when 
>> simulating itself.
>> The HHH that aborts after N cycles can only simulate correctly the HHH 
>> that abort after K cycles when K < N. This shows that HHH cannot 
>> possibly simulate *itself* correctly.
> 
> When N instructions of DDD are simulated according to the
> x86 semantics that they specify then N instructions of been
> simulated correctly.

But when it aborts M instructions before the simulation would come to an 
end, the simulation is incomplete and, therefore, incorrect.

> 
> When DDD specifies non-halting behavior then it is stupidly
> wrong to require a correct simulation to be a complete simulation.

But when DDD would halt after N cycles, it is stupidly wrong to abort 
after N-1 cycles and claim that it would not halt.

========== REMAINDER OF ARTICLE TRUNCATED ==========