From Newsgroup: comp.lang.c

On 8/15/2025 6:20 AM, Fred. Zwarts wrote:

Op 14.aug.2025 om 19:35 schreef olcott:

On 8/14/2025 12:26 PM, Kaz Kylheku wrote:

On 2025-08-13, olcott <polcott333@gmail.com> wrote:

On 8/13/2025 12:39 PM, Kaz Kylheku wrote:

On 2025-08-13, olcott <polcott333@gmail.com> wrote:

Simulating Termination Analyzer HHH correctly simulates its input >>>>>> until:
(a) Detects a non-terminating behavior pattern: abort simulation and >>>>>> return 0.
(b) Simulated input reaches its simulated "return" statement:
return 1.

typedef int (*ptr)();
int HHH(ptr P);

int DD()
{
     int Halt_Status = HHH(DD);
     if (Halt_Status)
       HERE: goto HERE;
     return Halt_Status;
}

What value should HHH(DD) correctly return?

The thing is that the procedure DD /integrates/ the deciding
function HHH.

If we have not yet committed to a behavior and return value for
HHH(DD),
then it means we have not yet committed to the design of DD itself!

You have to commit to a definition of HHH.

I did in (a) and (b) above and three LLM systems were
able to figure out that the input to HHH(DD) does specify
the recursive simulation non-halting behavior pattern
on their own without prompting.

If you then make a different definition, that is a new version of HHH. >>>>>
You have to separate these; you can't refer to all of them as HHH.

As you try different ways of creating the halting decider, you
have have HHH1, HHH2, HHH3.

The author of DD studies each of these and replicates its logic,
embedding it into DD.

This activity gives rise to DD1, DD2, DD3, ...

DD1 proves that HH1 is not a universal halting decider.
DD2 proves that HH2 is not a universal halting decider.
DD3 proves that HH3 is not a universal halting decider.

And so on. For every halting decider design that you finalize and
commit
to, a test case is easily produced which shows that it does not decide >>>>> the halting of all computations.

That creates a simple and convincing inductive argument that there
doesn't exist a univeral halting decider.

When HHH(DD) is executed that this begins simulating
DD that calls HHH(DD) that begins simulating DD that
calls HHH(DD) again.

OK and so if, in that recursive tower of HHH invocations, if one of the
HHH suddenly behaves differently and breaks the pattern, that HHH is not >>> the same as the previous HHH.

That HHH and the previous HHH have the same external name in your UTM
system, but that doesn't make them the same.

We can only be sure that two procedures in a language like C are
functions if their only inputs are are their arguments and compile time
constants, and if none of their inputs ever mutate in between or during
invocations.

I.e. f(x) is not a function invocation if x is a pointer
to something that is changing, so that two calls f(x); f(x)
do not actually operate on the same input.

Turing machines are pure functions in that they depend only on their
tape. The tape processing mechanism is destructive, but nothing external >>> meddles with the tape, each machine has its own tape not shared with
any other machines, and the tape is reset to its original content for
each simulation of the machine.

Invocations of prodcedures that are not pure functions are not
Turing computations. (I.e. are not instance of the material that the
Halting Theorem is about.)

Three different LLM systems figured out that the execution
trace of DD correctly simulated by HHH does match the
*recursive simulation non-halting behavior pattern*

We all agree that there is a recursive non-halting behavior pattern.

*By "we all" you are only actually including yourself and myself*
Everyone else here has consistently denied or dodged that point
for the last three years. That is why I needed to pull in some
experts in C.

If you can read, you will see that Kaz refers here to the HHH that does
not abort.

COUNTER-FACTUAL

THIS IS THE CONTEXT

int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}

Simulating Termination Analyzer HHH correctly simulates its input until:
(a) *Detects a non-terminating behavior pattern*:
abort simulation and return 0.
(b) Simulated input reaches its simulated "return" statement: return 1.

On 8/14/2025 12:26 PM, Kaz Kylheku wrote:

On 2025-08-13, olcott <polcott333@gmail.com> wrote:
*We all agree that there is a recursive non-halting behavior pattern*

This creates an infinite regress — HHH cannot finish
simulating DD() because to simulate it, it must simulate
itself again, and again, and again…

Since DD calls HHH, if HHH doesn't finish, DD is non-terminating.
That's the correct answer. HHH not terminating means it doesn't
calculate the correct answer.

*It's possible for HHH to terminate and return an answer to DD*

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