XPost: sci.logic

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, and the only H you have show that correctly simulates the input to show it to be non-halting is the
version of H that never aborts.

I am also pointing lut that as far as you have proviced evidence, NONE
of you Hs have actually correctly simulated the input per your
definition, as NONE of them have simulated that call H into H as required.

And you have admitted that you haven't ever produced (until maybe very recently) an output clearly showing that it did.

So, your claim has not be "verified".

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

XPost: sci.logic

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?

We KNOW that when D(D) will be directly executed, and it calls H(D,D)
just like main did, that H(D,D) will return 0, and thus D(D) will reach
its final return.

Thus, H is just wrong about the direct execution of its input.

For any input that is actually based on the Linz proof, if the decider
that the input program calls says its input is non-halting, that input
program will halt.

H, to be able to say it "correctly simulated" the input, must either
simulate the call instructions, and all the instructions in H (and never
again see any instructions of D, unless it gets to the point of
simulating H's return).

And, to be able to correctly say that the input is non-halting, it needs
to be able to ACTUALLY PROVE that the trace it has seen can only come
from programs that are non-halting.

THus, H can NOT abort its simulation before the call to H, and return non-halting, as it knows (or should know if it isn't programmed by an
idiot) that this means that the CALL H it say will return, but it has no
idea what will happen after that, so it can not prove the input is
non-halting.

It might be able to prove non-POOPing, with POOP being defined as
simulatable by the decider to a final state, but that isn't a legal
"function" for a decider since there is no such mathematical function
for it to try to compute the mapping of. (Said function would need to
take a triple, of descritions of Decider, Machine, and input, and would
be asking if a given decider could answer the question, not THIS decider.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)