| Sysop: | Amessyroom |
|---|---|
| Location: | Fayetteville, NC |
| Users: | 27 |
| Nodes: | 6 (0 / 6) |
| Uptime: | 38:01:03 |
| Calls: | 631 |
| Calls today: | 2 |
| Files: | 1,187 |
| D/L today: |
22 files (29,767K bytes) |
| Messages: | 173,681 |
Does there exist a single halt decider that can
compute the mapping from its finite string input(s)
to an accept or reject value on the basis of the
semantic halting property specified by this/these
finite string input(s) for all inputs?
*Defines a different result as shown below*
From just my own two sentences (a) and (b) five LLM
systems figured out how to correctly decide the halting
problem's counter example input.
They all figured out the recursive simulation non-halting
behavior pattern on their own.
<Input to LLM systems>
Simulating Termination Analyzer HHH correctly simulates its input until:
-a(a) Detects a non-terminating behavior pattern:
-a-a-a-a abort simulation and return 0.
-a(b) Simulated input reaches its simulated "return" statement:
-a-a-a-a return 1.
typedef int (*ptr)();
int HHH(ptr P);
int DD()
-a{
-a int Halt_Status = HHH(DD);
-a if (Halt_Status)
-a-a-a HERE: goto HERE;
-a return Halt_Status;
-a}
What value should HHH(DD) correctly return?
</Input to LLM systems>
*Here are the best three* 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
Am 25.09.2025 um 15:56 schrieb olcott:
Does there exist a single halt decider that can
compute the mapping from its finite string input(s)
to an accept or reject value on the basis of the
semantic halting property specified by this/these
finite string input(s) for all inputs?
*Defines a different result as shown below*
-aFrom just my own two sentences (a) and (b) five LLM
systems figured out how to correctly decide the halting
problem's counter example input.
They all figured out the recursive simulation non-halting
behavior pattern on their own.
<Input to LLM systems>
Simulating Termination Analyzer HHH correctly simulates its input until:
-a-a(a) Detects a non-terminating behavior pattern:
-a-a-a-a-a abort simulation and return 0.
-a-a(b) Simulated input reaches its simulated "return" statement:
-a-a-a-a-a return 1.
typedef int (*ptr)();
int HHH(ptr P);
int DD()
-a-a{
-a-a int Halt_Status = HHH(DD);
-a-a if (Halt_Status)
-a-a-a-a HERE: goto HERE;
-a-a return Halt_Status;
-a-a}
What value should HHH(DD) correctly return?
</Input to LLM systems>
*Here are the best three*
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
Do something more meaningful with your life than discussing
the same detail for years. I find that absolutely insane.
The semantic properties of finite strings is
the key aspect of the halting problem that no
one has ever properly addressed.
Am 25.09.2025 um 15:56 schrieb olcott:
Does there exist a single halt decider that can
compute the mapping from its finite string input(s)
to an accept or reject value on the basis of the
semantic halting property specified by this/these
finite string input(s) for all inputs?
*Defines a different result as shown below*
-aFrom just my own two sentences (a) and (b) five LLM
systems figured out how to correctly decide the halting
problem's counter example input.
They all figured out the recursive simulation non-halting
behavior pattern on their own.
<Input to LLM systems>
Simulating Termination Analyzer HHH correctly simulates its input until:
-a-a(a) Detects a non-terminating behavior pattern:
-a-a-a-a-a abort simulation and return 0.
-a-a(b) Simulated input reaches its simulated "return" statement:
-a-a-a-a-a return 1.
typedef int (*ptr)();
int HHH(ptr P);
int DD()
-a-a{
-a-a int Halt_Status = HHH(DD);
-a-a if (Halt_Status)
-a-a-a-a HERE: goto HERE;
-a-a return Halt_Status;
-a-a}
What value should HHH(DD) correctly return?
</Input to LLM systems>
*Here are the best three*
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
Do something more meaningful with your life than discussing
the same detail for years. I find that absolutely insane.
On 9/25/2025 7:21 AM, Bonita Montero wrote:
Am 25.09.2025 um 15:56 schrieb olcott:
Does there exist a single halt decider that can
compute the mapping from its finite string input(s)
to an accept or reject value on the basis of the
semantic halting property specified by this/these
finite string input(s) for all inputs?
*Defines a different result as shown below*
-aFrom just my own two sentences (a) and (b) five LLM
systems figured out how to correctly decide the halting
problem's counter example input.
They all figured out the recursive simulation non-halting
behavior pattern on their own.
<Input to LLM systems>
Simulating Termination Analyzer HHH correctly simulates its input until: >>> -a-a(a) Detects a non-terminating behavior pattern:
-a-a-a-a-a abort simulation and return 0.
-a-a(b) Simulated input reaches its simulated "return" statement:
-a-a-a-a-a return 1.
typedef int (*ptr)();
int HHH(ptr P);
int DD()
-a-a{
-a-a int Halt_Status = HHH(DD);
-a-a if (Halt_Status)
-a-a-a-a HERE: goto HERE;
-a-a return Halt_Status;
-a-a}
What value should HHH(DD) correctly return?
</Input to LLM systems>
*Here are the best three*
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
Do something more meaningful with your life than discussing
the same detail for years. I find that absolutely insane.
I hope he listens to you.
Am 25.09.2025 um 22:18 schrieb Chris M. Thomasson:
On 9/25/2025 7:21 AM, Bonita Montero wrote:
Am 25.09.2025 um 15:56 schrieb olcott:
Does there exist a single halt decider that can
compute the mapping from its finite string input(s)
to an accept or reject value on the basis of the
semantic halting property specified by this/these
finite string input(s) for all inputs?
*Defines a different result as shown below*
-aFrom just my own two sentences (a) and (b) five LLM
systems figured out how to correctly decide the halting
problem's counter example input.
They all figured out the recursive simulation non-halting
behavior pattern on their own.
<Input to LLM systems>
Simulating Termination Analyzer HHH correctly simulates its input
until:
-a-a(a) Detects a non-terminating behavior pattern:
-a-a-a-a-a abort simulation and return 0.
-a-a(b) Simulated input reaches its simulated "return" statement:
-a-a-a-a-a return 1.
typedef int (*ptr)();
int HHH(ptr P);
int DD()
-a-a{
-a-a int Halt_Status = HHH(DD);
-a-a if (Halt_Status)
-a-a-a-a HERE: goto HERE;
-a-a return Halt_Status;
-a-a}
What value should HHH(DD) correctly return?
</Input to LLM systems>
*Here are the best three*
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
Do something more meaningful with your life than discussing
the same detail for years. I find that absolutely insane.
I hope he listens to you.
<3
On 9/26/2025 10:44 AM, Bonita Montero wrote:
Am 25.09.2025 um 22:18 schrieb Chris M. Thomasson:
On 9/25/2025 7:21 AM, Bonita Montero wrote:
Am 25.09.2025 um 15:56 schrieb olcott:
Does there exist a single halt decider that can
compute the mapping from its finite string input(s)
to an accept or reject value on the basis of the
semantic halting property specified by this/these
finite string input(s) for all inputs?
*Defines a different result as shown below*
-aFrom just my own two sentences (a) and (b) five LLM
systems figured out how to correctly decide the halting
problem's counter example input.
They all figured out the recursive simulation non-halting
behavior pattern on their own.
<Input to LLM systems>
Simulating Termination Analyzer HHH correctly simulates its input
until:
-a-a(a) Detects a non-terminating behavior pattern:
-a-a-a-a-a abort simulation and return 0.
-a-a(b) Simulated input reaches its simulated "return" statement:
-a-a-a-a-a return 1.
typedef int (*ptr)();
int HHH(ptr P);
int DD()
-a-a{
-a-a int Halt_Status = HHH(DD);
-a-a if (Halt_Status)
-a-a-a-a HERE: goto HERE;
-a-a return Halt_Status;
-a-a}
What value should HHH(DD) correctly return?
</Input to LLM systems>
*Here are the best three*
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
Do something more meaningful with your life than discussing
the same detail for years. I find that absolutely insane.
I hope he listens to you.
<3
Two other PhD computer scientists agree with me.
https://www.cs.toronto.edu/~hehner/PHP.pdf
https://www.complang.tuwien.ac.at/anton/euroforth/ef17/papers/stoddart.pdf
Two other PhD computer scientists agree with me.
On 26/09/2025 16:56, olcott wrote:
<snip>
Two other PhD computer scientists agree with me.
That's an attempt at an appeal to authority, but it isn't a convincing argument. There must be many /thousands/ of Comp Sci PhDs who've studied
the Halting Problem (for the 10 minutes it takes to drink a cup of
coffee while they run the proof through their minds) and who have no
problem with it whatsoever.
On 9/26/2025 12:05 PM, Richard Heathfield wrote:
On 26/09/2025 16:56, olcott wrote:
<snip>
Two other PhD computer scientists agree with me.
That's an attempt at an appeal to authority, but it isn't a
convincing argument. There must be many /thousands/ of Comp Sci
PhDs who've studied the Halting Problem (for the 10 minutes it
takes to drink a cup of coffee while they run the proof through
their minds) and who have no problem with it whatsoever.
And of course you can dismiss whatever they say
without looking at a single word because majority
consensus have never been shown to be less than
totally infallible.
The economist J.K. Galbraith once wrote, rCLFaced with a choice
between changing onerCOs mind and proving there is no need to do
so, almost everyone gets busy with the proof.rCY
Leo Tolstoy was even bolder: rCLThe most difficult subjects can be
explained to the most slow-witted man if he has not formed any
idea of them already; but the simplest thing cannot be made clear
to the most intelligent man if he is firmly persuaded that he
knows already, without a shadow of doubt, what is laid before him.rCY
What's going on here? Why don't facts change our minds?
And why
would someone continue to believe a false or inaccurate idea
anyway?
On 26/09/2025 18:17, olcott wrote:
On 9/26/2025 12:05 PM, Richard Heathfield wrote:
On 26/09/2025 16:56, olcott wrote:
<snip>
Two other PhD computer scientists agree with me.
That's an attempt at an appeal to authority, but it isn't a
convincing argument. There must be many /thousands/ of Comp Sci PhDs
who've studied the Halting Problem (for the 10 minutes it takes to
drink a cup of coffee while they run the proof through their minds)
and who have no problem with it whatsoever.
And of course you can dismiss whatever they say
without looking at a single word because majority
consensus have never been shown to be less than
totally infallible.
That isn't what I said. I said that for every PhD you can appeal to who doesn't understand the proof, there will be thousands who do understand
the proof.
The economist J.K. Galbraith once wrote, rCLFaced with a choice between
changing onerCOs mind and proving there is no need to do so, almost
everyone gets busy with the proof.rCY
We don't even have to do that, because there is no need to change our
minds and the proof is already written.
Contrary to what you appear to believe, a proof doesn't mean someone got
it wrong. It means someone proved they're right.
Leo Tolstoy was even bolder: rCLThe most difficult subjects can be
explained to the most slow-witted man if he has not formed any idea of
them already; but the simplest thing cannot be made clear to the most
intelligent man if he is firmly persuaded that he knows already,
without a shadow of doubt, what is laid before him.rCY
You are the proof. The Halting Problem is remarkably simple, but as a
self-identified genius you are so sure it's mistaken that it has taken people 20 years to persuade you that DD proves HHH is not a halting
decider for DD, even though it's never *once* got the answer right, and having briefly accepted it, you have already returned to your overturned bowl; I suppose 20 years is a hard habit to break.
What's going on here? Why don't facts change our minds?
Like "DD halts", you mean?
And why would someone continue to believe a false or inaccurate idea
anyway?
Because you're so full of it you can't get rid of it?
-aHow do such behaviors serve us?
They don't. You have pissed away 20 years.
On 9/26/2025 1:01 PM, Richard Heathfield wrote:
On 26/09/2025 18:17, olcott wrote:
On 9/26/2025 12:05 PM, Richard Heathfield wrote:
On 26/09/2025 16:56, olcott wrote:
<snip>
Two other PhD computer scientists agree with me.
That's an attempt at an appeal to authority, but it isn't a
convincing argument. There must be many /thousands/ of Comp
Sci PhDs who've studied the Halting Problem (for the 10
minutes it takes to drink a cup of coffee while they run the
proof through their minds) and who have no problem with it
whatsoever.
And of course you can dismiss whatever they say
without looking at a single word because majority
consensus have never been shown to be less than
totally infallible.
That isn't what I said. I said that for every PhD you can
appeal to who doesn't understand the proof, there will be
thousands who do understand the proof.
By showing that two PhD computer scientists agree
with my position makes it unreasonably implausible
that I am a mere crackpot.
The economist J.K. Galbraith once wrote, rCLFaced with a choice
between changing onerCOs mind and proving there is no need to do
so, almost everyone gets busy with the proof.rCY
We don't even have to do that, because there is no need to
change our minds and the proof is already written.
In other words because you are sure that I must
be wrong there is no need to pay close attention
to what I say.
*The halting problem proof question is this*
On 9/26/2025 12:05 PM, Richard Heathfield wrote:
On 26/09/2025 16:56, olcott wrote:
<snip>
Two other PhD computer scientists agree with me.
That's an attempt at an appeal to authority, but it isn't a convincing
argument. There must be many /thousands/ of Comp Sci PhDs who've studied
the Halting Problem (for the 10 minutes it takes to drink a cup of
coffee while they run the proof through their minds) and who have no
problem with it whatsoever.
And of course you can dismiss whatever they say
without looking at a single word because majority
consensus have never been shown to be less than
totally infallible.
The economist J.K. Galbraith once wrote, rCLFaced with a choice between changing onerCOs mind and proving there is no need to do so, almost
everyone gets busy with the proof.rCY
What's going on here? Why don't facts change our minds? And why would
On 2025-09-26, olcott <polcott333@gmail.com> wrote:
On 9/26/2025 12:05 PM, Richard Heathfield wrote:
On 26/09/2025 16:56, olcott wrote:
<snip>
Two other PhD computer scientists agree with me.
That's an attempt at an appeal to authority, but it isn't a convincing
argument. There must be many /thousands/ of Comp Sci PhDs who've studied >>> the Halting Problem (for the 10 minutes it takes to drink a cup of
coffee while they run the proof through their minds) and who have no
problem with it whatsoever.
And of course you can dismiss whatever they say
without looking at a single word because majority
consensus have never been shown to be less than
totally infallible.
Consensus in mathematics /is/ pretty much infallible.
Mathematicians are a very careful bunch; they generally know when they
have a conjecture and when they have a proved theorem.
Some of their proofs go for hundreds of pages. Peer reviews of such
proofs are able to find flaws.
You are not going to find a flaw in a massively accepted, old result
that, in in most succinct presentations, takes about a page.
You might as well look for a dry spot on a T-shirt that was loaded
with rocks and is sitting at the bottom of the ocean.
The economist J.K. Galbraith once wrote, rCLFaced with a choice between
changing onerCOs mind and proving there is no need to do so, almost
everyone gets busy with the proof.rCY
That's a thought-terminating cliche, just like, oh, the idea that the
more someone protests an accusation, the more guilty he must be.
As if someone innocent would not protest?
Are you saying that the concensus is /never/ right? Everyone
who-so-ever has a contrary opinion to a mathematical consensus is right? Merely the possession of a contrary opinion is evidence of having
outwitted everyone?
What's going on here? Why don't facts change our minds? And why would
You've not presented any facts, see.
And your approach to a problem
in logic is to try to redefine it in some handwavy "extralogical" way
and then simply insist that anyone having to do with the original
problem should drop that and make the replacement one their agenda.
You are not able to earnestly engage with the subject matter in its
proper form.
*The conventional halting problem question is this*
Does there exist a single halt decider that
can correctly report the halt status of the
behavior of a directly executed machine on
the basis of this machine's machine description.
*The conventional halting problem proof question is this*
What correct halt status value can be returned
when the input to a halt decider actually does
the opposite of whatever value is returned?
These above conventional views are proven.
On 26/09/2025 19:10, olcott wrote:[SNIP]
On 9/26/2025 2:28 PM, Kaz Kylheku wrote:
On 2025-09-26, olcott <polcott333@gmail.com> wrote:
On 9/26/2025 12:05 PM, Richard Heathfield wrote:
On 26/09/2025 16:56, olcott wrote:
<snip>
Two other PhD computer scientists agree with me.
That's an attempt at an appeal to authority, but it isn't a convincing >>>> argument. There must be many /thousands/ of Comp Sci PhDs who've studied >>>> the Halting Problem (for the 10 minutes it takes to drink a cup of
coffee while they run the proof through their minds) and who have no
problem with it whatsoever.
And of course you can dismiss whatever they say
without looking at a single word because majority
consensus have never been shown to be less than
totally infallible.
Consensus in mathematics /is/ pretty much infallible.
That is like pretty much sterile.
Generally very reliable seems apt.
Math and logic people will hold to views that
are philosophically primarily because they view
knowledge in their field to be pretty much infallible.
The big mistake of logic is that it does not retain
semantics as fully integrated into its formal expressions.
That is how we get nutty things like the Principle of Explosion. https://en.wikipedia.org/wiki/Principle_of_explosion
On 2025-09-26 13:49, olcott wrote:
*The conventional halting problem question is this*
Does there exist a single halt decider that
can correctly report the halt status of the
behavior of a directly executed machine on
the basis of this machine's machine description.
*The conventional halting problem proof question is this*
What correct halt status value can be returned
when the input to a halt decider actually does
the opposite of whatever value is returned?
These above conventional views are proven.
Those are questions. You can't prove a question. You prove statements.
And neither of those are conventional. You can't make up your own formulations and then declare them to be conventional.
Andr|-
On 9/26/2025 3:00 PM, Andr|- G. Isaak wrote:
On 2025-09-26 13:49, olcott wrote:
*The conventional halting problem question is this*
Does there exist a single halt decider that
can correctly report the halt status of the
behavior of a directly executed machine on
the basis of this machine's machine description.
*The conventional halting problem proof question is this*
What correct halt status value can be returned
when the input to a halt decider actually does
the opposite of whatever value is returned?
These above conventional views are proven.
Those are questions. You can't prove a question. You prove statements.
And neither of those are conventional. You can't make up your own
formulations and then declare them to be conventional.
Andr|-
Any statement or question that is semantically
equivalent to another can be replaced by this
other expression of language while retaining
the same essential meaning.
On 2025-09-26, olcott <polcott333@gmail.com> wrote:
On 9/26/2025 2:28 PM, Kaz Kylheku wrote:
On 2025-09-26, olcott <polcott333@gmail.com> wrote:
On 9/26/2025 12:05 PM, Richard Heathfield wrote:
On 26/09/2025 16:56, olcott wrote:
<snip>
Two other PhD computer scientists agree with me.
That's an attempt at an appeal to authority, but it isn't a convincing >>>>> argument. There must be many /thousands/ of Comp Sci PhDs who've studied >>>>> the Halting Problem (for the 10 minutes it takes to drink a cup of
coffee while they run the proof through their minds) and who have no >>>>> problem with it whatsoever.
And of course you can dismiss whatever they say
without looking at a single word because majority
consensus have never been shown to be less than
totally infallible.
Consensus in mathematics /is/ pretty much infallible.
That is like pretty much sterile.
Sometime things are sterile and that is good. Like your surgeon's
gloves, or the interior of your next can of beans, and such.
Generally very reliable seems apt.
You don't even know the beginning of it.
Math and logic people will hold to views that
are philosophically primarily because they view
knowledge in their field to be pretty much infallible.
Formal systems are artificial inventions evolving from their axioms.
While we can't say that we know everything about a system just
because we invented its axioms, we know when we have captured an
air-tight truth.
It is not a situation in which we are relying on hypotheses,
observations and measurements, which are saddled with conditions.
You're not going to end up with a classical mechanics theory
of Turing Machine halting, distinct from a quantum and relativistic one,
in which they can't decide between loops and strings ...
The subject matter admits iron-clad conclusions that get permanently
laid to rest.
The big mistake of logic is that it does not retain
semantics as fully integrated into its formal expressions.
That is how we get nutty things like the Principle of Explosion.
https://en.wikipedia.org/wiki/Principle_of_explosion
The POE is utterly sane.
What is nutty is doing what it describe; go around assuming falsehoods
to be true and the deriving nonsense from them with the intent of
adopting a belief in all those falsehoods and the nonsense that follows.
But that, ironically, perfectly describes your own research programme,
right down to the acronym:
Principle of Explosion -> POE -> Peter Olcott Experiment
A contradiction is a piece of foreign material in a formal system. It
is nonsensical to bring it in, and assert it as a truth; it makes no
sense to do so. Once you do, it creates contagion.
I believe that POE is closely linked to the principle we know
in the systems side of computer science: "one bad bit stops the show".
If you interfere with a correct calculation program by flipping a bit,
all bets are off.
Another face of POE in computing is GIGO: garbage in, garbage out.
Assuming a falsehood to be true is garbage in; the bogus things
you dan then prove are garbage out.
The /reduction ad absurdum/ technique usefully makes a controlled use of
a contradiction. We introduce a contradiction and then derive from it
some other contradictions using the same logical tools that we normally
use for deriving truths from truths. We do that with the specific goal
of arriving at a proposion that we otherwise already know to be false.
At that point we drop regarding as true the entire chain, all the way
back to the initial wrong assumption.
The benefit is that the contradiction being initially assumed is not /obviously/ a contradiction, but when we show that it derivews an
/obvious/ contradiction, we readily see that it is so.
(Note that the diagonal halting proofs do not rely on /reduction ad
absurdum/ whatsoever. They directly show that no decider can be total, without assuming anything about it.)
On 2025-09-26, olcott <polcott333@gmail.com> wrote:
[...][...]
The big mistake of logic is that it does not retain
semantics as fully integrated into its formal expressions.
That is how we get nutty things like the Principle of Explosion.
https://en.wikipedia.org/wiki/Principle_of_explosion
[...]
BTW; with this link that you provided you can find your way through
https://en.wikipedia.org/wiki/Russell%27s_paradox
even to one of the respective quotes from Wittgenstein's "Tractatus":
''In 1923, Ludwig Wittgenstein proposed to "dispose" of Russell's
paradox as follows:
"The reason why a function cannot be its own argument is that the
sign for a function already contains the prototype of its argument,
and it cannot contain itself.
On 26.09.2025 22:35, Kaz Kylheku wrote:Don't make sense to me.
On 2025-09-26, olcott <polcott333@gmail.com> wrote:
[...][...]
The big mistake of logic is that it does not retain
semantics as fully integrated into its formal expressions.
When I read that I was tempted to suggest you reading Wittgenstein. Concerning "logic" (and any "mistakes" you see) I'm not sure what
you understand when reading Wittgenstein but it may be worth a try!
That is how we get nutty things like the Principle of Explosion. https://en.wikipedia.org/wiki/Principle_of_explosion
BTW; with this link that you provided you can find your way through
-a https://en.wikipedia.org/wiki/Russell%27s_paradox
even to one of the respective quotes from Wittgenstein's "Tractatus":
''In 1923, Ludwig Wittgenstein proposed to "dispose" of Russell's
-a paradox as follows:
-a-a-a "The reason why a function cannot be its own argument is that the -asign for a function already contains the prototype of its argument,
-aand it cannot contain itself. For let us suppose that the function
-aF(fx) could be its own argument: in that case there would be a -aproposition F(F(fx)), in which the outer function F and the inner -afunction F must have different meanings, since the inner one has the
-aform O(fx) and the outer one has the form Y(O(fx)). Only the letter
-a'F' is common to the two functions, but the letter by itself signifies -anothing. This immediately becomes clear if instead of F(Fu) we write
-a(do) : F(Ou) . Ou = Fu. That disposes of Russell's paradox. -a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a (Tractatus Logico-Philosophicus, 3.333)"
''
(Getting more context of the "Tractatus" might be advisable, though.--- Synchronet 3.21a-Linux NewsLink 1.2
And worth reading, IMO.)
Janis
PS (@Kaz): Sorry to have hijacked your reply, but I've configured my newsreader to not anymore see these pathological repetitions of the
OP's posts. - Although it's (a bit) pity since the junction towards
the topic of "logic and semantics" appears more appealing than what
we've suffered from before.
[...]
Far far better to not let garbage in.
''In 1923, Ludwig Wittgenstein proposed to "dispose" of Russell's
paradox as follows:
"The reason why a function cannot be its own argument is that the
sign for a function already contains the prototype of its argument,
and it cannot contain itself.
On 26.09.2025 22:35, Kaz Kylheku wrote:<SNIP>> ''In 1923, Ludwig Wittgenstein proposed to "dispose" of
paradox as follows:I've read the Tractatus and found it a lot of fun and stimulating of
"The reason why a function cannot be its own argument is that the
sign for a function already contains the prototype of its argument,
and it cannot contain itself. For let us suppose that the function
F(fx) could be its own argument: in that case there would be a
proposition F(F(fx)), in which the outer function F and the inner
function F must have different meanings, since the inner one has the
form O(fx) and the outer one has the form Y(O(fx)). Only the letter
'F' is common to the two functions, but the letter by itself signifies
nothing. This immediately becomes clear if instead of F(Fu) we write
(do) : F(Ou) . Ou = Fu. That disposes of Russell's paradox.
(Tractatus Logico-Philosophicus, 3.333)"
On 2025-09-26, olcott <polcott333@gmail.com> wrote:
On 9/26/2025 3:00 PM, Andr|- G. Isaak wrote:
On 2025-09-26 13:49, olcott wrote:
*The conventional halting problem question is this*
Does there exist a single halt decider that
can correctly report the halt status of the
behavior of a directly executed machine on
the basis of this machine's machine description.
*The conventional halting problem proof question is this*
What correct halt status value can be returned
when the input to a halt decider actually does
the opposite of whatever value is returned?
These above conventional views are proven.
Those are questions. You can't prove a question. You prove statements.
And neither of those are conventional. You can't make up your own
formulations and then declare them to be conventional.
Andr|-
Any statement or question that is semantically
equivalent to another can be replaced by this
other expression of language while retaining
the same essential meaning.
Lofty words there, Aristotle!
Too bad HHH(DD) has a different meaning depending on where it is placed
and who is evaluating it, plus whatever you need it to mean for whatever
you are saying.
On 26/09/2025 19:10, olcott wrote:
Close attention must be earned. You might get it out of sheer
curiosity to start with, but when you write an endless stream of
drivel you quickly lose it, and it's hard to regain.
*The halting problem proof question is this*
No, it isn't.
The halting problem proof question is this: can a universal
halting decider exist?
The halting problem proof answer is this: no.
<more drivel snipped>
I believe that POE is closely linked to the principle we know
in the systems side of computer science: "one bad bit stops the show".
If you interfere with a correct calculation program by flipping a bit,
all bets are off.
Another face of POE in computing is GIGO: garbage in, garbage out.
Assuming a falsehood to be true is garbage in; the bogus things
you dan then prove are garbage out.
On 9/26/2025 4:23 PM, Janis Papanagnou wrote:
I've read the Tractatus and found it a lot of fun and stimulating of
''In 1923, Ludwig Wittgenstein proposed to "dispose" of
Russell's
paradox as follows:
[...]
(Tractatus Logico-Philosophicus, 3.333)"
thought. I'm composing this note, not to argue with philosophy;
rather
to mention the realization of such such a possibility in an actual programming language. [...]
the OP's link misguided me to think that Russel's view would have
been the source of the OP's misconception. But the problem may lie
deeper; in not separating sensibly the involved categories. IMO.
On 2025-09-26, olcott <polcott333@gmail.com> wrote:
On 9/26/2025 2:28 PM, Kaz Kylheku wrote:
On 2025-09-26, olcott <polcott333@gmail.com> wrote:
On 9/26/2025 12:05 PM, Richard Heathfield wrote:
On 26/09/2025 16:56, olcott wrote:
<snip>
Two other PhD computer scientists agree with me.
That's an attempt at an appeal to authority, but it isn't a convincing >>>>> argument. There must be many /thousands/ of Comp Sci PhDs who've studied >>>>> the Halting Problem (for the 10 minutes it takes to drink a cup of
coffee while they run the proof through their minds) and who have no >>>>> problem with it whatsoever.
And of course you can dismiss whatever they say
without looking at a single word because majority
consensus have never been shown to be less than
totally infallible.
Consensus in mathematics /is/ pretty much infallible.
That is like pretty much sterile.
Sometime things are sterile and that is good. Like your surgeon's
gloves, or the interior of your next can of beans, and such.
Generally very reliable seems apt.
You don't even know the beginning of it.
Math and logic people will hold to views that
are philosophically primarily because they view
knowledge in their field to be pretty much infallible.
Formal systems are artificial inventions evolving from their axioms.
While we can't say that we know everything about a system just
because we invented its axioms, we know when we have captured an
air-tight truth.
It is not a situation in which we are relying on hypotheses,
observations and measurements, which are saddled with conditions.
You're not going to end up with a classical mechanics theory
of Turing Machine halting, distinct from a quantum and relativistic one,
in which they can't decide between loops and strings ...
The subject matter admits iron-clad conclusions that get permanently
laid to rest.
The big mistake of logic is that it does not retain
semantics as fully integrated into its formal expressions.
That is how we get nutty things like the Principle of Explosion.
https://en.wikipedia.org/wiki/Principle_of_explosion
The POE is utterly sane.
What is nutty is doing what it describe; go around assuming falsehoods
to be true and the deriving nonsense from them with the intent of
adopting a belief in all those falsehoods and the nonsense that follows.
But that, ironically, perfectly describes your own research programme,
right down to the acronym:
Principle of Explosion -> POE -> Peter Olcott Experiment
A contradiction is a piece of foreign material in a formal system. It
is nonsensical to bring it in, and assert it as a truth; it makes no
sense to do so. Once you do, it creates contagion.
I believe that POE is closely linked to the principle we know
in the systems side of computer science: "one bad bit stops the show".
If you interfere with a correct calculation program by flipping a bit,
all bets are off.
Another face of POE in computing is GIGO: garbage in, garbage out.
Assuming a falsehood to be true is garbage in; the bogus things
you dan then prove are garbage out.
The /reduction ad absurdum/ technique usefully makes a controlled use of
a contradiction. We introduce a contradiction and then derive from it
some other contradictions using the same logical tools that we normally
use for deriving truths from truths. We do that with the specific goal
of arriving at a proposion that we otherwise already know to be false.
At that point we drop regarding as true the entire chain, all the way
back to the initial wrong assumption.
The benefit is that the contradiction being initially assumed is not /obviously/ a contradiction, but when we show that it derivews an
/obvious/ contradiction, we readily see that it is so.
(Note that the diagonal halting proofs do not rely on /reduction ad
absurdum/ whatsoever. They directly show that no decider can be total, without assuming anything about it.)
On 27.09.2025 08:46, Jeff Barnett wrote:
On 9/26/2025 4:23 PM, Janis Papanagnou wrote:
thought. I'm composing this note, not to argue with philosophy;
''In 1923, Ludwig Wittgenstein proposed to "dispose" of
Russell's
paradox as follows:
[...]
(Tractatus Logico-Philosophicus, 3.333)" >> I've read the Tractatus and found it a lot of fun and stimulating of
Neither do I (that would certainly lead to far). My intention here
is just to direct to the OP's original statement which was linking
logic and semantics, and had been speaking of "mistakes of logic":
"The big mistake of logic is that it does not retain
semantics as fully integrated into its formal expressions."
Wittgenstein in his Tractatus (as I understood it) separated well
the factors [language-]semantics, [bool] logic, and [mathematical] "technical" aspects, including [real languages'] syntax (and [as
in programming languages] their [operational/technical] semantics).
That's why I had mentioned the necessary context for the full view!--
(Some can be found around the above quoted proposition, some later
in his opus. But for a full understanding it's necessary to read
the whole text from the start.)
(My mistake was to quote the single paragraph from Wikipedia that
is covering just a specific aspect, and certainly insufficiently;
the OP's link misguided me to think that Russel's view would have
been the source of the OP's misconception. But the problem may lie
deeper; in not separating sensibly the involved categories. IMO.)
rather
to mention the realization of such such a possibility in an actual
programming language. [...]
Yes.
On 9/26/2025 10:44 AM, Bonita Montero wrote:
Am 25.09.2025 um 22:18 schrieb Chris M. Thomasson:
On 9/25/2025 7:21 AM, Bonita Montero wrote:
Am 25.09.2025 um 15:56 schrieb olcott:
Does there exist a single halt decider that can
compute the mapping from its finite string input(s)
to an accept or reject value on the basis of the
semantic halting property specified by this/these
finite string input(s) for all inputs?
*Defines a different result as shown below*
-aFrom just my own two sentences (a) and (b) five LLM
systems figured out how to correctly decide the halting
problem's counter example input.
They all figured out the recursive simulation non-halting
behavior pattern on their own.
<Input to LLM systems>
Simulating Termination Analyzer HHH correctly simulates its input
until:
-a-a(a) Detects a non-terminating behavior pattern:
-a-a-a-a-a abort simulation and return 0.
-a-a(b) Simulated input reaches its simulated "return" statement:
-a-a-a-a-a return 1.
typedef int (*ptr)();
int HHH(ptr P);
int DD()
-a-a{
-a-a int Halt_Status = HHH(DD);
-a-a if (Halt_Status)
-a-a-a-a HERE: goto HERE;
-a-a return Halt_Status;
-a-a}
What value should HHH(DD) correctly return?
</Input to LLM systems>
*Here are the best three*
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
Do something more meaningful with your life than discussing
the same detail for years. I find that absolutely insane.
I hope he listens to you.
<3
Two other PhD computer scientists agree with me.
https://www.cs.toronto.edu/~hehner/PHP.pdf
https://www.complang.tuwien.ac.at/anton/euroforth/ef17/papers/stoddart.pdf
Am 26.09.2025 um 17:56 schrieb olcott:
On 9/26/2025 10:44 AM, Bonita Montero wrote:
Am 25.09.2025 um 22:18 schrieb Chris M. Thomasson:
On 9/25/2025 7:21 AM, Bonita Montero wrote:
Am 25.09.2025 um 15:56 schrieb olcott:
Does there exist a single halt decider that can
compute the mapping from its finite string input(s)
to an accept or reject value on the basis of the
semantic halting property specified by this/these
finite string input(s) for all inputs?
*Defines a different result as shown below*
-aFrom just my own two sentences (a) and (b) five LLM
systems figured out how to correctly decide the halting
problem's counter example input.
They all figured out the recursive simulation non-halting
behavior pattern on their own.
<Input to LLM systems>
Simulating Termination Analyzer HHH correctly simulates its input >>>>>> until:
-a-a(a) Detects a non-terminating behavior pattern:
-a-a-a-a-a abort simulation and return 0.
-a-a(b) Simulated input reaches its simulated "return" statement:
-a-a-a-a-a return 1.
typedef int (*ptr)();
int HHH(ptr P);
int DD()
-a-a{
-a-a int Halt_Status = HHH(DD);
-a-a if (Halt_Status)
-a-a-a-a HERE: goto HERE;
-a-a return Halt_Status;
-a-a}
What value should HHH(DD) correctly return?
</Input to LLM systems>
*Here are the best three*
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
Do something more meaningful with your life than discussing
the same detail for years. I find that absolutely insane.
I hope he listens to you.
<3
Two other PhD computer scientists agree with me.
Are they also crazy ?
https://www.cs.toronto.edu/~hehner/PHP.pdf
https://www.complang.tuwien.ac.at/anton/euroforth/ef17/papers/
stoddart.pdf
A contradiction is a piece of foreign material in a formal system. It
is nonsensical to bring it in, and assert it as a truth; it makes no
sense to do so. Once you do, it creates contagion.
The entailment relations of paraconsistent logics are propositionally
weaker than classical logic; that is, they deem fewer propositional inferences valid. The point is that a paraconsistent logic can never
be a propositional extension of classical logic, that is,
propositionally validate every entailment that classical logic
does. In some sense, then, paraconsistent logic is more conservative
or cautious than classical logic. It is due to such conservativeness
that paraconsistent languages can be more expressive than their
classical counterparts including the hierarchy of metalanguages due to
Alfred Tarski and others.
On 9/27/2025 7:14 AM, Janis Papanagnou wrote:No (currently) formal language is more expressive (and more real) than procedural language, e.g. C/C++ (precisely Turing Machine, so far).
On 27.09.2025 08:46, Jeff Barnett wrote:
On 9/26/2025 4:23 PM, Janis Papanagnou wrote:
''In 1923, Ludwig Wittgenstein proposed to "dispose" ofI've read the Tractatus and found it a lot of fun and stimulating of thought. I'm composing this note, not to argue with philosophy;
Russell's
-a-a-a paradox as follows:
[...]
-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a (Tractatus Logico-Philosophicus, 3.333)"
Neither do I (that would certainly lead to far). My intention here
is just to direct to the OP's original statement which was linking
logic and semantics, and had been speaking of "mistakes of logic":
-a-a "The big mistake of logic is that it does not retain
-a-a-a semantics as fully integrated into its formal expressions." Wittgenstein in his Tractatus (as I understood it) separated well
the factors [language-]semantics, [bool] logic, and [mathematical] "technical" aspects, including [real languages'] syntax (and [as
in programming languages] their [operational/technical] semantics).
My most interesting takeaway from T for me was the discussion that
posited that two (different?) entities that having precisely the same properties did not entail that the entities were identical, i.e., "=" in
the logical sense of merely having two names. The possibility was that
the model was not broad enough to distinguish them. This insight should
lead to a discussion of semantic sufficiency, big world assumptions and problems, and the obvious conclusion that logic is a formal, not all-informative system.
--- Synchronet 3.21a-Linux NewsLink 1.2That's why I had mentioned the necessary context for the full view!
(Some can be found around the above quoted proposition, some later
in his opus. But for a full understanding it's necessary to read
the whole text from the start.)
(My mistake was to quote the single paragraph from Wikipedia that
is covering just a specific aspect, and certainly insufficiently;
the OP's link misguided me to think that Russel's view would have
been the source of the OP's misconception. But the problem may lie
deeper; in not separating sensibly the involved categories. IMO.)
rather
to mention the realization of such such a possibility in an actual programming language. [...]
Yes.