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.
The same thing 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;
}
On 6/18/2025 5:12 AM, Fred. Zwarts wrote:Huh? They contain the code to abort, even if it is not simulated.
Op 18.jun.2025 om 03:54 schreef olcott:
On 6/17/2025 8:19 PM, Richard Damon wrote:
On 6/17/25 4:34 PM, olcott wrote:
*It is not given that any of them abort**none of them ever stop running unless aborted*When it is understood that HHH does simulate itself simulating DDD
then any first year CS student knows that when each of the above are >>>>> correctly simulated by HHH that none of them ever stop running
unless aborted.
WHich means that the code for HHH is part of the input, and thus
there is just ONE HHH in existance at this time.
Since that code aborts its simulation to return the answer that you
claim, you are just lying that it did a correct simulation (which in
this context means complete)
All of them do abort and their simulation does not need an abort.
On 6/18/2025 9:05 AM, joes wrote:If HHH(DDD), where DDD() only calls HHH(DDD), is simulated by a pure
Am Wed, 18 Jun 2025 08:46:16 -0500 schrieb olcott:*none of them ever stop running unless aborted* yes or no?
On 6/18/2025 5:12 AM, Fred. Zwarts wrote:Huh? They contain the code to abort, even if it is not simulated.
Op 18.jun.2025 om 03:54 schreef olcott:
On 6/17/2025 8:19 PM, Richard Damon wrote:
On 6/17/25 4:34 PM, olcott wrote:
*It is not given that any of them abort**none of them ever stop running unless aborted*When it is understood that HHH does simulate itself simulating DDD >>>>>>> then any first year CS student knows that when each of the above >>>>>>> are correctly simulated by HHH that none of them ever stop running >>>>>>> unless aborted.
WHich means that the code for HHH is part of the input, and thus
there is just ONE HHH in existance at this time.
Since that code aborts its simulation to return the answer that you >>>>>> claim, you are just lying that it did a correct simulation (which
in this context means complete)
All of them do abort and their simulation does not need an abort.
On 6/18/2025 9:05 AM, joes wrote:
Am Wed, 18 Jun 2025 08:46:16 -0500 schrieb olcott:
On 6/18/2025 5:12 AM, Fred. Zwarts wrote:Huh? They contain the code to abort, even if it is not simulated.
Op 18.jun.2025 om 03:54 schreef olcott:
On 6/17/2025 8:19 PM, Richard Damon wrote:
On 6/17/25 4:34 PM, olcott wrote:
*It is not given that any of them abort**none of them ever stop running unless aborted*When it is understood that HHH does simulate itself simulating DDD >>>>>>> then any first year CS student knows that when each of the above are >>>>>>> correctly simulated by HHH that none of them ever stop running
unless aborted.
WHich means that the code for HHH is part of the input, and thus
there is just ONE HHH in existance at this time.
Since that code aborts its simulation to return the answer that you >>>>>> claim, you are just lying that it did a correct simulation (which in >>>>>> this context means complete)
All of them do abort and their simulation does not need an abort.
*none of them ever stop running unless aborted* yes or no?
The favorite fake rebuttal of changing the subject
will not be tolerated.
On Wed, 18 Jun 2025 08:53:07 -0500, olcott wrote:
On 6/18/2025 6:01 AM, Richard Damon wrote:
On 6/17/25 9:54 PM, olcott wrote:
On 6/17/2025 8:19 PM, Richard Damon wrote:How about the fact that if they abort, they never did a correct
On 6/17/25 4:34 PM, olcott wrote:*none of them ever stop running unless aborted* *none of them ever
void Infinite_Recursion()
{
Infinite_Recursion();
return;
}
void Infinite_Loop()
{
HERE: goto HERE; return;
}
void DDD()
{
HHH(DDD);
return;
}
When it is understood that HHH does simulate itself simulating DDD >>>>>> then any first year CS student knows that when each of the above are >>>>>> correctly simulated by HHH that none of them ever stop running
unless aborted.
WHich means that the code for HHH is part of the input, and thus
there is just ONE HHH in existance at this time.
Since that code aborts its simulation to return the answer that you
claim, you are just lying that it did a correct simulation (which in >>>>> this context means complete)
stop running unless aborted* *none of them ever stop running unless
aborted*
Do you agree or can you refute THIS EXACT POINT?
Do you agree or can you refute THIS EXACT POINT?
Do you agree or can you refute THIS EXACT POINT?
simulation,
*You are not addressing THE EXACT POINT*
*When HHH never aborts any of the above functions then*
(a) None of the functions ever stops running.
(b) Each of the above functions stops running anyway.
You need to be clear that you are not making a claim about general undecidability but a claim about the SPECIFIC CASE of pathological self reference present in the classic Halting Problem definition .. the trolls here (especially Damon and Mikko) like to ignore that you are doing that.
On 6/18/2025 5:12 AM, Fred. Zwarts wrote:
Op 18.jun.2025 om 03:54 schreef olcott:
On 6/17/2025 8:19 PM, Richard Damon wrote:
On 6/17/25 4:34 PM, olcott wrote:
void Infinite_Recursion()
{
Infinite_Recursion();
return;
}
void Infinite_Loop()
{
HERE: goto HERE;
return;
}
void DDD()
{
HHH(DDD);
return;
}
When it is understood that HHH does simulate itself
simulating DDD then any first year CS student knows
that when each of the above are correctly simulated
by HHH that none of them ever stop running unless aborted.
WHich means that the code for HHH is part of the input, and thus there >>>> is just ONE HHH in existance at this time.
Since that code aborts its simulation to return the answer that you
claim, you are just lying that it did a correct simulation (which in
this context means complete)
*none of them ever stop running unless aborted*
All of them do abort and their simulation does not need an abort.
*It is not given that any of them abort*
void Infinite_Recursion()
{
Infinite_Recursion();
return;
}
void Infinite_Loop()
{
HERE: goto HERE;
return;
}
void DDD()
{
HHH(DDD);
return;
}
On 6/19/2025 1:17 AM, Mikko wrote:
On 2025-06-18 13:46:16 +0000, olcott said:
On 6/18/2025 5:12 AM, Fred. Zwarts wrote:
Op 18.jun.2025 om 03:54 schreef olcott:
On 6/17/2025 8:19 PM, Richard Damon wrote:
On 6/17/25 4:34 PM, olcott wrote:
void Infinite_Recursion()
{
Infinite_Recursion();
return;
}
void Infinite_Loop()
{
HERE: goto HERE;
return;
}
void DDD()
{
HHH(DDD);
return;
}
When it is understood that HHH does simulate itself
simulating DDD then any first year CS student knows
that when each of the above are correctly simulated
by HHH that none of them ever stop running unless aborted.
WHich means that the code for HHH is part of the input, and thus
there is just ONE HHH in existance at this time.
Since that code aborts its simulation to return the answer that
you claim, you are just lying that it did a correct simulation
(which in this context means complete)
*none of them ever stop running unless aborted*
All of them do abort and their simulation does not need an abort.
*It is not given that any of them abort*
It is known a priori that HHH either does or does not abort.
Very good.
If HHH does
not abort it does not terminate the simulation of DDD and therefore
DDD never stops running.
does
not report correctly. If HHH does abort it reports that DDD does not
halt, which is incorrect as in that case DDD does halt. HHH is correct
about DDD only if it does abort its simulation and reports "halts".
But you HHH does not do that.
On 6/19/2025 1:50 AM, Mikko wrote:
On 2025-06-17 20:34:11 +0000, olcott said:
void Infinite_Recursion()
{
Infinite_Recursion();
return;
}
void Infinite_Loop()
{
HERE: goto HERE;
return;
}
void DDD()
{
HHH(DDD);
return;
}
Considering the scope of termination analysis the above examples are
extremely simple. The first two are easily seen as non-terminating.
The third example is incomplete as HHH is not given.
*HHH is a simulating termination analyzer*
It simulates its input until it detects
a non halting behavior pattern, then it
aborts and rejects its input.
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/19/2025 1:17 AM, Mikko wrote:
On 2025-06-18 13:46:16 +0000, olcott said:
On 6/18/2025 5:12 AM, Fred. Zwarts wrote:
Op 18.jun.2025 om 03:54 schreef olcott:
On 6/17/2025 8:19 PM, Richard Damon wrote:
On 6/17/25 4:34 PM, olcott wrote:
void Infinite_Recursion()
{
Infinite_Recursion();
return;
}
void Infinite_Loop()
{
HERE: goto HERE;
return;
}
void DDD()
{
HHH(DDD);
return;
}
When it is understood that HHH does simulate itself
simulating DDD then any first year CS student knows
that when each of the above are correctly simulated
by HHH that none of them ever stop running unless aborted.
WHich means that the code for HHH is part of the input, and thus
there is just ONE HHH in existance at this time.
Since that code aborts its simulation to return the answer that
you claim, you are just lying that it did a correct simulation
(which in this context means complete)
*none of them ever stop running unless aborted*
All of them do abort and their simulation does not need an abort.
*It is not given that any of them abort*
It is known a priori that HHH either does or does not abort.
Very good.
If HHH does
not abort it does not terminate the simulation of DDD and therefore
DDD never stops running.
does
not report correctly. If HHH does abort it reports that DDD does not
halt, which is incorrect as in that case DDD does halt. HHH is correct
about DDD only if it does abort its simulation and reports "halts".
But you HHH does not do that.
Op 19.jun.2025 om 08:59 schreef olcott:
On 6/19/2025 1:17 AM, Mikko wrote:
On 2025-06-18 13:46:16 +0000, olcott said:
On 6/18/2025 5:12 AM, Fred. Zwarts wrote:
Op 18.jun.2025 om 03:54 schreef olcott:
On 6/17/2025 8:19 PM, Richard Damon wrote:
On 6/17/25 4:34 PM, olcott wrote:
void Infinite_Recursion()
{
Infinite_Recursion();
return;
}
void Infinite_Loop()
{
HERE: goto HERE;
return;
}
void DDD()
{
HHH(DDD);
return;
}
When it is understood that HHH does simulate itself
simulating DDD then any first year CS student knows
that when each of the above are correctly simulated
by HHH that none of them ever stop running unless aborted.
WHich means that the code for HHH is part of the input, and thus there >>>>>>> is just ONE HHH in existance at this time.
Since that code aborts its simulation to return the answer that you >>>>>>> claim, you are just lying that it did a correct simulation (which in >>>>>>> this context means complete)
*none of them ever stop running unless aborted*
All of them do abort and their simulation does not need an abort.
*It is not given that any of them abort*
It is known a priori that HHH either does or does not abort.
Very good.
If HHH does
not abort it does not terminate the simulation of DDD and therefore
DDD never stops running.
because HHH never stops running and therefore this HHH
does
not report correctly. If HHH does abort it reports that DDD does not
halt, which is incorrect as in that case DDD does halt. HHH is correct
about DDD only if it does abort its simulation and reports "halts".
But you HHH does not do that.
So, both the aborting and the non-aborting HHH do not provide a correct report.
On 6/19/2025 1:39 AM, Mikko wrote:
On 2025-06-18 18:28:43 +0000, Mr Flibble said:
On Wed, 18 Jun 2025 08:53:07 -0500, olcott wrote:He is not doing even that. What he is doing is totally outside of the
On 6/18/2025 6:01 AM, Richard Damon wrote:
On 6/17/25 9:54 PM, olcott wrote:
On 6/17/2025 8:19 PM, Richard Damon wrote:How about the fact that if they abort, they never did a correct
On 6/17/25 4:34 PM, olcott wrote:*none of them ever stop running unless aborted* *none of them ever >>>>>> stop running unless aborted* *none of them ever stop running unless >>>>>> aborted*
void Infinite_Recursion()
{
Infinite_Recursion();
return;
}
void Infinite_Loop()
{
HERE: goto HERE; return;
}
void DDD()
{
HHH(DDD);
return;
}
When it is understood that HHH does simulate itself simulating DDD >>>>>>>> then any first year CS student knows that when each of the above are >>>>>>>> correctly simulated by HHH that none of them ever stop running >>>>>>>> unless aborted.
WHich means that the code for HHH is part of the input, and thus >>>>>>> there is just ONE HHH in existance at this time.
Since that code aborts its simulation to return the answer that you >>>>>>> claim, you are just lying that it did a correct simulation (which in >>>>>>> this context means complete)
Do you agree or can you refute THIS EXACT POINT?
Do you agree or can you refute THIS EXACT POINT?
Do you agree or can you refute THIS EXACT POINT?
simulation,
*You are not addressing THE EXACT POINT*
*When HHH never aborts any of the above functions then*
(a) None of the functions ever stops running.
(b) Each of the above functions stops running anyway.
You need to be clear that you are not making a claim about general
undecidability but a claim about the SPECIFIC CASE of pathological self
reference present in the classic Halting Problem definition .. the trolls >>> here (especially Damon and Mikko) like to ignore that you are doing that. >>
scope of the halting problem. He has already verified that DDD halts
and that HHH does not report that DDD halts. Nothing else is relevant
in context of the halting problem.
If his intent is to deceive he should avoid clarity at least as much
as he has recently done. His switch from "halting decider" to
"termination analyzer"
is a more accurate term for what I am referring to.
On 6/19/2025 4:09 AM, Fred. Zwarts wrote:
Op 19.jun.2025 om 08:59 schreef olcott:
On 6/19/2025 1:17 AM, Mikko wrote:
On 2025-06-18 13:46:16 +0000, olcott said:
On 6/18/2025 5:12 AM, Fred. Zwarts wrote:
Op 18.jun.2025 om 03:54 schreef olcott:
On 6/17/2025 8:19 PM, Richard Damon wrote:
On 6/17/25 4:34 PM, olcott wrote:
void Infinite_Recursion()
{
Infinite_Recursion();
return;
}
void Infinite_Loop()
{
HERE: goto HERE;
return;
}
void DDD()
{
HHH(DDD);
return;
}
When it is understood that HHH does simulate itself
simulating DDD then any first year CS student knows
that when each of the above are correctly simulated
by HHH that none of them ever stop running unless aborted.
WHich means that the code for HHH is part of the input, and thus >>>>>>>> there is just ONE HHH in existance at this time.
Since that code aborts its simulation to return the answer that >>>>>>>> you claim, you are just lying that it did a correct simulation >>>>>>>> (which in this context means complete)
*none of them ever stop running unless aborted*
All of them do abort and their simulation does not need an abort.
*It is not given that any of them abort*
It is known a priori that HHH either does or does not abort.
Very good.
If HHH does
not abort it does not terminate the simulation of DDD and therefore
DDD never stops running.
because HHH never stops running and therefore this HHH
So you agree that when HHH never aborts that none
of the above three functions ever stop running?
does
not report correctly. If HHH does abort it reports that DDD does not
halt, which is incorrect as in that case DDD does halt. HHH is correct >>>> about DDD only if it does abort its simulation and reports "halts".
But you HHH does not do that.
So, both the aborting and the non-aborting HHH do not provide a
correct report.
I am not yet talking about any reports.
I am only talking about:
(a) stops running
(b) never stop running.
On 6/20/2025 3:45 AM, Mikko wrote:
On 2025-06-19 09:09:34 +0000, Fred. Zwarts said:
Op 19.jun.2025 om 08:59 schreef olcott:
On 6/19/2025 1:17 AM, Mikko wrote:
On 2025-06-18 13:46:16 +0000, olcott said:
On 6/18/2025 5:12 AM, Fred. Zwarts wrote:
Op 18.jun.2025 om 03:54 schreef olcott:
On 6/17/2025 8:19 PM, Richard Damon wrote:
On 6/17/25 4:34 PM, olcott wrote:
void Infinite_Recursion()
{
Infinite_Recursion();
return;
}
void Infinite_Loop()
{
HERE: goto HERE;
return;
}
void DDD()
{
HHH(DDD);
return;
}
When it is understood that HHH does simulate itself
simulating DDD then any first year CS student knows
that when each of the above are correctly simulated
by HHH that none of them ever stop running unless aborted.
WHich means that the code for HHH is part of the input, and
thus there is just ONE HHH in existance at this time.
Since that code aborts its simulation to return the answer that >>>>>>>>> you claim, you are just lying that it did a correct simulation >>>>>>>>> (which in this context means complete)
*none of them ever stop running unless aborted*
All of them do abort and their simulation does not need an abort. >>>>>>>
*It is not given that any of them abort*
It is known a priori that HHH either does or does not abort.
Very good.
If HHH does
not abort it does not terminate the simulation of DDD and therefore
DDD never stops running.
because HHH never stops running and therefore this HHH
does
not report correctly. If HHH does abort it reports that DDD does not >>>>> halt, which is incorrect as in that case DDD does halt. HHH is correct >>>>> about DDD only if it does abort its simulation and reports "halts".
But you HHH does not do that.
So, both the aborting and the non-aborting HHH do not provide a
correct report.
My HHH, if given DDD for input, does abort and does give the correct
report
but gives the worng report if given DD.
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 3:45 AM, Mikko wrote:
On 2025-06-19 09:09:34 +0000, Fred. Zwarts said:
Op 19.jun.2025 om 08:59 schreef olcott:
On 6/19/2025 1:17 AM, Mikko wrote:
On 2025-06-18 13:46:16 +0000, olcott said:
On 6/18/2025 5:12 AM, Fred. Zwarts wrote:
Op 18.jun.2025 om 03:54 schreef olcott:
On 6/17/2025 8:19 PM, Richard Damon wrote:
On 6/17/25 4:34 PM, olcott wrote:
void Infinite_Recursion()
{
Infinite_Recursion();
return;
}
void Infinite_Loop()
{
HERE: goto HERE;
return;
}
void DDD()
{
HHH(DDD);
return;
}
When it is understood that HHH does simulate itself
simulating DDD then any first year CS student knows
that when each of the above are correctly simulated
by HHH that none of them ever stop running unless aborted.
WHich means that the code for HHH is part of the input, and thus there
is just ONE HHH in existance at this time.
Since that code aborts its simulation to return the answer that you >>>>>>>>> claim, you are just lying that it did a correct simulation (which in >>>>>>>>> this context means complete)
*none of them ever stop running unless aborted*
All of them do abort and their simulation does not need an abort. >>>>>>>
*It is not given that any of them abort*
It is known a priori that HHH either does or does not abort.
Very good.
If HHH does
not abort it does not terminate the simulation of DDD and therefore
DDD never stops running.
because HHH never stops running and therefore this HHH
does
not report correctly. If HHH does abort it reports that DDD does not >>>>> halt, which is incorrect as in that case DDD does halt. HHH is correct >>>>> about DDD only if it does abort its simulation and reports "halts".
But you HHH does not do that.
So, both the aborting and the non-aborting HHH do not provide a correct report.
My HHH, if given DDD for input, does abort and does give the correct report >> but gives the worng report if given DD.
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:20 AM, Fred. Zwarts wrote:
Op 19.jun.2025 om 17:17 schreef olcott:
On 6/19/2025 4:21 AM, Fred. Zwarts wrote:
Op 18.jun.2025 om 15:46 schreef olcott:
On 6/18/2025 5:12 AM, Fred. Zwarts wrote:
Op 18.jun.2025 om 03:54 schreef olcott:
On 6/17/2025 8:19 PM, Richard Damon wrote:
On 6/17/25 4:34 PM, olcott wrote:
void Infinite_Recursion()
{
Infinite_Recursion();
return;
}
void Infinite_Loop()
{
HERE: goto HERE;
return;
}
void DDD()
{
HHH(DDD);
return;
}
When it is understood that HHH does simulate itself
simulating DDD then any first year CS student knows
that when each of the above are correctly simulated
by HHH that none of them ever stop running unless aborted.
WHich means that the code for HHH is part of the input, and thus there >>>>>>>> is just ONE HHH in existance at this time.
Since that code aborts its simulation to return the answer that you >>>>>>>> claim, you are just lying that it did a correct simulation (which in >>>>>>>> this context means complete)
*none of them ever stop running unless aborted*
All of them do abort and their simulation does not need an abort.
*It is not given that any of them abort*
At least it is true for all aborting ones, such as the one you
presented in Halt7.c.
My claim is that each of the above functions correctly
simulated by any termination analyzer HHH that can possibly
exist will never stop running unless aborted by HHH.
Can you affirm or correctly refute this?
Yes, I confirmed many times that we can confirm this vacuous claim,
because no such HHH exists. All of them fail to do a correct simulation
up to the point where they can see whether the input specifies a
halting program.
if DDD correctly simulated by any simulating termination
analyzer HHH never aborts its simulation of DDD then
On 6/20/2025 3:51 AM, Mikko wrote:
On 2025-06-19 07:02:27 +0000, olcott said:
On 6/19/2025 1:39 AM, Mikko wrote:
On 2025-06-18 18:28:43 +0000, Mr Flibble said:
On Wed, 18 Jun 2025 08:53:07 -0500, olcott wrote:He is not doing even that. What he is doing is totally outside of the
On 6/18/2025 6:01 AM, Richard Damon wrote:
On 6/17/25 9:54 PM, olcott wrote:
On 6/17/2025 8:19 PM, Richard Damon wrote:How about the fact that if they abort, they never did a correct
On 6/17/25 4:34 PM, olcott wrote:*none of them ever stop running unless aborted* *none of them ever >>>>>>>> stop running unless aborted* *none of them ever stop running unless >>>>>>>> aborted*
void Infinite_Recursion()
{
Infinite_Recursion();
return;
}
void Infinite_Loop()
{
HERE: goto HERE; return;
}
void DDD()
{
HHH(DDD);
return;
}
When it is understood that HHH does simulate itself simulating DDD >>>>>>>>>> then any first year CS student knows that when each of the above are >>>>>>>>>> correctly simulated by HHH that none of them ever stop running >>>>>>>>>> unless aborted.
WHich means that the code for HHH is part of the input, and thus >>>>>>>>> there is just ONE HHH in existance at this time.
Since that code aborts its simulation to return the answer that you >>>>>>>>> claim, you are just lying that it did a correct simulation (which in >>>>>>>>> this context means complete)
Do you agree or can you refute THIS EXACT POINT?
Do you agree or can you refute THIS EXACT POINT?
Do you agree or can you refute THIS EXACT POINT?
simulation,
*You are not addressing THE EXACT POINT*
*When HHH never aborts any of the above functions then*
(a) None of the functions ever stops running.
(b) Each of the above functions stops running anyway.
You need to be clear that you are not making a claim about general
undecidability but a claim about the SPECIFIC CASE of pathological self >>>>> reference present in the classic Halting Problem definition .. the trolls >>>>> here (especially Damon and Mikko) like to ignore that you are doing that. >>>>
scope of the halting problem. He has already verified that DDD halts
and that HHH does not report that DDD halts. Nothing else is relevant
in context of the halting problem.
If his intent is to deceive he should avoid clarity at least as much
as he has recently done. His switch from "halting decider" to
"termination analyzer"
is a more accurate term for what I am referring to.
Not really as you are only talking about programs that do not take
any input. Termination analysis is about programs that do take input.
Inputs are typical yet not required.
On 6/21/2025 4:46 AM, Mikko wrote:
On 2025-06-20 17:12:30 +0000, olcott said:
On 6/20/2025 3:45 AM, Mikko wrote:
On 2025-06-19 09:09:34 +0000, Fred. Zwarts said:
Op 19.jun.2025 om 08:59 schreef olcott:
On 6/19/2025 1:17 AM, Mikko wrote:
On 2025-06-18 13:46:16 +0000, olcott said:
On 6/18/2025 5:12 AM, Fred. Zwarts wrote:
Op 18.jun.2025 om 03:54 schreef olcott:
On 6/17/2025 8:19 PM, Richard Damon wrote:
On 6/17/25 4:34 PM, olcott wrote:
void Infinite_Recursion()WHich means that the code for HHH is part of the input, and >>>>>>>>>>> thus there is just ONE HHH in existance at this time.
{
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. >>>>>>>>>>>
Since that code aborts its simulation to return the answer >>>>>>>>>>> that you claim, you are just lying that it did a correct >>>>>>>>>>> simulation (which in this context means complete)
*none of them ever stop running unless aborted*
All of them do abort and their simulation does not need an abort. >>>>>>>>>
*It is not given that any of them abort*
It is known a priori that HHH either does or does not abort.
Very good.
If HHH doesDDD never stops running.
not abort it does not terminate the simulation of DDD and therefore >>>>>>
because HHH never stops running and therefore this HHH
does
not report correctly. If HHH does abort it reports that DDD does not >>>>>>> halt, which is incorrect as in that case DDD does halt. HHH is
correct
about DDD only if it does abort its simulation and reports "halts". >>>>>>> But you HHH does not do that.
So, both the aborting and the non-aborting HHH do not provide a
correct report.
My HHH, if given DDD for input, does abort and does give the correct
report
but gives the worng report if given DD.
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, because that is not well claimed. You have used "HHH" in at least
two different meanings and it is not clear which meaning is intended.
*clearer words*
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/21/2025 4:52 AM, Mikko wrote:
On 2025-06-20 13:59:02 +0000, olcott said:
On 6/20/2025 4:20 AM, Fred. Zwarts wrote:
Op 19.jun.2025 om 17:17 schreef olcott:
On 6/19/2025 4:21 AM, Fred. Zwarts wrote:
Op 18.jun.2025 om 15:46 schreef olcott:
On 6/18/2025 5:12 AM, Fred. Zwarts wrote:
Op 18.jun.2025 om 03:54 schreef olcott:
On 6/17/2025 8:19 PM, Richard Damon wrote:
On 6/17/25 4:34 PM, olcott wrote:
void Infinite_Recursion()WHich means that the code for HHH is part of the input, and >>>>>>>>>> thus there is just ONE HHH in existance at this time.
{
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. >>>>>>>>>>
Since that code aborts its simulation to return the answer >>>>>>>>>> that you claim, you are just lying that it did a correct
simulation (which in this context means complete)
*none of them ever stop running unless aborted*
All of them do abort and their simulation does not need an abort. >>>>>>>>
*It is not given that any of them abort*
At least it is true for all aborting ones, such as the one you
presented in Halt7.c.
My claim is that each of the above functions correctly
simulated by any termination analyzer HHH that can possibly
exist will never stop running unless aborted by HHH.
Can you affirm or correctly refute this?
Yes, I confirmed many times that we can confirm this vacuous claim,
because no such HHH exists. All of them fail to do a correct
simulation up to the point where they can see whether the input
specifies a halting program.
if DDD correctly simulated by any simulating termination
analyzer HHH never aborts its simulation of DDD then
that HHH is not interesting.
*then the HP proofs are proved to be wrong*
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
On 6/21/2025 4:54 AM, Mikko wrote:
On 2025-06-20 17:17:40 +0000, olcott said:
On 6/20/2025 3:51 AM, Mikko wrote:
On 2025-06-19 07:02:27 +0000, olcott said:
On 6/19/2025 1:39 AM, Mikko wrote:
On 2025-06-18 18:28:43 +0000, Mr Flibble said:
On Wed, 18 Jun 2025 08:53:07 -0500, olcott wrote:
On 6/18/2025 6:01 AM, Richard Damon wrote:
On 6/17/25 9:54 PM, olcott wrote:
On 6/17/2025 8:19 PM, Richard Damon wrote:How about the fact that if they abort, they never did a correct >>>>>>>>> simulation,
On 6/17/25 4:34 PM, olcott wrote:*none of them ever stop running unless aborted* *none of them >>>>>>>>>> ever
void Infinite_Recursion()
{
Infinite_Recursion();
return;
}
void Infinite_Loop()
{
HERE: goto HERE; return;
}
void DDD()
{
HHH(DDD);
return;
}
When it is understood that HHH does simulate itself
simulating DDD
then any first year CS student knows that when each of the >>>>>>>>>>>> above are
correctly simulated by HHH that none of them ever stop running >>>>>>>>>>>> unless aborted.
WHich means that the code for HHH is part of the input, and thus >>>>>>>>>>> there is just ONE HHH in existance at this time.
Since that code aborts its simulation to return the answer >>>>>>>>>>> that you
claim, you are just lying that it did a correct simulation >>>>>>>>>>> (which in
this context means complete)
stop running unless aborted* *none of them ever stop running >>>>>>>>>> unless
aborted*
Do you agree or can you refute THIS EXACT POINT?
Do you agree or can you refute THIS EXACT POINT?
Do you agree or can you refute THIS EXACT POINT?
*You are not addressing THE EXACT POINT*
*When HHH never aborts any of the above functions then*
(a) None of the functions ever stops running.
(b) Each of the above functions stops running anyway.
You need to be clear that you are not making a claim about general >>>>>>> undecidability but a claim about the SPECIFIC CASE of
pathological self
reference present in the classic Halting Problem definition ..
the trolls
here (especially Damon and Mikko) like to ignore that you are
doing that.
He is not doing even that. What he is doing is totally outside of the >>>>>> scope of the halting problem. He has already verified that DDD halts >>>>>> and that HHH does not report that DDD halts. Nothing else is relevant >>>>>> in context of the halting problem.
If his intent is to deceive he should avoid clarity at least as much >>>>>> as he has recently done. His switch from "halting decider" to
"termination analyzer"
is a more accurate term for what I am referring to.
Not really as you are only talking about programs that do not take
any input. Termination analysis is about programs that do take input.
Inputs are typical yet not required.
Ability to analyze (at least some) programs that take inputs is
required.
No that is wrong.
On 6/21/2025 4:46 AM, Mikko wrote:
On 2025-06-20 17:12:30 +0000, olcott said:
On 6/20/2025 3:45 AM, Mikko wrote:
On 2025-06-19 09:09:34 +0000, Fred. Zwarts said:
Op 19.jun.2025 om 08:59 schreef olcott:
On 6/19/2025 1:17 AM, Mikko wrote:
On 2025-06-18 13:46:16 +0000, olcott said:
On 6/18/2025 5:12 AM, Fred. Zwarts wrote:
Op 18.jun.2025 om 03:54 schreef olcott:
On 6/17/2025 8:19 PM, Richard Damon wrote:
On 6/17/25 4:34 PM, olcott wrote:
void Infinite_Recursion()WHich means that the code for HHH is part of the input, and thus there
{
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. >>>>>>>>>>>
is just ONE HHH in existance at this time.
Since that code aborts its simulation to return the answer that you >>>>>>>>>>> claim, you are just lying that it did a correct simulation (which in
this context means complete)
*none of them ever stop running unless aborted*
All of them do abort and their simulation does not need an abort. >>>>>>>>>
*It is not given that any of them abort*
It is known a priori that HHH either does or does not abort.
Very good.
If HHH doesDDD never stops running.
not abort it does not terminate the simulation of DDD and therefore >>>>>>
because HHH never stops running and therefore this HHH
does
not report correctly. If HHH does abort it reports that DDD does not >>>>>>> halt, which is incorrect as in that case DDD does halt. HHH is correct >>>>>>> about DDD only if it does abort its simulation and reports "halts". >>>>>>> But you HHH does not do that.
So, both the aborting and the non-aborting HHH do not provide a correct report.
My HHH, if given DDD for input, does abort and does give the correct report
but gives the worng report if given DD.
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, because that is not well claimed. You have used "HHH" in at least
two different meanings and it is not clear which meaning is intended.
*clearer words*
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/21/2025 4:52 AM, Mikko wrote:
On 2025-06-20 13:59:02 +0000, olcott said:
On 6/20/2025 4:20 AM, Fred. Zwarts wrote:
Op 19.jun.2025 om 17:17 schreef olcott:
On 6/19/2025 4:21 AM, Fred. Zwarts wrote:
Op 18.jun.2025 om 15:46 schreef olcott:
On 6/18/2025 5:12 AM, Fred. Zwarts wrote:
Op 18.jun.2025 om 03:54 schreef olcott:
On 6/17/2025 8:19 PM, Richard Damon wrote:
On 6/17/25 4:34 PM, olcott wrote:
void Infinite_Recursion()WHich means that the code for HHH is part of the input, and thus there
{
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. >>>>>>>>>>
is just ONE HHH in existance at this time.
Since that code aborts its simulation to return the answer that you >>>>>>>>>> claim, you are just lying that it did a correct simulation (which in >>>>>>>>>> this context means complete)
*none of them ever stop running unless aborted*
All of them do abort and their simulation does not need an abort. >>>>>>>>
*It is not given that any of them abort*
At least it is true for all aborting ones, such as the one you
presented in Halt7.c.
My claim is that each of the above functions correctly
simulated by any termination analyzer HHH that can possibly
exist will never stop running unless aborted by HHH.
Can you affirm or correctly refute this?
Yes, I confirmed many times that we can confirm this vacuous claim,
because no such HHH exists. All of them fail to do a correct simulation >>>> up to the point where they can see whether the input specifies a
halting program.
if DDD correctly simulated by any simulating termination
analyzer HHH never aborts its simulation of DDD then
that HHH is not interesting.
*then the HP proofs are proved to be wrong*
On 6/21/2025 4:54 AM, Mikko wrote:
On 2025-06-20 17:17:40 +0000, olcott said:
On 6/20/2025 3:51 AM, Mikko wrote:
On 2025-06-19 07:02:27 +0000, olcott said:
On 6/19/2025 1:39 AM, Mikko wrote:
On 2025-06-18 18:28:43 +0000, Mr Flibble said:
On Wed, 18 Jun 2025 08:53:07 -0500, olcott wrote:
On 6/18/2025 6:01 AM, Richard Damon wrote:
On 6/17/25 9:54 PM, olcott wrote:
On 6/17/2025 8:19 PM, Richard Damon wrote:How about the fact that if they abort, they never did a correct >>>>>>>>> simulation,
On 6/17/25 4:34 PM, olcott wrote:*none of them ever stop running unless aborted* *none of them ever >>>>>>>>>> stop running unless aborted* *none of them ever stop running unless >>>>>>>>>> aborted*
void Infinite_Recursion()
{
Infinite_Recursion();
return;
}
void Infinite_Loop()
{
HERE: goto HERE; return;
}
void DDD()
{
HHH(DDD);
return;
}
When it is understood that HHH does simulate itself simulating DDD >>>>>>>>>>>> then any first year CS student knows that when each of the above are
correctly simulated by HHH that none of them ever stop running >>>>>>>>>>>> unless aborted.
WHich means that the code for HHH is part of the input, and thus >>>>>>>>>>> there is just ONE HHH in existance at this time.
Since that code aborts its simulation to return the answer that you >>>>>>>>>>> claim, you are just lying that it did a correct simulation (which in
this context means complete)
Do you agree or can you refute THIS EXACT POINT?
Do you agree or can you refute THIS EXACT POINT?
Do you agree or can you refute THIS EXACT POINT?
*You are not addressing THE EXACT POINT*
*When HHH never aborts any of the above functions then*
(a) None of the functions ever stops running.
(b) Each of the above functions stops running anyway.
You need to be clear that you are not making a claim about general >>>>>>> undecidability but a claim about the SPECIFIC CASE of pathological self >>>>>>> reference present in the classic Halting Problem definition .. the trolls
here (especially Damon and Mikko) like to ignore that you are doing that.
He is not doing even that. What he is doing is totally outside of the >>>>>> scope of the halting problem. He has already verified that DDD halts >>>>>> and that HHH does not report that DDD halts. Nothing else is relevant >>>>>> in context of the halting problem.
If his intent is to deceive he should avoid clarity at least as much >>>>>> as he has recently done. His switch from "halting decider" to
"termination analyzer"
is a more accurate term for what I am referring to.
Not really as you are only talking about programs that do not take
any input. Termination analysis is about programs that do take input.
Inputs are typical yet not required.
Ability to analyze (at least some) programs that take inputs is
required.
No that is wrong.
On 6/22/2025 3:47 AM, Mikko wrote:
On 2025-06-21 17:33:10 +0000, olcott said:
On 6/21/2025 4:46 AM, Mikko wrote:
On 2025-06-20 17:12:30 +0000, olcott said:
On 6/20/2025 3:45 AM, Mikko wrote:
On 2025-06-19 09:09:34 +0000, Fred. Zwarts said:
Op 19.jun.2025 om 08:59 schreef olcott:
On 6/19/2025 1:17 AM, Mikko wrote:
On 2025-06-18 13:46:16 +0000, olcott said:
On 6/18/2025 5:12 AM, Fred. Zwarts wrote:
Op 18.jun.2025 om 03:54 schreef olcott:
On 6/17/2025 8:19 PM, Richard Damon wrote:
On 6/17/25 4:34 PM, olcott wrote:
void Infinite_Recursion()WHich means that the code for HHH is part of the input, and thus there
{
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. >>>>>>>>>>>>>
is just ONE HHH in existance at this time.
Since that code aborts its simulation to return the answer that you
claim, you are just lying that it did a correct simulation (which in
this context means complete)
*none of them ever stop running unless aborted*
All of them do abort and their simulation does not need an abort. >>>>>>>>>>>
*It is not given that any of them abort*
It is known a priori that HHH either does or does not abort.
Very good.
If HHH doesDDD never stops running.
not abort it does not terminate the simulation of DDD and therefore >>>>>>>>
because HHH never stops running and therefore this HHH
does
not report correctly. If HHH does abort it reports that DDD does not >>>>>>>>> halt, which is incorrect as in that case DDD does halt. HHH is correct
about DDD only if it does abort its simulation and reports "halts". >>>>>>>>> But you HHH does not do that.
So, both the aborting and the non-aborting HHH do not provide a correct report.
My HHH, if given DDD for input, does abort and does give the correct report
but gives the worng report if given DD.
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, because that is not well claimed. You have used "HHH" in at least
two different meanings and it is not clear which meaning is intended.
*clearer words*
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?
Not sufficiently clearer than the previous attempt.
Since you did not say exactly what seems unclear to
you I am taking this as a dishonest dodge away from the point.
On 6/22/2025 3:59 AM, Mikko wrote:
On 2025-06-21 17:34:55 +0000, olcott said:
On 6/21/2025 4:52 AM, Mikko wrote:
On 2025-06-20 13:59:02 +0000, olcott said:
On 6/20/2025 4:20 AM, Fred. Zwarts wrote:
Op 19.jun.2025 om 17:17 schreef olcott:
On 6/19/2025 4:21 AM, Fred. Zwarts wrote:
Op 18.jun.2025 om 15:46 schreef olcott:
On 6/18/2025 5:12 AM, Fred. Zwarts wrote:
Op 18.jun.2025 om 03:54 schreef olcott:
On 6/17/2025 8:19 PM, Richard Damon wrote:
On 6/17/25 4:34 PM, olcott wrote:
void Infinite_Recursion()WHich means that the code for HHH is part of the input, and thus there
{
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. >>>>>>>>>>>>
is just ONE HHH in existance at this time.
Since that code aborts its simulation to return the answer that you
claim, you are just lying that it did a correct simulation (which in
this context means complete)
*none of them ever stop running unless aborted*
All of them do abort and their simulation does not need an abort. >>>>>>>>>>
*It is not given that any of them abort*
At least it is true for all aborting ones, such as the one you >>>>>>>> presented in Halt7.c.
My claim is that each of the above functions correctly
simulated by any termination analyzer HHH that can possibly
exist will never stop running unless aborted by HHH.
Can you affirm or correctly refute this?
Yes, I confirmed many times that we can confirm this vacuous claim, >>>>>> because no such HHH exists. All of them fail to do a correct simulation >>>>>> up to the point where they can see whether the input specifies a
halting program.
if DDD correctly simulated by any simulating termination
analyzer HHH never aborts its simulation of DDD then
that HHH is not interesting.
*then the HP proofs are proved to be wrong*
No, they are not. You have not solved the halting problem and that
(in addition to all proofs) supports the claim that halting problem
is unsolvable.
ChatGPT corrected my words and agreed that I have
correctly refuted the generic HP proof technique
where an input has been defined to only do the
opposite of whatever value that its decider decides. https://chatgpt.com/s/t_6857335b37a08191a077d57039fa4a76
The ChatGPT that evaluated and affirmed my analysis
of HHH(DDD) one year ago could only handle 4000 tokens
thus could not understand HHH(DD).
ChatGPT with GPT-4-turbo — can handle up to 128,000 tokens
of context in a single conversation, immediately understood
HHH(DD) within the context of the conversation of HHH(DDD).
In order to show that a proof is wrong you need to show an error
in the proof. Even then the conclusion is proven unless you can
show an error in every proof of that conclusion.
On 6/22/2025 4:02 AM, Mikko wrote:
On 2025-06-21 17:35:58 +0000, olcott said:
On 6/21/2025 4:54 AM, Mikko wrote:
On 2025-06-20 17:17:40 +0000, olcott said:
On 6/20/2025 3:51 AM, Mikko wrote:
On 2025-06-19 07:02:27 +0000, olcott said:Inputs are typical yet not required.
On 6/19/2025 1:39 AM, Mikko wrote:
On 2025-06-18 18:28:43 +0000, Mr Flibble said:
On Wed, 18 Jun 2025 08:53:07 -0500, olcott wrote:
On 6/18/2025 6:01 AM, Richard Damon wrote:
On 6/17/25 9:54 PM, olcott wrote:
On 6/17/2025 8:19 PM, Richard Damon wrote:How about the fact that if they abort, they never did a correct >>>>>>>>>>> simulation,
On 6/17/25 4:34 PM, olcott wrote:*none of them ever stop running unless aborted* *none of them ever >>>>>>>>>>>> stop running unless aborted* *none of them ever stop running unless
void Infinite_Recursion()
{
Infinite_Recursion();
return;
}
void Infinite_Loop()
{
HERE: goto HERE; return;
}
void DDD()
{
HHH(DDD);
return;
}
When it is understood that HHH does simulate itself simulating DDD
then any first year CS student knows that when each of the above are
correctly simulated by HHH that none of them ever stop running >>>>>>>>>>>>>> unless aborted.
WHich means that the code for HHH is part of the input, and thus >>>>>>>>>>>>> there is just ONE HHH in existance at this time.
Since that code aborts its simulation to return the answer that you
claim, you are just lying that it did a correct simulation (which in
this context means complete)
aborted*
Do you agree or can you refute THIS EXACT POINT?
Do you agree or can you refute THIS EXACT POINT?
Do you agree or can you refute THIS EXACT POINT?
*You are not addressing THE EXACT POINT*
*When HHH never aborts any of the above functions then*
(a) None of the functions ever stops running.
(b) Each of the above functions stops running anyway.
You need to be clear that you are not making a claim about general >>>>>>>>> undecidability but a claim about the SPECIFIC CASE of pathological self
reference present in the classic Halting Problem definition .. the trolls
here (especially Damon and Mikko) like to ignore that you are doing that.
He is not doing even that. What he is doing is totally outside of the >>>>>>>> scope of the halting problem. He has already verified that DDD halts >>>>>>>> and that HHH does not report that DDD halts. Nothing else is relevant >>>>>>>> in context of the halting problem.
If his intent is to deceive he should avoid clarity at least as much >>>>>>>> as he has recently done. His switch from "halting decider" to
"termination analyzer"
is a more accurate term for what I am referring to.
Not really as you are only talking about programs that do not take >>>>>> any input. Termination analysis is about programs that do take input. >>>>>
Ability to analyze (at least some) programs that take inputs is
required.
No that is wrong.
Can you quote any author allowing a termination analyzer that is restricted >> to programs that do not take any input?
The ability to correctly determine the halt status
of at least one program that takes no inputs meets
the requirement of being a termination analyzer for
that one program.
On 6/23/2025 2:08 AM, Mikko wrote:
On 2025-06-22 16:37:37 +0000, olcott said:
On 6/22/2025 3:47 AM, Mikko wrote:
On 2025-06-21 17:33:10 +0000, olcott said:
On 6/21/2025 4:46 AM, Mikko wrote:
On 2025-06-20 17:12:30 +0000, olcott said:*clearer words*
On 6/20/2025 3:45 AM, Mikko wrote:
On 2025-06-19 09:09:34 +0000, Fred. Zwarts said:
Op 19.jun.2025 om 08:59 schreef olcott:
On 6/19/2025 1:17 AM, Mikko wrote:
On 2025-06-18 13:46:16 +0000, olcott said:Very good.
On 6/18/2025 5:12 AM, Fred. Zwarts wrote:
Op 18.jun.2025 om 03:54 schreef olcott:
On 6/17/2025 8:19 PM, Richard Damon wrote:
On 6/17/25 4:34 PM, olcott wrote:
void Infinite_Recursion()WHich means that the code for HHH is part of the input, and thus there
{
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. >>>>>>>>>>>>>>>
is just ONE HHH in existance at this time.
Since that code aborts its simulation to return the answer that you
claim, you are just lying that it did a correct simulation (which in
this context means complete)
*none of them ever stop running unless aborted*
All of them do abort and their simulation does not need an abort. >>>>>>>>>>>>>
*It is not given that any of them abort*
It is known a priori that HHH either does or does not abort. >>>>>>>>>>
If HHH doesDDD never stops running.
not abort it does not terminate the simulation of DDD and therefore >>>>>>>>>>
because HHH never stops running and therefore this HHH
does
not report correctly. If HHH does abort it reports that DDD does not
halt, which is incorrect as in that case DDD does halt. HHH is correct
about DDD only if it does abort its simulation and reports "halts". >>>>>>>>>>> But you HHH does not do that.
So, both the aborting and the non-aborting HHH do not provide a correct report.
My HHH, if given DDD for input, does abort and does give the correct report
but gives the worng report if given DD.
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, because that is not well claimed. You have used "HHH" in at least >>>>>> two different meanings and it is not clear which meaning is intended. >>>>>
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?
Not sufficiently clearer than the previous attempt.
Since you did not say exactly what seems unclear to
you I am taking this as a dishonest dodge away from the point.
You are lying. I did say. Your second attermpt does not clarify what
I did say was unclear. You didn't say what it did clarify, so
apparently nothing. You just claimed that an exact copy is clearer.
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?
All of those words are perfectly clear to me.
On 6/23/2025 2:12 AM, Mikko wrote:
On 2025-06-22 19:16:24 +0000, olcott said:
On 6/22/2025 3:59 AM, Mikko wrote:
On 2025-06-21 17:34:55 +0000, olcott said:
On 6/21/2025 4:52 AM, Mikko wrote:
On 2025-06-20 13:59:02 +0000, olcott said:
On 6/20/2025 4:20 AM, Fred. Zwarts wrote:
Op 19.jun.2025 om 17:17 schreef olcott:
On 6/19/2025 4:21 AM, Fred. Zwarts wrote:
Op 18.jun.2025 om 15:46 schreef olcott:
On 6/18/2025 5:12 AM, Fred. Zwarts wrote:
Op 18.jun.2025 om 03:54 schreef olcott:
On 6/17/2025 8:19 PM, Richard Damon wrote:
On 6/17/25 4:34 PM, olcott wrote:
void Infinite_Recursion()WHich means that the code for HHH is part of the input, and thus there
{
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. >>>>>>>>>>>>>>
is just ONE HHH in existance at this time.
Since that code aborts its simulation to return the answer that you
claim, you are just lying that it did a correct simulation (which in
this context means complete)
*none of them ever stop running unless aborted*
All of them do abort and their simulation does not need an abort. >>>>>>>>>>>>
*It is not given that any of them abort*
At least it is true for all aborting ones, such as the one you >>>>>>>>>> presented in Halt7.c.
My claim is that each of the above functions correctly
simulated by any termination analyzer HHH that can possibly
exist will never stop running unless aborted by HHH.
Can you affirm or correctly refute this?
Yes, I confirmed many times that we can confirm this vacuous claim, >>>>>>>> because no such HHH exists. All of them fail to do a correct simulation
up to the point where they can see whether the input specifies a >>>>>>>> halting program.
if DDD correctly simulated by any simulating termination
analyzer HHH never aborts its simulation of DDD then
that HHH is not interesting.
*then the HP proofs are proved to be wrong*
No, they are not. You have not solved the halting problem and that
(in addition to all proofs) supports the claim that halting problem
is unsolvable.
ChatGPT corrected my words and agreed that I have
correctly refuted the generic HP proof technique
where an input has been defined to only do the
opposite of whatever value that its decider decides.
https://chatgpt.com/s/t_6857335b37a08191a077d57039fa4a76
Doesn't matter. Only proofs matter. So far you have not proven anything
and it is unlikely you could prove anything even after asking ChatGPT
for help.
The ChatGPT that evaluated and affirmed my analysis
of HHH(DDD) one year ago could only handle 4000 tokens
thus could not understand HHH(DD).
ChatGPT with GPT-4-turbo — can handle up to 128,000 tokens
of context in a single conversation, immediately understood
HHH(DD) within the context of the conversation of HHH(DDD).
ChatGPT does not understand. Whether you do is still not determined.
Anyway,
In order to show that a proof is wrong you need to show an error
in the proof. Even then the conclusion is proven unless you can
show an error in every proof of that conclusion.
That you do not understand that any set of expressions of
language that show another expression of language is
necessarily true is its proof is your ignorance not mine.
On 6/23/2025 2:15 AM, Mikko wrote:
On 2025-06-22 19:23:37 +0000, olcott said:
On 6/22/2025 4:02 AM, Mikko wrote:
On 2025-06-21 17:35:58 +0000, olcott said:
On 6/21/2025 4:54 AM, Mikko wrote:
On 2025-06-20 17:17:40 +0000, olcott said:
On 6/20/2025 3:51 AM, Mikko wrote:
On 2025-06-19 07:02:27 +0000, olcott said:Inputs are typical yet not required.
On 6/19/2025 1:39 AM, Mikko wrote:
On 2025-06-18 18:28:43 +0000, Mr Flibble said:
On Wed, 18 Jun 2025 08:53:07 -0500, olcott wrote:
On 6/18/2025 6:01 AM, Richard Damon wrote:
On 6/17/25 9:54 PM, olcott wrote:
On 6/17/2025 8:19 PM, Richard Damon wrote:How about the fact that if they abort, they never did a correct >>>>>>>>>>>>> simulation,
On 6/17/25 4:34 PM, olcott wrote:*none of them ever stop running unless aborted* *none of them ever
void Infinite_Recursion()
{
Infinite_Recursion();
return;
}
void Infinite_Loop()
{
HERE: goto HERE; return;
}
void DDD()
{
HHH(DDD);
return;
}
When it is understood that HHH does simulate itself simulating DDD
then any first year CS student knows that when each of the above are
correctly simulated by HHH that none of them ever stop running >>>>>>>>>>>>>>>> unless aborted.
WHich means that the code for HHH is part of the input, and thus
there is just ONE HHH in existance at this time. >>>>>>>>>>>>>>>
Since that code aborts its simulation to return the answer that you
claim, you are just lying that it did a correct simulation (which in
this context means complete)
stop running unless aborted* *none of them ever stop running unless
aborted*
Do you agree or can you refute THIS EXACT POINT?
Do you agree or can you refute THIS EXACT POINT?
Do you agree or can you refute THIS EXACT POINT?
*You are not addressing THE EXACT POINT*
*When HHH never aborts any of the above functions then* >>>>>>>>>>>> (a) None of the functions ever stops running.
(b) Each of the above functions stops running anyway.
You need to be clear that you are not making a claim about general >>>>>>>>>>> undecidability but a claim about the SPECIFIC CASE of pathological self
reference present in the classic Halting Problem definition .. the trolls
here (especially Damon and Mikko) like to ignore that you are doing that.
He is not doing even that. What he is doing is totally outside of the
scope of the halting problem. He has already verified that DDD halts >>>>>>>>>> and that HHH does not report that DDD halts. Nothing else is relevant
in context of the halting problem.
If his intent is to deceive he should avoid clarity at least as much >>>>>>>>>> as he has recently done. His switch from "halting decider" to >>>>>>>>>> "termination analyzer"
is a more accurate term for what I am referring to.
Not really as you are only talking about programs that do not take >>>>>>>> any input. Termination analysis is about programs that do take input. >>>>>>>
Ability to analyze (at least some) programs that take inputs is
required.
No that is wrong.
Can you quote any author allowing a termination analyzer that is restricted
to programs that do not take any input?
The ability to correctly determine the halt status
of at least one program that takes no inputs meets
the requirement of being a termination analyzer for
that one program.
It does not prove that all requirements are met, in particular the
requirement that the analyzer must be able to analyze programs that
do take input.
That is a bogus requirement.
On 6/24/2025 3:52 AM, Mikko wrote:
On 2025-06-23 16:48:20 +0000, olcott said:
On 6/23/2025 2:08 AM, Mikko wrote:
On 2025-06-22 16:37:37 +0000, olcott said:
On 6/22/2025 3:47 AM, Mikko wrote:
On 2025-06-21 17:33:10 +0000, olcott said:
On 6/21/2025 4:46 AM, Mikko wrote:
On 2025-06-20 17:12:30 +0000, olcott said:*clearer words*
On 6/20/2025 3:45 AM, Mikko wrote:
On 2025-06-19 09:09:34 +0000, Fred. Zwarts said:
Op 19.jun.2025 om 08:59 schreef olcott:
On 6/19/2025 1:17 AM, Mikko wrote:
On 2025-06-18 13:46:16 +0000, olcott said:Very good.
On 6/18/2025 5:12 AM, Fred. Zwarts wrote:
Op 18.jun.2025 om 03:54 schreef olcott:
On 6/17/2025 8:19 PM, Richard Damon wrote:All of them do abort and their simulation does not need an abort.
On 6/17/25 4:34 PM, olcott wrote:
void Infinite_Recursion()WHich means that the code for HHH is part of the input, and thus there
{
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. >>>>>>>>>>>>>>>>>
is just ONE HHH in existance at this time.
Since that code aborts its simulation to return the answer that you
claim, you are just lying that it did a correct simulation (which in
this context means complete)
*none of them ever stop running unless aborted* >>>>>>>>>>>>>>>
*It is not given that any of them abort*
It is known a priori that HHH either does or does not abort. >>>>>>>>>>>>
If HHH does
not abort it does not terminate the simulation of DDD and therefore
DDD never stops running.
because HHH never stops running and therefore this HHH
does
not report correctly. If HHH does abort it reports that DDD does not
halt, which is incorrect as in that case DDD does halt. HHH is correct
about DDD only if it does abort its simulation and reports "halts".
But you HHH does not do that.
So, both the aborting and the non-aborting HHH do not provide a correct report.
My HHH, if given DDD for input, does abort and does give the correct report
but gives the worng report if given DD.
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, because that is not well claimed. You have used "HHH" in at least >>>>>>>> two different meanings and it is not clear which meaning is intended. >>>>>>>
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?
Not sufficiently clearer than the previous attempt.
Since you did not say exactly what seems unclear to
you I am taking this as a dishonest dodge away from the point.
You are lying. I did say. Your second attermpt does not clarify what
I did say was unclear. You didn't say what it did clarify, so
apparently nothing. You just claimed that an exact copy is clearer.
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?
All of those words are perfectly clear to me.
Isn't my HHH as a suffifient answer? If not, ask again when you
have clarified all points I or someone else has identified as
ambiguous.
You are playing head games.
On 6/24/2025 3:53 AM, Mikko wrote:
On 2025-06-23 16:51:23 +0000, olcott said:
On 6/23/2025 2:12 AM, Mikko wrote:
On 2025-06-22 19:16:24 +0000, olcott said:
On 6/22/2025 3:59 AM, Mikko wrote:
On 2025-06-21 17:34:55 +0000, olcott said:
On 6/21/2025 4:52 AM, Mikko wrote:
On 2025-06-20 13:59:02 +0000, olcott said:
On 6/20/2025 4:20 AM, Fred. Zwarts wrote:
Op 19.jun.2025 om 17:17 schreef olcott:
On 6/19/2025 4:21 AM, Fred. Zwarts wrote:
Op 18.jun.2025 om 15:46 schreef olcott:
On 6/18/2025 5:12 AM, Fred. Zwarts wrote:
Op 18.jun.2025 om 03:54 schreef olcott:
On 6/17/2025 8:19 PM, Richard Damon wrote:
On 6/17/25 4:34 PM, olcott wrote:
void Infinite_Recursion()WHich means that the code for HHH is part of the input, and thus there
{
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. >>>>>>>>>>>>>>>>
is just ONE HHH in existance at this time.
Since that code aborts its simulation to return the answer that you
claim, you are just lying that it did a correct simulation (which in
this context means complete)
*none of them ever stop running unless aborted*
All of them do abort and their simulation does not need an abort.
*It is not given that any of them abort*
At least it is true for all aborting ones, such as the one you >>>>>>>>>>>> presented in Halt7.c.
My claim is that each of the above functions correctly
simulated by any termination analyzer HHH that can possibly >>>>>>>>>>> exist will never stop running unless aborted by HHH.
Can you affirm or correctly refute this?
Yes, I confirmed many times that we can confirm this vacuous claim, >>>>>>>>>> because no such HHH exists. All of them fail to do a correct simulation
up to the point where they can see whether the input specifies a >>>>>>>>>> halting program.
if DDD correctly simulated by any simulating termination
analyzer HHH never aborts its simulation of DDD then
that HHH is not interesting.
*then the HP proofs are proved to be wrong*
No, they are not. You have not solved the halting problem and that >>>>>> (in addition to all proofs) supports the claim that halting problem >>>>>> is unsolvable.
ChatGPT corrected my words and agreed that I have
correctly refuted the generic HP proof technique
where an input has been defined to only do the
opposite of whatever value that its decider decides.
https://chatgpt.com/s/t_6857335b37a08191a077d57039fa4a76
Doesn't matter. Only proofs matter. So far you have not proven anything >>>> and it is unlikely you could prove anything even after asking ChatGPT
for help.
The ChatGPT that evaluated and affirmed my analysis
of HHH(DDD) one year ago could only handle 4000 tokens
thus could not understand HHH(DD).
ChatGPT with GPT-4-turbo — can handle up to 128,000 tokens
of context in a single conversation, immediately understood
HHH(DD) within the context of the conversation of HHH(DDD).
ChatGPT does not understand. Whether you do is still not determined.
Anyway,
In order to show that a proof is wrong you need to show an error
in the proof. Even then the conclusion is proven unless you can
show an error in every proof of that conclusion.
That you do not understand that any set of expressions of
language that show another expression of language is
necessarily true is its proof is your ignorance not mine.
Only a proof is a proof.
There are things called proofs that have a certain
form and there is the broader concept of proof that
does not require this certain form.
A proof is any set of expressions of language that
correctly concludes that another expression of
language is definitely true.
On 6/24/2025 3:57 AM, Mikko wrote:
On 2025-06-23 16:53:59 +0000, olcott said:
On 6/23/2025 2:15 AM, Mikko wrote:
On 2025-06-22 19:23:37 +0000, olcott said:
On 6/22/2025 4:02 AM, Mikko wrote:
On 2025-06-21 17:35:58 +0000, olcott said:
On 6/21/2025 4:54 AM, Mikko wrote:
On 2025-06-20 17:17:40 +0000, olcott said:
On 6/20/2025 3:51 AM, Mikko wrote:
On 2025-06-19 07:02:27 +0000, olcott said:
On 6/19/2025 1:39 AM, Mikko wrote:
On 2025-06-18 18:28:43 +0000, Mr Flibble said:
On Wed, 18 Jun 2025 08:53:07 -0500, olcott wrote:
On 6/18/2025 6:01 AM, Richard Damon wrote:You need to be clear that you are not making a claim about general
On 6/17/25 9:54 PM, olcott wrote:
On 6/17/2025 8:19 PM, Richard Damon wrote:How about the fact that if they abort, they never did a correct >>>>>>>>>>>>>>> simulation,
On 6/17/25 4:34 PM, olcott wrote:*none of them ever stop running unless aborted* *none of them ever
void Infinite_Recursion()
{
Infinite_Recursion();
return;
}
void Infinite_Loop()
{
HERE: goto HERE; return;
}
void DDD()
{
HHH(DDD);
return;
}
When it is understood that HHH does simulate itself simulating DDD
then any first year CS student knows that when each of the above are
correctly simulated by HHH that none of them ever stop running
unless aborted.
WHich means that the code for HHH is part of the input, and thus
there is just ONE HHH in existance at this time. >>>>>>>>>>>>>>>>>
Since that code aborts its simulation to return the answer that you
claim, you are just lying that it did a correct simulation (which in
this context means complete)
stop running unless aborted* *none of them ever stop running unless
aborted*
Do you agree or can you refute THIS EXACT POINT? >>>>>>>>>>>>>>>> Do you agree or can you refute THIS EXACT POINT? >>>>>>>>>>>>>>>> Do you agree or can you refute THIS EXACT POINT? >>>>>>>>>>>>>>>>
*You are not addressing THE EXACT POINT*
*When HHH never aborts any of the above functions then* >>>>>>>>>>>>>> (a) None of the functions ever stops running.
(b) Each of the above functions stops running anyway. >>>>>>>>>>>>>
undecidability but a claim about the SPECIFIC CASE of pathological self
reference present in the classic Halting Problem definition .. the trolls
here (especially Damon and Mikko) like to ignore that you are doing that.
He is not doing even that. What he is doing is totally outside of the
scope of the halting problem. He has already verified that DDD halts
and that HHH does not report that DDD halts. Nothing else is relevant
in context of the halting problem.
If his intent is to deceive he should avoid clarity at least as much
as he has recently done. His switch from "halting decider" to >>>>>>>>>>>> "termination analyzer"
is a more accurate term for what I am referring to.
Not really as you are only talking about programs that do not take >>>>>>>>>> any input. Termination analysis is about programs that do take input.
Inputs are typical yet not required.
Ability to analyze (at least some) programs that take inputs is >>>>>>>> required.
No that is wrong.
Can you quote any author allowing a termination analyzer that is restricted
to programs that do not take any input?
The ability to correctly determine the halt status
of at least one program that takes no inputs meets
the requirement of being a termination analyzer for
that one program.
It does not prove that all requirements are met, in particular the
requirement that the analyzer must be able to analyze programs that
do take input.
That is a bogus requirement.
No, it is not. It is essential to the meaning of the term.
A nut cracker is not a hammer although both can produce the same
effenct on nuts.
A termination analyzer determines the halt status
of a program for every input that this program takes.
When it does this for a program that takes no inputs
it is still doing this for every input that this
program takes.
On 6/25/2025 1:54 AM, Mikko wrote:
On 2025-06-24 15:02:43 +0000, olcott said:
On 6/24/2025 3:57 AM, Mikko wrote:
On 2025-06-23 16:53:59 +0000, olcott said:
On 6/23/2025 2:15 AM, Mikko wrote:
On 2025-06-22 19:23:37 +0000, olcott said:
On 6/22/2025 4:02 AM, Mikko wrote:
On 2025-06-21 17:35:58 +0000, olcott said:
On 6/21/2025 4:54 AM, Mikko wrote:
On 2025-06-20 17:17:40 +0000, olcott said:
On 6/20/2025 3:51 AM, Mikko wrote:
On 2025-06-19 07:02:27 +0000, olcott said:
On 6/19/2025 1:39 AM, Mikko wrote:
On 2025-06-18 18:28:43 +0000, Mr Flibble said:
On Wed, 18 Jun 2025 08:53:07 -0500, olcott wrote: >>>>>>>>>>>>>>>
On 6/18/2025 6:01 AM, Richard Damon wrote:You need to be clear that you are not making a claim about general
On 6/17/25 9:54 PM, olcott wrote:
On 6/17/2025 8:19 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>> On 6/17/25 4:34 PM, olcott wrote:How about the fact that if they abort, they never did a correct
*none of them ever stop running unless aborted* *none of them evervoid Infinite_Recursion()
{
Infinite_Recursion();
return;
}
void Infinite_Loop()
{
HERE: goto HERE; return;
}
void DDD()
{
HHH(DDD);
return;
}
When it is understood that HHH does simulate itself simulating DDD
then any first year CS student knows that when each of the above are
correctly simulated by HHH that none of them ever stop running
unless aborted.
WHich means that the code for HHH is part of the input, and thus
there is just ONE HHH in existance at this time. >>>>>>>>>>>>>>>>>>>
Since that code aborts its simulation to return the answer that you
claim, you are just lying that it did a correct simulation (which in
this context means complete)
stop running unless aborted* *none of them ever stop running unless
aborted*
Do you agree or can you refute THIS EXACT POINT? >>>>>>>>>>>>>>>>>> Do you agree or can you refute THIS EXACT POINT? >>>>>>>>>>>>>>>>>> Do you agree or can you refute THIS EXACT POINT? >>>>>>>>>>>>>>>>>>
simulation,
*You are not addressing THE EXACT POINT*
*When HHH never aborts any of the above functions then* >>>>>>>>>>>>>>>> (a) None of the functions ever stops running.
(b) Each of the above functions stops running anyway. >>>>>>>>>>>>>>>
undecidability but a claim about the SPECIFIC CASE of pathological self
reference present in the classic Halting Problem definition .. the trolls
here (especially Damon and Mikko) like to ignore that you are doing that.
He is not doing even that. What he is doing is totally outside of the
scope of the halting problem. He has already verified that DDD halts
and that HHH does not report that DDD halts. Nothing else is relevant
in context of the halting problem.
If his intent is to deceive he should avoid clarity at least as much
as he has recently done. His switch from "halting decider" to >>>>>>>>>>>>>> "termination analyzer"
is a more accurate term for what I am referring to.
Not really as you are only talking about programs that do not take >>>>>>>>>>>> any input. Termination analysis is about programs that do take input.
Inputs are typical yet not required.
Ability to analyze (at least some) programs that take inputs is >>>>>>>>>> required.
No that is wrong.
Can you quote any author allowing a termination analyzer that is restricted
to programs that do not take any input?
The ability to correctly determine the halt status
of at least one program that takes no inputs meets
the requirement of being a termination analyzer for
that one program.
It does not prove that all requirements are met, in particular the >>>>>> requirement that the analyzer must be able to analyze programs that >>>>>> do take input.
That is a bogus requirement.
No, it is not. It is essential to the meaning of the term.
A nut cracker is not a hammer although both can produce the same
effenct on nuts.
A termination analyzer determines the halt status
of a program for every input that this program takes.
When it does this for a program that takes no inputs
it is still doing this for every input that this
program takes.
You mean a nutcracker is a hammer?
A termination analyzer correctly determines the halt
status of an input program specification for every
input that this program can take. A program specification
taking zero inputs is merely the simpler case of this
same algorithm.
On 6/21/2025 4:52 AM, Mikko wrote:
On 2025-06-20 13:59:02 +0000, olcott said:
On 6/20/2025 4:20 AM, Fred. Zwarts wrote:
Op 19.jun.2025 om 17:17 schreef olcott:
On 6/19/2025 4:21 AM, Fred. Zwarts wrote:
Op 18.jun.2025 om 15:46 schreef olcott:
On 6/18/2025 5:12 AM, Fred. Zwarts wrote:
Op 18.jun.2025 om 03:54 schreef olcott:
On 6/17/2025 8:19 PM, Richard Damon wrote:
On 6/17/25 4:34 PM, olcott wrote:
void Infinite_Recursion()WHich means that the code for HHH is part of the input, and thus there
{
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. >>>>>>>>>>
is just ONE HHH in existance at this time.
Since that code aborts its simulation to return the answer that you >>>>>>>>>> claim, you are just lying that it did a correct simulation (which in >>>>>>>>>> this context means complete)
*none of them ever stop running unless aborted*
All of them do abort and their simulation does not need an abort. >>>>>>>>
*It is not given that any of them abort*
At least it is true for all aborting ones, such as the one you
presented in Halt7.c.
My claim is that each of the above functions correctly
simulated by any termination analyzer HHH that can possibly
exist will never stop running unless aborted by HHH.
Can you affirm or correctly refute this?
Yes, I confirmed many times that we can confirm this vacuous claim,
because no such HHH exists. All of them fail to do a correct simulation >>>> up to the point where they can see whether the input specifies a
halting program.
if DDD correctly simulated by any simulating termination
analyzer HHH never aborts its simulation of DDD then
that HHH is not interesting.
*then the HP proofs are proved to be wrong*
On 6/26/2025 4:35 AM, Mikko wrote:
On 2025-06-25 14:40:35 +0000, olcott said:
On 6/25/2025 1:54 AM, Mikko wrote:
On 2025-06-24 15:02:43 +0000, olcott said:
On 6/24/2025 3:57 AM, Mikko wrote:
On 2025-06-23 16:53:59 +0000, olcott said:
On 6/23/2025 2:15 AM, Mikko wrote:
On 2025-06-22 19:23:37 +0000, olcott said:
On 6/22/2025 4:02 AM, Mikko wrote:
On 2025-06-21 17:35:58 +0000, olcott said:
On 6/21/2025 4:54 AM, Mikko wrote:
On 2025-06-20 17:17:40 +0000, olcott said:
On 6/20/2025 3:51 AM, Mikko wrote:
On 2025-06-19 07:02:27 +0000, olcott said:
On 6/19/2025 1:39 AM, Mikko wrote:Not really as you are only talking about programs that do not take
On 2025-06-18 18:28:43 +0000, Mr Flibble said: >>>>>>>>>>>>>>>>
On Wed, 18 Jun 2025 08:53:07 -0500, olcott wrote: >>>>>>>>>>>>>>>>>
On 6/18/2025 6:01 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>> On 6/17/25 9:54 PM, olcott wrote:You need to be clear that you are not making a claim about general
On 6/17/2025 8:19 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>> On 6/17/25 4:34 PM, olcott wrote:How about the fact that if they abort, they never did a correct
*none of them ever stop running unless aborted* *none of them evervoid Infinite_Recursion()
{
Infinite_Recursion();
return;
}
void Infinite_Loop()
{
HERE: goto HERE; return;
}
void DDD()
{
HHH(DDD);
return;
}
When it is understood that HHH does simulate itself simulating DDD
then any first year CS student knows that when each of the above are
correctly simulated by HHH that none of them ever stop running
unless aborted.
WHich means that the code for HHH is part of the input, and thus
there is just ONE HHH in existance at this time. >>>>>>>>>>>>>>>>>>>>>
Since that code aborts its simulation to return the answer that you
claim, you are just lying that it did a correct simulation (which in
this context means complete)
stop running unless aborted* *none of them ever stop running unless
aborted*
Do you agree or can you refute THIS EXACT POINT? >>>>>>>>>>>>>>>>>>>> Do you agree or can you refute THIS EXACT POINT? >>>>>>>>>>>>>>>>>>>> Do you agree or can you refute THIS EXACT POINT? >>>>>>>>>>>>>>>>>>>>
simulation,
*You are not addressing THE EXACT POINT*
*When HHH never aborts any of the above functions then* >>>>>>>>>>>>>>>>>> (a) None of the functions ever stops running. >>>>>>>>>>>>>>>>>> (b) Each of the above functions stops running anyway. >>>>>>>>>>>>>>>>>
undecidability but a claim about the SPECIFIC CASE of pathological self
reference present in the classic Halting Problem definition .. the trolls
here (especially Damon and Mikko) like to ignore that you are doing that.
He is not doing even that. What he is doing is totally outside of the
scope of the halting problem. He has already verified that DDD halts
and that HHH does not report that DDD halts. Nothing else is relevant
in context of the halting problem.
If his intent is to deceive he should avoid clarity at least as much
as he has recently done. His switch from "halting decider" to >>>>>>>>>>>>>>>> "termination analyzer"
is a more accurate term for what I am referring to. >>>>>>>>>>>>>>
any input. Termination analysis is about programs that do take input.
Inputs are typical yet not required.
Ability to analyze (at least some) programs that take inputs is >>>>>>>>>>>> required.
No that is wrong.
Can you quote any author allowing a termination analyzer that is restricted
to programs that do not take any input?
The ability to correctly determine the halt status
of at least one program that takes no inputs meets
the requirement of being a termination analyzer for
that one program.
It does not prove that all requirements are met, in particular the >>>>>>>> requirement that the analyzer must be able to analyze programs that >>>>>>>> do take input.
That is a bogus requirement.
No, it is not. It is essential to the meaning of the term.
A nut cracker is not a hammer although both can produce the same
effenct on nuts.
A termination analyzer determines the halt status
of a program for every input that this program takes.
When it does this for a program that takes no inputs
it is still doing this for every input that this
program takes.
You mean a nutcracker is a hammer?
A termination analyzer correctly determines the halt
status of an input program specification for every
input that this program can take. A program specification
taking zero inputs is merely the simpler case of this
same algorithm.
So you do. Perhapts it is a matter of taste but honest people
prefer to call a spade a "spade" and not an "earthmover" or a
"manually operated earthmover".
Every input that a program can take logically includes
programs that take no inputs.
On 6/28/2025 6:50 AM, Mikko wrote:
On 2025-06-27 23:26:07 +0000, olcott said:
On 6/26/2025 4:35 AM, Mikko wrote:
On 2025-06-25 14:40:35 +0000, olcott said:
A termination analyzer correctly determines the halt
status of an input program specification for every
input that this program can take. A program specification
taking zero inputs is merely the simpler case of this
same algorithm.
So you do. Perhapts it is a matter of taste but honest people
prefer to call a spade a "spade" and not an "earthmover" or a
"manually operated earthmover".
Every input that a program can take logically includes
programs that take no inputs.
Yes. But the meaning of "termination analyzer" excludes analyzers
that don't analyze programs that do take inputs.
Line 506 has the original: u32 H(ptr P, ptr I)
Line 1243 has the original: void P(ptr x) https://github.com/plolcott/x86utm/blob/master/Halt7.c
*I had to dumb it down to this*
int main()
{
HHH(DDD);
DDD();
}
*And people still do not understand*
*Termination Analysis without the Tears* https://www.cs.princeton.edu/~zkincaid/pub/pldi21.pdf
On page three a code snippet is analyzed that takes
no input and its not even a function.
On 6/28/2025 6:41 AM, Mikko wrote:
On 2025-06-21 17:34:55 +0000, olcott said:
On 6/21/2025 4:52 AM, Mikko wrote:
On 2025-06-20 13:59:02 +0000, olcott said:
On 6/20/2025 4:20 AM, Fred. Zwarts wrote:
Op 19.jun.2025 om 17:17 schreef olcott:
On 6/19/2025 4:21 AM, Fred. Zwarts wrote:
Op 18.jun.2025 om 15:46 schreef olcott:
On 6/18/2025 5:12 AM, Fred. Zwarts wrote:
Op 18.jun.2025 om 03:54 schreef olcott:
On 6/17/2025 8:19 PM, Richard Damon wrote:
On 6/17/25 4:34 PM, olcott wrote:
void Infinite_Recursion()WHich means that the code for HHH is part of the input, and thus there
{
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. >>>>>>>>>>>>
is just ONE HHH in existance at this time.
Since that code aborts its simulation to return the answer that you
claim, you are just lying that it did a correct simulation (which in
this context means complete)
*none of them ever stop running unless aborted*
All of them do abort and their simulation does not need an abort. >>>>>>>>>>
*It is not given that any of them abort*
At least it is true for all aborting ones, such as the one you >>>>>>>> presented in Halt7.c.
My claim is that each of the above functions correctly
simulated by any termination analyzer HHH that can possibly
exist will never stop running unless aborted by HHH.
Can you affirm or correctly refute this?
Yes, I confirmed many times that we can confirm this vacuous claim, >>>>>> because no such HHH exists. All of them fail to do a correct simulation >>>>>> up to the point where they can see whether the input specifies a
halting program.
if DDD correctly simulated by any simulating termination
analyzer HHH never aborts its simulation of DDD then
that HHH is not interesting.
*then the HP proofs are proved to be wrong*
Does not follow. HHH and DDD are irrelevant to those proofs.
void DDD()
{
HHH(DDD);
return;
}
When I dumbed the original self-referential proof down
to HHH(DDD) everyone here proved that they did not even
understand what ordinary recursion is.
On 6/29/2025 3:56 AM, Mikko wrote:
On 2025-06-28 13:48:36 +0000, olcott said:
On 6/28/2025 6:50 AM, Mikko wrote:
On 2025-06-27 23:26:07 +0000, olcott said:
On 6/26/2025 4:35 AM, Mikko wrote:
On 2025-06-25 14:40:35 +0000, olcott said:
A termination analyzer correctly determines the halt
status of an input program specification for every
input that this program can take. A program specification
taking zero inputs is merely the simpler case of this
same algorithm.
So you do. Perhapts it is a matter of taste but honest people
prefer to call a spade a "spade" and not an "earthmover" or a
"manually operated earthmover".
Every input that a program can take logically includes
programs that take no inputs.
Yes. But the meaning of "termination analyzer" excludes analyzers
that don't analyze programs that do take inputs.
Line 506 has the original: u32 H(ptr P, ptr I)
Line 1243 has the original: void P(ptr x)
https://github.com/plolcott/x86utm/blob/master/Halt7.c
*I had to dumb it down to this*
int main()
{
HHH(DDD);
DDD();
}
*And people still do not understand*
Call a spade a spade if you want to be understood. If you constantly
changing words to other words that are no better you have no reason
to expect any understanding. You can expect people to understand
Common Language and terms defined in the same message or in the
message you are replying to but not ordinary words with unusual
random meanings.
*Termination Analysis without the Tears*
https://www.cs.princeton.edu/~zkincaid/pub/pldi21.pdf
On page three a code snippet is analyzed that takes
no input and its not even a function.
That does not contradict what I said. But the algorithm on the sixth
page (1301) illustrates my point that ability to hadle programs with
input is essential (though the purpose of the algorighm is to
illustrate someting else).
A termination analyzer is required to determine the
halt status of at least one program/C function for
all the inputs/arguments that this program/function
takes, including zero inputs/arguments.
On 6/29/2025 3:44 AM, Mikko wrote:
On 2025-06-28 13:17:17 +0000, olcott said:
On 6/28/2025 6:41 AM, Mikko wrote:
On 2025-06-21 17:34:55 +0000, olcott said:
On 6/21/2025 4:52 AM, Mikko wrote:
On 2025-06-20 13:59:02 +0000, olcott said:
On 6/20/2025 4:20 AM, Fred. Zwarts wrote:
Op 19.jun.2025 om 17:17 schreef olcott:
On 6/19/2025 4:21 AM, Fred. Zwarts wrote:
Op 18.jun.2025 om 15:46 schreef olcott:
On 6/18/2025 5:12 AM, Fred. Zwarts wrote:
Op 18.jun.2025 om 03:54 schreef olcott:
On 6/17/2025 8:19 PM, Richard Damon wrote:
On 6/17/25 4:34 PM, olcott wrote:
void Infinite_Recursion()WHich means that the code for HHH is part of the input, and thus there
{
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. >>>>>>>>>>>>>>
is just ONE HHH in existance at this time.
Since that code aborts its simulation to return the answer that you
claim, you are just lying that it did a correct simulation (which in
this context means complete)
*none of them ever stop running unless aborted*
All of them do abort and their simulation does not need an abort. >>>>>>>>>>>>
*It is not given that any of them abort*
At least it is true for all aborting ones, such as the one you >>>>>>>>>> presented in Halt7.c.
My claim is that each of the above functions correctly
simulated by any termination analyzer HHH that can possibly
exist will never stop running unless aborted by HHH.
Can you affirm or correctly refute this?
Yes, I confirmed many times that we can confirm this vacuous claim, >>>>>>>> because no such HHH exists. All of them fail to do a correct simulation
up to the point where they can see whether the input specifies a >>>>>>>> halting program.
if DDD correctly simulated by any simulating termination
analyzer HHH never aborts its simulation of DDD then
that HHH is not interesting.
*then the HP proofs are proved to be wrong*
Does not follow. HHH and DDD are irrelevant to those proofs.
void DDD()
{
HHH(DDD);
return;
}
When I dumbed the original self-referential proof down
to HHH(DDD) everyone here proved that they did not even
understand what ordinary recursion is.
That you are dumb does not mean that others don't understand
ordinary recursion.
Mensa scored me on the top 3% of the population.
This is a little more difficult than ordinary recursion.
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/30/2025 4:58 AM, Mikko wrote:
On 2025-06-29 14:21:55 +0000, olcott said:
On 6/29/2025 3:44 AM, Mikko wrote:
On 2025-06-28 13:17:17 +0000, olcott said:
On 6/28/2025 6:41 AM, Mikko wrote:
On 2025-06-21 17:34:55 +0000, olcott said:
On 6/21/2025 4:52 AM, Mikko wrote:
On 2025-06-20 13:59:02 +0000, olcott said:
On 6/20/2025 4:20 AM, Fred. Zwarts wrote:
Op 19.jun.2025 om 17:17 schreef olcott:
On 6/19/2025 4:21 AM, Fred. Zwarts wrote:
Op 18.jun.2025 om 15:46 schreef olcott:
On 6/18/2025 5:12 AM, Fred. Zwarts wrote:
Op 18.jun.2025 om 03:54 schreef olcott:
On 6/17/2025 8:19 PM, Richard Damon wrote:
On 6/17/25 4:34 PM, olcott wrote:
void Infinite_Recursion()WHich means that the code for HHH is part of the input, and thus there
{
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. >>>>>>>>>>>>>>>>
is just ONE HHH in existance at this time.
Since that code aborts its simulation to return the answer that you
claim, you are just lying that it did a correct simulation (which in
this context means complete)
*none of them ever stop running unless aborted*
All of them do abort and their simulation does not need an abort.
*It is not given that any of them abort*
At least it is true for all aborting ones, such as the one you >>>>>>>>>>>> presented in Halt7.c.
My claim is that each of the above functions correctly
simulated by any termination analyzer HHH that can possibly >>>>>>>>>>> exist will never stop running unless aborted by HHH.
Can you affirm or correctly refute this?
Yes, I confirmed many times that we can confirm this vacuous claim, >>>>>>>>>> because no such HHH exists. All of them fail to do a correct simulation
up to the point where they can see whether the input specifies a >>>>>>>>>> halting program.
if DDD correctly simulated by any simulating termination
analyzer HHH never aborts its simulation of DDD then
that HHH is not interesting.
*then the HP proofs are proved to be wrong*
Does not follow. HHH and DDD are irrelevant to those proofs.
void DDD()
{
HHH(DDD);
return;
}
When I dumbed the original self-referential proof down
to HHH(DDD) everyone here proved that they did not even
understand what ordinary recursion is.
That you are dumb does not mean that others don't understand
ordinary recursion.
Mensa scored me on the top 3% of the population.
Your intelligence, not wisdom.
This is a little more difficult than ordinary recursion.
Perhaps to your little mind.
void DDD()
{
HHH(DDD);
return;
}
_DDD()
[00002192] 55 push ebp
[00002193] 8bec mov ebp,esp
[00002195] 6892210000 push 00002192 // push DDD
[0000219a] e833f4ffff call 000015d2 // call HHH
[0000219f] 83c404 add esp,+04
[000021a2] 5d pop ebp
[000021a3] c3 ret
Size in bytes:(0018) [000021a3]
The x86 source code of DDD specifies that this emulated
DDD cannot possibly reach its own emulated "ret" instruction
final halt state when emulated by HHH according to the
semantics of the x86 language.
That defect in HHH is already known and a possible fix has been proposed.
Four Chatbots all agree that the input to simulating termination
analyzer HHH(DDD) specifies non-terminating recursive emulation
even though the directly executed DDD() halts.
| Sysop: | Keyop |
|---|---|
| Location: | Huddersfield, West Yorkshire, UK |
| Users: | 546 |
| Nodes: | 16 (2 / 14) |
| Uptime: | 147:16:08 |
| Calls: | 10,383 |
| Calls today: | 8 |
| Files: | 14,054 |
| D/L today: |
2 files (1,861K bytes) |
| Messages: | 6,417,728 |