Re: 195 page execution trace of DDD correctly simulated by HH0

Op 26.jun.2024 om 15:07 schreef olcott:

On 6/26/2024 3:01 AM, Fred. Zwarts wrote:

Op 25.jun.2024 om 21:30 schreef olcott:

On 6/25/2024 2:17 PM, Fred. Zwarts wrote:

>
It might be true, but it is irrelevant, because the simulated H0 is aborted prematurely. The simulating H0 aborts after two cycles,

>
*I am not even talking about a simulating halt decider yet dumbo*

>
Neither am I. Why do you mention a simulating halt decider? (Who is the dumbo?)
>

If you can't begin to comprehend x86 emulators then our conversation
is dead right here.

>
Fortunately, I am very well able to do so.
But it seems that you have to learn a few basic facts about simulation.
>

>
For every x86 emulator Ho that can possibly exist
at machine address 0000217a...
>
_DDD()
[00002172] 55               push ebp      ; housekeeping
[00002173] 8bec             mov ebp,esp   ; housekeeping
[00002175] 6872210000       push 00002172 ; push DDD
[0000217a] e853f4ffff       call 000015d2 ; call H0(DDD)
[0000217f] 83c404           add esp,+04
[00002182] 5d               pop ebp
[00002183] c3               ret
Size in bytes:(0018) [00002183]
>
The call from DDD to H0(DDD) when DDD is correctly emulated
by H0 cannot possibly return.

>
So, you repeat your claim without showing any error in my reasoning.
Therefore, I repeat again:
>
It might be true hat H0 cannot return,

 As soon as you say that you are certain that it is true
we can move on to its relevance. That it is true is as
simple as arithmetic. Why it is relevant is much more
difficult.
 

I cannot be certain, because you keep changing your definitions and there are no clear specifications for H0.
Anyhow, the only reason why the simulation of H0 would not return is that the simulation is aborted before it could return.
Since we know that H0 runs two cycles before it aborts, we know that no infinite recursion is involved, so the premature abort makes it impossible for the simulation to return.
It seems that it is over your head that a prematurely aborted simulation is not a correct simulation.
There are a few reasons why a simulation can be incorrect:
1) Some instructions are incorrectly simulated.
2) Instructions are simulated out of order.
3) Some instructions are not simulated at all.
Your problem is 3).
You only prove that your H0 is unable to simulate itself correctly, because it aborts too soon and fails to simulate the end of itself.
Only if we can agree about this, then we can discuss what it means that H0 cannot possibly return. I cannot tolerate to skip this step, because otherwise we will run in circles.