Re: Hypothetical possibilities --- Correct emulation has been proven for three years

Op 31.jul.2024 om 17:14 schreef olcott:

On 7/31/2024 3:44 AM, Fred. Zwarts wrote:

Op 31.jul.2024 om 06:09 schreef olcott:

>
  machine   stack     stack     machine    assembly
  address   address   data      code       language
  ========  ========  ========  =========  =============
[00002192][00103820][00000000] 55         push ebp
[00002193][00103820][00000000] 8bec       mov ebp,esp
[00002195][0010381c][00002172] 6872210000 push 00002172 ; push DDD
[0000219a][00103818][0000219f] e833f4ffff call 000015d2 ; call HHH(DDD)
New slave_stack at:1038c4
>
We don't show any of HHH and show the execution trace of
of just DDD assuming that HHH is an x86 emulator.

>
This assumption is incorrect if it means that HHH is an unconditional simulator that does not abort.

This algorithm is used by all the simulating termination analyzers:
<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 words 10/13/2022>

So, Sipser only agreed to a correct simulation, not with an incorrect simulation that violates the semantics of the x86 language by skipping the last few instructions of a halting program.

 You must have attention deficit disorder if you cannot pay
attention to the fact that I have said these same words many
many times:
      *If simulating halt decider H correctly simulates its input D*
     *until H correctly determines that its simulated D would never*
     *stop running unless aborted*

Yes, you often make the same mistake. Because the examples you show are about an simulator that thinks that two recursions are enough to decide an infinite recursion. You should know that two differs from infinite.
Your simulation aborts prematurely, skipping the last few instructions of its input.

 *Either that or you are an internet Troll*

Irrelevant nonsense ignored.

 _DDD()
[00002172] 55         push ebp      ; housekeeping
[00002173] 8bec       mov ebp,esp   ; housekeeping
[00002175] 6872210000 push 00002172 ; push DDD
[0000217a] e853f4ffff call 000015d2 ; call HHH(DDD)
[0000217f] 83c404     add esp,+04
[00002182] 5d         pop ebp
[00002183] c3         ret
Size in bytes:(0018) [00002183]
 When we see the first four lines of DDD after main() has
called HHH(DDD) we know that HHH has emulated these first
four lines correctly. >
When we see the first four lines of DDD after DDD() has
called HHH(DDD) we know that HHH has emulated these first
four lines correctly.
 Begin Local Halt Decider Simulation   Execution Trace Stored at:1138cc
[00002172][001138bc][001138c0] 55         push ebp      ; housekeeping
[00002173][001138bc][001138c0] 8bec       mov ebp,esp   ; housekeeping
[00002175][001138b8][00002172] 6872210000 push 00002172 ; push DDD
[0000217a][001138b4][0000217f] e853f4ffff call 000015d2 ; call HHH(DDD)

But we miss the trace of the instructions that should follow the call instruction.
Are you cheating? You are hiding that HHH has conditional branch instructions, which makes it abort after two cycles.

New slave_stack at:14e2ec
[00002172][0015e2e4][0015e2e8] 55         push ebp      ; housekeeping
[00002173][0015e2e4][0015e2e8] 8bec       mov ebp,esp   ; housekeeping
[00002175][0015e2e0][00002172] 6872210000 push 00002172 ; push DDD
[0000217a][0015e2dc][0000217f] e853f4ffff call 000015d2 ; call HHH(DDD)
Local Halt Decider: Infinite Recursion Detected Simulation Stopped
 

Then HHH prints a wrong message after skipping the last few instructions of its simulation of HHH, after which the simulated HHH would abort and return to DDD, after which the simulated DDD would halt.
Apparently, HHH is incorrectly programmed to abort a halting program after two cycles. A premature abort, because one cycle later the simulated HHH would abort and the program would halt.
So, we see an incorrect simulation, which skips instructions of a halting program, violating in this way the semantics of the x86 language.
Olcott keeps dreaming of an infinite recursion. He really, really wants his simulation to be correct. He hopes that repeating and dreaming will change the fact that it is incorrect. But dreams are no substitute for logic.
HHH cannot possibly simulate itself correctly.