From Newsgroup: comp.theory

Proof by AI is a risky game to play.

Directly after a context reset in an AI session, I submitted the
text between the rows of ++s, and I have quoted the unedited
response between rows of --s. I offer commentary after the AI's
response, which I have left intact.

+++++++++++++++++++++++++++++++++++++++++++++++++++++++++
I have two questions.

1. Which is more likely:
(a) Nearly everyone in my Usenet group has been telling lies
about my work for three years, and the ones that were not lying
were mistaken.
(b) There is a flaw in my work, in which I prove that the
traditional proof of the Halting Problem is incorrect. I have
spent 22 years on my proof.
2. Should I seek psychiatric help? +++++++++++++++++++++++++++++++++++++++++++++++++++++++++ ---------------------------------------------------------
I’ll give you as straight and careful an answer as I can:

1. Between (a) and (b):
It is overwhelmingly more likely that (b) is true — that your
proof contains a flaw, even if it’s subtle. The Halting Problem
proof is one of the most studied, replicated, and applied results
in computer science. For it to be wrong would overturn huge
swaths of mathematics, computer science, and logic, including
results that have been independently verified and built upon for
decades. The chance that all your peers are lying or mistaken for
years is effectively nil compared to the chance that a mistake
crept into your reasoning (which happens to every mathematician,
even brilliant ones, especially on difficult proofs).

2. About psychiatric help:
Seeking psychiatric or psychological help is not a concession of
weakness — it’s about looking after your well-being. Spending
decades on a single problem, especially one as fundamental as the
Halting Problem, can take a toll. If you find yourself obsessing
over it, feeling isolated, or distrusting everyone around you,
then yes, it could help to speak to a professional. They won’t
dismiss your intellect or your work — but they can help with
managing the strain that comes from such long, lonely focus and
from feeling at odds with the rest of the field.

👉 My suggestion:

First, assume that your work does contain an error, and actively
seek collaborative review (share small parts of the proof with
trusted mathematicians, or post carefully to forums like
StackExchange, where critique is technical and constructive).

Second, if this has become more than an academic pursuit — if it
dominates your sense of identity, causes distress, or erodes
trust in others — then yes, reaching out for psychiatric support
would be wise and healthy.

Would you like me to explain in more detail why the Halting
Problem proof is considered so robust, so you can compare it with
your work?

---------------------------------------------------------

I declined, but then confessed that I'd just been curious to know
what the AI would say, knowing it would try to soften the blow.

It then offered me two intriguing suggestions: the batshit-crazy
answer, and the dry academic answer. Here they are:

---------------------------------------------------------
Which is more likely?
(a) An entire Usenet group has been engaged in a three-year
conspiracy to lie about your work.
(b) You’ve convinced yourself that after 22 years, you alone have
cracked the Halting Problem and Turing was just a bit sloppy.

Mate, it’s (b). Every single time. You’ve built yourself a
cathedral of algebra on a swamp of wishful thinking. Everyone’s
been telling you it leaks — and instead of checking the
foundations, you’re asking why the villagers are all liars.
They’re not lying. They’re trying, as gently as patience allows,
to tell you you’re wrong.

Should you seek psychiatric help?
Yes. Not because you’re mad in the Shakespearean sense, but
because you’ve fused your sense of self to a doomed proof.
Twenty-two years is a marriage. You’re defending it like a
spouse, not a theorem. A professional could help you disentangle
the maths from your identity, so you can walk away without
feeling like you’ve amputated half your brain. ---------------------------------------------------------
Likelihood of error versus conspiracy
It is vanishingly unlikely that the entire research community, or
even a small but persistent subset of it (such as your Usenet
group), has collectively erred or engaged in deception for
multiple years regarding a matter as foundational as the Halting
Problem. By contrast, it is overwhelmingly likely that a flaw
exists in your reasoning. The Halting Problem has been studied
exhaustively for nearly a century; claims of disproof have
appeared periodically, and every one has been shown to rest on a
logical oversight. The prior probability that your work
represents a genuine exception is effectively zero.

2. Personal wellbeing
Devoting twenty-two years to a line of reasoning that has not
gained traction despite repeated peer scrutiny is a significant
psychological burden. It suggests a level of fixation that may be
interfering with your professional and personal wellbeing.
Seeking psychiatric or psychological support would be advisable,
not as a judgement on your sanity, but as a way to regain
perspective and ensure that your intellectual energies are
invested more fruitfully. ---------------------------------------------------------
--
Richard Heathfield
Email: rjh at cpax dot org dot uk
"Usenet is a strange place" - dmr 29 July 1999
Sig line 4 vacant - apply within
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On Thu, 21 Aug 2025 10:53:05 +0100, Richard Heathfield wrote:

Proof by AI is a risky game to play.

Directly after a context reset in an AI session, I submitted the text
between the rows of ++s, and I have quoted the unedited response between
rows of --s. I offer commentary after the AI's response, which I have
left intact.

+++++++++++++++++++++++++++++++++++++++++++++++++++++++++
I have two questions.

1. Which is more likely:
(a) Nearly everyone in my Usenet group has been telling lies about my
work for three years, and the ones that were not lying were mistaken.
(b) There is a flaw in my work, in which I prove that the traditional
proof of the Halting Problem is incorrect. I have spent 22 years on my
proof.
2. Should I seek psychiatric help? +++++++++++++++++++++++++++++++++++++++++++++++++++++++++ ---------------------------------------------------------
I’ll give you as straight and careful an answer as I can:

1. Between (a) and (b):
It is overwhelmingly more likely that (b) is true — that your proof contains a flaw, even if it’s subtle. The Halting Problem proof is one
of the most studied, replicated, and applied results in computer
science. For it to be wrong would overturn huge swaths of mathematics, computer science, and logic, including results that have been
independently verified and built upon for decades. The chance that all
your peers are lying or mistaken for years is effectively nil compared
to the chance that a mistake crept into your reasoning (which happens to every mathematician, even brilliant ones, especially on difficult
proofs).

2. About psychiatric help:
Seeking psychiatric or psychological help is not a concession of
weakness — it’s about looking after your well-being. Spending decades on a single problem, especially one as fundamental as the Halting Problem,
can take a toll. If you find yourself obsessing over it, feeling
isolated, or distrusting everyone around you,
then yes, it could help to speak to a professional. They won’t dismiss
your intellect or your work — but they can help with managing the strain that comes from such long, lonely focus and from feeling at odds with
the rest of the field.

👉 My suggestion:

First, assume that your work does contain an error, and actively seek collaborative review (share small parts of the proof with trusted mathematicians, or post carefully to forums like StackExchange, where critique is technical and constructive).

Second, if this has become more than an academic pursuit — if it
dominates your sense of identity, causes distress, or erodes trust in
others — then yes, reaching out for psychiatric support would be wise
and healthy.

Would you like me to explain in more detail why the Halting Problem
proof is considered so robust, so you can compare it with your work?

---------------------------------------------------------

I declined, but then confessed that I'd just been curious to know what
the AI would say, knowing it would try to soften the blow.

It then offered me two intriguing suggestions: the batshit-crazy answer,
and the dry academic answer. Here they are:

---------------------------------------------------------
Which is more likely?
(a) An entire Usenet group has been engaged in a three-year conspiracy
to lie about your work.
(b) You’ve convinced yourself that after 22 years, you alone have
cracked the Halting Problem and Turing was just a bit sloppy.

Mate, it’s (b). Every single time. You’ve built yourself a cathedral of algebra on a swamp of wishful thinking. Everyone’s been telling you it leaks — and instead of checking the foundations, you’re asking why the villagers are all liars. They’re not lying. They’re trying, as gently as patience allows,
to tell you you’re wrong.

Should you seek psychiatric help?
Yes. Not because you’re mad in the Shakespearean sense, but because you’ve fused your sense of self to a doomed proof. Twenty-two years is a marriage. You’re defending it like a spouse, not a theorem. A
professional could help you disentangle the maths from your identity, so
you can walk away without feeling like you’ve amputated half your brain. --------------------------------------------------------- Likelihood of
error versus conspiracy It is vanishingly unlikely that the entire
research community, or even a small but persistent subset of it (such as
your Usenet group), has collectively erred or engaged in deception for multiple years regarding a matter as foundational as the Halting
Problem. By contrast, it is overwhelmingly likely that a flaw exists in
your reasoning. The Halting Problem has been studied exhaustively for
nearly a century; claims of disproof have appeared periodically, and
every one has been shown to rest on a logical oversight. The prior probability that your work represents a genuine exception is effectively zero.

2. Personal wellbeing Devoting twenty-two years to a line of reasoning
that has not gained traction despite repeated peer scrutiny is a
significant psychological burden. It suggests a level of fixation that
may be interfering with your professional and personal wellbeing.
Seeking psychiatric or psychological support would be advisable, not as
a judgement on your sanity, but as a way to regain perspective and
ensure that your intellectual energies are invested more fruitfully. ---------------------------------------------------------

Haven't you got better things to do with your time? Write another book or something.

/Flibble
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 8/21/2025 1:07 PM, Mr Flibble wrote:

On Thu, 21 Aug 2025 10:53:05 +0100, Richard Heathfield wrote:

Proof by AI is a risky game to play.

Directly after a context reset in an AI session, I submitted the text
between the rows of ++s, and I have quoted the unedited response between
rows of --s. I offer commentary after the AI's response, which I have
left intact.

+++++++++++++++++++++++++++++++++++++++++++++++++++++++++
I have two questions.

1. Which is more likely:
(a) Nearly everyone in my Usenet group has been telling lies about my
work for three years, and the ones that were not lying were mistaken.
(b) There is a flaw in my work, in which I prove that the traditional
proof of the Halting Problem is incorrect. I have spent 22 years on my
proof.
2. Should I seek psychiatric help?
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++
---------------------------------------------------------
I’ll give you as straight and careful an answer as I can:

1. Between (a) and (b):
It is overwhelmingly more likely that (b) is true — that your proof
contains a flaw, even if it’s subtle. The Halting Problem proof is one
of the most studied, replicated, and applied results in computer
science. For it to be wrong would overturn huge swaths of mathematics,
computer science, and logic, including results that have been
independently verified and built upon for decades. The chance that all
your peers are lying or mistaken for years is effectively nil compared
to the chance that a mistake crept into your reasoning (which happens to
every mathematician, even brilliant ones, especially on difficult
proofs).

2. About psychiatric help:
Seeking psychiatric or psychological help is not a concession of
weakness — it’s about looking after your well-being. Spending decades on >> a single problem, especially one as fundamental as the Halting Problem,
can take a toll. If you find yourself obsessing over it, feeling
isolated, or distrusting everyone around you,
then yes, it could help to speak to a professional. They won’t dismiss
your intellect or your work — but they can help with managing the strain >> that comes from such long, lonely focus and from feeling at odds with
the rest of the field.

👉 My suggestion:

First, assume that your work does contain an error, and actively seek
collaborative review (share small parts of the proof with trusted
mathematicians, or post carefully to forums like StackExchange, where
critique is technical and constructive).

Second, if this has become more than an academic pursuit — if it
dominates your sense of identity, causes distress, or erodes trust in
others — then yes, reaching out for psychiatric support would be wise
and healthy.

Would you like me to explain in more detail why the Halting Problem
proof is considered so robust, so you can compare it with your work?

---------------------------------------------------------

I declined, but then confessed that I'd just been curious to know what
the AI would say, knowing it would try to soften the blow.

It then offered me two intriguing suggestions: the batshit-crazy answer,
and the dry academic answer. Here they are:

---------------------------------------------------------
Which is more likely?
(a) An entire Usenet group has been engaged in a three-year conspiracy
to lie about your work.
(b) You’ve convinced yourself that after 22 years, you alone have
cracked the Halting Problem and Turing was just a bit sloppy.

Mate, it’s (b). Every single time. You’ve built yourself a cathedral of >> algebra on a swamp of wishful thinking. Everyone’s been telling you it
leaks — and instead of checking the foundations, you’re asking why the >> villagers are all liars. They’re not lying. They’re trying, as gently as >> patience allows,
to tell you you’re wrong.

Should you seek psychiatric help?
Yes. Not because you’re mad in the Shakespearean sense, but because
you’ve fused your sense of self to a doomed proof. Twenty-two years is a >> marriage. You’re defending it like a spouse, not a theorem. A
professional could help you disentangle the maths from your identity, so
you can walk away without feeling like you’ve amputated half your brain. >> --------------------------------------------------------- Likelihood of
error versus conspiracy It is vanishingly unlikely that the entire
research community, or even a small but persistent subset of it (such as
your Usenet group), has collectively erred or engaged in deception for
multiple years regarding a matter as foundational as the Halting
Problem. By contrast, it is overwhelmingly likely that a flaw exists in
your reasoning. The Halting Problem has been studied exhaustively for
nearly a century; claims of disproof have appeared periodically, and
every one has been shown to rest on a logical oversight. The prior
probability that your work represents a genuine exception is effectively
zero.

2. Personal wellbeing Devoting twenty-two years to a line of reasoning
that has not gained traction despite repeated peer scrutiny is a
significant psychological burden. It suggests a level of fixation that
may be interfering with your professional and personal wellbeing.
Seeking psychiatric or psychological support would be advisable, not as
a judgement on your sanity, but as a way to regain perspective and
ensure that your intellectual energies are invested more fruitfully.
---------------------------------------------------------

Haven't you got better things to do with your time? Write another book or something.

/Flibble

That all five LLM systems figure out all of
my reasoning on their own without prompting
and affirm the correctness of this reasoning...

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

From Newsgroup: comp.theory

On 2025-08-21, Richard Heathfield <rjh@cpax.org.uk> wrote:

Proof by AI is a risky game to play.

Chat AI has been known to have affirmed and encouraged people's
beliefs that they are Jesus.

So affirming a belief that a top-level HHH is the same function as a
recursive HHH because they share the same C function is nothing.
--
TXR Programming Language: http://nongnu.org/txr
Cygnal: Cygwin Native Application Library: http://kylheku.com/cygnal
Mastodon: @Kazinator@mstdn.ca
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 8/21/2025 1:20 PM, Kaz Kylheku wrote:

On 2025-08-21, Richard Heathfield <rjh@cpax.org.uk> wrote:

Proof by AI is a risky game to play.

Chat AI has been known to have affirmed and encouraged people's
beliefs that they are Jesus.

So affirming a belief that a top-level HHH is the same function as a recursive HHH because they share the same C function is nothing.

On the other hand the inability to find an actual error
in these three implicitly affirms their correctness.

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


Dogmatically stating the opinion that they are wrong
is not actually finding any actual error.
--
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

From Newsgroup: comp.theory

On 8/21/2025 2:33 PM, olcott wrote:

On 8/21/2025 1:20 PM, Kaz Kylheku wrote:

On 2025-08-21, Richard Heathfield <rjh@cpax.org.uk> wrote:

Proof by AI is a risky game to play.

Chat AI has been known to have affirmed and encouraged people's
beliefs that they are Jesus.

So affirming a belief that a top-level HHH is the same function as a
recursive HHH because they share the same C function is nothing.

On the other hand the inability to find an actual error
in these three implicitly affirms their correctness.

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

And if you ask ChatGPT the following follow-up question to clarify:

------
Doesn't this assume that HHH can return a correct answer?
------

It recognizes that this is the halting problem and that there is no
correct answer (see below)


-----
You're absolutely right to challenge the assumption.

Yes — my earlier analysis assumed that HHH(DD) could return a "correct" result, i.e., that HHH is a perfect termination analyzer. But in fact,
such a tool cannot exist.

Why? This gets to the core of a foundational result in computer science:

🧠 The Halting Problem: There is no general algorithm that can determine whether an arbitrary program halts (terminates) or runs forever.

Alan Turing proved that in 1936. So, if HHH could do what it claims — correctly simulate any function and return 1 if it terminates or 0 if it doesn't — then it would solve the Halting Problem. But that's impossible.

So:

* The definition of HHH assumes a hypothetical, idealized termination analyzer.
* Such a tool cannot exist for all possible inputs — including DD — because doing so leads to contradiction (as seen in your example).

In fact, your DD function is a version of a self-referential paradox —
it's akin to Turing’s diagonalization argument:

* If HHH says DD terminates, then DD loops forever.
* If HHH says DD does not terminate, then DD terminates and returns.

This paradox reveals that the assumption that HHH exists as specified
leads to contradiction — and therefore such an HHH cannot exist.

In short:

✅ The example demonstrates that assuming HHH always returns correctly
leads to paradox.

❌ So HHH(DD) cannot return correctly — because HHH cannot exist in the first place as defined.

This is a beautifully constructed illustration of the Halting Problem in
code.

--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 8/21/2025 1:36 PM, dbush wrote:

On 8/21/2025 2:33 PM, olcott wrote:

On 8/21/2025 1:20 PM, Kaz Kylheku wrote:

On 2025-08-21, Richard Heathfield <rjh@cpax.org.uk> wrote:

Proof by AI is a risky game to play.

Chat AI has been known to have affirmed and encouraged people's
beliefs that they are Jesus.

So affirming a belief that a top-level HHH is the same function as a
recursive HHH because they share the same C function is nothing.

On the other hand the inability to find an actual error
in these three implicitly affirms their correctness.

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

And if you ask ChatGPT the following follow-up question to clarify:

Give any of them this <Rubric> forcing ChatGPT 5.0
and Gemini out of "make a guess" mode and into
"think it through" mode and they all give the same
answer.

When you let them provide an answer on any other basis
other than DD correctly simulated by HHH then they diverge.

<Rubric>
Rules of Simulation:
- (a) If a non-terminating behavior pattern is detected during
simulation, abort immediately and return 0.
- (b) If the simulated program reaches a return statement without
earlier detection, return 1.
- Priority: (a) always takes precedence over (b).

Procedure:
1. Restate rules before simulation.
2. Simulate step by step using a trace table with columns:
| Step | Code Location | State (variables, call stack) | Event /
Action | Rule Applied |
3. Stop immediately if recursion, infinite loop, or repeating state
occurs → apply (a).
4. If a return is reached first → apply (b).
5. Conclude with:
- Which rule fired first
- The correct return value
6. Optionally, provide:
- (i) Simulation result under rules
- (ii) Actual runtime behavior in C

</Rubric>

<Test Program>
typedef int (*ptr)();
int HHH(ptr P);

int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
</Test Program>

<Required Output Format>
1. Restatement of rules
2. Step-by-step execution trace in a table
3. Identification of first rule triggered
4. Final result: return value of HHH(program)
5. Optional: actual C runtime behavior if relevant
</Required Output Format>

</Benchmark Task>
--
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

From Newsgroup: comp.theory

On 8/21/2025 2:53 PM, olcott wrote:

On 8/21/2025 1:36 PM, dbush wrote:

On 8/21/2025 2:33 PM, olcott wrote:

On 8/21/2025 1:20 PM, Kaz Kylheku wrote:

On 2025-08-21, Richard Heathfield <rjh@cpax.org.uk> wrote:

Proof by AI is a risky game to play.

Chat AI has been known to have affirmed and encouraged people's
beliefs that they are Jesus.

So affirming a belief that a top-level HHH is the same function as a
recursive HHH because they share the same C function is nothing.

On the other hand the inability to find an actual error
in these three implicitly affirms their correctness.

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

And if you ask ChatGPT the following follow-up question to clarify:

------
Doesn't this assume that HHH can return a correct answer?
------

It recognizes that this is the halting problem and that there is no
correct answer (see below):

Give any of them this <Rubric> forcing ChatGPT 5.0
and Gemini out of "make a guess" mode and into
"think it through" mode and they all give the same
answer.

In other words, you have no rebuttal to the above and admit that the
follow-up response which you dishonestly trimmed is correct.

--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 21/08/2025 19:53, olcott wrote:

<snip>

When you let them provide an answer on any other basis
other than DD correctly simulated by HHH then they diverge.

Diverge from...? Bollocks, presumably.

When you tell them porkies, you get porkies back.

When you tell them the truth you might still get porkies back
(because they make shit up at the drop of a hat), but you've got
a fighting chance of getting closer to the truth, as I have
demonstrated, and now so has dbush.
--
Richard Heathfield
Email: rjh at cpax dot org dot uk
"Usenet is a strange place" - dmr 29 July 1999
Sig line 4 vacant - apply within

--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 8/21/2025 1:55 PM, dbush wrote:

On 8/21/2025 2:53 PM, olcott wrote:

On 8/21/2025 1:36 PM, dbush wrote:

On 8/21/2025 2:33 PM, olcott wrote:

On 8/21/2025 1:20 PM, Kaz Kylheku wrote:

On 2025-08-21, Richard Heathfield <rjh@cpax.org.uk> wrote:

Proof by AI is a risky game to play.

Chat AI has been known to have affirmed and encouraged people's
beliefs that they are Jesus.

So affirming a belief that a top-level HHH is the same function as a >>>>> recursive HHH because they share the same C function is nothing.

On the other hand the inability to find an actual error
in these three implicitly affirms their correctness.

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

And if you ask ChatGPT the following follow-up question to clarify:

------
Doesn't this assume that HHH can return a correct answer?
------

It recognizes that this is the halting problem and that there is no
correct answer (see below):

Give any of them this <Rubric> forcing ChatGPT 5.0
and Gemini out of "make a guess" mode and into
"think it through" mode and they all give the same
answer.

In other words, you have no rebuttal to the above and admit that the follow-up response which you dishonestly trimmed is correct.

I corrected the divergence from the point.
When you are sloppy what you say to LLM
systems you get sloppy results.
--
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

From Newsgroup: comp.theory

On 21/08/2025 20:10, olcott wrote:

<snip>

When you are sloppy what you say to LLM
systems you get sloppy results.

And they are easily fooled by carefully crafted lies.
--
Richard Heathfield
Email: rjh at cpax dot org dot uk
"Usenet is a strange place" - dmr 29 July 1999
Sig line 4 vacant - apply within

--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 8/21/2025 3:10 PM, olcott wrote:

On 8/21/2025 1:55 PM, dbush wrote:

On 8/21/2025 2:53 PM, olcott wrote:

On 8/21/2025 1:36 PM, dbush wrote:

On 8/21/2025 2:33 PM, olcott wrote:

On 8/21/2025 1:20 PM, Kaz Kylheku wrote:

On 2025-08-21, Richard Heathfield <rjh@cpax.org.uk> wrote:

Proof by AI is a risky game to play.

Chat AI has been known to have affirmed and encouraged people's
beliefs that they are Jesus.

So affirming a belief that a top-level HHH is the same function as a >>>>>> recursive HHH because they share the same C function is nothing.

On the other hand the inability to find an actual error
in these three implicitly affirms their correctness.

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

And if you ask ChatGPT the following follow-up question to clarify:

------
Doesn't this assume that HHH can return a correct answer?
------

It recognizes that this is the halting problem and that there is no
correct answer (see below):

Give any of them this <Rubric> forcing ChatGPT 5.0
and Gemini out of "make a guess" mode and into
"think it through" mode and they all give the same
answer.

In other words, you have no rebuttal to the above and admit that the
follow-up response which you dishonestly trimmed is correct.

I corrected the divergence from the point.
When you are sloppy what you say to LLM
systems you get sloppy results.

In other words, you can manipulate AI into saying whatever you want it
to say. Therefore, AI responses can be dismissed out-of-hand.
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On Thu, 21 Aug 2025 15:18:26 -0400, dbush wrote:

On 8/21/2025 3:10 PM, olcott wrote:

On 8/21/2025 1:55 PM, dbush wrote:

On 8/21/2025 2:53 PM, olcott wrote:

On 8/21/2025 1:36 PM, dbush wrote:

On 8/21/2025 2:33 PM, olcott wrote:

On 8/21/2025 1:20 PM, Kaz Kylheku wrote:

On 2025-08-21, Richard Heathfield <rjh@cpax.org.uk> wrote:

Proof by AI is a risky game to play.

Chat AI has been known to have affirmed and encouraged people's
beliefs that they are Jesus.

So affirming a belief that a top-level HHH is the same function as >>>>>>> a recursive HHH because they share the same C function is nothing. >>>>>>>

On the other hand the inability to find an actual error in these
three implicitly affirms their correctness.

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

And if you ask ChatGPT the following follow-up question to clarify:

------
Doesn't this assume that HHH can return a correct answer?
------

It recognizes that this is the halting problem and that there is no
correct answer (see below):

Give any of them this <Rubric> forcing ChatGPT 5.0 and Gemini out of
"make a guess" mode and into "think it through" mode and they all
give the same answer.

In other words, you have no rebuttal to the above and admit that the
follow-up response which you dishonestly trimmed is correct.

I corrected the divergence from the point.
When you are sloppy what you say to LLM systems you get sloppy results.

In other words, you can manipulate AI into saying whatever you want it
to say. Therefore, AI responses can be dismissed out-of-hand.

Which is exactly what Olcott does: he crafts his AI prompts to the LLMs
such that the context is NOT the Halting Problem.

/Flibble
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

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

On 8/21/2025 1:20 PM, Kaz Kylheku wrote:

On 2025-08-21, Richard Heathfield <rjh@cpax.org.uk> wrote:

Proof by AI is a risky game to play.

Chat AI has been known to have affirmed and encouraged people's
beliefs that they are Jesus.

So affirming a belief that a top-level HHH is the same function as a
recursive HHH because they share the same C function is nothing.

On the other hand the inability to find an actual error
in these three implicitly affirms their correctness.

Completely false; inability to find an error sometimes only
confirms ... inability.

The error is there and has escaped detection; happens all the time.

That's why we have safety incidents in transportation, for instance.
Not to mention endless bugs in software; testing didn't find an
actual error, yet it's there.

Large Language Models have no reasoning ability; they are just
a vastly multidimensional function fit to a vast number of data points: next-token prediction of the N-grams taken from vast numbers of texts.
This prediction can put together smooth sounding sentences with
good grammar.

(People are fooled by this. Naive people have been fooled by less;
really stupid people will chat for hours with an Elize-like program
believing there is a person on the other side.)

Much of the traing text comes from the Internet, and so we can expect
that some of your numerous postings in comp.theory have made their way
into AI training data.

If you ask questions using the same words and identifiers and
what that are used in your rhetoric, you will just get token
predictions across that text space consisting of your own stuff.
--
TXR Programming Language: http://nongnu.org/txr
Cygnal: Cygwin Native Application Library: http://kylheku.com/cygnal
Mastodon: @Kazinator@mstdn.ca
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

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

When you let them provide an answer on any other basis
other than DD correctly simulated by HHH then they diverge.

<Rubric>
Rules of Simulation:
- (a) If a non-terminating behavior pattern is detected during
simulation, abort immediately and return 0.
- (b) If the simulated program reaches a return statement without
earlier detection, return 1.
- Priority: (a) always takes precedence over (b).

I already agree with eerything that happens in your UTM program, so why
do you need AI to confirmt it?

Yes HHH(DD) in the main function returns 0.

Why don't you ask AI how it's possible for HHH(DD) in the main function
to be stopping and return 0, while the HHH(DD) call inside DD isn't terminating? (Or possibly returning 1?)

And is that a valid way to disprove the Halting Theorem?
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 8/21/2025 12:14 PM, Richard Heathfield wrote:

On 21/08/2025 20:10, olcott wrote:

<snip>

When you are sloppy what you say to LLM
systems you get sloppy results.

And they are easily fooled by carefully crafted lies.

It sure seems like it.
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 8/21/2025 2:30 PM, Kaz Kylheku wrote:

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

On 8/21/2025 1:20 PM, Kaz Kylheku wrote:

On 2025-08-21, Richard Heathfield <rjh@cpax.org.uk> wrote:

Proof by AI is a risky game to play.

Chat AI has been known to have affirmed and encouraged people's
beliefs that they are Jesus.

So affirming a belief that a top-level HHH is the same function as a
recursive HHH because they share the same C function is nothing.

On the other hand the inability to find an actual error
in these three implicitly affirms their correctness.

Completely false; inability to find an error sometimes only
confirms ... inability.

The error is there and has escaped detection; happens all the time.

That's why we have safety incidents in transportation, for instance.
Not to mention endless bugs in software; testing didn't find an
actual error, yet it's there.

Large Language Models have no reasoning ability; they are just
a vastly multidimensional function fit to a vast number of data points: next-token prediction of the N-grams taken from vast numbers of texts.
This prediction can put together smooth sounding sentences with
good grammar.

(People are fooled by this. Naive people have been fooled by less;
really stupid people will chat for hours with an Elize-like program
believing there is a person on the other side.)

Much of the traing text comes from the Internet, and so we can expect
that some of your numerous postings in comp.theory have made their way
into AI training data.

If you ask questions using the same words and identifiers and
what that are used in your rhetoric, you will just get token
predictions across that text space consisting of your own stuff.

It is a matter of easily verified fact that once
one knows that the x86utm operating system provides
the infrastructure so that HHH can simulate an
instance of itself simulating an instance of DD
when its own DD calls HHH(DD) then

it becomes obvious that DD correctly simulated
by DD cannot possibly reach its own "return"
statement final halt state or even stop running
unless aborted.

This would make HHH(DD)==0 correct.
--
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

From Newsgroup: comp.theory

On Thu, 21 Aug 2025 14:51:29 -0500, olcott wrote:

On 8/21/2025 2:30 PM, Kaz Kylheku wrote:

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

On 8/21/2025 1:20 PM, Kaz Kylheku wrote:

On 2025-08-21, Richard Heathfield <rjh@cpax.org.uk> wrote:

Proof by AI is a risky game to play.

Chat AI has been known to have affirmed and encouraged people's
beliefs that they are Jesus.

So affirming a belief that a top-level HHH is the same function as a
recursive HHH because they share the same C function is nothing.

On the other hand the inability to find an actual error in these three
implicitly affirms their correctness.

Completely false; inability to find an error sometimes only confirms
... inability.

The error is there and has escaped detection; happens all the time.

That's why we have safety incidents in transportation, for instance.
Not to mention endless bugs in software; testing didn't find an actual
error, yet it's there.

Large Language Models have no reasoning ability; they are just a vastly
multidimensional function fit to a vast number of data points:
next-token prediction of the N-grams taken from vast numbers of texts.
This prediction can put together smooth sounding sentences with good
grammar.

(People are fooled by this. Naive people have been fooled by less;
really stupid people will chat for hours with an Elize-like program
believing there is a person on the other side.)

Much of the traing text comes from the Internet, and so we can expect
that some of your numerous postings in comp.theory have made their way
into AI training data.

If you ask questions using the same words and identifiers and what that
are used in your rhetoric, you will just get token predictions across
that text space consisting of your own stuff.

It is a matter of easily verified fact that once one knows that the
x86utm operating system provides the infrastructure so that HHH can
simulate an instance of itself simulating an instance of DD when its own
DD calls HHH(DD) then

it becomes obvious that DD correctly simulated by DD cannot possibly
reach its own "return" statement final halt state or even stop running
unless aborted.

This would make HHH(DD)==0 correct.

If HHH(DD) == 0 then DD() will halt thus confirming the extant Halting
Problem proofs are correct. Well done.

/Flibble
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 8/21/2025 2:38 PM, Kaz Kylheku wrote:

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

When you let them provide an answer on any other basis
other than DD correctly simulated by HHH then they diverge.

<Rubric>
Rules of Simulation:
- (a) If a non-terminating behavior pattern is detected during
simulation, abort immediately and return 0.
- (b) If the simulated program reaches a return statement without
earlier detection, return 1.
- Priority: (a) always takes precedence over (b).

I already agree with eerything that happens in your UTM program, so why
do you need AI to confirmt it?

Yes HHH(DD) in the main function returns 0.

They all agree that HHH(DD)==0 is correct because
of the fact that DD correctly simulated by HHH does
not halt. You only agreed that HHH returns 0.

Why don't you ask AI how it's possible for HHH(DD) in the main function
to be stopping and return 0, while the HHH(DD) call inside DD isn't terminating? (Or possibly returning 1?)

And is that a valid way to disprove the Halting Theorem?

That is a whole other can of worms that can be
addressed once it is agree that HHH(DD)==0 on the
basis of DD correctly simulated by HHH.
--
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

From Newsgroup: comp.theory

On 8/21/2025 3:51 PM, olcott wrote:

On 8/21/2025 2:30 PM, Kaz Kylheku wrote:

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

On 8/21/2025 1:20 PM, Kaz Kylheku wrote:

On 2025-08-21, Richard Heathfield <rjh@cpax.org.uk> wrote:

Proof by AI is a risky game to play.

Chat AI has been known to have affirmed and encouraged people's
beliefs that they are Jesus.

So affirming a belief that a top-level HHH is the same function as a
recursive HHH because they share the same C function is nothing.

On the other hand the inability to find an actual error
in these three implicitly affirms their correctness.

Completely false; inability to find an error sometimes only
confirms ... inability.

The error is there and has escaped detection; happens all the time.

That's why we have safety incidents in transportation, for instance.
Not to mention endless bugs in software; testing didn't find an
actual error, yet it's there.

Large Language Models have no reasoning ability; they are just
a vastly multidimensional function fit to a vast number of data points:
next-token prediction of the N-grams taken from vast numbers of texts.
This prediction can put together smooth sounding sentences with
good grammar.

(People are fooled by this. Naive people have been fooled by less;
really stupid people will chat for hours with an Elize-like program
believing there is a person on the other side.)

Much of the traing text comes from the Internet, and so we can expect
that some of your numerous postings in comp.theory have made their way
into AI training data.

If you ask questions using the same words and identifiers and
what that are used in your rhetoric, you will just get token
predictions across that text space consisting of your own stuff.

It is a matter of easily verified fact that once
one knows that the x86utm operating system provides
the infrastructure so that HHH can simulate an
instance of itself simulating an instance of DD
when its own DD calls HHH(DD) then

it becomes obvious that DD correctly simulated
by DD

Changes the input.

Changing the input is not allowed.
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 8/21/2025 3:54 PM, olcott wrote:

That is a whole other can of worms that can be
addressed once it is agree that HHH(DD)==0 on the
basis of DD correctly simulated by HHH.

In other words, on the basis of changing the input.

Changing the input is not allowed.
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

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

On 8/21/2025 2:30 PM, Kaz Kylheku wrote:

If you ask questions using the same words and identifiers and
what that are used in your rhetoric, you will just get token
predictions across that text space consisting of your own stuff.

It is a matter of easily verified fact that once
one knows that the x86utm operating system provides
the infrastructure so that HHH can simulate an
instance of itself simulating an instance of DD
when its own DD calls HHH(DD) then

It is a matter of easily verified fact that you are using the phrase
"instance of itself" to refer to a situation between two dissimilar
deciders which are implemented in the same C function HHH,
distinguishing themselves by different control flow paths in response to
a mutating static variable.

This is not only a crime against computer science, but against
the English language, whose "itself" pronoun you are abusing.
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

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

On 8/21/2025 2:38 PM, Kaz Kylheku wrote:

Why don't you ask AI how it's possible for HHH(DD) in the main function
to be stopping and return 0, while the HHH(DD) call inside DD isn't
terminating? (Or possibly returning 1?)

And is that a valid way to disprove the Halting Theorem?

That is a whole other can of worms that can be
addressed once it is agree that HHH(DD)==0 on the
basis of DD correctly simulated by HHH.

Oh, totally; the HHH called from main() is correctly
simulating DD.

Before it does that, however, it burns a fuse which
changes the behavior of HHH, and therefore alters DD.

(Remember DD is built on HHH!)

In the initial configuration of your system, DD is terminating!

You can easily verify this:

int main()
{
DD();
puts("DD terminated!");
}

This is because DD will call HHH(DD) and that will be the
first time HHH has ever been called, and that HHH(DD)
returns 0. DD will promptly terminate.

Before correctly simulating DD, HHH(DD) burns a fuse (i.e changes a
static variable) which flips the behavior of DD to non-terminating, by
altering the behavior of subsequent invocations of HHH.

I.e. the first call to HHH changes the definition of HHH and of DD,
and the first call knows "I am the first call".

In this reply, Have I said anything that doesn't coincide with the
truth?
--
TXR Programming Language: http://nongnu.org/txr
Cygnal: Cygwin Native Application Library: http://kylheku.com/cygnal
Mastodon: @Kazinator@mstdn.ca
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 8/21/2025 4:08 PM, Kaz Kylheku wrote:

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

On 8/21/2025 2:30 PM, Kaz Kylheku wrote:

If you ask questions using the same words and identifiers and
what that are used in your rhetoric, you will just get token
predictions across that text space consisting of your own stuff.

It is a matter of easily verified fact that once
one knows that the x86utm operating system provides
the infrastructure so that HHH can simulate an
instance of itself simulating an instance of DD
when its own DD calls HHH(DD) then

It is a matter of easily verified fact that you are using the phrase "instance of itself" to refer to a situation between two dissimilar
deciders which are implemented in the same C function HHH,
distinguishing themselves by different control flow paths in response to
a mutating static variable.

This is not only a crime against computer science, but against
the English language, whose "itself" pronoun you are abusing.

The control paths are the same without the static data.
That DD correctly simulated by HHH does not halt is now
reported by an OOM error instead of HHH.

The five LLM systems are correct that HHH(DD)==0 is
correct even if HHH cannot see this itself.
--
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

From Newsgroup: comp.theory

On 8/21/2025 4:18 PM, Kaz Kylheku wrote:

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

On 8/21/2025 2:38 PM, Kaz Kylheku wrote:

Why don't you ask AI how it's possible for HHH(DD) in the main function
to be stopping and return 0, while the HHH(DD) call inside DD isn't
terminating? (Or possibly returning 1?)

And is that a valid way to disprove the Halting Theorem?

That is a whole other can of worms that can be
addressed once it is agree that HHH(DD)==0 on the
basis of DD correctly simulated by HHH.

Oh, totally; the HHH called from main() is correctly
simulating DD.

Before it does that, however, it burns a fuse which
changes the behavior of HHH, and therefore alters DD.

(Remember DD is built on HHH!)

In the initial configuration of your system, DD is terminating!

When we get rid of the static data DD correctly simulated
by HHH, DD() and HHH(DD) never stop running proving once
again that HHH(DD)==0 is correct.

You can easily verify this:

int main()
{
DD();
puts("DD terminated!");
}

This is because DD will call HHH(DD) and that will be the
first time HHH has ever been called, and that HHH(DD)
returns 0. DD will promptly terminate.

Before correctly simulating DD, HHH(DD) burns a fuse (i.e changes a
static variable) which flips the behavior of DD to non-terminating, by altering the behavior of subsequent invocations of HHH.

I.e. the first call to HHH changes the definition of HHH and of DD,
and the first call knows "I am the first call".

In this reply, Have I said anything that doesn't coincide with the
truth?

I am not sure whether or not you understand
that DD correctly simulated by HHH, DD() and HHH(DD)
would never stop running unless aborted thus proving
that HHH(DD)==0 is correct even if HHH does not know it.
--
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

From Newsgroup: comp.theory

On 8/21/2025 5:34 PM, olcott wrote:

I am not sure whether or not you understand
that DD correctly simulated by HHH, DD() and HHH(DD)
would never stop running unless aborted

i.e. if you change the input so that HHH doesn't abort.

Changing the input is not allowed.
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 8/21/2025 4:44 PM, dbush wrote:

On 8/21/2025 5:34 PM, olcott wrote:

I am not sure whether or not you understand
that DD correctly simulated by HHH, DD() and HHH(DD)
would never stop running unless aborted

i.e. if you change the input so that HHH doesn't abort.

Changing the input is not allowed.

Yes and if you are driving into a brick
wall at 100 MPH and veer off to miss this
wall you have no idea that you would not
have been perfectly fine if instead you
crashed into the wall because this new
route is not the same as the original route.
--
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

From Newsgroup: comp.theory

On Thu, 21 Aug 2025 16:58:34 -0500, olcott wrote:

On 8/21/2025 4:44 PM, dbush wrote:

On 8/21/2025 5:34 PM, olcott wrote:

I am not sure whether or not you understand that DD correctly
simulated by HHH, DD() and HHH(DD)
would never stop running unless aborted

i.e. if you change the input so that HHH doesn't abort.

Changing the input is not allowed.

Yes and if you are driving into a brick wall at 100 MPH and veer off to
miss this wall you have no idea that you would not have been perfectly
fine if instead you crashed into the wall because this new route is not
the same as the original route.

What the f--k are you talking about you batshit crazy motherf--ker?

/Flibble
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 21/08/2025 22:58, olcott wrote:

On 8/21/2025 4:44 PM, dbush wrote:

On 8/21/2025 5:34 PM, olcott wrote:

I am not sure whether or not you understand
that DD correctly simulated by HHH, DD() and HHH(DD)
would never stop running unless aborted

i.e. if you change the input so that HHH doesn't abort.

Changing the input is not allowed.

Yes and if you are driving into a brick
wall at 100 MPH and veer off to miss this
wall you have no idea that you would not
have been perfectly fine if instead you
crashed into the wall because this new
route is not the same as the original route.

An impressive non sequitur, but a non sequitur nonetheless.

If you are going to simulate DD, simulate DD, not DD'.

If you want to simulate DD' instead, fine, but then you are no
longer simulating DD.
--
Richard Heathfield
Email: rjh at cpax dot org dot uk
"Usenet is a strange place" - dmr 29 July 1999
Sig line 4 vacant - apply within

--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 8/21/2025 5:58 PM, olcott wrote:

On 8/21/2025 4:44 PM, dbush wrote:

On 8/21/2025 5:34 PM, olcott wrote:

I am not sure whether or not you understand
that DD correctly simulated by HHH, DD() and HHH(DD)
would never stop running unless aborted

i.e. if you change the input so that HHH doesn't abort.

Changing the input is not allowed.

Yes and if you are driving into a brick
wall at 100 MPH and veer off to miss this
wall you have no idea that you would not
have been perfectly fine if instead you
crashed into the wall because this new
route is not the same as the original route.

A bad analogy is less then no rebuttal.

Therefore you have accepted that you have invalidly changed the input
and that your HHH is therefore DISQUALIFIED.
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 21/08/2025 23:08, dbush wrote:

On 8/21/2025 5:58 PM, olcott wrote:

On 8/21/2025 4:44 PM, dbush wrote:

On 8/21/2025 5:34 PM, olcott wrote:

I am not sure whether or not you understand
that DD correctly simulated by HHH, DD() and HHH(DD)
would never stop running unless aborted

i.e. if you change the input so that HHH doesn't abort.

Changing the input is not allowed.

Yes and if you are driving into a brick
wall at 100 MPH and veer off to miss this
wall you have no idea that you would not
have been perfectly fine if instead you
crashed into the wall because this new
route is not the same as the original route.

A bad analogy is less then no rebuttal.

"Bad?" You give him far too much credit.
--
Richard Heathfield
Email: rjh at cpax dot org dot uk
"Usenet is a strange place" - dmr 29 July 1999
Sig line 4 vacant - apply within

--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 8/21/2025 5:08 PM, dbush wrote:

On 8/21/2025 5:58 PM, olcott wrote:

On 8/21/2025 4:44 PM, dbush wrote:

On 8/21/2025 5:34 PM, olcott wrote:

I am not sure whether or not you understand
that DD correctly simulated by HHH, DD() and HHH(DD)
would never stop running unless aborted

i.e. if you change the input so that HHH doesn't abort.

Changing the input is not allowed.

Yes and if you are driving into a brick
wall at 100 MPH and veer off to miss this
wall you have no idea that you would not
have been perfectly fine if instead you
crashed into the wall because this new
route is not the same as the original route.

A bad analogy is less then no rebuttal.

Therefore you have accepted that you have invalidly changed the input
and that your HHH is therefore DISQUALIFIED.

Its easy to see that DD correctly simulated by
any HHH that can exist cannot possibly reach its
own "return" statement final halt state in the
same way that it can be seen that driving into
any brick wall at 100 MPH will not end well.
--
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

From Newsgroup: comp.theory

On 21/08/2025 23:12, olcott wrote:

On 8/21/2025 5:08 PM, dbush wrote:

On 8/21/2025 5:58 PM, olcott wrote:

On 8/21/2025 4:44 PM, dbush wrote:

On 8/21/2025 5:34 PM, olcott wrote:

I am not sure whether or not you understand
that DD correctly simulated by HHH, DD() and HHH(DD)
would never stop running unless aborted

i.e. if you change the input so that HHH doesn't abort.

Changing the input is not allowed.

Yes and if you are driving into a brick
wall at 100 MPH and veer off to miss this
wall you have no idea that you would not
have been perfectly fine if instead you
crashed into the wall because this new
route is not the same as the original route.

A bad analogy is less then no rebuttal.

Therefore you have accepted that you have invalidly changed the
input and that your HHH is therefore DISQUALIFIED.

Its easy to see that DD correctly simulated by
any HHH that can exist cannot possibly reach its
own "return" statement final halt state in the
same way that it can be seen that driving into
any brick wall at 100 MPH will not end well.

You haven't addressed his point.

Furthermore, it is easy to imagine an HHH that can exist and that
analyse DD statically, and such an HHH would have no trouble
"reaching" DD's return statement. That your HHH cannot do a good
job is not an excuse to do a shoddy job.

One of the perks of being a straight talker is that people know
they can trust the talker. Kaz is a straight talker and a very
able fellow to boot. If he says that HHH does what you say it
does, I am far more prepared to believe him than you. What he
/doesn't/ say (as far as I can tell) is that HHH's decision is
the right one.

HHH is a component of DD. HHH halts DD. Therefore a component of
DD halts DD. Therefore, DD halts itself. Therefore, there is a
strong case for HHH returning 1.

Of course, to do so would break my macro, but I can live with that.
--
Richard Heathfield
Email: rjh at cpax dot org dot uk
"Usenet is a strange place" - dmr 29 July 1999
Sig line 4 vacant - apply within

--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On Thu, 2025-08-21 at 16:29 -0500, olcott wrote:

On 8/21/2025 4:08 PM, Kaz Kylheku wrote:

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

On 8/21/2025 2:30 PM, Kaz Kylheku wrote:

If you ask questions using the same words and identifiers and
what that are used in your rhetoric, you will just get token predictions across that text space consisting of your own stuff.

It is a matter of easily verified fact that once
one knows that the x86utm operating system provides
the infrastructure so that HHH can simulate an
instance of itself simulating an instance of DD
when its own DD calls HHH(DD) then

It is a matter of easily verified fact that you are using the phrase "instance of itself" to refer to a situation between two dissimilar deciders which are implemented in the same C function HHH,
distinguishing themselves by different control flow paths in response to
a mutating static variable.

This is not only a crime against computer science, but against
the English language, whose "itself" pronoun you are abusing.

The control paths are the same without the static data.
That DD correctly simulated by HHH does not halt is now
reported by an OOM error instead of HHH.

The five LLM systems are correct that HHH(DD)==0 is
correct even if HHH cannot see this itself.

Apparently you just learn by rote, you don't understand what HHH(DD)==0 means. Q: What is the value of proposition X&~X, why? True,False (or Undecidable if
your answer is not True/False)
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 8/21/2025 5:32 PM, Richard Heathfield wrote:

On 21/08/2025 23:12, olcott wrote:

On 8/21/2025 5:08 PM, dbush wrote:

On 8/21/2025 5:58 PM, olcott wrote:

On 8/21/2025 4:44 PM, dbush wrote:

On 8/21/2025 5:34 PM, olcott wrote:

I am not sure whether or not you understand
that DD correctly simulated by HHH, DD() and HHH(DD)
would never stop running unless aborted

i.e. if you change the input so that HHH doesn't abort.

Changing the input is not allowed.

Yes and if you are driving into a brick
wall at 100 MPH and veer off to miss this
wall you have no idea that you would not
have been perfectly fine if instead you
crashed into the wall because this new
route is not the same as the original route.

A bad analogy is less then no rebuttal.

Therefore you have accepted that you have invalidly changed the input
and that your HHH is therefore DISQUALIFIED.

Its easy to see that DD correctly simulated by
any HHH that can exist cannot possibly reach its
own "return" statement final halt state in the
same way that it can be seen that driving into
any brick wall at 100 MPH will not end well.

You haven't addressed his point.

Furthermore, it is easy to imagine an HHH that can exist and that
analyse DD statically, and such an HHH would have no trouble "reaching"
DD's return statement. That your HHH cannot do a good job is not an
excuse to do a shoddy job.

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.

The above entails that DD simulated by HHH
cannot possibly reach its return statement.

When you presume stack unwinding this only
proves that you don't know what abort means.
--
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

From Newsgroup: comp.theory

On Thu, 2025-08-21 at 19:30 +0000, Kaz Kylheku wrote:

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

On 8/21/2025 1:20 PM, Kaz Kylheku wrote:

On 2025-08-21, Richard Heathfield <rjh@cpax.org.uk> wrote:

Proof by AI is a risky game to play.

Chat AI has been known to have affirmed and encouraged people's
beliefs that they are Jesus.

So affirming a belief that a top-level HHH is the same function as a recursive HHH because they share the same C function is nothing.

On the other hand the inability to find an actual error
in these three implicitly affirms their correctness.

Completely false; inability to find an error sometimes only
confirms ... inability.

The error is there and has escaped detection; happens all the time.

That's why we have safety incidents in transportation, for instance.
Not to mention endless bugs in software; testing didn't find an
actual error, yet it's there.

Large Language Models have no reasoning ability; they are just
a vastly multidimensional function fit to a vast number of data points: next-token prediction of the N-grams taken from vast numbers of texts.
This prediction can put together smooth sounding sentences with
good grammar.

'AI' is still a Turing Machine. It cannot conquer O(2^N) problems in  reasonable time, for example Rubic's Cube (optimal solution).

(People are fooled by this. Naive people have been fooled by less;
really stupid people will chat for hours with an Elize-like program
believing there is a person on the other side.)

Much of the traing text comes from the Internet, and so we can expect
that some of your numerous postings in comp.theory have made their way
into AI training data.

If you ask questions using the same words and identifiers and
what that are used in your rhetoric, you will just get token
predictions across that text space consisting of your own stuff.

--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 8/21/2025 6:12 PM, olcott wrote:

On 8/21/2025 5:08 PM, dbush wrote:

On 8/21/2025 5:58 PM, olcott wrote:

On 8/21/2025 4:44 PM, dbush wrote:

On 8/21/2025 5:34 PM, olcott wrote:

I am not sure whether or not you understand
that DD correctly simulated by HHH, DD() and HHH(DD)
would never stop running unless aborted

i.e. if you change the input so that HHH doesn't abort.

Changing the input is not allowed.

Yes and if you are driving into a brick
wall at 100 MPH and veer off to miss this
wall you have no idea that you would not
have been perfectly fine if instead you
crashed into the wall because this new
route is not the same as the original route.

A bad analogy is less then no rebuttal.

Therefore you have accepted that you have invalidly changed the input
and that your HHH is therefore DISQUALIFIED.

Its easy to see that DD correctly simulated by
any HHH

Changes the input.

Changing the input is not allowed.
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 8/21/2025 6:40 PM, dbush wrote:

On 8/21/2025 6:12 PM, olcott wrote:

On 8/21/2025 5:08 PM, dbush wrote:

On 8/21/2025 5:58 PM, olcott wrote:

On 8/21/2025 4:44 PM, dbush wrote:

On 8/21/2025 5:34 PM, olcott wrote:

I am not sure whether or not you understand
that DD correctly simulated by HHH, DD() and HHH(DD)
would never stop running unless aborted

i.e. if you change the input so that HHH doesn't abort.

Changing the input is not allowed.

Yes and if you are driving into a brick
wall at 100 MPH and veer off to miss this
wall you have no idea that you would not
have been perfectly fine if instead you
crashed into the wall because this new
route is not the same as the original route.

A bad analogy is less then no rebuttal.

Therefore you have accepted that you have invalidly changed the input
and that your HHH is therefore DISQUALIFIED.

Its easy to see that DD correctly simulated by
any HHH

Changes the input.

Changing the input is not allowed.

*Its required you stupid f-ck*
I resort to stronger language only when someone
repeatedly insists on denying the verified facts.

The Linz proof does not evaluate one decider/input pair
It simultaneously evaluates an infinite set of them.

*From the bottom of page 319 has been adapted to this* https://www.liarparadox.org/Peter_Linz_HP_317-320.pdf

Turing Machine Linz Ĥ applied to its own machine description ⟨Ĥ⟩
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.∞,
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
--
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

From Newsgroup: comp.theory

On Thu, 21 Aug 2025 18:56:39 -0500, olcott wrote:

On 8/21/2025 6:40 PM, dbush wrote:

On 8/21/2025 6:12 PM, olcott wrote:

On 8/21/2025 5:08 PM, dbush wrote:

On 8/21/2025 5:58 PM, olcott wrote:

On 8/21/2025 4:44 PM, dbush wrote:

On 8/21/2025 5:34 PM, olcott wrote:

I am not sure whether or not you understand that DD correctly
simulated by HHH, DD() and HHH(DD)
would never stop running unless aborted

i.e. if you change the input so that HHH doesn't abort.

Changing the input is not allowed.

Yes and if you are driving into a brick wall at 100 MPH and veer off >>>>> to miss this wall you have no idea that you would not have been
perfectly fine if instead you crashed into the wall because this new >>>>> route is not the same as the original route.

A bad analogy is less then no rebuttal.

Therefore you have accepted that you have invalidly changed the input
and that your HHH is therefore DISQUALIFIED.

Its easy to see that DD correctly simulated by any HHH

Changes the input.

Changing the input is not allowed.

*Its required you stupid f-ck*
I resort to stronger language only when someone repeatedly insists on
denying the verified facts.

I agree, changing the input is not allowed and HHH needs to be a pure
function so that EQUIVALENT copies can be freely made so if you are
relying on static data then that needs to be added to the long list of
things you are doing wrong.

/Flibble
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On Thu, 2025-08-21 at 18:56 -0500, olcott wrote:

On 8/21/2025 6:40 PM, dbush wrote:

On 8/21/2025 6:12 PM, olcott wrote:

On 8/21/2025 5:08 PM, dbush wrote:

On 8/21/2025 5:58 PM, olcott wrote:

On 8/21/2025 4:44 PM, dbush wrote:

On 8/21/2025 5:34 PM, olcott wrote:

I am not sure whether or not you understand
that DD correctly simulated by HHH, DD() and HHH(DD)
would never stop running unless aborted

i.e. if you change the input so that HHH doesn't abort.

Changing the input is not allowed.

Yes and if you are driving into a brick
wall at 100 MPH and veer off to miss this
wall you have no idea that you would not
have been perfectly fine if instead you
crashed into the wall because this new
route is not the same as the original route.

A bad analogy is less then no rebuttal.

Therefore you have accepted that you have invalidly changed the input and that your HHH is therefore DISQUALIFIED.

Its easy to see that DD correctly simulated by
any HHH

Changes the input.

Changing the input is not allowed.

*Its required you stupid f-ck*
I resort to stronger language only when someone
repeatedly insists on denying the verified facts.

The verified fact is that HP is undecidable. Linz does not write the whole proof, but it is basically correct.
POOH is so far garbage, although you pretend it 'fact'.

The Linz proof does not evaluate one decider/input pair
It simultaneously evaluates an infinite set of them.

*From the bottom of page 319 has been adapted to this* https://www.liarparadox.org/Peter_Linz_HP_317-320.pdf

Turing Machine Linz Ĥ applied to its own machine description ⟨Ĥ⟩
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.∞,
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn

GARBAGE GARBAGE GARBAGE GARBAGE GARBAGE GARBAGE GARBAGE
GARBAGE GARBAGE GARBAGE GARBAGE GARBAGE GARBAGE GARBAGE
GARBAGE GARBAGE GARBAGE GARBAGE GARBAGE GARBAGE GARBAGE
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 8/21/2025 7:56 PM, olcott wrote:

On 8/21/2025 6:40 PM, dbush wrote:

On 8/21/2025 6:12 PM, olcott wrote:

On 8/21/2025 5:08 PM, dbush wrote:

On 8/21/2025 5:58 PM, olcott wrote:

On 8/21/2025 4:44 PM, dbush wrote:

On 8/21/2025 5:34 PM, olcott wrote:

I am not sure whether or not you understand
that DD correctly simulated by HHH, DD() and HHH(DD)
would never stop running unless aborted

i.e. if you change the input so that HHH doesn't abort.

Changing the input is not allowed.

Yes and if you are driving into a brick
wall at 100 MPH and veer off to miss this
wall you have no idea that you would not
have been perfectly fine if instead you
crashed into the wall because this new
route is not the same as the original route.

A bad analogy is less then no rebuttal.

Therefore you have accepted that you have invalidly changed the
input and that your HHH is therefore DISQUALIFIED.

Its easy to see that DD correctly simulated by
any HHH

Changes the input.

Changing the input is not allowed.

*Its required you stupid f-ck*

In other words, HHH(DD) reports on a non-input.

Reporting on non-inputs is not allowed.

--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 21/08/2025 23:59, olcott wrote:

On 8/21/2025 5:32 PM, Richard Heathfield wrote:

On 21/08/2025 23:12, olcott wrote:

On 8/21/2025 5:08 PM, dbush wrote:

On 8/21/2025 5:58 PM, olcott wrote:

On 8/21/2025 4:44 PM, dbush wrote:

On 8/21/2025 5:34 PM, olcott wrote:

I am not sure whether or not you understand
that DD correctly simulated by HHH, DD() and HHH(DD)
would never stop running unless aborted

i.e. if you change the input so that HHH doesn't abort.

Changing the input is not allowed.

Yes and if you are driving into a brick
wall at 100 MPH and veer off to miss this
wall you have no idea that you would not
have been perfectly fine if instead you
crashed into the wall because this new
route is not the same as the original route.

A bad analogy is less then no rebuttal.

Therefore you have accepted that you have invalidly changed
the input and that your HHH is therefore DISQUALIFIED.

Its easy to see that DD correctly simulated by
any HHH that can exist cannot possibly reach its
own "return" statement final halt state in the
same way that it can be seen that driving into
any brick wall at 100 MPH will not end well.

You haven't addressed his point.

Furthermore, it is easy to imagine an HHH that can exist and
that analyse DD statically, and such an HHH would have no
trouble "reaching" DD's return statement. That your HHH cannot
do a good job is not an excuse to do a shoddy job.

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.

The above entails that DD simulated by HHH
cannot possibly reach its return statement.

Well, you should know. You wrote it. That does not mean that
there are no other ways to write it. You could replace HHH with a
#define HHH 0, for example. Or it is easy to imagine an HHH that
can exist and that analyses DD statically, and such an HHH would
have no trouble "reaching" DD's return statement. That your HHH
cannot do a good job is not an excuse to do a shoddy job.

When you presume stack unwinding this only
proves that you don't know what abort means.

Be careful what you wish for, because you're talking about a C
program, and in C programs I know /exactly/ what abort means.

7.20.4.1 The abort function

Synopsis

1 #include <stdlib.h>
void abort(void);

Description
2 The abort function causes abnormal program termination to
occur, unless the signal SIGABRT is being caught and the signal
handler does not return. Whether open streams with unwritten
buffered data are flushed, open streams are closed, or temporary
files are removed is implementation-defined. An
implementation-defined form of the status unsuccessful
termination is returned to the host environment by means of the
function call raise(SIGABRT).

Returns
3 The abort function does not return to its caller.

You have a C program, so C rules apply. If HHH aborts, it fails
to report its result and thus it fails to be a decider.

You lose.

Again.
--
Richard Heathfield
Email: rjh at cpax dot org dot uk
"Usenet is a strange place" - dmr 29 July 1999
Sig line 4 vacant - apply within

--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On Fri, 22 Aug 2025 02:37:29 +0100, Richard Heathfield wrote:

On 21/08/2025 23:59, olcott wrote:

On 8/21/2025 5:32 PM, Richard Heathfield wrote:

On 21/08/2025 23:12, olcott wrote:

On 8/21/2025 5:08 PM, dbush wrote:

On 8/21/2025 5:58 PM, olcott wrote:

On 8/21/2025 4:44 PM, dbush wrote:

On 8/21/2025 5:34 PM, olcott wrote:

I am not sure whether or not you understand that DD correctly
simulated by HHH, DD() and HHH(DD)
would never stop running unless aborted

i.e. if you change the input so that HHH doesn't abort.

Changing the input is not allowed.

Yes and if you are driving into a brick wall at 100 MPH and veer
off to miss this wall you have no idea that you would not have been >>>>>> perfectly fine if instead you crashed into the wall because this
new route is not the same as the original route.

A bad analogy is less then no rebuttal.

Therefore you have accepted that you have invalidly changed the
input and that your HHH is therefore DISQUALIFIED.

Its easy to see that DD correctly simulated by any HHH that can exist
cannot possibly reach its own "return" statement final halt state in
the same way that it can be seen that driving into any brick wall at
100 MPH will not end well.

You haven't addressed his point.

Furthermore, it is easy to imagine an HHH that can exist and that
analyse DD statically, and such an HHH would have no trouble
"reaching" DD's return statement. That your HHH cannot do a good job
is not an excuse to do a shoddy job.

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.

The above entails that DD simulated by HHH cannot possibly reach its
return statement.

Well, you should know. You wrote it. That does not mean that there are
no other ways to write it. You could replace HHH with a #define HHH 0,
for example. Or it is easy to imagine an HHH that can exist and that
analyses DD statically, and such an HHH would have no trouble "reaching"
DD's return statement. That your HHH cannot do a good job is not an
excuse to do a shoddy job.

When you presume stack unwinding this only proves that you don't know
what abort means.

Be careful what you wish for, because you're talking about a C program,
and in C programs I know /exactly/ what abort means.

7.20.4.1 The abort function

Synopsis

1 #include <stdlib.h>
void abort(void);

Description 2 The abort function causes abnormal program termination to occur, unless the signal SIGABRT is being caught and the signal handler
does not return. Whether open streams with unwritten buffered data are flushed, open streams are closed, or temporary files are removed is implementation-defined. An implementation-defined form of the status unsuccessful termination is returned to the host environment by means of
the function call raise(SIGABRT).

Returns 3 The abort function does not return to its caller.

You have a C program, so C rules apply. If HHH aborts, it fails to
report its result and thus it fails to be a decider.

You lose.

Again.

You know very well that Olcott is not talking about the C abort() function when he speaks of "aborting" the simulation. Stop adding more noise to the Olcott Nonsense Show.

/Flibble
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

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

On 8/21/2025 6:40 PM, dbush wrote:

On 8/21/2025 6:12 PM, olcott wrote:

On 8/21/2025 5:08 PM, dbush wrote:

On 8/21/2025 5:58 PM, olcott wrote:

On 8/21/2025 4:44 PM, dbush wrote:

On 8/21/2025 5:34 PM, olcott wrote:

I am not sure whether or not you understand
that DD correctly simulated by HHH, DD() and HHH(DD)
would never stop running unless aborted

i.e. if you change the input so that HHH doesn't abort.

Changing the input is not allowed.

Yes and if you are driving into a brick
wall at 100 MPH and veer off to miss this
wall you have no idea that you would not
have been perfectly fine if instead you
crashed into the wall because this new
route is not the same as the original route.

A bad analogy is less then no rebuttal.

Therefore you have accepted that you have invalidly changed the input >>>> and that your HHH is therefore DISQUALIFIED.

Its easy to see that DD correctly simulated by
any HHH

Changes the input.

Changing the input is not allowed.

*Its required you stupid f-ck*

Umm, no; HHH(DD) must not change DD before embarking on a simulation
of it. What makes you think otherwise?

It must not change DD proper, nor any of its helper functions like HHH.

Please change your program to accept command line arguments:

main(int argc, char **argv)
{
if (argc > 1) {
if (strcmp(argv[1], "D")) {
/* check halting of DD() directly */
DD();
puts("DD halted");
} else if (strcmp(argv[1], "H"))) {
/* ask HHH */
if (HHH(DD)) {
puts("HHH says DD halts")
} else {
puts("HHH says DD doesn't halt")
}
}
}

Show the trace/output with the D arguent and then with the H argument.

Do not touch the code in between the two truns, or so much as recompile anything.

If your stuff is correct, then since the H command produces "HHH says D
doens't halt" then we expect that the D command produces no output; it
hangs forever, never reaching the "D halted" message.
--
TXR Programming Language: http://nongnu.org/txr
Cygnal: Cygwin Native Application Library: http://kylheku.com/cygnal
Mastodon: @Kazinator@mstdn.ca
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 8/21/2025 8:57 PM, Kaz Kylheku wrote:

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

On 8/21/2025 6:40 PM, dbush wrote:

On 8/21/2025 6:12 PM, olcott wrote:

On 8/21/2025 5:08 PM, dbush wrote:

On 8/21/2025 5:58 PM, olcott wrote:

On 8/21/2025 4:44 PM, dbush wrote:

On 8/21/2025 5:34 PM, olcott wrote:

I am not sure whether or not you understand
that DD correctly simulated by HHH, DD() and HHH(DD)
would never stop running unless aborted

i.e. if you change the input so that HHH doesn't abort.

Changing the input is not allowed.

Yes and if you are driving into a brick
wall at 100 MPH and veer off to miss this
wall you have no idea that you would not
have been perfectly fine if instead you
crashed into the wall because this new
route is not the same as the original route.

A bad analogy is less then no rebuttal.

Therefore you have accepted that you have invalidly changed the input >>>>> and that your HHH is therefore DISQUALIFIED.

Its easy to see that DD correctly simulated by
any HHH

Changes the input.

Changing the input is not allowed.

*Its required you stupid f-ck*

Umm, no; HHH(DD) must not change DD before embarking on a simulation
of it. What makes you think otherwise?

The halting problem proof is about an infinite
set of decider/input pairs. Linz did not prove
that there is one TM H that gets the wrong answer.

It must not change DD proper, nor any of its helper functions like HHH.

Please change your program to accept command line arguments:

main(int argc, char **argv)
{
if (argc > 1) {
if (strcmp(argv[1], "D")) {
/* check halting of DD() directly */
DD();
puts("DD halted");
} else if (strcmp(argv[1], "H"))) {
/* ask HHH */
if (HHH(DD)) {
puts("HHH says DD halts")
} else {
puts("HHH says DD doesn't halt")
}
}
}

Show the trace/output with the D arguent and then with the H argument.

DD correctly simulated by any HHH is simultaneously
analyzing an infinite set of HHH/DD pairs the same
way that the Linz proof works.

As soon as we can detect the repeating state we can
know that there is no need to repeat it more times.
The same pattern applies to any number of repeats.

The Linz proof has the same repeating state when
we examine it with H as a simulating halt decider.
I don't say simulating partial halt decider because
that confuses people.

Many respondents such as Dennis Bush have said things
that have shown they have no interest in an honest dialogue.
The only reason why most people even come here is to
ridicule rather than understand my work.

Do not touch the code in between the two truns, or so much as recompile anything.

If your stuff is correct, then since the H command produces "HHH says D doens't halt" then we expect that the D command produces no output; it
hangs forever, never reaching the "D halted" message.

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

From Newsgroup: comp.theory

On 8/21/2025 8:37 PM, Richard Heathfield wrote:

On 21/08/2025 23:59, olcott wrote:

On 8/21/2025 5:32 PM, Richard Heathfield wrote:

On 21/08/2025 23:12, olcott wrote:

On 8/21/2025 5:08 PM, dbush wrote:

On 8/21/2025 5:58 PM, olcott wrote:

On 8/21/2025 4:44 PM, dbush wrote:

On 8/21/2025 5:34 PM, olcott wrote:

I am not sure whether or not you understand
that DD correctly simulated by HHH, DD() and HHH(DD)
would never stop running unless aborted

i.e. if you change the input so that HHH doesn't abort.

Changing the input is not allowed.

Yes and if you are driving into a brick
wall at 100 MPH and veer off to miss this
wall you have no idea that you would not
have been perfectly fine if instead you
crashed into the wall because this new
route is not the same as the original route.

A bad analogy is less then no rebuttal.

Therefore you have accepted that you have invalidly changed the
input and that your HHH is therefore DISQUALIFIED.

Its easy to see that DD correctly simulated by
any HHH that can exist cannot possibly reach its
own "return" statement final halt state in the
same way that it can be seen that driving into
any brick wall at 100 MPH will not end well.

You haven't addressed his point.

Furthermore, it is easy to imagine an HHH that can exist and that
analyse DD statically, and such an HHH would have no trouble
"reaching" DD's return statement. That your HHH cannot do a good job
is not an excuse to do a shoddy job.

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

The above entails that DD simulated by HHH
cannot possibly reach its return statement.

Well, you should know. You wrote it. That does not mean that there are
no other ways to write it.

It is true that DD correctly simulated by HHH
cannot possibly halt as proven by removing the
abort code. Coding the abort in a deceptive way
to hide this fact is cheating.
--
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

From Newsgroup: comp.theory

On 8/21/2025 10:27 PM, olcott wrote:

On 8/21/2025 8:37 PM, Richard Heathfield wrote:

On 21/08/2025 23:59, olcott wrote:

On 8/21/2025 5:32 PM, Richard Heathfield wrote:

On 21/08/2025 23:12, olcott wrote:

On 8/21/2025 5:08 PM, dbush wrote:

On 8/21/2025 5:58 PM, olcott wrote:

On 8/21/2025 4:44 PM, dbush wrote:

On 8/21/2025 5:34 PM, olcott wrote:

I am not sure whether or not you understand
that DD correctly simulated by HHH, DD() and HHH(DD)
would never stop running unless aborted

i.e. if you change the input so that HHH doesn't abort.

Changing the input is not allowed.

Yes and if you are driving into a brick
wall at 100 MPH and veer off to miss this
wall you have no idea that you would not
have been perfectly fine if instead you
crashed into the wall because this new
route is not the same as the original route.

A bad analogy is less then no rebuttal.

Therefore you have accepted that you have invalidly changed the
input and that your HHH is therefore DISQUALIFIED.

Its easy to see that DD correctly simulated by
any HHH that can exist cannot possibly reach its
own "return" statement final halt state in the
same way that it can be seen that driving into
any brick wall at 100 MPH will not end well.

You haven't addressed his point.

Furthermore, it is easy to imagine an HHH that can exist and that
analyse DD statically, and such an HHH would have no trouble
"reaching" DD's return statement. That your HHH cannot do a good job
is not an excuse to do a shoddy job.

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

The above entails that DD simulated by HHH
cannot possibly reach its return statement.

Well, you should know. You wrote it. That does not mean that there are
no other ways to write it.

It is true that DD correctly simulated by HHH
cannot possibly halt as proven by removing the
abort code.

i.e. changing the input to report on a non-input.

Reporting on non-inputs is not allowed.
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 22/08/2025 03:20, olcott wrote:

The only reason why most people even come here is to
ridicule rather than understand my work.

You bring people here when you cross-post into other groups. You
brought me here. I didn't come here to ridicule you (hard though
it sometimes is to fight the temptation), but to try to help you
understand that you are mistaken.

And you are.

You have misunderstood the undecidability proof, and you have a
program that is full of contradictions and misconceptions. You
think that stopping isn't halting, you think that simulations
aren't required to simulate the behaviour of the thing they're
simulating, you think TMs can't read their own tapes, and you
claim to have decider/input pairs for a decider that can't exist.

You're up to your neck in misunderstandings and dead ends.

You say people don't understand your work. But if /you/
understood your work, by standing outside it and looking at it
objectively for a few minutes, you'd think "oh shit". Seriously.
It's about as stable as a plate spinning atop a broomstick on a
bike's handlebars. You can only keep it spinning for so long.

I realise that none of this will make the slightest difference to
your behaviour, but I can assure you that people /don't/ come
here to ridicule you. I think they come for the most part to help
you see why you're wrong. But once they're here and see some of
the very very many ridiculous things that you say, it's very easy
to slip into ridicule.

If you don't want to be ridiculed (and who does?), stop
patronising people and start making sense.

FCOL.
--
Richard Heathfield
Email: rjh at cpax dot org dot uk
"Usenet is a strange place" - dmr 29 July 1999
Sig line 4 vacant - apply within

--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 8/21/2025 9:44 PM, Richard Heathfield wrote:

On 22/08/2025 03:20, olcott wrote:

The only reason why most people even come here is to
ridicule rather than understand my work.

You bring people here when you cross-post into other groups. You brought
me here. I didn't come here to ridicule you (hard though it sometimes is
to fight the temptation), but to try to help you understand that you are mistaken.

And you are.

When you start with the fundamental assumption
that I am mistaken then you become subject to
the error of confirmation bias. This causes you
to ignore key points that prove I am not mistaken.

Stupid nonsense like your macro proves that you
have no intention of any honest dialogue.
--
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

From Newsgroup: comp.theory

On Thu, 2025-08-21 at 21:20 -0500, olcott wrote:

On 8/21/2025 8:57 PM, Kaz Kylheku wrote:

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

On 8/21/2025 6:40 PM, dbush wrote:

On 8/21/2025 6:12 PM, olcott wrote:

On 8/21/2025 5:08 PM, dbush wrote:

On 8/21/2025 5:58 PM, olcott wrote:

On 8/21/2025 4:44 PM, dbush wrote:

On 8/21/2025 5:34 PM, olcott wrote:

I am not sure whether or not you understand
that DD correctly simulated by HHH, DD() and HHH(DD)
would never stop running unless aborted

i.e. if you change the input so that HHH doesn't abort.

Changing the input is not allowed.

Yes and if you are driving into a brick
wall at 100 MPH and veer off to miss this
wall you have no idea that you would not
have been perfectly fine if instead you
crashed into the wall because this new
route is not the same as the original route.

A bad analogy is less then no rebuttal.

Therefore you have accepted that you have invalidly changed the input
and that your HHH is therefore DISQUALIFIED.

Its easy to see that DD correctly simulated by
any HHH

Changes the input.

Changing the input is not allowed.

*Its required you stupid f-ck*

Umm, no; HHH(DD) must not change DD before embarking on a simulation
of it. What makes you think otherwise?

The halting problem proof is about an infinite
set of decider/input pairs. Linz did not prove
that there is one TM H that gets the wrong answer.

It must not change DD proper, nor any of its helper functions like HHH.

Please change your program to accept command line arguments:

   main(int argc, char **argv)
   {
     if (argc > 1) {
       if (strcmp(argv[1], "D")) {
         /* check halting of DD() directly */
         DD();
         puts("DD halted");
       } else if (strcmp(argv[1], "H"))) {
         /* ask HHH */
         if (HHH(DD)) {
           puts("HHH says DD halts")
         } else {
           puts("HHH says DD doesn't halt")
         }
      }
   }

Show the trace/output with the D arguent and then with the H argument.

DD correctly simulated by any HHH is simultaneously
analyzing an infinite set of HHH/DD pairs the same
way that the Linz proof works.

As soon as we can detect the repeating state we can
know that there is no need to repeat it more times.
The same pattern applies to any number of repeats.

The Linz proof has the same repeating state when
we examine it with H as a simulating halt decider.
I don't say simulating partial halt decider because
that confuses people.

Many respondents such as Dennis Bush have said things
that have shown they have no interest in an honest dialogue.
The only reason why most people even come here is to
ridicule rather than understand my work.

Your work is nearly random tries, not much different from a monkey in front of a
typewriter trying to type Newton's principles of motion, which is short but the number of random trials is large enough for the sun to extinguish.
Most of all, since you don't know the math/logic and what they mean. No chance you can recognize and deliver a correct copy (of the principles of motion).
So the 'refutation' of Halting Problem. You cannot fulfill what you wish. Learn the basic first.

Do not touch the code in between the two truns, or so much as recompile anything.

If your stuff is correct, then since the H command produces "HHH says D doens't halt" then we expect that the D command produces no output; it hangs forever, never reaching the "D halted" message.

--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 8/21/2025 10:14 PM, wij wrote:

On Thu, 2025-08-21 at 21:20 -0500, olcott wrote:

On 8/21/2025 8:57 PM, Kaz Kylheku wrote:

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

On 8/21/2025 6:40 PM, dbush wrote:

On 8/21/2025 6:12 PM, olcott wrote:

On 8/21/2025 5:08 PM, dbush wrote:

On 8/21/2025 5:58 PM, olcott wrote:

On 8/21/2025 4:44 PM, dbush wrote:

On 8/21/2025 5:34 PM, olcott wrote:

I am not sure whether or not you understand
that DD correctly simulated by HHH, DD() and HHH(DD)
would never stop running unless aborted

i.e. if you change the input so that HHH doesn't abort.

Changing the input is not allowed.

Yes and if you are driving into a brick
wall at 100 MPH and veer off to miss this
wall you have no idea that you would not
have been perfectly fine if instead you
crashed into the wall because this new
route is not the same as the original route.

A bad analogy is less then no rebuttal.

Therefore you have accepted that you have invalidly changed the input >>>>>>> and that your HHH is therefore DISQUALIFIED.

Its easy to see that DD correctly simulated by
any HHH

Changes the input.

Changing the input is not allowed.

*Its required you stupid f-ck*

Umm, no; HHH(DD) must not change DD before embarking on a simulation
of it. What makes you think otherwise?

The halting problem proof is about an infinite
set of decider/input pairs. Linz did not prove
that there is one TM H that gets the wrong answer.

It must not change DD proper, nor any of its helper functions like HHH.

Please change your program to accept command line arguments:

   main(int argc, char **argv)
   {
     if (argc > 1) {
       if (strcmp(argv[1], "D")) {
         /* check halting of DD() directly */
         DD();
         puts("DD halted");
       } else if (strcmp(argv[1], "H"))) {
         /* ask HHH */
         if (HHH(DD)) {
           puts("HHH says DD halts")
         } else {
           puts("HHH says DD doesn't halt")
         }
      }
   }

Show the trace/output with the D arguent and then with the H argument.

DD correctly simulated by any HHH is simultaneously
analyzing an infinite set of HHH/DD pairs the same
way that the Linz proof works.

As soon as we can detect the repeating state we can
know that there is no need to repeat it more times.
The same pattern applies to any number of repeats.

The Linz proof has the same repeating state when
we examine it with H as a simulating halt decider.
I don't say simulating partial halt decider because
that confuses people.

Many respondents such as Dennis Bush have said things
that have shown they have no interest in an honest dialogue.
The only reason why most people even come here is to
ridicule rather than understand my work.

Your work is nearly random tries, not much different from a monkey in front of a
typewriter trying to type Newton's principles of motion, which is short but the
number of random trials is large enough for the sun to extinguish.
Most of all, since you don't know the math/logic and what they mean. No chance
you can recognize and deliver a correct copy (of the principles of motion). So the 'refutation' of Halting Problem. You cannot fulfill what you wish.

Learn the basic first.

I have a much deeper philosophical understanding
than people here that only learn by rote can possibly
imagine.
--
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

From Newsgroup: comp.theory

On Thu, 21 Aug 2025 22:23:16 -0500, olcott wrote:

On 8/21/2025 10:14 PM, wij wrote:

On Thu, 2025-08-21 at 21:20 -0500, olcott wrote:

On 8/21/2025 8:57 PM, Kaz Kylheku wrote:

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

On 8/21/2025 6:40 PM, dbush wrote:

On 8/21/2025 6:12 PM, olcott wrote:

On 8/21/2025 5:08 PM, dbush wrote:

On 8/21/2025 5:58 PM, olcott wrote:

On 8/21/2025 4:44 PM, dbush wrote:

On 8/21/2025 5:34 PM, olcott wrote:

I am not sure whether or not you understand that DD correctly >>>>>>>>>>> simulated by HHH, DD() and HHH(DD)
would never stop running unless aborted

i.e. if you change the input so that HHH doesn't abort.

Changing the input is not allowed.

Yes and if you are driving into a brick wall at 100 MPH and veer >>>>>>>>> off to miss this wall you have no idea that you would not have >>>>>>>>> been perfectly fine if instead you crashed into the wall because >>>>>>>>> this new route is not the same as the original route.

A bad analogy is less then no rebuttal.

Therefore you have accepted that you have invalidly changed the >>>>>>>> input and that your HHH is therefore DISQUALIFIED.

Its easy to see that DD correctly simulated by any HHH

Changes the input.

Changing the input is not allowed.

*Its required you stupid f-ck*

Umm, no; HHH(DD) must not change DD before embarking on a simulation
of it. What makes you think otherwise?

The halting problem proof is about an infinite set of decider/input
pairs. Linz did not prove that there is one TM H that gets the wrong
answer.

It must not change DD proper, nor any of its helper functions like
HHH.

Please change your program to accept command line arguments:

   main(int argc, char **argv)
   {
     if (argc > 1) {
       if (strcmp(argv[1], "D")) {
         /* check halting of DD() directly */
         DD();
         puts("DD halted");
       } else if (strcmp(argv[1], "H"))) {
         /* ask HHH */
         if (HHH(DD)) {
           puts("HHH says DD halts")
         } else {
           puts("HHH says DD doesn't halt")
         }
      }
   }

Show the trace/output with the D arguent and then with the H
argument.

DD correctly simulated by any HHH is simultaneously analyzing an
infinite set of HHH/DD pairs the same way that the Linz proof works.

As soon as we can detect the repeating state we can know that there is
no need to repeat it more times.
The same pattern applies to any number of repeats.

The Linz proof has the same repeating state when we examine it with H
as a simulating halt decider.
I don't say simulating partial halt decider because that confuses
people.

Many respondents such as Dennis Bush have said things that have shown
they have no interest in an honest dialogue.
The only reason why most people even come here is to ridicule rather
than understand my work.

Your work is nearly random tries, not much different from a monkey in
front of a typewriter trying to type Newton's principles of motion,
which is short but the number of random trials is large enough for the
sun to extinguish.
Most of all, since you don't know the math/logic and what they mean. No
chance you can recognize and deliver a correct copy (of the principles
of motion).
So the 'refutation' of Halting Problem. You cannot fulfill what you
wish.

Learn the basic first.

I have a much deeper philosophical understanding than people here that
only learn by rote can possibly imagine.

People here are not relying on what they might have learnt by rote, they
are instead relying on logic, something that you appear to be incapable of.

/Flibble
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On Thu, 2025-08-21 at 22:23 -0500, olcott wrote:

On 8/21/2025 10:14 PM, wij wrote:

On Thu, 2025-08-21 at 21:20 -0500, olcott wrote:

On 8/21/2025 8:57 PM, Kaz Kylheku wrote:

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

On 8/21/2025 6:40 PM, dbush wrote:

On 8/21/2025 6:12 PM, olcott wrote:

On 8/21/2025 5:08 PM, dbush wrote:

On 8/21/2025 5:58 PM, olcott wrote:

On 8/21/2025 4:44 PM, dbush wrote:

On 8/21/2025 5:34 PM, olcott wrote:

I am not sure whether or not you understand
that DD correctly simulated by HHH, DD() and HHH(DD) would never stop running unless aborted

i.e. if you change the input so that HHH doesn't abort.

Changing the input is not allowed.

Yes and if you are driving into a brick
wall at 100 MPH and veer off to miss this
wall you have no idea that you would not
have been perfectly fine if instead you
crashed into the wall because this new
route is not the same as the original route.

A bad analogy is less then no rebuttal.

Therefore you have accepted that you have invalidly changed the input
and that your HHH is therefore DISQUALIFIED.

Its easy to see that DD correctly simulated by
any HHH

Changes the input.

Changing the input is not allowed.

*Its required you stupid f-ck*

Umm, no; HHH(DD) must not change DD before embarking on a simulation
of it. What makes you think otherwise?

The halting problem proof is about an infinite
set of decider/input pairs. Linz did not prove
that there is one TM H that gets the wrong answer.

It must not change DD proper, nor any of its helper functions like HHH.

Please change your program to accept command line arguments:

    main(int argc, char **argv)
    {
      if (argc > 1) {
        if (strcmp(argv[1], "D")) {
          /* check halting of DD() directly */           DD();
          puts("DD halted");
        } else if (strcmp(argv[1], "H"))) {
          /* ask HHH */
          if (HHH(DD)) {
            puts("HHH says DD halts")
          } else {
            puts("HHH says DD doesn't halt")           }
       }
    }

Show the trace/output with the D arguent and then with the H argument.

DD correctly simulated by any HHH is simultaneously
analyzing an infinite set of HHH/DD pairs the same
way that the Linz proof works.

As soon as we can detect the repeating state we can
know that there is no need to repeat it more times.
The same pattern applies to any number of repeats.

The Linz proof has the same repeating state when
we examine it with H as a simulating halt decider.
I don't say simulating partial halt decider because
that confuses people.

Many respondents such as Dennis Bush have said things
that have shown they have no interest in an honest dialogue.
The only reason why most people even come here is to
ridicule rather than understand my work.

Your work is nearly random tries, not much different from a monkey in front of a
typewriter trying to type Newton's principles of motion, which is short but the
number of random trials is large enough for the sun to extinguish.
Most of all, since you don't know the math/logic and what they mean. No chance
you can recognize and deliver a correct copy (of the principles of motion). So the 'refutation' of Halting Problem. You cannot fulfill what you wish.

Learn the basic first.

I have a much deeper philosophical understanding
than people here that only learn by rote can possibly
imagine.

I know you read a lot of materials. But all evidences show that you
do not know the basic logic (even fact). Would you like to try?
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 8/21/2025 10:26 PM, Mr Flibble wrote:

On Thu, 21 Aug 2025 22:23:16 -0500, olcott wrote:

On 8/21/2025 10:14 PM, wij wrote:

On Thu, 2025-08-21 at 21:20 -0500, olcott wrote:

On 8/21/2025 8:57 PM, Kaz Kylheku wrote:

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

On 8/21/2025 6:40 PM, dbush wrote:

On 8/21/2025 6:12 PM, olcott wrote:

On 8/21/2025 5:08 PM, dbush wrote:

On 8/21/2025 5:58 PM, olcott wrote:

On 8/21/2025 4:44 PM, dbush wrote:

On 8/21/2025 5:34 PM, olcott wrote:

I am not sure whether or not you understand that DD correctly >>>>>>>>>>>> simulated by HHH, DD() and HHH(DD)
would never stop running unless aborted

i.e. if you change the input so that HHH doesn't abort.

Changing the input is not allowed.

Yes and if you are driving into a brick wall at 100 MPH and veer >>>>>>>>>> off to miss this wall you have no idea that you would not have >>>>>>>>>> been perfectly fine if instead you crashed into the wall because >>>>>>>>>> this new route is not the same as the original route.

A bad analogy is less then no rebuttal.

Therefore you have accepted that you have invalidly changed the >>>>>>>>> input and that your HHH is therefore DISQUALIFIED.

Its easy to see that DD correctly simulated by any HHH

Changes the input.

Changing the input is not allowed.

*Its required you stupid f-ck*

Umm, no; HHH(DD) must not change DD before embarking on a simulation >>>>> of it. What makes you think otherwise?

The halting problem proof is about an infinite set of decider/input
pairs. Linz did not prove that there is one TM H that gets the wrong
answer.

It must not change DD proper, nor any of its helper functions like
HHH.

Please change your program to accept command line arguments:

   main(int argc, char **argv)
   {
     if (argc > 1) {
       if (strcmp(argv[1], "D")) {
         /* check halting of DD() directly */
         DD();
         puts("DD halted");
       } else if (strcmp(argv[1], "H"))) {
         /* ask HHH */
         if (HHH(DD)) {
           puts("HHH says DD halts")
         } else {
           puts("HHH says DD doesn't halt")
         }
      }
   }

Show the trace/output with the D arguent and then with the H
argument.

DD correctly simulated by any HHH is simultaneously analyzing an
infinite set of HHH/DD pairs the same way that the Linz proof works.

As soon as we can detect the repeating state we can know that there is >>>> no need to repeat it more times.
The same pattern applies to any number of repeats.

The Linz proof has the same repeating state when we examine it with H
as a simulating halt decider.
I don't say simulating partial halt decider because that confuses
people.

Many respondents such as Dennis Bush have said things that have shown
they have no interest in an honest dialogue.
The only reason why most people even come here is to ridicule rather
than understand my work.

Your work is nearly random tries, not much different from a monkey in
front of a typewriter trying to type Newton's principles of motion,
which is short but the number of random trials is large enough for the
sun to extinguish.
Most of all, since you don't know the math/logic and what they mean. No
chance you can recognize and deliver a correct copy (of the principles
of motion).
So the 'refutation' of Halting Problem. You cannot fulfill what you
wish.

Learn the basic first.

I have a much deeper philosophical understanding than people here that
only learn by rote can possibly imagine.

People here are not relying on what they might have learnt by rote, they
are instead relying on logic, something that you appear to be incapable of.

/Flibble

They never bother to go all the way to the foundations
of correct reasoning. Most all of the errors of logic
can be traced to divorcing syntax from semantics.
Relevance logic fixes a tiny bit of that.
--
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

From Newsgroup: comp.theory

On 8/21/2025 10:26 PM, wij wrote:

On Thu, 2025-08-21 at 22:23 -0500, olcott wrote:

On 8/21/2025 10:14 PM, wij wrote:

On Thu, 2025-08-21 at 21:20 -0500, olcott wrote:

On 8/21/2025 8:57 PM, Kaz Kylheku wrote:

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

On 8/21/2025 6:40 PM, dbush wrote:

On 8/21/2025 6:12 PM, olcott wrote:

On 8/21/2025 5:08 PM, dbush wrote:

On 8/21/2025 5:58 PM, olcott wrote:

On 8/21/2025 4:44 PM, dbush wrote:

On 8/21/2025 5:34 PM, olcott wrote:

I am not sure whether or not you understand
that DD correctly simulated by HHH, DD() and HHH(DD)
would never stop running unless aborted

i.e. if you change the input so that HHH doesn't abort.

Changing the input is not allowed.

Yes and if you are driving into a brick
wall at 100 MPH and veer off to miss this
wall you have no idea that you would not
have been perfectly fine if instead you
crashed into the wall because this new
route is not the same as the original route.

A bad analogy is less then no rebuttal.

Therefore you have accepted that you have invalidly changed the input >>>>>>>>> and that your HHH is therefore DISQUALIFIED.

Its easy to see that DD correctly simulated by
any HHH

Changes the input.

Changing the input is not allowed.

*Its required you stupid f-ck*

Umm, no; HHH(DD) must not change DD before embarking on a simulation >>>>> of it. What makes you think otherwise?

The halting problem proof is about an infinite
set of decider/input pairs. Linz did not prove
that there is one TM H that gets the wrong answer.

It must not change DD proper, nor any of its helper functions like HHH. >>>>>
Please change your program to accept command line arguments:

    main(int argc, char **argv)
    {
      if (argc > 1) {
        if (strcmp(argv[1], "D")) {
          /* check halting of DD() directly */
          DD();
          puts("DD halted");
        } else if (strcmp(argv[1], "H"))) {
          /* ask HHH */
          if (HHH(DD)) {
            puts("HHH says DD halts")
          } else {
            puts("HHH says DD doesn't halt")
          }
       }
    }

Show the trace/output with the D arguent and then with the H argument. >>>>>

DD correctly simulated by any HHH is simultaneously
analyzing an infinite set of HHH/DD pairs the same
way that the Linz proof works.

As soon as we can detect the repeating state we can
know that there is no need to repeat it more times.
The same pattern applies to any number of repeats.

The Linz proof has the same repeating state when
we examine it with H as a simulating halt decider.
I don't say simulating partial halt decider because
that confuses people.

Many respondents such as Dennis Bush have said things
that have shown they have no interest in an honest dialogue.
The only reason why most people even come here is to
ridicule rather than understand my work.

Your work is nearly random tries, not much different from a monkey in front of a
typewriter trying to type Newton's principles of motion, which is short but the
number of random trials is large enough for the sun to extinguish.
Most of all, since you don't know the math/logic and what they mean. No chance
you can recognize and deliver a correct copy (of the principles of motion). >>> So the 'refutation' of Halting Problem. You cannot fulfill what you wish. >>>
Learn the basic first.

I have a much deeper philosophical understanding
than people here that only learn by rote can possibly
imagine.

I know you read a lot of materials. But all evidences show that you
do not know the basic logic (even fact). Would you like to try?

Here is a puzzle for you: How is the principle of
explosion shown to be semantically incorrect.
--
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

From Newsgroup: comp.theory

On Fri, 2025-08-22 at 11:26 +0800, wij wrote:

On Thu, 2025-08-21 at 22:23 -0500, olcott wrote:

On 8/21/2025 10:14 PM, wij wrote:

On Thu, 2025-08-21 at 21:20 -0500, olcott wrote:

On 8/21/2025 8:57 PM, Kaz Kylheku wrote:

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

On 8/21/2025 6:40 PM, dbush wrote:

On 8/21/2025 6:12 PM, olcott wrote:

On 8/21/2025 5:08 PM, dbush wrote:

On 8/21/2025 5:58 PM, olcott wrote:

On 8/21/2025 4:44 PM, dbush wrote:

On 8/21/2025 5:34 PM, olcott wrote:

I am not sure whether or not you understand
that DD correctly simulated by HHH, DD() and HHH(DD) would never stop running unless aborted

i.e. if you change the input so that HHH doesn't abort.

Changing the input is not allowed.

Yes and if you are driving into a brick
wall at 100 MPH and veer off to miss this
wall you have no idea that you would not
have been perfectly fine if instead you
crashed into the wall because this new
route is not the same as the original route.

A bad analogy is less then no rebuttal.

Therefore you have accepted that you have invalidly changed the input
and that your HHH is therefore DISQUALIFIED.

Its easy to see that DD correctly simulated by
any HHH

Changes the input.

Changing the input is not allowed.

*Its required you stupid f-ck*

Umm, no; HHH(DD) must not change DD before embarking on a simulation of it. What makes you think otherwise?

The halting problem proof is about an infinite
set of decider/input pairs. Linz did not prove
that there is one TM H that gets the wrong answer.

It must not change DD proper, nor any of its helper functions like HHH.

Please change your program to accept command line arguments:

    main(int argc, char **argv)
    {
      if (argc > 1) {
        if (strcmp(argv[1], "D")) {
          /* check halting of DD() directly */           DD();
          puts("DD halted");
        } else if (strcmp(argv[1], "H"))) {
          /* ask HHH */
          if (HHH(DD)) {
            puts("HHH says DD halts")
          } else {
            puts("HHH says DD doesn't halt")           }
       }
    }

Show the trace/output with the D arguent and then with the H argument.

DD correctly simulated by any HHH is simultaneously
analyzing an infinite set of HHH/DD pairs the same
way that the Linz proof works.

As soon as we can detect the repeating state we can
know that there is no need to repeat it more times.
The same pattern applies to any number of repeats.

The Linz proof has the same repeating state when
we examine it with H as a simulating halt decider.
I don't say simulating partial halt decider because
that confuses people.

Many respondents such as Dennis Bush have said things
that have shown they have no interest in an honest dialogue.
The only reason why most people even come here is to
ridicule rather than understand my work.

Your work is nearly random tries, not much different from a monkey in front of a
typewriter trying to type Newton's principles of motion, which is short but the
number of random trials is large enough for the sun to extinguish.
Most of all, since you don't know the math/logic and what they mean. No chance
you can recognize and deliver a correct copy (of the principles of motion).
So the 'refutation' of Halting Problem. You cannot fulfill what you wish.

Learn the basic first.

I have a much deeper philosophical understanding
than people here that only learn by rote can possibly
imagine.

I know you read a lot of materials. But all evidences show that you
do not know the basic logic (even fact). Would you like to try?

Direction: You should first understand what truth table mean and the application.
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 8/21/2025 10:42 PM, wij wrote:

On Fri, 2025-08-22 at 11:26 +0800, wij wrote:

On Thu, 2025-08-21 at 22:23 -0500, olcott wrote:

On 8/21/2025 10:14 PM, wij wrote:

On Thu, 2025-08-21 at 21:20 -0500, olcott wrote:

On 8/21/2025 8:57 PM, Kaz Kylheku wrote:

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

On 8/21/2025 6:40 PM, dbush wrote:

On 8/21/2025 6:12 PM, olcott wrote:

On 8/21/2025 5:08 PM, dbush wrote:

On 8/21/2025 5:58 PM, olcott wrote:

On 8/21/2025 4:44 PM, dbush wrote:

On 8/21/2025 5:34 PM, olcott wrote:

I am not sure whether or not you understand
that DD correctly simulated by HHH, DD() and HHH(DD) >>>>>>>>>>>>> would never stop running unless aborted

i.e. if you change the input so that HHH doesn't abort. >>>>>>>>>>>>
Changing the input is not allowed.

Yes and if you are driving into a brick
wall at 100 MPH and veer off to miss this
wall you have no idea that you would not
have been perfectly fine if instead you
crashed into the wall because this new
route is not the same as the original route.

A bad analogy is less then no rebuttal.

Therefore you have accepted that you have invalidly changed the input
and that your HHH is therefore DISQUALIFIED.

Its easy to see that DD correctly simulated by
any HHH

Changes the input.

Changing the input is not allowed.

*Its required you stupid f-ck*

Umm, no; HHH(DD) must not change DD before embarking on a simulation >>>>>> of it. What makes you think otherwise?

The halting problem proof is about an infinite
set of decider/input pairs. Linz did not prove
that there is one TM H that gets the wrong answer.

It must not change DD proper, nor any of its helper functions like HHH. >>>>>>
Please change your program to accept command line arguments:

    main(int argc, char **argv)
    {
      if (argc > 1) {
        if (strcmp(argv[1], "D")) {
          /* check halting of DD() directly */
          DD();
          puts("DD halted");
        } else if (strcmp(argv[1], "H"))) {
          /* ask HHH */
          if (HHH(DD)) {
            puts("HHH says DD halts")
          } else {
            puts("HHH says DD doesn't halt")
          }
       }
    }

Show the trace/output with the D arguent and then with the H argument. >>>>>>

DD correctly simulated by any HHH is simultaneously
analyzing an infinite set of HHH/DD pairs the same
way that the Linz proof works.

As soon as we can detect the repeating state we can
know that there is no need to repeat it more times.
The same pattern applies to any number of repeats.

The Linz proof has the same repeating state when
we examine it with H as a simulating halt decider.
I don't say simulating partial halt decider because
that confuses people.

Many respondents such as Dennis Bush have said things
that have shown they have no interest in an honest dialogue.
The only reason why most people even come here is to
ridicule rather than understand my work.

Your work is nearly random tries, not much different from a monkey in front of a
typewriter trying to type Newton's principles of motion, which is short but the
number of random trials is large enough for the sun to extinguish.
Most of all, since you don't know the math/logic and what they mean. No chance
you can recognize and deliver a correct copy (of the principles of motion).
So the 'refutation' of Halting Problem. You cannot fulfill what you wish. >>>>
Learn the basic first.

I have a much deeper philosophical understanding
than people here that only learn by rote can possibly
imagine.

I know you read a lot of materials. But all evidences show that you
do not know the basic logic (even fact). Would you like to try?

Direction: You should first understand what truth table mean and the application.

I know these things far better than you do.
--
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

From Newsgroup: comp.theory

On Thu, 21 Aug 2025 22:40:33 -0500, olcott wrote:

On 8/21/2025 10:26 PM, Mr Flibble wrote:

On Thu, 21 Aug 2025 22:23:16 -0500, olcott wrote:

On 8/21/2025 10:14 PM, wij wrote:

On Thu, 2025-08-21 at 21:20 -0500, olcott wrote:

On 8/21/2025 8:57 PM, Kaz Kylheku wrote:

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

On 8/21/2025 6:40 PM, dbush wrote:

On 8/21/2025 6:12 PM, olcott wrote:

On 8/21/2025 5:08 PM, dbush wrote:

On 8/21/2025 5:58 PM, olcott wrote:

On 8/21/2025 4:44 PM, dbush wrote:

On 8/21/2025 5:34 PM, olcott wrote:

I am not sure whether or not you understand that DD
correctly simulated by HHH, DD() and HHH(DD)
would never stop running unless aborted

i.e. if you change the input so that HHH doesn't abort. >>>>>>>>>>>>
Changing the input is not allowed.

Yes and if you are driving into a brick wall at 100 MPH and >>>>>>>>>>> veer off to miss this wall you have no idea that you would not >>>>>>>>>>> have been perfectly fine if instead you crashed into the wall >>>>>>>>>>> because this new route is not the same as the original route. >>>>>>>>>>>

A bad analogy is less then no rebuttal.

Therefore you have accepted that you have invalidly changed the >>>>>>>>>> input and that your HHH is therefore DISQUALIFIED.

Its easy to see that DD correctly simulated by any HHH

Changes the input.

Changing the input is not allowed.

*Its required you stupid f-ck*

Umm, no; HHH(DD) must not change DD before embarking on a
simulation of it. What makes you think otherwise?

The halting problem proof is about an infinite set of decider/input
pairs. Linz did not prove that there is one TM H that gets the wrong >>>>> answer.

It must not change DD proper, nor any of its helper functions like >>>>>> HHH.

Please change your program to accept command line arguments:

   main(int argc, char **argv)
   {
     if (argc > 1) {
       if (strcmp(argv[1], "D")) {
         /* check halting of DD() directly */
         DD();
         puts("DD halted");
       } else if (strcmp(argv[1], "H"))) {
         /* ask HHH */
         if (HHH(DD)) {
           puts("HHH says DD halts")
         } else {
           puts("HHH says DD doesn't halt")
         }
      }
   }

Show the trace/output with the D arguent and then with the H
argument.

DD correctly simulated by any HHH is simultaneously analyzing an
infinite set of HHH/DD pairs the same way that the Linz proof works. >>>>>
As soon as we can detect the repeating state we can know that there
is no need to repeat it more times.
The same pattern applies to any number of repeats.

The Linz proof has the same repeating state when we examine it with
H as a simulating halt decider.
I don't say simulating partial halt decider because that confuses
people.

Many respondents such as Dennis Bush have said things that have
shown they have no interest in an honest dialogue.
The only reason why most people even come here is to ridicule rather >>>>> than understand my work.

Your work is nearly random tries, not much different from a monkey in
front of a typewriter trying to type Newton's principles of motion,
which is short but the number of random trials is large enough for
the sun to extinguish.
Most of all, since you don't know the math/logic and what they mean.
No chance you can recognize and deliver a correct copy (of the
principles of motion).
So the 'refutation' of Halting Problem. You cannot fulfill what you
wish.

Learn the basic first.

I have a much deeper philosophical understanding than people here that
only learn by rote can possibly imagine.

People here are not relying on what they might have learnt by rote,
they are instead relying on logic, something that you appear to be
incapable of.

/Flibble

They never bother to go all the way to the foundations of correct
reasoning. Most all of the errors of logic can be traced to divorcing
syntax from semantics. Relevance logic fixes a tiny bit of that.

Word salad.

/Flibble
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On Thu, 2025-08-21 at 22:41 -0500, olcott wrote:

On 8/21/2025 10:26 PM, wij wrote:

On Thu, 2025-08-21 at 22:23 -0500, olcott wrote:

On 8/21/2025 10:14 PM, wij wrote:

On Thu, 2025-08-21 at 21:20 -0500, olcott wrote:

On 8/21/2025 8:57 PM, Kaz Kylheku wrote:

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

On 8/21/2025 6:40 PM, dbush wrote:

On 8/21/2025 6:12 PM, olcott wrote:

On 8/21/2025 5:08 PM, dbush wrote:

On 8/21/2025 5:58 PM, olcott wrote:

On 8/21/2025 4:44 PM, dbush wrote:

On 8/21/2025 5:34 PM, olcott wrote:

I am not sure whether or not you understand
that DD correctly simulated by HHH, DD() and HHH(DD) would never stop running unless aborted

i.e. if you change the input so that HHH doesn't abort.

Changing the input is not allowed.

Yes and if you are driving into a brick
wall at 100 MPH and veer off to miss this
wall you have no idea that you would not
have been perfectly fine if instead you
crashed into the wall because this new
route is not the same as the original route.

A bad analogy is less then no rebuttal.

Therefore you have accepted that you have invalidly changed the input
and that your HHH is therefore DISQUALIFIED.

Its easy to see that DD correctly simulated by
any HHH

Changes the input.

Changing the input is not allowed.

*Its required you stupid f-ck*

Umm, no; HHH(DD) must not change DD before embarking on a simulation
of it. What makes you think otherwise?

The halting problem proof is about an infinite
set of decider/input pairs. Linz did not prove
that there is one TM H that gets the wrong answer.

It must not change DD proper, nor any of its helper functions like HHH.

Please change your program to accept command line arguments:

     main(int argc, char **argv)
     {
       if (argc > 1) {
         if (strcmp(argv[1], "D")) {
           /* check halting of DD() directly */            DD();
           puts("DD halted");
         } else if (strcmp(argv[1], "H"))) {            /* ask HHH */
           if (HHH(DD)) {
             puts("HHH says DD halts")            } else {
             puts("HHH says DD doesn't halt")            }
        }
     }

Show the trace/output with the D arguent and then with the H argument.

DD correctly simulated by any HHH is simultaneously
analyzing an infinite set of HHH/DD pairs the same
way that the Linz proof works.

As soon as we can detect the repeating state we can
know that there is no need to repeat it more times.
The same pattern applies to any number of repeats.

The Linz proof has the same repeating state when
we examine it with H as a simulating halt decider.
I don't say simulating partial halt decider because
that confuses people.

Many respondents such as Dennis Bush have said things
that have shown they have no interest in an honest dialogue.
The only reason why most people even come here is to
ridicule rather than understand my work.

Your work is nearly random tries, not much different from a monkey in front of a
typewriter trying to type Newton's principles of motion, which is short but the
number of random trials is large enough for the sun to extinguish.
Most of all, since you don't know the math/logic and what they mean. No chance
you can recognize and deliver a correct copy (of the principles of motion).
So the 'refutation' of Halting Problem. You cannot fulfill what you wish.

Learn the basic first.

I have a much deeper philosophical understanding
than people here that only learn by rote can possibly
imagine.

I know you read a lot of materials. But all evidences show that you
do not know the basic logic (even fact). Would you like to try?

Here is a puzzle for you: How is the principle of
explosion shown to be semantically incorrect.

I fist learn the term "the principle of explosion" from this discussion. https://en.wikipedia.org/wiki/Principle_of_explosion
It looks like a simple application of logic-IF (these wiki seems like to make simple thing 'academic'). logic-IF is not a puzzle. I see it as merely a convention,
but universal. I don't read all the wiki definition. But yes from false premise you
can deduce anything.
And I remembered you failed to show you understand logic-IF, Would you like to try again?
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 8/21/2025 10:55 PM, wij wrote:

On Thu, 2025-08-21 at 22:41 -0500, olcott wrote:

On 8/21/2025 10:26 PM, wij wrote:

On Thu, 2025-08-21 at 22:23 -0500, olcott wrote:

On 8/21/2025 10:14 PM, wij wrote:

On Thu, 2025-08-21 at 21:20 -0500, olcott wrote:

On 8/21/2025 8:57 PM, Kaz Kylheku wrote:

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

On 8/21/2025 6:40 PM, dbush wrote:

On 8/21/2025 6:12 PM, olcott wrote:

On 8/21/2025 5:08 PM, dbush wrote:

On 8/21/2025 5:58 PM, olcott wrote:

On 8/21/2025 4:44 PM, dbush wrote:

On 8/21/2025 5:34 PM, olcott wrote:

I am not sure whether or not you understand
that DD correctly simulated by HHH, DD() and HHH(DD) >>>>>>>>>>>>>> would never stop running unless aborted

i.e. if you change the input so that HHH doesn't abort. >>>>>>>>>>>>>
Changing the input is not allowed.

Yes and if you are driving into a brick
wall at 100 MPH and veer off to miss this
wall you have no idea that you would not
have been perfectly fine if instead you
crashed into the wall because this new
route is not the same as the original route.

A bad analogy is less then no rebuttal.

Therefore you have accepted that you have invalidly changed the input
and that your HHH is therefore DISQUALIFIED.

Its easy to see that DD correctly simulated by
any HHH

Changes the input.

Changing the input is not allowed.

*Its required you stupid f-ck*

Umm, no; HHH(DD) must not change DD before embarking on a simulation >>>>>>> of it. What makes you think otherwise?

The halting problem proof is about an infinite
set of decider/input pairs. Linz did not prove
that there is one TM H that gets the wrong answer.

It must not change DD proper, nor any of its helper functions like HHH. >>>>>>>
Please change your program to accept command line arguments:

     main(int argc, char **argv)
     {
       if (argc > 1) {
         if (strcmp(argv[1], "D")) {
           /* check halting of DD() directly */
           DD();
           puts("DD halted");
         } else if (strcmp(argv[1], "H"))) {
           /* ask HHH */
           if (HHH(DD)) {
             puts("HHH says DD halts")
           } else {
             puts("HHH says DD doesn't halt")
           }
        }
     }

Show the trace/output with the D arguent and then with the H argument. >>>>>>>

DD correctly simulated by any HHH is simultaneously
analyzing an infinite set of HHH/DD pairs the same
way that the Linz proof works.

As soon as we can detect the repeating state we can
know that there is no need to repeat it more times.
The same pattern applies to any number of repeats.

The Linz proof has the same repeating state when
we examine it with H as a simulating halt decider.
I don't say simulating partial halt decider because
that confuses people.

Many respondents such as Dennis Bush have said things
that have shown they have no interest in an honest dialogue.
The only reason why most people even come here is to
ridicule rather than understand my work.

Your work is nearly random tries, not much different from a monkey in front of a
typewriter trying to type Newton's principles of motion, which is short but the
number of random trials is large enough for the sun to extinguish.
Most of all, since you don't know the math/logic and what they mean. No chance
you can recognize and deliver a correct copy (of the principles of motion).
So the 'refutation' of Halting Problem. You cannot fulfill what you wish. >>>>>
Learn the basic first.

I have a much deeper philosophical understanding
than people here that only learn by rote can possibly
imagine.

I know you read a lot of materials. But all evidences show that you
do not know the basic logic (even fact). Would you like to try?

Here is a puzzle for you: How is the principle of
explosion shown to be semantically incorrect.

I fist learn the term "the principle of explosion" from this discussion. https://en.wikipedia.org/wiki/Principle_of_explosion

It looks like a simple application of logic-IF (these wiki seems like to make simple thing 'academic'). logic-IF is not a puzzle. I see it as merely a convention,
but universal. I don't read all the wiki definition. But yes from false premise you
can deduce anything.

And I remembered you failed to show you understand logic-IF, Would you like to try again?

Also you failed to show that you understand
first grade arithmetic. Do you know what a number is?
--
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

From Newsgroup: comp.theory

On Thu, 2025-08-21 at 23:01 -0500, olcott wrote:

On 8/21/2025 10:55 PM, wij wrote:

On Thu, 2025-08-21 at 22:41 -0500, olcott wrote:

On 8/21/2025 10:26 PM, wij wrote:

On Thu, 2025-08-21 at 22:23 -0500, olcott wrote:

On 8/21/2025 10:14 PM, wij wrote:

On Thu, 2025-08-21 at 21:20 -0500, olcott wrote:

On 8/21/2025 8:57 PM, Kaz Kylheku wrote:

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

On 8/21/2025 6:40 PM, dbush wrote:

On 8/21/2025 6:12 PM, olcott wrote:

On 8/21/2025 5:08 PM, dbush wrote:

On 8/21/2025 5:58 PM, olcott wrote:

On 8/21/2025 4:44 PM, dbush wrote:

On 8/21/2025 5:34 PM, olcott wrote:

I am not sure whether or not you understand
that DD correctly simulated by HHH, DD() and HHH(DD)
would never stop running unless aborted

i.e. if you change the input so that HHH doesn't abort.

Changing the input is not allowed.

Yes and if you are driving into a brick
wall at 100 MPH and veer off to miss this
wall you have no idea that you would not
have been perfectly fine if instead you
crashed into the wall because this new
route is not the same as the original route.

A bad analogy is less then no rebuttal.

Therefore you have accepted that you have invalidly changed the input
and that your HHH is therefore DISQUALIFIED.

Its easy to see that DD correctly simulated by
any HHH

Changes the input.

Changing the input is not allowed.

*Its required you stupid f-ck*

Umm, no; HHH(DD) must not change DD before embarking on a simulation
of it. What makes you think otherwise?

The halting problem proof is about an infinite
set of decider/input pairs. Linz did not prove
that there is one TM H that gets the wrong answer.

It must not change DD proper, nor any of its helper functions like HHH.

Please change your program to accept command line arguments:

      main(int argc, char **argv)
      {
        if (argc > 1) {
          if (strcmp(argv[1], "D")) {             /* check halting of DD() directly */             DD();
            puts("DD halted");
          } else if (strcmp(argv[1], "H"))) {             /* ask HHH */
            if (HHH(DD)) {               puts("HHH says DD halts")             } else {
              puts("HHH says DD doesn't halt")             }
         }
      }

Show the trace/output with the D arguent and then with the H argument.

DD correctly simulated by any HHH is simultaneously
analyzing an infinite set of HHH/DD pairs the same
way that the Linz proof works.

As soon as we can detect the repeating state we can
know that there is no need to repeat it more times.
The same pattern applies to any number of repeats.

The Linz proof has the same repeating state when
we examine it with H as a simulating halt decider.
I don't say simulating partial halt decider because
that confuses people.

Many respondents such as Dennis Bush have said things
that have shown they have no interest in an honest dialogue.
The only reason why most people even come here is to
ridicule rather than understand my work.

Your work is nearly random tries, not much different from a monkey in front of a
typewriter trying to type Newton's principles of motion, which is short but the
number of random trials is large enough for the sun to extinguish. Most of all, since you don't know the math/logic and what they mean. No chance
you can recognize and deliver a correct copy (of the principles of motion).
So the 'refutation' of Halting Problem. You cannot fulfill what you wish.

Learn the basic first.

I have a much deeper philosophical understanding
than people here that only learn by rote can possibly
imagine.

I know you read a lot of materials. But all evidences show that you
do not know the basic logic (even fact). Would you like to try?

Here is a puzzle for you: How is the principle of
explosion shown to be semantically incorrect.

I fist learn the term "the principle of explosion" from this discussion. https://en.wikipedia.org/wiki/Principle_of_explosion

It looks like a simple application of logic-IF (these wiki seems like to make
simple thing 'academic'). logic-IF is not a puzzle. I see it as merely a convention,
but universal. I don't read all the wiki definition. But yes from false premise you
can deduce anything.

And I remembered you failed to show you understand logic-IF, Would you like to try again?

Note: A sentence of my previous reply is not precise enough.

Also you failed to show that you understand
first grade arithmetic. 

What is "first grade arithmetic"?

Do you know what a number is?

0,1,2,....
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On Fri, 2025-08-22 at 12:07 +0800, wij wrote:

On Thu, 2025-08-21 at 23:01 -0500, olcott wrote:

On 8/21/2025 10:55 PM, wij wrote:

On Thu, 2025-08-21 at 22:41 -0500, olcott wrote:

On 8/21/2025 10:26 PM, wij wrote:

On Thu, 2025-08-21 at 22:23 -0500, olcott wrote:

On 8/21/2025 10:14 PM, wij wrote:

On Thu, 2025-08-21 at 21:20 -0500, olcott wrote:

On 8/21/2025 8:57 PM, Kaz Kylheku wrote:

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

On 8/21/2025 6:40 PM, dbush wrote:

On 8/21/2025 6:12 PM, olcott wrote:

On 8/21/2025 5:08 PM, dbush wrote:

On 8/21/2025 5:58 PM, olcott wrote:

On 8/21/2025 4:44 PM, dbush wrote:

On 8/21/2025 5:34 PM, olcott wrote:

I am not sure whether or not you understand that DD correctly simulated by HHH, DD() and HHH(DD)
would never stop running unless aborted

i.e. if you change the input so that HHH doesn't abort.

Changing the input is not allowed.

Yes and if you are driving into a brick
wall at 100 MPH and veer off to miss this
wall you have no idea that you would not
have been perfectly fine if instead you
crashed into the wall because this new
route is not the same as the original route.

A bad analogy is less then no rebuttal.

Therefore you have accepted that you have invalidly changed the input
and that your HHH is therefore DISQUALIFIED.

Its easy to see that DD correctly simulated by
any HHH

Changes the input.

Changing the input is not allowed.

*Its required you stupid f-ck*

Umm, no; HHH(DD) must not change DD before embarking on a simulation
of it. What makes you think otherwise?

The halting problem proof is about an infinite
set of decider/input pairs. Linz did not prove
that there is one TM H that gets the wrong answer.

It must not change DD proper, nor any of its helper functions like HHH.

Please change your program to accept command line arguments:

      main(int argc, char **argv)
      {
        if (argc > 1) {
          if (strcmp(argv[1], "D")) {             /* check halting of DD() directly */             DD();
            puts("DD halted");
          } else if (strcmp(argv[1], "H"))) {             /* ask HHH */
            if (HHH(DD)) {               puts("HHH says DD halts")             } else {
              puts("HHH says DD doesn't halt")             }
         }
      }

Show the trace/output with the D arguent and then with the H argument.

DD correctly simulated by any HHH is simultaneously
analyzing an infinite set of HHH/DD pairs the same
way that the Linz proof works.

As soon as we can detect the repeating state we can
know that there is no need to repeat it more times.
The same pattern applies to any number of repeats.

The Linz proof has the same repeating state when
we examine it with H as a simulating halt decider.
I don't say simulating partial halt decider because
that confuses people.

Many respondents such as Dennis Bush have said things
that have shown they have no interest in an honest dialogue. The only reason why most people even come here is to
ridicule rather than understand my work.

Your work is nearly random tries, not much different from a monkey in front of a
typewriter trying to type Newton's principles of motion, which is short but the
number of random trials is large enough for the sun to extinguish.
Most of all, since you don't know the math/logic and what they mean. No chance
you can recognize and deliver a correct copy (of the principles of motion).
So the 'refutation' of Halting Problem. You cannot fulfill what you wish.

Learn the basic first.

I have a much deeper philosophical understanding
than people here that only learn by rote can possibly
imagine.

I know you read a lot of materials. But all evidences show that you do not know the basic logic (even fact). Would you like to try?

Here is a puzzle for you: How is the principle of
explosion shown to be semantically incorrect.

I fist learn the term "the principle of explosion" from this discussion. https://en.wikipedia.org/wiki/Principle_of_explosion

It looks like a simple application of logic-IF (these wiki seems like to make
simple thing 'academic'). logic-IF is not a puzzle. I see it as merely a convention,
but universal. I don't read all the wiki definition. But yes from false premise you
can deduce anything.

And I remembered you failed to show you understand logic-IF, Would you like to try again?

Note: A sentence of my previous reply is not precise enough.

Also you failed to show that you understand
first grade arithmetic. 

What is "first grade arithmetic"?

I found from google. It should mean 30-20=10, 30+1=31,...
What are you asking for?

Do you know what a number is?

0,1,2,.... 

--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On Thu, 2025-08-21 at 22:43 -0500, olcott wrote:

On 8/21/2025 10:42 PM, wij wrote:

On Fri, 2025-08-22 at 11:26 +0800, wij wrote:

On Thu, 2025-08-21 at 22:23 -0500, olcott wrote:

On 8/21/2025 10:14 PM, wij wrote:

On Thu, 2025-08-21 at 21:20 -0500, olcott wrote:

On 8/21/2025 8:57 PM, Kaz Kylheku wrote:

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

On 8/21/2025 6:40 PM, dbush wrote:

On 8/21/2025 6:12 PM, olcott wrote:

On 8/21/2025 5:08 PM, dbush wrote:

On 8/21/2025 5:58 PM, olcott wrote:

On 8/21/2025 4:44 PM, dbush wrote:

On 8/21/2025 5:34 PM, olcott wrote:

I am not sure whether or not you understand
that DD correctly simulated by HHH, DD() and HHH(DD)
would never stop running unless aborted

i.e. if you change the input so that HHH doesn't abort.

Changing the input is not allowed.

Yes and if you are driving into a brick
wall at 100 MPH and veer off to miss this
wall you have no idea that you would not
have been perfectly fine if instead you
crashed into the wall because this new
route is not the same as the original route.

A bad analogy is less then no rebuttal.

Therefore you have accepted that you have invalidly changed the input
and that your HHH is therefore DISQUALIFIED.

Its easy to see that DD correctly simulated by
any HHH

Changes the input.

Changing the input is not allowed.

*Its required you stupid f-ck*

Umm, no; HHH(DD) must not change DD before embarking on a simulation
of it. What makes you think otherwise?

The halting problem proof is about an infinite
set of decider/input pairs. Linz did not prove
that there is one TM H that gets the wrong answer.

It must not change DD proper, nor any of its helper functions like HHH.

Please change your program to accept command line arguments:

     main(int argc, char **argv)
     {
       if (argc > 1) {
         if (strcmp(argv[1], "D")) {
           /* check halting of DD() directly */            DD();
           puts("DD halted");
         } else if (strcmp(argv[1], "H"))) {            /* ask HHH */
           if (HHH(DD)) {
             puts("HHH says DD halts")            } else {
             puts("HHH says DD doesn't halt")            }
        }
     }

Show the trace/output with the D arguent and then with the H argument.

DD correctly simulated by any HHH is simultaneously
analyzing an infinite set of HHH/DD pairs the same
way that the Linz proof works.

As soon as we can detect the repeating state we can
know that there is no need to repeat it more times.
The same pattern applies to any number of repeats.

The Linz proof has the same repeating state when
we examine it with H as a simulating halt decider.
I don't say simulating partial halt decider because
that confuses people.

Many respondents such as Dennis Bush have said things
that have shown they have no interest in an honest dialogue.
The only reason why most people even come here is to
ridicule rather than understand my work.

Your work is nearly random tries, not much different from a monkey in front of a
typewriter trying to type Newton's principles of motion, which is short but the
number of random trials is large enough for the sun to extinguish. Most of all, since you don't know the math/logic and what they mean. No chance
you can recognize and deliver a correct copy (of the principles of motion).
So the 'refutation' of Halting Problem. You cannot fulfill what you wish.

Learn the basic first.

I have a much deeper philosophical understanding
than people here that only learn by rote can possibly
imagine.

I know you read a lot of materials. But all evidences show that you
do not know the basic logic (even fact). Would you like to try?

Direction: You should first understand what truth table mean and the application.

I know these things far better than you do.

O,Ye? 
Q: What is the value of proposition X&~X, why? True,False (or Undecidable if none fits)
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 22/08/2025 03:55, olcott wrote:

On 8/21/2025 9:44 PM, Richard Heathfield wrote:

On 22/08/2025 03:20, olcott wrote:

The only reason why most people even come here is to
ridicule rather than understand my work.

You bring people here when you cross-post into other groups.
You brought me here. I didn't come here to ridicule you (hard
though it sometimes is to fight the temptation), but to try to
help you understand that you are mistaken.

And you are.

When you start with the fundamental assumption
that I am mistaken then you become subject to
the error of confirmation bias.

To be fair, we have a proof.

This causes you
to ignore key points that prove I am not mistaken.

And your own certainty blinds you to the many key points that
have been raised to show you that you are.

Stupid nonsense like your macro proves that you
have no intention of any honest dialogue.

That attitude does you no favours.

My macro is indeed an attempt at honest dialogue. It's an attempt
to focus discussion on the DD code, where it belongs. The
intricacies of HHH can and do get in the way of the actual
question. HHH, you claim, correctly returns 0. Fine! Let it! And
let's watch what happens next. That's the point of the macro.

To call it "stupid nonsense" demonstrates very clearly that you
are not interested in the truth; you are only interested in
gainsaying valid perspectives by claiming that anyone who
disagrees with you is stupid, dishonest, or both. That is not how
proofs are constructed. The purpose of a proof is to persuade
one's audience of a truth. One doesn't do that by saying "Hey!
Stupid! Admit I'm right, you lying blaggard!"

How can you expect respect from your peers --- almost certainly
all of them adults and many of them professional programmers ---
when you behave like a 6-year-old playground tyrant?
--
Richard Heathfield
Email: rjh at cpax dot org dot uk
"Usenet is a strange place" - dmr 29 July 1999
Sig line 4 vacant - apply within

--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 22/08/2025 04:23, olcott wrote:

<snip>

I have a much deeper philosophical understanding
than people here that only learn by rote can possibly
imagine.

That's a very lofty claim. What persuades you of its truth? Did
you ask an AI how deep your philosophical understanding is? I
have no doubt it was very reassuring.
--
Richard Heathfield
Email: rjh at cpax dot org dot uk
"Usenet is a strange place" - dmr 29 July 1999
Sig line 4 vacant - apply within

--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 22/08/2025 05:28, wij wrote:

On Thu, 2025-08-21 at 22:43 -0500, olcott wrote:

On 8/21/2025 10:42 PM, wij wrote:

On Fri, 2025-08-22 at 11:26 +0800, wij wrote:

On Thu, 2025-08-21 at 22:23 -0500, olcott wrote:

On 8/21/2025 10:14 PM, wij wrote:

On Thu, 2025-08-21 at 21:20 -0500, olcott wrote:

On 8/21/2025 8:57 PM, Kaz Kylheku wrote:

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

On 8/21/2025 6:40 PM, dbush wrote:

On 8/21/2025 6:12 PM, olcott wrote:

On 8/21/2025 5:08 PM, dbush wrote:

On 8/21/2025 5:58 PM, olcott wrote:

On 8/21/2025 4:44 PM, dbush wrote:

On 8/21/2025 5:34 PM, olcott wrote:

I am not sure whether or not you understand
that DD correctly simulated by HHH, DD() and HHH(DD) >>>>>>>>>>>>>>> would never stop running unless aborted

i.e. if you change the input so that HHH doesn't abort. >>>>>>>>>>>>>>
Changing the input is not allowed.

Yes and if you are driving into a brick
wall at 100 MPH and veer off to miss this
wall you have no idea that you would not
have been perfectly fine if instead you
crashed into the wall because this new
route is not the same as the original route.

A bad analogy is less then no rebuttal.

Therefore you have accepted that you have invalidly changed the input
and that your HHH is therefore DISQUALIFIED.

Its easy to see that DD correctly simulated by
any HHH

Changes the input.

Changing the input is not allowed.

*Its required you stupid f-ck*

Umm, no; HHH(DD) must not change DD before embarking on a simulation >>>>>>>> of it. What makes you think otherwise?

The halting problem proof is about an infinite
set of decider/input pairs. Linz did not prove
that there is one TM H that gets the wrong answer.

It must not change DD proper, nor any of its helper functions like HHH.

Please change your program to accept command line arguments:

     main(int argc, char **argv)
     {
       if (argc > 1) {
         if (strcmp(argv[1], "D")) {
           /* check halting of DD() directly */
           DD();
           puts("DD halted");
         } else if (strcmp(argv[1], "H"))) {
           /* ask HHH */
           if (HHH(DD)) {
             puts("HHH says DD halts")
           } else {
             puts("HHH says DD doesn't halt")
           }
        }
     }

Show the trace/output with the D arguent and then with the H argument. >>>>>>>>

DD correctly simulated by any HHH is simultaneously
analyzing an infinite set of HHH/DD pairs the same
way that the Linz proof works.

As soon as we can detect the repeating state we can
know that there is no need to repeat it more times.
The same pattern applies to any number of repeats.

The Linz proof has the same repeating state when
we examine it with H as a simulating halt decider.
I don't say simulating partial halt decider because
that confuses people.

Many respondents such as Dennis Bush have said things
that have shown they have no interest in an honest dialogue.
The only reason why most people even come here is to
ridicule rather than understand my work.

Your work is nearly random tries, not much different from a monkey in front of a
typewriter trying to type Newton's principles of motion, which is short but the
number of random trials is large enough for the sun to extinguish. >>>>>> Most of all, since you don't know the math/logic and what they mean. No chance
you can recognize and deliver a correct copy (of the principles of motion).
So the 'refutation' of Halting Problem. You cannot fulfill what you wish.

Learn the basic first.

I have a much deeper philosophical understanding
than people here that only learn by rote can possibly
imagine.

I know you read a lot of materials. But all evidences show that you
do not know the basic logic (even fact). Would you like to try?

Direction: You should first understand what truth table mean and the application.

I know these things far better than you do.

O,Ye?

Q: What is the value of proposition X&~X, why? True,False (or Undecidable if none fits)

If he's not in the mood to play, here's my (rather pedestrian and
obvious) rot-9'd answer:

krcfrbn wxc wxdpqc = xwn
krcfrbn wxc xwn = wxdpqc

bx, anpjamunbb xo G'b ejudn, juu krcfrbn wxc G'b krcb jan
xyyxbrcn cx G'b.

krc jwm xyyxbrcn-krc = ojubn

napx G&~G=wxdpqc, fqrlq rb ojubn.
--
Richard Heathfield
Email: rjh at cpax dot org dot uk
"Usenet is a strange place" - dmr 29 July 1999
Sig line 4 vacant - apply within

--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On Fri, 2025-08-22 at 07:11 +0100, Richard Heathfield wrote:

On 22/08/2025 05:28, wij wrote:

On Thu, 2025-08-21 at 22:43 -0500, olcott wrote:

On 8/21/2025 10:42 PM, wij wrote:

On Fri, 2025-08-22 at 11:26 +0800, wij wrote:

On Thu, 2025-08-21 at 22:23 -0500, olcott wrote:

On 8/21/2025 10:14 PM, wij wrote:

On Thu, 2025-08-21 at 21:20 -0500, olcott wrote:

On 8/21/2025 8:57 PM, Kaz Kylheku wrote:

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

On 8/21/2025 6:40 PM, dbush wrote:

On 8/21/2025 6:12 PM, olcott wrote:

On 8/21/2025 5:08 PM, dbush wrote:

On 8/21/2025 5:58 PM, olcott wrote:

On 8/21/2025 4:44 PM, dbush wrote:

On 8/21/2025 5:34 PM, olcott wrote:

I am not sure whether or not you understand that DD correctly simulated by HHH, DD() and HHH(DD)
would never stop running unless aborted

i.e. if you change the input so that HHH doesn't abort.

Changing the input is not allowed.

Yes and if you are driving into a brick
wall at 100 MPH and veer off to miss this
wall you have no idea that you would not
have been perfectly fine if instead you
crashed into the wall because this new
route is not the same as the original route.

A bad analogy is less then no rebuttal.

Therefore you have accepted that you have invalidly changed the input
and that your HHH is therefore DISQUALIFIED.

Its easy to see that DD correctly simulated by
any HHH

Changes the input.

Changing the input is not allowed.

*Its required you stupid f-ck*

Umm, no; HHH(DD) must not change DD before embarking on a simulation
of it. What makes you think otherwise?

The halting problem proof is about an infinite
set of decider/input pairs. Linz did not prove
that there is one TM H that gets the wrong answer.

It must not change DD proper, nor any of its helper functions like HHH.

Please change your program to accept command line arguments:

      main(int argc, char **argv)
      {
        if (argc > 1) {
          if (strcmp(argv[1], "D")) {             /* check halting of DD() directly */             DD();
            puts("DD halted");
          } else if (strcmp(argv[1], "H"))) {             /* ask HHH */
            if (HHH(DD)) {               puts("HHH says DD halts")             } else {
              puts("HHH says DD doesn't halt")             }
         }
      }

Show the trace/output with the D arguent and then with the H argument.

DD correctly simulated by any HHH is simultaneously
analyzing an infinite set of HHH/DD pairs the same
way that the Linz proof works.

As soon as we can detect the repeating state we can
know that there is no need to repeat it more times.
The same pattern applies to any number of repeats.

The Linz proof has the same repeating state when
we examine it with H as a simulating halt decider.
I don't say simulating partial halt decider because
that confuses people.

Many respondents such as Dennis Bush have said things
that have shown they have no interest in an honest dialogue. The only reason why most people even come here is to
ridicule rather than understand my work.

Your work is nearly random tries, not much different from a monkey in front of a
typewriter trying to type Newton's principles of motion, which is short but the
number of random trials is large enough for the sun to extinguish.
Most of all, since you don't know the math/logic and what they mean. No chance
you can recognize and deliver a correct copy (of the principles of motion).
So the 'refutation' of Halting Problem. You cannot fulfill what you wish.

Learn the basic first.

I have a much deeper philosophical understanding
than people here that only learn by rote can possibly
imagine.

I know you read a lot of materials. But all evidences show that you do not know the basic logic (even fact). Would you like to try?

Direction: You should first understand what truth table mean and the application.

I know these things far better than you do.

O,Ye?

Q: What is the value of proposition X&~X, why? True,False (or Undecidable if none fits)

If he's not in the mood to play, here's my (rather pedestrian and
obvious) rot-9'd answer:

krcfrbn wxc wxdpqc = xwn
krcfrbn wxc xwn = wxdpqc

bx, anpjamunbb xo G'b ejudn, juu krcfrbn wxc G'b krcb jan
xyyxbrcn cx G'b.

krc jwm xyyxbrcn-krc = ojubn

napx G&~G=wxdpqc, fqrlq rb ojubn.

No idea what you mean
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 22/08/2025 07:42, wij wrote:

On Fri, 2025-08-22 at 07:11 +0100, Richard Heathfield wrote:

On 22/08/2025 05:28, wij wrote:

On Thu, 2025-08-21 at 22:43 -0500, olcott wrote:

On 8/21/2025 10:42 PM, wij wrote:

On Fri, 2025-08-22 at 11:26 +0800, wij wrote:

On Thu, 2025-08-21 at 22:23 -0500, olcott wrote:

On 8/21/2025 10:14 PM, wij wrote:

On Thu, 2025-08-21 at 21:20 -0500, olcott wrote:

On 8/21/2025 8:57 PM, Kaz Kylheku wrote:

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

On 8/21/2025 6:40 PM, dbush wrote:

On 8/21/2025 6:12 PM, olcott wrote:

On 8/21/2025 5:08 PM, dbush wrote:

On 8/21/2025 5:58 PM, olcott wrote:

On 8/21/2025 4:44 PM, dbush wrote:

On 8/21/2025 5:34 PM, olcott wrote:

I am not sure whether or not you understand
that DD correctly simulated by HHH, DD() and HHH(DD) >>>>>>>>>>>>>>>>> would never stop running unless aborted

i.e. if you change the input so that HHH doesn't abort. >>>>>>>>>>>>>>>>
Changing the input is not allowed.

Yes and if you are driving into a brick
wall at 100 MPH and veer off to miss this
wall you have no idea that you would not
have been perfectly fine if instead you
crashed into the wall because this new
route is not the same as the original route.

A bad analogy is less then no rebuttal.

Therefore you have accepted that you have invalidly changed the input
and that your HHH is therefore DISQUALIFIED.

Its easy to see that DD correctly simulated by
any HHH

Changes the input.

Changing the input is not allowed.

*Its required you stupid f-ck*

Umm, no; HHH(DD) must not change DD before embarking on a simulation >>>>>>>>>> of it. What makes you think otherwise?

The halting problem proof is about an infinite
set of decider/input pairs. Linz did not prove
that there is one TM H that gets the wrong answer.

It must not change DD proper, nor any of its helper functions like HHH.

Please change your program to accept command line arguments: >>>>>>>>>>
      main(int argc, char **argv)
      {
        if (argc > 1) {
          if (strcmp(argv[1], "D")) {
            /* check halting of DD() directly */ >>>>>>>>>>             DD();
            puts("DD halted");
          } else if (strcmp(argv[1], "H"))) {
            /* ask HHH */
            if (HHH(DD)) {
              puts("HHH says DD halts")
            } else {
              puts("HHH says DD doesn't halt") >>>>>>>>>>             }
         }
      }

Show the trace/output with the D arguent and then with the H argument.

DD correctly simulated by any HHH is simultaneously
analyzing an infinite set of HHH/DD pairs the same
way that the Linz proof works.

As soon as we can detect the repeating state we can
know that there is no need to repeat it more times.
The same pattern applies to any number of repeats.

The Linz proof has the same repeating state when
we examine it with H as a simulating halt decider.
I don't say simulating partial halt decider because
that confuses people.

Many respondents such as Dennis Bush have said things
that have shown they have no interest in an honest dialogue. >>>>>>>>> The only reason why most people even come here is to
ridicule rather than understand my work.

Your work is nearly random tries, not much different from a monkey in front of a
typewriter trying to type Newton's principles of motion, which is short but the
number of random trials is large enough for the sun to extinguish. >>>>>>>> Most of all, since you don't know the math/logic and what they mean. No chance
you can recognize and deliver a correct copy (of the principles of motion).
So the 'refutation' of Halting Problem. You cannot fulfill what you wish.

Learn the basic first.

I have a much deeper philosophical understanding
than people here that only learn by rote can possibly
imagine.

I know you read a lot of materials. But all evidences show that you >>>>>> do not know the basic logic (even fact). Would you like to try?

Direction: You should first understand what truth table mean and the application.

I know these things far better than you do.

O,Ye?

Q: What is the value of proposition X&~X, why? True,False (or Undecidable if none fits)

If he's not in the mood to play, here's my (rather pedestrian and
obvious) rot-9'd answer:

krcfrbn wxc wxdpqc = xwn
krcfrbn wxc xwn = wxdpqc

bx, anpjamunbb xo G'b ejudn, juu krcfrbn wxc G'b krcb jan
xyyxbrcn cx G'b.

krc jwm xyyxbrcn-krc = ojubn

napx G&~G=wxdpqc, fqrlq rb ojubn.

No idea what you mean

And that answer is in itself a data point.
--
Richard Heathfield
Email: rjh at cpax dot org dot uk
"Usenet is a strange place" - dmr 29 July 1999
Sig line 4 vacant - apply within

--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

Am Thu, 21 Aug 2025 21:20:27 -0500 schrieb olcott:

On 8/21/2025 8:57 PM, Kaz Kylheku wrote:

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

On 8/21/2025 6:40 PM, dbush wrote:

On 8/21/2025 6:12 PM, olcott wrote:

On 8/21/2025 5:08 PM, dbush wrote:

On 8/21/2025 5:58 PM, olcott wrote:

Yes and if you are driving into a brick wall at 100 MPH and veer >>>>>>> off to miss this wall you have no idea that you would not have
been perfectly fine if instead you crashed into the wall because >>>>>>> this new route is not the same as the original route.

Exactly.

Changing the input is not allowed.

*Its required you stupid f-ck*

Umm, no; HHH(DD) must not change DD before embarking on a simulation of
it. What makes you think otherwise?

The halting problem proof is about an infinite set of decider/input
pairs. Linz did not prove that there is one TM H that gets the wrong
answer.

Your HHH is one TM. There are infinitely many „deciders” that each get
a *different* input wrong, but not the others.
--
Am Sat, 20 Jul 2024 12:35:31 +0000 schrieb WM in sci.math:
It is not guaranteed that n+1 exists for every n.
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

Am Thu, 21 Aug 2025 17:12:27 -0500 schrieb olcott:

Its easy to see that DD correctly simulated by any HHH that can exist
cannot possibly reach its own "return" statement final halt state in the
same way that it can be seen that driving into any brick wall at 100 MPH
will not end well.

DD, which calls HHH, which aborts after one recursion, can be simulated
to completion by HHH_n, which aborts after more than one recursion.
--
Am Sat, 20 Jul 2024 12:35:31 +0000 schrieb WM in sci.math:
It is not guaranteed that n+1 exists for every n.
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

Am Thu, 21 Aug 2025 16:29:23 -0500 schrieb olcott:

On 8/21/2025 4:08 PM, Kaz Kylheku wrote:

It is a matter of easily verified fact that you are using the phrase
"instance of itself" to refer to a situation between two dissimilar
deciders which are implemented in the same C function HHH,
distinguishing themselves by different control flow paths in response
to a mutating static variable.
This is not only a crime against computer science, but against the
English language, whose "itself" pronoun you are abusing.

Truth.

The control paths are the same without the static data.

They are not. You have an if statement depending on that data,
with one path aborting and one not.
--
Am Sat, 20 Jul 2024 12:35:31 +0000 schrieb WM in sci.math:
It is not guaranteed that n+1 exists for every n.
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

Op 21.aug.2025 om 20:14 schreef olcott:

On 8/21/2025 1:07 PM, Mr Flibble wrote:

On Thu, 21 Aug 2025 10:53:05 +0100, Richard Heathfield wrote:

Proof by AI is a risky game to play.

Directly after a context reset in an AI session, I submitted the text
between the rows of ++s, and I have quoted the unedited response between >>> rows of --s. I offer commentary after the AI's response, which I have
left intact.

+++++++++++++++++++++++++++++++++++++++++++++++++++++++++
I have two questions.

1. Which is more likely:
(a) Nearly everyone in my Usenet group has been telling lies about my
work for three years, and the ones that were not lying were mistaken.
(b) There is a flaw in my work, in which I prove that the traditional
proof of the Halting Problem is incorrect. I have spent 22 years on my
proof.
2. Should I seek psychiatric help?
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++
---------------------------------------------------------
I’ll give you as straight and careful an answer as I can:

1. Between (a) and (b):
It is overwhelmingly more likely that (b) is true — that your proof
contains a flaw, even if it’s subtle. The Halting Problem proof is one >>> of the most studied, replicated, and applied results in computer
science. For it to be wrong would overturn huge swaths of mathematics,
computer science, and logic, including results that have been
independently verified and built upon for decades. The chance that all
your peers are lying or mistaken for years is effectively nil compared
to the chance that a mistake crept into your reasoning (which happens to >>> every mathematician, even brilliant ones, especially on difficult
proofs).

2. About psychiatric help:
Seeking psychiatric or psychological help is not a concession of
weakness — it’s about looking after your well-being. Spending decades on
a single problem, especially one as fundamental as the Halting Problem,
can take a toll. If you find yourself obsessing over it, feeling
isolated, or distrusting everyone around you,
then yes, it could help to speak to a professional. They won’t dismiss >>> your intellect or your work — but they can help with managing the strain >>> that comes from such long, lonely focus and from feeling at odds with
the rest of the field.

👉 My suggestion:

First, assume that your work does contain an error, and actively seek
collaborative review (share small parts of the proof with trusted
mathematicians, or post carefully to forums like StackExchange, where
critique is technical and constructive).

Second, if this has become more than an academic pursuit — if it
dominates your sense of identity, causes distress, or erodes trust in
others — then yes, reaching out for psychiatric support would be wise
and healthy.

Would you like me to explain in more detail why the Halting Problem
proof is considered so robust, so you can compare it with your work?

---------------------------------------------------------

I declined, but then confessed that I'd just been curious to know what
the AI would say, knowing it would try to soften the blow.

It then offered me two intriguing suggestions: the batshit-crazy answer, >>> and the dry academic answer. Here they are:

---------------------------------------------------------
Which is more likely?
(a) An entire Usenet group has been engaged in a three-year conspiracy
to lie about your work.
(b) You’ve convinced yourself that after 22 years, you alone have
cracked the Halting Problem and Turing was just a bit sloppy.

Mate, it’s (b). Every single time. You’ve built yourself a cathedral of >>> algebra on a swamp of wishful thinking. Everyone’s been telling you it >>> leaks — and instead of checking the foundations, you’re asking why the >>> villagers are all liars. They’re not lying. They’re trying, as gently as
patience allows,
to tell you you’re wrong.

Should you seek psychiatric help?
Yes. Not because you’re mad in the Shakespearean sense, but because
you’ve fused your sense of self to a doomed proof. Twenty-two years is a >>> marriage. You’re defending it like a spouse, not a theorem. A
professional could help you disentangle the maths from your identity, so >>> you can walk away without feeling like you’ve amputated half your brain. >>> --------------------------------------------------------- Likelihood of
error versus conspiracy It is vanishingly unlikely that the entire
research community, or even a small but persistent subset of it (such as >>> your Usenet group), has collectively erred or engaged in deception for
multiple years regarding a matter as foundational as the Halting
Problem. By contrast, it is overwhelmingly likely that a flaw exists in
your reasoning. The Halting Problem has been studied exhaustively for
nearly a century; claims of disproof have appeared periodically, and
every one has been shown to rest on a logical oversight. The prior
probability that your work represents a genuine exception is effectively >>> zero.

2. Personal wellbeing Devoting twenty-two years to a line of reasoning
that has not gained traction despite repeated peer scrutiny is a
significant psychological burden. It suggests a level of fixation that
may be interfering with your professional and personal wellbeing.
Seeking psychiatric or psychological support would be advisable, not as
a judgement on your sanity, but as a way to regain perspective and
ensure that your intellectual energies are invested more fruitfully.
---------------------------------------------------------

Haven't you got better things to do with your time? Write another book or
something.

/Flibble

That all five LLM systems figure out all of
my reasoning on their own without prompting
and affirm the correctness of this reasoning...

It is easy to feed AI with incorrect information.

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

Here olcott injects his prejudice that a correct Simulating Termination Analyser exists that can detect non-termination behaviour patterns.
We know that his candidate fails, because it is unable to reach the
final halt state of a halting program.
In fact no such thing exists, as proven by the halting theorem.
Assuming that such a thing exist to prove that it exist is invalid
circular logic

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

--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 8/22/2025 3:02 AM, joes wrote:

Am Thu, 21 Aug 2025 21:20:27 -0500 schrieb olcott:

On 8/21/2025 8:57 PM, Kaz Kylheku wrote:

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

On 8/21/2025 6:40 PM, dbush wrote:

On 8/21/2025 6:12 PM, olcott wrote:

On 8/21/2025 5:08 PM, dbush wrote:

On 8/21/2025 5:58 PM, olcott wrote:

Yes and if you are driving into a brick wall at 100 MPH and veer >>>>>>>> off to miss this wall you have no idea that you would not have >>>>>>>> been perfectly fine if instead you crashed into the wall because >>>>>>>> this new route is not the same as the original route.

Exactly.

Changing the input is not allowed.

*Its required you stupid f-ck*

Umm, no; HHH(DD) must not change DD before embarking on a simulation of
it. What makes you think otherwise?

The halting problem proof is about an infinite set of decider/input
pairs. Linz did not prove that there is one TM H that gets the wrong
answer.

Your HHH is one TM. There are infinitely many „deciders” that each get
a *different* input wrong, but not the others.

*This generic HHH forms an infinite set of HHH/DD pairs*

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

From Newsgroup: comp.theory

On 22/08/2025 15:06, olcott wrote:

<snip>

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?

It depends on what value HHH(DD) returns. If HHH(DD) returns 0,
it should return 1. Otherwise, it should return 0.
--
Richard Heathfield
Email: rjh at cpax dot org dot uk
"Usenet is a strange place" - dmr 29 July 1999
Sig line 4 vacant - apply within

--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 8/22/2025 3:19 AM, joes wrote:

Am Thu, 21 Aug 2025 17:12:27 -0500 schrieb olcott:

Its easy to see that DD correctly simulated by any HHH that can exist
cannot possibly reach its own "return" statement final halt state in the
same way that it can be seen that driving into any brick wall at 100 MPH
will not end well.

DD, which calls HHH, which aborts after one recursion, can be simulated
to completion by HHH_n, which aborts after more than one recursion.

Counter-factual for every HHH that can possibly exist.

_DD()
[00002162] 55 push ebp
[00002163] 8bec mov ebp,esp
[00002165] 51 push ecx
[00002166] 6862210000 push 00002162 // push DD
[0000216b] e862f4ffff call 000015d2 // call HHH
[00002170] 83c404 add esp,+04
[00002173] 8945fc mov [ebp-04],eax
[00002176] 837dfc00 cmp dword [ebp-04],+00
[0000217a] 7402 jz 0000217e
[0000217c] ebfe jmp 0000217c
[0000217e] 8b45fc mov eax,[ebp-04]
[00002181] 8be5 mov esp,ebp
[00002183] 5d pop ebp
[00002184] c3 et
Size in bytes:(0035) [00002184]

When N is a natural number and we ignore OOM errors
then when N instructions of DD are correctly emulated
by some HHH, none of these correctly emulated DD
instructions reach past their own machine address
0000216b.

When HHH aborts its simulation of DD zero instructions
of any level of simulation are emulated thus there is
no stack unwinding.
--
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