Re: Proof that DD correctly simulated by HH has different behavior than DD(DD) STEP(1)

On 6/10/24 1:54 PM, olcott wrote:

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

On 6/10/24 1:17 AM, olcott wrote:

On 6/9/2024 1:33 AM, Fred. Zwarts wrote:

Op 08.jun.2024 om 20:47 schreef olcott:

Before we can get to the behavior of the directly executed
DD(DD) we must first see that the Sipser approved criteria
have been met:
>
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
If simulating halt decider H correctly simulates its input D
until H correctly determines that its simulated D would never
stop running unless aborted then
>
H can abort its simulation of D and correctly report that D
specifies a non-halting sequence of configurations.
</MIT Professor Sipser agreed to ONLY these verbatim words10/13/2022>
>
On 10/14/2022 7:44 PM, Ben Bacarisse wrote:
 > I don't think that is the shell game. PO really /has/ an H
 > (it's trivial to do for this one case) that correctly determines
 > that P(P) *would* never stop running *unless* aborted.
>
Try to show how this DD correctly simulated by any HH ever
stops running without having its simulation aborted by HH.

>
Stopping at your first error. So, we can focus on it. Your are asking a question that contradicts itself.
A correct simulation of HH that aborts itself, should simulate up to the point where the simulated HH aborts. That is logically impossible. So, either it is a correct simulation and then we see that the simulated HH aborts and returns, or the simulation is incorrect, because it assumes incorrectly that things that happen (abort) do not happen.
A premature conclusion.
>
>

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

 I should have said no reviewers here have verified these
facts for THREE years. I have had four other reviewers
that verified these facts that were not in this forum.
 You are ridiculously childish for saying that every tiny
mistake is an intentional falsehood.

But REPEATING it shows it was.

 

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

 I am saying that no one here has bothered to carefully
study the proof that I am correct in THREE SOLID YEARS.

WHAT PROOF?
I haven't seen an actual statement of a truth-preserving operation connecting a statement accepted as true to any of your claims.
Only "examples" and statements of "obvious" (with sources)

 

>

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

 The only way for D simulated by H to have the same behavior as
the directly executed D(D) is for D simulated by H to skip over
this call.

You haven't proven that.
And all that actualy shows is that H's simulation can't be correct in the right manner to be used for the Halting Problem.
After all, the halting problem SPECIFICALLY takes about the direct execution as the criterion, and we can only talk about using simulation when that simulation agrees with that.
SO, you are just admitting that your claim to working on the Halting Problem is either a LIE or evidence of your total ignorance about the subject.

 

>
Your problem is that it turns out that the only way that a correct simulation by H to be an actual correct simulation that shows halting behavior, it can't answer and be a decider.
>

 <MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
   If simulating halt decider H correctly simulates its input D
   until H correctly determines that its simulated D would never
   stop running unless aborted then
    H can abort its simulation of D and correctly report that D
   specifies a non-halting sequence of configurations.
</MIT Professor Sipser agreed to ONLY these verbatim words10/13/2022>

And by "Correct Simulation" he means a simulation that recreates fully the behavior of the dirrectly executed machine, which requries a simulation that never aborts.
Not something that H satisified or proves that it is correct about.

 The above is self-evidently correct thus making it a verified
fact and you and others disagree anyway.

Yes, but not applicable to you, since you use a different definition of "correct simulation", so your quoting him this way just proves your attempt to be deceptive, in other words, to try to LIE.

 

>
H does not ignore that instruction and simulates itself simulating D.
The simulated H outputs its own execution trace of D.
>
>

>
But your H DOES ignore the CORRECT behavior of that instruction, as a correct simulation of that instruction (by what ever type of simulation you want to do) must either continue it trace inot the function H (which none of your publish traces of the resutls of the simulation H does do) if the simulation instruction level, or it must show the effective behavior of the actaul function H, which is to return 0 (since you claim you H is correct, and correct to return 0).
>
Neither of these is what your "correct simulation" of the input does, so it can not be a correct simulation of the input. Your H just doesn't "correctly simulate" that call instruction, but does invalid logic to conclude the wrong answer.
>
>
It seems impossible for you claim that you have looked at the trace of H acuallly doing the x86 instruction trace of H to show that it was correctly determining what you claim, as your "250 page" trace turns out not to be that trace, and you admit you didn't look at it closely, and you JUST think you figured out how to get such a trace out.
>

 There is no need to look at the trace of H correctly simulated
by H when the trace of D correctly simulated by simulated H is
proven to be correct.

But it CAN'T be if H didn't simulate the H that is PART OF D.
If you try to simulate D without H, your simulation STOPS after 7 instuctions and can not continue.
PERIOD.

 

Thus, you could NOT have verified it 3 years ago.
>
So, you have just been caught in a LIE.

 I have just proven otherwise.
 

WHere?
You have made unsubstantiated claims.
Where is the accepted truth perserving operation from accepted truth makers to your claim.
LIST THEM OR IT IS AN ADMITION THAT YOU HAVE LIED.