Re: DD specifies non-terminating behavior to HHH --- ONE POINT AT A TIME !!!

On 2025-02-20 17:42:49 +0000, Mr Flibble said:

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:

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:

 

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
trying to get away with changing the subject to some
other DD
somewhere else

such as one that calls a non-aborting version of HHH
 

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.

(There are other deciders that are not termination
analysers.)
 

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.

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?
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.
 

A very strange and invalid stipulation.

 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);
}
 

It is not true that this point has never been addressed. Olcott
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?

It is not an attack. It is an informative comment, formally to the author
of the previous message but actually to all readers. Whether it works
depends on each reader, and so does whether it needs to work.
--
Mikko