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

On 6/11/24 1:12 PM, olcott wrote:

On 6/11/2024 6:47 AM, Richard Damon wrote:

On 6/11/24 12:31 AM, olcott wrote:

On 6/10/2024 10:32 PM, Richard Damon wrote:

On 6/10/24 10:06 PM, olcott wrote:

On 6/10/2024 6:16 AM, Richard Damon wrote:

On 6/9/24 11:54 PM, olcott wrote:

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

>
So, I guess you are admitting that you claim it as a verified fact is just a LIE.
>

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

>
So, I guess you are admitting that this means that "D correctly simulated by H" is NOT a possible equivalent statement for the behavior of the direct execution of the input as required by the Halting Problem, so you admit you have been LYING every time you imply that it is.
>

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

>
No, H can, and must, simulate the call instruction correctly.
>

>
*Ah so you finally admit that the directly executed D(D) that*
*cannot possibly reach this instruction *is not* the behavior*
*of D correctly simulated by H that reaches this instruction*
*and simulates H simulating H*
>

>
No, I admit that THIS H didn't do it,

>
*This H does do it*
D is correctly simulated by H and H simulates itself simulating D
as the above line of code requires.
>
The directly executed D(D) can't possibly reach that line of code
thus proving that it has different behavior than D correctly
simulated by H.
>

>
WHy do you say the directly executed D(D) Can't reach its return statement?
>

 That is my second big mistake that I am aware of in the last year.
 *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*

WRONG.
*YOU* have verified that the directly executed D(D) will reach its return statement.

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

But that isn't the question, we were talking aboiut the direct exection of D(D).
To quote you from above: " The directly executed D(D) can't possibly reach that line of code"
Which is just a wrong stateement that you are now trying to do a dishonest dodge to diflect from.

 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

No, *YOU* are changing the subject, perhaps because you accidentally stumbled on a land mine and mistakenly got yourself onto the actual question that you have been avoiding,

 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*

Because no one cares about your D only partially simulated by H, as it doesn't actual answer any question that people care about.

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

Except that this is NOT what a correct simulation of the input to H(D,D) should be simulating

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

Which means it is NOT a trace of the sumulation of the input to the orginal H(D,D), so not relevlent to the quesiton.
So the ONLY simulation that you have show FAILS to meet youer own definiton of what a correct simulation would be, so you are just showing that your logic is just flawed.
Note, replacing the simulation of the simulator with the simulation it is doing is NOT correct per your definition, and can only be correct if the simulator is ACTUALLY unconditinal, which yours is not, and thus the simulation you have shown is just INCORRECT, and you LIE in your claims that it is correct.

*Infinitely Nested Simulation Detected Simulation Stopped*
 

But it ISN'T "Infintely Nested CORRECT Simulation", as it is a FACT that the CORRECT simulation of the input, for the D calling the H that actually exists, that answers, will show, that after H(D,D) aborted it simulaiton, that the continulation of that simulation will see the simulated H(D,D) also abort its simulation and return to the simulated D(D) and halt.
Thus, all H showed was that it didn't simulate it input to the final state, that it would reach with a more complete simulation.
The logic to call in "infintitely recursive" is INVALID as it assumes that the H(D,D) called by D(D) is a DIFFERENT funciton than that doing the simulation, so your H LIES (because YOU LIE) about what it is actually treating its input.
As you have previously said, looking at the wrong input that isn't what was actually given just make the person do that a LIAR.
SO you are admitting that is what you are.
Your H INCORRECTLY, and intentionally DECEPTIVELY, treats its input as not the inptut it actually is, but something else.