Re: How do simulating termination analyzers work?

On 2025-06-29 14:21:55 +0000, olcott said:

On 6/29/2025 3:44 AM, Mikko wrote:

On 2025-06-28 13:17:17 +0000, olcott said:
 

On 6/28/2025 6:41 AM, Mikko wrote:

On 2025-06-21 17:34:55 +0000, olcott said:
 

On 6/21/2025 4:52 AM, Mikko wrote:

On 2025-06-20 13:59:02 +0000, olcott said:
 

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

Op 19.jun.2025 om 17:17 schreef olcott:

On 6/19/2025 4:21 AM, Fred. Zwarts wrote:

Op 18.jun.2025 om 15:46 schreef olcott:

On 6/18/2025 5:12 AM, Fred. Zwarts wrote:

Op 18.jun.2025 om 03:54 schreef olcott:

On 6/17/2025 8:19 PM, Richard Damon wrote:

On 6/17/25 4:34 PM, olcott wrote:

void Infinite_Recursion()
{
   Infinite_Recursion();
   return;
}
 void Infinite_Loop()
{
   HERE: goto HERE;
   return;
}
 void DDD()
{
   HHH(DDD);
   return;
}
 When it is understood that HHH does simulate itself
simulating DDD then any first year CS student knows
that when each of the above are correctly simulated
by HHH that none of them ever stop running unless aborted.

 WHich means that the code for HHH is part of the input, and thus there is just ONE HHH in existance at this time.
 Since that code aborts its simulation to return the answer that you claim, you are just lying that it did a correct simulation (which in this context means complete)
 

 *none of them ever stop running unless aborted*

 All of them do abort and their simulation does not need an abort.
 

 *It is not given that any of them abort*
 

 At least it is true for all aborting ones, such as the one you presented in Halt7.c.

 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.
Can you affirm or correctly refute this?

 

Yes, I confirmed many times that we can confirm this vacuous claim, because no such HHH exists. All of them fail to do a correct simulation up to the point where they can see whether the input specifies a halting program.

 if DDD correctly simulated by any simulating termination
analyzer HHH never aborts its simulation of DDD then

 that HHH is not interesting.

 *then the HP proofs are proved to be wrong*

 Does not follow. HHH and DDD are irrelevant to those proofs.

 void DDD()
{
   HHH(DDD);
   return;
}
 When I dumbed the original self-referential proof down
to HHH(DDD) everyone here proved that they did not even
understand what ordinary recursion is.

 That you are dumb does not mean that others don't understand
ordinary recursion.
 

 Mensa scored me on the top 3% of the population.

Your intelligence, not wisdom.

This is a little more difficult than ordinary recursion.

Perhaps to your little mind.

void DDD()
{
   HHH(DDD);
   return;
}
 _DDD()
[00002192] 55             push ebp
[00002193] 8bec           mov ebp,esp
[00002195] 6892210000     push 00002192  // push DDD
[0000219a] e833f4ffff     call 000015d2  // call HHH
[0000219f] 83c404         add esp,+04
[000021a2] 5d             pop ebp
[000021a3] c3             ret
Size in bytes:(0018) [000021a3]
 The x86 source code of DDD specifies that this emulated
DDD cannot possibly reach its own emulated "ret" instruction
final halt state when emulated by HHH according to the
semantics of the x86 language.

That defect in HHH is already known and a possible fix has been proposed.
--
Mikko