Re: DDD correctly emulated by HHH is correctly rejected as non-halting.

Op 10.jul.2024 om 17:03 schreef olcott:

typedef void (*ptr)();
int HHH(ptr P);
 void DDD()
{
   HHH(DDD);
}
 int main()
{
   HHH(DDD);
}

Unneeded complexity. It is equivalent to:
        int main()
        {
          return HHH(main);
        }

 We stipulate that the only measure of a correct emulation
is the semantics of the x86 programming language. By this
measure when 1 to ∞ steps of DDD are correctly emulated by
each pure function x86 emulator HHH (of the infinite set
of every HHH that can possibly exist) then DDD cannot
possibly reach past its own machine address of 0000216b
and halt.

Proving that the simulation is incorrect. Because a correct simulation would not abort a halting program halfway its simulation.
void Finite_Recursion (int N) {
   if (N > 0) Finite_Recursion (N - 1);
}

 _DDD()
[00002163] 55         push ebp      ; housekeeping
[00002164] 8bec       mov ebp,esp   ; housekeeping
[00002166] 6863210000 push 00002163 ; push DDD
[0000216b] e853f4ffff call 000015c3 ; call HHH(DDD)
[00002170] 83c404     add esp,+04
[00002173] 5d         pop ebp
[00002174] c3         ret
Size in bytes:(0018) [00002174]
 *This algorithm is used by 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>

But these words do not apply for the above example, because these words apply to a correct simulation, not to HHH, which performs an incorrect simulation.

 Simulating termination analyzer HHH aborts its emulation of DDD
as soon as it correctly detects any non-halting behavior pattern.
At this point it aborts its emulation and returns 0 indicating
that it rejected this input as non-halting.
 

It cannot detect a non-halting pattern in a program that is programmed to halt after a few cycles of recursive simulation.
void Finite_Recursion (int N) {
   if (N > 0) Finite_Recursion (N - 1);
}
So, not only is the simulation incorrect, also the detection of a non-halting pattern failed.
So, the only report that it can make is that its own simulation failed.