Re: DDD correctly emulated by HHH --- Correct Emulation Defined 2 addendum

On 3/21/2025 7:50 PM, Richard Damon wrote:

On 3/21/25 8:02 PM, olcott wrote:

>
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]
>
For every HHH at machine address 000015d2 that emulates
a finite number of steps of DDD according to the
semantics of the x86 programming language no DDD
ever reaches its own "ret" instruction halt state.
>

 So, you demonstrate your utter stupidity and use of incorrect definitions.
 For EVERY HHH at machine address 000015d2 that emulates just a finite number of steps and return, then the PROGRAM DDD

https://en.wikipedia.org/wiki/Straw_man
typedef void (*ptr)();
int HHH(ptr P);
void DDD()
{
   HHH(DDD);
   return;
}
int main()
{
   HHH(Infinite_Recursion);
}
There is no program DDD in the above code.
DDD emulated by HHH according to he semantics of the
x86 language is the topic of discussion.
Since no Turing machine M can ever compute the mapping
from the behavior of any directly executed TM2 referring
to the behavior of the directly executed DDD has always
been incorrect. Halt Deciders always report on the behavior
that their input finite string specifies.
In every case that does not involve pathological self-reference
the behavior that the finite string specifies is coincidentally
the same behavior as the direct execution of the corresponding
machine. The actual measure, however, has always been the
behavior that the finite string input specifies.
typedef void (*ptr)();
int HHH(ptr P);
int DD()
{
   int Halt_Status = HHH(DD);
   if (Halt_Status)
     HERE: goto HERE;
   return Halt_Status;
}
int main()
{
   HHH(DD);
}
Prior to my work on simulating termination analyzers the
behavior of the counter-example input to the conventional
halting problem proofs was unknown. It was unknown because
it was previously assumed the input DD could actually do
the opposite of whatever value that HHH returned.
When we define the Olcott emulating termination
analyzer's purpose is to report in the behavior that
its x86 machine language input specifies according to
the semantics of the x86 language (thus defining what
a correct emulation is) then we see that DD cannot
possibly reach past its own first instruction in any
finite number of steps of correct emulation.
--
Copyright 2025 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer