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

On 6/8/24 3:49 PM, olcott wrote:

*This has been corrected so that it can be verified that*
*the execution trace matches the x86 source-code of DD*
(two versions of my text files were out-of-sync)
 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>

Which, since his definition of "Correct Simulation" is not yours, you can not use.
For you to use it, you need to first show that your H actually does a correct simulation of the input, which is a simualation that actually recreates the behavior of the input, which requires a simulation that never aborts.
Since your H doesn't do this, your logic fails.
Sipser would also allow for us to hypothocate that THIS H changes into such a simulator, but in doing so, the input does not change (since it can't) and thus for your system, that means the DD still says paired with the original HH that you are going to claim to be correct.
Since that simulation WILL HALT if H ever decides to abort and return 0, as long as that option remains, H can never correctly determine that its simulation would not halt if not aborted.
So, you FAIL to acheive the requirements, and can not use the clause that you did use, so you have lost correctness of your decider.

 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.

And who cares, since you have defined your "correct simulation" to allow for just partial simuations, and thus do not indicate non-halting behavior.

 _DD()
[00001c22] 55         push ebp
[00001c23] 8bec       mov ebp,esp
[00001c25] 51         push ecx
[00001c26] 8b4508     mov eax,[ebp+08]
[00001c29] 50         push eax      ; push DD 1c22
[00001c2a] 8b4d08     mov ecx,[ebp+08]
[00001c2d] 51         push ecx      ; push DD 1c22
[00001c2e] e80ff7ffff call 00001342 ; call HH
 A {correct simulation} means that each instruction of the
above x86 machine language of DD is correctly simulated
by HH and simulated in the correct order.
 In other words the first seven steps of DD correctly simulated
by HH call HH(DD,DD) to repeat these first seven steps. HH then
simulates itself simulating DD until this second instance of DD
calls another HH(DD,DD) to repeat these first seven steps again.

Nope, as after the 7th instruction must be the 8th instruction, which is thw Call HH instruction. To meet your definition, the simulation must then continue into HH as THAT is the correct behavior of that instruction
So your arguement is totally off track, andyou are failing to meet even your own requirements.

 New slave_stack at:10306d
Begin Local Halt Decider Simulation   Execution Trace Stored at:113075
  machine   stack     stack     machine    assembly
  address   address   data      code       language
  ========  ========  ========  =========  =============
[00001c22][00113061][00113065] 55         push ebp        ; begin DD
[00001c23][00113061][00113065] 8bec       mov ebp,esp
[00001c25][0011305d][00103031] 51         push ecx
[00001c26][0011305d][00103031] 8b4508     mov eax,[ebp+08]
[00001c29][00113059][00001c22] 50         push eax         ; push DD
[00001c2a][00113059][00001c22] 8b4d08     mov ecx,[ebp+08]
[00001c2d][00113055][00001c22] 51         push ecx         ; push DD
[00001c2e][00113051][00001c33] e80ff7ffff call 00001342    ; call HH
New slave_stack at:14da95
[00001c22][0015da89][0015da8d] 55         push ebp         ; begin DD
[00001c23][0015da89][0015da8d] 8bec       mov ebp,esp
[00001c25][0015da85][0014da59] 51         push ecx
[00001c26][0015da85][0014da59] 8b4508     mov eax,[ebp+08]
[00001c29][0015da81][00001c22] 50         push eax         ; push DD
[00001c2a][0015da81][00001c22] 8b4d08     mov ecx,[ebp+08]
[00001c2d][0015da7d][00001c22] 51         push ecx         ; push DD
[00001c2e][0015da79][00001c33] e80ff7ffff call 00001342    ; call HH
Local Halt Decider: Recursive Simulation Detected Simulation Stopped
 The above is the complete proof that DD correctly simulated
by any HH that can possibly exist never stops running without
having its simulation aborted by HH (or crashing for OOM error).
 

But if fails to meet your definition of "Correct Simulation" so your argument is just shown to be a LIE.