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
Am 18.06.2025 um 01:24 schrieb olcott:
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
Youre off-topic. That's not comp.theory here.
On 6/17/2025 9:49 PM, Bonita Montero wrote:
Am 18.06.2025 um 01:24 schrieb olcott:
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
Youre off-topic. That's not comp.theory here.
I am *ONLY* talking about the C/C++ programming
aspects of this. ..
Am 18.06.2025 um 06:04 schrieb olcott:
On 6/17/2025 9:49 PM, Bonita Montero wrote:
Am 18.06.2025 um 01:24 schrieb olcott:
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
Youre off-topic. That's not comp.theory here.
I am *ONLY* talking about the C/C++ programming
aspects of this. ..
Absolutely not, that's generic to any language.
On 6/18/2025 6:57 AM, Bonita Montero wrote:
Am 18.06.2025 um 06:04 schrieb olcott:
On 6/17/2025 9:49 PM, Bonita Montero wrote:
Am 18.06.2025 um 01:24 schrieb olcott:
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
Youre off-topic. That's not comp.theory here.
I am *ONLY* talking about the C/C++ programming
aspects of this. ..
Absolutely not, that's generic to any language.
I am talking about the (C/C++) computer programming aspects
of this. I am not taking about the computer science aspects
of this. People on comp.theory don't have the programming
skill to understand this.
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
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*
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.
Ask in comp.theory, here your posting is wrong.
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!
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
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*
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.
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.
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.
I don't need any more than the behavior of the posted
C functions.
Am 19.06.2025 um 01:04 schrieb olcott:
I don't need any more than the behavior of the posted
C functions.
Your question is generic to any language.
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.
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.
On 6/19/2025 1:57 AM, Mikko wrote:
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).
Is the above understood to be true?
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.
It could be done with a c interpreter.
On 6/19/2025 8:25 AM, Bonita Montero wrote:
Am 19.06.2025 um 01:04 schrieb olcott:
I don't need any more than the behavior of the posted
C functions.
Your question is generic to any language.
*Non-the-less I still need the answer*
You could just give me this answer,
(its very simple and won't take ten minutes)
or as they have done on comp.theory spend three
years and thousands of messages dodging the question.
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.
Can you affirm or correctly refute this?
*No one has ever been able to refute this in three years*
*Fully operational code* https://github.com/plolcott/x86utm/blob/master/Halt7.c
Am 19.06.2025 um 16:38 schrieb olcott:
On 6/19/2025 8:25 AM, Bonita Montero wrote:
Am 19.06.2025 um 01:04 schrieb olcott:
I don't need any more than the behavior of the posted
C functions.
Your question is generic to any language.
*Non-the-less I still need the answer*
You could just give me this answer,
(its very simple and won't take ten minutes)
or as they have done on comp.theory spend three
years and thousands of messages dodging the question.
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.
Can you affirm or correctly refute this?
*No one has ever been able to refute this in three years*
*Fully operational code*
https://github.com/plolcott/x86utm/blob/master/Halt7.c
You deal with a simple question for decades.
That's crazy.
On 6/19/2025 11:47 AM, Bonita Montero wrote:
Am 19.06.2025 um 16:38 schrieb olcott:
On 6/19/2025 8:25 AM, Bonita Montero wrote:
Am 19.06.2025 um 01:04 schrieb olcott:
I don't need any more than the behavior of the posted
C functions.
Your question is generic to any language.
*Non-the-less I still need the answer*
You could just give me this answer,
(its very simple and won't take ten minutes)
or as they have done on comp.theory spend three
years and thousands of messages dodging the question.
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.
Can you affirm or correctly refute this?
*No one has ever been able to refute this in three years*
*Fully operational code*
https://github.com/plolcott/x86utm/blob/master/Halt7.c
You deal with a simple question for decades.
That's crazy.
It is a very important simple question, yet the
reason why it is very important is outside of
the scope of this group.
You can spend hundreds of posts saying why you
won't answer the question or one post and ten
minutes answering it.
The people on comp.theory spent thousands of
posts and three years saying why they won't
answer it. That is the *only* reason why I
am here.
Am 19.06.2025 um 19:00 schrieb olcott:
On 6/19/2025 11:47 AM, Bonita Montero wrote:
Am 19.06.2025 um 16:38 schrieb olcott:
On 6/19/2025 8:25 AM, Bonita Montero wrote:
Am 19.06.2025 um 01:04 schrieb olcott:
I don't need any more than the behavior of the posted
C functions.
Your question is generic to any language.
*Non-the-less I still need the answer*
You could just give me this answer,
(its very simple and won't take ten minutes)
or as they have done on comp.theory spend three
years and thousands of messages dodging the question.
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.
Can you affirm or correctly refute this?
*No one has ever been able to refute this in three years*
*Fully operational code*
https://github.com/plolcott/x86utm/blob/master/Halt7.c
You deal with a simple question for decades.
That's crazy.
It is a very important simple question, yet the
reason why it is very important is outside of
the scope of this group.
You can spend hundreds of posts saying why you
won't answer the question or one post and ten
minutes answering it.
The people on comp.theory spent thousands of
posts and three years saying why they won't
answer it. That is the *only* reason why I
am here.
You need a psychiatrist
On 6/19/2025 12:02 PM, Bonita Montero wrote:
Am 19.06.2025 um 19:00 schrieb olcott:
On 6/19/2025 11:47 AM, Bonita Montero wrote:
Am 19.06.2025 um 16:38 schrieb olcott:
On 6/19/2025 8:25 AM, Bonita Montero wrote:
Am 19.06.2025 um 01:04 schrieb olcott:
I don't need any more than the behavior of the posted
C functions.
Your question is generic to any language.
*Non-the-less I still need the answer*
You could just give me this answer,
(its very simple and won't take ten minutes)
or as they have done on comp.theory spend three
years and thousands of messages dodging the question.
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.
Can you affirm or correctly refute this?
*No one has ever been able to refute this in three years*
*Fully operational code*
https://github.com/plolcott/x86utm/blob/master/Halt7.c
You deal with a simple question for decades.
That's crazy.
It is a very important simple question, yet the
reason why it is very important is outside of
the scope of this group.
You can spend hundreds of posts saying why you
won't answer the question or one post and ten
minutes answering it.
The people on comp.theory spent thousands of
posts and three years saying why they won't
answer it. That is the *only* reason why I
am here.
You need a psychiatrist
Ad hominem does not count as a rebuttal and makes
you look foolish.
Am 19.06.2025 um 19:07 schrieb olcott:
On 6/19/2025 12:02 PM, Bonita Montero wrote:
Am 19.06.2025 um 19:00 schrieb olcott:
On 6/19/2025 11:47 AM, Bonita Montero wrote:
Am 19.06.2025 um 16:38 schrieb olcott:
On 6/19/2025 8:25 AM, Bonita Montero wrote:
Am 19.06.2025 um 01:04 schrieb olcott:
I don't need any more than the behavior of the posted
C functions.
Your question is generic to any language.
*Non-the-less I still need the answer*
You could just give me this answer,
(its very simple and won't take ten minutes)
or as they have done on comp.theory spend three
years and thousands of messages dodging the question.
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.
Can you affirm or correctly refute this?
*No one has ever been able to refute this in three years*
*Fully operational code*
https://github.com/plolcott/x86utm/blob/master/Halt7.c
You deal with a simple question for decades.
That's crazy.
It is a very important simple question, yet the
reason why it is very important is outside of
the scope of this group.
You can spend hundreds of posts saying why you
won't answer the question or one post and ten
minutes answering it.
The people on comp.theory spent thousands of
posts and three years saying why they won't
answer it. That is the *only* reason why I
am here.
You need a psychiatrist
Ad hominem does not count as a rebuttal and makes
you look foolish.
That's not ad hominem. Anyone who asks the same question
thousands of times in a forum is mentally ill.
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.
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.
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.
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.)
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.
| Sysop: | Tetrazocine |
|---|---|
| Location: | Melbourne, VIC, Australia |
| Users: | 8 |
| Nodes: | 8 (0 / 8) |
| Uptime: | 101:54:08 |
| Calls: | 161 |
| Files: | 21,502 |
| Messages: | 78,549 |