Re: How do simulating termination analyzers work? (V2)

On 6/20/25 8:44 PM, olcott wrote:

On 6/20/2025 7:01 PM, Richard Damon wrote:

On 6/20/25 3:08 PM, olcott wrote:

void Infinite_Recursion()
{
   Infinite_Recursion();
   return;
}
>
void Infinite_Loop()
{
   HERE: goto HERE;
   return;
}
>
void DDD()
{
   HHH(DDD);
   return;
}
>
int Sipser_D()
{
   if (HHH(Sipser_D) == 1)
     return 0;
   return 1;
}
>
int DD()
{
   int Halt_Status = HHH(DD);
   if (Halt_Status)
     HERE: goto HERE;
   return Halt_Status;
}
>
My claim is that each of the above functions correctly
simulated by any termination analyzer HHH that can possibly
exist will never stop running unless aborted by HHH.

>
The problem is that NO "Simulating Halt Decider" HHH, can correctly simulte ANY of those inputs.
>
For the first two, it is possible for a smart enough Simulation Halt Decider to determine that the correct simulation of the input will not halt, no matter what HHH actually does, since it doesn't depend on the decider.
>
For the last 3, it can not prove that they will not halt, as, in fact,

 

the correct simulation of all those inputs *WILL* halt

 _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]

WHich can't be the FULL input, as you have admitted that the code for HHH *WILL* be used when we correctly simulate it, and thus that *ISN'T* the defininiton of DDD.
You have a LIE by equivocation, either the above is the definition of HHH, and thus it is impossible to correctly simulate it, but every HHH does get the same input, and your how proof is based on a category error, or
the actual definition includes the code of HHH, which you lie by not showing, and that means that each pairing of DDD to an HHH gives a different input, and your logic LIES when you say there is just "one" DDD that they all see.

 Exactly how would N instructions of DDD emulated by HHH
according to the semantics of the x86 language reach
machine address 000021a3 ?
 

Who says it does?
The problem is that you HHH isn't actually definable by your requirements to BOTH "correctly simulate" the input input and to "correctly decide" it.
Your world is divided into two diffent subsets of HHHs, each which look at two different subsets of DDD (since every DDD is different, or NONE of them are correctly simulatable due to the category error)
The HHHs that actually end up doing a correct simulation, end up creating DDD that are non-halting, but none of the HHH in this set give an answer, and so are just not correct.
The HHHs that are deciders, MUST abort their simulation (as otherwise they are in the above set, and don't answer), and thus do not do a "correct simulation" per the term-of-art meaning, and the correct simulation of those inputs (by a real correct simulator, which isn't HHH) will reach a final state (as you have previously admitted, and shown).
Since the correct simulation of these reach the final state, they have halting behavior, and HHH returning 0 is just incorrect.
Thus, your whole argument is just a lie built on the eqivocation that you can define an HHH that does what can not be done, as you base that on an equivocation in the definition of DDD which includes HHH to be simulatable, but also doesn't so all of them can be the same.
Thus, it is shown that you logic is just based on the need to lie about what you are talking about, and that you have no idea what the word you are using actually mean.