| Sysop: | Amessyroom |
|---|---|
| Location: | Fayetteville, NC |
| Users: | 23 |
| Nodes: | 6 (0 / 6) |
| Uptime: | 40:50:16 |
| Calls: | 583 |
| Calls today: | 1 |
| Files: | 1,138 |
| Messages: | 110,394 |
On 13/08/2025 07:05, olcott wrote:
On 8/13/2025 12:56 AM, Lawrence D'Oliveiro wrote:
Feel free to explain how it *is* self-evident.
typedef int (*ptr)();
int HHH(ptr P);
int DD()
{
-a-a int Halt_Status = HHH(DD);
-a-a if (Halt_Status)
-a-a-a-a HERE: goto HERE;
-a-a return Halt_Status;
}
I can directly see that that when HHH(DD) is executed
that this begins simulating DD that calls HHH(DD) that
begins simulating DD that calls HHH(DD) again.
...and when HHH eventually reports?
But of course that's self-evident.
What exactly is rCLself-evidentrCY supposed to mean? Please explain.
What exactly is rCLself-evidentrCY supposed to mean? Please explain.
On 2025-08-14 02:40, Lawrence D'Oliveiro wrote:
What exactly is rCLself-evidentrCY supposed to mean? Please explain.
It means that the message providing the answer contains, in itself, all
the evidence anyone needs to easily determine that the answer is true.
In practice, it is often used when the answer is not actually true.
Compare with a "no-brainer", where, in practice, the decision is almost always not the one that would be chosen if the brain were fully engaged.
On 8/14/2025 8:06 AM, James Kuyper wrote:
On 2025-08-14 02:40, Lawrence D'Oliveiro wrote:
What exactly is rCLself-evidentrCY supposed to mean? Please explain.
It means that the message providing the answer contains, in itself, all
the evidence anyone needs to easily determine that the answer is true.
In practice, it is often used when the answer is not actually true.
Compare with a "no-brainer", where, in practice, the decision is almost
always not the one that would be chosen if the brain were fully engaged.
<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()
{
-a int Halt_Status = HHH(DD);
-a if (Halt_Status)
-a-a-a HERE: goto HERE;
-a return Halt_Status;
}
What value should HHH(DD) correctly return?
<Input to LLM systems>
*The above was self-evident to three LLM systems*
I still find that it is absurd that no one here can
figure out something as simple as recursive simulation.
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*
on their own without prompting that such a pattern even exists.
-a-a The simulation shows DD calling HHH(DD) repeatedly
-a-a This creates an infinite recursive loop in the simulation
-a-a No simulated execution path leads to DD's return statement
-a-a being reached
-a-a https://claude.ai/share/da9e56ba-f4e9-45ee-9f2c-dc5ffe10f00c
-a-a In other words, simulating DD() requires simulating
-a-a HHH(DD), which requires simulating DD() againrCa recursive
-a-a simulation.
-a-a This creates an infinite regress rCo HHH cannot finish
-a-a simulating DD() because to simulate it, it must simulate
-a-a itself again, and again, and againrCa
-a-a https://chatgpt.com/share/68939ee5-e2f8-8011-837d-438fe8e98b9c
-a-a When HHH simulates DD, it must model DD's execution,
-a-a including the call to HHH(DD) within DD.
-a-a This introduces a recursive simulation: HHH simulating
-a-a DD involves simulating DD's call to HHH(DD), which
-a-a requires HHH to simulate DD again, and so on.
https://grok.com/share/c2hhcmQtMg%3D%3D_810120bb-5ab5-4bf8-af21- eedd0f09e141
Am 14.08.2025 um 16:17 schrieb olcott:
On 8/14/2025 8:06 AM, James Kuyper wrote:
On 2025-08-14 02:40, Lawrence D'Oliveiro wrote:
What exactly is rCLself-evidentrCY supposed to mean? Please explain.
It means that the message providing the answer contains, in itself, all
the evidence anyone needs to easily determine that the answer is true.
In practice, it is often used when the answer is not actually true.
Compare with a "no-brainer", where, in practice, the decision is almost
always not the one that would be chosen if the brain were fully engaged.
<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()
{
-a-a int Halt_Status = HHH(DD);
-a-a if (Halt_Status)
-a-a-a-a HERE: goto HERE;
-a-a return Halt_Status;
}
What value should HHH(DD) correctly return?
<Input to LLM systems>
*The above was self-evident to three LLM systems*
I still find that it is absurd that no one here can
figure out something as simple as recursive simulation.
Three different LLM systems figured out that the execution
trace of DD correctly simulated by HHH does ma
On 8/23/2025 9:41 AM, Richard Heathfield wrote:
On 23/08/2025 15:26, Bonita Montero wrote:
Am 23.08.2025 um 16:16 schrieb olcott:
The actual case is that you are too f-cking
stupid to find any mistake in my work.
I wonder why one has to pursue such a question so paranoidly
for years. I mean, it's nothing that has practical relevance.
I beg your pardon?
If he's right, the conventional proof of the undecidability of the
Halting Problem is flawed. You don't think that matters?
*Of course* it matters... IF he's right.
Thus providing evidence that Bonita Montero is a mere troll.
He /isn't/ right, but /he/ doesn't know that.
*This is a fact proven true on the basis of its meaning*
When 0 to reR instructions of DD are correctly
simulated by HHH this simulated DD never reaches
its own simulated "return" statement final halt state.
You still don't get it. How do you know you are not deluded merely by yourself?
Am 24.08.2025 um 04:41 schrieb wij:Indifference, suppression or spirit skill?
You still don't get it. How do you know you are not deluded merely by yourself?
Because I can quickly separate myself from vehement thoughts.