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

On 6/12/2024 1:18 AM, Fred. Zwarts wrote:

Op 11.jun.2024 om 19:07 schreef olcott:

On 6/11/2024 2:21 AM, Fred. Zwarts wrote:

Op 10.jun.2024 om 21:47 schreef olcott:

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

>
Proven false. The direct execution does not ignore the call to H.

>
Yes that is the second big mistake that I am aware that I made
within the last year.
>
When Ĥ is applied to ⟨Ĥ⟩
Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>
The other big mistake was what I said happens when Linz H is
applied to ⟨Ĥ⟩ ⟨Ĥ⟩. I forgot what I said and I forgot what the
correct answer was. I do remember this is was my big mistake.
>
No one has ever shown any actual error with my analysis of embedded_H
applied to ⟨Ĥ⟩ ⟨Ĥ⟩. It is a verified fact that is over everyone's head
besides mine that ⟨Ĥ⟩ ⟨Ĥ⟩ correctly simulated by embedded_H cannot
possibly reach its own simulated final state of ⟨Ĥ.qn⟩.
>
Everyone assumes that I must be wrong and only have dogma to base
this assumption on. I have reasoning to prove that they are wrong
yet this reasoning is over their heads.
>
I have made isomorphic reasoning 100% concrete with this example
and every has simply ignored this reasoning 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*
*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*
>
>

 There is no infinite nested simulation detected,

If I am wrong then a specific sequence of steps of D correctly
simulated by H where D terminates normally can be provided.
Every attempt of rebuttal of this only had pure bluster and
no actual sequence of steps as its basis.
If this cannot be provided then that proves that there is no
sequence of finite string transformation rules that derives
the behavior of the directly executed D(D) from the input to H(D,D).
This proves that when simulating halt decider H(D,D) computes
the mapping from its inputs the behavior of the directly executed
D(D) is proven to be irrelevant because there is no mapping that
reaches this behavior.
--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer