On 2/18/2025 7:48 AM, joes wrote:Way to derail.
Am Tue, 18 Feb 2025 07:37:54 -0600 schrieb olcott:When I focus on one single-point:
On 2/18/2025 6:25 AM, Richard Damon wrote:I mean, this is a deterministic program without any static variables,
On 2/18/25 6:26 AM, olcott wrote:Not at all.
On 2/18/2025 3:24 AM, Mikko wrote:So? Since it does that, it needs to presume that the copy of itself
On 2025-02-17 09:05:42 +0000, Fred. Zwarts said:Unless HHH(DD) aborts its simulation of DD itself cannot possibly
Op 16.feb.2025 om 23:51 schreef olcott:
On 2/16/2025 4:30 PM, joes wrote:A very strange and invalid stipulation.
Am Sun, 16 Feb 2025 15:58:14 -0600 schrieb olcott:Every simulated input that must be aborted to prevent the
On 2/16/2025 2:02 PM, joes wrote:What’s confusing about „halts”? I find it clearer as it does not
Am Sun, 16 Feb 2025 13:24:14 -0600 schrieb olcott:
On 2/16/2025 10:35 AM, joes wrote:
Am Sun, 16 Feb 2025 06:51:12 -0600 schrieb olcott:
On 2/15/2025 2:49 AM, Mikko wrote:
On 2025-02-14 12:40:04 +0000, olcott said:
On 2/14/2025 2:58 AM, Mikko wrote:
On 2025-02-14 00:07:23 +0000, olcott said:
On 2/13/2025 3:20 AM, Mikko wrote:
On 2025-02-13 04:21:34 +0000, olcott said: >>>>>>>>>>>>>>>>>>>> On 2/12/2025 4:04 AM, Mikko wrote:
On 2025-02-11 14:41:38 +0000, olcott said:
I am not even using the confusing term "halts".(There are other deciders that are not termination analysers.) >>>>>>>>>>>I am focusing on the isomorphic notion of a termination >>>>>>>>>>>> analyzer.such as one that calls a non-aborting version of HHH >>>>>>>>>>>>>When we are referring to the above DD simulated by HHH and >>>>>>>>>>>>>> not trying to get away with changing the subject to some >>>>>>>>>>>>>> other DD somewhere elseDD correctly simulated by HHH cannot possibly terminate >>>>>>>>>>>>>>>> normally.
That claim has already shown to be false. Nothing above >>>>>>>>>>>>>>> shows that HHH does not return 0. If it does DD also >>>>>>>>>>>>>>> returns 0.
then anyone with sufficient knowledge of C programming >>>>>>>>>>>>>> knows that no instance of DD shown above simulated by any >>>>>>>>>>>>>> corresponding instance of HHH can possibly terminate >>>>>>>>>>>>>> normally.Well, then that corresponding (by what?) HHH isn’t a >>>>>>>>>>>>> decider.
A simulating termination analyzer correctly rejects any input >>>>>>>>>>>> that must be aborted to prevent its own non-termination. >>>>>>>>>>> Yes, in particular itself is not such an input, because we >>>>>>>>>>> *know* that it halts, because it is a decider. You can’t have >>>>>>>>>>> your cake and eat it too.
Instead I am using in its place "terminates normally".
DD correctly simulated by HHH cannot possibly terminate
normally.
imply an ambiguous „abnormal termination”. How does HHH simulate >>>>>>>>> DD terminating abnormally, then? Why doesn’t it terminate
abnormally itself?
You can substitute the term: the input DD to HHH does not need >>>>>>>>> to be aborted, because the simulated decider terminates.
non-termination of HHH is stipulated to be correctly rejected by >>>>>>>> HHH as non-terminating.
It merely means that the words do not have their ordinary meaning. >>>>>>
terminate normally. Every expert in the C programming language can
see this. People that are not experts get confused by the loop after >>>>> the "if" statement.
it sees called does that.
amirite?
[D simulated by HHH cannot possibly terminate normally]
I get two years of dodging and this point is never addressed.
Since there is about a 7% chance that my very drastic cancer treatmentOh right, I wanted to wait a month for your 5% chance. When exactly is it?
will kill me in the next 100 days I must insist on 100% perfectly and completely addressing this point before moving on to any other points.
--Here is the point that you just missed Unless the first HHH that sees
the non-terminating pattern aborts its simulation none of them do
because they all have the exact same code.
On 2/18/2025 7:48 AM, joes wrote:
Am Tue, 18 Feb 2025 07:37:54 -0600 schrieb olcott:
On 2/18/2025 6:25 AM, Richard Damon wrote:I mean, this is a deterministic program without any static variables,
On 2/18/25 6:26 AM, olcott wrote:Not at all.
On 2/18/2025 3:24 AM, Mikko wrote:So? Since it does that, it needs to presume that the copy of itself it >>>> sees called does that.
On 2025-02-17 09:05:42 +0000, Fred. Zwarts said:Unless HHH(DD) aborts its simulation of DD itself cannot possibly
Op 16.feb.2025 om 23:51 schreef olcott:
On 2/16/2025 4:30 PM, joes wrote:A very strange and invalid stipulation.
Am Sun, 16 Feb 2025 15:58:14 -0600 schrieb olcott:Every simulated input that must be aborted to prevent the
On 2/16/2025 2:02 PM, joes wrote:imply an ambiguous „abnormal termination”. How does HHH simulate >>>>>>>>> DD terminating abnormally, then? Why doesn’t it terminate
Am Sun, 16 Feb 2025 13:24:14 -0600 schrieb olcott:
On 2/16/2025 10:35 AM, joes wrote:
Am Sun, 16 Feb 2025 06:51:12 -0600 schrieb olcott:
On 2/15/2025 2:49 AM, Mikko wrote:
On 2025-02-14 12:40:04 +0000, olcott said:
On 2/14/2025 2:58 AM, Mikko wrote:
On 2025-02-14 00:07:23 +0000, olcott said:
On 2/13/2025 3:20 AM, Mikko wrote:
On 2025-02-13 04:21:34 +0000, olcott said: >>>>>>>>>>>>>>>>>>>> On 2/12/2025 4:04 AM, Mikko wrote:
On 2025-02-11 14:41:38 +0000, olcott said:
I am not even using the confusing term "halts".(There are other deciders that are not termination analysers.) >>>>>>>>>>>such as one that calls a non-aborting version of HHH >>>>>>>>>>>>>When we are referring to the above DD simulated by HHH and >>>>>>>>>>>>>> not trying to get away with changing the subject to some >>>>>>>>>>>>>> other DD somewhere elseDD correctly simulated by HHH cannot possibly terminate >>>>>>>>>>>>>>>> normally.
That claim has already shown to be false. Nothing above >>>>>>>>>>>>>>> shows that HHH does not return 0. If it does DD also returns >>>>>>>>>>>>>>> 0.
then anyone with sufficient knowledge of C programming knows >>>>>>>>>>>>>> that no instance of DD shown above simulated by any >>>>>>>>>>>>>> corresponding instance of HHH can possibly terminate >>>>>>>>>>>>>> normally.Well, then that corresponding (by what?) HHH isn’t a decider. >>>>>>>>>>>> I am focusing on the isomorphic notion of a termination >>>>>>>>>>>> analyzer.
A simulating termination analyzer correctly rejects any input >>>>>>>>>>>> that must be aborted to prevent its own non-termination. >>>>>>>>>>> Yes, in particular itself is not such an input, because we >>>>>>>>>>> *know* that it halts, because it is a decider. You can’t have >>>>>>>>>>> your cake and eat it too.
Instead I am using in its place "terminates normally".
DD correctly simulated by HHH cannot possibly terminate normally. >>>>>>>>> What’s confusing about „halts”? I find it clearer as it does not
abnormally itself?
You can substitute the term: the input DD to HHH does not need to >>>>>>>>> be aborted, because the simulated decider terminates.
non-termination of HHH is stipulated to be correctly rejected by >>>>>>>> HHH as non-terminating.
It merely means that the words do not have their ordinary meaning. >>>>>>
terminate normally. Every expert in the C programming language can see >>>>> this. People that are not experts get confused by the loop after the >>>>> "if" statement.
amirite?
When I focus on one single-point:
[D simulated by HHH cannot possibly terminate normally]
I get two years of dodging and this point is never addressed.
Since there is about a 7% chance that my very drastic cancer
treatment will kill me in the next 100 days I must insist on
100% perfectly and completely addressing this point before
moving on to any other points.
Here is the point that you just missed Unless the first HHH that sees
the non-terminating pattern aborts its simulation none of them do
because they all have the exact same code.
On 2/18/2025 8:11 AM, Fred. Zwarts wrote:
Op 18.feb.2025 om 14:37 schreef olcott:
On 2/18/2025 6:25 AM, Richard Damon wrote:
On 2/18/25 6:26 AM, olcott wrote:
On 2/18/2025 3:24 AM, Mikko wrote:
On 2025-02-17 09:05:42 +0000, Fred. Zwarts said:
Op 16.feb.2025 om 23:51 schreef olcott:
On 2/16/2025 4:30 PM, joes wrote:A very strange and invalid stipulation.
Am Sun, 16 Feb 2025 15:58:14 -0600 schrieb olcott:
On 2/16/2025 2:02 PM, joes wrote:an ambiguous „abnormal termination”. How does HHH simulate DD >>>>>>>>> terminating abnormally, then? Why doesn’t it terminate abnormally >>>>>>>>> itself?
Am Sun, 16 Feb 2025 13:24:14 -0600 schrieb olcott:
On 2/16/2025 10:35 AM, joes wrote:
Am Sun, 16 Feb 2025 06:51:12 -0600 schrieb olcott:
On 2/15/2025 2:49 AM, Mikko wrote:
On 2025-02-14 12:40:04 +0000, olcott said:
On 2/14/2025 2:58 AM, Mikko wrote:
On 2025-02-14 00:07:23 +0000, olcott said:
On 2/13/2025 3:20 AM, Mikko wrote:
On 2025-02-13 04:21:34 +0000, olcott said: >>>>>>>>>>>>>>>>>>>> On 2/12/2025 4:04 AM, Mikko wrote:
On 2025-02-11 14:41:38 +0000, olcott said:
I am not even using the confusing term "halts".(There are other deciders that are not termination analysers.) >>>>>>>>>>>such as one that calls a non-aborting version of HHH >>>>>>>>>>>>>trying to get away with changing the subject to some other DD >>>>>>>>>>>>>> somewhere elseDD correctly simulated by HHH cannot possibly terminate >>>>>>>>>>>>>>>> normally.
That claim has already shown to be false. Nothing above >>>>>>>>>>>>>>> shows that
HHH does not return 0. If it does DD also returns 0. >>>>>>>>>>>>>> When we are referring to the above DD simulated by HHH and >>>>>>>>>>>>>> not
then anyone with sufficient knowledge of C programming >>>>>>>>>>>>>> knows that noWell, then that corresponding (by what?) HHH isn’t a decider. >>>>>>>>>>>> I am focusing on the isomorphic notion of a termination >>>>>>>>>>>> analyzer.
instance of DD shown above simulated by any corresponding >>>>>>>>>>>>>> instance
of HHH can possibly terminate normally.
A simulating termination analyzer correctly rejects any >>>>>>>>>>>> input thatYes, in particular itself is not such an input, because we >>>>>>>>>>> *know* that
must be aborted to prevent its own non-termination.
it halts, because it is a decider. You can’t have your cake >>>>>>>>>>> and eat it
too.
Instead I am using in its place "terminates normally".
DD correctly simulated by HHH cannot possibly terminate normally. >>>>>>>>> What’s confusing about „halts”? I find it clearer as it does >>>>>>>>> not imply
You can substitute the term: the input DD to HHH does not need >>>>>>>>> to be
aborted, because the simulated decider terminates.
typedef void (*ptr)();
int HHH(ptr P);
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
int main()
{
HHH(DD);
}
Every simulated input that must be aborted to
prevent the non-termination of HHH is stipulated
to be correctly rejected by HHH as non-terminating.
It merely means that the words do not have their ordinary meaning. >>>>>>
Unless HHH(DD) aborts its simulation of DD itself cannot possibly
terminate normally. Every expert in the C programming language
can see this. People that are not experts get confused by the loop
after the "if" statement.
So? Since it does that, it needs to presume that the copy of itself
it sees called does that.
Not at all. Perhaps your technical skill is much more woefully
deficient than I ever imagined.
Here is the point that you just missed Unless the first HHH
that sees the non-terminating pattern aborts its simulation
none of them do because they all have the exact same code.
The point Olcott misses is that if the non-terminating HHH is changed
to abort the simulation, the program is changed. He does not
understand that a modification of a program makes a change. Such a
change modifies the behaviour of the program. The non-termination
behaviour has disappeared with this change and only remains in his
dreams. After this change, the simulation would terminate normally and
HHH should no longer abort. But it does, because the code that detects
the 'special condition' has a bug, which makes that it does not see
that the program has been changed into a halting program.
When I focus on one single-point:
I get two years of dodging and this point is never addressed.
[DD simulated by HHH cannot possibly terminate normally]
void DDD()
{
HHH(DDD);
return;
}
int main()
{
HHH(Infinite_Recursion);
HHH(DDD);
}
Since there is about a 7% chance that my very drastic cancer
treatment will kill me in the next 100 days I must insist on
100% perfectly and completely addressing this point before
moving on to any other points.
On 2/18/2025 8:11 AM, Fred. Zwarts wrote:
Op 18.feb.2025 om 14:37 schreef olcott:
On 2/18/2025 6:25 AM, Richard Damon wrote:
On 2/18/25 6:26 AM, olcott wrote:
On 2/18/2025 3:24 AM, Mikko wrote:
On 2025-02-17 09:05:42 +0000, Fred. Zwarts said:
Op 16.feb.2025 om 23:51 schreef olcott:
On 2/16/2025 4:30 PM, joes wrote:A very strange and invalid stipulation.
Am Sun, 16 Feb 2025 15:58:14 -0600 schrieb olcott:
On 2/16/2025 2:02 PM, joes wrote:an ambiguous „abnormal termination”. How does HHH simulate DD >>>>>>>>> terminating abnormally, then? Why doesn’t it terminate abnormally >>>>>>>>> itself?
Am Sun, 16 Feb 2025 13:24:14 -0600 schrieb olcott:
On 2/16/2025 10:35 AM, joes wrote:
Am Sun, 16 Feb 2025 06:51:12 -0600 schrieb olcott:
On 2/15/2025 2:49 AM, Mikko wrote:
On 2025-02-14 12:40:04 +0000, olcott said:
On 2/14/2025 2:58 AM, Mikko wrote:
On 2025-02-14 00:07:23 +0000, olcott said:
On 2/13/2025 3:20 AM, Mikko wrote:
On 2025-02-13 04:21:34 +0000, olcott said: >>>>>>>>>>>>>>>>>>>> On 2/12/2025 4:04 AM, Mikko wrote:
On 2025-02-11 14:41:38 +0000, olcott said:
I am not even using the confusing term "halts".(There are other deciders that are not termination analysers.) >>>>>>>>>>>such as one that calls a non-aborting version of HHH >>>>>>>>>>>>>trying to get away with changing the subject to some other DD >>>>>>>>>>>>>> somewhere elseDD correctly simulated by HHH cannot possibly terminate >>>>>>>>>>>>>>>> normally.
That claim has already shown to be false. Nothing above >>>>>>>>>>>>>>> shows that
HHH does not return 0. If it does DD also returns 0. >>>>>>>>>>>>>> When we are referring to the above DD simulated by HHH and >>>>>>>>>>>>>> not
then anyone with sufficient knowledge of C programming >>>>>>>>>>>>>> knows that noWell, then that corresponding (by what?) HHH isn’t a decider. >>>>>>>>>>>> I am focusing on the isomorphic notion of a termination >>>>>>>>>>>> analyzer.
instance of DD shown above simulated by any corresponding >>>>>>>>>>>>>> instance
of HHH can possibly terminate normally.
A simulating termination analyzer correctly rejects any >>>>>>>>>>>> input thatYes, in particular itself is not such an input, because we >>>>>>>>>>> *know* that
must be aborted to prevent its own non-termination.
it halts, because it is a decider. You can’t have your cake >>>>>>>>>>> and eat it
too.
Instead I am using in its place "terminates normally".
DD correctly simulated by HHH cannot possibly terminate normally. >>>>>>>>> What’s confusing about „halts”? I find it clearer as it does >>>>>>>>> not imply
You can substitute the term: the input DD to HHH does not need >>>>>>>>> to be
aborted, because the simulated decider terminates.
typedef void (*ptr)();
int HHH(ptr P);
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
int main()
{
HHH(DD);
}
Every simulated input that must be aborted to
prevent the non-termination of HHH is stipulated
to be correctly rejected by HHH as non-terminating.
It merely means that the words do not have their ordinary meaning. >>>>>>
Unless HHH(DD) aborts its simulation of DD itself cannot possibly
terminate normally. Every expert in the C programming language
can see this. People that are not experts get confused by the loop
after the "if" statement.
So? Since it does that, it needs to presume that the copy of itself
it sees called does that.
Not at all. Perhaps your technical skill is much more woefully
deficient than I ever imagined.
Here is the point that you just missed Unless the first HHH
that sees the non-terminating pattern aborts its simulation
none of them do because they all have the exact same code.
The point Olcott misses is that if the non-terminating HHH is changed
to abort the simulation, the program is changed. He does not
understand that a modification of a program makes a change. Such a
change modifies the behaviour of the program. The non-termination
behaviour has disappeared with this change and only remains in his
dreams. After this change, the simulation would terminate normally and
HHH should no longer abort. But it does, because the code that detects
the 'special condition' has a bug, which makes that it does not see
that the program has been changed into a halting program.
When I focus on one single-point:
I get two years of dodging and this point is never addressed.
[DD simulated by HHH cannot possibly terminate normally]
void DDD()
{
HHH(DDD);
return;
}
int main()
{
HHH(Infinite_Recursion);
HHH(DDD);
}
On 2/18/2025 5:33 PM, Richard Damon wrote:
On 2/18/25 11:34 AM, olcott wrote:
On 2/18/2025 7:48 AM, joes wrote:
Am Tue, 18 Feb 2025 07:37:54 -0600 schrieb olcott:
On 2/18/2025 6:25 AM, Richard Damon wrote:I mean, this is a deterministic program without any static variables,
On 2/18/25 6:26 AM, olcott wrote:Not at all.
On 2/18/2025 3:24 AM, Mikko wrote:So? Since it does that, it needs to presume that the copy of
On 2025-02-17 09:05:42 +0000, Fred. Zwarts said:Unless HHH(DD) aborts its simulation of DD itself cannot possibly >>>>>>> terminate normally. Every expert in the C programming language
Op 16.feb.2025 om 23:51 schreef olcott:
On 2/16/2025 4:30 PM, joes wrote:A very strange and invalid stipulation.
Am Sun, 16 Feb 2025 15:58:14 -0600 schrieb olcott:Every simulated input that must be aborted to prevent the
On 2/16/2025 2:02 PM, joes wrote:What’s confusing about „halts”? I find it clearer as it does not
Am Sun, 16 Feb 2025 13:24:14 -0600 schrieb olcott:
On 2/16/2025 10:35 AM, joes wrote:
Am Sun, 16 Feb 2025 06:51:12 -0600 schrieb olcott: >>>>>>>>>>>>>>>> On 2/15/2025 2:49 AM, Mikko wrote:
On 2025-02-14 12:40:04 +0000, olcott said:
On 2/14/2025 2:58 AM, Mikko wrote:
On 2025-02-14 00:07:23 +0000, olcott said: >>>>>>>>>>>>>>>>>>>> On 2/13/2025 3:20 AM, Mikko wrote:
On 2025-02-13 04:21:34 +0000, olcott said: >>>>>>>>>>>>>>>>>>>>>> On 2/12/2025 4:04 AM, Mikko wrote: >>>>>>>>>>>>>>>>>>>>>>> On 2025-02-11 14:41:38 +0000, olcott said:
I am not even using the confusing term "halts".(There are other deciders that are not termination analysers.) >>>>>>>>>>>>>I am focusing on the isomorphic notion of a termination >>>>>>>>>>>>>> analyzer.such as one that calls a non-aborting version of HHH >>>>>>>>>>>>>>>When we are referring to the above DD simulated by HHH and >>>>>>>>>>>>>>>> not trying to get away with changing the subject to some >>>>>>>>>>>>>>>> other DD somewhere elseDD correctly simulated by HHH cannot possibly terminate >>>>>>>>>>>>>>>>>> normally.
That claim has already shown to be false. Nothing above >>>>>>>>>>>>>>>>> shows that HHH does not return 0. If it does DD also >>>>>>>>>>>>>>>>> returns
0.
then anyone with sufficient knowledge of C programming >>>>>>>>>>>>>>>> knowsWell, then that corresponding (by what?) HHH isn’t a >>>>>>>>>>>>>>> decider.
that no instance of DD shown above simulated by any >>>>>>>>>>>>>>>> corresponding instance of HHH can possibly terminate >>>>>>>>>>>>>>>> normally.
A simulating termination analyzer correctly rejects any input >>>>>>>>>>>>>> that must be aborted to prevent its own non-termination. >>>>>>>>>>>>> Yes, in particular itself is not such an input, because we >>>>>>>>>>>>> *know* that it halts, because it is a decider. You can’t have >>>>>>>>>>>>> your cake and eat it too.
Instead I am using in its place "terminates normally". >>>>>>>>>>>> DD correctly simulated by HHH cannot possibly terminate >>>>>>>>>>>> normally.
imply an ambiguous „abnormal termination”. How does HHH simulate
DD terminating abnormally, then? Why doesn’t it terminate >>>>>>>>>>> abnormally itself?
You can substitute the term: the input DD to HHH does not >>>>>>>>>>> need to
be aborted, because the simulated decider terminates.
non-termination of HHH is stipulated to be correctly rejected by >>>>>>>>>> HHH as non-terminating.
It merely means that the words do not have their ordinary meaning. >>>>>>>>
can see
this. People that are not experts get confused by the loop after the >>>>>>> "if" statement.
itself it
sees called does that.
amirite?
When I focus on one single-point:
[D simulated by HHH cannot possibly terminate normally]
I get two years of dodging and this point is never addressed.
And you thus miss the point that what the partial simulation by HHH
does is irerelvent, except to your strawman.
SAYING THAT IT IS IRRELEVANT PROVIDES ZERO EVIDENCE THAT IT IS FALSE
On 2/19/2025 4:55 AM, Fred. Zwarts wrote:
Op 18.feb.2025 om 17:48 schreef olcott:
On 2/18/2025 8:11 AM, Fred. Zwarts wrote:It is not true that this point has never been addressed. Olcott
Op 18.feb.2025 om 14:37 schreef olcott:
On 2/18/2025 6:25 AM, Richard Damon wrote:
On 2/18/25 6:26 AM, olcott wrote:
On 2/18/2025 3:24 AM, Mikko wrote:
On 2025-02-17 09:05:42 +0000, Fred. Zwarts said:
Op 16.feb.2025 om 23:51 schreef olcott:
On 2/16/2025 4:30 PM, joes wrote:A very strange and invalid stipulation.
Am Sun, 16 Feb 2025 15:58:14 -0600 schrieb olcott:
On 2/16/2025 2:02 PM, joes wrote:What’s confusing about „halts”? I find it clearer as it does >>>>>>>>>>> not imply
Am Sun, 16 Feb 2025 13:24:14 -0600 schrieb olcott:
On 2/16/2025 10:35 AM, joes wrote:
Am Sun, 16 Feb 2025 06:51:12 -0600 schrieb olcott: >>>>>>>>>>>>>>>> On 2/15/2025 2:49 AM, Mikko wrote:
On 2025-02-14 12:40:04 +0000, olcott said:
On 2/14/2025 2:58 AM, Mikko wrote:
On 2025-02-14 00:07:23 +0000, olcott said: >>>>>>>>>>>>>>>>>>>> On 2/13/2025 3:20 AM, Mikko wrote:
On 2025-02-13 04:21:34 +0000, olcott said: >>>>>>>>>>>>>>>>>>>>>> On 2/12/2025 4:04 AM, Mikko wrote: >>>>>>>>>>>>>>>>>>>>>>> On 2025-02-11 14:41:38 +0000, olcott said:
I am not even using the confusing term "halts".(There are other deciders that are not termination analysers.) >>>>>>>>>>>>>I am focusing on the isomorphic notion of a termination >>>>>>>>>>>>>> analyzer.such as one that calls a non-aborting version of HHH >>>>>>>>>>>>>>>trying to get away with changing the subject to some >>>>>>>>>>>>>>>> other DDDD correctly simulated by HHH cannot possibly >>>>>>>>>>>>>>>>>> terminate normally.
That claim has already shown to be false. Nothing above >>>>>>>>>>>>>>>>> shows that
HHH does not return 0. If it does DD also returns 0. >>>>>>>>>>>>>>>> When we are referring to the above DD simulated by HHH >>>>>>>>>>>>>>>> and not
somewhere else
then anyone with sufficient knowledge of C programming >>>>>>>>>>>>>>>> knows that noWell, then that corresponding (by what?) HHH isn’t a >>>>>>>>>>>>>>> decider.
instance of DD shown above simulated by any
corresponding instance
of HHH can possibly terminate normally.
A simulating termination analyzer correctly rejects any >>>>>>>>>>>>>> input thatit halts, because it is a decider. You can’t have your cake >>>>>>>>>>>>> and eat it
must be aborted to prevent its own non-termination. >>>>>>>>>>>>> Yes, in particular itself is not such an input, because we >>>>>>>>>>>>> *know* that
too.
Instead I am using in its place "terminates normally". >>>>>>>>>>>> DD correctly simulated by HHH cannot possibly terminate >>>>>>>>>>>> normally.
an ambiguous „abnormal termination”. How does HHH simulate DD >>>>>>>>>>> terminating abnormally, then? Why doesn’t it terminate >>>>>>>>>>> abnormally
itself?
You can substitute the term: the input DD to HHH does not >>>>>>>>>>> need to be
aborted, because the simulated decider terminates.
typedef void (*ptr)();
int HHH(ptr P);
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
int main()
{
HHH(DD);
}
Every simulated input that must be aborted to
prevent the non-termination of HHH is stipulated
to be correctly rejected by HHH as non-terminating.
It merely means that the words do not have their ordinary meaning. >>>>>>>>
Unless HHH(DD) aborts its simulation of DD itself cannot possibly >>>>>>> terminate normally. Every expert in the C programming language
can see this. People that are not experts get confused by the loop >>>>>>> after the "if" statement.
So? Since it does that, it needs to presume that the copy of
itself it sees called does that.
Not at all. Perhaps your technical skill is much more woefully
deficient than I ever imagined.
Here is the point that you just missed Unless the first HHH
that sees the non-terminating pattern aborts its simulation
none of them do because they all have the exact same code.
The point Olcott misses is that if the non-terminating HHH is
changed to abort the simulation, the program is changed. He does not
understand that a modification of a program makes a change. Such a
change modifies the behaviour of the program. The non-termination
behaviour has disappeared with this change and only remains in his
dreams. After this change, the simulation would terminate normally
and HHH should no longer abort. But it does, because the code that
detects the 'special condition' has a bug, which makes that it does
not see that the program has been changed into a halting program.
When I focus on one single-point:
I get two years of dodging and this point is never addressed.
[DD simulated by HHH cannot possibly terminate normally]
void DDD()
{
HHH(DDD);
return;
}
int main()
{
HHH(Infinite_Recursion);
HHH(DDD);
}
ignores it when it is addressed.
What is the point? Even if HHH fails to simulate the halting program
DD up to the end because it is logically impossible for it to complete
the simulation, it still fails.
It fails In the same way that every CAD system
will never correctly represent a geometric circle that has
four equal length sides in the same two dimensional plane.
If the logically impossible cannot be done, we can admit that HHH's
simulation fails to complete the impossible task.
So, why is Olcott trying to fix the logically impossible? He could as
well try to draw a square circle.
On 2/19/2025 4:55 AM, Fred. Zwarts wrote:Yes, no program will ever decide the halting status of every program.
Op 18.feb.2025 om 17:48 schreef olcott:
On 2/18/2025 8:11 AM, Fred. Zwarts wrote:It is not true that this point has never been addressed. Olcott ignores
Op 18.feb.2025 om 14:37 schreef olcott:
On 2/18/2025 6:25 AM, Richard Damon wrote:The point Olcott misses is that if the non-terminating HHH is changed
On 2/18/25 6:26 AM, olcott wrote:Not at all. Perhaps your technical skill is much more woefully
On 2/18/2025 3:24 AM, Mikko wrote:So? Since it does that, it needs to presume that the copy of itself >>>>>> it sees called does that.
On 2025-02-17 09:05:42 +0000, Fred. Zwarts said:Unless HHH(DD) aborts its simulation of DD itself cannot possibly >>>>>>> terminate normally. Every expert in the C programming language can >>>>>>> see this. People that are not experts get confused by the loop
Op 16.feb.2025 om 23:51 schreef olcott:
On 2/16/2025 4:30 PM, joes wrote:A very strange and invalid stipulation.
Am Sun, 16 Feb 2025 15:58:14 -0600 schrieb olcott:Every simulated input that must be aborted to prevent the
On 2/16/2025 2:02 PM, joes wrote:What’s confusing about „halts”? I find it clearer as it does >>>>>>>>>>> not imply an ambiguous „abnormal termination”. How does HHH >>>>>>>>>>> simulate DD terminating abnormally, then? Why doesn’t it >>>>>>>>>>> terminate abnormally itself?
Am Sun, 16 Feb 2025 13:24:14 -0600 schrieb olcott:
On 2/16/2025 10:35 AM, joes wrote:
Am Sun, 16 Feb 2025 06:51:12 -0600 schrieb olcott: >>>>>>>>>>>>>>>> On 2/15/2025 2:49 AM, Mikko wrote:
On 2025-02-14 12:40:04 +0000, olcott said:
On 2/14/2025 2:58 AM, Mikko wrote:
On 2025-02-14 00:07:23 +0000, olcott said: >>>>>>>>>>>>>>>>>>>> On 2/13/2025 3:20 AM, Mikko wrote:
On 2025-02-13 04:21:34 +0000, olcott said: >>>>>>>>>>>>>>>>>>>>>> On 2/12/2025 4:04 AM, Mikko wrote: >>>>>>>>>>>>>>>>>>>>>>> On 2025-02-11 14:41:38 +0000, olcott said:
I am not even using the confusing term "halts". Instead I am >>>>>>>>>>>> using in its place "terminates normally". DD correctly >>>>>>>>>>>> simulated by HHH cannot possibly terminate normally.(There are other deciders that are not terminationI am focusing on the isomorphic notion of a termination >>>>>>>>>>>>>> analyzer.such as one that calls a non-aborting version of HHH >>>>>>>>>>>>>>>When we are referring to the above DD simulated by HHH >>>>>>>>>>>>>>>> and not trying to get away with changing the subject to >>>>>>>>>>>>>>>> some other DD somewhere elseDD correctly simulated by HHH cannot possibly >>>>>>>>>>>>>>>>>> terminate normally.
That claim has already shown to be false. Nothing above >>>>>>>>>>>>>>>>> shows that HHH does not return 0. If it does DD also >>>>>>>>>>>>>>>>> returns 0.
then anyone with sufficient knowledge of C programming >>>>>>>>>>>>>>>> knows that no instance of DD shown above simulated by any >>>>>>>>>>>>>>>> corresponding instance of HHH can possibly terminate >>>>>>>>>>>>>>>> normally.Well, then that corresponding (by what?) HHH isn’t a >>>>>>>>>>>>>>> decider.
analysers.)
A simulating termination analyzer correctly rejects any >>>>>>>>>>>>>> input that must be aborted to prevent its ownYes, in particular itself is not such an input, because we >>>>>>>>>>>>> *know* that it halts, because it is a decider. You can’t >>>>>>>>>>>>> have your cake and eat it too.
non-termination.
You can substitute the term: the input DD to HHH does not need >>>>>>>>>>> to be aborted, because the simulated decider terminates. >>>>>>>>>>>
non-termination of HHH is stipulated to be correctly rejected >>>>>>>>>> by HHH as non-terminating.
It merely means that the words do not have their ordinary
meaning.
after the "if" statement.
deficient than I ever imagined.
Here is the point that you just missed Unless the first HHH that
sees the non-terminating pattern aborts its simulation none of them
do because they all have the exact same code.
to abort the simulation, the program is changed. He does not
understand that a modification of a program makes a change. Such a
change modifies the behaviour of the program. The non-termination
behaviour has disappeared with this change and only remains in his
dreams. After this change, the simulation would terminate normally
and HHH should no longer abort. But it does, because the code that
detects the 'special condition' has a bug, which makes that it does
not see that the program has been changed into a halting program.
When I focus on one single-point:
I get two years of dodging and this point is never addressed.
[DD simulated by HHH cannot possibly terminate normally]
it when it is addressed.
What is the point? Even if HHH fails to simulate the halting program DD
up to the end because it is logically impossible for it to complete the
simulation, it still fails.
It fails In the same way that every CAD system will never correctly
represent a geometric circle that has four equal length sides in the
same two dimensional plane.
--If the logically impossible cannot be done,
we can admit that HHH's simulation fails to complete the impossible
task.
So, why is Olcott trying to fix the logically impossible? He could as
well try to draw a square circle.
On 2/19/2025 8:14 PM, Richard Damon wrote:Self-contradiction doesn’t depend on the formulation.
On 2/19/25 7:34 PM, olcott wrote:When is formulated to be a self-contradictory it is the same as the CAD requirement.
On 2/19/2025 4:55 AM, Fred. Zwarts wrote:
Op 18.feb.2025 om 17:48 schreef olcott:
On 2/18/2025 8:11 AM, Fred. Zwarts wrote:It is not true that this point has never been addressed. Olcott
Op 18.feb.2025 om 14:37 schreef olcott:
On 2/18/2025 6:25 AM, Richard Damon wrote:The point Olcott misses is that if the non-terminating HHH is
On 2/18/25 6:26 AM, olcott wrote:Not at all. Perhaps your technical skill is much more woefully
On 2/18/2025 3:24 AM, Mikko wrote:So? Since it does that, it needs to presume that the copy of
On 2025-02-17 09:05:42 +0000, Fred. Zwarts said:Unless HHH(DD) aborts its simulation of DD itself cannot
Op 16.feb.2025 om 23:51 schreef olcott:
On 2/16/2025 4:30 PM, joes wrote:A very strange and invalid stipulation.
Am Sun, 16 Feb 2025 15:58:14 -0600 schrieb olcott:Every simulated input that must be aborted to prevent the >>>>>>>>>>>> non-termination of HHH is stipulated to be correctly rejected >>>>>>>>>>>> by HHH as non-terminating.
On 2/16/2025 2:02 PM, joes wrote:not imply an ambiguous „abnormal termination”. How does HHH >>>>>>>>>>>>> simulate DD terminating abnormally, then? Why doesn’t it >>>>>>>>>>>>> terminate abnormally itself?
Am Sun, 16 Feb 2025 13:24:14 -0600 schrieb olcott: >>>>>>>>>>>>>>>> On 2/16/2025 10:35 AM, joes wrote:I am not even using the confusing term "halts". Instead I >>>>>>>>>>>>>> am using in its place "terminates normally". DD correctly >>>>>>>>>>>>>> simulated by HHH cannot possibly terminate normally. >>>>>>>>>>>>> What’s confusing about „halts”? I find it clearer as it does
(There are other deciders that are not termination >>>>>>>>>>>>>>> analysers.)Am Sun, 16 Feb 2025 06:51:12 -0600 schrieb olcott: >>>>>>>>>>>>>>>>>> On 2/15/2025 2:49 AM, Mikko wrote:I am focusing on the isomorphic notion of a termination >>>>>>>>>>>>>>>> analyzer.
such as one that calls a non-aborting version of HHH >>>>>>>>>>>>>>>>>On 2025-02-14 12:40:04 +0000, olcott said: >>>>>>>>>>>>>>>>>>>> On 2/14/2025 2:58 AM, Mikko wrote:When we are referring to the above DD simulated by HHH >>>>>>>>>>>>>>>>>> and not trying to get away with changing the subject to >>>>>>>>>>>>>>>>>> some other DD somewhere else
On 2025-02-14 00:07:23 +0000, olcott said: >>>>>>>>>>>>>>>>>>>>>> On 2/13/2025 3:20 AM, Mikko wrote: >>>>>>>>>>>>>>>>>>>>>>> On 2025-02-13 04:21:34 +0000, olcott said: >>>>>>>>>>>>>>>>>>>>>>>> On 2/12/2025 4:04 AM, Mikko wrote: >>>>>>>>>>>>>>>>>>>>>>>>> On 2025-02-11 14:41:38 +0000, olcott said: >>>>>>>>>>>>>DD correctly simulated by HHH cannot possibly >>>>>>>>>>>>>>>>>>>> terminate normally.
That claim has already shown to be false. Nothing >>>>>>>>>>>>>>>>>>> above shows that HHH does not return 0. If it does DD >>>>>>>>>>>>>>>>>>> also returns 0.
then anyone with sufficient knowledge of C programming >>>>>>>>>>>>>>>>>> knows that no instance of DD shown above simulated by >>>>>>>>>>>>>>>>>> any corresponding instance of HHH can possibly >>>>>>>>>>>>>>>>>> terminate normally.Well, then that corresponding (by what?) HHH isn’t a >>>>>>>>>>>>>>>>> decider.
A simulating termination analyzer correctly rejects any >>>>>>>>>>>>>>>> input that must be aborted to prevent its ownYes, in particular itself is not such an input, because we >>>>>>>>>>>>>>> *know* that it halts, because it is a decider. You can’t >>>>>>>>>>>>>>> have your cake and eat it too.
non-termination.
You can substitute the term: the input DD to HHH does not >>>>>>>>>>>>> need to be aborted, because the simulated decider
terminates.
It merely means that the words do not have their ordinary
meaning.
possibly terminate normally. Every expert in the C programming >>>>>>>>> language can see this. People that are not experts get confused >>>>>>>>> by the loop after the "if" statement.
itself it sees called does that.
deficient than I ever imagined.
Here is the point that you just missed Unless the first HHH that >>>>>>> sees the non-terminating pattern aborts its simulation none of
them do because they all have the exact same code.
changed to abort the simulation, the program is changed. He does
not understand that a modification of a program makes a change.
Such a change modifies the behaviour of the program. The non-
termination behaviour has disappeared with this change and only
remains in his dreams. After this change, the simulation would
terminate normally and HHH should no longer abort. But it does,
because the code that detects the 'special condition' has a bug,
which makes that it does not see that the program has been changed >>>>>> into a halting program.
When I focus on one single-point:
I get two years of dodging and this point is never addressed.
[DD simulated by HHH cannot possibly terminate normally]
ignores it when it is addressed.
What is the point? Even if HHH fails to simulate the halting program
DD up to the end because it is logically impossible for it to
complete the simulation, it still fails.
It fails In the same way that every CAD system will never correctly
represent a geometric circle that has four equal length sides in the
same two dimensional plane.
But no one asks for that, because it is meaningless.
Asking if a program will halt is not meaningless.
On 2/19/2025 4:55 AM, Fred. Zwarts wrote:
Op 18.feb.2025 om 17:48 schreef olcott:
On 2/18/2025 8:11 AM, Fred. Zwarts wrote:It is not true that this point has never been addressed. Olcott
Op 18.feb.2025 om 14:37 schreef olcott:
On 2/18/2025 6:25 AM, Richard Damon wrote:
On 2/18/25 6:26 AM, olcott wrote:
On 2/18/2025 3:24 AM, Mikko wrote:
On 2025-02-17 09:05:42 +0000, Fred. Zwarts said:
Op 16.feb.2025 om 23:51 schreef olcott:
On 2/16/2025 4:30 PM, joes wrote:A very strange and invalid stipulation.
Am Sun, 16 Feb 2025 15:58:14 -0600 schrieb olcott:
On 2/16/2025 2:02 PM, joes wrote:What’s confusing about „halts”? I find it clearer as it does >>>>>>>>>>> not imply
Am Sun, 16 Feb 2025 13:24:14 -0600 schrieb olcott:
On 2/16/2025 10:35 AM, joes wrote:
Am Sun, 16 Feb 2025 06:51:12 -0600 schrieb olcott: >>>>>>>>>>>>>>>> On 2/15/2025 2:49 AM, Mikko wrote:
On 2025-02-14 12:40:04 +0000, olcott said:
On 2/14/2025 2:58 AM, Mikko wrote:
On 2025-02-14 00:07:23 +0000, olcott said: >>>>>>>>>>>>>>>>>>>> On 2/13/2025 3:20 AM, Mikko wrote:
On 2025-02-13 04:21:34 +0000, olcott said: >>>>>>>>>>>>>>>>>>>>>> On 2/12/2025 4:04 AM, Mikko wrote: >>>>>>>>>>>>>>>>>>>>>>> On 2025-02-11 14:41:38 +0000, olcott said:
I am not even using the confusing term "halts".(There are other deciders that are not termination analysers.) >>>>>>>>>>>>>I am focusing on the isomorphic notion of a termination >>>>>>>>>>>>>> analyzer.such as one that calls a non-aborting version of HHH >>>>>>>>>>>>>>>trying to get away with changing the subject to some >>>>>>>>>>>>>>>> other DDDD correctly simulated by HHH cannot possibly >>>>>>>>>>>>>>>>>> terminate normally.
That claim has already shown to be false. Nothing above >>>>>>>>>>>>>>>>> shows that
HHH does not return 0. If it does DD also returns 0. >>>>>>>>>>>>>>>> When we are referring to the above DD simulated by HHH >>>>>>>>>>>>>>>> and not
somewhere else
then anyone with sufficient knowledge of C programming >>>>>>>>>>>>>>>> knows that noWell, then that corresponding (by what?) HHH isn’t a >>>>>>>>>>>>>>> decider.
instance of DD shown above simulated by any
corresponding instance
of HHH can possibly terminate normally.
A simulating termination analyzer correctly rejects any >>>>>>>>>>>>>> input thatit halts, because it is a decider. You can’t have your cake >>>>>>>>>>>>> and eat it
must be aborted to prevent its own non-termination. >>>>>>>>>>>>> Yes, in particular itself is not such an input, because we >>>>>>>>>>>>> *know* that
too.
Instead I am using in its place "terminates normally". >>>>>>>>>>>> DD correctly simulated by HHH cannot possibly terminate >>>>>>>>>>>> normally.
an ambiguous „abnormal termination”. How does HHH simulate DD >>>>>>>>>>> terminating abnormally, then? Why doesn’t it terminate >>>>>>>>>>> abnormally
itself?
You can substitute the term: the input DD to HHH does not >>>>>>>>>>> need to be
aborted, because the simulated decider terminates.
typedef void (*ptr)();
int HHH(ptr P);
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
int main()
{
HHH(DD);
}
Every simulated input that must be aborted to
prevent the non-termination of HHH is stipulated
to be correctly rejected by HHH as non-terminating.
It merely means that the words do not have their ordinary meaning. >>>>>>>>
Unless HHH(DD) aborts its simulation of DD itself cannot possibly >>>>>>> terminate normally. Every expert in the C programming language
can see this. People that are not experts get confused by the loop >>>>>>> after the "if" statement.
So? Since it does that, it needs to presume that the copy of
itself it sees called does that.
Not at all. Perhaps your technical skill is much more woefully
deficient than I ever imagined.
Here is the point that you just missed Unless the first HHH
that sees the non-terminating pattern aborts its simulation
none of them do because they all have the exact same code.
The point Olcott misses is that if the non-terminating HHH is
changed to abort the simulation, the program is changed. He does not
understand that a modification of a program makes a change. Such a
change modifies the behaviour of the program. The non-termination
behaviour has disappeared with this change and only remains in his
dreams. After this change, the simulation would terminate normally
and HHH should no longer abort. But it does, because the code that
detects the 'special condition' has a bug, which makes that it does
not see that the program has been changed into a halting program.
When I focus on one single-point:
I get two years of dodging and this point is never addressed.
[DD simulated by HHH cannot possibly terminate normally]
void DDD()
{
HHH(DDD);
return;
}
int main()
{
HHH(Infinite_Recursion);
HHH(DDD);
}
ignores it when it is addressed.
What is the point? Even if HHH fails to simulate the halting program
DD up to the end because it is logically impossible for it to complete
the simulation, it still fails.
It fails In the same way that every CAD system
will never correctly represent a geometric circle that has
four equal length sides in the same two dimensional plane.
On 2/19/2025 8:14 PM, Richard Damon wrote:
On 2/19/25 7:34 PM, olcott wrote:
On 2/19/2025 4:55 AM, Fred. Zwarts wrote:
Op 18.feb.2025 om 17:48 schreef olcott:
On 2/18/2025 8:11 AM, Fred. Zwarts wrote:It is not true that this point has never been addressed. Olcott
Op 18.feb.2025 om 14:37 schreef olcott:
On 2/18/2025 6:25 AM, Richard Damon wrote:
On 2/18/25 6:26 AM, olcott wrote:
On 2/18/2025 3:24 AM, Mikko wrote:
On 2025-02-17 09:05:42 +0000, Fred. Zwarts said:
Op 16.feb.2025 om 23:51 schreef olcott:
On 2/16/2025 4:30 PM, joes wrote:A very strange and invalid stipulation.
Am Sun, 16 Feb 2025 15:58:14 -0600 schrieb olcott:
On 2/16/2025 2:02 PM, joes wrote:What’s confusing about „halts”? I find it clearer as it >>>>>>>>>>>>> does not imply
Am Sun, 16 Feb 2025 13:24:14 -0600 schrieb olcott: >>>>>>>>>>>>>>>> On 2/16/2025 10:35 AM, joes wrote:I am not even using the confusing term "halts".
(There are other deciders that are not termination >>>>>>>>>>>>>>> analysers.)Am Sun, 16 Feb 2025 06:51:12 -0600 schrieb olcott: >>>>>>>>>>>>>>>>>> On 2/15/2025 2:49 AM, Mikko wrote:I am focusing on the isomorphic notion of a termination >>>>>>>>>>>>>>>> analyzer.
such as one that calls a non-aborting version of HHH >>>>>>>>>>>>>>>>>On 2025-02-14 12:40:04 +0000, olcott said: >>>>>>>>>>>>>>>>>>>> On 2/14/2025 2:58 AM, Mikko wrote:trying to get away with changing the subject to some >>>>>>>>>>>>>>>>>> other DD
On 2025-02-14 00:07:23 +0000, olcott said: >>>>>>>>>>>>>>>>>>>>>> On 2/13/2025 3:20 AM, Mikko wrote: >>>>>>>>>>>>>>>>>>>>>>> On 2025-02-13 04:21:34 +0000, olcott said: >>>>>>>>>>>>>>>>>>>>>>>> On 2/12/2025 4:04 AM, Mikko wrote: >>>>>>>>>>>>>>>>>>>>>>>>> On 2025-02-11 14:41:38 +0000, olcott said: >>>>>>>>>>>>>DD correctly simulated by HHH cannot possibly >>>>>>>>>>>>>>>>>>>> terminate normally.
That claim has already shown to be false. Nothing >>>>>>>>>>>>>>>>>>> above shows that
HHH does not return 0. If it does DD also returns 0. >>>>>>>>>>>>>>>>>> When we are referring to the above DD simulated by HHH >>>>>>>>>>>>>>>>>> and not
somewhere else
then anyone with sufficient knowledge of C programming >>>>>>>>>>>>>>>>>> knows that noWell, then that corresponding (by what?) HHH isn’t a >>>>>>>>>>>>>>>>> decider.
instance of DD shown above simulated by any >>>>>>>>>>>>>>>>>> corresponding instance
of HHH can possibly terminate normally.
A simulating termination analyzer correctly rejects any >>>>>>>>>>>>>>>> input thatit halts, because it is a decider. You can’t have your >>>>>>>>>>>>>>> cake and eat it
must be aborted to prevent its own non-termination. >>>>>>>>>>>>>>> Yes, in particular itself is not such an input, because >>>>>>>>>>>>>>> we *know* that
too.
Instead I am using in its place "terminates normally". >>>>>>>>>>>>>> DD correctly simulated by HHH cannot possibly terminate >>>>>>>>>>>>>> normally.
an ambiguous „abnormal termination”. How does HHH simulate DD >>>>>>>>>>>>> terminating abnormally, then? Why doesn’t it terminate >>>>>>>>>>>>> abnormally
itself?
You can substitute the term: the input DD to HHH does not >>>>>>>>>>>>> need to be
aborted, because the simulated decider terminates.
typedef void (*ptr)();
int HHH(ptr P);
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
int main()
{
HHH(DD);
}
Every simulated input that must be aborted to
prevent the non-termination of HHH is stipulated
to be correctly rejected by HHH as non-terminating.
It merely means that the words do not have their ordinary
meaning.
Unless HHH(DD) aborts its simulation of DD itself cannot
possibly terminate normally. Every expert in the C programming >>>>>>>>> language
can see this. People that are not experts get confused by the loop >>>>>>>>> after the "if" statement.
So? Since it does that, it needs to presume that the copy of
itself it sees called does that.
Not at all. Perhaps your technical skill is much more woefully
deficient than I ever imagined.
Here is the point that you just missed Unless the first HHH
that sees the non-terminating pattern aborts its simulation
none of them do because they all have the exact same code.
The point Olcott misses is that if the non-terminating HHH is
changed to abort the simulation, the program is changed. He does
not understand that a modification of a program makes a change.
Such a change modifies the behaviour of the program. The non-
termination behaviour has disappeared with this change and only
remains in his dreams. After this change, the simulation would
terminate normally and HHH should no longer abort. But it does,
because the code that detects the 'special condition' has a bug,
which makes that it does not see that the program has been changed >>>>>> into a halting program.
When I focus on one single-point:
I get two years of dodging and this point is never addressed.
[DD simulated by HHH cannot possibly terminate normally]
void DDD()
{
HHH(DDD);
return;
}
int main()
{
HHH(Infinite_Recursion);
HHH(DDD);
}
ignores it when it is addressed.
What is the point? Even if HHH fails to simulate the halting program
DD up to the end because it is logically impossible for it to
complete the simulation, it still fails.
It fails In the same way that every CAD system
will never correctly represent a geometric circle that has
four equal length sides in the same two dimensional plane.
But no one asks for that, because it is meaningless.
Asking if a program will halt is not meaningless.
When is formulated to be a self-contradictory it is the
same as the CAD requirement.
On 2/19/25 9:56 PM, olcott wrote:
On 2/19/2025 8:14 PM, Richard Damon wrote:
On 2/19/25 7:34 PM, olcott wrote:
On 2/19/2025 4:55 AM, Fred. Zwarts wrote:
Op 18.feb.2025 om 17:48 schreef olcott:
On 2/18/2025 8:11 AM, Fred. Zwarts wrote:It is not true that this point has never been addressed. Olcott
Op 18.feb.2025 om 14:37 schreef olcott:
On 2/18/2025 6:25 AM, Richard Damon wrote:
On 2/18/25 6:26 AM, olcott wrote:
On 2/18/2025 3:24 AM, Mikko wrote:
On 2025-02-17 09:05:42 +0000, Fred. Zwarts said:
Op 16.feb.2025 om 23:51 schreef olcott:
On 2/16/2025 4:30 PM, joes wrote:A very strange and invalid stipulation.
Am Sun, 16 Feb 2025 15:58:14 -0600 schrieb olcott: >>>>>>>>>>>>>>> On 2/16/2025 2:02 PM, joes wrote:
Whats confusing about halts? I find it clearer as it >>>>>>>>>>>>>> does not implyAm Sun, 16 Feb 2025 13:24:14 -0600 schrieb olcott: >>>>>>>>>>>>>>>>> On 2/16/2025 10:35 AM, joes wrote:I am not even using the confusing term "halts".
(There are other deciders that are not termination >>>>>>>>>>>>>>>> analysers.)Am Sun, 16 Feb 2025 06:51:12 -0600 schrieb olcott: >>>>>>>>>>>>>>>>>>> On 2/15/2025 2:49 AM, Mikko wrote:I am focusing on the isomorphic notion of a termination >>>>>>>>>>>>>>>>> analyzer.
such as one that calls a non-aborting version of HHH >>>>>>>>>>>>>>>>>>On 2025-02-14 12:40:04 +0000, olcott said: >>>>>>>>>>>>>>>>>>>>> On 2/14/2025 2:58 AM, Mikko wrote:trying to get away with changing the subject to some >>>>>>>>>>>>>>>>>>> other DD
On 2025-02-14 00:07:23 +0000, olcott said: >>>>>>>>>>>>>>>>>>>>>>> On 2/13/2025 3:20 AM, Mikko wrote: >>>>>>>>>>>>>>>>>>>>>>>> On 2025-02-13 04:21:34 +0000, olcott said: >>>>>>>>>>>>>>>>>>>>>>>>> On 2/12/2025 4:04 AM, Mikko wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> On 2025-02-11 14:41:38 +0000, olcott said: >>>>>>>>>>>>>>DD correctly simulated by HHH cannot possibly >>>>>>>>>>>>>>>>>>>>> terminate normally.
That claim has already shown to be false. Nothing >>>>>>>>>>>>>>>>>>>> above shows that
HHH does not return 0. If it does DD also returns 0. >>>>>>>>>>>>>>>>>>> When we are referring to the above DD simulated by HHH >>>>>>>>>>>>>>>>>>> and not
somewhere else
then anyone with sufficient knowledge of C programming >>>>>>>>>>>>>>>>>>> knows that noWell, then that corresponding (by what?) HHH isnt a >>>>>>>>>>>>>>>>>> decider.
instance of DD shown above simulated by any >>>>>>>>>>>>>>>>>>> corresponding instance
of HHH can possibly terminate normally.
A simulating termination analyzer correctly rejects any >>>>>>>>>>>>>>>>> input thatit halts, because it is a decider. You cant have your >>>>>>>>>>>>>>>> cake and eat it
must be aborted to prevent its own non-termination. >>>>>>>>>>>>>>>> Yes, in particular itself is not such an input, because >>>>>>>>>>>>>>>> we *know* that
too.
Instead I am using in its place "terminates normally". >>>>>>>>>>>>>>> DD correctly simulated by HHH cannot possibly terminate >>>>>>>>>>>>>>> normally.
an ambiguous abnormal termination. How does HHH simulate DD >>>>>>>>>>>>>> terminating abnormally, then? Why doesnt it terminate >>>>>>>>>>>>>> abnormally
itself?
You can substitute the term: the input DD to HHH does not >>>>>>>>>>>>>> need to be
aborted, because the simulated decider terminates. >>>>>>>>>>>>>>
typedef void (*ptr)();
int HHH(ptr P);
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
int main()
{
HHH(DD);
}
Every simulated input that must be aborted to
prevent the non-termination of HHH is stipulated
to be correctly rejected by HHH as non-terminating.
It merely means that the words do not have their ordinary >>>>>>>>>>> meaning.
Unless HHH(DD) aborts its simulation of DD itself cannot
possibly terminate normally. Every expert in the C programming >>>>>>>>>> language
can see this. People that are not experts get confused by the loop >>>>>>>>>> after the "if" statement.
So? Since it does that, it needs to presume that the copy of >>>>>>>>> itself it sees called does that.
Not at all. Perhaps your technical skill is much more woefully >>>>>>>> deficient than I ever imagined.
Here is the point that you just missed Unless the first HHH
that sees the non-terminating pattern aborts its simulation
none of them do because they all have the exact same code.
The point Olcott misses is that if the non-terminating HHH is
changed to abort the simulation, the program is changed. He does >>>>>>> not understand that a modification of a program makes a change.
Such a change modifies the behaviour of the program. The non-
termination behaviour has disappeared with this change and only
remains in his dreams. After this change, the simulation would
terminate normally and HHH should no longer abort. But it does,
because the code that detects the 'special condition' has a bug, >>>>>>> which makes that it does not see that the program has been changed >>>>>>> into a halting program.
When I focus on one single-point:
I get two years of dodging and this point is never addressed.
[DD simulated by HHH cannot possibly terminate normally]
void DDD()
{
HHH(DDD);
return;
}
int main()
{
HHH(Infinite_Recursion);
HHH(DDD);
}
ignores it when it is addressed.
What is the point? Even if HHH fails to simulate the halting program >>>>> DD up to the end because it is logically impossible for it to
complete the simulation, it still fails.
It fails In the same way that every CAD system
will never correctly represent a geometric circle that has
four equal length sides in the same two dimensional plane.
But no one asks for that, because it is meaningless.
Asking if a program will halt is not meaningless.
When is formulated to be a self-contradictory it is the
same as the CAD requirement.
But it isn't.
The question is:
Does this program Halt when Run
That question has a definite Yes or No, if it *IS* a program.
For the DD in question (with the HHH that you claim to make it a
program) the answer is YES.
Your problem is you make the input not a program, because you don't >understand what that means.
The fact that your HHH GIVES UPS AND LIES before being able to determine >that, because YOU LIE as to what question it is actually trying to
answer, just shows your ignorance.
Sorry, but your stupidity becomes obvious to anyone with a bear minimum
of intelegence, something you clearly don't have.
On Thu, 20 Feb 2025 07:19:42 -0500, Richard Damon
<richard@damon-family.org> wrote:
On 2/19/25 9:56 PM, olcott wrote:
On 2/19/2025 8:14 PM, Richard Damon wrote:
On 2/19/25 7:34 PM, olcott wrote:
On 2/19/2025 4:55 AM, Fred. Zwarts wrote:
Op 18.feb.2025 om 17:48 schreef olcott:
On 2/18/2025 8:11 AM, Fred. Zwarts wrote:It is not true that this point has never been addressed. Olcott
Op 18.feb.2025 om 14:37 schreef olcott:
On 2/18/2025 6:25 AM, Richard Damon wrote:
On 2/18/25 6:26 AM, olcott wrote:
On 2/18/2025 3:24 AM, Mikko wrote:
On 2025-02-17 09:05:42 +0000, Fred. Zwarts said:
Op 16.feb.2025 om 23:51 schreef olcott:
On 2/16/2025 4:30 PM, joes wrote:A very strange and invalid stipulation.
Am Sun, 16 Feb 2025 15:58:14 -0600 schrieb olcott: >>>>>>>>>>>>>>>> On 2/16/2025 2:02 PM, joes wrote:
Whats confusing about halts? I find it clearer as it >>>>>>>>>>>>>>> does not implyAm Sun, 16 Feb 2025 13:24:14 -0600 schrieb olcott: >>>>>>>>>>>>>>>>>> On 2/16/2025 10:35 AM, joes wrote:I am not even using the confusing term "halts". >>>>>>>>>>>>>>>> Instead I am using in its place "terminates normally". >>>>>>>>>>>>>>>> DD correctly simulated by HHH cannot possibly terminate >>>>>>>>>>>>>>>> normally.
(There are other deciders that are not termination >>>>>>>>>>>>>>>>> analysers.)Am Sun, 16 Feb 2025 06:51:12 -0600 schrieb olcott: >>>>>>>>>>>>>>>>>>>> On 2/15/2025 2:49 AM, Mikko wrote:I am focusing on the isomorphic notion of a termination >>>>>>>>>>>>>>>>>> analyzer.
such as one that calls a non-aborting version of HHH >>>>>>>>>>>>>>>>>>>On 2025-02-14 12:40:04 +0000, olcott said: >>>>>>>>>>>>>>>>>>>>>> On 2/14/2025 2:58 AM, Mikko wrote: >>>>>>>>>>>>>>>>>>>>>>> On 2025-02-14 00:07:23 +0000, olcott said: >>>>>>>>>>>>>>>>>>>>>>>> On 2/13/2025 3:20 AM, Mikko wrote: >>>>>>>>>>>>>>>>>>>>>>>>> On 2025-02-13 04:21:34 +0000, olcott said: >>>>>>>>>>>>>>>>>>>>>>>>>> On 2/12/2025 4:04 AM, Mikko wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>> On 2025-02-11 14:41:38 +0000, olcott said: >>>>>>>>>>>>>>>trying to get away with changing the subject to some >>>>>>>>>>>>>>>>>>>> other DD
DD correctly simulated by HHH cannot possibly >>>>>>>>>>>>>>>>>>>>>> terminate normally.
That claim has already shown to be false. Nothing >>>>>>>>>>>>>>>>>>>>> above shows that
HHH does not return 0. If it does DD also returns 0. >>>>>>>>>>>>>>>>>>>> When we are referring to the above DD simulated by HHH >>>>>>>>>>>>>>>>>>>> and not
somewhere else
then anyone with sufficient knowledge of C programming >>>>>>>>>>>>>>>>>>>> knows that no
instance of DD shown above simulated by any >>>>>>>>>>>>>>>>>>>> corresponding instance
of HHH can possibly terminate normally. >>>>>>>>>>>>>>>>>>> Well, then that corresponding (by what?) HHH isnt a >>>>>>>>>>>>>>>>>>> decider.
A simulating termination analyzer correctly rejects any >>>>>>>>>>>>>>>>>> input thatit halts, because it is a decider. You cant have your >>>>>>>>>>>>>>>>> cake and eat it
must be aborted to prevent its own non-termination. >>>>>>>>>>>>>>>>> Yes, in particular itself is not such an input, because >>>>>>>>>>>>>>>>> we *know* that
too.
an ambiguous abnormal termination. How does HHH simulate DD >>>>>>>>>>>>>>> terminating abnormally, then? Why doesnt it terminate >>>>>>>>>>>>>>> abnormally
itself?
You can substitute the term: the input DD to HHH does not >>>>>>>>>>>>>>> need to be
aborted, because the simulated decider terminates. >>>>>>>>>>>>>>>
typedef void (*ptr)();
int HHH(ptr P);
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
int main()
{
HHH(DD);
}
Every simulated input that must be aborted to
prevent the non-termination of HHH is stipulated
to be correctly rejected by HHH as non-terminating. >>>>>>>>>>>>>>
It merely means that the words do not have their ordinary >>>>>>>>>>>> meaning.
Unless HHH(DD) aborts its simulation of DD itself cannot >>>>>>>>>>> possibly terminate normally. Every expert in the C programming >>>>>>>>>>> language
can see this. People that are not experts get confused by the loop >>>>>>>>>>> after the "if" statement.
So? Since it does that, it needs to presume that the copy of >>>>>>>>>> itself it sees called does that.
Not at all. Perhaps your technical skill is much more woefully >>>>>>>>> deficient than I ever imagined.
Here is the point that you just missed Unless the first HHH
that sees the non-terminating pattern aborts its simulation
none of them do because they all have the exact same code.
The point Olcott misses is that if the non-terminating HHH is
changed to abort the simulation, the program is changed. He does >>>>>>>> not understand that a modification of a program makes a change. >>>>>>>> Such a change modifies the behaviour of the program. The non-
termination behaviour has disappeared with this change and only >>>>>>>> remains in his dreams. After this change, the simulation would >>>>>>>> terminate normally and HHH should no longer abort. But it does, >>>>>>>> because the code that detects the 'special condition' has a bug, >>>>>>>> which makes that it does not see that the program has been changed >>>>>>>> into a halting program.
When I focus on one single-point:
I get two years of dodging and this point is never addressed.
[DD simulated by HHH cannot possibly terminate normally]
void DDD()
{
HHH(DDD);
return;
}
int main()
{
HHH(Infinite_Recursion);
HHH(DDD);
}
ignores it when it is addressed.
What is the point? Even if HHH fails to simulate the halting program >>>>>> DD up to the end because it is logically impossible for it to
complete the simulation, it still fails.
It fails In the same way that every CAD system
will never correctly represent a geometric circle that has
four equal length sides in the same two dimensional plane.
But no one asks for that, because it is meaningless.
Asking if a program will halt is not meaningless.
When is formulated to be a self-contradictory it is the
same as the CAD requirement.
But it isn't.
The question is:
Does this program Halt when Run
That question has a definite Yes or No, if it *IS* a program.
For the DD in question (with the HHH that you claim to make it a
program) the answer is YES.
Your problem is you make the input not a program, because you don't
understand what that means.
The fact that your HHH GIVES UPS AND LIES before being able to determine
that, because YOU LIE as to what question it is actually trying to
answer, just shows your ignorance.
Sorry, but your stupidity becomes obvious to anyone with a bear minimum
of intelegence, something you clearly don't have.
Ah, the ad hominem attack; does that ever work?
On 2/20/2025 3:35 AM, Fred. Zwarts wrote:
Op 20.feb.2025 om 01:34 schreef olcott:
On 2/19/2025 4:55 AM, Fred. Zwarts wrote:Indeed. Such a CAD system fails if it is given the task to draw a
Op 18.feb.2025 om 17:48 schreef olcott:
On 2/18/2025 8:11 AM, Fred. Zwarts wrote:It is not true that this point has never been addressed. Olcott
Op 18.feb.2025 om 14:37 schreef olcott:
On 2/18/2025 6:25 AM, Richard Damon wrote:
On 2/18/25 6:26 AM, olcott wrote:
On 2/18/2025 3:24 AM, Mikko wrote:
On 2025-02-17 09:05:42 +0000, Fred. Zwarts said:
Op 16.feb.2025 om 23:51 schreef olcott:
On 2/16/2025 4:30 PM, joes wrote:A very strange and invalid stipulation.
Am Sun, 16 Feb 2025 15:58:14 -0600 schrieb olcott:
On 2/16/2025 2:02 PM, joes wrote:What’s confusing about „halts”? I find it clearer as it >>>>>>>>>>>>> does not imply
Am Sun, 16 Feb 2025 13:24:14 -0600 schrieb olcott: >>>>>>>>>>>>>>>> On 2/16/2025 10:35 AM, joes wrote:I am not even using the confusing term "halts".
(There are other deciders that are not termination >>>>>>>>>>>>>>> analysers.)Am Sun, 16 Feb 2025 06:51:12 -0600 schrieb olcott: >>>>>>>>>>>>>>>>>> On 2/15/2025 2:49 AM, Mikko wrote:I am focusing on the isomorphic notion of a termination >>>>>>>>>>>>>>>> analyzer.
such as one that calls a non-aborting version of HHH >>>>>>>>>>>>>>>>>On 2025-02-14 12:40:04 +0000, olcott said: >>>>>>>>>>>>>>>>>>>> On 2/14/2025 2:58 AM, Mikko wrote:trying to get away with changing the subject to some >>>>>>>>>>>>>>>>>> other DD
On 2025-02-14 00:07:23 +0000, olcott said: >>>>>>>>>>>>>>>>>>>>>> On 2/13/2025 3:20 AM, Mikko wrote: >>>>>>>>>>>>>>>>>>>>>>> On 2025-02-13 04:21:34 +0000, olcott said: >>>>>>>>>>>>>>>>>>>>>>>> On 2/12/2025 4:04 AM, Mikko wrote: >>>>>>>>>>>>>>>>>>>>>>>>> On 2025-02-11 14:41:38 +0000, olcott said: >>>>>>>>>>>>>DD correctly simulated by HHH cannot possibly >>>>>>>>>>>>>>>>>>>> terminate normally.
That claim has already shown to be false. Nothing >>>>>>>>>>>>>>>>>>> above shows that
HHH does not return 0. If it does DD also returns 0. >>>>>>>>>>>>>>>>>> When we are referring to the above DD simulated by HHH >>>>>>>>>>>>>>>>>> and not
somewhere else
then anyone with sufficient knowledge of C programming >>>>>>>>>>>>>>>>>> knows that noWell, then that corresponding (by what?) HHH isn’t a >>>>>>>>>>>>>>>>> decider.
instance of DD shown above simulated by any >>>>>>>>>>>>>>>>>> corresponding instance
of HHH can possibly terminate normally.
A simulating termination analyzer correctly rejects any >>>>>>>>>>>>>>>> input thatit halts, because it is a decider. You can’t have your >>>>>>>>>>>>>>> cake and eat it
must be aborted to prevent its own non-termination. >>>>>>>>>>>>>>> Yes, in particular itself is not such an input, because >>>>>>>>>>>>>>> we *know* that
too.
Instead I am using in its place "terminates normally". >>>>>>>>>>>>>> DD correctly simulated by HHH cannot possibly terminate >>>>>>>>>>>>>> normally.
an ambiguous „abnormal termination”. How does HHH simulate DD >>>>>>>>>>>>> terminating abnormally, then? Why doesn’t it terminate >>>>>>>>>>>>> abnormally
itself?
You can substitute the term: the input DD to HHH does not >>>>>>>>>>>>> need to be
aborted, because the simulated decider terminates.
typedef void (*ptr)();
int HHH(ptr P);
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
int main()
{
HHH(DD);
}
Every simulated input that must be aborted to
prevent the non-termination of HHH is stipulated
to be correctly rejected by HHH as non-terminating.
It merely means that the words do not have their ordinary
meaning.
Unless HHH(DD) aborts its simulation of DD itself cannot
possibly terminate normally. Every expert in the C programming >>>>>>>>> language
can see this. People that are not experts get confused by the loop >>>>>>>>> after the "if" statement.
So? Since it does that, it needs to presume that the copy of
itself it sees called does that.
Not at all. Perhaps your technical skill is much more woefully
deficient than I ever imagined.
Here is the point that you just missed Unless the first HHH
that sees the non-terminating pattern aborts its simulation
none of them do because they all have the exact same code.
The point Olcott misses is that if the non-terminating HHH is
changed to abort the simulation, the program is changed. He does
not understand that a modification of a program makes a change.
Such a change modifies the behaviour of the program. The non-
termination behaviour has disappeared with this change and only
remains in his dreams. After this change, the simulation would
terminate normally and HHH should no longer abort. But it does,
because the code that detects the 'special condition' has a bug,
which makes that it does not see that the program has been changed >>>>>> into a halting program.
When I focus on one single-point:
I get two years of dodging and this point is never addressed.
[DD simulated by HHH cannot possibly terminate normally]
void DDD()
{
HHH(DDD);
return;
}
int main()
{
HHH(Infinite_Recursion);
HHH(DDD);
}
ignores it when it is addressed.
What is the point? Even if HHH fails to simulate the halting program
DD up to the end because it is logically impossible for it to
complete the simulation, it still fails.
It fails In the same way that every CAD system
will never correctly represent a geometric circle that has
four equal length sides in the same two dimensional plane.
square circle. Similarly, HHH fails if it is given the task to
determine the termination behaviour of DD.
It DOES NOT FAIL when it is defined coherently.
The square root of a basket of rotten eggs is also not computable.
We can't blame them, because they cannot possibly complete the
impossible task. We only blame the one that is trying do something
that has been proven that it cannot possibly work.
On 2/20/2025 3:52 AM, joes wrote:
Am Wed, 19 Feb 2025 18:34:14 -0600 schrieb olcott:
On 2/19/2025 4:55 AM, Fred. Zwarts wrote:Yes, no program will ever decide the halting status of every program.
Op 18.feb.2025 om 17:48 schreef olcott:
On 2/18/2025 8:11 AM, Fred. Zwarts wrote:It is not true that this point has never been addressed. Olcott ignores >>>> it when it is addressed.
Op 18.feb.2025 om 14:37 schreef olcott:
On 2/18/2025 6:25 AM, Richard Damon wrote:The point Olcott misses is that if the non-terminating HHH is changed >>>>>> to abort the simulation, the program is changed. He does not
On 2/18/25 6:26 AM, olcott wrote:Not at all. Perhaps your technical skill is much more woefully
On 2/18/2025 3:24 AM, Mikko wrote:So? Since it does that, it needs to presume that the copy of itself >>>>>>>> it sees called does that.
On 2025-02-17 09:05:42 +0000, Fred. Zwarts said:Unless HHH(DD) aborts its simulation of DD itself cannot possibly >>>>>>>>> terminate normally. Every expert in the C programming language can >>>>>>>>> see this. People that are not experts get confused by the loop >>>>>>>>> after the "if" statement.
Op 16.feb.2025 om 23:51 schreef olcott:
On 2/16/2025 4:30 PM, joes wrote:A very strange and invalid stipulation.
Am Sun, 16 Feb 2025 15:58:14 -0600 schrieb olcott:Every simulated input that must be aborted to prevent the >>>>>>>>>>>> non-termination of HHH is stipulated to be correctly rejected >>>>>>>>>>>> by HHH as non-terminating.
On 2/16/2025 2:02 PM, joes wrote:not imply an ambiguous „abnormal termination”. How does HHH >>>>>>>>>>>>> simulate DD terminating abnormally, then? Why doesn’t it >>>>>>>>>>>>> terminate abnormally itself?
Am Sun, 16 Feb 2025 13:24:14 -0600 schrieb olcott: >>>>>>>>>>>>>>>> On 2/16/2025 10:35 AM, joes wrote:I am not even using the confusing term "halts". Instead I am >>>>>>>>>>>>>> using in its place "terminates normally". DD correctly >>>>>>>>>>>>>> simulated by HHH cannot possibly terminate normally. >>>>>>>>>>>>> What’s confusing about „halts”? I find it clearer as it does
(There are other deciders that are not termination >>>>>>>>>>>>>>> analysers.)Am Sun, 16 Feb 2025 06:51:12 -0600 schrieb olcott: >>>>>>>>>>>>>>>>>> On 2/15/2025 2:49 AM, Mikko wrote:I am focusing on the isomorphic notion of a termination >>>>>>>>>>>>>>>> analyzer.
such as one that calls a non-aborting version of HHH >>>>>>>>>>>>>>>>>On 2025-02-14 12:40:04 +0000, olcott said: >>>>>>>>>>>>>>>>>>>> On 2/14/2025 2:58 AM, Mikko wrote:When we are referring to the above DD simulated by HHH >>>>>>>>>>>>>>>>>> and not trying to get away with changing the subject to >>>>>>>>>>>>>>>>>> some other DD somewhere else
On 2025-02-14 00:07:23 +0000, olcott said: >>>>>>>>>>>>>>>>>>>>>> On 2/13/2025 3:20 AM, Mikko wrote: >>>>>>>>>>>>>>>>>>>>>>> On 2025-02-13 04:21:34 +0000, olcott said: >>>>>>>>>>>>>>>>>>>>>>>> On 2/12/2025 4:04 AM, Mikko wrote: >>>>>>>>>>>>>>>>>>>>>>>>> On 2025-02-11 14:41:38 +0000, olcott said: >>>>>>>>>>>>>DD correctly simulated by HHH cannot possibly >>>>>>>>>>>>>>>>>>>> terminate normally.
That claim has already shown to be false. Nothing above >>>>>>>>>>>>>>>>>>> shows that HHH does not return 0. If it does DD also >>>>>>>>>>>>>>>>>>> returns 0.
then anyone with sufficient knowledge of C programming >>>>>>>>>>>>>>>>>> knows that no instance of DD shown above simulated by any >>>>>>>>>>>>>>>>>> corresponding instance of HHH can possibly terminate >>>>>>>>>>>>>>>>>> normally.Well, then that corresponding (by what?) HHH isn’t a >>>>>>>>>>>>>>>>> decider.
A simulating termination analyzer correctly rejects any >>>>>>>>>>>>>>>> input that must be aborted to prevent its ownYes, in particular itself is not such an input, because we >>>>>>>>>>>>>>> *know* that it halts, because it is a decider. You can’t >>>>>>>>>>>>>>> have your cake and eat it too.
non-termination.
You can substitute the term: the input DD to HHH does not need >>>>>>>>>>>>> to be aborted, because the simulated decider terminates. >>>>>>>>>>>>>
It merely means that the words do not have their ordinary
meaning.
deficient than I ever imagined.
Here is the point that you just missed Unless the first HHH that >>>>>>> sees the non-terminating pattern aborts its simulation none of them >>>>>>> do because they all have the exact same code.
understand that a modification of a program makes a change. Such a >>>>>> change modifies the behaviour of the program. The non-termination
behaviour has disappeared with this change and only remains in his >>>>>> dreams. After this change, the simulation would terminate normally >>>>>> and HHH should no longer abort. But it does, because the code that >>>>>> detects the 'special condition' has a bug, which makes that it does >>>>>> not see that the program has been changed into a halting program.
When I focus on one single-point:
I get two years of dodging and this point is never addressed.
[DD simulated by HHH cannot possibly terminate normally]
What is the point? Even if HHH fails to simulate the halting program DD >>>> up to the end because it is logically impossible for it to complete the >>>> simulation, it still fails.
It fails In the same way that every CAD system will never correctly
represent a geometric circle that has four equal length sides in the
same two dimensional plane.
In the exact same way that the square root of
a basket of rotten eggs is not computable.
On 2/20/2025 3:35 AM, Fred. Zwarts wrote:
Op 20.feb.2025 om 01:34 schreef olcott:
On 2/19/2025 4:55 AM, Fred. Zwarts wrote:Indeed. Such a CAD system fails if it is given the task to draw a
Op 18.feb.2025 om 17:48 schreef olcott:
On 2/18/2025 8:11 AM, Fred. Zwarts wrote:It is not true that this point has never been addressed. Olcott
Op 18.feb.2025 om 14:37 schreef olcott:
On 2/18/2025 6:25 AM, Richard Damon wrote:
On 2/18/25 6:26 AM, olcott wrote:
On 2/18/2025 3:24 AM, Mikko wrote:
On 2025-02-17 09:05:42 +0000, Fred. Zwarts said:
Op 16.feb.2025 om 23:51 schreef olcott:
On 2/16/2025 4:30 PM, joes wrote:A very strange and invalid stipulation.
Am Sun, 16 Feb 2025 15:58:14 -0600 schrieb olcott:
On 2/16/2025 2:02 PM, joes wrote:What’s confusing about „halts”? I find it clearer as it >>>>>>>>>>>>> does not imply
Am Sun, 16 Feb 2025 13:24:14 -0600 schrieb olcott: >>>>>>>>>>>>>>>> On 2/16/2025 10:35 AM, joes wrote:I am not even using the confusing term "halts".
(There are other deciders that are not termination >>>>>>>>>>>>>>> analysers.)Am Sun, 16 Feb 2025 06:51:12 -0600 schrieb olcott: >>>>>>>>>>>>>>>>>> On 2/15/2025 2:49 AM, Mikko wrote:I am focusing on the isomorphic notion of a termination >>>>>>>>>>>>>>>> analyzer.
such as one that calls a non-aborting version of HHH >>>>>>>>>>>>>>>>>On 2025-02-14 12:40:04 +0000, olcott said: >>>>>>>>>>>>>>>>>>>> On 2/14/2025 2:58 AM, Mikko wrote:trying to get away with changing the subject to some >>>>>>>>>>>>>>>>>> other DD
On 2025-02-14 00:07:23 +0000, olcott said: >>>>>>>>>>>>>>>>>>>>>> On 2/13/2025 3:20 AM, Mikko wrote: >>>>>>>>>>>>>>>>>>>>>>> On 2025-02-13 04:21:34 +0000, olcott said: >>>>>>>>>>>>>>>>>>>>>>>> On 2/12/2025 4:04 AM, Mikko wrote: >>>>>>>>>>>>>>>>>>>>>>>>> On 2025-02-11 14:41:38 +0000, olcott said: >>>>>>>>>>>>>DD correctly simulated by HHH cannot possibly >>>>>>>>>>>>>>>>>>>> terminate normally.
That claim has already shown to be false. Nothing >>>>>>>>>>>>>>>>>>> above shows that
HHH does not return 0. If it does DD also returns 0. >>>>>>>>>>>>>>>>>> When we are referring to the above DD simulated by HHH >>>>>>>>>>>>>>>>>> and not
somewhere else
then anyone with sufficient knowledge of C programming >>>>>>>>>>>>>>>>>> knows that noWell, then that corresponding (by what?) HHH isn’t a >>>>>>>>>>>>>>>>> decider.
instance of DD shown above simulated by any >>>>>>>>>>>>>>>>>> corresponding instance
of HHH can possibly terminate normally.
A simulating termination analyzer correctly rejects any >>>>>>>>>>>>>>>> input thatit halts, because it is a decider. You can’t have your >>>>>>>>>>>>>>> cake and eat it
must be aborted to prevent its own non-termination. >>>>>>>>>>>>>>> Yes, in particular itself is not such an input, because >>>>>>>>>>>>>>> we *know* that
too.
Instead I am using in its place "terminates normally". >>>>>>>>>>>>>> DD correctly simulated by HHH cannot possibly terminate >>>>>>>>>>>>>> normally.
an ambiguous „abnormal termination”. How does HHH simulate DD >>>>>>>>>>>>> terminating abnormally, then? Why doesn’t it terminate >>>>>>>>>>>>> abnormally
itself?
You can substitute the term: the input DD to HHH does not >>>>>>>>>>>>> need to be
aborted, because the simulated decider terminates.
typedef void (*ptr)();
int HHH(ptr P);
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
int main()
{
HHH(DD);
}
Every simulated input that must be aborted to
prevent the non-termination of HHH is stipulated
to be correctly rejected by HHH as non-terminating.
It merely means that the words do not have their ordinary
meaning.
Unless HHH(DD) aborts its simulation of DD itself cannot
possibly terminate normally. Every expert in the C programming >>>>>>>>> language
can see this. People that are not experts get confused by the loop >>>>>>>>> after the "if" statement.
So? Since it does that, it needs to presume that the copy of
itself it sees called does that.
Not at all. Perhaps your technical skill is much more woefully
deficient than I ever imagined.
Here is the point that you just missed Unless the first HHH
that sees the non-terminating pattern aborts its simulation
none of them do because they all have the exact same code.
The point Olcott misses is that if the non-terminating HHH is
changed to abort the simulation, the program is changed. He does
not understand that a modification of a program makes a change.
Such a change modifies the behaviour of the program. The non-
termination behaviour has disappeared with this change and only
remains in his dreams. After this change, the simulation would
terminate normally and HHH should no longer abort. But it does,
because the code that detects the 'special condition' has a bug,
which makes that it does not see that the program has been changed >>>>>> into a halting program.
When I focus on one single-point:
I get two years of dodging and this point is never addressed.
[DD simulated by HHH cannot possibly terminate normally]
void DDD()
{
HHH(DDD);
return;
}
int main()
{
HHH(Infinite_Recursion);
HHH(DDD);
}
ignores it when it is addressed.
What is the point? Even if HHH fails to simulate the halting program
DD up to the end because it is logically impossible for it to
complete the simulation, it still fails.
It fails In the same way that every CAD system
will never correctly represent a geometric circle that has
four equal length sides in the same two dimensional plane.
square circle. Similarly, HHH fails if it is given the task to
determine the termination behaviour of DD.
It DOES NOT FAIL when it is defined coherently.
The square root of a basket of rotten eggs is also not computable.
On 2/20/2025 3:56 AM, joes wrote:
Am Wed, 19 Feb 2025 20:56:17 -0600 schrieb olcott:
On 2/19/2025 8:14 PM, Richard Damon wrote:Self-contradiction doesn’t depend on the formulation.
On 2/19/25 7:34 PM, olcott wrote:When is formulated to be a self-contradictory it is the same as the CAD
On 2/19/2025 4:55 AM, Fred. Zwarts wrote:
Op 18.feb.2025 om 17:48 schreef olcott:
On 2/18/2025 8:11 AM, Fred. Zwarts wrote:It is not true that this point has never been addressed. Olcott
Op 18.feb.2025 om 14:37 schreef olcott:
On 2/18/2025 6:25 AM, Richard Damon wrote:The point Olcott misses is that if the non-terminating HHH is
On 2/18/25 6:26 AM, olcott wrote:Not at all. Perhaps your technical skill is much more woefully >>>>>>>>> deficient than I ever imagined.
On 2/18/2025 3:24 AM, Mikko wrote:So? Since it does that, it needs to presume that the copy of >>>>>>>>>> itself it sees called does that.
On 2025-02-17 09:05:42 +0000, Fred. Zwarts said:Unless HHH(DD) aborts its simulation of DD itself cannot >>>>>>>>>>> possibly terminate normally. Every expert in the C programming >>>>>>>>>>> language can see this. People that are not experts get confused >>>>>>>>>>> by the loop after the "if" statement.
Op 16.feb.2025 om 23:51 schreef olcott:
On 2/16/2025 4:30 PM, joes wrote:A very strange and invalid stipulation.
Am Sun, 16 Feb 2025 15:58:14 -0600 schrieb olcott: >>>>>>>>>>>>>>>> On 2/16/2025 2:02 PM, joes wrote:Every simulated input that must be aborted to prevent the >>>>>>>>>>>>>> non-termination of HHH is stipulated to be correctly rejected >>>>>>>>>>>>>> by HHH as non-terminating.
not imply an ambiguous „abnormal termination”. How does HHH >>>>>>>>>>>>>>> simulate DD terminating abnormally, then? Why doesn’t it >>>>>>>>>>>>>>> terminate abnormally itself?Am Sun, 16 Feb 2025 13:24:14 -0600 schrieb olcott: >>>>>>>>>>>>>>>>>> On 2/16/2025 10:35 AM, joes wrote:I am not even using the confusing term "halts". Instead I >>>>>>>>>>>>>>>> am using in its place "terminates normally". DD correctly >>>>>>>>>>>>>>>> simulated by HHH cannot possibly terminate normally. >>>>>>>>>>>>>>> What’s confusing about „halts”? I find it clearer as it does
(There are other deciders that are not termination >>>>>>>>>>>>>>>>> analysers.)Am Sun, 16 Feb 2025 06:51:12 -0600 schrieb olcott: >>>>>>>>>>>>>>>>>>>> On 2/15/2025 2:49 AM, Mikko wrote:I am focusing on the isomorphic notion of a termination >>>>>>>>>>>>>>>>>> analyzer.
such as one that calls a non-aborting version of HHH >>>>>>>>>>>>>>>>>>>On 2025-02-14 12:40:04 +0000, olcott said: >>>>>>>>>>>>>>>>>>>>>> On 2/14/2025 2:58 AM, Mikko wrote: >>>>>>>>>>>>>>>>>>>>>>> On 2025-02-14 00:07:23 +0000, olcott said: >>>>>>>>>>>>>>>>>>>>>>>> On 2/13/2025 3:20 AM, Mikko wrote: >>>>>>>>>>>>>>>>>>>>>>>>> On 2025-02-13 04:21:34 +0000, olcott said: >>>>>>>>>>>>>>>>>>>>>>>>>> On 2/12/2025 4:04 AM, Mikko wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>> On 2025-02-11 14:41:38 +0000, olcott said: >>>>>>>>>>>>>>>When we are referring to the above DD simulated by HHH >>>>>>>>>>>>>>>>>>>> and not trying to get away with changing the subject to >>>>>>>>>>>>>>>>>>>> some other DD somewhere else
DD correctly simulated by HHH cannot possibly >>>>>>>>>>>>>>>>>>>>>> terminate normally.
That claim has already shown to be false. Nothing >>>>>>>>>>>>>>>>>>>>> above shows that HHH does not return 0. If it does DD >>>>>>>>>>>>>>>>>>>>> also returns 0.
then anyone with sufficient knowledge of C programming >>>>>>>>>>>>>>>>>>>> knows that no instance of DD shown above simulated by >>>>>>>>>>>>>>>>>>>> any corresponding instance of HHH can possibly >>>>>>>>>>>>>>>>>>>> terminate normally.Well, then that corresponding (by what?) HHH isn’t a >>>>>>>>>>>>>>>>>>> decider.
A simulating termination analyzer correctly rejects any >>>>>>>>>>>>>>>>>> input that must be aborted to prevent its own >>>>>>>>>>>>>>>>>> non-termination.Yes, in particular itself is not such an input, because we >>>>>>>>>>>>>>>>> *know* that it halts, because it is a decider. You can’t >>>>>>>>>>>>>>>>> have your cake and eat it too.
You can substitute the term: the input DD to HHH does not >>>>>>>>>>>>>>> need to be aborted, because the simulated decider >>>>>>>>>>>>>>> terminates.
It merely means that the words do not have their ordinary >>>>>>>>>>>> meaning.
Here is the point that you just missed Unless the first HHH that >>>>>>>>> sees the non-terminating pattern aborts its simulation none of >>>>>>>>> them do because they all have the exact same code.
changed to abort the simulation, the program is changed. He does >>>>>>>> not understand that a modification of a program makes a change. >>>>>>>> Such a change modifies the behaviour of the program. The non-
termination behaviour has disappeared with this change and only >>>>>>>> remains in his dreams. After this change, the simulation would >>>>>>>> terminate normally and HHH should no longer abort. But it does, >>>>>>>> because the code that detects the 'special condition' has a bug, >>>>>>>> which makes that it does not see that the program has been changed >>>>>>>> into a halting program.
When I focus on one single-point:
I get two years of dodging and this point is never addressed.
[DD simulated by HHH cannot possibly terminate normally]
ignores it when it is addressed.
What is the point? Even if HHH fails to simulate the halting program >>>>>> DD up to the end because it is logically impossible for it to
complete the simulation, it still fails.
It fails In the same way that every CAD system will never correctly
represent a geometric circle that has four equal length sides in the >>>>> same two dimensional plane.
But no one asks for that, because it is meaningless.
Asking if a program will halt is not meaningless.
requirement.
Mere ignorance on your part.
On 2/22/2025 3:34 AM, Fred. Zwarts wrote:No, the code proves that HHH simulates a different version that doesn't
Op 22.feb.2025 om 00:15 schreef olcott:
On 2/20/2025 3:35 AM, Fred. Zwarts wrote:
Op 20.feb.2025 om 01:34 schreef olcott:
On 2/19/2025 4:55 AM, Fred. Zwarts wrote:
Op 18.feb.2025 om 17:48 schreef olcott:
On 2/18/2025 8:11 AM, Fred. Zwarts wrote:
Op 18.feb.2025 om 14:37 schreef olcott:
On 2/18/2025 6:25 AM, Richard Damon wrote:
On 2/18/25 6:26 AM, olcott wrote:
On 2/18/2025 3:24 AM, Mikko wrote:
On 2025-02-17 09:05:42 +0000, Fred. Zwarts said:
Op 16.feb.2025 om 23:51 schreef olcott:
On 2/16/2025 4:30 PM, joes wrote:
Am Sun, 16 Feb 2025 15:58:14 -0600 schrieb olcott: >>>>>>>>>>>>>>>> On 2/16/2025 2:02 PM, joes wrote:
Am Sun, 16 Feb 2025 13:24:14 -0600 schrieb olcott: >>>>>>>>>>>>>>>>>> On 2/16/2025 10:35 AM, joes wrote:
Am Sun, 16 Feb 2025 06:51:12 -0600 schrieb olcott: >>>>>>>>>>>>>>>>>>>> On 2/15/2025 2:49 AM, Mikko wrote:
On 2025-02-14 12:40:04 +0000, olcott said: >>>>>>>>>>>>>>>>>>>>>> On 2/14/2025 2:58 AM, Mikko wrote: >>>>>>>>>>>>>>>>>>>>>>> On 2025-02-14 00:07:23 +0000, olcott said: >>>>>>>>>>>>>>>>>>>>>>>> On 2/13/2025 3:20 AM, Mikko wrote: >>>>>>>>>>>>>>>>>>>>>>>>> On 2025-02-13 04:21:34 +0000, olcott said: >>>>>>>>>>>>>>>>>>>>>>>>>> On 2/12/2025 4:04 AM, Mikko wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>> On 2025-02-11 14:41:38 +0000, olcott said:
Because the code proves that HHH does simulate itself correctly it isTherefore it is stupid to give something the task to compute the squareIt DOES NOT FAIL when it is defined coherently.Indeed. Such a CAD system fails if it is given the task to draw aIt fails In the same way that every CAD system will never correctlyIt is not true that this point has never been addressed. OlcottWhen I focus on one single-point:The point Olcott misses is that if the non-terminating HHH isNot at all. Perhaps your technical skill is much more woefully >>>>>>>>> deficient than I ever imagined.So? Since it does that, it needs to presume that the copy of >>>>>>>>>> itself it sees called does that.Unless HHH(DD) aborts its simulation of DD itself cannot >>>>>>>>>>> possibly terminate normally. Every expert in the C programming >>>>>>>>>>> language can see this. People that are not experts getIt merely means that the words do not have their ordinary >>>>>>>>>>>> meaning.A very strange and invalid stipulation.Every simulated input that must be aborted to prevent the >>>>>>>>>>>>>> non-termination of HHH is stipulated to be correctly >>>>>>>>>>>>>> rejected by HHH as non-terminating.You can substitute the term: the input DD to HHH does not >>>>>>>>>>>>>>> need to be aborted, because the simulated decider >>>>>>>>>>>>>>> terminates.I am not even using the confusing term "halts". Instead I >>>>>>>>>>>>>>>> am using in its place "terminates normally". DD correctly >>>>>>>>>>>>>>>> simulated by HHH cannot possibly terminate normally. >>>>>>>>>>>>>>> What’s confusing about „halts”? I find it clearer as it >>>>>>>>>>>>>>> does not imply an ambiguous „abnormal termination”. How >>>>>>>>>>>>>>> does HHH simulate DD terminating abnormally, then? Why >>>>>>>>>>>>>>> doesn’t it terminate abnormally itself?A simulating termination analyzer correctly rejects any >>>>>>>>>>>>>>>>>> input that must be aborted to prevent its own >>>>>>>>>>>>>>>>>> non-termination.Yes, in particular itself is not such an input, because >>>>>>>>>>>>>>>>> we *know* that it halts, because it is a decider. You >>>>>>>>>>>>>>>>> can’t have your cake and eat it too.
confused by the loop after the "if" statement.
Here is the point that you just missed Unless the first HHH that >>>>>>>>> sees the non-terminating pattern aborts its simulation none of >>>>>>>>> them do because they all have the exact same code.
changed to abort the simulation, the program is changed. He does >>>>>>>> not understand that a modification of a program makes a change. >>>>>>>> Such a change modifies the behaviour of the program. The non-
termination behaviour has disappeared with this change and only >>>>>>>> remains in his dreams. After this change, the simulation would >>>>>>>> terminate normally and HHH should no longer abort. But it does, >>>>>>>> because the code that detects the 'special condition' has a bug, >>>>>>>> which makes that it does not see that the program has been
changed into a halting program.
I get two years of dodging and this point is never addressed.
[DD simulated by HHH cannot possibly terminate normally]
ignores it when it is addressed.
What is the point? Even if HHH fails to simulate the halting
program DD up to the end because it is logically impossible for it >>>>>> to complete the simulation, it still fails.
represent a geometric circle that has four equal length sides in the >>>>> same two dimensional plane.
square circle. Similarly, HHH fails if it is given the task to
determine the termination behaviour of DD.
The square root of a basket of rotten eggs is also not computable.
root of a basket of rotten eggs. Similarly, it is equally stupid to try
the impossible task of letting HHH simulate itself.
not stupid for HHH to simulate itself. This was the most difficult
aspect of creating the x86utm operating system.
On 2/22/2025 10:45 AM, joes wrote:No. Simulating a decider never needs to be aborted.
Am Sat, 22 Feb 2025 10:28:34 -0600 schrieb olcott:
On 2/22/2025 3:34 AM, Fred. Zwarts wrote:
Op 22.feb.2025 om 00:15 schreef olcott:
The code proves that it is correct.Because the code proves that HHH does simulate itself correctly it isNo, the code proves that HHH simulates a different version that doesn't
not stupid for HHH to simulate itself. This was the most difficult
aspect of creating the x86utm operating system.
abort. See line 1059.
HHH does correctly recognize and terminate the infinite recursion
behavior pattern.
On 2/22/2025 12:17 PM, joes wrote:Lol. Deciders *always* terminate.
Am Sat, 22 Feb 2025 12:07:17 -0600 schrieb olcott:You can equally assume that squares are round.
On 2/22/2025 10:45 AM, joes wrote:No. Simulating a decider never needs to be aborted.
Am Sat, 22 Feb 2025 10:28:34 -0600 schrieb olcott:The code proves that it is correct.
On 2/22/2025 3:34 AM, Fred. Zwarts wrote:
Op 22.feb.2025 om 00:15 schreef olcott:
Because the code proves that HHH does simulate itself correctly itNo, the code proves that HHH simulates a different version that
is not stupid for HHH to simulate itself. This was the most
difficult aspect of creating the x86utm operating system.
doesn't abort. See line 1059.
HHH does correctly recognize and terminate the infinite recursion
behavior pattern.
you never did tell me whether or not you fully understand what infinite recursion is.You wouldn't believe it.
On 2/22/2025 3:34 AM, Fred. Zwarts wrote:
Op 22.feb.2025 om 00:15 schreef olcott:
On 2/20/2025 3:35 AM, Fred. Zwarts wrote:Therefore it is stupid to give something the task to compute the
Op 20.feb.2025 om 01:34 schreef olcott:
On 2/19/2025 4:55 AM, Fred. Zwarts wrote:Indeed. Such a CAD system fails if it is given the task to draw a
Op 18.feb.2025 om 17:48 schreef olcott:
On 2/18/2025 8:11 AM, Fred. Zwarts wrote:It is not true that this point has never been addressed. Olcott
Op 18.feb.2025 om 14:37 schreef olcott:
On 2/18/2025 6:25 AM, Richard Damon wrote:
On 2/18/25 6:26 AM, olcott wrote:
On 2/18/2025 3:24 AM, Mikko wrote:
On 2025-02-17 09:05:42 +0000, Fred. Zwarts said:
Op 16.feb.2025 om 23:51 schreef olcott:
On 2/16/2025 4:30 PM, joes wrote:A very strange and invalid stipulation.
Am Sun, 16 Feb 2025 15:58:14 -0600 schrieb olcott: >>>>>>>>>>>>>>>> On 2/16/2025 2:02 PM, joes wrote:
What’s confusing about „halts”? I find it clearer as it >>>>>>>>>>>>>>> does not implyAm Sun, 16 Feb 2025 13:24:14 -0600 schrieb olcott: >>>>>>>>>>>>>>>>>> On 2/16/2025 10:35 AM, joes wrote:I am not even using the confusing term "halts". >>>>>>>>>>>>>>>> Instead I am using in its place "terminates normally". >>>>>>>>>>>>>>>> DD correctly simulated by HHH cannot possibly terminate >>>>>>>>>>>>>>>> normally.
(There are other deciders that are not termination >>>>>>>>>>>>>>>>> analysers.)Am Sun, 16 Feb 2025 06:51:12 -0600 schrieb olcott: >>>>>>>>>>>>>>>>>>>> On 2/15/2025 2:49 AM, Mikko wrote:I am focusing on the isomorphic notion of a >>>>>>>>>>>>>>>>>> termination analyzer.
such as one that calls a non-aborting version of HHH >>>>>>>>>>>>>>>>>>>On 2025-02-14 12:40:04 +0000, olcott said: >>>>>>>>>>>>>>>>>>>>>> On 2/14/2025 2:58 AM, Mikko wrote: >>>>>>>>>>>>>>>>>>>>>>> On 2025-02-14 00:07:23 +0000, olcott said: >>>>>>>>>>>>>>>>>>>>>>>> On 2/13/2025 3:20 AM, Mikko wrote: >>>>>>>>>>>>>>>>>>>>>>>>> On 2025-02-13 04:21:34 +0000, olcott said: >>>>>>>>>>>>>>>>>>>>>>>>>> On 2/12/2025 4:04 AM, Mikko wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>> On 2025-02-11 14:41:38 +0000, olcott said: >>>>>>>>>>>>>>>trying to get away with changing the subject to some >>>>>>>>>>>>>>>>>>>> other DD
DD correctly simulated by HHH cannot possibly >>>>>>>>>>>>>>>>>>>>>> terminate normally.
That claim has already shown to be false. Nothing >>>>>>>>>>>>>>>>>>>>> above shows that
HHH does not return 0. If it does DD also returns 0. >>>>>>>>>>>>>>>>>>>> When we are referring to the above DD simulated by >>>>>>>>>>>>>>>>>>>> HHH and not
somewhere else
then anyone with sufficient knowledge of C >>>>>>>>>>>>>>>>>>>> programming knows that no
instance of DD shown above simulated by any >>>>>>>>>>>>>>>>>>>> corresponding instance
of HHH can possibly terminate normally. >>>>>>>>>>>>>>>>>>> Well, then that corresponding (by what?) HHH isn’t a >>>>>>>>>>>>>>>>>>> decider.
A simulating termination analyzer correctly rejects >>>>>>>>>>>>>>>>>> any input thatit halts, because it is a decider. You can’t have your >>>>>>>>>>>>>>>>> cake and eat it
must be aborted to prevent its own non-termination. >>>>>>>>>>>>>>>>> Yes, in particular itself is not such an input, because >>>>>>>>>>>>>>>>> we *know* that
too.
an ambiguous „abnormal termination”. How does HHH >>>>>>>>>>>>>>> simulate DD
terminating abnormally, then? Why doesn’t it terminate >>>>>>>>>>>>>>> abnormally
itself?
You can substitute the term: the input DD to HHH does not >>>>>>>>>>>>>>> need to be
aborted, because the simulated decider terminates. >>>>>>>>>>>>>>>
typedef void (*ptr)();
int HHH(ptr P);
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
int main()
{
HHH(DD);
}
Every simulated input that must be aborted to
prevent the non-termination of HHH is stipulated
to be correctly rejected by HHH as non-terminating. >>>>>>>>>>>>>>
It merely means that the words do not have their ordinary >>>>>>>>>>>> meaning.
Unless HHH(DD) aborts its simulation of DD itself cannot >>>>>>>>>>> possibly terminate normally. Every expert in the C
programming language
can see this. People that are not experts get confused by the >>>>>>>>>>> loop
after the "if" statement.
So? Since it does that, it needs to presume that the copy of >>>>>>>>>> itself it sees called does that.
Not at all. Perhaps your technical skill is much more woefully >>>>>>>>> deficient than I ever imagined.
Here is the point that you just missed Unless the first HHH
that sees the non-terminating pattern aborts its simulation
none of them do because they all have the exact same code.
The point Olcott misses is that if the non-terminating HHH is
changed to abort the simulation, the program is changed. He does >>>>>>>> not understand that a modification of a program makes a change. >>>>>>>> Such a change modifies the behaviour of the program. The non-
termination behaviour has disappeared with this change and only >>>>>>>> remains in his dreams. After this change, the simulation would >>>>>>>> terminate normally and HHH should no longer abort. But it does, >>>>>>>> because the code that detects the 'special condition' has a bug, >>>>>>>> which makes that it does not see that the program has been
changed into a halting program.
When I focus on one single-point:
I get two years of dodging and this point is never addressed.
[DD simulated by HHH cannot possibly terminate normally]
void DDD()
{
HHH(DDD);
return;
}
int main()
{
HHH(Infinite_Recursion);
HHH(DDD);
}
ignores it when it is addressed.
What is the point? Even if HHH fails to simulate the halting
program DD up to the end because it is logically impossible for it >>>>>> to complete the simulation, it still fails.
It fails In the same way that every CAD system
will never correctly represent a geometric circle that has
four equal length sides in the same two dimensional plane.
square circle. Similarly, HHH fails if it is given the task to
determine the termination behaviour of DD.
It DOES NOT FAIL when it is defined coherently.
The square root of a basket of rotten eggs is also not computable.
square root of a basket of rotten eggs. Similarly, it is equally
stupid to try the impossible task of letting HHH simulate itself.
Because the code proves that HHH does simulate itself correctly
it is not stupid for HHH to simulate itself. This was the most
difficult aspect of creating the x86utm operating system.
| Sysop: | Keyop |
|---|---|
| Location: | Huddersfield, West Yorkshire, UK |
| Users: | 546 |
| Nodes: | 16 (2 / 14) |
| Uptime: | 154:26:15 |
| Calls: | 10,383 |
| Files: | 14,054 |
| Messages: | 6,417,847 |