Re: The input to HHH(DDD) specifies a non-halting sequence of configurations +++

On 6/15/2025 4:39 AM, Mikko wrote:

On 2025-06-14 14:17:46 +0000, olcott said:
 

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

On 2025-06-11 14:11:32 +0000, olcott said:
 

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

On 2025-06-10 16:10:49 +0000, olcott said:
 

On 6/10/2025 7:01 AM, Mikko wrote:

On 2025-06-09 14:46:30 +0000, olcott said:
 

On 6/9/2025 6:24 AM, Richard Damon wrote:

On 6/8/25 10:50 PM, olcott wrote:

void DDD()
{
   HHH(DDD);
   return;
}
 The *input* to simulating termination analyzer HHH(DDD)
specifies recursive simulation that can never reach its
*simulated "return" instruction final halt state*
 *Every rebuttal to this changes the words*
 

  So, you think a partial simulation defines behavior?
 Where do you get that LIE from?
 

 void Infinite_Recursion()
{
   Infinite_Recursion();
}
 void Infinite_Loop()
{
   HERE: goto HERE;
   return;
}
 I am no so stupid that I require a complete
simulation of a non-terminating input.

 Yes you are. You just express your stupidity in another way.
 

 It only takes two simulations of DDD by HHH for HHH
to correctly recognize a non-halting behavior pattern.

 Either the pattern or the recognition is incorrect.

 DDD correctly simulated by HHH cannot possibly reach its
own "return" statement final halt state. This by itself
*is* complete proof that the input to HHH(DDD) specifies
non-halting behavior.

 No, it is not. The words "cannot possibly" are not sufficiently
meaningful to prove anything. HHH does what it does and does
not what it does not. But what it can or cannot do, possiby or
otherwise?

 It is required that one have the technical competence of
a first year CS student that knows C to understand that
it is self-evident that the input to HHH(DDD) specifies
behavior such that DDD correctly simulated by HHH cannot
possibly reach its simulated "return" statement.

 The meaning of "self-evident" excludes all requirements of
any technical competence.
 The meaning of "cannot possibly", if there is any, is too far from
clear that a sentence containing it could be self-evident.
 

 void DDD()
{
   HHH(DDD);
   return;
}
 Where DDD is correctly simulated by HHH is
merely a more complex form of this same pattern:
 void H()
{
   D();
}
 void D()
{
   H();
}