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

On 6/11/2024 4:00 AM, Mikko wrote:

On 2024-06-10 15:33:23 +0000, olcott said:
 

On 6/10/2024 4:59 AM, Mikko wrote:

On 2024-06-10 08:35:09 +0000, joes said:
>

Am Sun, 09 Jun 2024 22:54:52 -0500 schrieb olcott:

On 5/29/2021 2:26 PM, olcott wrote:
https://groups.google.com/g/comp.theory/c/dTvIY5NX6b4/m/cHR2ZPgPBAAJ
>
THE ONLY POSSIBLE WAY for D simulated by H to have the same behavior as
the directly executed D(D) is for the instructions of D to be
incorrectly simulated by H (details provided below).
>
_D()
[00000cfc](01)  55                      push ebp
[00000cfd](02)  8bec                    mov ebp,esp
[00000cff](03)  8b4508                  mov eax,[ebp+08]
[00000d02](01)  50                      push eax       ; push D
[00000d03](03)  8b4d08                  mov ecx,[ebp+08]
[00000d06](01)  51                      push ecx       ; push D
[00000d07](05)  e800feffff              call 00000b0c  ; call H
[00000d0c](03)  83c408                  add esp,+08
[00000d0f](02)  85c0                    test eax,eax
[00000d11](02)  7404                    jz 00000d17
[00000d13](02)  33c0                    xor eax,eax
[00000d15](02)  eb05                    jmp 00000d1c
[00000d17](05)  b801000000              mov eax,00000001
[00000d1c](01)  5d                      pop ebp
[00000d1d](01)  c3                      ret Size in
bytes:(0034) [00000d1d]
>
In order for D simulated by H to have the same behavior as the directly
executed D(D) H must ignore the instruction at machine address
[00000d07]. *That is an incorrect simulation of D*

I don't understand. Does D(D) ignore the call to H(D,D)?
>

H does not ignore that instruction and simulates itself simulating D.
The simulated H outputs its own execution trace of D.

>
What instructions does H use to output that trace and how those

>
I don't remember it has been two years.
I am looking into this again.
>

instructions are simulated when H is simulated?
>

>
They are simulated by
u32  DebugStep(Registers* master_state,
                Registers* slave_state, Decoded_Line_Of_Code* decoded)
                { return 0; }
>
This depends on libx86emu.
>

And why does H output any traces? That is not required by its

>
The traces are output so that people can directly see the
same infinite recursion behavior pattern that H sees and
thus know that H really is required to abort ts simulation.

 Looks like they don't serve that purpose. Perhaps you should
change something.

*No one has verified the actual facts of this for THREE YEARS*
*No one has verified the actual facts of this for THREE YEARS*
*No one has verified the actual facts of this for THREE YEARS*
On 5/29/2021 2:26 PM, olcott wrote:
https://groups.google.com/g/comp.theory/c/dTvIY5NX6b4/m/cHR2ZPgPBAAJ
_D()
[00000cfc](01) 55          push ebp
[00000cfd](02) 8bec        mov ebp,esp
[00000cff](03) 8b4508      mov eax,[ebp+08]
[00000d02](01) 50          push eax       ; push D
[00000d03](03) 8b4d08      mov ecx,[ebp+08]
[00000d06](01) 51          push ecx       ; push D
[00000d07](05) e800feffff  call 00000b0c  ; call H
[00000d0c](03) 83c408      add esp,+08
[00000d0f](02) 85c0        test eax,eax
[00000d11](02) 7404        jz 00000d17
[00000d13](02) 33c0        xor eax,eax
[00000d15](02) eb05        jmp 00000d1c
[00000d17](05) b801000000  mov eax,00000001
[00000d1c](01) 5d          pop ebp
[00000d1d](01) c3          ret
Size in bytes:(0034) [00000d1d]
It is impossible for D correctly simulated by H to ever reach
its simulated final state at its own machine address [00000d1d].
People disagree with this by changing the subject to D not simulated
by H as all. They have been indoctrinated into believing that this
strawman deception is correct yet
cannot possibly show the detailed steps of how D correctly simulated
by H can possibly reach its own simulated machine address of [00000d1d].
*Here are the steps that prove that I am correct*
(1) Executed H simulates the first seven instructions of D.
(2) Simulated D calls simulated H(D,D) to simulate itself again.
(3) Simulated H simulates the first seven instructions of simulated
     simulated D.
(4) Simulated simulated D simulated by simulated H calls
     simulated simulated H(D,D) to simulate itself again.
*HERE ARE ALL OF CONCRETE DETAILS OF THAT*
*Begin Local Halt Decider Simulation at Machine Address:cfc*
[00000cfc][00211839][0021183d](01)  55          push ebp      ; begin D
[00000cfd][00211839][0021183d](02)  8bec        mov ebp,esp
[00000cff][00211839][0021183d](03)  8b4508      mov eax,[ebp+08]
[00000d02][00211835][00000cfc](01)  50          push eax      ; push D
[00000d03][00211835][00000cfc](03)  8b4d08      mov ecx,[ebp+08]
[00000d06][00211831][00000cfc](01)  51          push ecx      ; push D
[00000d07][0021182d][00000d0c](05)  e800feffff  call 00000b0c ; call H
*This call to H is simulated by directly executed H*
  machine   stack     stack     machine          assembly
  address   address   data      code             language
  ========  ========  ========  ===============  =============
[00000cfc][0025c261][0025c265](01)  55          push ebp      ; begin D
[00000cfd][0025c261][0025c265](02)  8bec        mov ebp,esp
[00000cff][0025c261][0025c265](03)  8b4508      mov eax,[ebp+08]
[00000d02][0025c25d][00000cfc](01)  50          push eax      ; push D
[00000d03][0025c25d][00000cfc](03)  8b4d08      mov ecx,[ebp+08]
[00000d06][0025c259][00000cfc](01)  51          push ecx      ; push D
[00000d07][0025c255][00000d0c](05)  e800feffff  call 00000b0c ; call H
*This call to H would be simulated by simulated executed H*
*Infinitely Nested Simulation Detected Simulation Stopped*
--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer