I am doing the same thing that ZFC did to the Russell's Paradox problem. Since ZFC set theory is now called naive set theory.eedd0f09e141
After my correction the original halting problem will be called *the
naive halting problem*
*Correcting the error of the halting problem spec*
Is it possible to create a halt decider H that consistently reports the
halt status of the behavior specified by its input finite string Turing machine description P on the basis of P correctly simulated by H?
<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>
*The corrected halting problem spec says* HHH(DD)==0
Three different LLM AI systems figured this out on their own without prompting.
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-
On 8/16/2025 9:42 AM, Mr Flibble wrote:
On Sat, 16 Aug 2025 09:20:10 -0500, olcott wrote:
I am doing the same thing that ZFC did to the Russell's Paradoxeedd0f09e141
problem.
Since ZFC set theory is now called naive set theory.
After my correction the original halting problem will be called *the
naive halting problem*
*Correcting the error of the halting problem spec*
Is it possible to create a halt decider H that consistently reports
the halt status of the behavior specified by its input finite string
Turing machine description P on the basis of P correctly simulated by
H?
<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>
*The corrected halting problem spec says* HHH(DD)==0
Three different LLM AI systems figured this out on their own without
prompting.
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-
If HHH(DD) returns a result of non-halting to DD when it reports (as it
must do to be a halt decider) then DD() will halt thus confirming the
extant Halting Problem proofs are valid.
/Flibble
On 8/12/2025 2:50 PM, Kaz Kylheku wrote:
If you're trying to demonstrate your work using stateful procedures,
you must be explicit about revealing the state, and ensure that two instances of a computations which you are identifying as being of the
same computation have exactly the same initial state, same inputs,
and same subsequent state transitions. You cannot call two different computations with different state transitions "DD" and claim they are
the same.
The DD of HHH1(DD) and the directly executed DD() have the same state.
The DD of HHH(DD) has a different set of state transitions because the
fact that DD calls HHH(DD) in recursive simulation cannot be simply
ignored as everone here has done for three years.
On 8/16/2025 9:50 AM, Mr Flibble wrote:
On Sat, 16 Aug 2025 09:48:11 -0500, olcott wrote:
On 8/16/2025 9:42 AM, Mr Flibble wrote:
On Sat, 16 Aug 2025 09:20:10 -0500, olcott wrote:
I am doing the same thing that ZFC did to the Russell's Paradoxeedd0f09e141
problem.
Since ZFC set theory is now called naive set theory.
After my correction the original halting problem will be called *the >>>>> naive halting problem*
*Correcting the error of the halting problem spec*
Is it possible to create a halt decider H that consistently reports
the halt status of the behavior specified by its input finite string >>>>> Turing machine description P on the basis of P correctly simulated
by H?
<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>
*The corrected halting problem spec says* HHH(DD)==0
Three different LLM AI systems figured this out on their own without >>>>> prompting.
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-
If HHH(DD) returns a result of non-halting to DD when it reports (as
it must do to be a halt decider) then DD() will halt thus confirming
the extant Halting Problem proofs are valid.
/Flibble
On 8/12/2025 2:50 PM, Kaz Kylheku wrote:
>
> If you're trying to demonstrate your work using stateful
> procedures, you must be explicit about revealing the state, and
> ensure that two instances of a computations which you are
> identifying as being of the same computation have exactly the same
> initial state, same inputs, and same subsequent state transitions.
> You cannot call two different computations with different state
> transitions "DD" and claim they are the same.
>
>
The DD of HHH1(DD) and the directly executed DD() have the same state.
The DD of HHH(DD) has a different set of state transitions because the
fact that DD calls HHH(DD) in recursive simulation cannot be simply
ignored as everone here has done for three years.
Nope. If HHH(DD) reports non-halting to DD() then DD() will halt thus
confirming that the Halting Problem is undecidable.
/Flibble.
If Bill's identical twin brother Jack robs a liquor store then
(according to your reasoning)
Bill is guilty and Jack can go free.
Halt deciders are only required to report on the actual behavior that
their actual input actually specifies.
The only way to measure this is DD correctly simulated by HHH.
Halt deciders were never actually required to report on the behavior of directly executed machines. Textbooks say otherwise and on this point textbooks have always been wrong.
On 8/16/2025 10:34 AM, Mr Flibble wrote:
On Sat, 16 Aug 2025 09:58:01 -0500, olcott wrote:
On 8/16/2025 9:50 AM, Mr Flibble wrote:
On Sat, 16 Aug 2025 09:48:11 -0500, olcott wrote:
On 8/16/2025 9:42 AM, Mr Flibble wrote:
On Sat, 16 Aug 2025 09:20:10 -0500, olcott wrote:
I am doing the same thing that ZFC did to the Russell's Paradoxeedd0f09e141
problem.
Since ZFC set theory is now called naive set theory.
After my correction the original halting problem will be called
*the naive halting problem*
*Correcting the error of the halting problem spec*
Is it possible to create a halt decider H that consistently
reports the halt status of the behavior specified by its input
finite string Turing machine description P on the basis of P
correctly simulated by H?
<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>
*The corrected halting problem spec says* HHH(DD)==0
Three different LLM AI systems figured this out on their own
without prompting.
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-
If HHH(DD) returns a result of non-halting to DD when it reports
(as it must do to be a halt decider) then DD() will halt thus
confirming the extant Halting Problem proofs are valid.
/Flibble
On 8/12/2025 2:50 PM, Kaz Kylheku wrote:
>
> If you're trying to demonstrate your work using stateful
> procedures, you must be explicit about revealing the state, and >>>>> > ensure that two instances of a computations which you are
> identifying as being of the same computation have exactly the
> same initial state, same inputs, and same subsequent state
> transitions.
> You cannot call two different computations with different state >>>>> > transitions "DD" and claim they are the same.
>
>
The DD of HHH1(DD) and the directly executed DD() have the same
state.
The DD of HHH(DD) has a different set of state transitions because
the fact that DD calls HHH(DD) in recursive simulation cannot be
simply ignored as everone here has done for three years.
Nope. If HHH(DD) reports non-halting to DD() then DD() will halt thus
confirming that the Halting Problem is undecidable.
/Flibble.
If Bill's identical twin brother Jack robs a liquor store then
(according to your reasoning)
Bill is guilty and Jack can go free.
Halt deciders are only required to report on the actual behavior that
their actual input actually specifies.
The only way to measure this is DD correctly simulated by HHH.
Halt deciders were never actually required to report on the behavior
of directly executed machines. Textbooks say otherwise and on this
point textbooks have always been wrong.
If HHH(DD) reports non-halting to DD() then DD() will halt thus
confirming that the Halting Problem is undecidable.
/Flibble.
Yes the naive halting problem does get the wrong answer. The naive
halting problem incorrectly believes that HHH must report on the
behavior of DD().
I am doing the same thing that ZFC did to the
Russell's Paradox problem. Since ZFC set theory
is now called naive set theory.
After my correction the original halting problem
will be called *the naive halting problem*
On 16/08/2025 15:20, olcott wrote:
I am doing the same thing that ZFC did to the Russell's Paradox
problem. Since ZFC set theory is now called naive set theory.
After my correction the original halting problem will be called *the
naive halting problem*
So what does that mean? You're working on something else?
Fine.
I am doing the same thing that ZFC did to the
Russell's Paradox problem. Since ZFC set theory
is now called naive set theory.
After my correction the original halting problem
will be called *the naive halting problem*
*Correcting the error of the halting problem spec*
Is it possible to create a halt decider H that consistently
reports the halt status of the behavior specified by its
input finite string Turing machine description P on the
basis of P correctly simulated by H?
<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>
*The corrected halting problem spec says* HHH(DD)==0
Three different LLM AI systems figured this out
on their own without prompting.
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
On 8/16/2025 12:14 PM, dbush wrote:
On 8/16/2025 1:12 PM, olcott wrote:
On 8/16/2025 11:51 AM, dbush wrote:And that expectation follows from a series of truth preserving
On 8/16/2025 11:02 AM, olcott wrote:
On 8/16/2025 10:00 AM, dbush wrote:
On 8/16/2025 10:20 AM, olcott wrote:
I am doing the same thing that ZFC did to the
Russell's Paradox problem. Since ZFC set theory
is now called naive set theory.
After my correction the original halting problem
will be called *the naive halting problem*
*Correcting the error of the halting problem spec*
Is it possible to create a halt decider H that consistently
reports the halt status of the behavior specified by its
input finite string Turing machine description P on the
basis of P correctly simulated by H?
In other words, the you admit Linz proof of the naive halting
problem that a naive halt decider cannot exits is correct.
I admit that the Linz proof is naive.
In other words, you can't find an error in the Linz proof.
The error is that Linz expects the halt decider
to report on its own behavior
operations starting from the assumption that H is a total halt decider.
It does not. No Turing machine decider can
ever directly report on its own behavior it
can at best only indirectly report on its behavior
through the proxy of its machine description.
Even if this is a perfect proxy it remains the
case that no Turing machine decider can ever
directly report on its own behavior.
If there is any way that M.H ⟨M⟩ ⟨M⟩ can see
that it remains stuck in recursive simulation
then we know that its machine description is
not a perfect proxy for its behavior in the
single case shown below.
Even if M.H ⟨M⟩ ⟨M⟩ cannot see this then it is
still true that M applied to ⟨M⟩ remains stuck
in recursive simulation.
Machine M contains simulating halt decider H
M.q0 ⟨M⟩ ⊢* M.H ⟨M⟩ ⟨M⟩ ⊢* M.∞
M.q0 ⟨M⟩ ⊢* M.H ⟨M⟩ ⟨M⟩ ⊢* M.qn
*Repeats until aborted proving non-halting*
(a) M copies its input ⟨M⟩
(b) M invokes M.H ⟨M⟩ ⟨M⟩
(c) M.H simulates ⟨M⟩ ⟨M⟩
then M.H ⟨M⟩ ⟨M⟩ transitions to M.qn
causing M applied to ⟨M⟩ halt
On 8/16/2025 2:11 PM, dbush wrote:
On 8/16/2025 3:01 PM, olcott wrote:
On 8/16/2025 12:14 PM, dbush wrote:
On 8/16/2025 1:12 PM, olcott wrote:It does not.
On 8/16/2025 11:51 AM, dbush wrote:And that expectation follows from a series of truth preserving
On 8/16/2025 11:02 AM, olcott wrote:
On 8/16/2025 10:00 AM, dbush wrote:
On 8/16/2025 10:20 AM, olcott wrote:
I am doing the same thing that ZFC did to the
Russell's Paradox problem. Since ZFC set theory
is now called naive set theory.
After my correction the original halting problem
will be called *the naive halting problem*
*Correcting the error of the halting problem spec*
Is it possible to create a halt decider H that consistently
reports the halt status of the behavior specified by its
input finite string Turing machine description P on the
basis of P correctly simulated by H?
In other words, the you admit Linz proof of the naive halting
problem that a naive halt decider cannot exits is correct.
I admit that the Linz proof is naive.
In other words, you can't find an error in the Linz proof.
The error is that Linz expects the halt decider
to report on its own behavior
operations starting from the assumption that H is a total halt decider. >>>
Then show which step in the Linz proof is in error.
No Turing machine decider can
ever directly report on its own behavior it
can at best only indirectly report on its behavior
through the proxy of its machine description.
Error: assuming the conclusion
I am assuming the definition of Turing machines
that no Turing machine can take another actual
Turing machine as an input. You skipped over
the word *DIRECTLY REPORT* That you fail to pay
close attention is not my mistake.
Even if this is a perfect proxy
Which it is as proven by UTM(X) exactly duplicating the behavior of
X() in all cases.
it remains the
case that no Turing machine decider can ever
directly report on its own behavior.
Error: assuming the conclusion
On 8/16/2025 2:18 PM, dbush wrote:
On 8/16/2025 3:16 PM, olcott wrote:
On 8/16/2025 2:11 PM, dbush wrote:Then you believe that Turing machines can't do arithmetic because no
On 8/16/2025 3:01 PM, olcott wrote:
On 8/16/2025 12:14 PM, dbush wrote:
On 8/16/2025 1:12 PM, olcott wrote:
On 8/16/2025 11:51 AM, dbush wrote:And that expectation follows from a series of truth preserving
On 8/16/2025 11:02 AM, olcott wrote:
On 8/16/2025 10:00 AM, dbush wrote:
On 8/16/2025 10:20 AM, olcott wrote:
I am doing the same thing that ZFC did to the
Russell's Paradox problem. Since ZFC set theory
is now called naive set theory.
After my correction the original halting problem
will be called *the naive halting problem*
*Correcting the error of the halting problem spec*
Is it possible to create a halt decider H that consistently >>>>>>>>>>> reports the halt status of the behavior specified by its >>>>>>>>>>> input finite string Turing machine description P on the
basis of P correctly simulated by H?
In other words, the you admit Linz proof of the naive halting >>>>>>>>>> problem that a naive halt decider cannot exits is correct. >>>>>>>>>>
I admit that the Linz proof is naive.
In other words, you can't find an error in the Linz proof.
The error is that Linz expects the halt decider
to report on its own behavior
operations starting from the assumption that H is a total halt
decider.
It does not.
Then show which step in the Linz proof is in error.
No Turing machine decider can
ever directly report on its own behavior it
can at best only indirectly report on its behavior
through the proxy of its machine description.
Error: assuming the conclusion
I am assuming the definition of Turing machines
that no Turing machine can take another actual
Turing machine as an input.
Turing machine can take an actual number as input.
Not at all. This is merely your attention deficit disorder
inability to pay attention to the difference between
DIRECTLY REPORT and INDIRECTLY REPORT. Because of ADD
you only glance at a couple of my words before contriving
an incorrect rebuttal.
On 8/16/2025 3:13 PM, dbush wrote:
On 8/16/2025 3:24 PM, olcott wrote:
On 8/16/2025 2:18 PM, dbush wrote:And because Turing machines can't DIRECTLY report on the values of
On 8/16/2025 3:16 PM, olcott wrote:
On 8/16/2025 2:11 PM, dbush wrote:Then you believe that Turing machines can't do arithmetic because no
On 8/16/2025 3:01 PM, olcott wrote:
On 8/16/2025 12:14 PM, dbush wrote:
On 8/16/2025 1:12 PM, olcott wrote:
On 8/16/2025 11:51 AM, dbush wrote:And that expectation follows from a series of truth preserving >>>>>>>> operations starting from the assumption that H is a total halt >>>>>>>> decider.
On 8/16/2025 11:02 AM, olcott wrote:
On 8/16/2025 10:00 AM, dbush wrote:
On 8/16/2025 10:20 AM, olcott wrote:
I am doing the same thing that ZFC did to the
Russell's Paradox problem. Since ZFC set theory
is now called naive set theory.
After my correction the original halting problem
will be called *the naive halting problem*
*Correcting the error of the halting problem spec*
Is it possible to create a halt decider H that consistently >>>>>>>>>>>>> reports the halt status of the behavior specified by its >>>>>>>>>>>>> input finite string Turing machine description P on the >>>>>>>>>>>>> basis of P correctly simulated by H?
In other words, the you admit Linz proof of the naive
halting problem that a naive halt decider cannot exits is >>>>>>>>>>>> correct.
I admit that the Linz proof is naive.
In other words, you can't find an error in the Linz proof.
The error is that Linz expects the halt decider
to report on its own behavior
It does not.
Then show which step in the Linz proof is in error.
No Turing machine decider can
ever directly report on its own behavior it
can at best only indirectly report on its behavior
through the proxy of its machine description.
Error: assuming the conclusion
I am assuming the definition of Turing machines
that no Turing machine can take another actual
Turing machine as an input.
Turing machine can take an actual number as input.
Not at all. This is merely your attention deficit disorder
inability to pay attention to the difference between
DIRECTLY REPORT and INDIRECTLY REPORT.
actual numbers, Turing machines can't do arithmetic.
Agreed?
There is no functional difference in this case.
In the case of HHH(DD) recognizing recursive
emulation there is a big difference.
On 8/16/2025 3:26 PM, dbush wrote:
On 8/16/2025 4:21 PM, olcott wrote:
On 8/16/2025 3:13 PM, dbush wrote:
On 8/16/2025 3:24 PM, olcott wrote:
On 8/16/2025 2:18 PM, dbush wrote:And because Turing machines can't DIRECTLY report on the values of
On 8/16/2025 3:16 PM, olcott wrote:
On 8/16/2025 2:11 PM, dbush wrote:Then you believe that Turing machines can't do arithmetic because
On 8/16/2025 3:01 PM, olcott wrote:
On 8/16/2025 12:14 PM, dbush wrote:
On 8/16/2025 1:12 PM, olcott wrote:
On 8/16/2025 11:51 AM, dbush wrote:And that expectation follows from a series of truth preserving >>>>>>>>>> operations starting from the assumption that H is a total halt >>>>>>>>>> decider.
On 8/16/2025 11:02 AM, olcott wrote:The error is that Linz expects the halt decider
On 8/16/2025 10:00 AM, dbush wrote:
On 8/16/2025 10:20 AM, olcott wrote:
I am doing the same thing that ZFC did to the
Russell's Paradox problem. Since ZFC set theory
is now called naive set theory.
After my correction the original halting problem >>>>>>>>>>>>>>> will be called *the naive halting problem*
*Correcting the error of the halting problem spec* >>>>>>>>>>>>>>> Is it possible to create a halt decider H that consistently >>>>>>>>>>>>>>> reports the halt status of the behavior specified by its >>>>>>>>>>>>>>> input finite string Turing machine description P on the >>>>>>>>>>>>>>> basis of P correctly simulated by H?
In other words, the you admit Linz proof of the naive >>>>>>>>>>>>>> halting problem that a naive halt decider cannot exits is >>>>>>>>>>>>>> correct.
I admit that the Linz proof is naive.
In other words, you can't find an error in the Linz proof. >>>>>>>>>>>
to report on its own behavior
It does not.
Then show which step in the Linz proof is in error.
No Turing machine decider can
ever directly report on its own behavior it
can at best only indirectly report on its behavior
through the proxy of its machine description.
Error: assuming the conclusion
I am assuming the definition of Turing machines
that no Turing machine can take another actual
Turing machine as an input.
no Turing machine can take an actual number as input.
Not at all. This is merely your attention deficit disorder
inability to pay attention to the difference between
DIRECTLY REPORT and INDIRECTLY REPORT.
actual numbers, Turing machines can't do arithmetic.
Agreed?
There is no functional difference in this case.
In the case of HHH(DD) recognizing recursive
emulation
It does so by using an extra input and is therefore DISQUALIFIED from
being a halt decider / termination analyzer.
It only needs to watch the details of the simulation
of its input by some means. Thus it is still only
about the input.
I am doing the same thing that ZFC did to the
Russell's Paradox problem. Since ZFC set theory
is now called naive set theory.
After my correction the original halting problem
will be called *the naive halting problem*
*Correcting the error of the halting problem spec*
Is it possible to create a halt decider H that consistently
reports the halt status of the behavior specified by its
input finite string Turing machine description P on the
basis of P correctly simulated by H?
On 8/17/2025 4:03 AM, Mikko wrote:
On 2025-08-16 14:20:10 +0000, olcott said:
I am doing the same thing that ZFC did to the
Russell's Paradox problem. Since ZFC set theory
is now called naive set theory.
You can't do the same because you don't have a paradox problem.
That both return values from HHH(DD) are
contradicted by the behavior of the directly DD()
is a paradox that is abolished when we understand
that Turing machine deciders only compute the
mapping from their inputs, thus the behavior
of non-input DD() is of no consequence.
On 8/17/2025 9:57 AM, Bonita Montero wrote:
Am 16.08.2025 um 16:20 schrieb olcott:
I am doing the same thing that ZFC did to the
Russell's Paradox problem. Since ZFC set theory
is now called naive set theory.
After my correction the original halting problem
will be called *the naive halting problem*
*Correcting the error of the halting problem spec*
Is it possible to create a halt decider H that consistently
reports the halt status of the behavior specified by its
input finite string Turing machine description P on the
basis of P correctly simulated by H?
<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>
*The corrected halting problem spec says* HHH(DD)==0
Three different LLM AI systems figured this out
on their own without prompting.
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
You're always wrong and ereryone knows it.
If that was true then they could point out the error
that five different LLM systems made when they figured
out my same reasoning on their own without being prompted.
All of the recent rebuttals of the essence of my work
are provable counter-factual.
It is a verified fact that DD correctly simulated by HHH
cannot possibly reach its own simulated "return" statement
final halt state thus making HHH(DD)==0 necessarily correct.
*Here is a PhD computer science professor that agrees*
*with that essence of my work long before I ever said it*
*Professor Hehner recognized this repeating process before I did*
From a programmer's point of view, if we apply
an interpreter to a program text that includes
a call to that same interpreter with that same
text as argument, then we have an infinite loop.
A halting program has some of the same character
as an interpreter: it applies to texts through
abstract interpretation. Unsurprisingly, if we
apply a halting program to a program text that
includes a call to that same halting program
with that same text as argument, then we have an
infinite loop. (Hehner:2011:15)
[5] E C R Hehner. Problems with the Halting Problem,
COMPUTING2011 Symposium on 75 years of Turing Machine
and Lambda-Calculus, Karlsruhe Germany, invited,
2011 October 20-21; Advances in Computer Science
and Engineering v.10 n.1 p.31-60, 2013 https://www.cs.toronto.edu/~hehner/PHP.pdf
On 8/17/25 11:12 AM, olcott wrote:
On 8/17/2025 9:57 AM, Bonita Montero wrote:
Am 16.08.2025 um 16:20 schrieb olcott:If that was true then they could point out the error that five
I am doing the same thing that ZFC did to the Russell's ParadoxYou're always wrong and ereryone knows it.
problem. Since ZFC set theory is now called naive set theory.
After my correction the original halting problem will be called *the
naive halting problem*
*Correcting the error of the halting problem spec*
Is it possible to create a halt decider H that consistently reports
the halt status of the behavior specified by its input finite string
Turing machine description P on the basis of P correctly simulated by
H?
<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>
*The corrected halting problem spec says* HHH(DD)==0
Three different LLM AI systems figured this out on their own without
prompting.
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
different LLM systems made when they figured out my same reasoning on
their own without being prompted.
HHH(DD) says that DD does not halt.
DD when run halts.
Therefore HHH(DD) is wrong, by the definition of the problem
Trying to change the definition of the problem is just a lie, for which
you freely admit you are doing.
Thus, since you changing of definition expeled your logic from the field
of Computablilty Theory, very time you claim to be working on or showing something about that field is just a LIE.
All of the recent rebuttals of the essence of my work are provable
counter-factual.
Nope, since you ADMIT that you system is built on changing the
definitions, and thus is a LIE.
It is a verified fact that DD correctly simulated by HHH cannot
possibly reach its own simulated "return" statement final halt state
thus making HHH(DD)==0 necessarily correct.
Nope, since you HHH doesn't do a correct simulation and thus you prove
your logic is built on lying.
*Here is a PhD computer science professor that agrees*
*with that essence of my work long before I ever said it*
*Professor Hehner recognized this repeating process before I did*
From a programmer's point of view, if we apply an interpreter to a
program text that includes a call to that same interpreter with
that same text as argument, then we have an infinite loop.
A halting program has some of the same character as an interpreter:
it applies to texts through abstract interpretation.
Unsurprisingly, if we apply a halting program to a program text
that includes a call to that same halting program with that same
text as argument, then we have an infinite loop. (Hehner:2011:15)
No, because he makes the same error as you do of assuming that the input isn't built on the actual decider, but the idealized version of the
decide3r.
[5] E C R Hehner. Problems with the Halting Problem, COMPUTING2011
Symposium on 75 years of Turing Machine and Lambda-Calculus, Karlsruhe
Germany, invited,
2011 October 20-21; Advances in Computer Science and Engineering v.10
n.1 p.31-60, 2013 https://www.cs.toronto.edu/~hehner/PHP.pdf
Note, Professor Hebner makes a number of errors in his paper, which
shows his lack of knowledge in the field, and explains why he makes some
of his errors. On clear one is that he states:
In Turing's time, programs were commands to a computer. Today, they are
also mathematical expressions in their own right
But in Turing's time, "Computers" as we know then didn't really exists,
a "computer" was a person following an instruction deck recording
results. And Turing's discussion of "programs" was largely built on the mathematics expressions that he claims came later.
The whole field of computability was being developed to see if the
problems of statements being unprovable could be eliminated by the presumption of a powerful enough algorithm runner that could
diffinatively answer the questions. The proof of the theroetical
limitations of such an algorithm runner let mathematics move on from
trying to avoid incompleteness, but to embrace it and move on.
You are just stuck in a world a century old, trying to back the people
that were trying to fight against the truth being revealed.
You put yourself on the side that eventually admitted defeat, and are
just more ignorant then them and refuse to accept what they eventually
did.
Yes, there are systems that can avoid this incompleteness problem, but
they are, by necessity, severely limited in domain, and are largley considered to be "toys" for most real work. But of course, there is a
place to look at the study of toys, but those need to understand the limitations of the field.
The fact that you don't (and refuse to) understand the known limits just makes you stupid.
On Sun, 17 Aug 2025 15:12:01 -0400, Richard Damon wrote:
On 8/17/25 11:12 AM, olcott wrote:
On 8/17/2025 9:57 AM, Bonita Montero wrote:
Am 16.08.2025 um 16:20 schrieb olcott:If that was true then they could point out the error that five
I am doing the same thing that ZFC did to the Russell's ParadoxYou're always wrong and ereryone knows it.
problem. Since ZFC set theory is now called naive set theory.
After my correction the original halting problem will be called *the >>>>> naive halting problem*
*Correcting the error of the halting problem spec*
Is it possible to create a halt decider H that consistently reports
the halt status of the behavior specified by its input finite string >>>>> Turing machine description P on the basis of P correctly simulated by >>>>> H?
<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>
*The corrected halting problem spec says* HHH(DD)==0
Three different LLM AI systems figured this out on their own without >>>>> prompting.
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
different LLM systems made when they figured out my same reasoning on
their own without being prompted.
HHH(DD) says that DD does not halt.
DD when run halts.
Therefore HHH(DD) is wrong, by the definition of the problem
Trying to change the definition of the problem is just a lie, for which
you freely admit you are doing.
Thus, since you changing of definition expeled your logic from the field
of Computablilty Theory, very time you claim to be working on or showing
something about that field is just a LIE.
All of the recent rebuttals of the essence of my work are provable
counter-factual.
Nope, since you ADMIT that you system is built on changing the
definitions, and thus is a LIE.
It is a verified fact that DD correctly simulated by HHH cannot
possibly reach its own simulated "return" statement final halt state
thus making HHH(DD)==0 necessarily correct.
Nope, since you HHH doesn't do a correct simulation and thus you prove
your logic is built on lying.
*Here is a PhD computer science professor that agrees*
*with that essence of my work long before I ever said it*
*Professor Hehner recognized this repeating process before I did*
From a programmer's point of view, if we apply an interpreter to a
program text that includes a call to that same interpreter with
that same text as argument, then we have an infinite loop.
A halting program has some of the same character as an interpreter: >>> it applies to texts through abstract interpretation.
Unsurprisingly, if we apply a halting program to a program text
that includes a call to that same halting program with that same
text as argument, then we have an infinite loop. (Hehner:2011:15)
No, because he makes the same error as you do of assuming that the input
isn't built on the actual decider, but the idealized version of the
decide3r.
[5] E C R Hehner. Problems with the Halting Problem, COMPUTING2011
Symposium on 75 years of Turing Machine and Lambda-Calculus, Karlsruhe
Germany, invited,
2011 October 20-21; Advances in Computer Science and Engineering v.10
n.1 p.31-60, 2013 https://www.cs.toronto.edu/~hehner/PHP.pdf
Note, Professor Hebner makes a number of errors in his paper, which
shows his lack of knowledge in the field, and explains why he makes some
of his errors. On clear one is that he states:
In Turing's time, programs were commands to a computer. Today, they are
also mathematical expressions in their own right
But in Turing's time, "Computers" as we know then didn't really exists,
a "computer" was a person following an instruction deck recording
results. And Turing's discussion of "programs" was largely built on the
mathematics expressions that he claims came later.
The whole field of computability was being developed to see if the
problems of statements being unprovable could be eliminated by the
presumption of a powerful enough algorithm runner that could
diffinatively answer the questions. The proof of the theroetical
limitations of such an algorithm runner let mathematics move on from
trying to avoid incompleteness, but to embrace it and move on.
You are just stuck in a world a century old, trying to back the people
that were trying to fight against the truth being revealed.
You put yourself on the side that eventually admitted defeat, and are
just more ignorant then them and refuse to accept what they eventually
did.
Yes, there are systems that can avoid this incompleteness problem, but
they are, by necessity, severely limited in domain, and are largley
considered to be "toys" for most real work. But of course, there is a
place to look at the study of toys, but those need to understand the
limitations of the field.
The fact that you don't (and refuse to) understand the known limits just
makes you stupid.
Olcott hasn't replied to you for a while so I think you are wasting your
time replying to him, he might have killfiled you.
/Flibble
On 8/17/2025 4:03 AM, Mikko wrote:
On 2025-08-16 14:20:10 +0000, olcott said:
I am doing the same thing that ZFC did to the
Russell's Paradox problem. Since ZFC set theory
is now called naive set theory.
You can't do the same because you don't have a paradox problem.
That both return values from HHH(DD) are
contradicted by the behavior of the directly DD()
is a paradox that is abolished when we understand
that Turing machine deciders only compute the
mapping from their inputs, thus the behavior
of non-input DD() is of no consequence.
If an *actual input* actually exists (no such input exists)
that can do the opposite of whatever its halt decider reports
then it would be impossible to say what the correct return
value from the decider should be.
On 8/18/2025 4:08 AM, Mikko wrote:
On 2025-08-17 15:48:10 +0000, olcott said:
On 8/17/2025 4:03 AM, Mikko wrote:
On 2025-08-16 14:20:10 +0000, olcott said:
I am doing the same thing that ZFC did to the
Russell's Paradox problem. Since ZFC set theory
is now called naive set theory.
You can't do the same because you don't have a paradox problem.
That both return values from HHH(DD) are
contradicted by the behavior of the directly DD()
is a paradox that is abolished when we understand
that Turing machine deciders only compute the
mapping from their inputs, thus the behavior
of non-input DD() is of no consequence.
That is not a paradox. That is how DD is constructed. A paradox is
something that seems impossible. But one can see DD so it obviously
is possible.
"This sentence is not true" It is not possible to
correctly determine whether that sentence is true or false.
And one can see HHH so there is nothing impossible
there, either. And even wihout seeing HHH it is quite credible that
it may always return either zero or something else (DD does not
care what else if not zero).
The only paradox is if HHH is assumed to be a halt decider.
But the paradox disappears when we note that HHH is not a lalt decider.
If an *actual input* actually exists (no such input exists)
that can do the opposite of whatever its halt decider reports
then it would be impossible to say what the correct return
value from the decider should be.
If an *actual input* actually exists (no such input exists)
that can do the opposite of whatever its halt decider reports
then it would be impossible to say what the correct return
value from the decider should be.
On 8/18/2025 4:08 AM, Mikko wrote:
On 2025-08-17 15:48:10 +0000, olcott said:
On 8/17/2025 4:03 AM, Mikko wrote:
On 2025-08-16 14:20:10 +0000, olcott said:
I am doing the same thing that ZFC did to the
Russell's Paradox problem. Since ZFC set theory
is now called naive set theory.
You can't do the same because you don't have a paradox problem.
That both return values from HHH(DD) are
contradicted by the behavior of the directly DD()
is a paradox that is abolished when we understand
that Turing machine deciders only compute the
mapping from their inputs, thus the behavior
of non-input DD() is of no consequence.
That is not a paradox. That is how DD is constructed. A paradox is
something that seems impossible. But one can see DD so it obviously
is possible.
"This sentence is not true" It is not possible to
correctly determine whether that sentence is true or false.
On 8/18/2025 4:08 AM, Mikko wrote:
On 2025-08-17 15:48:10 +0000, olcott said:
On 8/17/2025 4:03 AM, Mikko wrote:
On 2025-08-16 14:20:10 +0000, olcott said:
I am doing the same thing that ZFC did to the
Russell's Paradox problem. Since ZFC set theory
is now called naive set theory.
You can't do the same because you don't have a paradox problem.
That both return values from HHH(DD) are
contradicted by the behavior of the directly DD()
is a paradox that is abolished when we understand
that Turing machine deciders only compute the
mapping from their inputs, thus the behavior
of non-input DD() is of no consequence.
That is not a paradox. That is how DD is constructed. A paradox is
something that seems impossible. But one can see DD so it obviously
is possible.
"This sentence is not true" It is not possible to
correctly determine whether that sentence is true or false.
And one can see HHH so there is nothing impossible
there, either. And even wihout seeing HHH it is quite credible that
it may always return either zero or something else (DD does not
care what else if not zero).
The only paradox is if HHH is assumed to be a halt decider.
But the paradox disappears when we note that HHH is not a lalt decider.
If an *actual input* actually exists (no such input exists)
that can do the opposite of whatever its halt decider reports
then it would be impossible to say what the correct return
value from the decider should be.
Irrelevant. What matters is that there is an actual input that is
known to specify a halting behaviour but reported as non-halting
by HHH. But that is a feature of HHH, not of the halting problem.
On 8/19/2025 2:52 AM, Richard Heathfield wrote:
On 19/08/2025 08:37, Mikko wrote:
Irrelevant. What matters is that there is an actual input that is
known to specify a halting behaviour but reported as non-halting
by HHH. But that is a feature of HHH, not of the halting problem.
Yes, and it should also be noted that the halting behaviour
itself is also a feature of HHH, and that only because of
runaway recursion. There is nothing inherent in DD that causes
it to halt. Whether it halts is entirely in the hands of HHH's
behaviour and its own bloody-mindedness.
To illustrate this, we can take HHH and DD out of the equation
and hypothesise an EE, wholly parallel in structure to DD,
which is submitted not to simulation and recursion but to
intelligent analysis of its source code:
int EE()
{
int Halt_Status = JJJ("ee.src");
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
Unlike HHH, JJJ will not make the rookie error of ignoring 75%
of the input, but of course it will still get the answer wrong.
Why? Because the problem is in the general case incomputable.
Turing machine deciders only compute the mapping
from their inputs...
This is best measured by simulating N steps of
the input
On 8/19/2025 10:20 AM, Richard Heathfield wrote:
On 19/08/2025 16:04, olcott wrote:
This is best measured by simulating N steps of
the input
Assumes facts not in evidence.
The only simulator in evidence - yours - patently fails to
measure the behaviour of a 7-line C function. We can do better
by inspection, or we can run it directly - either way, the
simulator gets it wrong.
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.
On 8/19/2025 1:16 AM, Kaz Kylheku wrote:
On 2025-08-18, olcott <polcott333@gmail.com> wrote:
If an *actual input* actually exists (no such input exists)
that can do the opposite of whatever its halt decider reports
then it would be impossible to say what the correct return
value from the decider should be.
No it isn't. Every Turing machine either halts or does not,
so there is a correct answer.
Yet in the above hypothetical case we are not looking
at whether it halts or not, we are looking at what the
correct return value would be.
*From the bottom of page 319 has been adapted to this* https://www.liarparadox.org/Peter_Linz_HP_317-320.pdf
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.∞,
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
Linz requires the second named state of Turing
machine Ĥ to report on the behavior of its own
machine rather than the behavior of its input.
When the second named state of Turing machine Ĥ
reports on the behavior of its correct simulation
of its input
*Repeats until aborted*
(a) Ĥ copies its input ⟨Ĥ⟩
(b) Ĥ invokes embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩
(c) embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩
*thus making this state transition correct*
Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
As long as the decider reports on the behavior
specified by its input then it is correct because
Turing machine deciders only compute the mapping
from their inputs...
All that is impossible is for that decider that has been embedded into
the test case to return the correct answer for that test case. The
decider returns something incorrect, or else does not halt.
You cannot "edit" the decider to try to fix it. There is
no "edit" in mathematics. The decider is an entity commited
to existence, and cannot be other than what it is.
You can propose a different decider. For that different decider
a new test case can be constructed in which it either doesn't
terminate or returns the wrong answer.
In your latest coding attempt, you have resorted to self-modifying
code. That's a very clear way to communicate that your configuration
does not contain one single decider. It starts out as one function
and morphs into a different one.
I can't fathom how you can have it so that two instances of the same
HHH(DD) expression have two different behaviors, yet believe that there
is one HHH which is a function of DD, and that HHH is correctly
deciding.
On 8/19/2025 1:16 AM, Kaz Kylheku wrote:
On 2025-08-18, olcott <polcott333@gmail.com> wrote:
If an *actual input* actually exists (no such input exists)
that can do the opposite of whatever its halt decider reports
then it would be impossible to say what the correct return
value from the decider should be.
No it isn't. Every Turing machine either halts or does not,
so there is a correct answer.
Yet in the above hypothetical case we are not looking
at whether it halts or not, we are looking at what the
correct return value would be.
*From the bottom of page 319 has been adapted to this* https://www.liarparadox.org/Peter_Linz_HP_317-320.pdf
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.∞,
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
Linz requires the second named state of Turing
machine Ĥ to report on the behavior of its own
machine rather than the behavior of its input.
When the second named state of Turing machine Ĥ
reports on the behavior of its correct simulation
of its input
*Repeats until aborted*
(a) Ĥ copies its input ⟨Ĥ⟩
(b) Ĥ invokes embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩
(c) embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩
*thus making this state transition correct*
Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
As long as the decider reports on the behavior
specified by its input then it is correct because
Turing machine deciders only compute the mapping
from their inputs...
All that is impossible is for that decider that has been embedded into
the test case to return the correct answer for that test case. The
decider returns something incorrect, or else does not halt.
You cannot "edit" the decider to try to fix it. There is
no "edit" in mathematics. The decider is an entity commited
to existence, and cannot be other than what it is.
You can propose a different decider. For that different decider
a new test case can be constructed in which it either doesn't
terminate or returns the wrong answer.
In your latest coding attempt, you have resorted to self-modifying
code. That's a very clear way to communicate that your configuration
does not contain one single decider. It starts out as one function
and morphs into a different one.
I can't fathom how you can have it so that two instances of the same
HHH(DD) expression have two different behaviors, yet believe that there
is one HHH which is a function of DD, and that HHH is correctly
deciding.
On 8/19/2025 1:33 AM, Kaz Kylheku wrote:
On 2025-08-18, olcott <polcott333@gmail.com> wrote:
On 8/18/2025 4:08 AM, Mikko wrote:
On 2025-08-17 15:48:10 +0000, olcott said:
On 8/17/2025 4:03 AM, Mikko wrote:
On 2025-08-16 14:20:10 +0000, olcott said:
I am doing the same thing that ZFC did to the
Russell's Paradox problem. Since ZFC set theory
is now called naive set theory.
You can't do the same because you don't have a paradox problem.
That both return values from HHH(DD) are
contradicted by the behavior of the directly DD()
is a paradox that is abolished when we understand
that Turing machine deciders only compute the
mapping from their inputs, thus the behavior
of non-input DD() is of no consequence.
That is not a paradox. That is how DD is constructed. A paradox is
something that seems impossible. But one can see DD so it obviously
is possible.
"This sentence is not true" It is not possible to
correctly determine whether that sentence is true or false.
However, it is possible to determine whether the evaluation
of the sentence's truth value terminates. (Spoiler: it doesn't).
?- LP = not(true(LP)).
LP = not(true(LP)).
?- unify_with_occurs_check(LP, not(true(LP))).
false.
And that's the only way in which it is related to halting,
if at all.
DD is not a paradox; it is not analogous to the Liar Paradox.
It never was even a paradox when we realize that there
never was an actual input that does the opposite of
whatever the decider decides.
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
DD correctly simulated by HHH never reaches its own
simulated "if" statement, thus to "do the opposite"
code is unreachable.
We can see that DD correctly simulated by HHH would
never stop running, thus we can see that it would be
correct for HHH(DD) to abort its simulation and return 0.
The Halting Theorem is related to Gödel's Incompleteness.
Gödel uses a construction resembling the Liar Paradox, but which
markedly differs from it. It is more similar (though also not the same
as) the sentence "This sentence cannot be proved". Note that this
sentence can be assumed true without any contradiction; it doesn't have
a runaway recursion issue if given that value.
?- G = not(provable(F, G)).
G = not(provable(F, G)).
?- unify_with_occurs_check(G, not(provable(F, G))).
false.
In short, you cannot appeal to the Liar Paradox to make any relevant
analogy or valid argument in any of these areas.
It's just used as a tool for introducing a certain aspect of the topic
to complete neophytes.
Prolog seems to disagree.
On 8/19/2025 2:37 AM, Mikko wrote:
On 2025-08-18 17:43:56 +0000, olcott said:
On 8/18/2025 4:08 AM, Mikko wrote:
On 2025-08-17 15:48:10 +0000, olcott said:
On 8/17/2025 4:03 AM, Mikko wrote:
On 2025-08-16 14:20:10 +0000, olcott said:
I am doing the same thing that ZFC did to the
Russell's Paradox problem. Since ZFC set theory
is now called naive set theory.
You can't do the same because you don't have a paradox problem.
That both return values from HHH(DD) are
contradicted by the behavior of the directly DD()
is a paradox that is abolished when we understand
that Turing machine deciders only compute the
mapping from their inputs, thus the behavior
of non-input DD() is of no consequence.
That is not a paradox. That is how DD is constructed. A paradox is
something that seems impossible. But one can see DD so it obviously
is possible.
"This sentence is not true" It is not possible to
correctly determine whether that sentence is true or false.
Doesn't matter. The truth value of that sentence is not needed for
any useful purpose.
It was the basis for the Tarski proof that
Boolean True(Language L, Expression e) cannot be computed. https://liarparadox.org/Tarski_247_248.pdf
On 8/26/2025 3:54 AM, Mikko wrote:
On 2025-08-19 15:04:36 +0000, olcott said:
On 8/19/2025 2:37 AM, Mikko wrote:
On 2025-08-18 17:43:56 +0000, olcott said:
On 8/18/2025 4:08 AM, Mikko wrote:
On 2025-08-17 15:48:10 +0000, olcott said:
On 8/17/2025 4:03 AM, Mikko wrote:
On 2025-08-16 14:20:10 +0000, olcott said:That both return values from HHH(DD) are
I am doing the same thing that ZFC did to the
Russell's Paradox problem. Since ZFC set theory
is now called naive set theory.
You can't do the same because you don't have a paradox problem. >>>>>>>
contradicted by the behavior of the directly DD()
is a paradox that is abolished when we understand
that Turing machine deciders only compute the
mapping from their inputs, thus the behavior
of non-input DD() is of no consequence.
That is not a paradox. That is how DD is constructed. A paradox is >>>>>> something that seems impossible. But one can see DD so it obviously >>>>>> is possible.
"This sentence is not true" It is not possible to
correctly determine whether that sentence is true or false.
Doesn't matter. The truth value of that sentence is not needed for
any useful purpose.
It was the basis for the Tarski proof that
Boolean True(Language L, Expression e) cannot be computed.
https://liarparadox.org/Tarski_247_248.pdf
The expression, not the truth value of the expression.
The Liar Paradox cannot be derived through Rules applied to Facts https://en.wikipedia.org/wiki/Negation_as_failure
Thus is rejected by Prolog proving that Tarski was
incorrect to use it as any basis.
?- LP = not(true(LP)).
LP = not(true(LP)).
?- unify_with_occurs_check(LP, not(true(LP))).
false.
On 8/26/2025 3:54 AM, Mikko wrote:
On 2025-08-19 15:04:36 +0000, olcott said:
On 8/19/2025 2:37 AM, Mikko wrote:
On 2025-08-18 17:43:56 +0000, olcott said:
On 8/18/2025 4:08 AM, Mikko wrote:
On 2025-08-17 15:48:10 +0000, olcott said:
On 8/17/2025 4:03 AM, Mikko wrote:
On 2025-08-16 14:20:10 +0000, olcott said:That both return values from HHH(DD) are
I am doing the same thing that ZFC did to the
Russell's Paradox problem. Since ZFC set theory
is now called naive set theory.
You can't do the same because you don't have a paradox problem. >>>>>>>
contradicted by the behavior of the directly DD()
is a paradox that is abolished when we understand
that Turing machine deciders only compute the
mapping from their inputs, thus the behavior
of non-input DD() is of no consequence.
That is not a paradox. That is how DD is constructed. A paradox is >>>>>> something that seems impossible. But one can see DD so it obviously >>>>>> is possible.
"This sentence is not true" It is not possible to
correctly determine whether that sentence is true or false.
Doesn't matter. The truth value of that sentence is not needed for
any useful purpose.
It was the basis for the Tarski proof that
Boolean True(Language L, Expression e) cannot be computed.
https://liarparadox.org/Tarski_247_248.pdf
The expression, not the truth value of the expression.
The Liar Paradox cannot be derived through Rules applied to Facts https://en.wikipedia.org/wiki/Negation_as_failure
Thus is rejected by Prolog proving that Tarski was
incorrect to use it as any basis.
On 8/27/2025 2:40 AM, Mikko wrote:
On 2025-08-26 15:49:20 +0000, olcott said:
On 8/26/2025 3:54 AM, Mikko wrote:
On 2025-08-19 15:04:36 +0000, olcott said:
On 8/19/2025 2:37 AM, Mikko wrote:
On 2025-08-18 17:43:56 +0000, olcott said:
On 8/18/2025 4:08 AM, Mikko wrote:
On 2025-08-17 15:48:10 +0000, olcott said:
On 8/17/2025 4:03 AM, Mikko wrote:
On 2025-08-16 14:20:10 +0000, olcott said:That both return values from HHH(DD) are
I am doing the same thing that ZFC did to the
Russell's Paradox problem. Since ZFC set theory
is now called naive set theory.
You can't do the same because you don't have a paradox problem. >>>>>>>>>
contradicted by the behavior of the directly DD()
is a paradox that is abolished when we understand
that Turing machine deciders only compute the
mapping from their inputs, thus the behavior
of non-input DD() is of no consequence.
That is not a paradox. That is how DD is constructed. A paradox is >>>>>>>> something that seems impossible. But one can see DD so it obviously >>>>>>>> is possible.
"This sentence is not true" It is not possible to
correctly determine whether that sentence is true or false.
Doesn't matter. The truth value of that sentence is not needed for >>>>>> any useful purpose.
It was the basis for the Tarski proof that
Boolean True(Language L, Expression e) cannot be computed.
https://liarparadox.org/Tarski_247_248.pdf
The expression, not the truth value of the expression.
The Liar Paradox cannot be derived through Rules applied to Facts
https://en.wikipedia.org/wiki/Negation_as_failure
Thus is rejected by Prolog proving that Tarski was
incorrect to use it as any basis.
Tarski does not derive it from facts.
It my system that would be enough to reject LP as
not a member of this formal system thus rejected
as not a truth bearer.
In particular, the hypothesis
that it is possible to define a truth predicate is counter-factual.
On 8/27/2025 2:40 AM, Mikko wrote:
On 2025-08-26 15:49:20 +0000, olcott said:
On 8/26/2025 3:54 AM, Mikko wrote:
On 2025-08-19 15:04:36 +0000, olcott said:
On 8/19/2025 2:37 AM, Mikko wrote:
On 2025-08-18 17:43:56 +0000, olcott said:
On 8/18/2025 4:08 AM, Mikko wrote:
On 2025-08-17 15:48:10 +0000, olcott said:
On 8/17/2025 4:03 AM, Mikko wrote:
On 2025-08-16 14:20:10 +0000, olcott said:That both return values from HHH(DD) are
I am doing the same thing that ZFC did to the
Russell's Paradox problem. Since ZFC set theory
is now called naive set theory.
You can't do the same because you don't have a paradox problem. >>>>>>>>>
contradicted by the behavior of the directly DD()
is a paradox that is abolished when we understand
that Turing machine deciders only compute the
mapping from their inputs, thus the behavior
of non-input DD() is of no consequence.
That is not a paradox. That is how DD is constructed. A paradox is >>>>>>>> something that seems impossible. But one can see DD so it obviously >>>>>>>> is possible.
"This sentence is not true" It is not possible to
correctly determine whether that sentence is true or false.
Doesn't matter. The truth value of that sentence is not needed for >>>>>> any useful purpose.
It was the basis for the Tarski proof that
Boolean True(Language L, Expression e) cannot be computed.
https://liarparadox.org/Tarski_247_248.pdf
The expression, not the truth value of the expression.
The Liar Paradox cannot be derived through Rules applied to Facts
https://en.wikipedia.org/wiki/Negation_as_failure
Thus is rejected by Prolog proving that Tarski was
incorrect to use it as any basis.
Tarski does not derive it from facts.
It my system that would be enough to reject LP as
not a member of this formal system thus rejected
as not a truth bearer.
On 8/28/2025 2:04 AM, Mikko wrote:
On 2025-08-27 14:52:19 +0000, olcott said:
On 8/27/2025 2:40 AM, Mikko wrote:
On 2025-08-26 15:49:20 +0000, olcott said:
On 8/26/2025 3:54 AM, Mikko wrote:
On 2025-08-19 15:04:36 +0000, olcott said:
On 8/19/2025 2:37 AM, Mikko wrote:
On 2025-08-18 17:43:56 +0000, olcott said:
On 8/18/2025 4:08 AM, Mikko wrote:
On 2025-08-17 15:48:10 +0000, olcott said:
On 8/17/2025 4:03 AM, Mikko wrote:
On 2025-08-16 14:20:10 +0000, olcott said:That both return values from HHH(DD) are
I am doing the same thing that ZFC did to the
Russell's Paradox problem. Since ZFC set theory
is now called naive set theory.
You can't do the same because you don't have a paradox problem. >>>>>>>>>>>
contradicted by the behavior of the directly DD()
is a paradox that is abolished when we understand
that Turing machine deciders only compute the
mapping from their inputs, thus the behavior
of non-input DD() is of no consequence.
That is not a paradox. That is how DD is constructed. A paradox is >>>>>>>>>> something that seems impossible. But one can see DD so it obviously >>>>>>>>>> is possible.
"This sentence is not true" It is not possible to
correctly determine whether that sentence is true or false.
Doesn't matter. The truth value of that sentence is not needed for >>>>>>>> any useful purpose.
It was the basis for the Tarski proof that
Boolean True(Language L, Expression e) cannot be computed.
https://liarparadox.org/Tarski_247_248.pdf
The expression, not the truth value of the expression.
The Liar Paradox cannot be derived through Rules applied to Facts
https://en.wikipedia.org/wiki/Negation_as_failure
Thus is rejected by Prolog proving that Tarski was
incorrect to use it as any basis.
Tarski does not derive it from facts.
It my system that would be enough to reject LP as
not a member of this formal system thus rejected
as not a truth bearer.
Your system does not exist. But in the system Tarski used a sentence
that claims its own falsity is unprovable unless ordinary arithmetic
is inconsistent.
It unprovable because it is not a truth bearer.
On 8/28/2025 2:04 AM, Mikko wrote:
On 2025-08-27 14:52:19 +0000, olcott said:
On 8/27/2025 2:40 AM, Mikko wrote:
On 2025-08-26 15:49:20 +0000, olcott said:
On 8/26/2025 3:54 AM, Mikko wrote:
On 2025-08-19 15:04:36 +0000, olcott said:
On 8/19/2025 2:37 AM, Mikko wrote:
On 2025-08-18 17:43:56 +0000, olcott said:
On 8/18/2025 4:08 AM, Mikko wrote:
On 2025-08-17 15:48:10 +0000, olcott said:
On 8/17/2025 4:03 AM, Mikko wrote:
On 2025-08-16 14:20:10 +0000, olcott said:That both return values from HHH(DD) are
I am doing the same thing that ZFC did to the
Russell's Paradox problem. Since ZFC set theory
is now called naive set theory.
You can't do the same because you don't have a paradox problem. >>>>>>>>>>>
contradicted by the behavior of the directly DD()
is a paradox that is abolished when we understand
that Turing machine deciders only compute the
mapping from their inputs, thus the behavior
of non-input DD() is of no consequence.
That is not a paradox. That is how DD is constructed. A
paradox is
something that seems impossible. But one can see DD so it
obviously
is possible.
"This sentence is not true" It is not possible to
correctly determine whether that sentence is true or false.
Doesn't matter. The truth value of that sentence is not needed for >>>>>>>> any useful purpose.
It was the basis for the Tarski proof that
Boolean True(Language L, Expression e) cannot be computed.
https://liarparadox.org/Tarski_247_248.pdf
The expression, not the truth value of the expression.
The Liar Paradox cannot be derived through Rules applied to Facts
https://en.wikipedia.org/wiki/Negation_as_failure
Thus is rejected by Prolog proving that Tarski was
incorrect to use it as any basis.
Tarski does not derive it from facts.
It my system that would be enough to reject LP as
not a member of this formal system thus rejected
as not a truth bearer.
Your system does not exist. But in the system Tarski used a sentence
that claims its own falsity is unprovable unless ordinary arithmetic
is inconsistent.
It unprovable because it is not a truth bearer.
?- LP = not(true(LP)).
LP = not(true(LP)).
?- unify_with_occurs_check(LP, not(true(LP))).
false.
Proving that LP is not a truth bearer.
We might as well ask is this sentence true
or false: "What time is it?"
Tarski couldn't prove that one either.
On 8/29/2025 1:54 AM, Mikko wrote:
On 2025-08-28 14:19:23 +0000, olcott said:
On 8/28/2025 2:04 AM, Mikko wrote:
On 2025-08-27 14:52:19 +0000, olcott said:
On 8/27/2025 2:40 AM, Mikko wrote:
On 2025-08-26 15:49:20 +0000, olcott said:
On 8/26/2025 3:54 AM, Mikko wrote:
On 2025-08-19 15:04:36 +0000, olcott said:
On 8/19/2025 2:37 AM, Mikko wrote:
On 2025-08-18 17:43:56 +0000, olcott said:
On 8/18/2025 4:08 AM, Mikko wrote:Doesn't matter. The truth value of that sentence is not needed for >>>>>>>>>> any useful purpose.
On 2025-08-17 15:48:10 +0000, olcott said:
On 8/17/2025 4:03 AM, Mikko wrote:
On 2025-08-16 14:20:10 +0000, olcott said:That both return values from HHH(DD) are
I am doing the same thing that ZFC did to the
Russell's Paradox problem. Since ZFC set theory
is now called naive set theory.
You can't do the same because you don't have a paradox problem. >>>>>>>>>>>>>
contradicted by the behavior of the directly DD()
is a paradox that is abolished when we understand
that Turing machine deciders only compute the
mapping from their inputs, thus the behavior
of non-input DD() is of no consequence.
That is not a paradox. That is how DD is constructed. A paradox is >>>>>>>>>>>> something that seems impossible. But one can see DD so it obviously
is possible.
"This sentence is not true" It is not possible to
correctly determine whether that sentence is true or false. >>>>>>>>>>
It was the basis for the Tarski proof that
Boolean True(Language L, Expression e) cannot be computed.
https://liarparadox.org/Tarski_247_248.pdf
The expression, not the truth value of the expression.
The Liar Paradox cannot be derived through Rules applied to Facts >>>>>>> https://en.wikipedia.org/wiki/Negation_as_failure
Thus is rejected by Prolog proving that Tarski was
incorrect to use it as any basis.
Tarski does not derive it from facts.
It my system that would be enough to reject LP as
not a member of this formal system thus rejected
as not a truth bearer.
Your system does not exist. But in the system Tarski used a sentence
that claims its own falsity is unprovable unless ordinary arithmetic
is inconsistent.
It unprovable because it is not a truth bearer.
However, it would be provable (and proven) if there were a truth predicate.
Likewise we could know whether or not
"What time is it?" is true or false.
On 8/30/2025 5:20 AM, Mikko wrote:
On 2025-08-29 14:04:37 +0000, olcott said:
On 8/29/2025 1:54 AM, Mikko wrote:
On 2025-08-28 14:19:23 +0000, olcott said:
On 8/28/2025 2:04 AM, Mikko wrote:
On 2025-08-27 14:52:19 +0000, olcott said:
On 8/27/2025 2:40 AM, Mikko wrote:
On 2025-08-26 15:49:20 +0000, olcott said:
On 8/26/2025 3:54 AM, Mikko wrote:
On 2025-08-19 15:04:36 +0000, olcott said:
On 8/19/2025 2:37 AM, Mikko wrote:
On 2025-08-18 17:43:56 +0000, olcott said:
On 8/18/2025 4:08 AM, Mikko wrote:Doesn't matter. The truth value of that sentence is not needed for >>>>>>>>>>>> any useful purpose.
On 2025-08-17 15:48:10 +0000, olcott said:
On 8/17/2025 4:03 AM, Mikko wrote:
On 2025-08-16 14:20:10 +0000, olcott said:
I am doing the same thing that ZFC did to the >>>>>>>>>>>>>>>>> Russell's Paradox problem. Since ZFC set theory >>>>>>>>>>>>>>>>> is now called naive set theory.
You can't do the same because you don't have a paradox problem.
That both return values from HHH(DD) are
contradicted by the behavior of the directly DD() >>>>>>>>>>>>>>> is a paradox that is abolished when we understand >>>>>>>>>>>>>>> that Turing machine deciders only compute the
mapping from their inputs, thus the behavior
of non-input DD() is of no consequence.
That is not a paradox. That is how DD is constructed. A paradox is
something that seems impossible. But one can see DD so it obviously
is possible.
"This sentence is not true" It is not possible to
correctly determine whether that sentence is true or false. >>>>>>>>>>>>
It was the basis for the Tarski proof that
Boolean True(Language L, Expression e) cannot be computed. >>>>>>>>>>> https://liarparadox.org/Tarski_247_248.pdf
The expression, not the truth value of the expression.
The Liar Paradox cannot be derived through Rules applied to Facts >>>>>>>>> https://en.wikipedia.org/wiki/Negation_as_failure
Thus is rejected by Prolog proving that Tarski was
incorrect to use it as any basis.
Tarski does not derive it from facts.
It my system that would be enough to reject LP as
not a member of this formal system thus rejected
as not a truth bearer.
Your system does not exist. But in the system Tarski used a sentence >>>>>> that claims its own falsity is unprovable unless ordinary arithmetic >>>>>> is inconsistent.
It unprovable because it is not a truth bearer.
However, it would be provable (and proven) if there were a truth predicate.
Likewise we could know whether or not
"What time is it?" is true or false.
Only if you can express that question as a term expression in the domain
of the truth predicate.
Questions are not truth bearers thus it is
incorrect to ask whether they are true or false.
On 8/31/2025 3:36 AM, Mikko wrote:
On 2025-08-30 16:24:16 +0000, olcott said:
On 8/30/2025 5:20 AM, Mikko wrote:
On 2025-08-29 14:04:37 +0000, olcott said:
On 8/29/2025 1:54 AM, Mikko wrote:
On 2025-08-28 14:19:23 +0000, olcott said:
On 8/28/2025 2:04 AM, Mikko wrote:
On 2025-08-27 14:52:19 +0000, olcott said:
On 8/27/2025 2:40 AM, Mikko wrote:
On 2025-08-26 15:49:20 +0000, olcott said:
On 8/26/2025 3:54 AM, Mikko wrote:
On 2025-08-19 15:04:36 +0000, olcott said:
On 8/19/2025 2:37 AM, Mikko wrote:
On 2025-08-18 17:43:56 +0000, olcott said:
On 8/18/2025 4:08 AM, Mikko wrote:Doesn't matter. The truth value of that sentence is not >>>>>>>>>>>>>> needed for
On 2025-08-17 15:48:10 +0000, olcott said:
On 8/17/2025 4:03 AM, Mikko wrote:
On 2025-08-16 14:20:10 +0000, olcott said: >>>>>>>>>>>>>>>>>>
I am doing the same thing that ZFC did to the >>>>>>>>>>>>>>>>>>> Russell's Paradox problem. Since ZFC set theory >>>>>>>>>>>>>>>>>>> is now called naive set theory.
You can't do the same because you don't have a paradox >>>>>>>>>>>>>>>>>> problem.
That both return values from HHH(DD) are
contradicted by the behavior of the directly DD() >>>>>>>>>>>>>>>>> is a paradox that is abolished when we understand >>>>>>>>>>>>>>>>> that Turing machine deciders only compute the >>>>>>>>>>>>>>>>> mapping from their inputs, thus the behavior >>>>>>>>>>>>>>>>> of non-input DD() is of no consequence.
That is not a paradox. That is how DD is constructed. A >>>>>>>>>>>>>>>> paradox is
something that seems impossible. But one can see DD so >>>>>>>>>>>>>>>> it obviously
is possible.
"This sentence is not true" It is not possible to >>>>>>>>>>>>>>> correctly determine whether that sentence is true or false. >>>>>>>>>>>>>>
any useful purpose.
It was the basis for the Tarski proof that
Boolean True(Language L, Expression e) cannot be computed. >>>>>>>>>>>>> https://liarparadox.org/Tarski_247_248.pdf
The expression, not the truth value of the expression.
The Liar Paradox cannot be derived through Rules applied to >>>>>>>>>>> Facts
https://en.wikipedia.org/wiki/Negation_as_failure
Thus is rejected by Prolog proving that Tarski was
incorrect to use it as any basis.
Tarski does not derive it from facts.
It my system that would be enough to reject LP as
not a member of this formal system thus rejected
as not a truth bearer.
Your system does not exist. But in the system Tarski used a
sentence
that claims its own falsity is unprovable unless ordinary
arithmetic
is inconsistent.
It unprovable because it is not a truth bearer.
However, it would be provable (and proven) if there were a truth
predicate.
Likewise we could know whether or not
"What time is it?" is true or false.
Only if you can express that question as a term expression in the
domain
of the truth predicate.
Questions are not truth bearers thus it is
incorrect to ask whether they are true or false.
In certain sense true but irrelevant to your (not quire correct) claim
in your previous message.
The Liar Paradox is not a truth bearer thus Tarski
should have rejected it as the basis for his proof.
On 8/31/2025 3:36 AM, Mikko wrote:
On 2025-08-30 16:24:16 +0000, olcott said:
On 8/30/2025 5:20 AM, Mikko wrote:
On 2025-08-29 14:04:37 +0000, olcott said:
On 8/29/2025 1:54 AM, Mikko wrote:
On 2025-08-28 14:19:23 +0000, olcott said:
On 8/28/2025 2:04 AM, Mikko wrote:
On 2025-08-27 14:52:19 +0000, olcott said:
On 8/27/2025 2:40 AM, Mikko wrote:
On 2025-08-26 15:49:20 +0000, olcott said:
On 8/26/2025 3:54 AM, Mikko wrote:
On 2025-08-19 15:04:36 +0000, olcott said:
On 8/19/2025 2:37 AM, Mikko wrote:
On 2025-08-18 17:43:56 +0000, olcott said:
On 8/18/2025 4:08 AM, Mikko wrote:Doesn't matter. The truth value of that sentence is not needed for
On 2025-08-17 15:48:10 +0000, olcott said:
On 8/17/2025 4:03 AM, Mikko wrote:
On 2025-08-16 14:20:10 +0000, olcott said: >>>>>>>>>>>>>>>>>>
I am doing the same thing that ZFC did to the >>>>>>>>>>>>>>>>>>> Russell's Paradox problem. Since ZFC set theory >>>>>>>>>>>>>>>>>>> is now called naive set theory.
You can't do the same because you don't have a paradox problem.
That both return values from HHH(DD) are
contradicted by the behavior of the directly DD() >>>>>>>>>>>>>>>>> is a paradox that is abolished when we understand >>>>>>>>>>>>>>>>> that Turing machine deciders only compute the >>>>>>>>>>>>>>>>> mapping from their inputs, thus the behavior >>>>>>>>>>>>>>>>> of non-input DD() is of no consequence.
That is not a paradox. That is how DD is constructed. A paradox is
something that seems impossible. But one can see DD so it obviously
is possible.
"This sentence is not true" It is not possible to >>>>>>>>>>>>>>> correctly determine whether that sentence is true or false. >>>>>>>>>>>>>>
any useful purpose.
It was the basis for the Tarski proof that
Boolean True(Language L, Expression e) cannot be computed. >>>>>>>>>>>>> https://liarparadox.org/Tarski_247_248.pdf
The expression, not the truth value of the expression.
The Liar Paradox cannot be derived through Rules applied to Facts >>>>>>>>>>> https://en.wikipedia.org/wiki/Negation_as_failure
Thus is rejected by Prolog proving that Tarski was
incorrect to use it as any basis.
Tarski does not derive it from facts.
It my system that would be enough to reject LP as
not a member of this formal system thus rejected
as not a truth bearer.
Your system does not exist. But in the system Tarski used a sentence >>>>>>>> that claims its own falsity is unprovable unless ordinary arithmetic >>>>>>>> is inconsistent.
It unprovable because it is not a truth bearer.
However, it would be provable (and proven) if there were a truth predicate.
Likewise we could know whether or not
"What time is it?" is true or false.
Only if you can express that question as a term expression in the domain >>>> of the truth predicate.
Questions are not truth bearers thus it is
incorrect to ask whether they are true or false.
In certain sense true but irrelevant to your (not quire correct) claim
in your previous message.
The Liar Paradox is not a truth bearer thus Tarski
should have rejected it as the basis for his proof.
On 9/1/2025 2:51 AM, Mikko wrote:
On 2025-08-31 16:07:59 +0000, olcott said:
On 8/31/2025 3:36 AM, Mikko wrote:
On 2025-08-30 16:24:16 +0000, olcott said:
On 8/30/2025 5:20 AM, Mikko wrote:
On 2025-08-29 14:04:37 +0000, olcott said:
On 8/29/2025 1:54 AM, Mikko wrote:
On 2025-08-28 14:19:23 +0000, olcott said:
On 8/28/2025 2:04 AM, Mikko wrote:
On 2025-08-27 14:52:19 +0000, olcott said:
On 8/27/2025 2:40 AM, Mikko wrote:
On 2025-08-26 15:49:20 +0000, olcott said:
On 8/26/2025 3:54 AM, Mikko wrote:
On 2025-08-19 15:04:36 +0000, olcott said:The Liar Paradox cannot be derived through Rules applied to >>>>>>>>>>>>> Facts
On 8/19/2025 2:37 AM, Mikko wrote:
On 2025-08-18 17:43:56 +0000, olcott said:
On 8/18/2025 4:08 AM, Mikko wrote:
On 2025-08-17 15:48:10 +0000, olcott said: >>>>>>>>>>>>>>>>>>
On 8/17/2025 4:03 AM, Mikko wrote:
On 2025-08-16 14:20:10 +0000, olcott said: >>>>>>>>>>>>>>>>>>>>
I am doing the same thing that ZFC did to the >>>>>>>>>>>>>>>>>>>>> Russell's Paradox problem. Since ZFC set theory >>>>>>>>>>>>>>>>>>>>> is now called naive set theory.
You can't do the same because you don't have a >>>>>>>>>>>>>>>>>>>> paradox problem.
That both return values from HHH(DD) are >>>>>>>>>>>>>>>>>>> contradicted by the behavior of the directly DD() >>>>>>>>>>>>>>>>>>> is a paradox that is abolished when we understand >>>>>>>>>>>>>>>>>>> that Turing machine deciders only compute the >>>>>>>>>>>>>>>>>>> mapping from their inputs, thus the behavior >>>>>>>>>>>>>>>>>>> of non-input DD() is of no consequence.
That is not a paradox. That is how DD is constructed. >>>>>>>>>>>>>>>>>> A paradox is
something that seems impossible. But one can see DD so >>>>>>>>>>>>>>>>>> it obviously
is possible.
"This sentence is not true" It is not possible to >>>>>>>>>>>>>>>>> correctly determine whether that sentence is true or >>>>>>>>>>>>>>>>> false.
Doesn't matter. The truth value of that sentence is not >>>>>>>>>>>>>>>> needed for
any useful purpose.
It was the basis for the Tarski proof that
Boolean True(Language L, Expression e) cannot be computed. >>>>>>>>>>>>>>> https://liarparadox.org/Tarski_247_248.pdf
The expression, not the truth value of the expression. >>>>>>>>>>>>>
https://en.wikipedia.org/wiki/Negation_as_failure
Thus is rejected by Prolog proving that Tarski was
incorrect to use it as any basis.
Tarski does not derive it from facts.
It my system that would be enough to reject LP as
not a member of this formal system thus rejected
as not a truth bearer.
Your system does not exist. But in the system Tarski used a >>>>>>>>>> sentence
that claims its own falsity is unprovable unless ordinary
arithmetic
is inconsistent.
It unprovable because it is not a truth bearer.
However, it would be provable (and proven) if there were a truth >>>>>>>> predicate.
Likewise we could know whether or not
"What time is it?" is true or false.
Only if you can express that question as a term expression in the
domain
of the truth predicate.
Questions are not truth bearers thus it is
incorrect to ask whether they are true or false.
In certain sense true but irrelevant to your (not quire correct) claim >>>> in your previous message.
The Liar Paradox is not a truth bearer thus Tarski
should have rejected it as the basis for his proof.
If you agree with Tarski that the liar paradox is not a truth-bearer
and therefore not true, why don't you cosider the statement "The Liar
Paradox is not a truth bearer" false?
The same reason that I don't say "What time is it?"
is true or false. Only truth bearers have a Boolean
value.
On 9/1/2025 2:51 AM, Mikko wrote:
On 2025-08-31 16:07:59 +0000, olcott said:
On 8/31/2025 3:36 AM, Mikko wrote:
On 2025-08-30 16:24:16 +0000, olcott said:
On 8/30/2025 5:20 AM, Mikko wrote:
On 2025-08-29 14:04:37 +0000, olcott said:
On 8/29/2025 1:54 AM, Mikko wrote:
On 2025-08-28 14:19:23 +0000, olcott said:
On 8/28/2025 2:04 AM, Mikko wrote:
On 2025-08-27 14:52:19 +0000, olcott said:
On 8/27/2025 2:40 AM, Mikko wrote:
On 2025-08-26 15:49:20 +0000, olcott said:
On 8/26/2025 3:54 AM, Mikko wrote:
On 2025-08-19 15:04:36 +0000, olcott said:The Liar Paradox cannot be derived through Rules applied to Facts >>>>>>>>>>>>> https://en.wikipedia.org/wiki/Negation_as_failure
On 8/19/2025 2:37 AM, Mikko wrote:
On 2025-08-18 17:43:56 +0000, olcott said:
On 8/18/2025 4:08 AM, Mikko wrote:Doesn't matter. The truth value of that sentence is not needed for
On 2025-08-17 15:48:10 +0000, olcott said: >>>>>>>>>>>>>>>>>>
On 8/17/2025 4:03 AM, Mikko wrote:
On 2025-08-16 14:20:10 +0000, olcott said: >>>>>>>>>>>>>>>>>>>>
I am doing the same thing that ZFC did to the >>>>>>>>>>>>>>>>>>>>> Russell's Paradox problem. Since ZFC set theory >>>>>>>>>>>>>>>>>>>>> is now called naive set theory.
You can't do the same because you don't have a paradox problem.
That both return values from HHH(DD) are >>>>>>>>>>>>>>>>>>> contradicted by the behavior of the directly DD() >>>>>>>>>>>>>>>>>>> is a paradox that is abolished when we understand >>>>>>>>>>>>>>>>>>> that Turing machine deciders only compute the >>>>>>>>>>>>>>>>>>> mapping from their inputs, thus the behavior >>>>>>>>>>>>>>>>>>> of non-input DD() is of no consequence.
That is not a paradox. That is how DD is constructed. A paradox is
something that seems impossible. But one can see DD so it obviously
is possible.
"This sentence is not true" It is not possible to >>>>>>>>>>>>>>>>> correctly determine whether that sentence is true or false. >>>>>>>>>>>>>>>>
any useful purpose.
It was the basis for the Tarski proof that
Boolean True(Language L, Expression e) cannot be computed. >>>>>>>>>>>>>>> https://liarparadox.org/Tarski_247_248.pdf
The expression, not the truth value of the expression. >>>>>>>>>>>>>
Thus is rejected by Prolog proving that Tarski was
incorrect to use it as any basis.
Tarski does not derive it from facts.
It my system that would be enough to reject LP as
not a member of this formal system thus rejected
as not a truth bearer.
Your system does not exist. But in the system Tarski used a sentence >>>>>>>>>> that claims its own falsity is unprovable unless ordinary arithmetic >>>>>>>>>> is inconsistent.
It unprovable because it is not a truth bearer.
However, it would be provable (and proven) if there were a truth predicate.
Likewise we could know whether or not
"What time is it?" is true or false.
Only if you can express that question as a term expression in the domain >>>>>> of the truth predicate.
Questions are not truth bearers thus it is
incorrect to ask whether they are true or false.
In certain sense true but irrelevant to your (not quire correct) claim >>>> in your previous message.
The Liar Paradox is not a truth bearer thus Tarski
should have rejected it as the basis for his proof.
If you agree with Tarski that the liar paradox is not a truth-bearer
and therefore not true, why don't you cosider the statement "The Liar
Paradox is not a truth bearer" false?
The same reason that I don't say "What time is it?"
is true or false. Only truth bearers have a Boolean
value.
On 9/2/2025 3:12 AM, Mikko wrote:ZFC doesn't make Russell's paradox go away in naive set theory.
On 2025-09-01 14:51:17 +0000, olcott said:
On 9/1/2025 2:51 AM, Mikko wrote:
On 2025-08-31 16:07:59 +0000, olcott said:
On 8/31/2025 3:36 AM, Mikko wrote:
On 2025-08-30 16:24:16 +0000, olcott said:
On 8/30/2025 5:20 AM, Mikko wrote:
On 2025-08-29 14:04:37 +0000, olcott said:
On 8/29/2025 1:54 AM, Mikko wrote:
On 2025-08-28 14:19:23 +0000, olcott said:
On 8/28/2025 2:04 AM, Mikko wrote:
On 2025-08-27 14:52:19 +0000, olcott said:
On 8/27/2025 2:40 AM, Mikko wrote:
On 2025-08-26 15:49:20 +0000, olcott said:
On 8/26/2025 3:54 AM, Mikko wrote:
On 2025-08-19 15:04:36 +0000, olcott said:
On 8/19/2025 2:37 AM, Mikko wrote:
On 2025-08-18 17:43:56 +0000, olcott said: >>>>>>>>>>>>>>>>>>> On 8/18/2025 4:08 AM, Mikko wrote:
On 2025-08-17 15:48:10 +0000, olcott said: >>>>>>>>>>>>>>>>>>>>> On 8/17/2025 4:03 AM, Mikko wrote:
On 2025-08-16 14:20:10 +0000, olcott said: >>>>>>>>>>>>>>>>>>>>>>
I am doing the same thing that ZFC did to the >>>>>>>>>>>>>>>>>>>>>>> Russell's Paradox problem. Since ZFC set theory is >>>>>>>>>>>>>>>>>>>>>>> now called naive set theory.
It might be. You can add it or the negation as an axiomIt unprovable because it is not a truth bearer.
Why do you think you are the smartest in the world? The liar sentenceWhat is the reaaon to say that "The Liar Paradox is not a truth bearer"It has taken humanity 2000 years** and even after it has been completely proven that the liar paradox cannot possibly have truth value no other
is false but "What time is it?" isn't?
human gets this.
On 9/2/2025 12:31 PM, joes wrote:
Am Tue, 02 Sep 2025 10:04:15 -0500 schrieb olcott:
On 9/2/2025 3:12 AM, Mikko wrote:
On 2025-09-01 14:51:17 +0000, olcott said:
On 9/1/2025 2:51 AM, Mikko wrote:
On 2025-08-31 16:07:59 +0000, olcott said:
On 8/31/2025 3:36 AM, Mikko wrote:
On 2025-08-30 16:24:16 +0000, olcott said:
On 8/30/2025 5:20 AM, Mikko wrote:
On 2025-08-29 14:04:37 +0000, olcott said:
On 8/29/2025 1:54 AM, Mikko wrote:
On 2025-08-28 14:19:23 +0000, olcott said:
On 8/28/2025 2:04 AM, Mikko wrote:
On 2025-08-27 14:52:19 +0000, olcott said:
On 8/27/2025 2:40 AM, Mikko wrote:
On 2025-08-26 15:49:20 +0000, olcott said:
On 8/26/2025 3:54 AM, Mikko wrote:
On 2025-08-19 15:04:36 +0000, olcott said: >>>>>>>>>>>>>>>>>>> On 8/19/2025 2:37 AM, Mikko wrote:
On 2025-08-18 17:43:56 +0000, olcott said: >>>>>>>>>>>>>>>>>>>>> On 8/18/2025 4:08 AM, Mikko wrote:
On 2025-08-17 15:48:10 +0000, olcott said: >>>>>>>>>>>>>>>>>>>>>>> On 8/17/2025 4:03 AM, Mikko wrote: >>>>>>>>>>>>>>>>>>>>>>>> On 2025-08-16 14:20:10 +0000, olcott said: >>>>>>>>>>>>>>>>>>>>>>>>
I am doing the same thing that ZFC did to the >>>>>>>>>>>>>>>>>>>>>>>>> Russell's Paradox problem. Since ZFC set theory is >>>>>>>>>>>>>>>>>>>>>>>>> now called naive set theory.
ZFC doesn't make Russell's paradox go away in naive set theory.
ZFC essentially correctly rules that naive set theory is stupid.
It might be. You can add it or the negation as an axiomIt unprovable because it is not a truth bearer.
What is the reaaon to say that "The Liar Paradox is not a truth bearer" >>>> is false but "What time is it?" isn't?It has taken humanity 2000 years** and even after it has been completely >>> proven that the liar paradox cannot possibly have truth value no other
human gets this.
Why do you think you are the smartest in the world? The liar sentence
is syntactically well-formed and could be false or true. Its content
is then in contradiction to the assigned value. It's not a question.
It took me a lot of work to conclusively prove
that the Liar Paradox is not a truth bearer, yet
it should be simple as soon as the notion of truth
bearer is understood.
On 9/2/2025 3:12 AM, Mikko wrote:
On 2025-09-01 14:51:17 +0000, olcott said:
On 9/1/2025 2:51 AM, Mikko wrote:
On 2025-08-31 16:07:59 +0000, olcott said:
On 8/31/2025 3:36 AM, Mikko wrote:
On 2025-08-30 16:24:16 +0000, olcott said:
On 8/30/2025 5:20 AM, Mikko wrote:
On 2025-08-29 14:04:37 +0000, olcott said:
On 8/29/2025 1:54 AM, Mikko wrote:
On 2025-08-28 14:19:23 +0000, olcott said:
On 8/28/2025 2:04 AM, Mikko wrote:
On 2025-08-27 14:52:19 +0000, olcott said:
On 8/27/2025 2:40 AM, Mikko wrote:
On 2025-08-26 15:49:20 +0000, olcott said:
On 8/26/2025 3:54 AM, Mikko wrote:
On 2025-08-19 15:04:36 +0000, olcott said:The Liar Paradox cannot be derived through Rules applied to Facts
On 8/19/2025 2:37 AM, Mikko wrote:
On 2025-08-18 17:43:56 +0000, olcott said: >>>>>>>>>>>>>>>>>>
On 8/18/2025 4:08 AM, Mikko wrote:Doesn't matter. The truth value of that sentence is not needed for
On 2025-08-17 15:48:10 +0000, olcott said: >>>>>>>>>>>>>>>>>>>>
On 8/17/2025 4:03 AM, Mikko wrote:That is not a paradox. That is how DD is constructed. A paradox is
On 2025-08-16 14:20:10 +0000, olcott said: >>>>>>>>>>>>>>>>>>>>>>
I am doing the same thing that ZFC did to the >>>>>>>>>>>>>>>>>>>>>>> Russell's Paradox problem. Since ZFC set theory >>>>>>>>>>>>>>>>>>>>>>> is now called naive set theory.
You can't do the same because you don't have a paradox problem.
That both return values from HHH(DD) are >>>>>>>>>>>>>>>>>>>>> contradicted by the behavior of the directly DD() >>>>>>>>>>>>>>>>>>>>> is a paradox that is abolished when we understand >>>>>>>>>>>>>>>>>>>>> that Turing machine deciders only compute the >>>>>>>>>>>>>>>>>>>>> mapping from their inputs, thus the behavior >>>>>>>>>>>>>>>>>>>>> of non-input DD() is of no consequence. >>>>>>>>>>>>>>>>>>>>
something that seems impossible. But one can see DD so it obviously
is possible.
"This sentence is not true" It is not possible to >>>>>>>>>>>>>>>>>>> correctly determine whether that sentence is true or false. >>>>>>>>>>>>>>>>>>
any useful purpose.
It was the basis for the Tarski proof that
Boolean True(Language L, Expression e) cannot be computed. >>>>>>>>>>>>>>>>> https://liarparadox.org/Tarski_247_248.pdf
The expression, not the truth value of the expression. >>>>>>>>>>>>>>>
https://en.wikipedia.org/wiki/Negation_as_failure >>>>>>>>>>>>>>> Thus is rejected by Prolog proving that Tarski was >>>>>>>>>>>>>>> incorrect to use it as any basis.
Tarski does not derive it from facts.
It my system that would be enough to reject LP as
not a member of this formal system thus rejected
as not a truth bearer.
Your system does not exist. But in the system Tarski used a sentence
that claims its own falsity is unprovable unless ordinary arithmetic
is inconsistent.
It unprovable because it is not a truth bearer.
However, it would be provable (and proven) if there were a truth predicate.
Likewise we could know whether or not
"What time is it?" is true or false.
Only if you can express that question as a term expression in the domain
of the truth predicate.
Questions are not truth bearers thus it is
incorrect to ask whether they are true or false.
In certain sense true but irrelevant to your (not quire correct) claim >>>>>> in your previous message.
The Liar Paradox is not a truth bearer thus Tarski
should have rejected it as the basis for his proof.
If you agree with Tarski that the liar paradox is not a truth-bearer
and therefore not true, why don't you cosider the statement "The Liar
Paradox is not a truth bearer" false?
The same reason that I don't say "What time is it?"
is true or false. Only truth bearers have a Boolean
value.
What is the reaaon to say that "The Liar Paradox is not a truth bearer"
is false but "What time is it?" isn't?
It has taken humanity 2000 years** and even
after it has been completely proven that the
liar paradox cannot possibly have truth value
no other human gets this.
** The Liar Paradox is in the bible.
| Sysop: | Keyop |
|---|---|
| Location: | Huddersfield, West Yorkshire, UK |
| Users: | 546 |
| Nodes: | 16 (2 / 14) |
| Uptime: | 28:50:58 |
| Calls: | 10,390 |
| Calls today: | 1 |
| Files: | 14,064 |
| Messages: | 6,417,082 |