void DDD()
{
HHH(DDD);
return;
}
When I challenge anyone to show the details of exactly
how DDD correctly simulated by ANY simulating termination
analyzer HHH can possibly reach its own simulated "return"
statement final halt state they ignore this challenge.
THAT FACT THAT NOT ONE PERSON HAS MET THIS CHALLENGE
IN SEVERAL YEARS IS VERY STRONG EVIDENCE THAT I AM CORRECT.
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
DDD is a simplified version of DD.
On 6/15/2025 6:44 PM, Richard Damon wrote:
On 6/15/25 4:10 PM, olcott wrote:
void DDD()
{
HHH(DDD);
return;
}
When I challenge anyone to show the details of exactly
how DDD correctly simulated by ANY simulating termination
analyzer HHH can possibly reach its own simulated "return"
statement final halt state they ignore this challenge.
And it seems you don't understand that the problem is that while, yes,
if HHH does infact do a correct simulation, it will not reach a final
state, that fact only applie *IF* HHH does that, and all the other HHHs
which differ see different inputs.
*I should have said*
When one or more instructions of DDD are correctly
simulated by ANY simulating termination analyzer HHH
then DDD never reaches its simulated "return" statement
final halt state.
On 6/16/2025 6:37 AM, Mikko wrote:
On 2025-06-16 00:57:42 +0000, olcott said:
On 6/15/2025 6:44 PM, Richard Damon wrote:
On 6/15/25 4:10 PM, olcott wrote:
void DDD()
{
HHH(DDD);
return;
}
When I challenge anyone to show the details of exactly
how DDD correctly simulated by ANY simulating termination
analyzer HHH can possibly reach its own simulated "return"
statement final halt state they ignore this challenge.
And it seems you don't understand that the problem is that while,
yes, if HHH does infact do a correct simulation, it will not reach a
final state, that fact only applie *IF* HHH does that, and all the
other HHHs which differ see different inputs.
*I should have said*
No, that is not how you should have said.
When one or more instructions of DDD are correctly
simulated by ANY simulating termination analyzer HHH
then DDD never reaches its simulated "return" statement
final halt state.
How does ANY simulating termination analyzer HHH differ form some
other simulating termination alalyzer?
I changed the evaluation from the HHH that I have coded
to every HHH that could possibly exist.
On 6/16/2025 6:37 AM, Mikko wrote:
On 2025-06-16 00:57:42 +0000, olcott said:
On 6/15/2025 6:44 PM, Richard Damon wrote:
On 6/15/25 4:10 PM, olcott wrote:
void DDD()
{
HHH(DDD);
return;
}
When I challenge anyone to show the details of exactly
how DDD correctly simulated by ANY simulating termination
analyzer HHH can possibly reach its own simulated "return"
statement final halt state they ignore this challenge.
And it seems you don't understand that the problem is that while, yes, >>>> if HHH does infact do a correct simulation, it will not reach a final
state, that fact only applie *IF* HHH does that, and all the other HHHs >>>> which differ see different inputs.
*I should have said*
No, that is not how you should have said.
When one or more instructions of DDD are correctly
simulated by ANY simulating termination analyzer HHH
then DDD never reaches its simulated "return" statement
final halt state.
How does ANY simulating termination analyzer HHH differ form some
other simulating termination alalyzer?
I changed the evaluation from the HHH that I have coded
to every HHH that could possibly exist.
On 6/17/2025 4:33 AM, Fred. Zwarts wrote:
Op 16.jun.2025 om 19:01 schreef olcott:
On 6/16/2025 6:37 AM, Mikko wrote:
On 2025-06-16 00:57:42 +0000, olcott said:
On 6/15/2025 6:44 PM, Richard Damon wrote:
On 6/15/25 4:10 PM, olcott wrote:
void DDD()
{
HHH(DDD);
return;
}
When I challenge anyone to show the details of exactly
how DDD correctly simulated by ANY simulating termination
analyzer HHH can possibly reach its own simulated "return"
statement final halt state they ignore this challenge.
And it seems you don't understand that the problem is that while,
yes, if HHH does infact do a correct simulation, it will not reach >>>>>> a final state, that fact only applie *IF* HHH does that, and all
the other HHHs which differ see different inputs.
*I should have said*
No, that is not how you should have said.
When one or more instructions of DDD are correctly
simulated by ANY simulating termination analyzer HHH
then DDD never reaches its simulated "return" statement
final halt state.
How does ANY simulating termination analyzer HHH differ form some
other simulating termination alalyzer?
I changed the evaluation from the HHH that I have coded
to every HHH that could possibly exist.
And even a beginner can see that they all fail to reach the end of the
simulation, even though the input is a pointer to code that includes
the code to abort and halt.
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.
On 6/17/2025 5:09 AM, Mikko wrote:
On 2025-06-16 17:01:08 +0000, olcott said:
On 6/16/2025 6:37 AM, Mikko wrote:
On 2025-06-16 00:57:42 +0000, olcott said:
On 6/15/2025 6:44 PM, Richard Damon wrote:
On 6/15/25 4:10 PM, olcott wrote:
void DDD()
{
HHH(DDD);
return;
}
When I challenge anyone to show the details of exactly
how DDD correctly simulated by ANY simulating termination
analyzer HHH can possibly reach its own simulated "return"
statement final halt state they ignore this challenge.
And it seems you don't understand that the problem is that while, yes, >>>>>> if HHH does infact do a correct simulation, it will not reach a final >>>>>> state, that fact only applie *IF* HHH does that, and all the other HHHs >>>>>> which differ see different inputs.
*I should have said*
No, that is not how you should have said.
When one or more instructions of DDD are correctly
simulated by ANY simulating termination analyzer HHH
then DDD never reaches its simulated "return" statement
final halt state.
How does ANY simulating termination analyzer HHH differ form some
other simulating termination alalyzer?
I changed the evaluation from the HHH that I have coded
to every HHH that could possibly exist.
Tnat means that you think the program
int HHH((void *)x(void)) {
return 1;
}
when called with HHH(DDD) would return 0
void DDD()
{
HHH(DDD);
return;
}
to indicate that DDD does not halt?
Your HHH is not s simulating termination analyzer as required:
On 6/17/2025 4:33 AM, Fred. Zwarts wrote:And they will also understand that the simulating HHH does not need to
Op 16.jun.2025 om 19:01 schreef olcott:
On 6/16/2025 6:37 AM, Mikko wrote:
On 2025-06-16 00:57:42 +0000, olcott said:
On 6/15/2025 6:44 PM, Richard Damon wrote:
On 6/15/25 4:10 PM, olcott wrote:
void DDD()
{
HHH(DDD);
return;
}
When I challenge anyone to show the details of exactly
how DDD correctly simulated by ANY simulating termination
analyzer HHH can possibly reach its own simulated "return"
statement final halt state they ignore this challenge.
And it seems you don't understand that the problem is that while,
yes, if HHH does infact do a correct simulation, it will not reach >>>>>> a final state, that fact only applie *IF* HHH does that, and all
the other HHHs which differ see different inputs.
*I should have said*
No, that is not how you should have said.
When one or more instructions of DDD are correctly
simulated by ANY simulating termination analyzer HHH
then DDD never reaches its simulated "return" statement
final halt state.
How does ANY simulating termination analyzer HHH differ form some
other simulating termination alalyzer?
I changed the evaluation from the HHH that I have coded
to every HHH that could possibly exist.
And even a beginner can see that they all fail to reach the end of the
simulation, even though the input is a pointer to code that includes
the code to abort and halt.
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.
On 6/17/2025 4:33 AM, Fred. Zwarts wrote:
Op 16.jun.2025 om 19:01 schreef olcott:
On 6/16/2025 6:37 AM, Mikko wrote:
On 2025-06-16 00:57:42 +0000, olcott said:
On 6/15/2025 6:44 PM, Richard Damon wrote:
On 6/15/25 4:10 PM, olcott wrote:
void DDD()
{
HHH(DDD);
return;
}
When I challenge anyone to show the details of exactly
how DDD correctly simulated by ANY simulating termination
analyzer HHH can possibly reach its own simulated "return"
statement final halt state they ignore this challenge.
And it seems you don't understand that the problem is that while,
yes, if HHH does infact do a correct simulation, it will not reach >>>>>> a final state, that fact only applie *IF* HHH does that, and all
the other HHHs which differ see different inputs.
*I should have said*
No, that is not how you should have said.
When one or more instructions of DDD are correctly
simulated by ANY simulating termination analyzer HHH
then DDD never reaches its simulated "return" statement
final halt state.
How does ANY simulating termination analyzer HHH differ form some
other simulating termination alalyzer?
I changed the evaluation from the HHH that I have coded
to every HHH that could possibly exist.
And even a beginner can see that they all fail to reach the end of the
simulation, even though the input is a pointer to code that includes
the code to abort and halt.
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.
On 6/17/2025 8:27 PM, Richard Damon wrote:
On 6/17/25 10:46 AM, olcott wrote:
On 6/17/2025 4:33 AM, Fred. Zwarts wrote:
Op 16.jun.2025 om 19:01 schreef olcott:
On 6/16/2025 6:37 AM, Mikko wrote:
On 2025-06-16 00:57:42 +0000, olcott said:
On 6/15/2025 6:44 PM, Richard Damon wrote:
On 6/15/25 4:10 PM, olcott wrote:
void DDD()
{
HHH(DDD);
return;
}
When I challenge anyone to show the details of exactly
how DDD correctly simulated by ANY simulating termination
analyzer HHH can possibly reach its own simulated "return"
statement final halt state they ignore this challenge.
And it seems you don't understand that the problem is that
while, yes, if HHH does infact do a correct simulation, it will >>>>>>>> not reach a final state, that fact only applie *IF* HHH does
that, and all the other HHHs which differ see different inputs. >>>>>>>>
*I should have said*
No, that is not how you should have said.
When one or more instructions of DDD are correctly
simulated by ANY simulating termination analyzer HHH
then DDD never reaches its simulated "return" statement
final halt state.
How does ANY simulating termination analyzer HHH differ form some
other simulating termination alalyzer?
I changed the evaluation from the HHH that I have coded
to every HHH that could possibly exist.
And even a beginner can see that they all fail to reach the end of
the simulation, even though the input is a pointer to code that
includes the code to abort and halt.
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.
No, they understand that a pattern seen is a halting program (since
you admit that DDD halts when run directly) can't be a pattern that
proves the program is non-halting.
You changed the subject from THIS EXACT POINT
*none of them ever stop running unless aborted*
(a) YES that is true
(b) No that is not true
Here are the exact steps of how X stops running
without every being aborted.
It seems you think that you can proves false statements.
In other words, you logic lies.
I am not the one that perpetually changes the subject
to avoid addressing the actual point.
On 6/17/2025 8:27 PM, Richard Damon wrote:
On 6/17/25 10:46 AM, olcott wrote:
On 6/17/2025 4:33 AM, Fred. Zwarts wrote:
Op 16.jun.2025 om 19:01 schreef olcott:
On 6/16/2025 6:37 AM, Mikko wrote:
On 2025-06-16 00:57:42 +0000, olcott said:
On 6/15/2025 6:44 PM, Richard Damon wrote:
On 6/15/25 4:10 PM, olcott wrote:
void DDD()
{
HHH(DDD);
return;
}
When I challenge anyone to show the details of exactly
how DDD correctly simulated by ANY simulating termination
analyzer HHH can possibly reach its own simulated "return"
statement final halt state they ignore this challenge.
And it seems you don't understand that the problem is that while, yes, >>>>>>>> if HHH does infact do a correct simulation, it will not reach a final >>>>>>>> state, that fact only applie *IF* HHH does that, and all the other HHHs
which differ see different inputs.
*I should have said*
No, that is not how you should have said.
When one or more instructions of DDD are correctly
simulated by ANY simulating termination analyzer HHH
then DDD never reaches its simulated "return" statement
final halt state.
How does ANY simulating termination analyzer HHH differ form some
other simulating termination alalyzer?
I changed the evaluation from the HHH that I have coded
to every HHH that could possibly exist.
And even a beginner can see that they all fail to reach the end of the >>>> simulation, even though the input is a pointer to code that includes
the code to abort and halt.
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.
No, they understand that a pattern seen is a halting program (since you
admit that DDD halts when run directly) can't be a pattern that proves
the program is non-halting.
You changed the subject from THIS EXACT POINT
*none of them ever stop running unless aborted*
(a) YES that is true
(b) No that is not true
On 6/19/2025 3:21 AM, Mikko wrote:
On 2025-06-18 15:07:14 +0000, olcott said:
On 6/17/2025 8:27 PM, Richard Damon wrote:
On 6/17/25 10:46 AM, olcott wrote:
On 6/17/2025 4:33 AM, Fred. Zwarts wrote:
Op 16.jun.2025 om 19:01 schreef olcott:
On 6/16/2025 6:37 AM, Mikko wrote:
On 2025-06-16 00:57:42 +0000, olcott said:
On 6/15/2025 6:44 PM, Richard Damon wrote:
On 6/15/25 4:10 PM, olcott wrote:
void DDD()
{
HHH(DDD);
return;
}
When I challenge anyone to show the details of exactly
how DDD correctly simulated by ANY simulating termination >>>>>>>>>>> analyzer HHH can possibly reach its own simulated "return" >>>>>>>>>>> statement final halt state they ignore this challenge.
And it seems you don't understand that the problem is that >>>>>>>>>> while, yes, if HHH does infact do a correct simulation, it >>>>>>>>>> will not reach a final state, that fact only applie *IF* HHH >>>>>>>>>> does that, and all the other HHHs which differ see different >>>>>>>>>> inputs.
*I should have said*
No, that is not how you should have said.
When one or more instructions of DDD are correctly
simulated by ANY simulating termination analyzer HHH
then DDD never reaches its simulated "return" statement
final halt state.
How does ANY simulating termination analyzer HHH differ form some >>>>>>>> other simulating termination alalyzer?
I changed the evaluation from the HHH that I have coded
to every HHH that could possibly exist.
And even a beginner can see that they all fail to reach the end of >>>>>> the simulation, even though the input is a pointer to code that
includes the code to abort and halt.
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.
No, they understand that a pattern seen is a halting program (since
you admit that DDD halts when run directly) can't be a pattern that
proves the program is non-halting.
You changed the subject from THIS EXACT POINT
*none of them ever stop running unless aborted*
(a) YES that is true
(b) No that is not true
No, he did not. The paragraph responded to was about first year CS
students and what know, and so is the response.
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?
On 6/19/2025 3:21 AM, Mikko wrote:
On 2025-06-18 15:07:14 +0000, olcott said:
On 6/17/2025 8:27 PM, Richard Damon wrote:
On 6/17/25 10:46 AM, olcott wrote:
On 6/17/2025 4:33 AM, Fred. Zwarts wrote:
Op 16.jun.2025 om 19:01 schreef olcott:
On 6/16/2025 6:37 AM, Mikko wrote:
On 2025-06-16 00:57:42 +0000, olcott said:
On 6/15/2025 6:44 PM, Richard Damon wrote:
On 6/15/25 4:10 PM, olcott wrote:
void DDD()
{
HHH(DDD);
return;
}
When I challenge anyone to show the details of exactly
how DDD correctly simulated by ANY simulating termination >>>>>>>>>>> analyzer HHH can possibly reach its own simulated "return" >>>>>>>>>>> statement final halt state they ignore this challenge.
And it seems you don't understand that the problem is that while, yes,
if HHH does infact do a correct simulation, it will not reach a final
state, that fact only applie *IF* HHH does that, and all the other HHHs
which differ see different inputs.
*I should have said*
No, that is not how you should have said.
When one or more instructions of DDD are correctly
simulated by ANY simulating termination analyzer HHH
then DDD never reaches its simulated "return" statement
final halt state.
How does ANY simulating termination analyzer HHH differ form some >>>>>>>> other simulating termination alalyzer?
I changed the evaluation from the HHH that I have coded
to every HHH that could possibly exist.
And even a beginner can see that they all fail to reach the end of the >>>>>> simulation, even though the input is a pointer to code that includes >>>>>> the code to abort and halt.
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.
No, they understand that a pattern seen is a halting program (since you >>>> admit that DDD halts when run directly) can't be a pattern that proves >>>> the program is non-halting.
You changed the subject from THIS EXACT POINT
*none of them ever stop running unless aborted*
(a) YES that is true
(b) No that is not true
No, he did not. The paragraph responded to was about first year CS
students and what know, and so is the response.
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?
On 6/20/2025 4:42 AM, Fred. Zwarts wrote:It was an agreement.
Op 19.jun.2025 om 17:23 schreef olcott:
On 6/19/2025 3:55 AM, Fred. Zwarts wrote:
Op 18.jun.2025 om 17:41 schreef olcott:
On 6/18/2025 4:36 AM, Fred. Zwarts wrote:
Op 17.jun.2025 om 16:36 schreef olcott:
Indeed, HHH fails to reach the end of the simulation, even thoughThat is counter-factual and over-your-head.
the end is only one cycle further from the point where it gave up
the simulation.
Lol, that was the same paragraph.Yes this is factual.No evidence presented for this claim. Dreaming again?
Even a beginner understands that when HHH has code to abort and halt,
the simulated HHH runs one cycle behind the simulating HHH, so that
when the simulating HHH aborts, the simulated HHH is only one cycle
away from the same point.
Proving that you do not understand what unreachable code is.
Even a beginner understands that when HHH has code to abort and halt,
the simulated HHH runs one cycle behind the simulating HHH, so that
when the simulating HHH aborts, the simulated HHH is only one cycle
away from the same point.
Every simulated HHH remains one cycle behind its simulator no matter howYes, no simulator can proceed past a call to itself.
deep the recursive simulations go. This means that the outermost
directly executed HHH reaches its abort criteria first.
This means that none of simulated HHH have reached their abort criteria.Or rather, it hasn't been reached yet. It is already unreachable *for HHH*
This means that their own abort code is unreachable at the point where
the outermost HHH would abort.
This.The failure to reach that point of the simulation is a property of the
simulator, not of the program specified in the input.
On 6/20/2025 10:27 AM, joes wrote:
Am Fri, 20 Jun 2025 09:53:41 -0500 schrieb olcott:
On 6/20/2025 4:42 AM, Fred. Zwarts wrote:It was an agreement.
Op 19.jun.2025 om 17:23 schreef olcott:
On 6/19/2025 3:55 AM, Fred. Zwarts wrote:
Op 18.jun.2025 om 17:41 schreef olcott:
On 6/18/2025 4:36 AM, Fred. Zwarts wrote:
Op 17.jun.2025 om 16:36 schreef olcott:
Indeed, HHH fails to reach the end of the simulation, even though >>>>>>>> the end is only one cycle further from the point where it gave up >>>>>>>> the simulation.That is counter-factual and over-your-head.
Lol, that was the same paragraph.Yes this is factual.No evidence presented for this claim. Dreaming again?
Even a beginner understands that when HHH has code to abort and halt, >>>>>> the simulated HHH runs one cycle behind the simulating HHH, so that >>>>>> when the simulating HHH aborts, the simulated HHH is only one cycle >>>>>> away from the same point.
Proving that you do not understand what unreachable code is.
Even a beginner understands that when HHH has code to abort and halt,
the simulated HHH runs one cycle behind the simulating HHH, so that
when the simulating HHH aborts, the simulated HHH is only one cycle
away from the same point.
Every simulated HHH remains one cycle behind its simulator no matter how >>> deep the recursive simulations go. This means that the outermostYes, no simulator can proceed past a call to itself.
directly executed HHH reaches its abort criteria first.
That is counter-factual and it you knew c well
enough you could verify that is counter-factual. https://github.com/plolcott/x86utm/blob/master/Halt7.c
This means that none of simulated HHH have reached their abort criteria. >>> This means that their own abort code is unreachable at the point where
the outermost HHH would abort.
Or rather, it hasn't been reached yet.
void Infinite_Loop()
{
HERE: goto HERE;
return;
}
Like Infinite_Loop() has not reached its "return" statement yet.
It is already unreachable *for HHH*
when it starts simulating. It is not unreachable when DDD is run
directly,
or simulated by anything else that simulates the one cycle more until
the next inner HHH aborts, so clearly HHH is faulty.
This.The failure to reach that point of the simulation is a property of the >>>> simulator, not of the program specified in the input.
On 6/20/2025 3:35 AM, Mikko wrote:
On 2025-06-19 15:25:45 +0000, olcott said:
On 6/19/2025 3:21 AM, Mikko wrote:
On 2025-06-18 15:07:14 +0000, olcott said:
On 6/17/2025 8:27 PM, Richard Damon wrote:
On 6/17/25 10:46 AM, olcott wrote:
On 6/17/2025 4:33 AM, Fred. Zwarts wrote:
Op 16.jun.2025 om 19:01 schreef olcott:
On 6/16/2025 6:37 AM, Mikko wrote:
On 2025-06-16 00:57:42 +0000, olcott said:
On 6/15/2025 6:44 PM, Richard Damon wrote:
On 6/15/25 4:10 PM, olcott wrote:
void DDD()And it seems you don't understand that the problem is that while, yes,
{
HHH(DDD);
return;
}
When I challenge anyone to show the details of exactly >>>>>>>>>>>>> how DDD correctly simulated by ANY simulating termination >>>>>>>>>>>>> analyzer HHH can possibly reach its own simulated "return" >>>>>>>>>>>>> statement final halt state they ignore this challenge. >>>>>>>>>>>>
if HHH does infact do a correct simulation, it will not reach a final
state, that fact only applie *IF* HHH does that, and all the other HHHs
which differ see different inputs.
*I should have said*
No, that is not how you should have said.
When one or more instructions of DDD are correctly
simulated by ANY simulating termination analyzer HHH
then DDD never reaches its simulated "return" statement
final halt state.
How does ANY simulating termination analyzer HHH differ form some >>>>>>>>>> other simulating termination alalyzer?
I changed the evaluation from the HHH that I have coded
to every HHH that could possibly exist.
And even a beginner can see that they all fail to reach the end of the >>>>>>>> simulation, even though the input is a pointer to code that includes >>>>>>>> the code to abort and halt.
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.
No, they understand that a pattern seen is a halting program (since you >>>>>> admit that DDD halts when run directly) can't be a pattern that proves >>>>>> the program is non-halting.
You changed the subject from THIS EXACT POINT
*none of them ever stop running unless aborted*
(a) YES that is true
(b) No that is not true
No, he did not. The paragraph responded to was about first year CS
students and what know, and so is the response.
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?
Now you are changed the topic.
That is what I said (less clearly) all along.
On 6/21/2025 5:00 AM, Mikko wrote:
On 2025-06-20 17:11:30 +0000, olcott said:
On 6/20/2025 3:35 AM, Mikko wrote:
On 2025-06-19 15:25:45 +0000, olcott said:
On 6/19/2025 3:21 AM, Mikko wrote:
On 2025-06-18 15:07:14 +0000, olcott said:
On 6/17/2025 8:27 PM, Richard Damon wrote:
On 6/17/25 10:46 AM, olcott wrote:
On 6/17/2025 4:33 AM, Fred. Zwarts wrote:
Op 16.jun.2025 om 19:01 schreef olcott:
On 6/16/2025 6:37 AM, Mikko wrote:
On 2025-06-16 00:57:42 +0000, olcott said:
On 6/15/2025 6:44 PM, Richard Damon wrote:
On 6/15/25 4:10 PM, olcott wrote:
void DDD()And it seems you don't understand that the problem is that >>>>>>>>>>>>>> while, yes, if HHH does infact do a correct simulation, it >>>>>>>>>>>>>> will not reach a final state, that fact only applie *IF* >>>>>>>>>>>>>> HHH does that, and all the other HHHs which differ see >>>>>>>>>>>>>> different inputs.
{
HHH(DDD);
return;
}
When I challenge anyone to show the details of exactly >>>>>>>>>>>>>>> how DDD correctly simulated by ANY simulating termination >>>>>>>>>>>>>>> analyzer HHH can possibly reach its own simulated "return" >>>>>>>>>>>>>>> statement final halt state they ignore this challenge. >>>>>>>>>>>>>>
*I should have said*
No, that is not how you should have said.
When one or more instructions of DDD are correctly
simulated by ANY simulating termination analyzer HHH >>>>>>>>>>>>> then DDD never reaches its simulated "return" statement >>>>>>>>>>>>> final halt state.
How does ANY simulating termination analyzer HHH differ form >>>>>>>>>>>> some
other simulating termination alalyzer?
I changed the evaluation from the HHH that I have coded
to every HHH that could possibly exist.
And even a beginner can see that they all fail to reach the >>>>>>>>>> end of the simulation, even though the input is a pointer to >>>>>>>>>> code that includes the code to abort and halt.
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.
No, they understand that a pattern seen is a halting program
(since you admit that DDD halts when run directly) can't be a
pattern that proves the program is non-halting.
You changed the subject from THIS EXACT POINT
*none of them ever stop running unless aborted*
(a) YES that is true
(b) No that is not true
No, he did not. The paragraph responded to was about first year CS >>>>>> students and what know, and so is the response.
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?
Now you are changed the topic.
That is what I said (less clearly) all along.
No, you accused that it was someone else. But that does not matter
anymore as you now admit that you did it.
I have been saying the exact same thing for at least
three years and have been merely making my words more
clear.
On 6/21/2025 5:00 AM, Mikko wrote:
On 2025-06-20 17:11:30 +0000, olcott said:
On 6/20/2025 3:35 AM, Mikko wrote:
On 2025-06-19 15:25:45 +0000, olcott said:
On 6/19/2025 3:21 AM, Mikko wrote:
On 2025-06-18 15:07:14 +0000, olcott said:
On 6/17/2025 8:27 PM, Richard Damon wrote:
On 6/17/25 10:46 AM, olcott wrote:
On 6/17/2025 4:33 AM, Fred. Zwarts wrote:
Op 16.jun.2025 om 19:01 schreef olcott:
On 6/16/2025 6:37 AM, Mikko wrote:
On 2025-06-16 00:57:42 +0000, olcott said:
On 6/15/2025 6:44 PM, Richard Damon wrote:
On 6/15/25 4:10 PM, olcott wrote:
void DDD()And it seems you don't understand that the problem is that while, yes,
{
HHH(DDD);
return;
}
When I challenge anyone to show the details of exactly >>>>>>>>>>>>>>> how DDD correctly simulated by ANY simulating termination >>>>>>>>>>>>>>> analyzer HHH can possibly reach its own simulated "return" >>>>>>>>>>>>>>> statement final halt state they ignore this challenge. >>>>>>>>>>>>>>
if HHH does infact do a correct simulation, it will not reach a final
state, that fact only applie *IF* HHH does that, and all the other HHHs
which differ see different inputs.
*I should have said*
No, that is not how you should have said.
When one or more instructions of DDD are correctly
simulated by ANY simulating termination analyzer HHH >>>>>>>>>>>>> then DDD never reaches its simulated "return" statement >>>>>>>>>>>>> final halt state.
How does ANY simulating termination analyzer HHH differ form some >>>>>>>>>>>> other simulating termination alalyzer?
I changed the evaluation from the HHH that I have coded
to every HHH that could possibly exist.
And even a beginner can see that they all fail to reach the end of the
simulation, even though the input is a pointer to code that includes >>>>>>>>>> the code to abort and halt.
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.
No, they understand that a pattern seen is a halting program (since you
admit that DDD halts when run directly) can't be a pattern that proves >>>>>>>> the program is non-halting.
You changed the subject from THIS EXACT POINT
*none of them ever stop running unless aborted*
(a) YES that is true
(b) No that is not true
No, he did not. The paragraph responded to was about first year CS >>>>>> students and what know, and so is the response.
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?
Now you are changed the topic.
That is what I said (less clearly) all along.
No, you accused that it was someone else. But that does not matter
anymore as you now admit that you did it.
I have been saying the exact same thing for at least
three years and have been merely making my words more
clear.
On 6/22/2025 4:25 AM, Mikko 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.
Can you affirm or correctly refute this?
Anyway, it was you who changed the topic and then falsely
accused someone else.
In other words you find my latest words irrefutable
so you dodge addressing them.
Op 22.jun.2025 om 21:27 schreef olcott:
On 6/22/2025 11:01 AM, Fred. Zwarts wrote:Another claim without any evidence.
Op 20.jun.2025 om 16:53 schreef olcott:
On 6/20/2025 4:42 AM, Fred. Zwarts wrote:
Op 19.jun.2025 om 17:23 schreef olcott:
On 6/19/2025 3:55 AM, Fred. Zwarts wrote:
Op 18.jun.2025 om 17:41 schreef olcott:
On 6/18/2025 4:36 AM, Fred. Zwarts wrote:
Op 17.jun.2025 om 16:36 schreef olcott:
On 6/17/2025 4:28 AM, Fred. Zwarts wrote:
Op 17.jun.2025 om 00:26 schreef olcott:
On 6/16/2025 3:53 AM, Fred. Zwarts wrote:
Op 15.jun.2025 om 22:10 schreef olcott:
void DDD()It seems very difficult for you to read.
{
HHH(DDD);
return;
}
When I challenge anyone to show the details of exactly >>>>>>>>>>>>>> how DDD correctly simulated by ANY simulating termination >>>>>>>>>>>>>> analyzer HHH can possibly reach its own simulated "return" >>>>>>>>>>>>>> statement final halt state they ignore this challenge. >>>>>>>>>>>>>
We clearly stated that the challenge is improper.
Are you too stupid to understand that dogmatic
assertions that are utterly bereft of any supporting
reasoning DO NOT COUNT AS REBUTTALS ???
No, you are too stupid to realise that challenging for a recipe to draw
a square circle does not count as a proof that square circles exist.
Claiming that I made a mistake with no ability to
show this mistake is DISHONEST.
Indeed, but irrelevant,
That alternative is that you are dishonest.
When you claim that I am wrong and have
no ability to show how and where I am wrong
this would seem to make you a liar.
No one has ever even attempted to show the details
of how this is not correct:
void DDD()
{
HHH(DDD);
return;
}
When one or more instructions of DDD are correctly
simulated by ANY simulating termination analyzer HHH
then this correctly simulated DDD never reaches its
simulated "return" statement final halt state.
Indeed, HHH fails to reach the end of the simulation, even though the >>>>>>>>> end is only one cycle further from the point where it gave up the >>>>>>>>> simulation.
That is counter-factual and over-your-head.
No evidence presented for this claim. Dreaming again?
Even a beginner understands that when HHH has code to abort and halt, >>>>>>> the simulated HHH runs one cycle behind the simulating HHH, so that >>>>>>> when the simulating HHH aborts, the simulated HHH is only one cycle >>>>>>> away from the same point.
Proving that you do not understand what unreachable code is.
First year CS students and EE majors may not understand this.
All CS graduates would understand this.
That you do not understand what I write makes it difficult for you to >>>>> learn from your errors.
It is not that difficult. Try again and pay full attention to it.
Even a beginner understands that when HHH has code to abort and halt, >>>>> the simulated HHH runs one cycle behind the simulating HHH, so that
when the simulating HHH aborts, the simulated HHH is only one cycle
away from the same point.
Yes this is factual.
*This is only ordinary computer programming with*
*no theory of computation computer science required*
Every simulated HHH remains one cycle behind its simulator
no matter how deep the recursive simulations go. This means
that the outermost directly executed HHH reaches its abort
criteria first.
And it fails to see that the simulated HHH would reach exactly the same
abort criteria one cycle later.
In this way, it misses the fact that it is simulating an HHH that would
abort and halt.
void Infinite_Loop()
{
HERE: goto HERE;
printf("Fred Zwarts can't understand this is never reached\n");
}
Olcott does not understand that his HHH does not see an infinite loop.
On 6/24/2025 2:58 AM, Mikko wrote:
printf("Fred Zwarts can't understand this is never reached\n");
On 6/24/2025 2:54 AM, Fred. Zwarts wrote:
Op 23.jun.2025 om 16:50 schreef olcott:
On 6/23/2025 3:24 AM, Fred. Zwarts wrote:
Op 22.jun.2025 om 21:27 schreef olcott:
On 6/22/2025 11:01 AM, Fred. Zwarts wrote:Another claim without any evidence.
Op 20.jun.2025 om 16:53 schreef olcott:
On 6/20/2025 4:42 AM, Fred. Zwarts wrote:
Op 19.jun.2025 om 17:23 schreef olcott:
On 6/19/2025 3:55 AM, Fred. Zwarts wrote:
Op 18.jun.2025 om 17:41 schreef olcott:
On 6/18/2025 4:36 AM, Fred. Zwarts wrote:
Op 17.jun.2025 om 16:36 schreef olcott:
On 6/17/2025 4:28 AM, Fred. Zwarts wrote:
Op 17.jun.2025 om 00:26 schreef olcott:
On 6/16/2025 3:53 AM, Fred. Zwarts wrote:
Op 15.jun.2025 om 22:10 schreef olcott:Are you too stupid to understand that dogmatic
void DDD()It seems very difficult for you to read.
{
HHH(DDD);
return;
}
When I challenge anyone to show the details of exactly >>>>>>>>>>>>>>>>> how DDD correctly simulated by ANY simulating termination >>>>>>>>>>>>>>>>> analyzer HHH can possibly reach its own simulated "return" >>>>>>>>>>>>>>>>> statement final halt state they ignore this challenge. >>>>>>>>>>>>>>>>
We clearly stated that the challenge is improper. >>>>>>>>>>>>>>>
assertions that are utterly bereft of any supporting >>>>>>>>>>>>>>> reasoning DO NOT COUNT AS REBUTTALS ???
No, you are too stupid to realise that challenging for a recipe to draw
a square circle does not count as a proof that square circles exist.
Claiming that I made a mistake with no ability to >>>>>>>>>>>>>>> show this mistake is DISHONEST.
Indeed, but irrelevant,
That alternative is that you are dishonest.
When you claim that I am wrong and have
no ability to show how and where I am wrong
this would seem to make you a liar.
No one has ever even attempted to show the details
of how this is not correct:
void DDD()
{
HHH(DDD);
return;
}
When one or more instructions of DDD are correctly
simulated by ANY simulating termination analyzer HHH >>>>>>>>>>>>> then this correctly simulated DDD never reaches its
simulated "return" statement final halt state.
Indeed, HHH fails to reach the end of the simulation, even though the
end is only one cycle further from the point where it gave up the >>>>>>>>>>>> simulation.
That is counter-factual and over-your-head.
No evidence presented for this claim. Dreaming again?
Even a beginner understands that when HHH has code to abort and halt,
the simulated HHH runs one cycle behind the simulating HHH, so that >>>>>>>>>> when the simulating HHH aborts, the simulated HHH is only one cycle >>>>>>>>>> away from the same point.
Proving that you do not understand what unreachable code is. >>>>>>>>> First year CS students and EE majors may not understand this. >>>>>>>>> All CS graduates would understand this.
That you do not understand what I write makes it difficult for you to >>>>>>>> learn from your errors.
It is not that difficult. Try again and pay full attention to it. >>>>>>>> Even a beginner understands that when HHH has code to abort and halt, >>>>>>>> the simulated HHH runs one cycle behind the simulating HHH, so that >>>>>>>> when the simulating HHH aborts, the simulated HHH is only one cycle >>>>>>>> away from the same point.
Yes this is factual.
*This is only ordinary computer programming with*
*no theory of computation computer science required*
Every simulated HHH remains one cycle behind its simulator
no matter how deep the recursive simulations go. This means
that the outermost directly executed HHH reaches its abort
criteria first.
And it fails to see that the simulated HHH would reach exactly the same >>>>>> abort criteria one cycle later.
In this way, it misses the fact that it is simulating an HHH that would >>>>>> abort and halt.
void Infinite_Loop()
{
HERE: goto HERE;
printf("Fred Zwarts can't understand this is never reached\n"); >>>>> }
Olcott does not understand that his HHH does not see an infinite loop. >>>> It aborts and halt, so the recursion is finite.
You didn't even use the term recursion correctly.
Infinite loops have nothing to do with recursion.
And infinite loops have nothing to do with a simulator simulating
itself. Therefore, talking about infinite loops is changing the subject.
Mike understands that HHH could recognize an infinite
loop correctly.
The process in which a function calls itself directly
or indirectly is called recursion and the corresponding
function is called a recursive function.
https://www.geeksforgeeks.org/introduction-to-recursion-2/
Lines 987 to 992 is where infinite loops are recognized
Lines 996 to 1005 is where infinite recursion is recognized
https://github.com/plolcott/x86utm/blob/master/Halt7.c
HHH correctly emulates the x86 machine code of its
input until one of those two patterns is matched.
But there is a bug in the code that tries to recognise an infinite recursion.
There is no bug. Quit your defamation.
It forgets to count the conditional branch instructions when simulating
the simulator.
*It does not forget them. They are irrelevant*
The question being asked is this:
Can DDD correctly simulated by any termination analyzer
HHH that can possibly exist reach its own "return" statement
final halt state?
On 6/25/2025 1:36 AM, Mikko wrote:
On 2025-06-24 14:45:02 +0000, olcott said:
On 6/24/2025 2:58 AM, Mikko wrote:
printf("Fred Zwarts can't understand this is never reached\n");
Again you are lying. I did not say that. I just quoted what you
had said earlier. Without quoting the context readers might not
understand what I was talking about and what motiviated and
justified my words.
"Fred Zwarts" does not fully understand
what unreachable code is.
On 6/25/2025 1:27 AM, Mikko wrote:
On 2025-06-24 14:06:12 +0000, olcott said:
On 6/24/2025 2:54 AM, Fred. Zwarts wrote:
Op 23.jun.2025 om 16:50 schreef olcott:
On 6/23/2025 3:24 AM, Fred. Zwarts wrote:
Op 22.jun.2025 om 21:27 schreef olcott:
On 6/22/2025 11:01 AM, Fred. Zwarts wrote:Another claim without any evidence.
Op 20.jun.2025 om 16:53 schreef olcott:
On 6/20/2025 4:42 AM, Fred. Zwarts wrote:
Op 19.jun.2025 om 17:23 schreef olcott:
On 6/19/2025 3:55 AM, Fred. Zwarts wrote:
Op 18.jun.2025 om 17:41 schreef olcott:
On 6/18/2025 4:36 AM, Fred. Zwarts wrote:
Op 17.jun.2025 om 16:36 schreef olcott:
On 6/17/2025 4:28 AM, Fred. Zwarts wrote:
Op 17.jun.2025 om 00:26 schreef olcott:
On 6/16/2025 3:53 AM, Fred. Zwarts wrote:
Op 15.jun.2025 om 22:10 schreef olcott:Are you too stupid to understand that dogmatic >>>>>>>>>>>>>>>>> assertions that are utterly bereft of any supporting >>>>>>>>>>>>>>>>> reasoning DO NOT COUNT AS REBUTTALS ???
void DDD()It seems very difficult for you to read.
{
HHH(DDD);
return;
}
When I challenge anyone to show the details of exactly >>>>>>>>>>>>>>>>>>> how DDD correctly simulated by ANY simulating termination >>>>>>>>>>>>>>>>>>> analyzer HHH can possibly reach its own simulated "return" >>>>>>>>>>>>>>>>>>> statement final halt state they ignore this challenge. >>>>>>>>>>>>>>>>>>
We clearly stated that the challenge is improper. >>>>>>>>>>>>>>>>>
No, you are too stupid to realise that challenging for a recipe to draw
a square circle does not count as a proof that square circles exist.
Claiming that I made a mistake with no ability to >>>>>>>>>>>>>>>>> show this mistake is DISHONEST.
Indeed, but irrelevant,
That alternative is that you are dishonest.
When you claim that I am wrong and have
no ability to show how and where I am wrong
this would seem to make you a liar.
No one has ever even attempted to show the details >>>>>>>>>>>>>>> of how this is not correct:
void DDD()
{
HHH(DDD);
return;
}
When one or more instructions of DDD are correctly >>>>>>>>>>>>>>> simulated by ANY simulating termination analyzer HHH >>>>>>>>>>>>>>> then this correctly simulated DDD never reaches its >>>>>>>>>>>>>>> simulated "return" statement final halt state.
Indeed, HHH fails to reach the end of the simulation, even though the
end is only one cycle further from the point where it gave up the
simulation.
That is counter-factual and over-your-head.
No evidence presented for this claim. Dreaming again?
Even a beginner understands that when HHH has code to abort and halt,
the simulated HHH runs one cycle behind the simulating HHH, so that
when the simulating HHH aborts, the simulated HHH is only one cycle
away from the same point.
Proving that you do not understand what unreachable code is. >>>>>>>>>>> First year CS students and EE majors may not understand this. >>>>>>>>>>> All CS graduates would understand this.
That you do not understand what I write makes it difficult for you to
learn from your errors.
It is not that difficult. Try again and pay full attention to it. >>>>>>>>>> Even a beginner understands that when HHH has code to abort and halt,
the simulated HHH runs one cycle behind the simulating HHH, so that >>>>>>>>>> when the simulating HHH aborts, the simulated HHH is only one cycle >>>>>>>>>> away from the same point.
Yes this is factual.
*This is only ordinary computer programming with*
*no theory of computation computer science required*
Every simulated HHH remains one cycle behind its simulator
no matter how deep the recursive simulations go. This means
that the outermost directly executed HHH reaches its abort
criteria first.
And it fails to see that the simulated HHH would reach exactly the same
abort criteria one cycle later.
In this way, it misses the fact that it is simulating an HHH that would
abort and halt.
void Infinite_Loop()
{
HERE: goto HERE;
printf("Fred Zwarts can't understand this is never reached\n"); >>>>>>> }
Olcott does not understand that his HHH does not see an infinite loop. >>>>>> It aborts and halt, so the recursion is finite.
You didn't even use the term recursion correctly.
Infinite loops have nothing to do with recursion.
And infinite loops have nothing to do with a simulator simulating
itself. Therefore, talking about infinite loops is changing the subject. >>>>
Mike understands that HHH could recognize an infinite
loop correctly.
The process in which a function calls itself directly
or indirectly is called recursion and the corresponding
function is called a recursive function.
https://www.geeksforgeeks.org/introduction-to-recursion-2/
Lines 987 to 992 is where infinite loops are recognized
Lines 996 to 1005 is where infinite recursion is recognized
https://github.com/plolcott/x86utm/blob/master/Halt7.c
HHH correctly emulates the x86 machine code of its
input until one of those two patterns is matched.
But there is a bug in the code that tries to recognise an infinite recursion.
There is no bug. Quit your defamation.
It forgets to count the conditional branch instructions when simulating >>>> the simulator.
*It does not forget them. They are irrelevant*
The question being asked is this:
Can DDD correctly simulated by any termination analyzer
HHH that can possibly exist reach its own "return" statement
final halt state?
Why would anyone ask that question or care about the answer?
In computer science the only measure of halting
is reaching a final halt state. Stopping running
for any other reason does not count as halting.
On 6/26/2025 5:20 AM, Mikko wrote:
On 2025-06-25 14:14:07 +0000, olcott said:
On 6/25/2025 1:27 AM, Mikko wrote:
On 2025-06-24 14:06:12 +0000, olcott said:
On 6/24/2025 2:54 AM, Fred. Zwarts wrote:
Op 23.jun.2025 om 16:50 schreef olcott:
On 6/23/2025 3:24 AM, Fred. Zwarts wrote:
Op 22.jun.2025 om 21:27 schreef olcott:
On 6/22/2025 11:01 AM, Fred. Zwarts wrote:Another claim without any evidence.
Op 20.jun.2025 om 16:53 schreef olcott:
On 6/20/2025 4:42 AM, Fred. Zwarts wrote:
Op 19.jun.2025 om 17:23 schreef olcott:
On 6/19/2025 3:55 AM, Fred. Zwarts wrote:
Op 18.jun.2025 om 17:41 schreef olcott:
On 6/18/2025 4:36 AM, Fred. Zwarts wrote:
Op 17.jun.2025 om 16:36 schreef olcott:
On 6/17/2025 4:28 AM, Fred. Zwarts wrote:Indeed, HHH fails to reach the end of the simulation, even though the
Op 17.jun.2025 om 00:26 schreef olcott:
On 6/16/2025 3:53 AM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>> Op 15.jun.2025 om 22:10 schreef olcott: >>>>>>>>>>>>>>>>>>>>> void DDD()
Are you too stupid to understand that dogmatic >>>>>>>>>>>>>>>>>>> assertions that are utterly bereft of any supporting >>>>>>>>>>>>>>>>>>> reasoning DO NOT COUNT AS REBUTTALS ???{It seems very difficult for you to read. >>>>>>>>>>>>>>>>>>>> We clearly stated that the challenge is improper. >>>>>>>>>>>>>>>>>>>
HHH(DDD);
return;
}
When I challenge anyone to show the details of exactly >>>>>>>>>>>>>>>>>>>>> how DDD correctly simulated by ANY simulating termination >>>>>>>>>>>>>>>>>>>>> analyzer HHH can possibly reach its own simulated "return"
statement final halt state they ignore this challenge. >>>>>>>>>>>>>>>>>>>>
No, you are too stupid to realise that challenging for a recipe to draw
a square circle does not count as a proof that square circles exist.
Claiming that I made a mistake with no ability to >>>>>>>>>>>>>>>>>>> show this mistake is DISHONEST.
Indeed, but irrelevant,
That alternative is that you are dishonest.
When you claim that I am wrong and have
no ability to show how and where I am wrong
this would seem to make you a liar.
No one has ever even attempted to show the details >>>>>>>>>>>>>>>>> of how this is not correct:
void DDD()
{
HHH(DDD);
return;
}
When one or more instructions of DDD are correctly >>>>>>>>>>>>>>>>> simulated by ANY simulating termination analyzer HHH >>>>>>>>>>>>>>>>> then this correctly simulated DDD never reaches its >>>>>>>>>>>>>>>>> simulated "return" statement final halt state. >>>>>>>>>>>>>>>>
end is only one cycle further from the point where it gave up the
simulation.
That is counter-factual and over-your-head.
No evidence presented for this claim. Dreaming again? >>>>>>>>>>>>>> Even a beginner understands that when HHH has code to abort and halt,
the simulated HHH runs one cycle behind the simulating HHH, so that
when the simulating HHH aborts, the simulated HHH is only one cycle
away from the same point.
Proving that you do not understand what unreachable code is. >>>>>>>>>>>>> First year CS students and EE majors may not understand this. >>>>>>>>>>>>> All CS graduates would understand this.
That you do not understand what I write makes it difficult for you to
learn from your errors.
It is not that difficult. Try again and pay full attention to it. >>>>>>>>>>>> Even a beginner understands that when HHH has code to abort and halt,
the simulated HHH runs one cycle behind the simulating HHH, so that
when the simulating HHH aborts, the simulated HHH is only one cycle
away from the same point.
Yes this is factual.
*This is only ordinary computer programming with*
*no theory of computation computer science required*
Every simulated HHH remains one cycle behind its simulator >>>>>>>>>>> no matter how deep the recursive simulations go. This means >>>>>>>>>>> that the outermost directly executed HHH reaches its abort >>>>>>>>>>> criteria first.
And it fails to see that the simulated HHH would reach exactly the same
abort criteria one cycle later.
In this way, it misses the fact that it is simulating an HHH that would
abort and halt.
void Infinite_Loop()
{
HERE: goto HERE;
printf("Fred Zwarts can't understand this is never reached\n"); >>>>>>>>> }
Olcott does not understand that his HHH does not see an infinite loop. >>>>>>>> It aborts and halt, so the recursion is finite.
You didn't even use the term recursion correctly.
Infinite loops have nothing to do with recursion.
And infinite loops have nothing to do with a simulator simulating
itself. Therefore, talking about infinite loops is changing the subject. >>>>>>
Mike understands that HHH could recognize an infinite
loop correctly.
The process in which a function calls itself directly
or indirectly is called recursion and the corresponding
function is called a recursive function.
https://www.geeksforgeeks.org/introduction-to-recursion-2/
Lines 987 to 992 is where infinite loops are recognized
Lines 996 to 1005 is where infinite recursion is recognized
https://github.com/plolcott/x86utm/blob/master/Halt7.c
HHH correctly emulates the x86 machine code of its
input until one of those two patterns is matched.
But there is a bug in the code that tries to recognise an infinite recursion.
There is no bug. Quit your defamation.
It forgets to count the conditional branch instructions when simulating >>>>>> the simulator.
*It does not forget them. They are irrelevant*
The question being asked is this:
Can DDD correctly simulated by any termination analyzer
HHH that can possibly exist reach its own "return" statement
final halt state?
Why would anyone ask that question or care about the answer?
In computer science the only measure of halting
is reaching a final halt state. Stopping running
for any other reason does not count as halting.
In computer science the only measure of non-halting is the
possibility to execute an unlimited number of steps without
halting. An execution of a limited number of steps does not
count as non-haltign.
Halting means reaching a final halt state.
On 6/27/2025 1:42 AM, Mikko wrote:Not at all. The measure is unlimited execution. Otherwise smashing your computer with a sledge hammer after 1 second would prove that all
On 2025-06-27 04:21:01 +0000, olcott said:
On 6/26/2025 5:20 AM, Mikko wrote:>>>
In computer science the only measure of non-halting is the
possibility to execute an unlimited number of steps without
halting. An execution of a limited number of steps does not
count as non-haltign.
Halting means reaching a final halt state.
And non-halting means unlimited execution.
Not at all. The measure has always been can't possibly reach
final halt state. If it was not that way then smashing a
computer with a sledge hammer would "prove" that an infinite
loop halts.
On 6/27/2025 1:42 AM, Mikko wrote:
On 2025-06-27 04:21:01 +0000, olcott said:
On 6/26/2025 5:20 AM, Mikko wrote:>>>
In computer science the only measure of non-halting is the
possibility to execute an unlimited number of steps without
halting. An execution of a limited number of steps does not
count as non-haltign.
Halting means reaching a final halt state.
And non-halting means unlimited execution.
Not at all. The measure has always been can't possibly reach
final halt state.
On 6/28/2025 6:56 AM, Mikko wrote:
On 2025-06-27 14:26:41 +0000, olcott said:
On 6/27/2025 1:42 AM, Mikko wrote:
On 2025-06-27 04:21:01 +0000, olcott said:
On 6/26/2025 5:20 AM, Mikko wrote:>>>
In computer science the only measure of non-halting is the
possibility to execute an unlimited number of steps without
halting. An execution of a limited number of steps does not
count as non-haltign.
Halting means reaching a final halt state.
And non-halting means unlimited execution.
Not at all. The measure has always been can't possibly reach
final halt state.
In Post's simplified version, which is the most commonly used one,
a computation halts when there is no applicable rule to specify
the next action.
It is best to use the standard measure of halting
as reaching a final halt state.
If we don't do this then we get psychotic ideas like Richard's that
we cannot know that a computation does not halt until after we
simulate it forever.
On 6/28/2025 3:47 AM, Fred. Zwarts wrote:
Op 27.jun.2025 om 16:26 schreef olcott:
On 6/27/2025 1:42 AM, Mikko wrote:
On 2025-06-27 04:21:01 +0000, olcott said:
On 6/26/2025 5:20 AM, Mikko wrote:>>>
In computer science the only measure of non-halting is the
possibility to execute an unlimited number of steps without
halting. An execution of a limited number of steps does not
count as non-haltign.
Halting means reaching a final halt state.
And non-halting means unlimited execution.
Not at all. The measure has always been can't possibly reach
final halt state. If it was not that way then smashing a
computer with a sledge hammer would "prove" that an infinite
loop halts.
Not at all. The measure is unlimited execution.
counter-factual
On 6/28/2025 3:50 AM, Fred. Zwarts wrote:
Op 28.jun.2025 om 01:30 schreef olcott:
On 6/26/2025 4:16 AM, Fred. Zwarts wrote:As usual irrelevant claims without evidence. No rebuttal.
Op 25.jun.2025 om 16:09 schreef olcott:
On 6/25/2025 2:59 AM, Fred. Zwarts wrote:
Op 24.jun.2025 om 16:06 schreef olcott:
None of the code in HHH can possibly cause DDD correctly
simulated by HHH to reach its own simulated "return" statement.
Yes, exactly, that is the bug.
Recursive emulation is only a tiny bit more complicated
than recursion yet no one here seems to have a clue.
Do you know what recursion is?
(If you don't that would explain a lot)
Ah so you don't know what recursion is.
HHH has a bug that makes that it does not recognise the halting
behaviour of the program specified in the input.
If you don't even know what recursion is then
you are totally unqualified to review these things.
Even a beginner can see that the input is a pointer to code, including
the code to abort and halt. But HHH is programmed to ignore the
conditional branch instructions, when simulating itself, so it thinks
that there is an infinite loop when there are only a finite number of
recursions.
But Olcott does not understand that not all recursions are infinite.
When the measure is whether or not DDD correctly
simulated by HHH can possibly reach its own "return"
instruction final halt state nothing inside HHH can
possibly have any effect on this.
On 6/28/2025 3:47 AM, Fred. Zwarts wrote:
Op 27.jun.2025 om 16:26 schreef olcott:
On 6/27/2025 1:42 AM, Mikko wrote:
On 2025-06-27 04:21:01 +0000, olcott said:
On 6/26/2025 5:20 AM, Mikko wrote:>>>
In computer science the only measure of non-halting is the
possibility to execute an unlimited number of steps without
halting. An execution of a limited number of steps does not
count as non-haltign.
Halting means reaching a final halt state.
And non-halting means unlimited execution.
Not at all. The measure has always been can't possibly reach
final halt state. If it was not that way then smashing a
computer with a sledge hammer would "prove" that an infinite
loop halts.
Not at all. The measure is unlimited execution.
counter-factual
*can't possibly reach final halt state*
even if correctly simulated forever gets
rid of the psychotic requirement to actually
simulate it forever before we know that it
does not halt.
On 6/29/2025 4:10 AM, Mikko wrote:
On 2025-06-28 13:51:21 +0000, olcott said:
On 6/28/2025 6:56 AM, Mikko wrote:
On 2025-06-27 14:26:41 +0000, olcott said:
On 6/27/2025 1:42 AM, Mikko wrote:
On 2025-06-27 04:21:01 +0000, olcott said:
On 6/26/2025 5:20 AM, Mikko wrote:>>>
In computer science the only measure of non-halting is the
possibility to execute an unlimited number of steps without
halting. An execution of a limited number of steps does not
count as non-haltign.
Halting means reaching a final halt state.
And non-halting means unlimited execution.
Not at all. The measure has always been can't possibly reach
final halt state.
In Post's simplified version, which is the most commonly used one,
a computation halts when there is no applicable rule to specify
the next action.
It is best to use the standard measure of halting
as reaching a final halt state.
If you use Turing's original form of Turing maches then it is best to
use Turing's definition of halting. If you are using some usual form
then the usual criterion that halting means inability to contimue.
Otherwise you get the paradox that a computation cannot be continued
but it has not halted, either.
Because no one ever thought of a simulating partial halt
decider (SPHD) before as a partial halt decider (PHD) we
must divide halting from an aborted simulation.
If we don't do this then actual infinite loops will
be misconstrued as halting because their SPHD stopped
simulating them.
On 6/29/2025 5:43 AM, Fred. Zwarts wrote:
Op 28.jun.2025 om 14:42 schreef olcott:
On 6/28/2025 3:47 AM, Fred. Zwarts wrote:
Op 27.jun.2025 om 16:26 schreef olcott:
On 6/27/2025 1:42 AM, Mikko wrote:
On 2025-06-27 04:21:01 +0000, olcott said:
On 6/26/2025 5:20 AM, Mikko wrote:>>>
In computer science the only measure of non-halting is the
possibility to execute an unlimited number of steps without
halting. An execution of a limited number of steps does not
count as non-haltign.
Halting means reaching a final halt state.
And non-halting means unlimited execution.
Not at all. The measure has always been can't possibly reach
final halt state. If it was not that way then smashing a
computer with a sledge hammer would "prove" that an infinite
loop halts.
Not at all. The measure is unlimited execution.
counter-factual
*can't possibly reach final halt state*
even if correctly simulated forever gets
rid of the psychotic requirement to actually
simulate it forever before we know that it
does not halt.
Counter factual. Only in your dreams.
A correct simulation of exactly the same input by world-class
simulators show that this input specifies a halting program.
Therefore, the fact that HHH cannot reach that end is a failure of
HHH, not a property of the input.
There is no need to simulate forever, because the simulation would
halt naturally one cycle later, as proven by direct execution and
world-class simulators.
To think that simulating forever is required is indeed psychotic. No-
one else but Olcott thinks that it is required.
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 you fail to comprehend the self-evident truth of the
above IS NO ACTUAL REBUTTAL WHAT-SO-EVER.
On 6/29/2025 4:01 AM, Mikko wrote:
On 2025-06-28 12:42:07 +0000, olcott said:
On 6/28/2025 3:47 AM, Fred. Zwarts wrote:
Op 27.jun.2025 om 16:26 schreef olcott:
On 6/27/2025 1:42 AM, Mikko wrote:
On 2025-06-27 04:21:01 +0000, olcott said:
On 6/26/2025 5:20 AM, Mikko wrote:>>>
In computer science the only measure of non-halting is the
possibility to execute an unlimited number of steps without
halting. An execution of a limited number of steps does not
count as non-haltign.
Halting means reaching a final halt state.
And non-halting means unlimited execution.
Not at all. The measure has always been can't possibly reach
final halt state. If it was not that way then smashing a
computer with a sledge hammer would "prove" that an infinite
loop halts.
Not at all. The measure is unlimited execution.
counter-factual
If is not a matter of fact but a matter of convention. The only
relevant fact is that what I said really is the convention.
Ultimately by definition a Turing machine only halts
when it reaches its own final halt state.
On 6/29/2025 4:10 AM, Mikko wrote:
On 2025-06-28 13:51:21 +0000, olcott said:
On 6/28/2025 6:56 AM, Mikko wrote:
On 2025-06-27 14:26:41 +0000, olcott said:
On 6/27/2025 1:42 AM, Mikko wrote:
On 2025-06-27 04:21:01 +0000, olcott said:
On 6/26/2025 5:20 AM, Mikko wrote:>>>
In computer science the only measure of non-halting is the
possibility to execute an unlimited number of steps without
halting. An execution of a limited number of steps does not
count as non-haltign.
Halting means reaching a final halt state.
And non-halting means unlimited execution.
Not at all. The measure has always been can't possibly reach
final halt state.
In Post's simplified version, which is the most commonly used one,
a computation halts when there is no applicable rule to specify
the next action.
It is best to use the standard measure of halting
as reaching a final halt state.
If you use Turing's original form of Turing maches then it is best to
use Turing's definition of halting. If you are using some usual form
then the usual criterion that halting means inability to contimue.
Otherwise you get the paradox that a computation cannot be continued
but it has not halted, either.
Because no one ever thought of a simulating partial halt
decider (SPHD) before as a partial halt decider (PHD) we
must divide halting from an aborted simulation.
If we don't do this then actual infinite loops will
be misconstrued as halting because their SPHD stopped
simulating them.
If we don't do this then we get psychotic ideas like Richard's that
we cannot know that a computation does not halt until after we
simulate it forever.
It is a sin to lie about other people.
Anyway, you don't know that a computation does not halt unless you
can prove it. There is no method that can find a proof in all cases
but that doesn't prevent from finding a proof for some non-halting
cases.
This very simple proof seems too difficult for anyone
to understand.
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.
On 6/29/2025 4:14 AM, Mikko wrote:
On 2025-06-28 13:02:02 +0000, olcott said:
On 6/28/2025 3:50 AM, Fred. Zwarts wrote:
Op 28.jun.2025 om 01:30 schreef olcott:
On 6/26/2025 4:16 AM, Fred. Zwarts wrote:As usual irrelevant claims without evidence. No rebuttal.
Op 25.jun.2025 om 16:09 schreef olcott:
On 6/25/2025 2:59 AM, Fred. Zwarts wrote:
Op 24.jun.2025 om 16:06 schreef olcott:
None of the code in HHH can possibly cause DDD correctly
simulated by HHH to reach its own simulated "return" statement.
Yes, exactly, that is the bug.
Recursive emulation is only a tiny bit more complicated
than recursion yet no one here seems to have a clue.
Do you know what recursion is?
(If you don't that would explain a lot)
Ah so you don't know what recursion is.
HHH has a bug that makes that it does not recognise the halting
behaviour of the program specified in the input.
If you don't even know what recursion is then
you are totally unqualified to review these things.
Even a beginner can see that the input is a pointer to code, including >>>> the code to abort and halt. But HHH is programmed to ignore the
conditional branch instructions, when simulating itself, so it thinks
that there is an infinite loop when there are only a finite number of
recursions.
But Olcott does not understand that not all recursions are infinite.
When the measure is whether or not DDD correctly
simulated by HHH can possibly reach its own "return"
instruction final halt state nothing inside HHH can
possibly have any effect on this.
Programs that report about their own behaviour are not useful and
are interesting only if you can derive someting like a paradox.
Because Turing machines cannot possibly ever take
other actual directly executed Turing Machines as
inputs they use the proxy of finite string Turing
Machine descriptions.
The behavior of the correctly simulated input to
a partial halt decider is always the same as the
behavior of the directly executed Turing Machine
except when this input calls its own decider.
| Sysop: | Keyop |
|---|---|
| Location: | Huddersfield, West Yorkshire, UK |
| Users: | 715 |
| Nodes: | 16 (2 / 14) |
| Uptime: | 33:07:17 |
| Calls: | 12,109 |
| Files: | 15,006 |
| Messages: | 6,518,309 |