Re: 197 page execution trace of DDD correctly simulated by HHH

Op 28.jun.2024 om 17:01 schreef olcott:

On 6/28/2024 9:43 AM, Fred. Zwarts wrote:

Op 28.jun.2024 om 16:12 schreef olcott:

On 6/28/2024 3:06 AM, Fred. Zwarts wrote:

Op 27.jun.2024 om 19:21 schreef olcott:

>
_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 x86 emulator H0 cannot possibly return.
>
>

>
Repeating your claim does not show any error in my reasoning.
>
Your claim is a contradictio in terminus.
1) It is impossible for a simulator to simulate itself correctly.

>
*I have already proven otherwise*
https://liarparadox.org/HHH(DDD)_Full_Trace.pdf

>
Except that this trace only proved that I am right. The simulator is unable to simulate itself correctly, which is shown in this trace.
>

 void Infinite_Recursion()
{
   Infinite_Recursion();
}
 That is counter-factual. HHH(DDD) does correctly emulate
the call from DDD to HHH(DDD) emulating itself emulating DDD.
 That you don't seem to have a clue about how HHH correctly
decides Infinite_Recursion() prevents your understanding of HHH(DDD).
 _Infinite_Recursion()
[00002122] 55               push ebp
[00002123] 8bec             mov ebp,esp
[00002125] e8f8ffffff       call 00002122
[0000212a] 5d               pop ebp
[0000212b] c3               ret
Size in bytes:(0010) [0000212b]
 _main()
[00002192] 55               push ebp
[00002193] 8bec             mov ebp,esp
[00002195] 6822210000       push 00002122
[0000219a] e833f4ffff       call 000015d2
[0000219f] 83c404           add esp,+04
[000021a2] 50               push eax
[000021a3] 6843070000       push 00000743
[000021a8] e8b5e5ffff       call 00000762
[000021ad] 83c408           add esp,+08
[000021b0] eb04             jmp 000021b6
[000021b2] 33c0             xor eax,eax
[000021b4] eb02             jmp 000021b8
[000021b6] 33c0             xor eax,eax
[000021b8] 5d               pop ebp
[000021b9] c3               ret
Size in bytes:(0040) [000021b9]
   machine   stack     stack     machine    assembly
  address   address   data      code       language
  ========  ========  ========  =========  =============
[00002192][00103826][00000000] 55               push ebp
[00002193][00103826][00000000] 8bec             mov ebp,esp
[00002195][00103822][00002122] 6822210000       push 00002122
[0000219a][0010381e][0000219f] e833f4ffff       call 000015d2
New slave_stack at:1038ca
 Begin Local Halt Decider Simulation   Execution Trace Stored at:1138d2
[00002122][001138c2][001138c6] 55               push ebp
[00002123][001138c2][001138c6] 8bec             mov ebp,esp
[00002125][001138be][0000212a] e8f8ffffff       call 00002122
[00002122][001138ba][001138c2] 55               push ebp
[00002123][001138ba][001138c2] 8bec             mov ebp,esp
[00002125][001138b6][0000212a] e8f8ffffff       call 00002122
Local Halt Decider: Infinite Recursion Detected Simulation Stopped
 [0000219f][00103826][00000000] 83c404           add esp,+04
[000021a2][00103822][00000000] 50               push eax
[000021a3][0010381e][00000743] 6843070000       push 00000743
[000021a8][0010381e][00000743] e8b5e5ffff       call 00000762
Input_Halts = 0
[000021ad][00103826][00000000] 83c408           add esp,+08
[000021b0][00103826][00000000] eb04             jmp 000021b6
[000021b6][00103826][00000000] 33c0             xor eax,eax
[000021b8][0010382a][00000018] 5d               pop ebp
[000021b9][0010382e][00000000] c3               ret
Number of Instructions Executed(864) == 13 Pages
 

Don't start talking about infinite recursion if you do not even understand two cycles of simulation.