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

On 6/10/2024 10:25 AM, joes wrote:

Am Mon, 10 Jun 2024 09:36:09 -0500 schrieb olcott:

On 6/10/2024 3:35 AM, joes wrote:

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

On 5/29/2021 2:26 PM, olcott wrote:

 

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

The only correct simulation must simulate incorrectly? Wat.
 

Try carefully studying those words again and again until
you see how your paraphrase is wrong.
Perhaps your paraphrase was wrong on purpose?

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.
>
The directly executed D(D) reaps the benefit of D simulated by
H proving that *its input never halts*
>
Begin Local Halt Decider Simulation at Machine Address:cfc
..[00000cfc][00211839][0021183d](01)  55          push ebp
..[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 H.
We can tell that it is the simulated H is providing this trace because
it has a different virtual machine stack.
*The simulated H derives this execution trace of D*
      machine   stack     stack     machine          assembly address
      address   data      code             language ========  ========
      ========  ===============  =============
..[00000cfc][0025c261][0025c265](01)  55          push ebp
..[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
Infinitely Nested Simulation Detected Simulation Stopped
>
Because the H(D,D) that D(D) calls recognizes the its input
DOES NOT HALT, it aborts the simulation of this input causing
the directly executed D(D) to halt.

How can H report "non-halting" when D(D) halts?
 

I proved that D simulated by H can only have the same behavior as the
directly executed D(D) when D is simulated by H incorrectly.

You've got it the wrong way around. A simulation must have the same
behaviour.
 

I proved otherwise. Maybe the proof is simply over-your-head?
--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer