On 8/18/2025 7:25 PM, Richard Heathfield wrote:
On 19/08/2025 01:15, olcott wrote:
<snip>
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.
Disingenuous. My point, which you have left far behind when
hiking the above from its setting, is that you can use the
above fact to improve HHH() into doing a far better job --- so
much better, in fact, that to claim that what you currently
have as "correctly simulating" is very clearly not the case.
*What you finally admitted to has been my whole point all along*
On 8/18/2025 7:45 PM, Richard Heathfield wrote:
On 19/08/2025 01:36, olcott wrote:
On 8/18/2025 7:25 PM, Richard Heathfield wrote:
On 19/08/2025 01:15, olcott wrote:
<snip>
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.
;
Disingenuous. My point, which you have left far behind when
hiking the above from its setting, is that you can use the
above fact to improve HHH() into doing a far better job ---
so much better, in fact, that to claim that what you
currently have as "correctly simulating" is very clearly not
the case.
*What you finally admitted to has been my whole point all along*
The HHH(DD) = 0 thing? Is that why you're so cross with me? I
agreed to that a *long* long time ago. You can call it an
"admission" if you like - why should I care? - but you still
don't have a "correct simulation" of DD.
Because we all know that all non-terminating simulations
must be simulated until they terminate or they are not correct.
What you have is a reasonably truncated simulation of infinite
recursion. At no point do you simulate what happens /afterwards/.
*Yes I do not simulate anything that never happens*
When HHH aborts its simulation then every aspect
of every recursive simulation becomes 100% totally
dead.
There is no stack unwinding of any stack of
any dead process.
You have always maintained that /afterwards/ is impossible to
simulate. I have now shown you that it can be done after all.
*By failing to understand the notion of a dead process*
Heh we did finally make progress on my one key point.
That you think that a dead process has behavior
seems nuts.
On 8/18/2025 8:53 PM, Richard Heathfield wrote:
On 19/08/2025 02:32, olcott wrote:
<snip>
That you think that a dead process has behavior
seems nuts.
That you think it's dead seems nuts.
The process of HHH simulating DD is 100% totally
dead it is as if DD has been erased from memory.
On 8/18/2025 9:17 PM, Richard Heathfield wrote:
On 19/08/2025 03:02, olcott wrote:
On 8/18/2025 8:53 PM, Richard Heathfield wrote:
On 19/08/2025 02:32, olcott wrote:
<snip>
That you think that a dead process has behavior
seems nuts.
That you think it's dead seems nuts.
The process of HHH simulating DD is 100% totally
dead it is as if DD has been erased from memory.
Which invocation? How deep?
The only thing driving any recursive simulations
is the simulation of the outermost DD. When that
stops every simulation everywhere totally stops.
No simulated stack has any chance of ever unwinding.
On 8/18/2025 7:45 PM, Richard Heathfield wrote:
On 19/08/2025 01:36, olcott wrote:
On 8/18/2025 7:25 PM, Richard Heathfield wrote:
Because we all know that all non-terminating simulations must beDisingenuous. My point, which you have left far behind when hiking*What you finally admitted to has been my whole point all along*
the above from its setting, is that you can use the above fact to
improve HHH() into doing a far better job --- so much better, in
fact, that to claim that what you currently have as "correctly
simulating" is very clearly not the case.
The HHH(DD) = 0 thing? Is that why you're so cross with me? I agreed to
that a *long* long time ago. You can call it an "admission" if you like
- why should I care? - but you still don't have a "correct simulation"
of DD.
simulated until they terminate or they are not correct.
That doesn’t mean that that program would stop and not do something afterwards if executed or simulated further.What you have is a reasonably truncated simulation of infinite*Yes I do not simulate anything that never happens*
recursion. At no point do you simulate what happens /afterwards/.
When HHH aborts its simulation then every aspect of every recursive simulation becomes 100% totally dead. There is no stack unwinding of any stack of any dead process.
…, what happens?You have always maintained that /afterwards/ is impossible to simulate.*By failing to understand the notion of a dead process*
I have now shown you that it can be done after all.
Once HHH(DD) has aborted its simulation none of
the recursive simulations has any behavior.
On 8/19/2025 3:52 PM, Chris M. Thomasson wrote:
On 8/19/2025 7:34 AM, Richard Heathfield wrote:
On 19/08/2025 15:26, olcott wrote:
Once HHH(DD) has aborted its simulation none of
the recursive simulations has any behavior.
And that's your bug.
DD is a C function. It would be easy to put a direct call to it into
main and compile it into a program. Its behaviour then departs from
your simulation. Ergo, your simulation is incorrect.
Perhaps his simulator should just take C source code as input, compile
it and run/simulate it in a sandbox via an entry point, say main? In
this scenario, his system would require a compiler.
I was thinking of something like that.
All of the LLM systems can figure out on their
own that HHH(DD) would correctly return 0 for non-halting.
A static analysis of the source-code is what they are doing.
Op 19.aug.2025 om 23:55 schreef olcott:
On 8/19/2025 3:52 PM, Chris M. Thomasson wrote:
On 8/19/2025 7:34 AM, Richard Heathfield wrote:
On 19/08/2025 15:26, olcott wrote:
Once HHH(DD) has aborted its simulation none of
the recursive simulations has any behavior.
And that's your bug.
DD is a C function. It would be easy to put a direct call to
it into main and compile it into a program. Its behaviour
then departs from your simulation. Ergo, your simulation is
incorrect.
Perhaps his simulator should just take C source code as input,
compile it and run/simulate it in a sandbox via an entry
point, say main? In this scenario, his system would require a
compiler.
I was thinking of something like that.
All of the LLM systems can figure out on their
own that HHH(DD) would correctly return 0 for non-halting.
A static analysis of the source-code is what they are doing.
All LLM systems make this error, because you fed them incorrect
input. They are not smart enough to analyse the input and see the contradictions and errors in it.
On 8/19/2025 2:56 AM, joes wrote:
Am Mon, 18 Aug 2025 20:02:26 -0500 schrieb olcott:
On 8/18/2025 7:45 PM, Richard Heathfield wrote:
On 19/08/2025 01:36, olcott wrote:
On 8/18/2025 7:25 PM, Richard Heathfield wrote:
Because we all know that all non-terminating simulations must beDisingenuous. My point, which you have left far behind when hiking >>>>>> the above from its setting, is that you can use the above fact to*What you finally admitted to has been my whole point all along*
improve HHH() into doing a far better job --- so much better, in
fact, that to claim that what you currently have as "correctly
simulating" is very clearly not the case.
The HHH(DD) = 0 thing? Is that why you're so cross with me? I agreed to >>>> that a *long* long time ago. You can call it an "admission" if you like >>>> - why should I care? - but you still don't have a "correct simulation" >>>> of DD.
simulated until they terminate or they are not correct.
Yes! It’s not enough that no instructions are simulated *incorrectly*.
What you have is a reasonably truncated simulation of infinite*Yes I do not simulate anything that never happens*
recursion. At no point do you simulate what happens /afterwards/.
When HHH aborts its simulation then every aspect of every recursive
simulation becomes 100% totally dead. There is no stack unwinding of any >>> stack of any dead process.
That doesn’t mean that that program would stop and not do something
afterwards if executed or simulated further.
…, what happens?You have always maintained that /afterwards/ is impossible to simulate. >>>> I have now shown you that it can be done after all.*By failing to understand the notion of a dead process*
Once HHH(DD) has aborted its simulation none of
the recursive simulations has any behavior.
Mike explains this well.
W
On 8/19/2025 3:52 PM, Chris M. Thomasson wrote:
On 8/19/2025 7:34 AM, Richard Heathfield wrote:
On 19/08/2025 15:26, olcott wrote:
Once HHH(DD) has aborted its simulation none of
the recursive simulations has any behavior.
And that's your bug.
DD is a C function. It would be easy to put a direct call to it into
main and compile it into a program. Its behaviour then departs from
your simulation. Ergo, your simulation is incorrect.
Perhaps his simulator should just take C source code as input, compile
it and run/simulate it in a sandbox via an entry point, say main? In
this scenario, his system would require a compiler.
I was thinking of something like that.
All of the LLM systems can figure out on their
own that HHH(DD) would correctly return 0 for non-halting.
A static analysis of the source-code is what they are doing.
On 8/18/2025 6:22 PM, Richard Heathfield wrote:
[...]
Then you didn't abort the simulation, so your simulation is still
running, so you can't report, so you're not a decider. You lose.
Is his "simulation" akin to artificially killing a running process and
then deem said process 100% non-halting? We don't know for sure if it
would have halted some time down the road... Am I getting closer to understanding his system? Flip a coin gives better output...?
| Sysop: | Keyop |
|---|---|
| Location: | Huddersfield, West Yorkshire, UK |
| Users: | 546 |
| Nodes: | 16 (0 / 16) |
| Uptime: | 169:12:10 |
| Calls: | 10,385 |
| Calls today: | 2 |
| Files: | 14,057 |
| Messages: | 6,416,551 |