Path: ...!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,sci.logic
Subject: Re: D correctly simulated by H proved for THREE YEARS --- rewritten
Date: Thu, 13 Jun 2024 21:33:54 +0200
Organization: A noiseless patient Spider
Lines: 128
Message-ID: <v4fhj3$2dce5$1@dont-email.me>
References: <v428vv$2no74$2@dont-email.me> <v43ib7$38hnd$1@dont-email.me>
 <v4628o$6ero$1@dont-email.me> <v468qt$7uvj$1@dont-email.me>
 <v47joj$je45$1@dont-email.me> <v47kt3$jhs8$1@dont-email.me>
 <v47l92$je45$2@dont-email.me> <v48tt4$tqad$1@dont-email.me>
 <v4a07r$157ic$1@dont-email.me> <v4beis$1h0p6$1@dont-email.me>
 <v4cceu$1mi5i$2@dont-email.me> <v4corm$1p0h0$1@dont-email.me>
 <v4cp5s$1pe0q$1@dont-email.me> <v4cs0b$1p0h1$1@dont-email.me>
 <v4csdq$1q0a8$1@dont-email.me> <v4ctuq$1p0h1$2@dont-email.me>
 <v4cuc6$1qedu$1@dont-email.me> <v4e9qm$25ks0$1@dont-email.me>
 <v4epji$28g4v$2@dont-email.me>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Thu, 13 Jun 2024 21:33:55 +0200 (CEST)
Injection-Info: dont-email.me; posting-host="3766a8f8abdcd797f08898baf8262d75";
	logging-data="2535877"; mail-complaints-to="abuse@eternal-september.org";	posting-account="U2FsdGVkX18EO7m7ZWbbzubrvluO4Vyv"
User-Agent: Mozilla Thunderbird
Cancel-Lock: sha1:tX84Xt5ttbF4dyEzRvIhxY8QXRw=
Content-Language: en-GB
In-Reply-To: <v4epji$28g4v$2@dont-email.me>
Bytes: 7060

Op 13.jun.2024 om 14:44 schreef olcott:
> On 6/13/2024 3:15 AM, Fred. Zwarts wrote:
>> Op 12.jun.2024 om 21:53 schreef olcott:
>>> On 6/12/2024 2:46 PM, Fred. Zwarts wrote:
>>>> Op 12.jun.2024 om 21:20 schreef olcott:
>>>>>
>>>>> On 5/29/2021 2:26 PM, olcott wrote:
>>>>> https://groups.google.com/g/comp.theory/c/dTvIY5NX6b4/m/cHR2ZPgPBAAJ
>>>>>
>>>>> If that was true then you could provide every step of D correctly
>>>>> simulated by H such that D simulated by H reaches its own simulated
>>>>> "ret" instruction.
>>>>
>>>> I said that each H is unable to hit its target, so how could it 
>>>> reach the "ret" instruction of D? Please, think before you reply.
>>>
>>> It is a binary choice either D correctly simulated by H can
>>> possibly terminate normally by reaching its "ret" instruction
>>> or not. Your attempt to twist these words to make it look like
>>> there is more than these two possibilities is either ignorant
>>> or deceptive.
>>>
>>
>> Please, take some more attention to what I said. Read, then think, 
>> before you reply.
>> I said that H is not able to reach its own "ret" when it is simulating 
>> itself. 
> 
> That has always been totally irrelevant.

So, you think that if H does not reach its "ret", D can still reach its 
"ret"?
Try to think. D does not reach its "ret", *because* "H" does not reach 
its "ret".

> 
>> So, no disagreement with that. That proves that H misses its target. 
>> The abort is too early. The target is just some steps further. It does 
>> not mean that the target is at infinity.
>>
> 
> The outer H always has one more execution trace to base its halt
> status decision on than any of the nested emulations. This means
> that unless the outer H aborts its simulation then none of them do.

That is true. But it also means that H aborts one execution trace too 
early. And since a simulation is unable to simulate itself, it is not 
possible to do it correctly.

The H that simulates one execution trace is unable to see the abort of 
its simulated self, because it needs two execution traces to see that.
The H that simulates two execution traces is unable to see the abort of 
its simulated self, because it needs three execution traces to see that.
Etc.
The invariant is that they all abort one execution trace too early.
The other invariant is that there is never an infinite simulation recursion.
Conclusion is that it is impossible for such a simulator to correctly 
simulate itself.

> 
>> It is like an archer who is asked to hit a target twice as far as his 
>> bow can reach. His bow reaches 50m and the target is at 100m. He misses.
>> Then he uses a new bow that reaches 100m, but now the target is at 
>> 200m. He is able to reach the old target, but again he misses the 
>> target for the new bow. He can continue with a stronger bow, but if 
>> the bow reaches further, the target is also further away. But note, 
>> the target is never at infinity.
> 
> Sure just like Zeno's paradox where he "proved" that it is impossible to 
> cross a ten foot wide room in finite time.

Strange twist of Zeno's paradox.
*You* try to "prove" similarly that there is an infinite recursion, 
where H is only some steps away from its target.


> 
>> Similarly, the target of the simulator is never at infinity, but 
>> always some steps further that the simulation goes. You can make a 
>> simulator that simulates further, which can reach the target of the 
>> old simulator, but it is unable to reach its own target. So, there is 
>> no infinite recursion, but the simulation always misses the target. 
>> The simulation is never able to simulate itself up to the end. It 
>> always aborts prematurely.
>> So, your claim proves that it is not a good idea to simulate H by 
>> itself. It will always miss the target.
> 
> *As soon as H sees the repeating state it stops*
> *As soon as H sees the repeating state it stops*
> *As soon as H sees the repeating state it stops*

Yes, it stops. But the conclusion is that there is repetition, but not 
an infinite repetition, but the repetition is only one more than the 
simulator could see. If it would simulate one execution trace more, it 
would see its own abort. But it is not possible to do that with this 
simulator. Another simulator, with more steps would see that, but than 
there is another target for this new simulator when it would also try to 
simulate itself.

> 
> *If you don't understand the infinite recursion example then*
> *You lack the required prerequisite knowledge to understand me*

If you do not understand that there is a difference between an finite 
number of repetitions and an infinite recursion, you miss the background 
to talk about infinite recursions.

> 
> void Infinite_Recursion(u32 N)
> {
>    Infinite_Recursion(N);
> }
> 
> int main()
> {
>    H(Infinite_Recursion, (ptr)5);
> }
> 

If you do not understand that the simulation of Infinite_Recursion by H 
is totally different from H simulating itself, than you do not have the 
competence to think about infinite recursion.

H has the requirement to halt. Infinite_Recursion does not have that 
requirement. So, a correct simulation of H would also reach its "ret", 
but that correct simulation cannot be done by H itself, because its 
simulation runs one execution trace behind its simulator execution.