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

On 6/16/25 3:35 PM, olcott wrote:

On 6/16/2025 5:36 AM, Mikko wrote:

On 2025-06-15 13:49:51 +0000, olcott said:
>

On 6/15/2025 3:24 AM, Fred. Zwarts wrote:

Op 14.jun.2025 om 15:38 schreef olcott:

On 6/14/2025 4:10 AM, Fred. Zwarts wrote:

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

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

On 2025-06-12 15:30:05 +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

>
Strachey only informally presents the idea of the proof. Formalism
and details needed in a rigorous proof is not shown.
>

>
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]
>
Exactly how would DDD correctly emulated by HHH
reach its own "ret" instruction final halt state?

>
Indeed, HHH fails where other world-class simulators have no problem to simulate the program specified in the input.

>
So you still don't understand what recursive simulation is?

>
It seems I understand it better than you do. You seem to think that every recursion is a infinite recursion. As soon as you see a recursion, you think it has been proven that it is an infinite recursion, even if the code specifies an abort and halt.

>
<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>
>
It is an easily verified fact that the input to HHH(DDD) and
the input to HHH(DD) meets the above self-evidently true criteria.

>
No, they don't meet the second cireterion. HHH does not correctly
determine that its input would never stop running unless aborted.
Perhaps you may deceive with someting like equivocation someone to
believe it does but in reality it does not.
>

 No one has ever even attempted to show the details
of how this is not correct:
 void DDD()
{
   HHH(DDD);
   return;
}
 When one or more instructions of DDD are correctly
simulated by ANY simulating termination analyzer HHH
then this correctly simulated DDD never reaches its
simulated "return" statement final halt state.
 

The problem is that isn't the definition of non-halting, and thus irrelevent.
You have indicated that you agree that this actually is an error in your logic by failing to actually attempt to refute the error pointed out with any actual facts. All you do is continue to make the baseless claim, which is just a lie.
Sorry, but your refusal to even try to argue to the facts, but just repeat your baseless assertion just shows that you known and effectively acknoledge that you have no actual basis for the claim (if you had a basis, why look like an idiot and not present it).