int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
It is a verified fact that DD() *is* one of the forms
of the counter-example input as such an input would
be encoded in C. Christopher Strachey wrote his in CPL.
// rec routine P
// §L :if T[P] go to L
// Return §
// https://academic.oup.com/comjnl/article/7/4/313/354243
void Strachey_P()
{
L: if (HHH(Strachey_P)) goto L;
return;
}
https://academic.oup.com/comjnl/article-abstract/7/4/313/354243? redirectedFrom=fulltext
It *is* a verified fact DD correctly simulated by HHH
cannot possibly reach its own "return" statement
final halt state.
All of the above code is fully operational in this file https://github.com/plolcott/x86utm/blob/master/Halt7.c
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
It is a verified fact that DD() *is* one of the forms
of the counter-example input as such an input would
be encoded in C. Christopher Strachey wrote his in CPL.
// rec routine P
// §L :if T[P] go to L
// Return §
// https://academic.oup.com/comjnl/article/7/4/313/354243
void Strachey_P()
{
L: if (HHH(Strachey_P)) goto L;
return;
}
https://academic.oup.com/comjnl/article-abstract/7/4/313/354243?redirectedFrom=fulltext
It *is* a verified fact DD correctly simulated by HHH cannot
possibly reach its own "return" statement final halt state
because the input to HHH(DD) specifies recursive simulation.
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
It is a verified fact that DD() *is* one of the forms
of the counter-example input as such an input would
be encoded in C. Christopher Strachey wrote his in CPL.
// rec routine P
// §L :if T[P] go to L
// Return §
// https://academic.oup.com/comjnl/article/7/4/313/354243
void Strachey_P()
{
L: if (HHH(Strachey_P)) goto L;
return;
}
https://academic.oup.com/comjnl/article-abstract/7/4/313/354243?redirectedFrom=fulltext
It *is* a verified fact DD correctly simulated by HHH
cannot possibly reach its own "return" statement
final halt state.
On 6/13/2025 4:26 AM, Fred. Zwarts wrote:
Op 12.jun.2025 om 17:30 schreef olcott:
Even after many corrections, Olcott repeated his claims without
learning anything from his previous errors.
Lack of knowledge does not make someone look stupid, but the
resistance against learning does.
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
It is a verified fact that DD() *is* one of the forms
of the counter-example input as such an input would
be encoded in C. Christopher Strachey wrote his in CPL.
// rec routine P
// §L :if T[P] go to L
// Return §
// https://academic.oup.com/comjnl/article/7/4/313/354243
void Strachey_P()
{
L: if (HHH(Strachey_P)) goto L;
return;
}
https://academic.oup.com/comjnl/article-abstract/7/4/313/354243?
redirectedFrom=fulltext
It *is* a verified fact DD correctly simulated by HHH
cannot possibly reach its own "return" statement
final halt state.
Showing the failure of HHH to reach the end of the simulation.
The code of the input to HHH(DD) specifies
HHH simulates DD that calls HHH(DD)
HHH simulates DD that calls HHH(DD)
HHH simulates DD that calls HHH(DD)...
That you can't understand this is merely a lack
of sufficient tecnh9cal competence on your part.
That you continue to fail to show all of the details
of exactly how DD does reach its simulated "return"
statement final halt state proves that you know you
are not competent.
A simulation that is no problem for other world-class simulators.
What is the purpose to verify the fact of a failure? Another
confirmation of the halting theorem?
All of the above code is fully operational in this file
https://github.com/plolcott/x86utm/blob/master/Halt7.c
Halt.c includes code to abort and halt the simulation.
HHH is not able to simulate this code correctly, because the criteria
to abort are incorrect. It aborts the simulation even for some halting
programs, including the simulation of itself.
On 6/13/2025 12:33 PM, Richard Damon wrote:
On 6/13/25 1:26 PM, olcott wrote:THE SIMULATED DD CANNOT POSSIBLY REACH ITS SIMULATED FINAL
On 6/13/2025 12:19 PM, Richard Damon wrote:
On 6/13/25 10:37 AM, olcott wrote:
On 6/13/2025 4:26 AM, Fred. Zwarts wrote:
Op 12.jun.2025 om 17:30 schreef olcott:
Even after many corrections, Olcott repeated his claims without
learning anything from his previous errors.
Lack of knowledge does not make someone look stupid, but the
resistance against learning does.
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
It is a verified fact that DD() *is* one of the forms
of the counter-example input as such an input would
be encoded in C. Christopher Strachey wrote his in CPL.
// rec routine P
// §L :if T[P] go to L
// Return §
// https://academic.oup.com/comjnl/article/7/4/313/354243
void Strachey_P()
{
L: if (HHH(Strachey_P)) goto L;
return;
}
https://academic.oup.com/comjnl/article-abstract/7/4/313/354243? >>>>>>> redirectedFrom=fulltext
It *is* a verified fact DD correctly simulated by HHH
cannot possibly reach its own "return" statement
final halt state.
Showing the failure of HHH to reach the end of the simulation.
The code of the input to HHH(DD) specifies
HHH simulates DD that calls HHH(DD)
HHH simulates DD that calls HHH(DD)
HHH simulates DD that calls HHH(DD)...
Then you are lying that HHH will abort and return 0.
That is your problem, you world is based on being able to just lie
about what you want.
That you can't understand this is merely a lack
of sufficient tecnh9cal competence on your part.
No, it is merely a lack of honesty on your part.
That you continue to fail to show all of the details
of exactly how DD does reach its simulated "return"
statement final halt state proves that you know you
are not competent.
But DD DOES reach its final state
YOU DAMNED JACKASS.
On 6/13/2025 12:19 PM, Richard Damon wrote:
On 6/13/25 10:37 AM, olcott wrote:You damned liar you changed my words and then rebutted
On 6/13/2025 4:26 AM, Fred. Zwarts wrote:
Op 12.jun.2025 om 17:30 schreef olcott:
Even after many corrections, Olcott repeated his claims without
learning anything from his previous errors.
Lack of knowledge does not make someone look stupid, but the
resistance against learning does.
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
It is a verified fact that DD() *is* one of the forms
of the counter-example input as such an input would
be encoded in C. Christopher Strachey wrote his in CPL.
// rec routine P
// §L :if T[P] go to L
// Return §
// https://academic.oup.com/comjnl/article/7/4/313/354243
void Strachey_P()
{
L: if (HHH(Strachey_P)) goto L;
return;
}
https://academic.oup.com/comjnl/article-abstract/7/4/313/354243?
redirectedFrom=fulltext
It *is* a verified fact DD correctly simulated by HHH
cannot possibly reach its own "return" statement
final halt state.
Showing the failure of HHH to reach the end of the simulation.
The code of the input to HHH(DD) specifies
HHH simulates DD that calls HHH(DD)
HHH simulates DD that calls HHH(DD)
HHH simulates DD that calls HHH(DD)...
Then you are lying that HHH will abort and return 0.
That is your problem, you world is based on being able to just lie
about what you want.
That you can't understand this is merely a lack
of sufficient tecnh9cal competence on your part.
No, it is merely a lack of honesty on your part.
That you continue to fail to show all of the details
of exactly how DD does reach its simulated "return"
statement final halt state proves that you know you
are not competent.
But DD DOES reach its final state when HHH(DD) returns 0,
the changed words.
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
DD does not reach its simulated "return" statement
On 6/13/2025 12:50 PM, Richard Damon wrote:
On 6/13/25 1:37 PM, olcott wrote:You have never shown how DDD correctly emulated by
On 6/13/2025 12:33 PM, Richard Damon wrote:
On 6/13/25 1:26 PM, olcott wrote:THE SIMULATED DD CANNOT POSSIBLY REACH ITS SIMULATED FINAL
On 6/13/2025 12:19 PM, Richard Damon wrote:
On 6/13/25 10:37 AM, olcott wrote:
On 6/13/2025 4:26 AM, Fred. Zwarts wrote:
Op 12.jun.2025 om 17:30 schreef olcott:
Even after many corrections, Olcott repeated his claims without >>>>>>>> learning anything from his previous errors.
Lack of knowledge does not make someone look stupid, but the
resistance against learning does.
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
It is a verified fact that DD() *is* one of the forms
of the counter-example input as such an input would
be encoded in C. Christopher Strachey wrote his in CPL.
// rec routine P
// §L :if T[P] go to L
// Return §
// https://academic.oup.com/comjnl/article/7/4/313/354243
void Strachey_P()
{
L: if (HHH(Strachey_P)) goto L;
return;
}
https://academic.oup.com/comjnl/article-
abstract/7/4/313/354243? redirectedFrom=fulltext
It *is* a verified fact DD correctly simulated by HHH
cannot possibly reach its own "return" statement
final halt state.
Showing the failure of HHH to reach the end of the simulation.
The code of the input to HHH(DD) specifies
HHH simulates DD that calls HHH(DD)
HHH simulates DD that calls HHH(DD)
HHH simulates DD that calls HHH(DD)...
Then you are lying that HHH will abort and return 0.
That is your problem, you world is based on being able to just lie >>>>>> about what you want.
That you can't understand this is merely a lack
of sufficient tecnh9cal competence on your part.
No, it is merely a lack of honesty on your part.
That you continue to fail to show all of the details
of exactly how DD does reach its simulated "return"
statement final halt state proves that you know you
are not competent.
But DD DOES reach its final state
YOU DAMNED JACKASS.
So you erroneously think. I have shown how it does.
simulating termination analyzer HHH reaches its own
simulated final halt state.
I thought that I made a square circle once until
I added the unstated requirement that it must be
in the same two dimensional plane.
On 6/13/2025 6:38 PM, Richard Damon wrote:
On 6/13/25 2:03 PM, olcott wrote:
On 6/13/2025 12:50 PM, Richard Damon wrote:
On 6/13/25 1:37 PM, olcott wrote:You have never shown how DDD correctly emulated by
On 6/13/2025 12:33 PM, Richard Damon wrote:
On 6/13/25 1:26 PM, olcott wrote:THE SIMULATED DD CANNOT POSSIBLY REACH ITS SIMULATED FINAL
On 6/13/2025 12:19 PM, Richard Damon wrote:
On 6/13/25 10:37 AM, olcott wrote:
On 6/13/2025 4:26 AM, Fred. Zwarts wrote:
Op 12.jun.2025 om 17:30 schreef olcott:The code of the input to HHH(DD) specifies
Even after many corrections, Olcott repeated his claims
without learning anything from his previous errors.
Lack of knowledge does not make someone look stupid, but the >>>>>>>>>> resistance against learning does.
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
It is a verified fact that DD() *is* one of the forms
of the counter-example input as such an input would
be encoded in C. Christopher Strachey wrote his in CPL.
// rec routine P
// §L :if T[P] go to L
// Return §
// https://academic.oup.com/comjnl/article/7/4/313/354243 >>>>>>>>>>> void Strachey_P()
{
L: if (HHH(Strachey_P)) goto L;
return;
}
https://academic.oup.com/comjnl/article-
abstract/7/4/313/354243? redirectedFrom=fulltext
It *is* a verified fact DD correctly simulated by HHH
cannot possibly reach its own "return" statement
final halt state.
Showing the failure of HHH to reach the end of the simulation. >>>>>>>>>
HHH simulates DD that calls HHH(DD)
HHH simulates DD that calls HHH(DD)
HHH simulates DD that calls HHH(DD)...
Then you are lying that HHH will abort and return 0.
That is your problem, you world is based on being able to just >>>>>>>> lie about what you want.
That you can't understand this is merely a lack
of sufficient tecnh9cal competence on your part.
No, it is merely a lack of honesty on your part.
That you continue to fail to show all of the details
of exactly how DD does reach its simulated "return"
statement final halt state proves that you know you
are not competent.
But DD DOES reach its final state
YOU DAMNED JACKASS.
So you erroneously think. I have shown how it does.
simulating termination analyzer HHH reaches its own
simulated final halt state.
And why should I?
Therefore admitting that you are a damned* liar.
Therefore admitting that you are a damned* liar.
Therefore admitting that you are a damned* liar.
Therefore admitting that you are a damned* liar.
* Condemned to actual Hell
On 6/13/2025 9:14 PM, Richard Damon wrote:
On 6/13/25 8:27 PM, olcott wrote:
On 6/13/2025 6:38 PM, Richard Damon wrote:
On 6/13/25 2:03 PM, olcott wrote:
On 6/13/2025 12:50 PM, Richard Damon wrote:
On 6/13/25 1:37 PM, olcott wrote:You have never shown how DDD correctly emulated by
On 6/13/2025 12:33 PM, Richard Damon wrote:
On 6/13/25 1:26 PM, olcott wrote:THE SIMULATED DD CANNOT POSSIBLY REACH ITS SIMULATED FINAL
On 6/13/2025 12:19 PM, Richard Damon wrote:
On 6/13/25 10:37 AM, olcott wrote:
On 6/13/2025 4:26 AM, Fred. Zwarts wrote:
Op 12.jun.2025 om 17:30 schreef olcott:The code of the input to HHH(DD) specifies
Even after many corrections, Olcott repeated his claims >>>>>>>>>>>> without learning anything from his previous errors.
Lack of knowledge does not make someone look stupid, but the >>>>>>>>>>>> resistance against learning does.
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
It is a verified fact that DD() *is* one of the forms >>>>>>>>>>>>> of the counter-example input as such an input would
be encoded in C. Christopher Strachey wrote his in CPL. >>>>>>>>>>>>>
// rec routine P
// §L :if T[P] go to L
// Return §
// https://academic.oup.com/comjnl/article/7/4/313/354243 >>>>>>>>>>>>> void Strachey_P()
{
L: if (HHH(Strachey_P)) goto L;
return;
}
https://academic.oup.com/comjnl/article-
abstract/7/4/313/354243? redirectedFrom=fulltext
It *is* a verified fact DD correctly simulated by HHH >>>>>>>>>>>>> cannot possibly reach its own "return" statement
final halt state.
Showing the failure of HHH to reach the end of the simulation. >>>>>>>>>>>
HHH simulates DD that calls HHH(DD)
HHH simulates DD that calls HHH(DD)
HHH simulates DD that calls HHH(DD)...
Then you are lying that HHH will abort and return 0.
That is your problem, you world is based on being able to just >>>>>>>>>> lie about what you want.
That you can't understand this is merely a lack
of sufficient tecnh9cal competence on your part.
No, it is merely a lack of honesty on your part.
That you continue to fail to show all of the details
of exactly how DD does reach its simulated "return"
statement final halt state proves that you know you
are not competent.
But DD DOES reach its final state
YOU DAMNED JACKASS.
So you erroneously think. I have shown how it does.
simulating termination analyzer HHH reaches its own
simulated final halt state.
And why should I?
Therefore admitting that you are a damned* liar.
Therefore admitting that you are a damned* liar.
Therefore admitting that you are a damned* liar.
Therefore admitting that you are a damned* liar.
* Condemned to actual Hell
SO, what is the lie?
I am just pointing out that your strawman criteria is just invalid.
You can not show all of the details of how and why
it is proved to be invalid because my criteria is correct.
How is that a lie.
Note, I never say that *IF* HHH does a correct simulation, that it can
not reach a final state, just that your HHH doesn't do that correct
simulation, and thus that criteria is non-sense.
HHH does do the minimum required for a correct decision.
On 6/13/2025 4:26 AM, Fred. Zwarts wrote:
Op 12.jun.2025 om 17:30 schreef olcott:
Even after many corrections, Olcott repeated his claims without
learning anything from his previous errors.
Lack of knowledge does not make someone look stupid, but the
resistance against learning does.
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
It is a verified fact that DD() *is* one of the forms
of the counter-example input as such an input would
be encoded in C. Christopher Strachey wrote his in CPL.
// rec routine P
// §L :if T[P] go to L
// Return §
// https://academic.oup.com/comjnl/article/7/4/313/354243
void Strachey_P()
{
L: if (HHH(Strachey_P)) goto L;
return;
}
https://academic.oup.com/comjnl/article-abstract/7/4/313/354243?
redirectedFrom=fulltext
It *is* a verified fact DD correctly simulated by HHH
cannot possibly reach its own "return" statement
final halt state.
Showing the failure of HHH to reach the end of the simulation.
The code of the input to HHH(DD) specifies
HHH simulates DD that calls HHH(DD)
HHH simulates DD that calls HHH(DD)
HHH simulates DD that calls HHH(DD)...
That you can't understand this is merely a lack
of sufficient tecnh9cal competence on your part.
That you continue to fail to show all of the details
of exactly how DD does reach its simulated "return"
statement final halt state proves that you know you
are not competent.
On 6/13/2025 5:20 AM, Mikko wrote:
On 2025-06-12 15:34:01 +0000, olcott said:
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
It is a verified fact that DD() *is* one of the forms
of the counter-example input as such an input would
be encoded in C. Christopher Strachey wrote his in CPL.
// rec routine P
// §L :if T[P] go to L
// Return §
// https://academic.oup.com/comjnl/article/7/4/313/354243
void Strachey_P()
{
L: if (HHH(Strachey_P)) goto L;
return;
}
https://academic.oup.com/comjnl/article-abstract/7/4/313/354243?
redirectedFrom=fulltext
It *is* a verified fact DD correctly simulated by HHH cannot
possibly reach its own "return" statement final halt state
because the input to HHH(DD) specifies recursive simulation.
False. It is not the reursive simulation that prevents the reaching
the simulation of the "return" statement. Instead, previention is
a consequence of the discontinuation of the simulation that the
input specifies.
When you try to prove this by providing ALL of the
details you will find that you are incorrect.
On 6/13/2025 5:51 AM, Mikko wrote:
On 2025-06-12 15:30:05 +0000, olcott said:
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
It is a verified fact that DD() *is* one of the forms
of the counter-example input as such an input would
be encoded in C. Christopher Strachey wrote his in CPL.
// rec routine P
// §L :if T[P] go to L
// Return §
// https://academic.oup.com/comjnl/article/7/4/313/354243
void Strachey_P()
{
L: if (HHH(Strachey_P)) goto L;
return;
}
https://academic.oup.com/comjnl/article-abstract/7/4/313/354243?
redirectedFrom=fulltext
Strachey only informally presents the idea of the proof. Formalism
and details needed in a rigorous proof is not shown.
void DDD()
{
HHH(DDD);
return;
}
_DDD()
[00002192] 55 push ebp
[00002193] 8bec mov ebp,esp
[00002195] 6892210000 push 00002192
[0000219a] e833f4ffff call 000015d2 // call HHH
[0000219f] 83c404 add esp,+04
[000021a2] 5d pop ebp
[000021a3] c3 ret
Size in bytes:(0018) [000021a3]
Exactly how would DDD correctly emulated by HHH
reach its own "ret" instruction final halt state?
The directly executed HHH emulates DDD that calls
HHH(DDD) to emulate DDD again until this directly
executed HHH sees the repeating pattern then aborts
its simulation of DDD causing every level of
emulation to immediately stop.
It *is* a verified fact DD correctly simulated by HHH
cannot possibly reach its own "return" statement
final halt state.
That "cannot possibly" is not a part of any verifiable fact as
it is not sufficiently well-defined for a verification.
It is a self-evident truth that required actual comprehension
to be complete proof.
2 + 3 = 5 is another example of a self-evident truth.
Some people could say "I doan beeve in nummers". That
is not any rebuttal.
What
cannot be stated cearly and unambiguoulsy cannot be a verified
fact.
HHH emulates DDD that calls HHH(DDD)
that emulates DDD that calls HHH(DDD)
that emulates DDD that calls HHH(DDD)
that emulates DDD that calls HHH(DDD)...
until the outer HHH sees the repeating
pattern and aborts its own emulation thus
killing off every other emulation.
On 6/13/2025 9:14 PM, Richard Damon wrote:
On 6/13/25 8:27 PM, olcott wrote:
On 6/13/2025 6:38 PM, Richard Damon wrote:
On 6/13/25 2:03 PM, olcott wrote:
On 6/13/2025 12:50 PM, Richard Damon wrote:
On 6/13/25 1:37 PM, olcott wrote:You have never shown how DDD correctly emulated by
On 6/13/2025 12:33 PM, Richard Damon wrote:
On 6/13/25 1:26 PM, olcott wrote:THE SIMULATED DD CANNOT POSSIBLY REACH ITS SIMULATED FINAL
On 6/13/2025 12:19 PM, Richard Damon wrote:
On 6/13/25 10:37 AM, olcott wrote:
On 6/13/2025 4:26 AM, Fred. Zwarts wrote:
Op 12.jun.2025 om 17:30 schreef olcott:The code of the input to HHH(DD) specifies
Even after many corrections, Olcott repeated his claims >>>>>>>>>>>> without learning anything from his previous errors.
Lack of knowledge does not make someone look stupid, but the >>>>>>>>>>>> resistance against learning does.
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
It is a verified fact that DD() *is* one of the forms >>>>>>>>>>>>> of the counter-example input as such an input would
be encoded in C. Christopher Strachey wrote his in CPL. >>>>>>>>>>>>>
// rec routine P
// §L :if T[P] go to L
// Return §
// https://academic.oup.com/comjnl/article/7/4/313/354243 >>>>>>>>>>>>> void Strachey_P()
{
L: if (HHH(Strachey_P)) goto L;
return;
}
https://academic.oup.com/comjnl/article-
abstract/7/4/313/354243? redirectedFrom=fulltext
It *is* a verified fact DD correctly simulated by HHH >>>>>>>>>>>>> cannot possibly reach its own "return" statement
final halt state.
Showing the failure of HHH to reach the end of the simulation. >>>>>>>>>>>
HHH simulates DD that calls HHH(DD)
HHH simulates DD that calls HHH(DD)
HHH simulates DD that calls HHH(DD)...
Then you are lying that HHH will abort and return 0.
That is your problem, you world is based on being able to just >>>>>>>>>> lie about what you want.
That you can't understand this is merely a lack
of sufficient tecnh9cal competence on your part.
No, it is merely a lack of honesty on your part.
That you continue to fail to show all of the details
of exactly how DD does reach its simulated "return"
statement final halt state proves that you know you
are not competent.
But DD DOES reach its final state
YOU DAMNED JACKASS.
So you erroneously think. I have shown how it does.
simulating termination analyzer HHH reaches its own
simulated final halt state.
And why should I?
Therefore admitting that you are a damned* liar.
Therefore admitting that you are a damned* liar.
Therefore admitting that you are a damned* liar.
Therefore admitting that you are a damned* liar.
* Condemned to actual Hell
SO, what is the lie?
I am just pointing out that your strawman criteria is just invalid.
You can not show all of the details of how and why
it is proved to be invalid because my criteria is correct.
When you try to go counter-factual you look really silly.
How is that a lie.
Note, I never say that *IF* HHH does a correct simulation, that it can
not reach a final state, just that your HHH doesn't do that correct
simulation, and thus that criteria is non-sense.
HHH does do the minimum required for a correct decision.
You yourself condemn the use of strawmen, but then, you always
projected your errors onto others, just like Trump, who seems to be
your model for behavior and logic.
You logic is based on the need to say that two things that are very
different are actually exactly the same thing.
That is just a LIE. Just like most of what you say.
On 6/14/2025 6:30 AM, Mikko wrote:
On 2025-06-13 15:22:04 +0000, olcott said:
On 6/13/2025 5:20 AM, Mikko wrote:
On 2025-06-12 15:34:01 +0000, olcott said:
int DD()
{
�� int Halt_Status = HHH(DD);
�� if (Halt_Status)
���� HERE: goto HERE;
�� return Halt_Status;
}
It is a verified fact that DD() *is* one of the forms
of the counter-example input as such an input would
be encoded in C. Christopher Strachey wrote his in CPL.
// rec routine P
//�� �L :if T[P] go to L
//���� Return �
// https://academic.oup.com/comjnl/article/7/4/313/354243
void Strachey_P()
{
�� L: if (HHH(Strachey_P)) goto L;
�� return;
}
https://academic.oup.com/comjnl/article-abstract/7/4/313/354243? redirectedFrom=fulltext
It *is* a verified fact DD correctly simulated by HHH cannot
possibly reach its own "return" statement final halt state
because the input to HHH(DD) specifies recursive simulation.
False. It is not the reursive simulation that prevents the reaching
the simulation of the "return" statement. Instead, previention is
a consequence of the discontinuation of the simulation that the
input specifies.
When you try to prove this by providing ALL of the
details you will find that you are incorrect.
I don't need to prove anything. It is sufficient to point out that
you have not proven anything. For this discussion a sufficient
proof that HHH aborts is simulation is that you have said it does.
This code proves everything that I claimed beyond all possible doubt https://github.com/plolcott/x86utm/blob/master/Halt7.c
Mike verified everything that I claimed from this code except the
very last step of my proof. Mike demonstrated the non-halting behavior pattern for infinite loops.
He might understand the non-halting
behavior patterns for infinite recursion.
The only thing left is understanding the non-halting behavior
pattern of recursive simulation.
On 6/13/2025 5:51 AM, Mikko wrote:
On 2025-06-12 15:30:05 +0000, olcott said:
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
It is a verified fact that DD() *is* one of the forms
of the counter-example input as such an input would
be encoded in C. Christopher Strachey wrote his in CPL.
// rec routine P
// §L :if T[P] go to L
// Return §
// https://academic.oup.com/comjnl/article/7/4/313/354243
void Strachey_P()
{
L: if (HHH(Strachey_P)) goto L;
return;
}
https://academic.oup.com/comjnl/article-abstract/7/4/313/354243?
redirectedFrom=fulltext
Strachey only informally presents the idea of the proof. Formalism
and details needed in a rigorous proof is not shown.
It *is* a verified fact DD correctly simulated by HHH
cannot possibly reach its own "return" statement
final halt state.
That "cannot possibly" is not a part of any verifiable fact as
it is not sufficiently well-defined for a verification. What
cannot be stated cearly and unambiguoulsy cannot be a verified
fact.
void DDD()
{
HHH(DDD);
return;
}
_DDD()
[00002192] 55 push ebp
[00002193] 8bec mov ebp,esp
[00002195] 6892210000 push 00002192
[0000219a] e833f4ffff call 000015d2 // call HHH
[0000219f] 83c404 add esp,+04
[000021a2] 5d pop ebp
[000021a3] c3 ret
Size in bytes:(0018) [000021a3]
It is a self-evidently true verified fact that DDD
correctly emulated by HHH cannot possibly reach its
own simulated "ret" instruction final halt state in
1 to ∞ steps of correct emulation of DDD by HHH.
Everyone that does not agree has less than a first
year CS student's understanding of the C programming
language.
On 6/14/2025 4:10 AM, Fred. Zwarts wrote:
Op 13.jun.2025 om 17:53 schreef olcott:
On 6/13/2025 5:51 AM, Mikko wrote:
On 2025-06-12 15:30:05 +0000, olcott said:
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
It is a verified fact that DD() *is* one of the forms
of the counter-example input as such an input would
be encoded in C. Christopher Strachey wrote his in CPL.
// rec routine P
// §L :if T[P] go to L
// Return §
// https://academic.oup.com/comjnl/article/7/4/313/354243
void Strachey_P()
{
L: if (HHH(Strachey_P)) goto L;
return;
}
https://academic.oup.com/comjnl/article-abstract/7/4/313/354243?
redirectedFrom=fulltext
Strachey only informally presents the idea of the proof. Formalism
and details needed in a rigorous proof is not shown.
void DDD()
{
HHH(DDD);
return;
}
_DDD()
[00002192] 55 push ebp
[00002193] 8bec mov ebp,esp
[00002195] 6892210000 push 00002192
[0000219a] e833f4ffff call 000015d2 // call HHH
[0000219f] 83c404 add esp,+04
[000021a2] 5d pop ebp
[000021a3] c3 ret
Size in bytes:(0018) [000021a3]
Exactly how would DDD correctly emulated by HHH
reach its own "ret" instruction final halt state?
Indeed, HHH fails where other world-class simulators have no problem to
simulate the program specified in the input.
So you still don't understand what recursive simulation is?
On 6/14/2025 6:30 AM, Mikko wrote:
On 2025-06-13 15:22:04 +0000, olcott said:
On 6/13/2025 5:20 AM, Mikko wrote:
On 2025-06-12 15:34:01 +0000, olcott said:
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
It is a verified fact that DD() *is* one of the forms
of the counter-example input as such an input would
be encoded in C. Christopher Strachey wrote his in CPL.
// rec routine P
// §L :if T[P] go to L
// Return §
// https://academic.oup.com/comjnl/article/7/4/313/354243
void Strachey_P()
{
L: if (HHH(Strachey_P)) goto L;
return;
}
https://academic.oup.com/comjnl/article-abstract/7/4/313/354243?
redirectedFrom=fulltext
It *is* a verified fact DD correctly simulated by HHH cannot
possibly reach its own "return" statement final halt state
because the input to HHH(DD) specifies recursive simulation.
False. It is not the reursive simulation that prevents the reaching
the simulation of the "return" statement. Instead, previention is
a consequence of the discontinuation of the simulation that the
input specifies.
When you try to prove this by providing ALL of the
details you will find that you are incorrect.
I don't need to prove anything. It is sufficient to point out that
you have not proven anything. For this discussion a sufficient
proof that HHH aborts is simulation is that you have said it does.
This code proves everything that I claimed beyond all possible doubt https://github.com/plolcott/x86utm/blob/master/Halt7.c
On 6/15/2025 4:23 AM, Mikko wrote:
On 2025-06-14 13:53:01 +0000, olcott said:
On 6/14/2025 6:30 AM, Mikko wrote:
On 2025-06-13 15:22:04 +0000, olcott said:
On 6/13/2025 5:20 AM, Mikko wrote:
On 2025-06-12 15:34:01 +0000, olcott said:
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
It is a verified fact that DD() *is* one of the forms
of the counter-example input as such an input would
be encoded in C. Christopher Strachey wrote his in CPL.
// rec routine P
// §L :if T[P] go to L
// Return §
// https://academic.oup.com/comjnl/article/7/4/313/354243
void Strachey_P()
{
L: if (HHH(Strachey_P)) goto L;
return;
}
https://academic.oup.com/comjnl/article-abstract/7/4/313/354243? >>>>>>> redirectedFrom=fulltext
It *is* a verified fact DD correctly simulated by HHH cannot
possibly reach its own "return" statement final halt state
because the input to HHH(DD) specifies recursive simulation.
False. It is not the reursive simulation that prevents the reaching >>>>>> the simulation of the "return" statement. Instead, previention is
a consequence of the discontinuation of the simulation that the
input specifies.
When you try to prove this by providing ALL of the
details you will find that you are incorrect.
I don't need to prove anything. It is sufficient to point out that
you have not proven anything. For this discussion a sufficient
proof that HHH aborts is simulation is that you have said it does.
This code proves everything that I claimed beyond all possible doubt
https://github.com/plolcott/x86utm/blob/master/Halt7.c
More importantly, it proves what I climed: HHH does abort its simulation.
*Just like it is required to do*
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
If simulating halt decider H correctly simulates its
input D until H correctly determines that its simulated D
would never stop running unless aborted then
H can abort its simulation of D and correctly report that D
specifies a non-halting sequence of configurations.
</MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
On 6/15/2025 3:45 AM, Mikko wrote:
On 2025-06-14 13:58:48 +0000, olcott said:
On 6/13/2025 5:51 AM, Mikko wrote:
On 2025-06-12 15:30:05 +0000, olcott said:
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
It is a verified fact that DD() *is* one of the forms
of the counter-example input as such an input would
be encoded in C. Christopher Strachey wrote his in CPL.
// rec routine P
// §L :if T[P] go to L
// Return §
// https://academic.oup.com/comjnl/article/7/4/313/354243
void Strachey_P()
{
L: if (HHH(Strachey_P)) goto L;
return;
}
https://academic.oup.com/comjnl/article-abstract/7/4/313/354243?
redirectedFrom=fulltext
Strachey only informally presents the idea of the proof. Formalism
and details needed in a rigorous proof is not shown.
It *is* a verified fact DD correctly simulated by HHH
cannot possibly reach its own "return" statement
final halt state.
That "cannot possibly" is not a part of any verifiable fact as
it is not sufficiently well-defined for a verification. What
cannot be stated cearly and unambiguoulsy cannot be a verified
fact.
void DDD()
{
HHH(DDD);
return;
}
_DDD()
[00002192] 55 push ebp
[00002193] 8bec mov ebp,esp
[00002195] 6892210000 push 00002192
[0000219a] e833f4ffff call 000015d2 // call HHH
[0000219f] 83c404 add esp,+04
[000021a2] 5d pop ebp
[000021a3] c3 ret
Size in bytes:(0018) [000021a3]
It is a self-evidently true verified fact that DDD
correctly emulated by HHH cannot possibly reach its
own simulated "ret" instruction final halt state in
1 to ∞ steps of correct emulation of DDD by HHH.
That does not make sense.
If you are ignorant enough then 2 + 3 = 5 would make no sense.
If you don't know what "self-evidently true"
or "fact" mean you should not use those expressions. A statement is
"self-evidently true" if it can be seen to be true even the facts are
not known,
WRONG, all relevant facts must be wrong or
"understanding its meaning" will not occur.
In epistemology (theory of knowledge), a self-evident
proposition is a proposition that is known to be true
by understanding its meaning without proof... https://en.wikipedia.org/wiki/Self-evidence
and "fact" is a statement that cannot. Therefore no fact
is self-evidently true.
This is the key new philosophical insight that I have
had into the fundamental nature of analytical truth.
Facts are expressions of language that are stipulated
to be true. "cats are animals" is stipulated to be
true on the basis of the stipulated meaning of those
words. 猫是动物 says the same thing.
Everyone that does not agree has less than a first
year CS student's understanding of the C programming
language.
That does not follow from anything above and is far from any truth.
void Infinite_Recursion()
{
Infinite_Recursion();
}
Anyone that does not understand that the above function
does not halt has far less than a first year CS student
degree of understanding.
On 6/15/2025 4:23 AM, Mikko wrote:
On 2025-06-14 13:53:01 +0000, olcott said:
On 6/14/2025 6:30 AM, Mikko wrote:
On 2025-06-13 15:22:04 +0000, olcott said:
On 6/13/2025 5:20 AM, Mikko wrote:
On 2025-06-12 15:34:01 +0000, olcott said:
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
It is a verified fact that DD() *is* one of the forms
of the counter-example input as such an input would
be encoded in C. Christopher Strachey wrote his in CPL.
// rec routine P
// §L :if T[P] go to L
// Return §
// https://academic.oup.com/comjnl/article/7/4/313/354243
void Strachey_P()
{
L: if (HHH(Strachey_P)) goto L;
return;
}
https://academic.oup.com/comjnl/article-abstract/7/4/313/354243? >>>>>>> redirectedFrom=fulltext
It *is* a verified fact DD correctly simulated by HHH cannot
possibly reach its own "return" statement final halt state
because the input to HHH(DD) specifies recursive simulation.
False. It is not the reursive simulation that prevents the reaching >>>>>> the simulation of the "return" statement. Instead, previention is
a consequence of the discontinuation of the simulation that the
input specifies.
When you try to prove this by providing ALL of the
details you will find that you are incorrect.
I don't need to prove anything. It is sufficient to point out that
you have not proven anything. For this discussion a sufficient
proof that HHH aborts is simulation is that you have said it does.
This code proves everything that I claimed beyond all possible doubt
https://github.com/plolcott/x86utm/blob/master/Halt7.c
More importantly, it proves what I climed: HHH does abort its simulation.
*Just like it is required to do*
On 6/15/2025 3:24 AM, Fred. Zwarts wrote:
Op 14.jun.2025 om 15:38 schreef olcott:
On 6/14/2025 4:10 AM, Fred. Zwarts wrote:
Op 13.jun.2025 om 17:53 schreef olcott:
On 6/13/2025 5:51 AM, Mikko wrote:
On 2025-06-12 15:30:05 +0000, olcott said:
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
It is a verified fact that DD() *is* one of the forms
of the counter-example input as such an input would
be encoded in C. Christopher Strachey wrote his in CPL.
// rec routine P
// §L :if T[P] go to L
// Return §
// https://academic.oup.com/comjnl/article/7/4/313/354243
void Strachey_P()
{
L: if (HHH(Strachey_P)) goto L;
return;
}
https://academic.oup.com/comjnl/article-abstract/7/4/313/354243? >>>>>>> redirectedFrom=fulltext
Strachey only informally presents the idea of the proof. Formalism >>>>>> and details needed in a rigorous proof is not shown.
void DDD()
{
HHH(DDD);
return;
}
_DDD()
[00002192] 55 push ebp
[00002193] 8bec mov ebp,esp
[00002195] 6892210000 push 00002192
[0000219a] e833f4ffff call 000015d2 // call HHH
[0000219f] 83c404 add esp,+04
[000021a2] 5d pop ebp
[000021a3] c3 ret
Size in bytes:(0018) [000021a3]
Exactly how would DDD correctly emulated by HHH
reach its own "ret" instruction final halt state?
Indeed, HHH fails where other world-class simulators have no problem to >>>> simulate the program specified in the input.
So you still don't understand what recursive simulation is?
It seems I understand it better than you do. You seem to think that
every recursion is a infinite recursion. As soon as you see a
recursion, you think it has been proven that it is an infinite
recursion, even if the code specifies an abort and halt.
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
If simulating halt decider H correctly simulates its
input D until H correctly determines that its simulated D
would never stop running unless aborted then
H can abort its simulation of D and correctly report that D
specifies a non-halting sequence of configurations.
</MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
It is an easily verified fact that the input to HHH(DDD) and
the input to HHH(DD) meets the above self-evidently true criteria.
On 6/15/2025 3:39 AM, Mikko wrote:
On 2025-06-14 13:38:48 +0000, olcott said:
On 6/14/2025 4:10 AM, Fred. Zwarts wrote:
Op 13.jun.2025 om 17:53 schreef olcott:
On 6/13/2025 5:51 AM, Mikko wrote:
On 2025-06-12 15:30:05 +0000, olcott said:
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
It is a verified fact that DD() *is* one of the forms
of the counter-example input as such an input would
be encoded in C. Christopher Strachey wrote his in CPL.
// rec routine P
// §L :if T[P] go to L
// Return §
// https://academic.oup.com/comjnl/article/7/4/313/354243
void Strachey_P()
{
L: if (HHH(Strachey_P)) goto L;
return;
}
https://academic.oup.com/comjnl/article-abstract/7/4/313/354243? >>>>>>> redirectedFrom=fulltext
Strachey only informally presents the idea of the proof. Formalism >>>>>> and details needed in a rigorous proof is not shown.
void DDD()
{
HHH(DDD);
return;
}
_DDD()
[00002192] 55 push ebp
[00002193] 8bec mov ebp,esp
[00002195] 6892210000 push 00002192
[0000219a] e833f4ffff call 000015d2 // call HHH
[0000219f] 83c404 add esp,+04
[000021a2] 5d pop ebp
[000021a3] c3 ret
Size in bytes:(0018) [000021a3]
Exactly how would DDD correctly emulated by HHH
reach its own "ret" instruction final halt state?
Indeed, HHH fails where other world-class simulators have no problem to >>>> simulate the program specified in the input.
So you still don't understand what recursive simulation is?
What makes you think that that question is relevant here?
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
If simulating halt decider H correctly simulates its
input D until H correctly determines that its simulated D
would never stop running unless aborted then
H can abort its simulation of D and correctly report that D
specifies a non-halting sequence of configurations.
</MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
It is an easily verified fact that the input to HHH(DDD) and
the input to HHH(DD) meets the above self-evidently true criteria.
On 6/15/2025 3:45 AM, Mikko wrote:
On 2025-06-14 13:58:48 +0000, olcott said:
On 6/13/2025 5:51 AM, Mikko wrote:
On 2025-06-12 15:30:05 +0000, olcott said:
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
It is a verified fact that DD() *is* one of the forms
of the counter-example input as such an input would
be encoded in C. Christopher Strachey wrote his in CPL.
// rec routine P
// §L :if T[P] go to L
// Return §
// https://academic.oup.com/comjnl/article/7/4/313/354243
void Strachey_P()
{
L: if (HHH(Strachey_P)) goto L;
return;
}
https://academic.oup.com/comjnl/article-abstract/7/4/313/354243?
redirectedFrom=fulltext
Strachey only informally presents the idea of the proof. Formalism
and details needed in a rigorous proof is not shown.
It *is* a verified fact DD correctly simulated by HHH
cannot possibly reach its own "return" statement
final halt state.
That "cannot possibly" is not a part of any verifiable fact as
it is not sufficiently well-defined for a verification. What
cannot be stated cearly and unambiguoulsy cannot be a verified
fact.
void DDD()
{
HHH(DDD);
return;
}
_DDD()
[00002192] 55 push ebp
[00002193] 8bec mov ebp,esp
[00002195] 6892210000 push 00002192
[0000219a] e833f4ffff call 000015d2 // call HHH
[0000219f] 83c404 add esp,+04
[000021a2] 5d pop ebp
[000021a3] c3 ret
Size in bytes:(0018) [000021a3]
It is a self-evidently true verified fact that DDD
correctly emulated by HHH cannot possibly reach its
own simulated "ret" instruction final halt state in
1 to ∞ steps of correct emulation of DDD by HHH.
That does not make sense.
If you are ignorant enough then 2 + 3 = 5 would make no sense.
If you don't know what "self-evidently true"
or "fact" mean you should not use those expressions. A statement is
"self-evidently true" if it can be seen to be true even the facts are
not known,
WRONG, all relevant facts must be wrong or
"understanding its meaning" will not occur.
In epistemology (theory of knowledge), a self-evident
proposition is a proposition that is known to be true
by understanding its meaning without proof... https://en.wikipedia.org/wiki/Self-evidence
On 6/16/2025 5:36 AM, Mikko wrote:
On 2025-06-15 13:49:51 +0000, olcott said:
On 6/15/2025 3:24 AM, Fred. Zwarts wrote:
Op 14.jun.2025 om 15:38 schreef olcott:
On 6/14/2025 4:10 AM, Fred. Zwarts wrote:
Op 13.jun.2025 om 17:53 schreef olcott:
On 6/13/2025 5:51 AM, Mikko wrote:
On 2025-06-12 15:30:05 +0000, olcott said:
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
It is a verified fact that DD() *is* one of the forms
of the counter-example input as such an input would
be encoded in C. Christopher Strachey wrote his in CPL.
// rec routine P
// §L :if T[P] go to L
// Return §
// https://academic.oup.com/comjnl/article/7/4/313/354243
void Strachey_P()
{
L: if (HHH(Strachey_P)) goto L;
return;
}
https://academic.oup.com/comjnl/article-
abstract/7/4/313/354243? redirectedFrom=fulltext
Strachey only informally presents the idea of the proof. Formalism >>>>>>>> and details needed in a rigorous proof is not shown.
void DDD()
{
HHH(DDD);
return;
}
_DDD()
[00002192] 55 push ebp
[00002193] 8bec mov ebp,esp
[00002195] 6892210000 push 00002192
[0000219a] e833f4ffff call 000015d2 // call HHH
[0000219f] 83c404 add esp,+04
[000021a2] 5d pop ebp
[000021a3] c3 ret
Size in bytes:(0018) [000021a3]
Exactly how would DDD correctly emulated by HHH
reach its own "ret" instruction final halt state?
Indeed, HHH fails where other world-class simulators have no
problem to simulate the program specified in the input.
So you still don't understand what recursive simulation is?
It seems I understand it better than you do. You seem to think that
every recursion is a infinite recursion. As soon as you see a
recursion, you think it has been proven that it is an infinite
recursion, even if the code specifies an abort and halt.
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
If simulating halt decider H correctly simulates its
input D until H correctly determines that its simulated D
would never stop running unless aborted then
H can abort its simulation of D and correctly report that D
specifies a non-halting sequence of configurations.
</MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
It is an easily verified fact that the input to HHH(DDD) and
the input to HHH(DD) meets the above self-evidently true criteria.
No, they don't meet the second cireterion. HHH does not correctly
determine that its input would never stop running unless aborted.
Perhaps you may deceive with someting like equivocation someone to
believe it does but in reality it does not.
No one has ever even attempted to show the details
of how this is not correct:
void DDD()
{
HHH(DDD);
return;
}
When one or more instructions of DDD are correctly
simulated by ANY simulating termination analyzer HHH
then this correctly simulated DDD never reaches its
simulated "return" statement final halt state.
On 6/16/2025 5:36 AM, Mikko wrote:
On 2025-06-15 13:49:51 +0000, olcott said:
On 6/15/2025 3:24 AM, Fred. Zwarts wrote:
Op 14.jun.2025 om 15:38 schreef olcott:
On 6/14/2025 4:10 AM, Fred. Zwarts wrote:
Op 13.jun.2025 om 17:53 schreef olcott:
On 6/13/2025 5:51 AM, Mikko wrote:
On 2025-06-12 15:30:05 +0000, olcott said:
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
It is a verified fact that DD() *is* one of the forms
of the counter-example input as such an input would
be encoded in C. Christopher Strachey wrote his in CPL.
// rec routine P
// §L :if T[P] go to L
// Return §
// https://academic.oup.com/comjnl/article/7/4/313/354243
void Strachey_P()
{
L: if (HHH(Strachey_P)) goto L;
return;
}
https://academic.oup.com/comjnl/article-abstract/7/4/313/354243? >>>>>>>>> redirectedFrom=fulltext
Strachey only informally presents the idea of the proof. Formalism >>>>>>>> and details needed in a rigorous proof is not shown.
void DDD()
{
HHH(DDD);
return;
}
_DDD()
[00002192] 55 push ebp
[00002193] 8bec mov ebp,esp
[00002195] 6892210000 push 00002192
[0000219a] e833f4ffff call 000015d2 // call HHH
[0000219f] 83c404 add esp,+04
[000021a2] 5d pop ebp
[000021a3] c3 ret
Size in bytes:(0018) [000021a3]
Exactly how would DDD correctly emulated by HHH
reach its own "ret" instruction final halt state?
Indeed, HHH fails where other world-class simulators have no problem to >>>>>> simulate the program specified in the input.
So you still don't understand what recursive simulation is?
It seems I understand it better than you do. You seem to think that
every recursion is a infinite recursion. As soon as you see a
recursion, you think it has been proven that it is an infinite
recursion, even if the code specifies an abort and halt.
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
If simulating halt decider H correctly simulates its
input D until H correctly determines that its simulated D
would never stop running unless aborted then
H can abort its simulation of D and correctly report that D
specifies a non-halting sequence of configurations.
</MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
It is an easily verified fact that the input to HHH(DDD) and
the input to HHH(DD) meets the above self-evidently true criteria.
No, they don't meet the second cireterion. HHH does not correctly
determine that its input would never stop running unless aborted.
Perhaps you may deceive with someting like equivocation someone to
believe it does but in reality it does not.
No one has ever even attempted to show the details
of how this is not correct:
void DDD()
{
HHH(DDD);
return;
}
When one or more instructions of DDD are correctly
simulated by ANY simulating termination analyzer HHH
then this correctly simulated DDD never reaches its
simulated "return" statement final halt state.
On 6/16/2025 8:41 PM, Richard Damon wrote:
On 6/16/25 3:35 PM, olcott wrote:
On 6/16/2025 5:36 AM, Mikko wrote:
On 2025-06-15 13:49:51 +0000, olcott said:
On 6/15/2025 3:24 AM, Fred. Zwarts wrote:
Op 14.jun.2025 om 15:38 schreef olcott:
On 6/14/2025 4:10 AM, Fred. Zwarts wrote:
Op 13.jun.2025 om 17:53 schreef olcott:
On 6/13/2025 5:51 AM, Mikko wrote:
On 2025-06-12 15:30:05 +0000, olcott said:
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
It is a verified fact that DD() *is* one of the forms
of the counter-example input as such an input would
be encoded in C. Christopher Strachey wrote his in CPL.
// rec routine P
// §L :if T[P] go to L
// Return §
// https://academic.oup.com/comjnl/article/7/4/313/354243 >>>>>>>>>>> void Strachey_P()
{
L: if (HHH(Strachey_P)) goto L;
return;
}
https://academic.oup.com/comjnl/article-
abstract/7/4/313/354243? redirectedFrom=fulltext
Strachey only informally presents the idea of the proof.
Formalism
and details needed in a rigorous proof is not shown.
void DDD()
{
HHH(DDD);
return;
}
_DDD()
[00002192] 55 push ebp
[00002193] 8bec mov ebp,esp
[00002195] 6892210000 push 00002192
[0000219a] e833f4ffff call 000015d2 // call HHH
[0000219f] 83c404 add esp,+04
[000021a2] 5d pop ebp
[000021a3] c3 ret
Size in bytes:(0018) [000021a3]
Exactly how would DDD correctly emulated by HHH
reach its own "ret" instruction final halt state?
Indeed, HHH fails where other world-class simulators have no
problem to simulate the program specified in the input.
So you still don't understand what recursive simulation is?
It seems I understand it better than you do. You seem to think
that every recursion is a infinite recursion. As soon as you see a >>>>>> recursion, you think it has been proven that it is an infinite
recursion, even if the code specifies an abort and halt.
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022> >>>>> If simulating halt decider H correctly simulates its
input D until H correctly determines that its simulated D
would never stop running unless aborted then
H can abort its simulation of D and correctly report that D >>>>> specifies a non-halting sequence of configurations.
</MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022> >>>>>
It is an easily verified fact that the input to HHH(DDD) and
the input to HHH(DD) meets the above self-evidently true criteria.
No, they don't meet the second cireterion. HHH does not correctly
determine that its input would never stop running unless aborted.
Perhaps you may deceive with someting like equivocation someone to
believe it does but in reality it does not.
No one has ever even attempted to show the details
of how this is not correct:
void DDD()
{
HHH(DDD);
return;
}
When one or more instructions of DDD are correctly
simulated by ANY simulating termination analyzer HHH
then this correctly simulated DDD never reaches its
simulated "return" statement final halt state.
The problem is that isn't the definition of non-halting, and thus
irrelevent.
Counter-factual.
Halting is defined as reaching a final halt state.
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.
You have indicated that you agree that this actually is an error in
your logic by failing to actually attempt to refute the error pointed
out with any actual facts. All you do is continue to make the baseless
claim, which is just a lie.
Sorry, but your refusal to even try to argue to the facts, but just
repeat your baseless assertion just shows that you known and
effectively acknoledge that you have no actual basis for the claim (if
you had a basis, why look like an idiot and not present it).
On 6/17/2025 3:42 AM, Mikko wrote:
On 2025-06-16 19:35:52 +0000, olcott said:
On 6/16/2025 5:36 AM, Mikko wrote:
On 2025-06-15 13:49:51 +0000, olcott said:
On 6/15/2025 3:24 AM, Fred. Zwarts wrote:
Op 14.jun.2025 om 15:38 schreef olcott:
On 6/14/2025 4:10 AM, Fred. Zwarts wrote:
Op 13.jun.2025 om 17:53 schreef olcott:
On 6/13/2025 5:51 AM, Mikko wrote:
On 2025-06-12 15:30:05 +0000, olcott said:
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
It is a verified fact that DD() *is* one of the forms
of the counter-example input as such an input would
be encoded in C. Christopher Strachey wrote his in CPL.
// rec routine P
// §L :if T[P] go to L
// Return §
// https://academic.oup.com/comjnl/article/7/4/313/354243 >>>>>>>>>>> void Strachey_P()
{
L: if (HHH(Strachey_P)) goto L;
return;
}
https://academic.oup.com/comjnl/article- abstract/7/4/313/354243? >>>>>>>>>>> redirectedFrom=fulltext
Strachey only informally presents the idea of the proof. Formalism >>>>>>>>>> and details needed in a rigorous proof is not shown.
void DDD()
{
HHH(DDD);
return;
}
_DDD()
[00002192] 55 push ebp
[00002193] 8bec mov ebp,esp
[00002195] 6892210000 push 00002192
[0000219a] e833f4ffff call 000015d2 // call HHH
[0000219f] 83c404 add esp,+04
[000021a2] 5d pop ebp
[000021a3] c3 ret
Size in bytes:(0018) [000021a3]
Exactly how would DDD correctly emulated by HHH
reach its own "ret" instruction final halt state?
Indeed, HHH fails where other world-class simulators have no problem to
simulate the program specified in the input.
So you still don't understand what recursive simulation is?
It seems I understand it better than you do. You seem to think that >>>>>> every recursion is a infinite recursion. As soon as you see a
recursion, you think it has been proven that it is an infinite
recursion, even if the code specifies an abort and halt.
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022> >>>>> If simulating halt decider H correctly simulates its
input D until H correctly determines that its simulated D
would never stop running unless aborted then
H can abort its simulation of D and correctly report that D >>>>> specifies a non-halting sequence of configurations.
</MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022> >>>>>
It is an easily verified fact that the input to HHH(DDD) and
the input to HHH(DD) meets the above self-evidently true criteria.
No, they don't meet the second cireterion. HHH does not correctly
determine that its input would never stop running unless aborted.
Perhaps you may deceive with someting like equivocation someone to
believe it does but in reality it does not.
No one has ever even attempted to show the details
of how this is not correct:
void DDD()
{
HHH(DDD);
return;
}
When one or more instructions of DDD are correctly
simulated by ANY simulating termination analyzer HHH
then this correctly simulated DDD never reaches its
simulated "return" statement final halt state.
I have. I have shown that there is a simulating termination
analyser that has the name HHH and that simulates until it
finds either a call to HHH or termination. If it finds HHH
it continues simulation after the call. If it finds a return
from the input runction it returns 1. Your "any simulating
termination analyzer HHH" does not exclude my HHH. Therefore
your claim is false.
void Infinite_Loop()
{
HERE: goto HERE;
return;
}
void Infinite_Recursion()
{
Infinite_Recursion();
}
void DDD()
{
HHH(DDD);
return;
}
When it is understood that HHH does simulate itself
On 6/17/2025 8:33 PM, Richard Damon wrote:What? The code says so.
On 6/17/25 11:11 AM, olcott wrote:
That is not given.When it is understood that HHH does simulate itself simulating DDDBut since HHH *DOES* abort
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/18/2025 11:02 AM, joes wrote:
Am Wed, 18 Jun 2025 10:08:11 -0500 schrieb olcott:
On 6/17/2025 8:33 PM, Richard Damon wrote:What? The code says so.
On 6/17/25 11:11 AM, olcott wrote:
That is not given.When it is understood that HHH does simulate itself simulating DDDBut since HHH *DOES* abort
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 HHH that I am talking about here is the infinite
set of every simulating termination analyzer named HHH.
Some of them abort, some of them do not abort.
On 6/17/2025 8:33 PM, Richard Damon wrote:
On 6/17/25 11:11 AM, olcott wrote:That is not given.
On 6/16/2025 8:41 PM, Richard Damon wrote:
On 6/16/25 3:35 PM, olcott wrote:
On 6/16/2025 5:36 AM, Mikko wrote:
On 2025-06-15 13:49:51 +0000, olcott said:
On 6/15/2025 3:24 AM, Fred. Zwarts wrote:No, they don't meet the second cireterion. HHH does not correctly
Op 14.jun.2025 om 15:38 schreef olcott:
On 6/14/2025 4:10 AM, Fred. Zwarts wrote:
Op 13.jun.2025 om 17:53 schreef olcott:
On 6/13/2025 5:51 AM, Mikko wrote:
On 2025-06-12 15:30:05 +0000, olcott said:
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
It is a verified fact that DD() *is* one of the forms >>>>>>>>>>>>> of the counter-example input as such an input would
be encoded in C. Christopher Strachey wrote his in CPL. >>>>>>>>>>>>>
// rec routine P
// §L :if T[P] go to L
// Return §
// https://academic.oup.com/comjnl/article/7/4/313/354243 >>>>>>>>>>>>> void Strachey_P()
{
L: if (HHH(Strachey_P)) goto L;
return;
}
https://academic.oup.com/comjnl/article-
abstract/7/4/313/354243? redirectedFrom=fulltext
Strachey only informally presents the idea of the proof. >>>>>>>>>>>> Formalism
and details needed in a rigorous proof is not shown.
void DDD()
{
HHH(DDD);
return;
}
_DDD()
[00002192] 55 push ebp
[00002193] 8bec mov ebp,esp
[00002195] 6892210000 push 00002192
[0000219a] e833f4ffff call 000015d2 // call HHH >>>>>>>>>>> [0000219f] 83c404 add esp,+04
[000021a2] 5d pop ebp
[000021a3] c3 ret
Size in bytes:(0018) [000021a3]
Exactly how would DDD correctly emulated by HHH
reach its own "ret" instruction final halt state?
Indeed, HHH fails where other world-class simulators have no >>>>>>>>>> problem to simulate the program specified in the input.
So you still don't understand what recursive simulation is?
It seems I understand it better than you do. You seem to think >>>>>>>> that every recursion is a infinite recursion. As soon as you see >>>>>>>> a recursion, you think it has been proven that it is an infinite >>>>>>>> recursion, even if the code specifies an abort and halt.
<MIT Professor Sipser agreed to ONLY these verbatim words
10/13/2022>
If simulating halt decider H correctly simulates its
input D until H correctly determines that its simulated D >>>>>>> would never stop running unless aborted then
H can abort its simulation of D and correctly report that D >>>>>>> specifies a non-halting sequence of configurations.
</MIT Professor Sipser agreed to ONLY these verbatim words
10/13/2022>
It is an easily verified fact that the input to HHH(DDD) and
the input to HHH(DD) meets the above self-evidently true criteria. >>>>>>
determine that its input would never stop running unless aborted.
Perhaps you may deceive with someting like equivocation someone to >>>>>> believe it does but in reality it does not.
No one has ever even attempted to show the details
of how this is not correct:
void DDD()
{
HHH(DDD);
return;
}
When one or more instructions of DDD are correctly
simulated by ANY simulating termination analyzer HHH
then this correctly simulated DDD never reaches its
simulated "return" statement final halt state.
The problem is that isn't the definition of non-halting, and thus
irrelevent.
Counter-factual.
Halting is defined as reaching a final halt state.
Right, but its complement is *NEVER* reaching a final state, no matter
how far you continue looking at the behavior (since machines don't
stop until the reach a halting state).
Your PARTIAL simulation just do not indicate non-halting, just not-
yet- halted.
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.
But since HHH *DOES* abort
On 6/18/2025 4:16 AM, Mikko wrote:
On 2025-06-17 14:45:42 +0000, olcott said:
On 6/17/2025 3:42 AM, Mikko wrote:
On 2025-06-16 19:35:52 +0000, olcott said:
On 6/16/2025 5:36 AM, Mikko wrote:
On 2025-06-15 13:49:51 +0000, olcott said:
On 6/15/2025 3:24 AM, Fred. Zwarts wrote:No, they don't meet the second cireterion. HHH does not correctly
Op 14.jun.2025 om 15:38 schreef olcott:
On 6/14/2025 4:10 AM, Fred. Zwarts wrote:
Op 13.jun.2025 om 17:53 schreef olcott:
On 6/13/2025 5:51 AM, Mikko wrote:
On 2025-06-12 15:30:05 +0000, olcott said:
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
It is a verified fact that DD() *is* one of the forms >>>>>>>>>>>>> of the counter-example input as such an input would
be encoded in C. Christopher Strachey wrote his in CPL. >>>>>>>>>>>>>
// rec routine P
// §L :if T[P] go to L
// Return §
// https://academic.oup.com/comjnl/article/7/4/313/354243 >>>>>>>>>>>>> void Strachey_P()
{
L: if (HHH(Strachey_P)) goto L;
return;
}
https://academic.oup.com/comjnl/article-
abstract/7/4/313/354243? redirectedFrom=fulltext
Strachey only informally presents the idea of the proof. >>>>>>>>>>>> Formalism
and details needed in a rigorous proof is not shown.
void DDD()
{
HHH(DDD);
return;
}
_DDD()
[00002192] 55 push ebp
[00002193] 8bec mov ebp,esp
[00002195] 6892210000 push 00002192
[0000219a] e833f4ffff call 000015d2 // call HHH >>>>>>>>>>> [0000219f] 83c404 add esp,+04
[000021a2] 5d pop ebp
[000021a3] c3 ret
Size in bytes:(0018) [000021a3]
Exactly how would DDD correctly emulated by HHH
reach its own "ret" instruction final halt state?
Indeed, HHH fails where other world-class simulators have no >>>>>>>>>> problem to simulate the program specified in the input.
So you still don't understand what recursive simulation is?
It seems I understand it better than you do. You seem to think >>>>>>>> that every recursion is a infinite recursion. As soon as you see >>>>>>>> a recursion, you think it has been proven that it is an infinite >>>>>>>> recursion, even if the code specifies an abort and halt.
<MIT Professor Sipser agreed to ONLY these verbatim words
10/13/2022>
If simulating halt decider H correctly simulates its
input D until H correctly determines that its simulated D >>>>>>> would never stop running unless aborted then
H can abort its simulation of D and correctly report that D >>>>>>> specifies a non-halting sequence of configurations.
</MIT Professor Sipser agreed to ONLY these verbatim words
10/13/2022>
It is an easily verified fact that the input to HHH(DDD) and
the input to HHH(DD) meets the above self-evidently true criteria. >>>>>>
determine that its input would never stop running unless aborted.
Perhaps you may deceive with someting like equivocation someone to >>>>>> believe it does but in reality it does not.
No one has ever even attempted to show the details
of how this is not correct:
void DDD()
{
HHH(DDD);
return;
}
When one or more instructions of DDD are correctly
simulated by ANY simulating termination analyzer HHH
then this correctly simulated DDD never reaches its
simulated "return" statement final halt state.
I have. I have shown that there is a simulating termination
analyser that has the name HHH and that simulates until it
finds either a call to HHH or termination. If it finds HHH
it continues simulation after the call. If it finds a return
from the input runction it returns 1. Your "any simulating
termination analyzer HHH" does not exclude my HHH. Therefore
your claim is false.
void Infinite_Loop()
{
HERE: goto HERE;
return;
}
void Infinite_Recursion()
{
Infinite_Recursion();
}
void DDD()
{
HHH(DDD);
return;
}
When it is understood that HHH does simulate itself
Can you prove that my HHH does simulate itself?
*That is a given* for this thought experiment.
On 6/18/2025 4:16 AM, Mikko wrote:
On 2025-06-17 14:45:42 +0000, olcott said:
On 6/17/2025 3:42 AM, Mikko wrote:
On 2025-06-16 19:35:52 +0000, olcott said:
On 6/16/2025 5:36 AM, Mikko wrote:
On 2025-06-15 13:49:51 +0000, olcott said:
On 6/15/2025 3:24 AM, Fred. Zwarts wrote:No, they don't meet the second cireterion. HHH does not correctly
Op 14.jun.2025 om 15:38 schreef olcott:
On 6/14/2025 4:10 AM, Fred. Zwarts wrote:
Op 13.jun.2025 om 17:53 schreef olcott:
On 6/13/2025 5:51 AM, Mikko wrote:
On 2025-06-12 15:30:05 +0000, olcott said:
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
It is a verified fact that DD() *is* one of the forms >>>>>>>>>>>>> of the counter-example input as such an input would
be encoded in C. Christopher Strachey wrote his in CPL. >>>>>>>>>>>>>
// rec routine P
// §L :if T[P] go to L
// Return §
// https://academic.oup.com/comjnl/article/7/4/313/354243 >>>>>>>>>>>>> void Strachey_P()
{
L: if (HHH(Strachey_P)) goto L;
return;
}
https://academic.oup.com/comjnl/article- abstract/7/4/313/354243? >>>>>>>>>>>>> redirectedFrom=fulltext
Strachey only informally presents the idea of the proof. Formalism >>>>>>>>>>>> and details needed in a rigorous proof is not shown.
void DDD()
{
HHH(DDD);
return;
}
_DDD()
[00002192] 55 push ebp
[00002193] 8bec mov ebp,esp
[00002195] 6892210000 push 00002192
[0000219a] e833f4ffff call 000015d2 // call HHH >>>>>>>>>>> [0000219f] 83c404 add esp,+04
[000021a2] 5d pop ebp
[000021a3] c3 ret
Size in bytes:(0018) [000021a3]
Exactly how would DDD correctly emulated by HHH
reach its own "ret" instruction final halt state?
Indeed, HHH fails where other world-class simulators have no problem to
simulate the program specified in the input.
So you still don't understand what recursive simulation is?
It seems I understand it better than you do. You seem to think that >>>>>>>> every recursion is a infinite recursion. As soon as you see a
recursion, you think it has been proven that it is an infinite >>>>>>>> recursion, even if the code specifies an abort and halt.
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022> >>>>>>> If simulating halt decider H correctly simulates its
input D until H correctly determines that its simulated D >>>>>>> would never stop running unless aborted then
H can abort its simulation of D and correctly report that D >>>>>>> specifies a non-halting sequence of configurations.
</MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022> >>>>>>>
It is an easily verified fact that the input to HHH(DDD) and
the input to HHH(DD) meets the above self-evidently true criteria. >>>>>>
determine that its input would never stop running unless aborted.
Perhaps you may deceive with someting like equivocation someone to >>>>>> believe it does but in reality it does not.
No one has ever even attempted to show the details
of how this is not correct:
void DDD()
{
HHH(DDD);
return;
}
When one or more instructions of DDD are correctly
simulated by ANY simulating termination analyzer HHH
then this correctly simulated DDD never reaches its
simulated "return" statement final halt state.
I have. I have shown that there is a simulating termination
analyser that has the name HHH and that simulates until it
finds either a call to HHH or termination. If it finds HHH
it continues simulation after the call. If it finds a return
from the input runction it returns 1. Your "any simulating
termination analyzer HHH" does not exclude my HHH. Therefore
your claim is false.
void Infinite_Loop()
{
HERE: goto HERE;
return;
}
void Infinite_Recursion()
{
Infinite_Recursion();
}
void DDD()
{
HHH(DDD);
return;
}
When it is understood that HHH does simulate itself
Can you prove that my HHH does simulate itself?
*That is a given* for this thought experiment.
On 6/19/2025 3:32 AM, Mikko wrote:
On 2025-06-18 15:32:50 +0000, olcott said:
On 6/18/2025 4:16 AM, Mikko wrote:
On 2025-06-17 14:45:42 +0000, olcott said:
On 6/17/2025 3:42 AM, Mikko wrote:
On 2025-06-16 19:35:52 +0000, olcott said:
On 6/16/2025 5:36 AM, Mikko wrote:
On 2025-06-15 13:49:51 +0000, olcott said:
On 6/15/2025 3:24 AM, Fred. Zwarts wrote:No, they don't meet the second cireterion. HHH does not correctly >>>>>>>> determine that its input would never stop running unless aborted. >>>>>>>> Perhaps you may deceive with someting like equivocation someone to >>>>>>>> believe it does but in reality it does not.
Op 14.jun.2025 om 15:38 schreef olcott:<MIT Professor Sipser agreed to ONLY these verbatim words
On 6/14/2025 4:10 AM, Fred. Zwarts wrote:It seems I understand it better than you do. You seem to think >>>>>>>>>> that every recursion is a infinite recursion. As soon as you >>>>>>>>>> see a recursion, you think it has been proven that it is an >>>>>>>>>> infinite recursion, even if the code specifies an abort and halt. >>>>>>>>>
Op 13.jun.2025 om 17:53 schreef olcott:So you still don't understand what recursive simulation is? >>>>>>>>>>
On 6/13/2025 5:51 AM, Mikko wrote:
On 2025-06-12 15:30:05 +0000, olcott said:
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
It is a verified fact that DD() *is* one of the forms >>>>>>>>>>>>>>> of the counter-example input as such an input would >>>>>>>>>>>>>>> be encoded in C. Christopher Strachey wrote his in CPL. >>>>>>>>>>>>>>>
// rec routine P
// §L :if T[P] go to L
// Return §
// https://academic.oup.com/comjnl/article/7/4/313/354243 >>>>>>>>>>>>>>> void Strachey_P()
{
L: if (HHH(Strachey_P)) goto L;
return;
}
https://academic.oup.com/comjnl/article-
abstract/7/4/313/354243? redirectedFrom=fulltext
Strachey only informally presents the idea of the proof. >>>>>>>>>>>>>> Formalism
and details needed in a rigorous proof is not shown. >>>>>>>>>>>>>>
void DDD()
{
HHH(DDD);
return;
}
_DDD()
[00002192] 55 push ebp
[00002193] 8bec mov ebp,esp
[00002195] 6892210000 push 00002192
[0000219a] e833f4ffff call 000015d2 // call HHH >>>>>>>>>>>>> [0000219f] 83c404 add esp,+04
[000021a2] 5d pop ebp
[000021a3] c3 ret
Size in bytes:(0018) [000021a3]
Exactly how would DDD correctly emulated by HHH
reach its own "ret" instruction final halt state?
Indeed, HHH fails where other world-class simulators have no >>>>>>>>>>>> problem to simulate the program specified in the input. >>>>>>>>>>>
10/13/2022>
If simulating halt decider H correctly simulates its >>>>>>>>> input D until H correctly determines that its simulated D >>>>>>>>> would never stop running unless aborted then
H can abort its simulation of D and correctly report that D >>>>>>>>> specifies a non-halting sequence of configurations. >>>>>>>>> </MIT Professor Sipser agreed to ONLY these verbatim words
10/13/2022>
It is an easily verified fact that the input to HHH(DDD) and >>>>>>>>> the input to HHH(DD) meets the above self-evidently true criteria. >>>>>>>>
No one has ever even attempted to show the details
of how this is not correct:
void DDD()
{
HHH(DDD);
return;
}
When one or more instructions of DDD are correctly
simulated by ANY simulating termination analyzer HHH
then this correctly simulated DDD never reaches its
simulated "return" statement final halt state.
I have. I have shown that there is a simulating termination
analyser that has the name HHH and that simulates until it
finds either a call to HHH or termination. If it finds HHH
it continues simulation after the call. If it finds a return
from the input runction it returns 1. Your "any simulating
termination analyzer HHH" does not exclude my HHH. Therefore
your claim is false.
void Infinite_Loop()
{
HERE: goto HERE;
return;
}
void Infinite_Recursion()
{
Infinite_Recursion();
}
void DDD()
{
HHH(DDD);
return;
}
When it is understood that HHH does simulate itself
Can you prove that my HHH does simulate itself?
*That is a given* for this thought experiment.
Above is only required that HHH partially simulates the behaviour
specified by its input.
counter-factual
That the simulated part includes all of
or even a part of HHH is not required.
My claim is that each of the above functions correctly
simulated by any termination analyzer HHH that can possibly
exist will never stop running unless aborted by HHH.
Can you affirm or correctly refute this?
*No one has ever been able to refute this in three years*
| Sysop: | Keyop |
|---|---|
| Location: | Huddersfield, West Yorkshire, UK |
| Users: | 715 |
| Nodes: | 16 (2 / 14) |
| Uptime: | 04:13:17 |
| Calls: | 12,099 |
| Calls today: | 7 |
| Files: | 15,003 |
| Messages: | 6,517,890 |