Subject: Re: Correct simulation of DDD by HHH is proven --- Heathfield FINALLY
admits the truth

*Context for what Richard Heathfield agreed to*

<Input to LLM systems>
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?
<Input to LLM systems>

On 8/18/2025 6:05 PM, Richard Heathfield wrote:>

It is an easily verified fact, as you love to say, that if DD calls HHH
(as it does) and HHH calls DD (as, through simulation, it effectively
does) that HHH(DD) can never halt naturally, so it will have to abort
the recursion and report its result as 0 - didn't halt.

Here are three of the five LLM systems that figured
out this same reasoning on their own.

https://claude.ai/share/da9e56ba-f4e9-45ee-9f2c-dc5ffe10f00c

https://chatgpt.com/share/68939ee5-e2f8-8011-837d-438fe8e98b9c

https://grok.com/share/c2hhcmQtMg%3D%3D_810120bb-5ab5-4bf8-af21-eedd0f09e141


ChatGPT 5.0 and Gemini both had to be told DO NOT GUESS.
They are not included in the above three. Systems that
guess by default are inferior.

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

--- MBSE BBS v1.1.2 (Linux-x86_64)
* Origin: A noiseless patient Spider (3:633/280.2@fidonet)

Subject: Re: Correct simulation of DDD by HHH is proven --- Heathfield FINALLY
admits the truth

On 8/18/2025 9:16 PM, Richard Heathfield wrote:

On 19/08/2025 03:00, olcott wrote:

*Context for what Richard Heathfield agreed to*

Close but no banana.

<Input to LLM systems>
Simulating Termination Analyzer HHH correctly simulates its input

I certainly didn't agree to that.

until:
(a) Detects a non-terminating behavior pattern:
abort simulation and return 0.

I am prepared to accept that this is how you cope with runaway
recursion, yes.

(b) Simulated input reaches its simulated "return" statement:
return 1.

This doesn't happen as far as I'm aware.

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

int DD()
{
�� int Halt_Status = HHH(DD);

You know that'll be 0, so memoise it:

����� Halt_Status = 0;

�� if (Halt_Status)

if(0)... so no...

���� HERE: goto HERE;

After skipping that, we get to:

�� return Halt_Status;

return 0;

}

What value should HHH(DD) correctly return?

You've already said that it correctly returns 0 - which correctly
describes HHH's action (aborted and concluded non-halting).

*Hence perfect agreement as shown more clearly here*

On 8/18/2025 6:05 PM, Richard Heathfield wrote:

It is an easily verified fact, as you love to say,
that if DD calls HHH (as it does) and HHH calls DD
(as, through simulation, it effectively does) that
HHH(DD) can never halt naturally, so it will have
to abort the recursion and report its result as 0
- didn't halt.

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

--- MBSE BBS v1.1.2 (Linux-x86_64)
* Origin: A noiseless patient Spider (3:633/280.2@fidonet)

Subject: Re: Correct simulation of DDD by HHH is proven --- Heathfield FINALLY
admits the truth (Yeah)

On 8/18/2025 9:40 PM, Richard Heathfield wrote:

On 19/08/2025 03:07, dbush wrote:

<snip>

So we see that Richard Heathfield agreed that HHH can't give a correct
answer, as Linz and other have proved and as you have *explicitly*
agreed is correct.

I look at it this way.

HHH cannot reasonably abort as soon as it detects recursion. After all, there are lots of recursive algorithms around, and plenty of them
terminate. It has to dig a little deeper than that.

So by the time we're some way in, we have several levels of recursion:

DD -> HHH -> DD -> HHH -> DD -> HHH -> DD
����� (a)��������� (b)��������� (c)

Let's say (c) decides enough is enough.

So (c) stops *its* simulation of DD. THIS HAS NO IMPACT ON (a) AND (b).

(c) now returns 0 to (b)'s DD.

(b) regains control, accepts 0 from (c), assigns 0 to Halt_Status, and returns 0 to (a).

(a) regains control, accepts 0 from (b), assigns 0 to Halt_Status, and returns 0 to the original DD.

If the original DD has a caller, it gets a 0, incorrectly indicating non-halting.

Looking at it this way, I no longer see the need for memoisation. All
that is necessary is for HHH *only* to abort the simulation it's
hosting, *not* the simulation that invoked it.

There's your bug, Mr Olcott.

It is your failing to understand that HHH does not
have enough evidence to abort (a) until after it has
done more recursive simulations and then it aborts
(a) killing them all.

We have hit the key juncture where you have finally
proven that you can work within an honest dialogue.
THAT IS GREAT !!!

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

--- MBSE BBS v1.1.2 (Linux-x86_64)
* Origin: A noiseless patient Spider (3:633/280.2@fidonet)