Re: D correctly simulated by H proved for THREE YEARS --- rewritten

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