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

On 6/8/24 2:47 PM, olcott wrote:

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>

But it hasn't since the Sipser criteria is based on "Correct SImulation" meaning a simulation the exactly reproduces the behavior of the directly executed code, which means a simulation that doesn't stop until it reaches a final state (even if that takes forever).
H does NOT do that sort of simulation, nor does it correctly determine that THIS input (and thus still calling the original H), if simulated by that sort of simulator will not halt, so you never satisfy the requirements, so can never claim the right of the second clause.
This has been explained to you many times, and your repeating it just shows a reckless disregard for the truth, and could open you up to a defamation suit by Professor Sipser. It also shows that your understanding of what other people say needs to be kept suspect, and you are proving yourself to be a pathological liar.

 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 why do we care?

 _DD()
[00001e12] 55         push ebp
[00001e13] 8bec       mov  ebp,esp
[00001e15] 51         push ecx
[00001e16] 8b4508     mov  eax,[ebp+08]
[00001e19] 50         push eax      ; push DD
[00001e1a] 8b4d08     mov  ecx,[ebp+08]
[00001e1d] 51         push ecx      ; push DD
[00001e1e] e85ff5ffff call 00001382 ; 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, by your definition

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

And this does not happen by your definition of a correst simulation, but the trace SHOULD continue at address 00001342, and show the code of HH
What do you think the actual x86 instrucitons mean?
It just shows your intent to decieve.
The following does NOT happen again in the context of the correct x86 simulation of the code given to HH.
So, your trace just proves that you are a LIAR.
And this is not an honest mistake, as you have been told this many times, but you are unable to accept the truth.

[00001c22][0015da89][0015da8d] 55         push ebp
[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).
 

Nope, it shows that you can't even follow your own definitions.