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

On 6/12/24 12:57 PM, olcott wrote:

On 6/12/2024 6:33 AM, Richard Damon wrote:

On 6/11/24 11:21 PM, olcott wrote:

On 6/11/2024 9:30 PM, Richard Damon wrote:

On 6/11/24 7:23 PM, olcott wrote:

On 6/11/2024 5:47 PM, Richard Damon wrote:

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.

>
It turns out that by the generic definition of a decider
what the directly executed D(D) does is not any of the
business of H.

>
IMPOSSIBLE.
>
Just shows that you don't understand what you are talking about.
>
The problem is that you don't understand what a xxxx-decider means.

>
There are no finite string transformation rules
from the input to H(D,D) to the behavior of D(D).
>

>
As I pointed out, there ARE finite-string transformations that do it, that is a UTM.
>

 On 5/29/2021 2:26 PM, olcott wrote:
https://groups.google.com/g/comp.theory/c/dTvIY5NX6b4/m/cHR2ZPgPBAAJ
 Unless you show every single step of D correctly simulated
by H that reaches the simulated "ret" of D all you have
is bluster utterly bereft of any supporting reasoning.

Why, because the claim isn't about the simulate by H, but the behavior of the difectly executed D(D), or its simulation by a UTM.

 *Steps 1-7 are simulated then THE SIMULATED D CALLS THE SIMULATED H*
*Steps 1-7 are simulated then THE SIMULATED D CALLS THE SIMULATED H*
*Steps 1-7 are simulated then THE SIMULATED D CALLS THE SIMULATED H*

And since H doesn't then simulate that, it is just an incorrect simulation

 *What are the exact next steps of D CORRECTLY SIMULATED BY H*
*What are the exact next steps of D CORRECTLY SIMULATED BY H*
*What are the exact next steps of D CORRECTLY SIMULATED BY H*
 

The call to H, followed by the assembly instructions of H.

THAT REACH THE SIMULATED "ret" INSTRUCTION?
THAT REACH THE SIMULATED "ret" INSTRUCTION?
THAT REACH THE SIMULATED "ret" INSTRUCTION?

who says the simualation, BY H, can do that?
It is the simulation by a UTM that can.
Since you don't give the instructions of H, and I won't fix your program to generate that (without payment), I won't provide that detail list to you, but since it has been shown that D(D) WILL halt since H(D,D) returns 0, that is sufficient.

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