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: olcott <polcott333@gmail.com>
Newsgroups: comp.theory,sci.logic
Subject: Re: D correctly simulated by H proved for THREE YEARS --- rewritten
Date: Thu, 13 Jun 2024 07:44:34 -0500
Organization: A noiseless patient Spider
Lines: 140
Message-ID: <v4epji$28g4v$2@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>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Injection-Date: Thu, 13 Jun 2024 14:44:35 +0200 (CEST)
Injection-Info: dont-email.me; posting-host="72fba8c553b5e17b65491f92678bf7b8";
	logging-data="2375839"; mail-complaints-to="abuse@eternal-september.org";	posting-account="U2FsdGVkX18ZV7rSNtpBShcI3EBfz8Q2"
User-Agent: Mozilla Thunderbird
Cancel-Lock: sha1:nbbXdheT9NFgxa5hHFjV185I6r8=
Content-Language: en-US
In-Reply-To: <v4e9qm$25ks0$1@dont-email.me>
Bytes: 7393

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, 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.

> 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.

> 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*

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

void Infinite_Recursion(u32 N)
{
   Infinite_Recursion(N);
}

int main()
{
   H(Infinite_Recursion, (ptr)5);
}

_Infinite_Recursion()
[00001ca3] 55               push ebp
[00001ca4] 8bec             mov ebp,esp
[00001ca6] 8b4508           mov eax,[ebp+08]
[00001ca9] 50               push eax
[00001caa] e8f4ffffff       call 00001ca3
[00001caf] 83c404           add esp,+04
[00001cb2] 5d               pop ebp
[00001cb3] c3               ret
Size in bytes:(0017) [00001cb3]

_main()
[00001e23] 55               push ebp
[00001e24] 8bec             mov ebp,esp
[00001e26] 6a05             push +05      ; push 5
[00001e28] 68a31c0000       push 00001ca3 ; push Infinite_Recursion
[00001e2d] e8e1f6ffff       call 00001513 ; call H
[00001e32] 83c408           add esp,+08
[00001e35] eb04             jmp 00001e3b
[00001e37] 33c0             xor eax,eax
[00001e39] eb02             jmp 00001e3d
[00001e3b] 33c0             xor eax,eax
[00001e3d] 5d               pop ebp
[00001e3e] c3               ret
Size in bytes:(0028) [00001e3e]

  machine   stack     stack     machine    assembly
  address   address   data      code       language
  ========  ========  ========  =========  =============
[00001e23][001031e9][00000000] 55         push ebp
[00001e24][001031e9][00000000] 8bec       mov ebp,esp
[00001e26][001031e5][00000005] 6a05       push +05      ; push 5
[00001e28][001031e1][00001ca3] 68a31c0000 push 00001ca3 ; push 
Infinite_Recursion
[00001e2d][001031dd][00001e32] e8e1f6ffff call 00001513 ; call H

H: Begin Simulation   Execution Trace Stored at:113295
Address_of_H:1513
[00001ca3][00113281][00113285] 55         push ebp
[00001ca4][00113281][00113285] 8bec       mov ebp,esp
[00001ca6][00113281][00113285] 8b4508     mov eax,[ebp+08]
[00001ca9][0011327d][00000005] 50         push eax      ; push param
[00001caa][00113279][00001caf] e8f4ffffff call 00001ca3 ; call 
Infinite_Recursion
[00001ca3][00113275][00113281] 55         push ebp
[00001ca4][00113275][00113281] 8bec       mov ebp,esp
[00001ca6][00113275][00113281] 8b4508     mov eax,[ebp+08]
[00001ca9][00113271][00000005] 50         push eax      ; push param
[00001caa][0011326d][00001caf] e8f4ffffff call 00001ca3 ; call 
Infinite_Recursion
H: Infinite Recursion Detected Simulation Stopped

[00001e32][001031e9][00000000] 83c408           add esp,+08
[00001e35][001031e9][00000000] eb04             jmp 00001e3b
[00001e3b][001031e9][00000000] 33c0             xor eax,eax
[00001e3d][001031ed][00000018] 5d               pop ebp
[00001e3e][001031f1][00000000] c3               ret
Number of Instructions Executed(1104) == 16 Pages


-- 
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer