Re: HHH(DD) does correctly reject its input as non-halting --- VERIFIED FACT

Op 13.jun.2025 om 17:22 schreef olcott:

On 6/13/2025 5:20 AM, Mikko wrote:

On 2025-06-12 15:34:01 +0000, olcott said:
>

int DD()
{
   int Halt_Status = HHH(DD);
   if (Halt_Status)
     HERE: goto HERE;
   return Halt_Status;
}
>
It is a verified fact that DD() *is* one of the forms
of the counter-example input as such an input would
be encoded in C. Christopher Strachey wrote his in CPL.
>
// rec routine P
//   §L :if T[P] go to L
//     Return §
// https://academic.oup.com/comjnl/article/7/4/313/354243
void Strachey_P()
{
   L: if (HHH(Strachey_P)) goto L;
   return;
}
>
https://academic.oup.com/comjnl/article-abstract/7/4/313/354243? redirectedFrom=fulltext
>
It *is* a verified fact DD correctly simulated by HHH cannot
possibly reach its own "return" statement final halt state
because the input to HHH(DD) specifies recursive simulation.

>
False. It is not the reursive simulation that prevents the reaching
the simulation of the "return" statement. Instead, previention is
a consequence of the discontinuation of the simulation that the
input specifies.

 When you try to prove this by providing ALL of the
details you will find that you are incorrect. Dogmatic
assertions utterly bereft of any supporting reasoning
do not count as rebuttals.
 

The input also specifies that the final "return"
statement is executed after the discontination of the simulation.
At this point HHH is not faithful to the specification.
>

 void DDD()
{
   HHH(DDD);
   return;
}
 _DDD()
[00002192] 55             push ebp
[00002193] 8bec           mov ebp,esp
[00002195] 6892210000     push 00002192
[0000219a] e833f4ffff     call 000015d2  // call HHH
[0000219f] 83c404         add esp,+04
[000021a2] 5d             pop ebp
[000021a3] c3             ret
Size in bytes:(0018) [000021a3]
 How does DDD correctly emulated by HHH reach its
own "ret" instruction final halt state?

It can't, because it has a bug causing a premature abort.

 It is an easily verified fact that zero to
infinity instructions of DDD correctly emulated
by HHH cannot possibly reach their own "ret"
instruction final halt state.

This failure of HHH to see the specified behaviour has no need to be repeated again and again.

 In incorrect emulation could do this. As soon
as HHH "interprets" "call 000015d2" as jmp 000021a3
DDD incorrectly emulated by HHH reaches its own "ret"
instruction final halt state.

No, a correct simulation does not need to change the call to a jmp instruction. A correct simulation, by world-class simulators, shows that the simulated HHH returns and then the instruction following the call instruction will be simulated eventually leading to the instruction at 000021a3.
That you do not understand that when a called function returns, the instruction following the call will be executed, shows your lack of understanding the x86 language.

 That you only have dogmatic assertions utterly bereft
of any supporting reasoning proves that what you are
calling knowledge is merely presumption.
 

Not knowing something does not make you stupid, but resistance against learning does.