From Newsgroup: comp.ai.philosophy

On 7/20/25 10:08 AM, olcott wrote:

On 7/20/2025 2:38 AM, Fred. Zwarts wrote:

Op 20.jul.2025 om 05:20 schreef olcott:

On 7/19/2025 9:12 PM, Richard Damon wrote:

On 7/19/25 5:18 PM, olcott wrote:

On 7/19/2025 4:00 PM, Alan Mackenzie wrote:

Mike Terry <news.dead.person.stones@darjeeling.plus.com> wrote:

[ .... ]

ps. learn to post more respectfully.

You've hit the nail on the head, there.  Peter Olcott doesn't show >>>>>> respect here for anybody.  Because of this he isn't shown any respect >>>>>> back - he hasn't earned any.  I don't think he understands the
concept
of respect any more than he understands the concept of truth.

If he were to show repect, he'd repect knowledge, truth, and
learning,
and strive to acquire these qualities.  Instead he displays
contempt for
them.  This is a large part of what makes him a crank.  It is
a large part of what makes it such a waste of time trying to correct >>>>>> him, something that you've sensibly given up.

Now that chat bots have proven that they understand
what I am saying I can rephrase my words to be more
clear.

They have done no such thing, because they can't

Since yoiu feed them lies, all you have done is shown that you think
lies are valid logic.

I have been rude because I cannot interpret the
rebuttal to this statement as anything besides
a despicable lie for the sole purpose of sadistic
pleasure of gaslighting:

Because you are just too stupid.

How is the "pattern" that HHH detects a non-halting pattern, when
non- halting is DEFINED by the behavior of the directly executed
machine, and the pattern you are thinking of exists in the execution
of the DDD that halts because it was built on the same HHH you claim
is correct to return 0,

Thus, your claim *IS* just a lie, and you shows your ignorance by
saying you can't undetstand how it is one.

<input to chat bots>
typedef void (*ptr)();
int HHH(ptr P);

void DDD()
{
   HHH(DDD);
   return;
}

int main()
{
   HHH(DDD);
   DDD();
}

Termination Analyzer HHH simulates its input until
it detects a non-terminating behavior pattern. When
HHH detects such a pattern it aborts its simulation
and returns 0.
</input to chat bots>

Every chatbot figures out on its own that HHH
correctly rejects DDD as non-terminating because
the input to HHH(DDD) specifies recursive simulation.

BECAUSE YOU LIE TO THEM, and a prime training parameter is to give
an answer the user is apt to like, and thus will tend to just accept
lies and errors provided.

I only defined the hypothetical possibility of a simulating
termination analyzer. This cannot possibly be a lie. They
figured out all the rest on their own.

No you told it that a correct simulating termination analyser could be
presumed. Which is an invalid presumption, because it has been proven
that it cannot.

Unlike a halt decider that must be correct
on every input a simulating termination analyzer
only needs be correct on at least one input.

Nope, got a source for that definition.

Per you favorite sourse:
https://en.wikipedia.org/wiki/Termination_analysis

The difference between a Halt Decider and a Terminatation Analyzer is:


In computer science, termination analysis is program analysis which
attempts to determine whether the evaluation of a given program halts
for each input. This means to determine whether the input program
computes a total function.

ANd further described with:

It is closely related to the halting problem, which is to determine
whether a given program halts for a given input and which is
undecidable. The termination analysis is even more difficult than the
halting problem: the termination analysis in the model of Turing
machines as the model of programs implementing computable functions
would have the goal of deciding whether a given Turing machine is a
total Turing machine, and this problem is at level <unrepresentable
symbol in plain text> of the arithmetical hierarchy and thus is strictly
more difficult than the halting problem.Note,
So, there is NOTHING about the base term being allowed to be just a
partial decider. It is a fact (as explained somewhat in the article)
that the field understand that complete isn't possible, and talk about
how good you can do.

void Infinite_Recursion()
{
  Infinite_Recursion();
}

void Infinite_Loop()
{
  HERE: goto HERE;
  return;
}

void Infinite_Loop2()
{
L1: goto L3;
L2: goto L1;
L3: goto L2;
}

HHH correctly determines the halt status of
the above three functions.

So?

It seems you don't understand the error of proof by example. Just
because you get a simple problem right, doesn't me you are right on a
more complicated one.

All you are doing is showing you don't understand how Artificiial
Intelegence actualy works, showing your Natural Stupidity.

That they provided all of the reasoning why DDD correctly
simulated by HHH does not halt proves that they do have
the functional equivalent of human understanding.

The other error is the presumption that a simulation that does not
reach the end of the simulation is evidence for non-termination.

*Incorrect paraphrase*
Halting is defined as reaching a final halt state.

*INCORRECT PARAPHRASE*

Halting is defined as the PROGRAM / MACHINE reaching a final state.

if the state is final, the machine just stops and continues no more. https://cs.stackexchange.com/questions/38228/what-is-halting

When it is correctly predicted that
an infinite simulation of the input
cannot possibly reach its own "return"
statement final halt state then the
input is non-halting.

But it isn't correctly predeicted, as Halting is about THE PROGRAM, as DIRECTLY EXECUTED and you admit that this halts.

That the decider can't simulate the input has nothing to do with the definition, showing that you just don't understand what you are talking
about.

It is not. An incomplete simulation is at best an indication that
other tools are needed to determine non-halting behaviour.

You cannot possibly coherently explain the details of this
because what you just said in incorrect. Exactly what are
the "other tools" that you are referring to a magic wand?

The other tool is a UTM, or in this case HHH1.

That everyone here denies what every first year CS student
would understand seems to prove that they know that they
are liars.

Even first year CS students understand that false presumptions lead to
false conclusions. That is the only thing the chat box shows.Yet they
recognize that recursive simulation is a

non-halting behavior pattern similar to infinite
recursion. Termination analyzers correctly predict
what the behavior of infinite simulation would be.

But the pattern isn't a non-halting pattern, as shown, proving you are
just a pathological liar.

You have ADMITTED that the behavior of the input by the ACTUAL
DEFINITION (that you try to ignore) halts, but then try to claim that non-halting is an acceptable alternative.

By the law of non-contradiction, you just prove yourself to be a liar.
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.ai.philosophy

On 7/20/25 10:30 AM, olcott wrote:

On 7/20/2025 6:13 AM, Richard Damon wrote:

On 7/19/25 11:20 PM, olcott wrote:

On 7/19/2025 9:12 PM, Richard Damon wrote:

On 7/19/25 5:18 PM, olcott wrote:

On 7/19/2025 4:00 PM, Alan Mackenzie wrote:

Mike Terry <news.dead.person.stones@darjeeling.plus.com> wrote:

[ .... ]

ps. learn to post more respectfully.

You've hit the nail on the head, there.  Peter Olcott doesn't show >>>>>> respect here for anybody.  Because of this he isn't shown any respect >>>>>> back - he hasn't earned any.  I don't think he understands the
concept
of respect any more than he understands the concept of truth.

If he were to show repect, he'd repect knowledge, truth, and
learning,
and strive to acquire these qualities.  Instead he displays
contempt for
them.  This is a large part of what makes him a crank.  It is
a large part of what makes it such a waste of time trying to correct >>>>>> him, something that you've sensibly given up.

Now that chat bots have proven that they understand
what I am saying I can rephrase my words to be more
clear.

They have done no such thing, because they can't

Since yoiu feed them lies, all you have done is shown that you think
lies are valid logic.

I have been rude because I cannot interpret the
rebuttal to this statement as anything besides
a despicable lie for the sole purpose of sadistic
pleasure of gaslighting:

Because you are just too stupid.

How is the "pattern" that HHH detects a non-halting pattern, when
non- halting is DEFINED by the behavior of the directly executed
machine, and the pattern you are thinking of exists in the execution
of the DDD that halts because it was built on the same HHH you claim
is correct to return 0,

Thus, your claim *IS* just a lie, and you shows your ignorance by
saying you can't undetstand how it is one.

<input to chat bots>
typedef void (*ptr)();
int HHH(ptr P);

void DDD()
{
   HHH(DDD);
   return;
}

int main()
{
   HHH(DDD);
   DDD();
}

Termination Analyzer HHH simulates its input until
it detects a non-terminating behavior pattern. When
HHH detects such a pattern it aborts its simulation
and returns 0.
</input to chat bots>

Every chatbot figures out on its own that HHH
correctly rejects DDD as non-terminating because
the input to HHH(DDD) specifies recursive simulation.

BECAUSE YOU LIE TO THEM, and a prime training parameter is to give
an answer the user is apt to like, and thus will tend to just accept
lies and errors provided.

I only defined the hypothetical possibility of a simulating
termination analyzer. This cannot possibly be a lie. They
figured out all the rest on their own.

No, you stated that it DOES something that it doesn't.

Unlike a halt decider that must be correct
on every input a simulating termination analyzer
only needs be correct on at least one input.

WRONG. (Full details in another post)

That you can't show a reliable source for your definition just proves
you just make things up, because you are just a pathological liar.

You may have THOUGHT you read that somewhere, but that was probably
because you misunderstood what you were reading or took something out of context.

void Infinite_Recursion()
{
  Infinite_Recursion();
}

void Infinite_Loop()
{
  HERE: goto HERE;
  return;
}

void Infinite_Loop2()
{
L1: goto L3;
L2: goto L1;
L3: goto L2;
}

HHH correctly determines the halt status of
the above three functions.

So?

Proof by example of a universal condition is just a logical fallacy.

Shows you don't understand how logic works.

Also, you imply that your "input" isn't the input that actually needs
to be given, as without the code of the specific HHH that this DDD
calls, no Simulating Halt Decider could do the simulation that you
talk about.

Your brain damage causes you to keep forgetting
that DDD has access to all of the machine code
in Halt7.obj. I told you this dozens of times
and you already forget by the time you reply.

And thus you are admitting that all of that is "part of the input", as
in computability theory, programs can only access things that are part
of thier input.

It seems you just don't undetstand that.

It should be noted that it is a well known property of Artifical
Intelegence, and in particular, Large Languge Models, are built not to
give a "correct" answer, but an answer the user will like. And thus
they will pick up on the subtle clues of how things are worded to give
the responce that seems to be desired, even if it is just wrong.

That is an incorrect assessment of how LLM systems work
and you can't show otherwise because you are wrong.

Look at the training regimine and traineer instructions,

The people "grading" the results were often specifically told not to
worry about if the details were factually correct, just if the answer
seemed plausible.

Maybe you just never looked into the full process of building an AI. THe
issue is that it is a very abstract process, and many of the mechanisms
not well understood.

When you add to the input the actual definition of "Non-Halting", as
being that the exectuion of the program or its complete simulation
will NEVER halt, even if carried out to an unbounded number of steps,
they will give a different answer.

This is a whole other issue that I have addressed.

They figured out on their own that if DDD was correctly
simulated by HHH for an infinite number of steps that
DDD would never stop running.

But that is a different input.

THe problem is you LIED about the input, because you omitted that DDD
and HHH had access to a fixed halt7.c file, which actually means that
there is no HHH that simluates for an infinite number of steps, as the definition of HHH was fixed by your problem specification, as it is in
that fixed Halt7.c

If you disagree with that definition, then you are admitting that you
don't know the meaning of the terms-of-art of the system, but are just
admitting to being the lying bastard that you are.

Two different LLM systems both agree that the halting
problem definition is wrong.

So? You lie to them.

Sorry, you just are proving you don't know what it means to actually
PROVE something, which makes you worse than the Climate change deniers
or the election denies. They at least try to use mostly proper logic,
just pull in questionable interpresations of data.

You just ignore the basics of the system.

<ChatGPT>
  The standard proof assumes a decider
  H(M,x) that determines whether machine
  M halts on input x.

  But this formulation is flawed, because:
  Turing machines can only process finite
  encodings (e.g. ⟨M⟩), not executable entities
  like M.

  So the valid formulation must be
  H(⟨M⟩,x), where ⟨M⟩ is a string.
</ChatGPT>

You cannot point out any error with that because
it is correct.

All you are doing is showing you don't understand how Artificiial
Intelegence actualy works, showing your Natural Stupidity.

That they provided all of the reasoning why DDD correctly
simulated by HHH does not halt proves that they do have
the functional equivalent of human understanding.

But the problem is that your HHH that answers doesn't do a correct
simulation.

All simulating termination analyzers only predict
what would happen if they did a complete simulation
on non terminating inputs.

But of the SPECIFIC input they are given, which must be a PROGRAM, and
thus for DDD, contains the exact code of the HHH that you claim gives
the corect answer, and NOT change to this hypothetical decider.

It has always been completely nuts to require a non
terminating input to be simulating until its non-existent
completion.

And never was the requreiment, only that it decides on the basis of what
a complete and correct simulation of its exact input would do, and that
will still be the DDD that calls the original HHH, not the UTM.

Yes, if *THE* HHH is one that correctly simulates the input (that has
been fixed to include the code of HHH) then that simulation will not
halt and be non-halting, but that HHH never answers.

Correctly *predict* the behavior of unlimited simulation,
not actually do an infinite simulation.

Right, OF THE PROGRAM whose descxription it was given,

That is the DDD that calls the HHH that gives the answer you claim to be correct.

The unlimited simulation of that input halts, as you admit.

Your problem is you try to make category errors by changing the input
and the decider to not be programs, and thus you just go into non-sense.

Since that input included the code for the HHH that doesn't abort, it
isn't the input that any of your HHHs that do abort has been given.

Correctly *predict* the behavior of unlimited simulation,
not actually do an infinite simulation.

Right, and the unlimited simulation of this exact program given as the
input, which for D/DD/DDD calls the HHH that you claim is getting the
righrt asnwer (and not changed to call the unlimited simulator) and thus
that simulation does halt.

All you are doing is admitting to you don't know what you are talking
about and it has been shown that you logic is just full of errors.

Thus, the reason you need to LIE about what the input is.

That everyone here denies what every first year CS student
would understand seems to prove that they know that they
are liars.

The problem is that a first year CS Student would see your mistake.
(or would be destined to fail out of the program).

Your use of arguments like that is what shows that you don't understand

--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.ai.philosophy

On 7/20/2025 6:13 PM, Richard Damon wrote:

On 7/20/25 10:08 AM, olcott wrote:

On 7/20/2025 2:38 AM, Fred. Zwarts wrote:

Op 20.jul.2025 om 05:20 schreef olcott:

On 7/19/2025 9:12 PM, Richard Damon wrote:

On 7/19/25 5:18 PM, olcott wrote:

On 7/19/2025 4:00 PM, Alan Mackenzie wrote:

Mike Terry <news.dead.person.stones@darjeeling.plus.com> wrote:

[ .... ]

ps. learn to post more respectfully.

You've hit the nail on the head, there.  Peter Olcott doesn't show >>>>>>> respect here for anybody.  Because of this he isn't shown any
respect
back - he hasn't earned any.  I don't think he understands the >>>>>>> concept
of respect any more than he understands the concept of truth.

If he were to show repect, he'd repect knowledge, truth, and
learning,
and strive to acquire these qualities.  Instead he displays
contempt for
them.  This is a large part of what makes him a crank.  It is
a large part of what makes it such a waste of time trying to correct >>>>>>> him, something that you've sensibly given up.

Now that chat bots have proven that they understand
what I am saying I can rephrase my words to be more
clear.

They have done no such thing, because they can't

Since yoiu feed them lies, all you have done is shown that you
think lies are valid logic.

I have been rude because I cannot interpret the
rebuttal to this statement as anything besides
a despicable lie for the sole purpose of sadistic
pleasure of gaslighting:

Because you are just too stupid.

How is the "pattern" that HHH detects a non-halting pattern, when
non- halting is DEFINED by the behavior of the directly executed
machine, and the pattern you are thinking of exists in the
execution of the DDD that halts because it was built on the same
HHH you claim is correct to return 0,

Thus, your claim *IS* just a lie, and you shows your ignorance by
saying you can't undetstand how it is one.

<input to chat bots>
typedef void (*ptr)();
int HHH(ptr P);

void DDD()
{
   HHH(DDD);
   return;
}

int main()
{
   HHH(DDD);
   DDD();
}

Termination Analyzer HHH simulates its input until
it detects a non-terminating behavior pattern. When
HHH detects such a pattern it aborts its simulation
and returns 0.
</input to chat bots>

Every chatbot figures out on its own that HHH
correctly rejects DDD as non-terminating because
the input to HHH(DDD) specifies recursive simulation.

BECAUSE YOU LIE TO THEM, and a prime training parameter is to give
an answer the user is apt to like, and thus will tend to just
accept lies and errors provided.

I only defined the hypothetical possibility of a simulating
termination analyzer. This cannot possibly be a lie. They
figured out all the rest on their own.

No you told it that a correct simulating termination analyser could
be presumed. Which is an invalid presumption, because it has been
proven that it cannot.

Unlike a halt decider that must be correct
on every input a simulating termination analyzer
only needs be correct on at least one input.

Nope, got a source for that definition.

Per you favorite sourse:
https://en.wikipedia.org/wiki/Termination_analysis

The difference between a Halt Decider and a Terminatation Analyzer is:

In computer science, termination analysis is program analysis which
attempts to determine whether the evaluation of a given program halts
for each input.

void Infinite_Loop()
{
HERE: goto HERE;
return;
}

Thus HHH(Infinite_Loop) is correct for every
input that Infinite_Loop has.
--
Copyright 2024 Olcott

"Talent hits a target no one else can hit;
Genius hits a target no one else can see."
Arthur Schopenhauer
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.ai.philosophy

On 7/20/25 7:54 PM, olcott wrote:

On 7/20/2025 6:13 PM, Richard Damon wrote:

On 7/20/25 10:08 AM, olcott wrote:

On 7/20/2025 2:38 AM, Fred. Zwarts wrote:

Op 20.jul.2025 om 05:20 schreef olcott:

On 7/19/2025 9:12 PM, Richard Damon wrote:

On 7/19/25 5:18 PM, olcott wrote:

On 7/19/2025 4:00 PM, Alan Mackenzie wrote:

Mike Terry <news.dead.person.stones@darjeeling.plus.com> wrote: >>>>>>>>
[ .... ]

ps. learn to post more respectfully.

You've hit the nail on the head, there.  Peter Olcott doesn't show >>>>>>>> respect here for anybody.  Because of this he isn't shown any >>>>>>>> respect
back - he hasn't earned any.  I don't think he understands the >>>>>>>> concept
of respect any more than he understands the concept of truth.

If he were to show repect, he'd repect knowledge, truth, and
learning,
and strive to acquire these qualities.  Instead he displays
contempt for
them.  This is a large part of what makes him a crank.  It is >>>>>>>> a large part of what makes it such a waste of time trying to
correct
him, something that you've sensibly given up.

Now that chat bots have proven that they understand
what I am saying I can rephrase my words to be more
clear.

They have done no such thing, because they can't

Since yoiu feed them lies, all you have done is shown that you
think lies are valid logic.

I have been rude because I cannot interpret the
rebuttal to this statement as anything besides
a despicable lie for the sole purpose of sadistic
pleasure of gaslighting:

Because you are just too stupid.

How is the "pattern" that HHH detects a non-halting pattern, when >>>>>> non- halting is DEFINED by the behavior of the directly executed
machine, and the pattern you are thinking of exists in the
execution of the DDD that halts because it was built on the same
HHH you claim is correct to return 0,

Thus, your claim *IS* just a lie, and you shows your ignorance by >>>>>> saying you can't undetstand how it is one.

<input to chat bots>
typedef void (*ptr)();
int HHH(ptr P);

void DDD()
{
   HHH(DDD);
   return;
}

int main()
{
   HHH(DDD);
   DDD();
}

Termination Analyzer HHH simulates its input until
it detects a non-terminating behavior pattern. When
HHH detects such a pattern it aborts its simulation
and returns 0.
</input to chat bots>

Every chatbot figures out on its own that HHH
correctly rejects DDD as non-terminating because
the input to HHH(DDD) specifies recursive simulation.

BECAUSE YOU LIE TO THEM, and a prime training parameter is to give >>>>>> an answer the user is apt to like, and thus will tend to just
accept lies and errors provided.

I only defined the hypothetical possibility of a simulating
termination analyzer. This cannot possibly be a lie. They
figured out all the rest on their own.

No you told it that a correct simulating termination analyser could
be presumed. Which is an invalid presumption, because it has been
proven that it cannot.

Unlike a halt decider that must be correct
on every input a simulating termination analyzer
only needs be correct on at least one input.

Nope, got a source for that definition.

Per you favorite sourse:
https://en.wikipedia.org/wiki/Termination_analysis

The difference between a Halt Decider and a Terminatation Analyzer is:


In computer science, termination analysis is program analysis which
attempts to determine whether the evaluation of a given program halts
for each input.

void Infinite_Loop()
{
  HERE: goto HERE;
  return;
}

Thus HHH(Infinite_Loop) is correct for every
input that Infinite_Loop has.

But the Termination Analyzer is HHH, not HHH(Infinte_Loop).

HHH(Infinite_Loop) is just a single invocation of the Analyzer.

To be a correct Termination Analyzer, HHH needs to give the correct
answer for *ALL* calls HHH(x) for all possible values of x as
representations of programs (not just of Infinite_Loop)

It seems you just like demonstrating your ignorance of the meaning of
the words, probably because you DECIDED that you wanted to be ignorant
so you could make up you lies without the truth being able to bother
your dead brain.
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.ai.philosophy

On 7/20/2025 7:29 PM, Richard Damon wrote:

On 7/20/25 7:54 PM, olcott wrote:

On 7/20/2025 6:13 PM, Richard Damon wrote:

On 7/20/25 10:08 AM, olcott wrote:

On 7/20/2025 2:38 AM, Fred. Zwarts wrote:

Op 20.jul.2025 om 05:20 schreef olcott:

On 7/19/2025 9:12 PM, Richard Damon wrote:

On 7/19/25 5:18 PM, olcott wrote:

On 7/19/2025 4:00 PM, Alan Mackenzie wrote:

Mike Terry <news.dead.person.stones@darjeeling.plus.com> wrote: >>>>>>>>>
[ .... ]

ps. learn to post more respectfully.

You've hit the nail on the head, there.  Peter Olcott doesn't show >>>>>>>>> respect here for anybody.  Because of this he isn't shown any >>>>>>>>> respect
back - he hasn't earned any.  I don't think he understands the >>>>>>>>> concept
of respect any more than he understands the concept of truth. >>>>>>>>>
If he were to show repect, he'd repect knowledge, truth, and >>>>>>>>> learning,
and strive to acquire these qualities.  Instead he displays >>>>>>>>> contempt for
them.  This is a large part of what makes him a crank.  It is >>>>>>>>> a large part of what makes it such a waste of time trying to >>>>>>>>> correct
him, something that you've sensibly given up.

Now that chat bots have proven that they understand
what I am saying I can rephrase my words to be more
clear.

They have done no such thing, because they can't

Since yoiu feed them lies, all you have done is shown that you
think lies are valid logic.

I have been rude because I cannot interpret the
rebuttal to this statement as anything besides
a despicable lie for the sole purpose of sadistic
pleasure of gaslighting:

Because you are just too stupid.

How is the "pattern" that HHH detects a non-halting pattern, when >>>>>>> non- halting is DEFINED by the behavior of the directly executed >>>>>>> machine, and the pattern you are thinking of exists in the
execution of the DDD that halts because it was built on the same >>>>>>> HHH you claim is correct to return 0,

Thus, your claim *IS* just a lie, and you shows your ignorance by >>>>>>> saying you can't undetstand how it is one.

<input to chat bots>
typedef void (*ptr)();
int HHH(ptr P);

void DDD()
{
   HHH(DDD);
   return;
}

int main()
{
   HHH(DDD);
   DDD();
}

Termination Analyzer HHH simulates its input until
it detects a non-terminating behavior pattern. When
HHH detects such a pattern it aborts its simulation
and returns 0.
</input to chat bots>

Every chatbot figures out on its own that HHH
correctly rejects DDD as non-terminating because
the input to HHH(DDD) specifies recursive simulation.

BECAUSE YOU LIE TO THEM, and a prime training parameter is to
give an answer the user is apt to like, and thus will tend to
just accept lies and errors provided.

I only defined the hypothetical possibility of a simulating
termination analyzer. This cannot possibly be a lie. They
figured out all the rest on their own.

No you told it that a correct simulating termination analyser could >>>>> be presumed. Which is an invalid presumption, because it has been
proven that it cannot.

Unlike a halt decider that must be correct
on every input a simulating termination analyzer
only needs be correct on at least one input.

Nope, got a source for that definition.

Per you favorite sourse:
https://en.wikipedia.org/wiki/Termination_analysis

The difference between a Halt Decider and a Terminatation Analyzer is:


In computer science, termination analysis is program analysis which
attempts to determine whether the evaluation of a given program halts
for each input.

void Infinite_Loop()
{
   HERE: goto HERE;
   return;
}

Thus HHH(Infinite_Loop) is correct for every
input that Infinite_Loop has.

But the Termination Analyzer is HHH, not HHH(Infinite_Loop).

HHH correctly reports on the halt status
for every input that Infinite_Loop takes,
all zero of them. This proves that HHH is
a termination analyzer for Infinite_Loop
even if HHH is wrong on everything else.
--
Copyright 2024 Olcott

"Talent hits a target no one else can hit;
Genius hits a target no one else can see."
Arthur Schopenhauer
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.ai.philosophy

On 7/20/2025 7:29 PM, Richard Damon wrote:

On 7/20/25 7:54 PM, olcott wrote:

On 7/20/2025 6:13 PM, Richard Damon wrote:

On 7/20/25 10:08 AM, olcott wrote:

On 7/20/2025 2:38 AM, Fred. Zwarts wrote:

Op 20.jul.2025 om 05:20 schreef olcott:

On 7/19/2025 9:12 PM, Richard Damon wrote:

On 7/19/25 5:18 PM, olcott wrote:

On 7/19/2025 4:00 PM, Alan Mackenzie wrote:

Mike Terry <news.dead.person.stones@darjeeling.plus.com> wrote: >>>>>>>>>
[ .... ]

ps. learn to post more respectfully.

You've hit the nail on the head, there.  Peter Olcott doesn't show >>>>>>>>> respect here for anybody.  Because of this he isn't shown any >>>>>>>>> respect
back - he hasn't earned any.  I don't think he understands the >>>>>>>>> concept
of respect any more than he understands the concept of truth. >>>>>>>>>
If he were to show repect, he'd repect knowledge, truth, and >>>>>>>>> learning,
and strive to acquire these qualities.  Instead he displays >>>>>>>>> contempt for
them.  This is a large part of what makes him a crank.  It is >>>>>>>>> a large part of what makes it such a waste of time trying to >>>>>>>>> correct
him, something that you've sensibly given up.

Now that chat bots have proven that they understand
what I am saying I can rephrase my words to be more
clear.

They have done no such thing, because they can't

Since yoiu feed them lies, all you have done is shown that you
think lies are valid logic.

I have been rude because I cannot interpret the
rebuttal to this statement as anything besides
a despicable lie for the sole purpose of sadistic
pleasure of gaslighting:

Because you are just too stupid.

How is the "pattern" that HHH detects a non-halting pattern, when >>>>>>> non- halting is DEFINED by the behavior of the directly executed >>>>>>> machine, and the pattern you are thinking of exists in the
execution of the DDD that halts because it was built on the same >>>>>>> HHH you claim is correct to return 0,

Thus, your claim *IS* just a lie, and you shows your ignorance by >>>>>>> saying you can't undetstand how it is one.

<input to chat bots>
typedef void (*ptr)();
int HHH(ptr P);

void DDD()
{
   HHH(DDD);
   return;
}

int main()
{
   HHH(DDD);
   DDD();
}

Termination Analyzer HHH simulates its input until
it detects a non-terminating behavior pattern. When
HHH detects such a pattern it aborts its simulation
and returns 0.
</input to chat bots>

Every chatbot figures out on its own that HHH
correctly rejects DDD as non-terminating because
the input to HHH(DDD) specifies recursive simulation.

BECAUSE YOU LIE TO THEM, and a prime training parameter is to
give an answer the user is apt to like, and thus will tend to
just accept lies and errors provided.

I only defined the hypothetical possibility of a simulating
termination analyzer. This cannot possibly be a lie. They
figured out all the rest on their own.

No you told it that a correct simulating termination analyser could >>>>> be presumed. Which is an invalid presumption, because it has been
proven that it cannot.

Unlike a halt decider that must be correct
on every input a simulating termination analyzer
only needs be correct on at least one input.

Nope, got a source for that definition.

Per you favorite sourse:
https://en.wikipedia.org/wiki/Termination_analysis

The difference between a Halt Decider and a Terminatation Analyzer is:


In computer science, termination analysis is program analysis which
attempts to determine whether the evaluation of a given program halts
for each input.

void Infinite_Loop()
{
   HERE: goto HERE;
   return;
}

Thus HHH(Infinite_Loop) is correct for every
input that Infinite_Loop has.

But the Termination Analyzer is HHH, not HHH(Infinte_Loop).

HHH(Infinite_Loop) is just a single invocation of the Analyzer.

To be a correct Termination Analyzer, HHH needs to give the correct
answer for *ALL* calls HHH(x) for all possible values of x as representations of programs (not just of Infinite_Loop)

evaluation of a given program halts for each input.

evaluation of a given program (such as Infinite_Loop)
halts for each input (all zero of them).
--
Copyright 2024 Olcott

"Talent hits a target no one else can hit;
Genius hits a target no one else can see."
Arthur Schopenhauer
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.ai.philosophy

On 7/20/25 8:48 PM, olcott wrote:

On 7/20/2025 7:29 PM, Richard Damon wrote:

On 7/20/25 7:54 PM, olcott wrote:

On 7/20/2025 6:13 PM, Richard Damon wrote:

On 7/20/25 10:08 AM, olcott wrote:

On 7/20/2025 2:38 AM, Fred. Zwarts wrote:

Op 20.jul.2025 om 05:20 schreef olcott:

On 7/19/2025 9:12 PM, Richard Damon wrote:

On 7/19/25 5:18 PM, olcott wrote:

On 7/19/2025 4:00 PM, Alan Mackenzie wrote:

Mike Terry <news.dead.person.stones@darjeeling.plus.com> wrote: >>>>>>>>>>
[ .... ]

ps. learn to post more respectfully.

You've hit the nail on the head, there.  Peter Olcott doesn't >>>>>>>>>> show
respect here for anybody.  Because of this he isn't shown any >>>>>>>>>> respect
back - he hasn't earned any.  I don't think he understands the >>>>>>>>>> concept
of respect any more than he understands the concept of truth. >>>>>>>>>>
If he were to show repect, he'd repect knowledge, truth, and >>>>>>>>>> learning,
and strive to acquire these qualities.  Instead he displays >>>>>>>>>> contempt for
them.  This is a large part of what makes him a crank.  It is >>>>>>>>>> a large part of what makes it such a waste of time trying to >>>>>>>>>> correct
him, something that you've sensibly given up.

Now that chat bots have proven that they understand
what I am saying I can rephrase my words to be more
clear.

They have done no such thing, because they can't

Since yoiu feed them lies, all you have done is shown that you >>>>>>>> think lies are valid logic.

I have been rude because I cannot interpret the
rebuttal to this statement as anything besides
a despicable lie for the sole purpose of sadistic
pleasure of gaslighting:

Because you are just too stupid.

How is the "pattern" that HHH detects a non-halting pattern,
when non- halting is DEFINED by the behavior of the directly
executed machine, and the pattern you are thinking of exists in >>>>>>>> the execution of the DDD that halts because it was built on the >>>>>>>> same HHH you claim is correct to return 0,

Thus, your claim *IS* just a lie, and you shows your ignorance >>>>>>>> by saying you can't undetstand how it is one.

<input to chat bots>
typedef void (*ptr)();
int HHH(ptr P);

void DDD()
{
   HHH(DDD);
   return;
}

int main()
{
   HHH(DDD);
   DDD();
}

Termination Analyzer HHH simulates its input until
it detects a non-terminating behavior pattern. When
HHH detects such a pattern it aborts its simulation
and returns 0.
</input to chat bots>

Every chatbot figures out on its own that HHH
correctly rejects DDD as non-terminating because
the input to HHH(DDD) specifies recursive simulation.

BECAUSE YOU LIE TO THEM, and a prime training parameter is to >>>>>>>> give an answer the user is apt to like, and thus will tend to >>>>>>>> just accept lies and errors provided.

I only defined the hypothetical possibility of a simulating
termination analyzer. This cannot possibly be a lie. They
figured out all the rest on their own.

No you told it that a correct simulating termination analyser
could be presumed. Which is an invalid presumption, because it has >>>>>> been proven that it cannot.

Unlike a halt decider that must be correct
on every input a simulating termination analyzer
only needs be correct on at least one input.

Nope, got a source for that definition.

Per you favorite sourse:
https://en.wikipedia.org/wiki/Termination_analysis

The difference between a Halt Decider and a Terminatation Analyzer is: >>>>

In computer science, termination analysis is program analysis which
attempts to determine whether the evaluation of a given program
halts for each input.

void Infinite_Loop()
{
   HERE: goto HERE;
   return;
}

Thus HHH(Infinite_Loop) is correct for every
input that Infinite_Loop has.

But the Termination Analyzer is HHH, not HHH(Infinte_Loop).

HHH(Infinite_Loop) is just a single invocation of the Analyzer.

To be a correct Termination Analyzer, HHH needs to give the correct
answer for *ALL* calls HHH(x) for all possible values of x as
representations of programs (not just of Infinite_Loop)

evaluation of a given program halts for each input.

evaluation of a given program (such as Infinite_Loop)
halts for each input (all zero of them).

Nope, because a Termination Analyzer needs to answer about *ANY* Program reperesented with an input.

It was right about THAT input, but that isn't *ALL*

You are just lying to yourself about what a Termination Analyzer is
because you just don't understand the meaning of the words.

Sorry, provide a reliable source for you definition, or you are just
admitting that you world is all just make believe and thus a lie.



--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.ai.philosophy

On 7/20/25 8:45 PM, olcott wrote:

On 7/20/2025 7:29 PM, Richard Damon wrote:

On 7/20/25 7:54 PM, olcott wrote:

On 7/20/2025 6:13 PM, Richard Damon wrote:

On 7/20/25 10:08 AM, olcott wrote:

On 7/20/2025 2:38 AM, Fred. Zwarts wrote:

Op 20.jul.2025 om 05:20 schreef olcott:

On 7/19/2025 9:12 PM, Richard Damon wrote:

On 7/19/25 5:18 PM, olcott wrote:

On 7/19/2025 4:00 PM, Alan Mackenzie wrote:

Mike Terry <news.dead.person.stones@darjeeling.plus.com> wrote: >>>>>>>>>>
[ .... ]

ps. learn to post more respectfully.

You've hit the nail on the head, there.  Peter Olcott doesn't >>>>>>>>>> show
respect here for anybody.  Because of this he isn't shown any >>>>>>>>>> respect
back - he hasn't earned any.  I don't think he understands the >>>>>>>>>> concept
of respect any more than he understands the concept of truth. >>>>>>>>>>
If he were to show repect, he'd repect knowledge, truth, and >>>>>>>>>> learning,
and strive to acquire these qualities.  Instead he displays >>>>>>>>>> contempt for
them.  This is a large part of what makes him a crank.  It is >>>>>>>>>> a large part of what makes it such a waste of time trying to >>>>>>>>>> correct
him, something that you've sensibly given up.

Now that chat bots have proven that they understand
what I am saying I can rephrase my words to be more
clear.

They have done no such thing, because they can't

Since yoiu feed them lies, all you have done is shown that you >>>>>>>> think lies are valid logic.

I have been rude because I cannot interpret the
rebuttal to this statement as anything besides
a despicable lie for the sole purpose of sadistic
pleasure of gaslighting:

Because you are just too stupid.

How is the "pattern" that HHH detects a non-halting pattern,
when non- halting is DEFINED by the behavior of the directly
executed machine, and the pattern you are thinking of exists in >>>>>>>> the execution of the DDD that halts because it was built on the >>>>>>>> same HHH you claim is correct to return 0,

Thus, your claim *IS* just a lie, and you shows your ignorance >>>>>>>> by saying you can't undetstand how it is one.

<input to chat bots>
typedef void (*ptr)();
int HHH(ptr P);

void DDD()
{
   HHH(DDD);
   return;
}

int main()
{
   HHH(DDD);
   DDD();
}

Termination Analyzer HHH simulates its input until
it detects a non-terminating behavior pattern. When
HHH detects such a pattern it aborts its simulation
and returns 0.
</input to chat bots>

Every chatbot figures out on its own that HHH
correctly rejects DDD as non-terminating because
the input to HHH(DDD) specifies recursive simulation.

BECAUSE YOU LIE TO THEM, and a prime training parameter is to >>>>>>>> give an answer the user is apt to like, and thus will tend to >>>>>>>> just accept lies and errors provided.

I only defined the hypothetical possibility of a simulating
termination analyzer. This cannot possibly be a lie. They
figured out all the rest on their own.

No you told it that a correct simulating termination analyser
could be presumed. Which is an invalid presumption, because it has >>>>>> been proven that it cannot.

Unlike a halt decider that must be correct
on every input a simulating termination analyzer
only needs be correct on at least one input.

Nope, got a source for that definition.

Per you favorite sourse:
https://en.wikipedia.org/wiki/Termination_analysis

The difference between a Halt Decider and a Terminatation Analyzer is: >>>>

In computer science, termination analysis is program analysis which
attempts to determine whether the evaluation of a given program
halts for each input.

void Infinite_Loop()
{
   HERE: goto HERE;
   return;
}

Thus HHH(Infinite_Loop) is correct for every
input that Infinite_Loop has.

But the Termination Analyzer is HHH, not HHH(Infinite_Loop).

HHH correctly reports on the halt status
for every input that Infinite_Loop takes,

So?

all zero of them. This proves that HHH is
a termination analyzer for Infinite_Loop
even if HHH is wrong on everything else.

Nope, because a Termination Analyzer needs to answer about *ANY* Program reperesented with an input.

It was right about THAT input, but that isn't *ALL*

You are just lying to yourself about what a Termination Analyzer is
because you just don't understand the meaning of the words.

Sorry, provide a reliable source for you definition, or you are just
admitting that you world is all just make believe and thus a lie.



--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.ai.philosophy

On 7/20/2025 8:58 PM, Richard Damon wrote:

On 7/20/25 8:45 PM, olcott wrote:

On 7/20/2025 7:29 PM, Richard Damon wrote:

On 7/20/25 7:54 PM, olcott wrote:

On 7/20/2025 6:13 PM, Richard Damon wrote:

On 7/20/25 10:08 AM, olcott wrote:

On 7/20/2025 2:38 AM, Fred. Zwarts wrote:

Op 20.jul.2025 om 05:20 schreef olcott:

On 7/19/2025 9:12 PM, Richard Damon wrote:

On 7/19/25 5:18 PM, olcott wrote:

On 7/19/2025 4:00 PM, Alan Mackenzie wrote:

Mike Terry <news.dead.person.stones@darjeeling.plus.com> wrote: >>>>>>>>>>>
[ .... ]

ps. learn to post more respectfully.

You've hit the nail on the head, there.  Peter Olcott doesn't >>>>>>>>>>> show
respect here for anybody.  Because of this he isn't shown any >>>>>>>>>>> respect
back - he hasn't earned any.  I don't think he understands >>>>>>>>>>> the concept
of respect any more than he understands the concept of truth. >>>>>>>>>>>
If he were to show repect, he'd repect knowledge, truth, and >>>>>>>>>>> learning,
and strive to acquire these qualities.  Instead he displays >>>>>>>>>>> contempt for
them.  This is a large part of what makes him a crank.  It is >>>>>>>>>>> a large part of what makes it such a waste of time trying to >>>>>>>>>>> correct
him, something that you've sensibly given up.

Now that chat bots have proven that they understand
what I am saying I can rephrase my words to be more
clear.

They have done no such thing, because they can't

Since yoiu feed them lies, all you have done is shown that you >>>>>>>>> think lies are valid logic.

I have been rude because I cannot interpret the
rebuttal to this statement as anything besides
a despicable lie for the sole purpose of sadistic
pleasure of gaslighting:

Because you are just too stupid.

How is the "pattern" that HHH detects a non-halting pattern, >>>>>>>>> when non- halting is DEFINED by the behavior of the directly >>>>>>>>> executed machine, and the pattern you are thinking of exists in >>>>>>>>> the execution of the DDD that halts because it was built on the >>>>>>>>> same HHH you claim is correct to return 0,

Thus, your claim *IS* just a lie, and you shows your ignorance >>>>>>>>> by saying you can't undetstand how it is one.

<input to chat bots>
typedef void (*ptr)();
int HHH(ptr P);

void DDD()
{
   HHH(DDD);
   return;
}

int main()
{
   HHH(DDD);
   DDD();
}

Termination Analyzer HHH simulates its input until
it detects a non-terminating behavior pattern. When
HHH detects such a pattern it aborts its simulation
and returns 0.
</input to chat bots>

Every chatbot figures out on its own that HHH
correctly rejects DDD as non-terminating because
the input to HHH(DDD) specifies recursive simulation.

BECAUSE YOU LIE TO THEM, and a prime training parameter is to >>>>>>>>> give an answer the user is apt to like, and thus will tend to >>>>>>>>> just accept lies and errors provided.

I only defined the hypothetical possibility of a simulating
termination analyzer. This cannot possibly be a lie. They
figured out all the rest on their own.

No you told it that a correct simulating termination analyser
could be presumed. Which is an invalid presumption, because it
has been proven that it cannot.

Unlike a halt decider that must be correct
on every input a simulating termination analyzer
only needs be correct on at least one input.

Nope, got a source for that definition.

Per you favorite sourse:
https://en.wikipedia.org/wiki/Termination_analysis

The difference between a Halt Decider and a Terminatation Analyzer is: >>>>>

In computer science, termination analysis is program analysis which >>>>> attempts to determine whether the evaluation of a given program
halts for each input.

void Infinite_Loop()
{
   HERE: goto HERE;
   return;
}

Thus HHH(Infinite_Loop) is correct for every
input that Infinite_Loop has.

But the Termination Analyzer is HHH, not HHH(Infinite_Loop).

HHH correctly reports on the halt status
for every input that Infinite_Loop takes,

So?

all zero of them. This proves that HHH is
a termination analyzer for Infinite_Loop
even if HHH is wrong on everything else.

Nope, because a Termination Analyzer needs to answer about *ANY* Program reperesented with an input.

*No that is merely your ADD*
determine whether the evaluation of a given program
halts for each input.
--
Copyright 2024 Olcott

"Talent hits a target no one else can hit;
Genius hits a target no one else can see."
Arthur Schopenhauer
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.ai.philosophy

Op 20.jul.2025 om 17:07 schreef olcott:

On 7/20/2025 2:44 AM, Fred. Zwarts wrote:

Op 19.jul.2025 om 23:18 schreef olcott:

On 7/19/2025 4:00 PM, Alan Mackenzie wrote:

Mike Terry <news.dead.person.stones@darjeeling.plus.com> wrote:

[ .... ]

ps. learn to post more respectfully.

You've hit the nail on the head, there.  Peter Olcott doesn't show
respect here for anybody.  Because of this he isn't shown any respect >>>> back - he hasn't earned any.  I don't think he understands the concept >>>> of respect any more than he understands the concept of truth.

If he were to show repect, he'd repect knowledge, truth, and learning, >>>> and strive to acquire these qualities.  Instead he displays contempt >>>> for
them.  This is a large part of what makes him a crank.  It is
a large part of what makes it such a waste of time trying to correct
him, something that you've sensibly given up.

Now that chat bots have proven that they understand
what I am saying I can rephrase my words to be more
clear.

Chat-boxes prove that reasoning with invalid presumptions lead to
invalid conclusions.

I have been rude because I cannot interpret the
rebuttal to this statement as anything besides
a despicable lie for the sole purpose of sadistic
pleasure of gaslighting:

<input to chat bots>
typedef void (*ptr)();
int HHH(ptr P);

void DDD()
{
   HHH(DDD);
   return;
}

int main()
{
   HHH(DDD);
   DDD();
}

Termination Analyzer HHH simulates its input until
it detects a non-terminating behavior pattern. When
HHH detects such a pattern it aborts its simulation
and returns 0.
</input to chat bots>

We see the invalid presumption in the input. There is no non-
termination behaviour in the input.

You can see that I did not even hint at non
termination of the input

??? We read that '... until it detects non-termination pattern' and
'When HHH detects such a pattern ...' before the '</input'
Since these presumptions are never happen, all conclusions based on it
are invalid as well.
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.ai.philosophy

Op 20.jul.2025 om 16:08 schreef olcott:

On 7/20/2025 2:38 AM, Fred. Zwarts wrote:

Op 20.jul.2025 om 05:20 schreef olcott:

On 7/19/2025 9:12 PM, Richard Damon wrote:

On 7/19/25 5:18 PM, olcott wrote:

On 7/19/2025 4:00 PM, Alan Mackenzie wrote:

Mike Terry <news.dead.person.stones@darjeeling.plus.com> wrote:

[ .... ]

ps. learn to post more respectfully.

You've hit the nail on the head, there.  Peter Olcott doesn't show >>>>>> respect here for anybody.  Because of this he isn't shown any respect >>>>>> back - he hasn't earned any.  I don't think he understands the
concept
of respect any more than he understands the concept of truth.

If he were to show repect, he'd repect knowledge, truth, and
learning,
and strive to acquire these qualities.  Instead he displays
contempt for
them.  This is a large part of what makes him a crank.  It is
a large part of what makes it such a waste of time trying to correct >>>>>> him, something that you've sensibly given up.

Now that chat bots have proven that they understand
what I am saying I can rephrase my words to be more
clear.

They have done no such thing, because they can't

Since yoiu feed them lies, all you have done is shown that you think
lies are valid logic.

I have been rude because I cannot interpret the
rebuttal to this statement as anything besides
a despicable lie for the sole purpose of sadistic
pleasure of gaslighting:

Because you are just too stupid.

How is the "pattern" that HHH detects a non-halting pattern, when
non- halting is DEFINED by the behavior of the directly executed
machine, and the pattern you are thinking of exists in the execution
of the DDD that halts because it was built on the same HHH you claim
is correct to return 0,

Thus, your claim *IS* just a lie, and you shows your ignorance by
saying you can't undetstand how it is one.

<input to chat bots>
typedef void (*ptr)();
int HHH(ptr P);

void DDD()
{
   HHH(DDD);
   return;
}

int main()
{
   HHH(DDD);
   DDD();
}

Termination Analyzer HHH simulates its input until
it detects a non-terminating behavior pattern. When
HHH detects such a pattern it aborts its simulation
and returns 0.
</input to chat bots>

Every chatbot figures out on its own that HHH
correctly rejects DDD as non-terminating because
the input to HHH(DDD) specifies recursive simulation.

BECAUSE YOU LIE TO THEM, and a prime training parameter is to give
an answer the user is apt to like, and thus will tend to just accept
lies and errors provided.

I only defined the hypothetical possibility of a simulating
termination analyzer. This cannot possibly be a lie. They
figured out all the rest on their own.

No you told it that a correct simulating termination analyser could be
presumed. Which is an invalid presumption, because it has been proven
that it cannot.

Unlike a halt decider that must be correct
on every input a simulating termination analyzer
only needs be correct on at least one input.

As usual only an invalid claim without evidence.

void Infinite_Recursion()
{
  Infinite_Recursion();
}

void Infinite_Loop()
{
  HERE: goto HERE;
  return;
}

void Infinite_Loop2()
{
L1: goto L3;
L2: goto L1;
L3: goto L2;
}

HHH correctly determines the halt status of
the above three functions.

Irrelevant, because the case we are talking about has neither an
infinite loop, nor an infinite recursion.
HHH must simulate DDD that calls HHH. If HHH halts, then there is only a finite recursion:

void Finite_Recursion (int N) {
if (N > 0) Finite_Recursion (N - 1);
printf ("Olcott thinks this is never printed.\n");
}

HHH decides after N recursions that there is an infinite recursion,
which is incorrect.

All you are doing is showing you don't understand how Artificiial
Intelegence actualy works, showing your Natural Stupidity.

That they provided all of the reasoning why DDD correctly
simulated by HHH does not halt proves that they do have
the functional equivalent of human understanding.

The other error is the presumption that a simulation that does not
reach the end of the simulation is evidence for non-termination.

*Incorrect paraphrase*
Halting is defined as reaching a final halt state.

Yes and non-haltig is defined as never reaching the haltstate when
running undisturbed. When a computer is switched off, or a simulation
aborted, before a final halt state is reached, there is no evidence for non-halting behaviour of the program.

if the state is final, the machine just stops and continues no more. https://cs.stackexchange.com/questions/38228/what-is-halting

When it is correctly predicted that
an infinite simulation of the input
cannot possibly reach its own "return"
statement final halt state then the
input is non-halting.

But when it is incorrectly predicted, the program fails. This is the
case when HHH aborts the program that is specified in the input, which
has the same abort code as HHH itself. The input specifies a halting
program, as proven by other simulations, but HHH fails to reach this
final halt state. This is evidence that HHH is not the right tool for
this input.

It is not. An incomplete simulation is at best an indication that
other tools are needed to determine non-halting behaviour.

You cannot possibly coherently explain the details of this
because what you just said in incorrect. Exactly what are
the "other tools" that you are referring to a magic wand?

In this case it is the reasoning that the input specifies a final halt
state, proven by other tools, like world-class simulators and direct execution. For other inputs we may need to use other tools, but it is
very well possible that for some inputs no such tool exists.
It is a sign of bad reading capability that I have to repeat that so
many times and you still do not understand it.

That everyone here denies what every first year CS student
would understand seems to prove that they know that they
are liars.

Even first year CS students understand that false presumptions lead to
false conclusions. That is the only thing the chat box shows.Yet they
recognize that recursive simulation is a

non-halting behavior pattern similar to infinite
recursion. Termination analyzers correctly predict
what the behavior of infinite simulation would be.

Sorry, the non-halting behaviour and the infinite recursion exists only
in your dream. The HHH that aborts only sees a finite recursion, because
the simulated HHH has the same code to (incorrectly) abort and halt.
Dreams are no substitute for facts, nor a mathematical proof.
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.ai.philosophy

On 7/20/25 10:05 PM, olcott wrote:

On 7/20/2025 8:58 PM, Richard Damon wrote:

On 7/20/25 8:45 PM, olcott wrote:

On 7/20/2025 7:29 PM, Richard Damon wrote:

On 7/20/25 7:54 PM, olcott wrote:

On 7/20/2025 6:13 PM, Richard Damon wrote:

On 7/20/25 10:08 AM, olcott wrote:

On 7/20/2025 2:38 AM, Fred. Zwarts wrote:

Op 20.jul.2025 om 05:20 schreef olcott:

On 7/19/2025 9:12 PM, Richard Damon wrote:

On 7/19/25 5:18 PM, olcott wrote:

On 7/19/2025 4:00 PM, Alan Mackenzie wrote:

Mike Terry <news.dead.person.stones@darjeeling.plus.com> wrote: >>>>>>>>>>>>
[ .... ]

ps. learn to post more respectfully.

You've hit the nail on the head, there.  Peter Olcott >>>>>>>>>>>> doesn't show
respect here for anybody.  Because of this he isn't shown >>>>>>>>>>>> any respect
back - he hasn't earned any.  I don't think he understands >>>>>>>>>>>> the concept
of respect any more than he understands the concept of truth. >>>>>>>>>>>>
If he were to show repect, he'd repect knowledge, truth, and >>>>>>>>>>>> learning,
and strive to acquire these qualities.  Instead he displays >>>>>>>>>>>> contempt for
them.  This is a large part of what makes him a crank.  It is >>>>>>>>>>>> a large part of what makes it such a waste of time trying to >>>>>>>>>>>> correct
him, something that you've sensibly given up.

Now that chat bots have proven that they understand
what I am saying I can rephrase my words to be more
clear.

They have done no such thing, because they can't

Since yoiu feed them lies, all you have done is shown that you >>>>>>>>>> think lies are valid logic.

I have been rude because I cannot interpret the
rebuttal to this statement as anything besides
a despicable lie for the sole purpose of sadistic
pleasure of gaslighting:

Because you are just too stupid.

How is the "pattern" that HHH detects a non-halting pattern, >>>>>>>>>> when non- halting is DEFINED by the behavior of the directly >>>>>>>>>> executed machine, and the pattern you are thinking of exists >>>>>>>>>> in the execution of the DDD that halts because it was built on >>>>>>>>>> the same HHH you claim is correct to return 0,

Thus, your claim *IS* just a lie, and you shows your ignorance >>>>>>>>>> by saying you can't undetstand how it is one.

<input to chat bots>
typedef void (*ptr)();
int HHH(ptr P);

void DDD()
{
   HHH(DDD);
   return;
}

int main()
{
   HHH(DDD);
   DDD();
}

Termination Analyzer HHH simulates its input until
it detects a non-terminating behavior pattern. When
HHH detects such a pattern it aborts its simulation
and returns 0.
</input to chat bots>

Every chatbot figures out on its own that HHH
correctly rejects DDD as non-terminating because
the input to HHH(DDD) specifies recursive simulation.

BECAUSE YOU LIE TO THEM, and a prime training parameter is to >>>>>>>>>> give an answer the user is apt to like, and thus will tend to >>>>>>>>>> just accept lies and errors provided.

I only defined the hypothetical possibility of a simulating
termination analyzer. This cannot possibly be a lie. They
figured out all the rest on their own.

No you told it that a correct simulating termination analyser >>>>>>>> could be presumed. Which is an invalid presumption, because it >>>>>>>> has been proven that it cannot.

Unlike a halt decider that must be correct
on every input a simulating termination analyzer
only needs be correct on at least one input.

Nope, got a source for that definition.

Per you favorite sourse:
https://en.wikipedia.org/wiki/Termination_analysis

The difference between a Halt Decider and a Terminatation Analyzer >>>>>> is:


In computer science, termination analysis is program analysis
which attempts to determine whether the evaluation of a given
program halts for each input.

void Infinite_Loop()
{
   HERE: goto HERE;
   return;
}

Thus HHH(Infinite_Loop) is correct for every
input that Infinite_Loop has.

But the Termination Analyzer is HHH, not HHH(Infinite_Loop).

HHH correctly reports on the halt status
for every input that Infinite_Loop takes,

So?

all zero of them. This proves that HHH is
a termination analyzer for Infinite_Loop
even if HHH is wrong on everything else.

Nope, because a Termination Analyzer needs to answer about *ANY*
Program reperesented with an input.

*No that is merely your ADD*
determine whether the evaluation of a given program
halts for each input.

No, it is YOU who is altering it. I gave a reference, that points out
that it is the same as the halting problem, only about all possible
inputs, not just one given one.

WHere is the source of your fantasy?

It seems it is just your own ignorance, unless you can give a source for it.

Note, the term "given" means it is supplied one input per invocation,
not just needs to solve that one possible input.

You are just showing how poorly you think, and that you don't care about
being right, and that is how people will remember you, as you waste away
into oblivion.
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.ai.philosophy

On 7/21/2025 1:39 AM, Fred. Zwarts wrote:

Op 20.jul.2025 om 17:07 schreef olcott:

On 7/20/2025 2:44 AM, Fred. Zwarts wrote:

Op 19.jul.2025 om 23:18 schreef olcott:

On 7/19/2025 4:00 PM, Alan Mackenzie wrote:

Mike Terry <news.dead.person.stones@darjeeling.plus.com> wrote:

[ .... ]

ps. learn to post more respectfully.

You've hit the nail on the head, there.  Peter Olcott doesn't show
respect here for anybody.  Because of this he isn't shown any respect >>>>> back - he hasn't earned any.  I don't think he understands the concept >>>>> of respect any more than he understands the concept of truth.

If he were to show repect, he'd repect knowledge, truth, and learning, >>>>> and strive to acquire these qualities.  Instead he displays
contempt for
them.  This is a large part of what makes him a crank.  It is
a large part of what makes it such a waste of time trying to correct >>>>> him, something that you've sensibly given up.

Now that chat bots have proven that they understand
what I am saying I can rephrase my words to be more
clear.

Chat-boxes prove that reasoning with invalid presumptions lead to
invalid conclusions.

I have been rude because I cannot interpret the
rebuttal to this statement as anything besides
a despicable lie for the sole purpose of sadistic
pleasure of gaslighting:

<input to chat bots>
typedef void (*ptr)();
int HHH(ptr P);

void DDD()
{
   HHH(DDD);
   return;
}

int main()
{
   HHH(DDD);
   DDD();
}

Termination Analyzer HHH simulates its input until
it detects a non-terminating behavior pattern. When
HHH detects such a pattern it aborts its simulation
and returns 0.
</input to chat bots>

We see the invalid presumption in the input. There is no non-
termination behaviour in the input.

You can see that I did not even hint at non
termination of the input

??? We read that '... until it detects non-termination pattern' and
'When HHH detects such a pattern ...' before the '</input'
Since these presumptions are never happen, all conclusions based on it
are invalid as well.

I did not tell any bot that the input to HHH(DDD)
does not terminate and they all figured out on their
own that the input to HHH(DDD) does not terminate
because it specifies recursive emulation.
--
Copyright 2025 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.ai.philosophy

On 7/21/2025 6:17 AM, Richard Damon wrote:

On 7/20/25 10:05 PM, olcott wrote:

On 7/20/2025 8:58 PM, Richard Damon wrote:

On 7/20/25 8:45 PM, olcott wrote:

On 7/20/2025 7:29 PM, Richard Damon wrote:

On 7/20/25 7:54 PM, olcott wrote:

On 7/20/2025 6:13 PM, Richard Damon wrote:

On 7/20/25 10:08 AM, olcott wrote:

On 7/20/2025 2:38 AM, Fred. Zwarts wrote:

Op 20.jul.2025 om 05:20 schreef olcott:

On 7/19/2025 9:12 PM, Richard Damon wrote:

On 7/19/25 5:18 PM, olcott wrote:

On 7/19/2025 4:00 PM, Alan Mackenzie wrote:

Mike Terry <news.dead.person.stones@darjeeling.plus.com> >>>>>>>>>>>>> wrote:

[ .... ]

ps. learn to post more respectfully.

You've hit the nail on the head, there.  Peter Olcott >>>>>>>>>>>>> doesn't show
respect here for anybody.  Because of this he isn't shown >>>>>>>>>>>>> any respect
back - he hasn't earned any.  I don't think he understands >>>>>>>>>>>>> the concept
of respect any more than he understands the concept of truth. >>>>>>>>>>>>>
If he were to show repect, he'd repect knowledge, truth, >>>>>>>>>>>>> and learning,
and strive to acquire these qualities.  Instead he displays >>>>>>>>>>>>> contempt for
them.  This is a large part of what makes him a crank.  It is >>>>>>>>>>>>> a large part of what makes it such a waste of time trying >>>>>>>>>>>>> to correct
him, something that you've sensibly given up.

Now that chat bots have proven that they understand
what I am saying I can rephrase my words to be more
clear.

They have done no such thing, because they can't

Since yoiu feed them lies, all you have done is shown that >>>>>>>>>>> you think lies are valid logic.

I have been rude because I cannot interpret the
rebuttal to this statement as anything besides
a despicable lie for the sole purpose of sadistic
pleasure of gaslighting:

Because you are just too stupid.

How is the "pattern" that HHH detects a non-halting pattern, >>>>>>>>>>> when non- halting is DEFINED by the behavior of the directly >>>>>>>>>>> executed machine, and the pattern you are thinking of exists >>>>>>>>>>> in the execution of the DDD that halts because it was built >>>>>>>>>>> on the same HHH you claim is correct to return 0,

Thus, your claim *IS* just a lie, and you shows your
ignorance by saying you can't undetstand how it is one.

<input to chat bots>
typedef void (*ptr)();
int HHH(ptr P);

void DDD()
{
   HHH(DDD);
   return;
}

int main()
{
   HHH(DDD);
   DDD();
}

Termination Analyzer HHH simulates its input until
it detects a non-terminating behavior pattern. When
HHH detects such a pattern it aborts its simulation
and returns 0.
</input to chat bots>

Every chatbot figures out on its own that HHH
correctly rejects DDD as non-terminating because
the input to HHH(DDD) specifies recursive simulation.

BECAUSE YOU LIE TO THEM, and a prime training parameter is to >>>>>>>>>>> give an answer the user is apt to like, and thus will tend to >>>>>>>>>>> just accept lies and errors provided.

I only defined the hypothetical possibility of a simulating >>>>>>>>>> termination analyzer. This cannot possibly be a lie. They
figured out all the rest on their own.

No you told it that a correct simulating termination analyser >>>>>>>>> could be presumed. Which is an invalid presumption, because it >>>>>>>>> has been proven that it cannot.

Unlike a halt decider that must be correct
on every input a simulating termination analyzer
only needs be correct on at least one input.

Nope, got a source for that definition.

Per you favorite sourse:
https://en.wikipedia.org/wiki/Termination_analysis

The difference between a Halt Decider and a Terminatation
Analyzer is:


In computer science, termination analysis is program analysis
which attempts to determine whether the evaluation of a given
program halts for each input.

void Infinite_Loop()
{
   HERE: goto HERE;
   return;
}

Thus HHH(Infinite_Loop) is correct for every
input that Infinite_Loop has.

But the Termination Analyzer is HHH, not HHH(Infinite_Loop).

HHH correctly reports on the halt status
for every input that Infinite_Loop takes,

So?

all zero of them. This proves that HHH is
a termination analyzer for Infinite_Loop
even if HHH is wrong on everything else.

Nope, because a Termination Analyzer needs to answer about *ANY*
Program reperesented with an input.

*No that is merely your ADD*
determine whether the evaluation of a given program
halts for each input.

No, it is YOU who is altering it. I gave a reference, that points out
that it is the same as the halting problem, only about all possible
inputs, not just one given one.

*I quoted that from your above reference so it must be ADD*

On 7/20/2025 6:13 PM, Richard Damon wrote:

In computer science, termination analysis is program
analysis which attempts to
*determine whether the evaluation of a given program halts*
for each input. This means to determine whether the input program
computes a total function.

None of the people that are creating termination analyzers
have ever made one that works on all programs. They still
call their work termination analyzers.

WHere is the source of your fantasy?

It seems it is just your own ignorance, unless you can give a source for
it.

Note, the term "given" means it is supplied one input per invocation,
not just needs to solve that one possible input.

You are just showing how poorly you think, and that you don't care about being right, and that is how people will remember you, as you waste away into oblivion.

--
Copyright 2025 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.ai.philosophy

Op 21.jul.2025 om 15:03 schreef olcott:

On 7/21/2025 1:39 AM, Fred. Zwarts wrote:

Op 20.jul.2025 om 17:07 schreef olcott:

On 7/20/2025 2:44 AM, Fred. Zwarts wrote:

Op 19.jul.2025 om 23:18 schreef olcott:

On 7/19/2025 4:00 PM, Alan Mackenzie wrote:

Mike Terry <news.dead.person.stones@darjeeling.plus.com> wrote:

[ .... ]

ps. learn to post more respectfully.

You've hit the nail on the head, there.  Peter Olcott doesn't show >>>>>> respect here for anybody.  Because of this he isn't shown any respect >>>>>> back - he hasn't earned any.  I don't think he understands the
concept
of respect any more than he understands the concept of truth.

If he were to show repect, he'd repect knowledge, truth, and
learning,
and strive to acquire these qualities.  Instead he displays
contempt for
them.  This is a large part of what makes him a crank.  It is
a large part of what makes it such a waste of time trying to correct >>>>>> him, something that you've sensibly given up.

Now that chat bots have proven that they understand
what I am saying I can rephrase my words to be more
clear.

Chat-boxes prove that reasoning with invalid presumptions lead to
invalid conclusions.

I have been rude because I cannot interpret the
rebuttal to this statement as anything besides
a despicable lie for the sole purpose of sadistic
pleasure of gaslighting:

<input to chat bots>
typedef void (*ptr)();
int HHH(ptr P);

void DDD()
{
   HHH(DDD);
   return;
}

int main()
{
   HHH(DDD);
   DDD();
}

Termination Analyzer HHH simulates its input until
it detects a non-terminating behavior pattern. When
HHH detects such a pattern it aborts its simulation
and returns 0.
</input to chat bots>

We see the invalid presumption in the input. There is no non-
termination behaviour in the input.

You can see that I did not even hint at non
termination of the input

??? We read that '... until it detects non-termination pattern' and
'When HHH detects such a pattern ...' before the '</input'
Since these presumptions are never happen, all conclusions based on it
are invalid as well.

I did not tell any bot that the input to HHH(DDD)
does not terminate and they all figured out on their
own that the input to HHH(DDD) does not terminate
because it specifies recursive emulation.

You gave it contradictory information. You told it that it simulates
until it detects non-halting behaviour. You also told it that it aborts
and returns 0. HHH cannot at the same time return 0 and show
non-termination behaviour when simulated.

With invalid and contradictory starting points, any conclusion becomes useless.
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.ai.philosophy

On 7/21/25 9:03 AM, olcott wrote:

On 7/21/2025 1:39 AM, Fred. Zwarts wrote:

Op 20.jul.2025 om 17:07 schreef olcott:

On 7/20/2025 2:44 AM, Fred. Zwarts wrote:

Op 19.jul.2025 om 23:18 schreef olcott:

On 7/19/2025 4:00 PM, Alan Mackenzie wrote:

Mike Terry <news.dead.person.stones@darjeeling.plus.com> wrote:

[ .... ]

ps. learn to post more respectfully.

You've hit the nail on the head, there.  Peter Olcott doesn't show >>>>>> respect here for anybody.  Because of this he isn't shown any respect >>>>>> back - he hasn't earned any.  I don't think he understands the
concept
of respect any more than he understands the concept of truth.

If he were to show repect, he'd repect knowledge, truth, and
learning,
and strive to acquire these qualities.  Instead he displays
contempt for
them.  This is a large part of what makes him a crank.  It is
a large part of what makes it such a waste of time trying to correct >>>>>> him, something that you've sensibly given up.

Now that chat bots have proven that they understand
what I am saying I can rephrase my words to be more
clear.

Chat-boxes prove that reasoning with invalid presumptions lead to
invalid conclusions.

I have been rude because I cannot interpret the
rebuttal to this statement as anything besides
a despicable lie for the sole purpose of sadistic
pleasure of gaslighting:

<input to chat bots>
typedef void (*ptr)();
int HHH(ptr P);

void DDD()
{
   HHH(DDD);
   return;
}

int main()
{
   HHH(DDD);
   DDD();
}

Termination Analyzer HHH simulates its input until
it detects a non-terminating behavior pattern. When
HHH detects such a pattern it aborts its simulation
and returns 0.
</input to chat bots>

We see the invalid presumption in the input. There is no non-
termination behaviour in the input.

You can see that I did not even hint at non
termination of the input

??? We read that '... until it detects non-termination pattern' and
'When HHH detects such a pattern ...' before the '</input'
Since these presumptions are never happen, all conclusions based on it
are invalid as well.

I did not tell any bot that the input to HHH(DDD)
does not terminate and they all figured out on their
own that the input to HHH(DDD) does not terminate
because it specifies recursive emulation.

You told it that HHH detected a non-halting pattern in the input, by
using the word "when" which implies existance.

Sorry, you are just lying.
--- Synchronet 3.21a-Linux NewsLink 1.2