On 2025-06-18 14:59:42 +0000, olcott said:

On 6/17/2025 6:24 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.
(recursive simulation is similar to infinite recursion).

The same thing equally applies to these two, yet they may
be  too difficult for a first year CS student.

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;
 }

*Fully operational code*
https://github.com/plolcott/x86utm/blob/master/Halt7.c

I am only asking whether or not people here can understand
that when each of the above functions are correctly simulated
by simulating termination analyzer HHH that they would never
stop running unless aborted. *Please start with the first three*

They are not required to understand that. Some may understand anyway.

--
Mikko

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 2025-06-17 23:24:45 +0000, olcott said:

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.
(recursive simulation is similar to infinite recursion).

The same thing equally applies to these two, yet they may
be too difficult for a first year CS student.

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;
}

*Fully operational code* https://github.com/plolcott/x86utm/blob/master/Halt7.c

Your "fully operational code" uses non-standard extensions to
C language. It does not work and cannot be made to work in an
environment where it is not possible to read the machine code
of a function as data.

--
Mikko

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 2025-06-18 23:04:28 +0000, olcott said:

On 6/18/2025 5:23 PM, Chris M. Thomasson wrote:

On 6/18/2025 8:11 AM, Bonita Montero wrote:
[...]

Ask in comp.theory, here your posting is wrong.

You are in the rabbit hole? Jump out!

Asking about the behavior of a C function in a C group
is not wrong. I could not get a straight answer to this
question in comp.theory for three years. That is the only
reason why I am here.

I don't need any more than the behavior of the posted
C functions.

It might help if your subject line were about C programs or C language.

--
Mikko

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 2025-06-18 15:40:12 +0000, olcott said:

On 6/18/2025 10:11 AM, Bonita Montero wrote:

Am 18.06.2025 um 16:59 schrieb olcott:

On 6/17/2025 6:24 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.
(recursive simulation is similar to infinite recursion).

The same thing equally applies to these two, yet they may
be  too difficult for a first year CS student.

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;
  }

*Fully operational code*
https://github.com/plolcott/x86utm/blob/master/Halt7.c

I am only asking whether or not people here can understand
that when each of the above functions are correctly simulated
by simulating termination analyzer HHH that they would never
stop running unless aborted. *Please start with the first three*

Ask in comp.theory, here your posting is wrong.

Asking about the behavior of a C function in a C group
is not wrong.

It is if essential aspects of the bhaviour depend on non-standard
extensions to C.

Nobody is going to answer about a complex program. The way to ask about
a complex program is to ask the same question about a simple program.

--
Mikko

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

XPost: comp.lang.c++

On 2025-06-19, olcott <polcott333@gmail.com> wrote:

On 6/19/2025 1:55 PM, Bonita Montero wrote:

Am 19.06.2025 um 20:32 schrieb olcott:

On 6/19/2025 1:20 PM, Bonita Montero wrote:

Am 19.06.2025 um 19:07 schrieb olcott:
That's not ad hominem. Anyone who asks the same question
thousands of times in a forum is mentally ill.

Not when one understands the importance of the question.
The importance of the question is off-topic for this
group.

You really need a doctor.

If that was true then you could point to an actual
error in my work.

If that wasn't true, you would /believe/ it when someone pointed
out an actual error in your work. I've not seen evidence that
you are prepared to receive such a report in good faith.

That has been done numerous times by different people; unfortunately,
you refuse to believe or understand it.

For instance, it came to light a few years ago that you don't understand
the traces of your own x86 program; what conclusions they allow and what conclusions they don't allow.

You are confused by situations in which multiple self-similar dynamic
contexts have to be identified as separate and unrelated.

(Analogy: someone who doesn't understand function call semantics
won't understand that a recursive function has multiple simultaneous activations, with different instances of local variables and parameters, possibly holding different values. This is not you, but your confusion
along this vein in matters related to halting. You conflate different
instances of the same function with different parameters as being
the same one, and such. These are rookie mistakes that computer
scientists wash themselves of before finishing undergrad.)

--
TXR Programming Language: http://nongnu.org/txr
Cygnal: Cygwin Native Application Library: http://kylheku.com/cygnal
Mastodon: @Kazinator@mstdn.ca

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)