On 1/7/2026 5:49 AM, Mikko wrote:
On 07/01/2026 06:44, olcott wrote:
All deciders essentially: Transform finite string
inputs by finite string transformation rules into
{Accept, Reject} values.
The counter-example input to requires more than
can be derived from finite string transformation
rules applied to this specific input thus the
Halting Problem requires too much.
In a sense the halting problem asks too much: the problem is proven to
be unsolvable. In another sense it asks too little: usually we want to
know whether a method halts on every input, not just one.
Although the halting problem is unsolvable, there are partial solutions
to the halting problem. In particular, every counter-example to the
full solution is correctly solved by some partial deciders.
*if undecidability is correct then truth itself is broken*
On 07/01/2026 13:54, olcott wrote:
On 1/7/2026 5:49 AM, Mikko wrote:
On 07/01/2026 06:44, olcott wrote:
All deciders essentially: Transform finite string
inputs by finite string transformation rules into
{Accept, Reject} values.
The counter-example input to requires more than
can be derived from finite string transformation
rules applied to this specific input thus the
Halting Problem requires too much.
In a sense the halting problem asks too much: the problem is proven to
be unsolvable. In another sense it asks too little: usually we want to
know whether a method halts on every input, not just one.
Although the halting problem is unsolvable, there are partial solutions
to the halting problem. In particular, every counter-example to the
full solution is correctly solved by some partial deciders.
*if undecidability is correct then truth itself is broken*
Depends on whether the word "truth" is interpeted in the standard
sense or in Olcott's sense.
On 1/8/2026 4:22 AM, Mikko wrote:
On 07/01/2026 13:54, olcott wrote:
On 1/7/2026 5:49 AM, Mikko wrote:
On 07/01/2026 06:44, olcott wrote:
All deciders essentially: Transform finite string
inputs by finite string transformation rules into
{Accept, Reject} values.
The counter-example input to requires more than
can be derived from finite string transformation
rules applied to this specific input thus the
Halting Problem requires too much.
In a sense the halting problem asks too much: the problem is proven to >>>> be unsolvable. In another sense it asks too little: usually we want to >>>> know whether a method halts on every input, not just one.
Although the halting problem is unsolvable, there are partial solutions >>>> to the halting problem. In particular, every counter-example to the
full solution is correctly solved by some partial deciders.
*if undecidability is correct then truth itself is broken*
Depends on whether the word "truth" is interpeted in the standard
sense or in Olcott's sense.
Undecidability is misconception. Self-contradictory
expressions are correctly rejected as semantically
incoherent thus form no undecidability or incompleteness.
On 07/01/2026 13:54, olcott wrote:
On 1/7/2026 5:49 AM, Mikko wrote:
On 07/01/2026 06:44, olcott wrote:
All deciders essentially: Transform finite string
inputs by finite string transformation rules into
{Accept, Reject} values.
The counter-example input to requires more than
can be derived from finite string transformation
rules applied to this specific input thus the
Halting Problem requires too much.
In a sense the halting problem asks too much: the problem is proven to
be unsolvable. In another sense it asks too little: usually we want to
know whether a method halts on every input, not just one.
Although the halting problem is unsolvable, there are partial solutions
to the halting problem. In particular, every counter-example to the
full solution is correctly solved by some partial deciders.
*if undecidability is correct then truth itself is broken*
Depends on whether the word "truth" is interpeted in the standard
sense or in Olcott's sense.
On 08/01/2026 16:22, olcott wrote:
On 1/8/2026 4:22 AM, Mikko wrote:
On 07/01/2026 13:54, olcott wrote:
On 1/7/2026 5:49 AM, Mikko wrote:
On 07/01/2026 06:44, olcott wrote:
All deciders essentially: Transform finite string
inputs by finite string transformation rules into
{Accept, Reject} values.
The counter-example input to requires more than
can be derived from finite string transformation
rules applied to this specific input thus the
Halting Problem requires too much.
In a sense the halting problem asks too much: the problem is proven to >>>>> be unsolvable. In another sense it asks too little: usually we want to >>>>> know whether a method halts on every input, not just one.
Although the halting problem is unsolvable, there are partial
solutions
to the halting problem. In particular, every counter-example to the
full solution is correctly solved by some partial deciders.
*if undecidability is correct then truth itself is broken*
Depends on whether the word "truth" is interpeted in the standard
sense or in Olcott's sense.
Undecidability is misconception. Self-contradictory
expressions are correctly rejected as semantically
incoherent thus form no undecidability or incompleteness.
The misconception is yours. No expression in the language of the first
order group theory is self-contradictory. But the first order goupr
theory is incomplete: it is impossible to prove that AB = BA is true
for every A and every B but it is also impossible to prove that AB = BA
is false for some A and some B.
On 1/9/2026 3:59 AM, Mikko wrote:
On 08/01/2026 16:22, olcott wrote:
On 1/8/2026 4:22 AM, Mikko wrote:
On 07/01/2026 13:54, olcott wrote:
On 1/7/2026 5:49 AM, Mikko wrote:
On 07/01/2026 06:44, olcott wrote:
All deciders essentially: Transform finite string
inputs by finite string transformation rules into
{Accept, Reject} values.
The counter-example input to requires more than
can be derived from finite string transformation
rules applied to this specific input thus the
Halting Problem requires too much.
In a sense the halting problem asks too much: the problem is
proven to
be unsolvable. In another sense it asks too little: usually we
want to
know whether a method halts on every input, not just one.
Although the halting problem is unsolvable, there are partial
solutions
to the halting problem. In particular, every counter-example to the >>>>>> full solution is correctly solved by some partial deciders.
*if undecidability is correct then truth itself is broken*
Depends on whether the word "truth" is interpeted in the standard
sense or in Olcott's sense.
Undecidability is misconception. Self-contradictory
expressions are correctly rejected as semantically
incoherent thus form no undecidability or incompleteness.
The misconception is yours. No expression in the language of the first
order group theory is self-contradictory. But the first order goupr
theory is incomplete: it is impossible to prove that AB = BA is true
for every A and every B but it is also impossible to prove that AB = BA
is false for some A and some B.
All deciders essentially: Transform finite string
inputs by finite string transformation rules into
{Accept, Reject} values.
When a required result cannot be derived by applying
finite string transformation rules to actual finite
string inputs, then the required result exceeds the
scope of computation and must be rejected as an
incorrect requirement.
On 09/01/2026 17:52, olcott wrote:
On 1/9/2026 3:59 AM, Mikko wrote:
On 08/01/2026 16:22, olcott wrote:
On 1/8/2026 4:22 AM, Mikko wrote:
On 07/01/2026 13:54, olcott wrote:
On 1/7/2026 5:49 AM, Mikko wrote:
On 07/01/2026 06:44, olcott wrote:
All deciders essentially: Transform finite string
inputs by finite string transformation rules into
{Accept, Reject} values.
The counter-example input to requires more than
can be derived from finite string transformation
rules applied to this specific input thus the
Halting Problem requires too much.
In a sense the halting problem asks too much: the problem is
proven to
be unsolvable. In another sense it asks too little: usually we
want to
know whether a method halts on every input, not just one.
Although the halting problem is unsolvable, there are partial
solutions
to the halting problem. In particular, every counter-example to the >>>>>>> full solution is correctly solved by some partial deciders.
*if undecidability is correct then truth itself is broken*
Depends on whether the word "truth" is interpeted in the standard
sense or in Olcott's sense.
Undecidability is misconception. Self-contradictory
expressions are correctly rejected as semantically
incoherent thus form no undecidability or incompleteness.
The misconception is yours. No expression in the language of the first
order group theory is self-contradictory. But the first order goupr
theory is incomplete: it is impossible to prove that AB = BA is true
for every A and every B but it is also impossible to prove that AB = BA
is false for some A and some B.
All deciders essentially: Transform finite string
inputs by finite string transformation rules into
{Accept, Reject} values.
When a required result cannot be derived by applying
finite string transformation rules to actual finite
string inputs, then the required result exceeds the
scope of computation and must be rejected as an
incorrect requirement.
No, that does not follow. If a required result cannot be derived by
appying a finite string transformation then the it it is uncomputable.
Of course, it one can prove that the required result is not computable
then that helps to avoid wasting effort to try the impossible. The
situation is worse if it is not known that the required result is not computable.
That something is not computable does not mean that there is anyting "incorrect" in the requirement.
In order to claim that a requirement
is incorrect one must at least prove that the requirement does not
serve its intended purpose.
Even then it is possible that the
requirement serves some other purpose. Even if a requirement serves
no purpose that need not mean that it be "incorrect", only that it
is useless.
On 1/10/2026 2:23 AM, Mikko wrote:
On 09/01/2026 17:52, olcott wrote:
On 1/9/2026 3:59 AM, Mikko wrote:
On 08/01/2026 16:22, olcott wrote:
On 1/8/2026 4:22 AM, Mikko wrote:
On 07/01/2026 13:54, olcott wrote:
On 1/7/2026 5:49 AM, Mikko wrote:
On 07/01/2026 06:44, olcott wrote:
All deciders essentially: Transform finite string
inputs by finite string transformation rules into
{Accept, Reject} values.
The counter-example input to requires more than
can be derived from finite string transformation
rules applied to this specific input thus the
Halting Problem requires too much.
In a sense the halting problem asks too much: the problem is
proven to
be unsolvable. In another sense it asks too little: usually we >>>>>>>> want to
know whether a method halts on every input, not just one.
Although the halting problem is unsolvable, there are partial >>>>>>>> solutions
to the halting problem. In particular, every counter-example to the >>>>>>>> full solution is correctly solved by some partial deciders.
*if undecidability is correct then truth itself is broken*
Depends on whether the word "truth" is interpeted in the standard
sense or in Olcott's sense.
Undecidability is misconception. Self-contradictory
expressions are correctly rejected as semantically
incoherent thus form no undecidability or incompleteness.
The misconception is yours. No expression in the language of the first >>>> order group theory is self-contradictory. But the first order goupr
theory is incomplete: it is impossible to prove that AB = BA is true
for every A and every B but it is also impossible to prove that AB = BA >>>> is false for some A and some B.
All deciders essentially: Transform finite string
inputs by finite string transformation rules into
{Accept, Reject} values.
When a required result cannot be derived by applying
finite string transformation rules to actual finite
string inputs, then the required result exceeds the
scope of computation and must be rejected as an
incorrect requirement.
No, that does not follow. If a required result cannot be derived by
appying a finite string transformation then the it it is uncomputable.
Right. Outside the scope of computation. Requiring anything
outside the scope of computation is an incorrect requirement.
Of course, it one can prove that the required result is not computable
then that helps to avoid wasting effort to try the impossible. The
situation is worse if it is not known that the required result is not
computable.
That something is not computable does not mean that there is anyting
"incorrect" in the requirement.
Yes it certainly does. Requiring the impossible is always an error.
Requiring an answer to a yes/no question that has no correct yes/no
answer is an incorrect question that must be rejected.
In order to claim that a requirement
is incorrect one must at least prove that the requirement does not
serve its intended purpose.
Requiring the impossible cannot possibly serve any purpose
except perhaps to exemplify one's own ignorance.
Even then it is possible that the
requirement serves some other purpose. Even if a requirement serves
no purpose that need not mean that it be "incorrect", only that it
is useless.
On 09/01/2026 17:52, olcott wrote:
On 1/9/2026 3:59 AM, Mikko wrote:
On 08/01/2026 16:22, olcott wrote:
On 1/8/2026 4:22 AM, Mikko wrote:
On 07/01/2026 13:54, olcott wrote:
On 1/7/2026 5:49 AM, Mikko wrote:
On 07/01/2026 06:44, olcott wrote:
All deciders essentially: Transform finite string
inputs by finite string transformation rules into
{Accept, Reject} values.
The counter-example input to requires more than
can be derived from finite string transformation
rules applied to this specific input thus the
Halting Problem requires too much.
In a sense the halting problem asks too much: the problem is
proven to
be unsolvable. In another sense it asks too little: usually we
want to
know whether a method halts on every input, not just one.
Although the halting problem is unsolvable, there are partial
solutions
to the halting problem. In particular, every counter-example to the >>>>>>> full solution is correctly solved by some partial deciders.
*if undecidability is correct then truth itself is broken*
Depends on whether the word "truth" is interpeted in the standard
sense or in Olcott's sense.
Undecidability is misconception. Self-contradictory
expressions are correctly rejected as semantically
incoherent thus form no undecidability or incompleteness.
The misconception is yours. No expression in the language of the first
order group theory is self-contradictory. But the first order goupr
theory is incomplete: it is impossible to prove that AB = BA is true
for every A and every B but it is also impossible to prove that AB = BA
is false for some A and some B.
All deciders essentially: Transform finite string
inputs by finite string transformation rules into
{Accept, Reject} values.
When a required result cannot be derived by applying
finite string transformation rules to actual finite
string inputs, then the required result exceeds the
scope of computation and must be rejected as an
incorrect requirement.
No, that does not follow. If a required result cannot be derived by
appying a finite string transformation then the it it is uncomputable.
Of course, it one can prove that the required result is not computable
then that helps to avoid wasting effort to try the impossible. The
situation is worse if it is not known that the required result is not computable.
That something is not computable does not mean that there is anyting "incorrect" in the requirement. In order to claim that a requirement
is incorrect one must at least prove that the requirement does not
serve its intended purpose. Even then it is possible that the
requirement serves some other purpose. Even if a requirement serves
no purpose that need not mean that it be "incorrect", only that it
is useless.
On 1/10/26 10:47 AM, olcott wrote:
On 1/10/2026 2:23 AM, Mikko wrote:
On 09/01/2026 17:52, olcott wrote:
On 1/9/2026 3:59 AM, Mikko wrote:
On 08/01/2026 16:22, olcott wrote:
On 1/8/2026 4:22 AM, Mikko wrote:
On 07/01/2026 13:54, olcott wrote:
On 1/7/2026 5:49 AM, Mikko wrote:
On 07/01/2026 06:44, olcott wrote:
All deciders essentially: Transform finite string
inputs by finite string transformation rules into
{Accept, Reject} values.
The counter-example input to requires more than
can be derived from finite string transformation
rules applied to this specific input thus the
Halting Problem requires too much.
In a sense the halting problem asks too much: the problem is >>>>>>>>> proven to
be unsolvable. In another sense it asks too little: usually we >>>>>>>>> want to
know whether a method halts on every input, not just one.
Although the halting problem is unsolvable, there are partial >>>>>>>>> solutions
to the halting problem. In particular, every counter-example to >>>>>>>>> the
full solution is correctly solved by some partial deciders.
*if undecidability is correct then truth itself is broken*
Depends on whether the word "truth" is interpeted in the standard >>>>>>> sense or in Olcott's sense.
Undecidability is misconception. Self-contradictory
expressions are correctly rejected as semantically
incoherent thus form no undecidability or incompleteness.
The misconception is yours. No expression in the language of the first >>>>> order group theory is self-contradictory. But the first order goupr
theory is incomplete: it is impossible to prove that AB = BA is true >>>>> for every A and every B but it is also impossible to prove that AB
= BA
is false for some A and some B.
All deciders essentially: Transform finite string
inputs by finite string transformation rules into
{Accept, Reject} values.
When a required result cannot be derived by applying
finite string transformation rules to actual finite
string inputs, then the required result exceeds the
scope of computation and must be rejected as an
incorrect requirement.
No, that does not follow. If a required result cannot be derived by
appying a finite string transformation then the it it is uncomputable.
Right. Outside the scope of computation. Requiring anything
outside the scope of computation is an incorrect requirement.
Of course, it one can prove that the required result is not computable
then that helps to avoid wasting effort to try the impossible. The
situation is worse if it is not known that the required result is not
computable.
That something is not computable does not mean that there is anyting
"incorrect" in the requirement.
Yes it certainly does. Requiring the impossible is always an error.
Requiring an answer to a yes/no question that has no correct yes/no
answer is an incorrect question that must be rejected.
But then, insisting that things are possilbe to ask the question is an error, as you might not be able to know if it is possible when you ask
the question.
Thus, your logic only allows that asking of questions you already know
that an answer exists.
In order to claim that a requirement
is incorrect one must at least prove that the requirement does not
serve its intended purpose.
Requiring the impossible cannot possibly serve any purpose
except perhaps to exemplify one's own ignorance.
But asking if it is possible lets you know about the limits of what you
can do.
Remember, the halting problems as the question about IS IT POSSIBLE, and that has an answer, it is not possible to to it.
On 1/10/2026 5:19 PM, Richard Damon wrote:
On 1/10/26 10:47 AM, olcott wrote:
On 1/10/2026 2:23 AM, Mikko wrote:
On 09/01/2026 17:52, olcott wrote:
On 1/9/2026 3:59 AM, Mikko wrote:
On 08/01/2026 16:22, olcott wrote:
On 1/8/2026 4:22 AM, Mikko wrote:
On 07/01/2026 13:54, olcott wrote:
On 1/7/2026 5:49 AM, Mikko wrote:
On 07/01/2026 06:44, olcott wrote:*if undecidability is correct then truth itself is broken*
All deciders essentially: Transform finite string
inputs by finite string transformation rules into
{Accept, Reject} values.
The counter-example input to requires more than
can be derived from finite string transformation
rules applied to this specific input thus the
Halting Problem requires too much.
In a sense the halting problem asks too much: the problem is >>>>>>>>>> proven to
be unsolvable. In another sense it asks too little: usually we >>>>>>>>>> want to
know whether a method halts on every input, not just one.
Although the halting problem is unsolvable, there are partial >>>>>>>>>> solutions
to the halting problem. In particular, every counter-example >>>>>>>>>> to the
full solution is correctly solved by some partial deciders. >>>>>>>>>
Depends on whether the word "truth" is interpeted in the standard >>>>>>>> sense or in Olcott's sense.
Undecidability is misconception. Self-contradictory
expressions are correctly rejected as semantically
incoherent thus form no undecidability or incompleteness.
The misconception is yours. No expression in the language of the
first
order group theory is self-contradictory. But the first order goupr >>>>>> theory is incomplete: it is impossible to prove that AB = BA is true >>>>>> for every A and every B but it is also impossible to prove that AB >>>>>> = BA
is false for some A and some B.
All deciders essentially: Transform finite string
inputs by finite string transformation rules into
{Accept, Reject} values.
When a required result cannot be derived by applying
finite string transformation rules to actual finite
string inputs, then the required result exceeds the
scope of computation and must be rejected as an
incorrect requirement.
No, that does not follow. If a required result cannot be derived by
appying a finite string transformation then the it it is uncomputable.
Right. Outside the scope of computation. Requiring anything
outside the scope of computation is an incorrect requirement.
Of course, it one can prove that the required result is not computable >>>> then that helps to avoid wasting effort to try the impossible. The
situation is worse if it is not known that the required result is not
computable.
That something is not computable does not mean that there is anyting
"incorrect" in the requirement.
Yes it certainly does. Requiring the impossible is always an error.
Requiring an answer to a yes/no question that has no correct yes/no
answer is an incorrect question that must be rejected.
But then, insisting that things are possilbe to ask the question is an
error, as you might not be able to know if it is possible when you ask
the question.
Thus, your logic only allows that asking of questions you already know
that an answer exists.
In order to claim that a requirement
is incorrect one must at least prove that the requirement does not
serve its intended purpose.
Requiring the impossible cannot possibly serve any purpose
except perhaps to exemplify one's own ignorance.
But asking if it is possible lets you know about the limits of what
you can do.
Remember, the halting problems as the question about IS IT POSSIBLE,
and that has an answer, it is not possible to to it.
Is it possible to correctly answer self-contradictory questions?
No not even when they are rearranged into a Halting Problem.
I proved the HP input is the same as the Liar Paradox back in 2004
function LoopIfYouSayItHalts (bool YouSayItHalts):
if YouSayItHalts () then
while true do {}
else
return false;
Does this program Halt?
(Your (YES or NO) answer is to be considered
translated to Boolean as the function's input
parameter)
Please ONLY PROVIDE CORRECT ANSWERS
https://groups.google.com/g/sci.logic/c/Hs78nMN6QZE/m/ID2rxwo__yQJ
When you yourself say YES you are wrong
When you yourself say NO you are wrong
Therefore the halting problem counter example input
is a yes/no question lacking a correct yes/no answer.
On 1/10/2026 2:23 AM, Mikko wrote:
On 09/01/2026 17:52, olcott wrote:
On 1/9/2026 3:59 AM, Mikko wrote:
On 08/01/2026 16:22, olcott wrote:
On 1/8/2026 4:22 AM, Mikko wrote:
On 07/01/2026 13:54, olcott wrote:
On 1/7/2026 5:49 AM, Mikko wrote:
On 07/01/2026 06:44, olcott wrote:
All deciders essentially: Transform finite string
inputs by finite string transformation rules into
{Accept, Reject} values.
The counter-example input to requires more than
can be derived from finite string transformation
rules applied to this specific input thus the
Halting Problem requires too much.
In a sense the halting problem asks too much: the problem is
proven to
be unsolvable. In another sense it asks too little: usually we >>>>>>>> want to
know whether a method halts on every input, not just one.
Although the halting problem is unsolvable, there are partial >>>>>>>> solutions
to the halting problem. In particular, every counter-example to the >>>>>>>> full solution is correctly solved by some partial deciders.
*if undecidability is correct then truth itself is broken*
Depends on whether the word "truth" is interpeted in the standard
sense or in Olcott's sense.
Undecidability is misconception. Self-contradictory
expressions are correctly rejected as semantically
incoherent thus form no undecidability or incompleteness.
The misconception is yours. No expression in the language of the first >>>> order group theory is self-contradictory. But the first order goupr
theory is incomplete: it is impossible to prove that AB = BA is true
for every A and every B but it is also impossible to prove that AB = BA >>>> is false for some A and some B.
All deciders essentially: Transform finite string
inputs by finite string transformation rules into
{Accept, Reject} values.
When a required result cannot be derived by applying
finite string transformation rules to actual finite
string inputs, then the required result exceeds the
scope of computation and must be rejected as an
incorrect requirement.
No, that does not follow. If a required result cannot be derived by
appying a finite string transformation then the it it is uncomputable.
Of course, it one can prove that the required result is not computable
then that helps to avoid wasting effort to try the impossible. The
situation is worse if it is not known that the required result is not
computable.
That something is not computable does not mean that there is anyting
"incorrect" in the requirement. In order to claim that a requirement
is incorrect one must at least prove that the requirement does not
serve its intended purpose. Even then it is possible that the
requirement serves some other purpose. Even if a requirement serves
no purpose that need not mean that it be "incorrect", only that it
is useless.
*Computation and Undecidability*
Any result that cannot be derived as a pure function of
finite strings is outside the scope of computation. What
has been construed as decision problem undecidability
has always actually been requirements that are outside
of the scope of computation.
https://www.researchgate.net/ publication/399111881_Computation_and_Undecidability
On 1/10/26 7:13 PM, olcott wrote:
On 1/10/2026 5:19 PM, Richard Damon wrote:
On 1/10/26 10:47 AM, olcott wrote:
On 1/10/2026 2:23 AM, Mikko wrote:
On 09/01/2026 17:52, olcott wrote:Right. Outside the scope of computation. Requiring anything
On 1/9/2026 3:59 AM, Mikko wrote:
On 08/01/2026 16:22, olcott wrote:
On 1/8/2026 4:22 AM, Mikko wrote:
On 07/01/2026 13:54, olcott wrote:
On 1/7/2026 5:49 AM, Mikko wrote:
On 07/01/2026 06:44, olcott wrote:*if undecidability is correct then truth itself is broken*
All deciders essentially: Transform finite string
inputs by finite string transformation rules into
{Accept, Reject} values.
The counter-example input to requires more than
can be derived from finite string transformation
rules applied to this specific input thus the
Halting Problem requires too much.
In a sense the halting problem asks too much: the problem is >>>>>>>>>>> proven to
be unsolvable. In another sense it asks too little: usually >>>>>>>>>>> we want to
know whether a method halts on every input, not just one. >>>>>>>>>>>
Although the halting problem is unsolvable, there are partial >>>>>>>>>>> solutions
to the halting problem. In particular, every counter-example >>>>>>>>>>> to the
full solution is correctly solved by some partial deciders. >>>>>>>>>>
Depends on whether the word "truth" is interpeted in the standard >>>>>>>>> sense or in Olcott's sense.
Undecidability is misconception. Self-contradictory
expressions are correctly rejected as semantically
incoherent thus form no undecidability or incompleteness.
The misconception is yours. No expression in the language of the >>>>>>> first
order group theory is self-contradictory. But the first order goupr >>>>>>> theory is incomplete: it is impossible to prove that AB = BA is true >>>>>>> for every A and every B but it is also impossible to prove that >>>>>>> AB = BA
is false for some A and some B.
All deciders essentially: Transform finite string
inputs by finite string transformation rules into
{Accept, Reject} values.
When a required result cannot be derived by applying
finite string transformation rules to actual finite
string inputs, then the required result exceeds the
scope of computation and must be rejected as an
incorrect requirement.
No, that does not follow. If a required result cannot be derived by
appying a finite string transformation then the it it is uncomputable. >>>>
outside the scope of computation is an incorrect requirement.
Of course, it one can prove that the required result is not computable >>>>> then that helps to avoid wasting effort to try the impossible. The
situation is worse if it is not known that the required result is not >>>>> computable.
That something is not computable does not mean that there is anyting >>>>> "incorrect" in the requirement.
Yes it certainly does. Requiring the impossible is always an error.
Requiring an answer to a yes/no question that has no correct yes/no
answer is an incorrect question that must be rejected.
But then, insisting that things are possilbe to ask the question is
an error, as you might not be able to know if it is possible when you
ask the question.
Thus, your logic only allows that asking of questions you already
know that an answer exists.
In order to claim that a requirement
is incorrect one must at least prove that the requirement does not
serve its intended purpose.
Requiring the impossible cannot possibly serve any purpose
except perhaps to exemplify one's own ignorance.
But asking if it is possible lets you know about the limits of what
you can do.
Remember, the halting problems as the question about IS IT POSSIBLE,
and that has an answer, it is not possible to to it.
Is it possible to correctly answer self-contradictory questions?
But the actual question isn't "self-contradictiory".
No not even when they are rearranged into a Halting Problem.
But the actual problem isn't the one you talk about, only your
subjective misquoting of it.
I proved the HP input is the same as the Liar Paradox back in 2004
No, that provees you don't know what the halting problem IS.,
function LoopIfYouSayItHalts (bool YouSayItHalts):
if YouSayItHalts () then
while true do {}
else
return false;
Does this program Halt?
(Your (YES or NO) answer is to be considered
translated to Boolean as the function's input
parameter)
Please ONLY PROVIDE CORRECT ANSWERS
https://groups.google.com/g/sci.logic/c/Hs78nMN6QZE/m/ID2rxwo__yQJ
When you yourself say YES you are wrong
When you yourself say NO you are wrong
But you are asking TWO questions, as the behavior of a program is a funcgtion of its input.
Thus, you show you don't understand that problem.
Therefore the halting problem counter example input
is a yes/no question lacking a correct yes/no answer.
No, you are just showing you re too stupid to read the simple
explanatins of the problem.
Your problem HAS an answer, but one you reject as you don't understand--
the question.
The correct answer is:
LoopIfYouSayItHalts(true) does not halt
LoopIfYouSayItHalts(false) halts.
Remember, the question is about the behavior of the program with its
input, and thus you are allowed a different answer for every possible
input.
Now, for a Termination analyzer, the answer is that the program is NOT a complete function, as it doens't halt for some inputs.
On 1/10/26 6:19 PM, olcott wrote:
On 1/10/2026 2:23 AM, Mikko wrote:
On 09/01/2026 17:52, olcott wrote:
On 1/9/2026 3:59 AM, Mikko wrote:
On 08/01/2026 16:22, olcott wrote:
On 1/8/2026 4:22 AM, Mikko wrote:
On 07/01/2026 13:54, olcott wrote:
On 1/7/2026 5:49 AM, Mikko wrote:
On 07/01/2026 06:44, olcott wrote:
All deciders essentially: Transform finite string
inputs by finite string transformation rules into
{Accept, Reject} values.
The counter-example input to requires more than
can be derived from finite string transformation
rules applied to this specific input thus the
Halting Problem requires too much.
In a sense the halting problem asks too much: the problem is >>>>>>>>> proven to
be unsolvable. In another sense it asks too little: usually we >>>>>>>>> want to
know whether a method halts on every input, not just one.
Although the halting problem is unsolvable, there are partial >>>>>>>>> solutions
to the halting problem. In particular, every counter-example to >>>>>>>>> the
full solution is correctly solved by some partial deciders.
*if undecidability is correct then truth itself is broken*
Depends on whether the word "truth" is interpeted in the standard >>>>>>> sense or in Olcott's sense.
Undecidability is misconception. Self-contradictory
expressions are correctly rejected as semantically
incoherent thus form no undecidability or incompleteness.
The misconception is yours. No expression in the language of the first >>>>> order group theory is self-contradictory. But the first order goupr
theory is incomplete: it is impossible to prove that AB = BA is true >>>>> for every A and every B but it is also impossible to prove that AB
= BA
is false for some A and some B.
All deciders essentially: Transform finite string
inputs by finite string transformation rules into
{Accept, Reject} values.
When a required result cannot be derived by applying
finite string transformation rules to actual finite
string inputs, then the required result exceeds the
scope of computation and must be rejected as an
incorrect requirement.
No, that does not follow. If a required result cannot be derived by
appying a finite string transformation then the it it is uncomputable.
Of course, it one can prove that the required result is not computable
then that helps to avoid wasting effort to try the impossible. The
situation is worse if it is not known that the required result is not
computable.
That something is not computable does not mean that there is anyting
"incorrect" in the requirement. In order to claim that a requirement
is incorrect one must at least prove that the requirement does not
serve its intended purpose. Even then it is possible that the
requirement serves some other purpose. Even if a requirement serves
no purpose that need not mean that it be "incorrect", only that it
is useless.
*Computation and Undecidability*
Any result that cannot be derived as a pure function of
finite strings is outside the scope of computation. What
has been construed as decision problem undecidability
has always actually been requirements that are outside
of the scope of computation.
https://www.researchgate.net/
publication/399111881_Computation_and_Undecidability
So why isn't DD() -> Halts (since your HHH(DD) returns 0) not a pure function of the input.
Now, if your DD doesn't include the code for HHH, then you show your problem, your input isn't that of a program, and thus out of sco[e.
The Halting Problem only talks about the behavior of PROGRAMS, which requires that the input specify ALL of the algorith/code used by it. so
your "C function" DD isn't a valid input without also specifying the SPECIFIC HHH that it calls.
On 1/10/26 6:19 PM, olcott wrote:
On 1/10/2026 2:23 AM, Mikko wrote:
On 09/01/2026 17:52, olcott wrote:
On 1/9/2026 3:59 AM, Mikko wrote:
On 08/01/2026 16:22, olcott wrote:
On 1/8/2026 4:22 AM, Mikko wrote:
On 07/01/2026 13:54, olcott wrote:
On 1/7/2026 5:49 AM, Mikko wrote:
On 07/01/2026 06:44, olcott wrote:
All deciders essentially: Transform finite string
inputs by finite string transformation rules into
{Accept, Reject} values.
The counter-example input to requires more than
can be derived from finite string transformation
rules applied to this specific input thus the
Halting Problem requires too much.
In a sense the halting problem asks too much: the problem is >>>>>>>>> proven to
be unsolvable. In another sense it asks too little: usually we >>>>>>>>> want to
know whether a method halts on every input, not just one.
Although the halting problem is unsolvable, there are partial >>>>>>>>> solutions
to the halting problem. In particular, every counter-example to >>>>>>>>> the
full solution is correctly solved by some partial deciders.
*if undecidability is correct then truth itself is broken*
Depends on whether the word "truth" is interpeted in the standard >>>>>>> sense or in Olcott's sense.
Undecidability is misconception. Self-contradictory
expressions are correctly rejected as semantically
incoherent thus form no undecidability or incompleteness.
The misconception is yours. No expression in the language of the first >>>>> order group theory is self-contradictory. But the first order goupr
theory is incomplete: it is impossible to prove that AB = BA is true >>>>> for every A and every B but it is also impossible to prove that AB
= BA
is false for some A and some B.
All deciders essentially: Transform finite string
inputs by finite string transformation rules into
{Accept, Reject} values.
When a required result cannot be derived by applying
finite string transformation rules to actual finite
string inputs, then the required result exceeds the
scope of computation and must be rejected as an
incorrect requirement.
No, that does not follow. If a required result cannot be derived by
appying a finite string transformation then the it it is uncomputable.
Of course, it one can prove that the required result is not computable
then that helps to avoid wasting effort to try the impossible. The
situation is worse if it is not known that the required result is not
computable.
That something is not computable does not mean that there is anyting
"incorrect" in the requirement. In order to claim that a requirement
is incorrect one must at least prove that the requirement does not
serve its intended purpose. Even then it is possible that the
requirement serves some other purpose. Even if a requirement serves
no purpose that need not mean that it be "incorrect", only that it
is useless.
*Computation and Undecidability*
Any result that cannot be derived as a pure function of
finite strings is outside the scope of computation. What
has been construed as decision problem undecidability
has always actually been requirements that are outside
of the scope of computation.
https://www.researchgate.net/
publication/399111881_Computation_and_Undecidability
So why isn't DD() -> Halts (since your HHH(DD) returns 0) not a pure function of the input.
Now, if your DD doesn't include the code for HHH, then you show your problem, your input isn't that of a program, and thus out of sco[e.
The Halting Problem only talks about the behavior of PROGRAMS, which requires that the input specify ALL of the algorith/code used by it. so
your "C function" DD isn't a valid input without also specifying the SPECIFIC HHH that it calls.
On 1/10/2026 6:35 PM, Richard Damon wrote:
On 1/10/26 6:19 PM, olcott wrote:
On 1/10/2026 2:23 AM, Mikko wrote:
On 09/01/2026 17:52, olcott wrote:
On 1/9/2026 3:59 AM, Mikko wrote:
On 08/01/2026 16:22, olcott wrote:
On 1/8/2026 4:22 AM, Mikko wrote:
On 07/01/2026 13:54, olcott wrote:
On 1/7/2026 5:49 AM, Mikko wrote:
On 07/01/2026 06:44, olcott wrote:*if undecidability is correct then truth itself is broken*
All deciders essentially: Transform finite string
inputs by finite string transformation rules into
{Accept, Reject} values.
The counter-example input to requires more than
can be derived from finite string transformation
rules applied to this specific input thus the
Halting Problem requires too much.
In a sense the halting problem asks too much: the problem is >>>>>>>>>> proven to
be unsolvable. In another sense it asks too little: usually we >>>>>>>>>> want to
know whether a method halts on every input, not just one.
Although the halting problem is unsolvable, there are partial >>>>>>>>>> solutions
to the halting problem. In particular, every counter-example >>>>>>>>>> to the
full solution is correctly solved by some partial deciders. >>>>>>>>>
Depends on whether the word "truth" is interpeted in the standard >>>>>>>> sense or in Olcott's sense.
Undecidability is misconception. Self-contradictory
expressions are correctly rejected as semantically
incoherent thus form no undecidability or incompleteness.
The misconception is yours. No expression in the language of the
first
order group theory is self-contradictory. But the first order goupr >>>>>> theory is incomplete: it is impossible to prove that AB = BA is true >>>>>> for every A and every B but it is also impossible to prove that AB >>>>>> = BA
is false for some A and some B.
All deciders essentially: Transform finite string
inputs by finite string transformation rules into
{Accept, Reject} values.
When a required result cannot be derived by applying
finite string transformation rules to actual finite
string inputs, then the required result exceeds the
scope of computation and must be rejected as an
incorrect requirement.
No, that does not follow. If a required result cannot be derived by
appying a finite string transformation then the it it is uncomputable. >>>> Of course, it one can prove that the required result is not computable >>>> then that helps to avoid wasting effort to try the impossible. The
situation is worse if it is not known that the required result is not
computable.
That something is not computable does not mean that there is anyting
"incorrect" in the requirement. In order to claim that a requirement
is incorrect one must at least prove that the requirement does not
serve its intended purpose. Even then it is possible that the
requirement serves some other purpose. Even if a requirement serves
no purpose that need not mean that it be "incorrect", only that it
is useless.
*Computation and Undecidability*
Any result that cannot be derived as a pure function of
finite strings is outside the scope of computation. What
has been construed as decision problem undecidability
has always actually been requirements that are outside
of the scope of computation.
https://www.researchgate.net/
publication/399111881_Computation_and_Undecidability
So why isn't DD() -> Halts (since your HHH(DD) returns 0) not a pure
function of the input.
Now, if your DD doesn't include the code for HHH, then you show your
problem, your input isn't that of a program, and thus out of sco[e.
The Halting Problem only talks about the behavior of PROGRAMS, which
requires that the input specify ALL of the algorith/code used by it.
so your "C function" DD isn't a valid input without also specifying
the SPECIFIC HHH that it calls.
A shorter link that won't get unintentionally chopped off.
*Computation and Undecidability*
https://philpapers.org/go.pl?aid=OLCCAU
*ChatGPT explains how and why I am correct*
*Reinterpretation of undecidability*
The example of P and H demonstrates that what is
often called “undecidable” is better understood as
ill-posed with respect to computable semantics.
When the specification is constrained to properties
detectable via finite simulation and finite pattern
recognition, computation proceeds normally and
correctly. Undecidability only appears when the
specification overreaches that boundary.
On 1/10/2026 6:35 PM, Richard Damon wrote:
On 1/10/26 6:19 PM, olcott wrote:
On 1/10/2026 2:23 AM, Mikko wrote:
On 09/01/2026 17:52, olcott wrote:
On 1/9/2026 3:59 AM, Mikko wrote:
On 08/01/2026 16:22, olcott wrote:
On 1/8/2026 4:22 AM, Mikko wrote:
On 07/01/2026 13:54, olcott wrote:
On 1/7/2026 5:49 AM, Mikko wrote:
On 07/01/2026 06:44, olcott wrote:*if undecidability is correct then truth itself is broken*
All deciders essentially: Transform finite string
inputs by finite string transformation rules into
{Accept, Reject} values.
The counter-example input to requires more than
can be derived from finite string transformation
rules applied to this specific input thus the
Halting Problem requires too much.
In a sense the halting problem asks too much: the problem is >>>>>>>>>> proven to
be unsolvable. In another sense it asks too little: usually we >>>>>>>>>> want to
know whether a method halts on every input, not just one.
Although the halting problem is unsolvable, there are partial >>>>>>>>>> solutions
to the halting problem. In particular, every counter-example >>>>>>>>>> to the
full solution is correctly solved by some partial deciders. >>>>>>>>>
Depends on whether the word "truth" is interpeted in the standard >>>>>>>> sense or in Olcott's sense.
Undecidability is misconception. Self-contradictory
expressions are correctly rejected as semantically
incoherent thus form no undecidability or incompleteness.
The misconception is yours. No expression in the language of the
first
order group theory is self-contradictory. But the first order goupr >>>>>> theory is incomplete: it is impossible to prove that AB = BA is true >>>>>> for every A and every B but it is also impossible to prove that AB >>>>>> = BA
is false for some A and some B.
All deciders essentially: Transform finite string
inputs by finite string transformation rules into
{Accept, Reject} values.
When a required result cannot be derived by applying
finite string transformation rules to actual finite
string inputs, then the required result exceeds the
scope of computation and must be rejected as an
incorrect requirement.
No, that does not follow. If a required result cannot be derived by
appying a finite string transformation then the it it is uncomputable. >>>> Of course, it one can prove that the required result is not computable >>>> then that helps to avoid wasting effort to try the impossible. The
situation is worse if it is not known that the required result is not
computable.
That something is not computable does not mean that there is anyting
"incorrect" in the requirement. In order to claim that a requirement
is incorrect one must at least prove that the requirement does not
serve its intended purpose. Even then it is possible that the
requirement serves some other purpose. Even if a requirement serves
no purpose that need not mean that it be "incorrect", only that it
is useless.
*Computation and Undecidability*
Any result that cannot be derived as a pure function of
finite strings is outside the scope of computation. What
has been construed as decision problem undecidability
has always actually been requirements that are outside
of the scope of computation.
https://www.researchgate.net/
publication/399111881_Computation_and_Undecidability
*Computation and Undecidability*
https://philpapers.org/go.pl?aid=OLCCAU
So why isn't DD() -> Halts (since your HHH(DD) returns 0) not a pure
function of the input.
Now, if your DD doesn't include the code for HHH, then you show your
problem, your input isn't that of a program, and thus out of sco[e.
The Halting Problem only talks about the behavior of PROGRAMS, which
requires that the input specify ALL of the algorith/code used by it.
so your "C function" DD isn't a valid input without also specifying
the SPECIFIC HHH that it calls.
*ChatGPT explains how and why I am correct*
*Reinterpretation of undecidability*
The example of P and H demonstrates that what is
often called “undecidable” is better understood as
ill-posed with respect to computable semantics.
When the specification is constrained to properties
detectable via finite simulation and finite pattern
recognition, computation proceeds normally and
correctly. Undecidability only appears when the
specification overreaches that boundary.
On 1/10/2026 6:35 PM, Richard Damon wrote:
On 1/10/26 7:13 PM, olcott wrote:
On 1/10/2026 5:19 PM, Richard Damon wrote:
On 1/10/26 10:47 AM, olcott wrote:
On 1/10/2026 2:23 AM, Mikko wrote:
On 09/01/2026 17:52, olcott wrote:
On 1/9/2026 3:59 AM, Mikko wrote:
On 08/01/2026 16:22, olcott wrote:
On 1/8/2026 4:22 AM, Mikko wrote:
On 07/01/2026 13:54, olcott wrote:
On 1/7/2026 5:49 AM, Mikko wrote:Depends on whether the word "truth" is interpeted in the standard >>>>>>>>>> sense or in Olcott's sense.
On 07/01/2026 06:44, olcott wrote:*if undecidability is correct then truth itself is broken* >>>>>>>>>>
All deciders essentially: Transform finite string
inputs by finite string transformation rules into
{Accept, Reject} values.
The counter-example input to requires more than
can be derived from finite string transformation
rules applied to this specific input thus the
Halting Problem requires too much.
In a sense the halting problem asks too much: the problem is >>>>>>>>>>>> proven to
be unsolvable. In another sense it asks too little: usually >>>>>>>>>>>> we want to
know whether a method halts on every input, not just one. >>>>>>>>>>>>
Although the halting problem is unsolvable, there are >>>>>>>>>>>> partial solutions
to the halting problem. In particular, every counter-example >>>>>>>>>>>> to the
full solution is correctly solved by some partial deciders. >>>>>>>>>>>
Undecidability is misconception. Self-contradictory
expressions are correctly rejected as semantically
incoherent thus form no undecidability or incompleteness.
The misconception is yours. No expression in the language of the >>>>>>>> first
order group theory is self-contradictory. But the first order goupr >>>>>>>> theory is incomplete: it is impossible to prove that AB = BA is >>>>>>>> true
for every A and every B but it is also impossible to prove that >>>>>>>> AB = BA
is false for some A and some B.
All deciders essentially: Transform finite string
inputs by finite string transformation rules into
{Accept, Reject} values.
When a required result cannot be derived by applying
finite string transformation rules to actual finite
string inputs, then the required result exceeds the
scope of computation and must be rejected as an
incorrect requirement.
No, that does not follow. If a required result cannot be derived by >>>>>> appying a finite string transformation then the it it is
uncomputable.
Right. Outside the scope of computation. Requiring anything
outside the scope of computation is an incorrect requirement.
Of course, it one can prove that the required result is not
computable
then that helps to avoid wasting effort to try the impossible. The >>>>>> situation is worse if it is not known that the required result is not >>>>>> computable.
That something is not computable does not mean that there is anyting >>>>>> "incorrect" in the requirement.
Yes it certainly does. Requiring the impossible is always an error.
Requiring an answer to a yes/no question that has no correct yes/no
answer is an incorrect question that must be rejected.
But then, insisting that things are possilbe to ask the question is
an error, as you might not be able to know if it is possible when
you ask the question.
Thus, your logic only allows that asking of questions you already
know that an answer exists.
In order to claim that a requirement
is incorrect one must at least prove that the requirement does not >>>>>> serve its intended purpose.
Requiring the impossible cannot possibly serve any purpose
except perhaps to exemplify one's own ignorance.
But asking if it is possible lets you know about the limits of what
you can do.
Remember, the halting problems as the question about IS IT POSSIBLE,
and that has an answer, it is not possible to to it.
Is it possible to correctly answer self-contradictory questions?
But the actual question isn't "self-contradictiory".
No not even when they are rearranged into a Halting Problem.
But the actual problem isn't the one you talk about, only your
subjective misquoting of it.
I proved the HP input is the same as the Liar Paradox back in 2004
No, that provees you don't know what the halting problem IS.,
function LoopIfYouSayItHalts (bool YouSayItHalts):
if YouSayItHalts () then
while true do {}
else
return false;
Does this program Halt?
(Your (YES or NO) answer is to be considered
translated to Boolean as the function's input
parameter)
Please ONLY PROVIDE CORRECT ANSWERS
https://groups.google.com/g/sci.logic/c/Hs78nMN6QZE/m/ID2rxwo__yQJ
When you yourself say YES you are wrong
When you yourself say NO you are wrong
But you are asking TWO questions, as the behavior of a program is a
funcgtion of its input.
Thus, you show you don't understand that problem.
Therefore the halting problem counter example input
is a yes/no question lacking a correct yes/no answer.
No, you are just showing you re too stupid to read the simple
explanatins of the problem.
Every explanation of the problem requires a result that
cannot be derived by applying finite string transformation
rules to actual finite string inputs.
When an input does the opposite of whatever value
its decider returns: Does this input halt?
Is a yes/no question lacking a correct yes/no answer
thus an incorrect question.
Your problem HAS an answer, but one you reject as you don't understand
the question.
The correct answer is:
LoopIfYouSayItHalts(true) does not halt
LoopIfYouSayItHalts(false) halts.
Remember, the question is about the behavior of the program with its
input, and thus you are allowed a different answer for every possible
input.
Now, for a Termination analyzer, the answer is that the program is NOT
a complete function, as it doens't halt for some inputs.
On 1/10/26 8:05 PM, olcott wrote:
On 1/10/2026 6:35 PM, Richard Damon wrote:
On 1/10/26 6:19 PM, olcott wrote:
On 1/10/2026 2:23 AM, Mikko wrote:
On 09/01/2026 17:52, olcott wrote:
On 1/9/2026 3:59 AM, Mikko wrote:
On 08/01/2026 16:22, olcott wrote:
On 1/8/2026 4:22 AM, Mikko wrote:
On 07/01/2026 13:54, olcott wrote:
On 1/7/2026 5:49 AM, Mikko wrote:
On 07/01/2026 06:44, olcott wrote:*if undecidability is correct then truth itself is broken*
All deciders essentially: Transform finite string
inputs by finite string transformation rules into
{Accept, Reject} values.
The counter-example input to requires more than
can be derived from finite string transformation
rules applied to this specific input thus the
Halting Problem requires too much.
In a sense the halting problem asks too much: the problem is >>>>>>>>>>> proven to
be unsolvable. In another sense it asks too little: usually >>>>>>>>>>> we want to
know whether a method halts on every input, not just one. >>>>>>>>>>>
Although the halting problem is unsolvable, there are partial >>>>>>>>>>> solutions
to the halting problem. In particular, every counter-example >>>>>>>>>>> to the
full solution is correctly solved by some partial deciders. >>>>>>>>>>
Depends on whether the word "truth" is interpeted in the standard >>>>>>>>> sense or in Olcott's sense.
Undecidability is misconception. Self-contradictory
expressions are correctly rejected as semantically
incoherent thus form no undecidability or incompleteness.
The misconception is yours. No expression in the language of the >>>>>>> first
order group theory is self-contradictory. But the first order goupr >>>>>>> theory is incomplete: it is impossible to prove that AB = BA is true >>>>>>> for every A and every B but it is also impossible to prove that >>>>>>> AB = BA
is false for some A and some B.
All deciders essentially: Transform finite string
inputs by finite string transformation rules into
{Accept, Reject} values.
When a required result cannot be derived by applying
finite string transformation rules to actual finite
string inputs, then the required result exceeds the
scope of computation and must be rejected as an
incorrect requirement.
No, that does not follow. If a required result cannot be derived by
appying a finite string transformation then the it it is uncomputable. >>>>> Of course, it one can prove that the required result is not computable >>>>> then that helps to avoid wasting effort to try the impossible. The
situation is worse if it is not known that the required result is not >>>>> computable.
That something is not computable does not mean that there is anyting >>>>> "incorrect" in the requirement. In order to claim that a requirement >>>>> is incorrect one must at least prove that the requirement does not
serve its intended purpose. Even then it is possible that the
requirement serves some other purpose. Even if a requirement serves
no purpose that need not mean that it be "incorrect", only that it
is useless.
*Computation and Undecidability*
Any result that cannot be derived as a pure function of
finite strings is outside the scope of computation. What
has been construed as decision problem undecidability
has always actually been requirements that are outside
of the scope of computation.
https://www.researchgate.net/
publication/399111881_Computation_and_Undecidability
So why isn't DD() -> Halts (since your HHH(DD) returns 0) not a pure
function of the input.
Now, if your DD doesn't include the code for HHH, then you show your
problem, your input isn't that of a program, and thus out of sco[e.
The Halting Problem only talks about the behavior of PROGRAMS, which
requires that the input specify ALL of the algorith/code used by it.
so your "C function" DD isn't a valid input without also specifying
the SPECIFIC HHH that it calls.
A shorter link that won't get unintentionally chopped off.
*Computation and Undecidability*
https://philpapers.org/go.pl?aid=OLCCAU
*ChatGPT explains how and why I am correct*
*Reinterpretation of undecidability*
The example of P and H demonstrates that what is
often called “undecidable” is better understood as
ill-posed with respect to computable semantics.
When the specification is constrained to properties
detectable via finite simulation and finite pattern
recognition, computation proceeds normally and
correctly. Undecidability only appears when the
specification overreaches that boundary.
Which just shows it doesn't know what "undecidability" is.
And neither do you, or how LLMs work.
Note, your "criteria" means you can't ask a question about computing you don't know the answer to.
This shows how stupid you are.
On 1/10/26 8:03 PM, olcott wrote:
On 1/10/2026 6:35 PM, Richard Damon wrote:
On 1/10/26 6:19 PM, olcott wrote:
On 1/10/2026 2:23 AM, Mikko wrote:
On 09/01/2026 17:52, olcott wrote:
On 1/9/2026 3:59 AM, Mikko wrote:
On 08/01/2026 16:22, olcott wrote:
On 1/8/2026 4:22 AM, Mikko wrote:
On 07/01/2026 13:54, olcott wrote:
On 1/7/2026 5:49 AM, Mikko wrote:
On 07/01/2026 06:44, olcott wrote:*if undecidability is correct then truth itself is broken*
All deciders essentially: Transform finite string
inputs by finite string transformation rules into
{Accept, Reject} values.
The counter-example input to requires more than
can be derived from finite string transformation
rules applied to this specific input thus the
Halting Problem requires too much.
In a sense the halting problem asks too much: the problem is >>>>>>>>>>> proven to
be unsolvable. In another sense it asks too little: usually >>>>>>>>>>> we want to
know whether a method halts on every input, not just one. >>>>>>>>>>>
Although the halting problem is unsolvable, there are partial >>>>>>>>>>> solutions
to the halting problem. In particular, every counter-example >>>>>>>>>>> to the
full solution is correctly solved by some partial deciders. >>>>>>>>>>
Depends on whether the word "truth" is interpeted in the standard >>>>>>>>> sense or in Olcott's sense.
Undecidability is misconception. Self-contradictory
expressions are correctly rejected as semantically
incoherent thus form no undecidability or incompleteness.
The misconception is yours. No expression in the language of the >>>>>>> first
order group theory is self-contradictory. But the first order goupr >>>>>>> theory is incomplete: it is impossible to prove that AB = BA is true >>>>>>> for every A and every B but it is also impossible to prove that >>>>>>> AB = BA
is false for some A and some B.
All deciders essentially: Transform finite string
inputs by finite string transformation rules into
{Accept, Reject} values.
When a required result cannot be derived by applying
finite string transformation rules to actual finite
string inputs, then the required result exceeds the
scope of computation and must be rejected as an
incorrect requirement.
No, that does not follow. If a required result cannot be derived by
appying a finite string transformation then the it it is uncomputable. >>>>> Of course, it one can prove that the required result is not computable >>>>> then that helps to avoid wasting effort to try the impossible. The
situation is worse if it is not known that the required result is not >>>>> computable.
That something is not computable does not mean that there is anyting >>>>> "incorrect" in the requirement. In order to claim that a requirement >>>>> is incorrect one must at least prove that the requirement does not
serve its intended purpose. Even then it is possible that the
requirement serves some other purpose. Even if a requirement serves
no purpose that need not mean that it be "incorrect", only that it
is useless.
*Computation and Undecidability*
Any result that cannot be derived as a pure function of
finite strings is outside the scope of computation. What
has been construed as decision problem undecidability
has always actually been requirements that are outside
of the scope of computation.
https://www.researchgate.net/
publication/399111881_Computation_and_Undecidability
*Computation and Undecidability*
https://philpapers.org/go.pl?aid=OLCCAU
Which just shows you don't know what you are talking about.
You said:
Any result that cannot be derived as a pure function of finite strings
is outside the scope of computation. What has been construed as decision problem undecidability has always actually been requirements that are outside of the scope of computation.
Which is just a LIE, based on not knowing what you are talking about.
The "Scope of Computation", as in what scope of problems that Compuation Theory looks at, are the mappings of one domain (often limited to a countably infinite domain so it is representable as a finte string) to another domain.
The primary question of that domain, is which mapping can be computed by
a finite machine using a specific fully defined algorithm.
What you can your "Scope of Computation" is the range of what is
computable.
In other words, the "Scope" of what we want to be able to
do,
and thus the set of problems that ARE computable.
You don't seem to understand the differnce between the problem of determining Computability and what is actually computable, just like you don't understand the difference between Truth and Knowledge.
So why isn't DD() -> Halts (since your HHH(DD) returns 0) not a pure
function of the input.
Now, if your DD doesn't include the code for HHH, then you show your
problem, your input isn't that of a program, and thus out of sco[e.
The Halting Problem only talks about the behavior of PROGRAMS, which
requires that the input specify ALL of the algorith/code used by it.
so your "C function" DD isn't a valid input without also specifying
the SPECIFIC HHH that it calls.
*ChatGPT explains how and why I am correct*
*Reinterpretation of undecidability*
The example of P and H demonstrates that what is
often called “undecidable” is better understood as
ill-posed with respect to computable semantics.
When the specification is constrained to properties
detectable via finite simulation and finite pattern
recognition, computation proceeds normally and
correctly. Undecidability only appears when the
specification overreaches that boundary.
But "Finite Simulation and finite pattern recognition" is NOT "Finiite String Transformation".
So, you are just showing you don't understand what you are talking about.
On 1/10/26 7:52 PM, olcott wrote:
On 1/10/2026 6:35 PM, Richard Damon wrote:
On 1/10/26 7:13 PM, olcott wrote:
On 1/10/2026 5:19 PM, Richard Damon wrote:
On 1/10/26 10:47 AM, olcott wrote:
On 1/10/2026 2:23 AM, Mikko wrote:
On 09/01/2026 17:52, olcott wrote:
On 1/9/2026 3:59 AM, Mikko wrote:
On 08/01/2026 16:22, olcott wrote:
On 1/8/2026 4:22 AM, Mikko wrote:
On 07/01/2026 13:54, olcott wrote:
On 1/7/2026 5:49 AM, Mikko wrote:Depends on whether the word "truth" is interpeted in the >>>>>>>>>>> standard
On 07/01/2026 06:44, olcott wrote:*if undecidability is correct then truth itself is broken* >>>>>>>>>>>
All deciders essentially: Transform finite string
inputs by finite string transformation rules into
{Accept, Reject} values.
The counter-example input to requires more than
can be derived from finite string transformation
rules applied to this specific input thus the
Halting Problem requires too much.
In a sense the halting problem asks too much: the problem >>>>>>>>>>>>> is proven to
be unsolvable. In another sense it asks too little: usually >>>>>>>>>>>>> we want to
know whether a method halts on every input, not just one. >>>>>>>>>>>>>
Although the halting problem is unsolvable, there are >>>>>>>>>>>>> partial solutions
to the halting problem. In particular, every counter- >>>>>>>>>>>>> example to the
full solution is correctly solved by some partial deciders. >>>>>>>>>>>>
sense or in Olcott's sense.
Undecidability is misconception. Self-contradictory
expressions are correctly rejected as semantically
incoherent thus form no undecidability or incompleteness.
The misconception is yours. No expression in the language of >>>>>>>>> the first
order group theory is self-contradictory. But the first order >>>>>>>>> goupr
theory is incomplete: it is impossible to prove that AB = BA is >>>>>>>>> true
for every A and every B but it is also impossible to prove that >>>>>>>>> AB = BA
is false for some A and some B.
All deciders essentially: Transform finite string
inputs by finite string transformation rules into
{Accept, Reject} values.
When a required result cannot be derived by applying
finite string transformation rules to actual finite
string inputs, then the required result exceeds the
scope of computation and must be rejected as an
incorrect requirement.
No, that does not follow. If a required result cannot be derived by >>>>>>> appying a finite string transformation then the it it is
uncomputable.
Right. Outside the scope of computation. Requiring anything
outside the scope of computation is an incorrect requirement.
Of course, it one can prove that the required result is not
computable
then that helps to avoid wasting effort to try the impossible. The >>>>>>> situation is worse if it is not known that the required result is >>>>>>> not
computable.
That something is not computable does not mean that there is anyting >>>>>>> "incorrect" in the requirement.
Yes it certainly does. Requiring the impossible is always an error. >>>>>> Requiring an answer to a yes/no question that has no correct yes/no >>>>>> answer is an incorrect question that must be rejected.
But then, insisting that things are possilbe to ask the question is >>>>> an error, as you might not be able to know if it is possible when
you ask the question.
Thus, your logic only allows that asking of questions you already
know that an answer exists.
In order to claim that a requirement
is incorrect one must at least prove that the requirement does not >>>>>>> serve its intended purpose.
Requiring the impossible cannot possibly serve any purpose
except perhaps to exemplify one's own ignorance.
But asking if it is possible lets you know about the limits of what >>>>> you can do.
Remember, the halting problems as the question about IS IT
POSSIBLE, and that has an answer, it is not possible to to it.
Is it possible to correctly answer self-contradictory questions?
But the actual question isn't "self-contradictiory".
No not even when they are rearranged into a Halting Problem.
But the actual problem isn't the one you talk about, only your
subjective misquoting of it.
I proved the HP input is the same as the Liar Paradox back in 2004
No, that provees you don't know what the halting problem IS.,
function LoopIfYouSayItHalts (bool YouSayItHalts):
if YouSayItHalts () then
while true do {}
else
return false;
Does this program Halt?
(Your (YES or NO) answer is to be considered
translated to Boolean as the function's input
parameter)
Please ONLY PROVIDE CORRECT ANSWERS
https://groups.google.com/g/sci.logic/c/Hs78nMN6QZE/m/ID2rxwo__yQJ
When you yourself say YES you are wrong
When you yourself say NO you are wrong
But you are asking TWO questions, as the behavior of a program is a
funcgtion of its input.
Thus, you show you don't understand that problem.
Therefore the halting problem counter example input
is a yes/no question lacking a correct yes/no answer.
No, you are just showing you re too stupid to read the simple
explanatins of the problem.
Every explanation of the problem requires a result that
cannot be derived by applying finite string transformation
rules to actual finite string inputs.
LIE!!!
Whys isn't [DD] -> Halting a "Finite String Transformation"?
On 1/10/2026 8:03 PM, Richard Damon wrote:
On 1/10/26 8:05 PM, olcott wrote:
On 1/10/2026 6:35 PM, Richard Damon wrote:
On 1/10/26 6:19 PM, olcott wrote:
On 1/10/2026 2:23 AM, Mikko wrote:
On 09/01/2026 17:52, olcott wrote:
On 1/9/2026 3:59 AM, Mikko wrote:
On 08/01/2026 16:22, olcott wrote:
On 1/8/2026 4:22 AM, Mikko wrote:
On 07/01/2026 13:54, olcott wrote:
On 1/7/2026 5:49 AM, Mikko wrote:Depends on whether the word "truth" is interpeted in the standard >>>>>>>>>> sense or in Olcott's sense.
On 07/01/2026 06:44, olcott wrote:*if undecidability is correct then truth itself is broken* >>>>>>>>>>
All deciders essentially: Transform finite string
inputs by finite string transformation rules into
{Accept, Reject} values.
The counter-example input to requires more than
can be derived from finite string transformation
rules applied to this specific input thus the
Halting Problem requires too much.
In a sense the halting problem asks too much: the problem is >>>>>>>>>>>> proven to
be unsolvable. In another sense it asks too little: usually >>>>>>>>>>>> we want to
know whether a method halts on every input, not just one. >>>>>>>>>>>>
Although the halting problem is unsolvable, there are >>>>>>>>>>>> partial solutions
to the halting problem. In particular, every counter-example >>>>>>>>>>>> to the
full solution is correctly solved by some partial deciders. >>>>>>>>>>>
Undecidability is misconception. Self-contradictory
expressions are correctly rejected as semantically
incoherent thus form no undecidability or incompleteness.
The misconception is yours. No expression in the language of the >>>>>>>> first
order group theory is self-contradictory. But the first order goupr >>>>>>>> theory is incomplete: it is impossible to prove that AB = BA is >>>>>>>> true
for every A and every B but it is also impossible to prove that >>>>>>>> AB = BA
is false for some A and some B.
All deciders essentially: Transform finite string
inputs by finite string transformation rules into
{Accept, Reject} values.
When a required result cannot be derived by applying
finite string transformation rules to actual finite
string inputs, then the required result exceeds the
scope of computation and must be rejected as an
incorrect requirement.
No, that does not follow. If a required result cannot be derived by >>>>>> appying a finite string transformation then the it it is
uncomputable.
Of course, it one can prove that the required result is not
computable
then that helps to avoid wasting effort to try the impossible. The >>>>>> situation is worse if it is not known that the required result is not >>>>>> computable.
That something is not computable does not mean that there is anyting >>>>>> "incorrect" in the requirement. In order to claim that a requirement >>>>>> is incorrect one must at least prove that the requirement does not >>>>>> serve its intended purpose. Even then it is possible that the
requirement serves some other purpose. Even if a requirement serves >>>>>> no purpose that need not mean that it be "incorrect", only that it >>>>>> is useless.
*Computation and Undecidability*
Any result that cannot be derived as a pure function of
finite strings is outside the scope of computation. What
has been construed as decision problem undecidability
has always actually been requirements that are outside
of the scope of computation.
https://www.researchgate.net/
publication/399111881_Computation_and_Undecidability
So why isn't DD() -> Halts (since your HHH(DD) returns 0) not a pure
function of the input.
Now, if your DD doesn't include the code for HHH, then you show your
problem, your input isn't that of a program, and thus out of sco[e.
The Halting Problem only talks about the behavior of PROGRAMS, which
requires that the input specify ALL of the algorith/code used by it.
so your "C function" DD isn't a valid input without also specifying
the SPECIFIC HHH that it calls.
A shorter link that won't get unintentionally chopped off.
*Computation and Undecidability*
https://philpapers.org/go.pl?aid=OLCCAU
*ChatGPT explains how and why I am correct*
*Reinterpretation of undecidability*
The example of P and H demonstrates that what is
often called “undecidable” is better understood as
ill-posed with respect to computable semantics.
When the specification is constrained to properties
detectable via finite simulation and finite pattern
recognition, computation proceeds normally and
correctly. Undecidability only appears when the
specification overreaches that boundary.
Which just shows it doesn't know what "undecidability" is.
And neither do you, or how LLMs work.
Note, your "criteria" means you can't ask a question about computing
you don't know the answer to.
This shows how stupid you are.
It doesn't say anything like that.
You seem to have a reason comprehension problem.
Proof Theoretic Semantics perfectly agrees with me.
That you never heard of that is not a rebuttal.
On 1/10/2026 8:03 PM, Richard Damon wrote:
On 1/10/26 8:03 PM, olcott wrote:
On 1/10/2026 6:35 PM, Richard Damon wrote:
On 1/10/26 6:19 PM, olcott wrote:
On 1/10/2026 2:23 AM, Mikko wrote:
On 09/01/2026 17:52, olcott wrote:
On 1/9/2026 3:59 AM, Mikko wrote:
On 08/01/2026 16:22, olcott wrote:
On 1/8/2026 4:22 AM, Mikko wrote:
On 07/01/2026 13:54, olcott wrote:
On 1/7/2026 5:49 AM, Mikko wrote:Depends on whether the word "truth" is interpeted in the standard >>>>>>>>>> sense or in Olcott's sense.
On 07/01/2026 06:44, olcott wrote:*if undecidability is correct then truth itself is broken* >>>>>>>>>>
All deciders essentially: Transform finite string
inputs by finite string transformation rules into
{Accept, Reject} values.
The counter-example input to requires more than
can be derived from finite string transformation
rules applied to this specific input thus the
Halting Problem requires too much.
In a sense the halting problem asks too much: the problem is >>>>>>>>>>>> proven to
be unsolvable. In another sense it asks too little: usually >>>>>>>>>>>> we want to
know whether a method halts on every input, not just one. >>>>>>>>>>>>
Although the halting problem is unsolvable, there are >>>>>>>>>>>> partial solutions
to the halting problem. In particular, every counter-example >>>>>>>>>>>> to the
full solution is correctly solved by some partial deciders. >>>>>>>>>>>
Undecidability is misconception. Self-contradictory
expressions are correctly rejected as semantically
incoherent thus form no undecidability or incompleteness.
The misconception is yours. No expression in the language of the >>>>>>>> first
order group theory is self-contradictory. But the first order goupr >>>>>>>> theory is incomplete: it is impossible to prove that AB = BA is >>>>>>>> true
for every A and every B but it is also impossible to prove that >>>>>>>> AB = BA
is false for some A and some B.
All deciders essentially: Transform finite string
inputs by finite string transformation rules into
{Accept, Reject} values.
When a required result cannot be derived by applying
finite string transformation rules to actual finite
string inputs, then the required result exceeds the
scope of computation and must be rejected as an
incorrect requirement.
No, that does not follow. If a required result cannot be derived by >>>>>> appying a finite string transformation then the it it is
uncomputable.
Of course, it one can prove that the required result is not
computable
then that helps to avoid wasting effort to try the impossible. The >>>>>> situation is worse if it is not known that the required result is not >>>>>> computable.
That something is not computable does not mean that there is anyting >>>>>> "incorrect" in the requirement. In order to claim that a requirement >>>>>> is incorrect one must at least prove that the requirement does not >>>>>> serve its intended purpose. Even then it is possible that the
requirement serves some other purpose. Even if a requirement serves >>>>>> no purpose that need not mean that it be "incorrect", only that it >>>>>> is useless.
*Computation and Undecidability*
Any result that cannot be derived as a pure function of
finite strings is outside the scope of computation. What
has been construed as decision problem undecidability
has always actually been requirements that are outside
of the scope of computation.
https://www.researchgate.net/
publication/399111881_Computation_and_Undecidability
*Computation and Undecidability*
https://philpapers.org/go.pl?aid=OLCCAU
Which just shows you don't know what you are talking about.
You said:
Any result that cannot be derived as a pure function of finite strings
is outside the scope of computation. What has been construed as
decision problem undecidability has always actually been requirements
that are outside of the scope of computation.
Which is just a LIE, based on not knowing what you are talking about.
The "Scope of Computation", as in what scope of problems that
Compuation Theory looks at, are the mappings of one domain (often
limited to a countably infinite domain so it is representable as a
finte string) to another domain.
You merely are not bothering to pay close enough
attention to the exact meaning of my words.
The primary question of that domain, is which mapping can be computed
by a finite machine using a specific fully defined algorithm.
Yes you are correct about this, yet that is a mere
paraphrase of my own words.
What you can your "Scope of Computation" is the range of what is
computable.
Yes that is still correct.
In other words, the "Scope" of what we want to be able to do,
Not at all you are totally incorrect and the regulars
that know comp.theory will confirm this.
and thus the set of problems that ARE computable.
You don't seem to understand the differnce between the problem of
determining Computability and what is actually computable, just like
you don't understand the difference between Truth and Knowledge.
I proved that I do understand by creating my
own formal definition that is consistent with
standard definitions.
All deciders essentially: Transform finite string
inputs by finite string transformation rules into
{Accept, Reject} values.
So why isn't DD() -> Halts (since your HHH(DD) returns 0) not a pure
function of the input.
Now, if your DD doesn't include the code for HHH, then you show your
problem, your input isn't that of a program, and thus out of sco[e.
The Halting Problem only talks about the behavior of PROGRAMS, which
requires that the input specify ALL of the algorith/code used by it.
so your "C function" DD isn't a valid input without also specifying
the SPECIFIC HHH that it calls.
*ChatGPT explains how and why I am correct*
*Reinterpretation of undecidability*
The example of P and H demonstrates that what is
often called “undecidable” is better understood as
ill-posed with respect to computable semantics.
When the specification is constrained to properties
detectable via finite simulation and finite pattern
recognition, computation proceeds normally and
correctly. Undecidability only appears when the
specification overreaches that boundary.
But "Finite Simulation and finite pattern recognition" is NOT "Finiite
String Transformation".
So, you are just showing you don't understand what you are talking about.
You are just showing you don't understand what you are talking about:
That you don't even know what elements are in the finite string transformations prove this. *finite simulation* is the ultimate
measure of the behavior that an input finite string specifies.
On 1/10/2026 8:03 PM, Richard Damon wrote:
On 1/10/26 7:52 PM, olcott wrote:
On 1/10/2026 6:35 PM, Richard Damon wrote:
On 1/10/26 7:13 PM, olcott wrote:
On 1/10/2026 5:19 PM, Richard Damon wrote:
On 1/10/26 10:47 AM, olcott wrote:
On 1/10/2026 2:23 AM, Mikko wrote:
On 09/01/2026 17:52, olcott wrote:
On 1/9/2026 3:59 AM, Mikko wrote:
On 08/01/2026 16:22, olcott wrote:
On 1/8/2026 4:22 AM, Mikko wrote:The misconception is yours. No expression in the language of >>>>>>>>>> the first
On 07/01/2026 13:54, olcott wrote:
On 1/7/2026 5:49 AM, Mikko wrote:Depends on whether the word "truth" is interpeted in the >>>>>>>>>>>> standard
On 07/01/2026 06:44, olcott wrote:*if undecidability is correct then truth itself is broken* >>>>>>>>>>>>
All deciders essentially: Transform finite string >>>>>>>>>>>>>>> inputs by finite string transformation rules into >>>>>>>>>>>>>>> {Accept, Reject} values.
The counter-example input to requires more than
can be derived from finite string transformation >>>>>>>>>>>>>>> rules applied to this specific input thus the
Halting Problem requires too much.
In a sense the halting problem asks too much: the problem >>>>>>>>>>>>>> is proven to
be unsolvable. In another sense it asks too little: >>>>>>>>>>>>>> usually we want to
know whether a method halts on every input, not just one. >>>>>>>>>>>>>>
Although the halting problem is unsolvable, there are >>>>>>>>>>>>>> partial solutions
to the halting problem. In particular, every counter- >>>>>>>>>>>>>> example to the
full solution is correctly solved by some partial deciders. >>>>>>>>>>>>>
sense or in Olcott's sense.
Undecidability is misconception. Self-contradictory
expressions are correctly rejected as semantically
incoherent thus form no undecidability or incompleteness. >>>>>>>>>>
order group theory is self-contradictory. But the first order >>>>>>>>>> goupr
theory is incomplete: it is impossible to prove that AB = BA >>>>>>>>>> is true
for every A and every B but it is also impossible to prove >>>>>>>>>> that AB = BA
is false for some A and some B.
All deciders essentially: Transform finite string
inputs by finite string transformation rules into
{Accept, Reject} values.
When a required result cannot be derived by applying
finite string transformation rules to actual finite
string inputs, then the required result exceeds the
scope of computation and must be rejected as an
incorrect requirement.
No, that does not follow. If a required result cannot be derived by >>>>>>>> appying a finite string transformation then the it it is
uncomputable.
Right. Outside the scope of computation. Requiring anything
outside the scope of computation is an incorrect requirement.
Of course, it one can prove that the required result is not
computable
then that helps to avoid wasting effort to try the impossible. The >>>>>>>> situation is worse if it is not known that the required result >>>>>>>> is not
computable.
That something is not computable does not mean that there is
anyting
"incorrect" in the requirement.
Yes it certainly does. Requiring the impossible is always an error. >>>>>>> Requiring an answer to a yes/no question that has no correct yes/no >>>>>>> answer is an incorrect question that must be rejected.
But then, insisting that things are possilbe to ask the question
is an error, as you might not be able to know if it is possible
when you ask the question.
Thus, your logic only allows that asking of questions you already >>>>>> know that an answer exists.
In order to claim that a requirement
is incorrect one must at least prove that the requirement does not >>>>>>>> serve its intended purpose.
Requiring the impossible cannot possibly serve any purpose
except perhaps to exemplify one's own ignorance.
But asking if it is possible lets you know about the limits of
what you can do.
Remember, the halting problems as the question about IS IT
POSSIBLE, and that has an answer, it is not possible to to it.
Is it possible to correctly answer self-contradictory questions?
But the actual question isn't "self-contradictiory".
No not even when they are rearranged into a Halting Problem.
But the actual problem isn't the one you talk about, only your
subjective misquoting of it.
I proved the HP input is the same as the Liar Paradox back in 2004
No, that provees you don't know what the halting problem IS.,
function LoopIfYouSayItHalts (bool YouSayItHalts):
if YouSayItHalts () then
while true do {}
else
return false;
Does this program Halt?
(Your (YES or NO) answer is to be considered
translated to Boolean as the function's input
parameter)
Please ONLY PROVIDE CORRECT ANSWERS
https://groups.google.com/g/sci.logic/c/Hs78nMN6QZE/m/ID2rxwo__yQJ
When you yourself say YES you are wrong
When you yourself say NO you are wrong
But you are asking TWO questions, as the behavior of a program is a
funcgtion of its input.
Thus, you show you don't understand that problem.
Therefore the halting problem counter example input
is a yes/no question lacking a correct yes/no answer.
No, you are just showing you re too stupid to read the simple
explanatins of the problem.
Every explanation of the problem requires a result that
cannot be derived by applying finite string transformation
rules to actual finite string inputs.
LIE!!!
Whys isn't [DD] -> Halting a "Finite String Transformation"?
Finite String Transformations of
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
INPUT FINITE STRINGS
On 1/10/26 9:09 PM, olcott wrote:
On 1/10/2026 8:03 PM, Richard Damon wrote:
On 1/10/26 8:05 PM, olcott wrote:
On 1/10/2026 6:35 PM, Richard Damon wrote:
On 1/10/26 6:19 PM, olcott wrote:
On 1/10/2026 2:23 AM, Mikko wrote:
On 09/01/2026 17:52, olcott wrote:
On 1/9/2026 3:59 AM, Mikko wrote:
On 08/01/2026 16:22, olcott wrote:
On 1/8/2026 4:22 AM, Mikko wrote:
On 07/01/2026 13:54, olcott wrote:
On 1/7/2026 5:49 AM, Mikko wrote:Depends on whether the word "truth" is interpeted in the >>>>>>>>>>> standard
On 07/01/2026 06:44, olcott wrote:*if undecidability is correct then truth itself is broken* >>>>>>>>>>>
All deciders essentially: Transform finite string
inputs by finite string transformation rules into
{Accept, Reject} values.
The counter-example input to requires more than
can be derived from finite string transformation
rules applied to this specific input thus the
Halting Problem requires too much.
In a sense the halting problem asks too much: the problem >>>>>>>>>>>>> is proven to
be unsolvable. In another sense it asks too little: usually >>>>>>>>>>>>> we want to
know whether a method halts on every input, not just one. >>>>>>>>>>>>>
Although the halting problem is unsolvable, there are >>>>>>>>>>>>> partial solutions
to the halting problem. In particular, every counter- >>>>>>>>>>>>> example to the
full solution is correctly solved by some partial deciders. >>>>>>>>>>>>
sense or in Olcott's sense.
Undecidability is misconception. Self-contradictory
expressions are correctly rejected as semantically
incoherent thus form no undecidability or incompleteness.
The misconception is yours. No expression in the language of >>>>>>>>> the first
order group theory is self-contradictory. But the first order >>>>>>>>> goupr
theory is incomplete: it is impossible to prove that AB = BA is >>>>>>>>> true
for every A and every B but it is also impossible to prove that >>>>>>>>> AB = BA
is false for some A and some B.
All deciders essentially: Transform finite string
inputs by finite string transformation rules into
{Accept, Reject} values.
When a required result cannot be derived by applying
finite string transformation rules to actual finite
string inputs, then the required result exceeds the
scope of computation and must be rejected as an
incorrect requirement.
No, that does not follow. If a required result cannot be derived by >>>>>>> appying a finite string transformation then the it it is
uncomputable.
Of course, it one can prove that the required result is not
computable
then that helps to avoid wasting effort to try the impossible. The >>>>>>> situation is worse if it is not known that the required result is >>>>>>> not
computable.
That something is not computable does not mean that there is anyting >>>>>>> "incorrect" in the requirement. In order to claim that a requirement >>>>>>> is incorrect one must at least prove that the requirement does not >>>>>>> serve its intended purpose. Even then it is possible that the
requirement serves some other purpose. Even if a requirement serves >>>>>>> no purpose that need not mean that it be "incorrect", only that it >>>>>>> is useless.
*Computation and Undecidability*
Any result that cannot be derived as a pure function of
finite strings is outside the scope of computation. What
has been construed as decision problem undecidability
has always actually been requirements that are outside
of the scope of computation.
https://www.researchgate.net/
publication/399111881_Computation_and_Undecidability
So why isn't DD() -> Halts (since your HHH(DD) returns 0) not a
pure function of the input.
Now, if your DD doesn't include the code for HHH, then you show
your problem, your input isn't that of a program, and thus out of
sco[e.
The Halting Problem only talks about the behavior of PROGRAMS,
which requires that the input specify ALL of the algorith/code used >>>>> by it. so your "C function" DD isn't a valid input without also
specifying the SPECIFIC HHH that it calls.
A shorter link that won't get unintentionally chopped off.
*Computation and Undecidability*
https://philpapers.org/go.pl?aid=OLCCAU
*ChatGPT explains how and why I am correct*
*Reinterpretation of undecidability*
The example of P and H demonstrates that what is
often called “undecidable” is better understood as
ill-posed with respect to computable semantics.
When the specification is constrained to properties
detectable via finite simulation and finite pattern
recognition, computation proceeds normally and
correctly. Undecidability only appears when the
specification overreaches that boundary.
Which just shows it doesn't know what "undecidability" is.
And neither do you, or how LLMs work.
Note, your "criteria" means you can't ask a question about computing
you don't know the answer to.
This shows how stupid you are.
It doesn't say anything like that.
You seem to have a reason comprehension problem.
Proof Theoretic Semantics perfectly agrees with me.
That you never heard of that is not a rebuttal.
No, you are just showing your stupidity.
How can you determine if a given problem is in the scope of Computation Theory? (If you don't already have the answer).
Is the problem of, "given an even Natural Number, return two prime
numbers that sum to it" in the scope of computation theory by your definition?
We don't know if this is POSSIBLE, but seems like it likely is.
How do you handle questions and deciding if they are "in scope", if you haven't done any analysis yet of the problem, and how can you do
analysis of a question you don't know if it is even valid in the field
to see if it is valid.
On 1/10/26 9:09 PM, olcott wrote:
On 1/10/2026 8:03 PM, Richard Damon wrote:
On 1/10/26 8:05 PM, olcott wrote:
On 1/10/2026 6:35 PM, Richard Damon wrote:
On 1/10/26 6:19 PM, olcott wrote:
On 1/10/2026 2:23 AM, Mikko wrote:
On 09/01/2026 17:52, olcott wrote:
On 1/9/2026 3:59 AM, Mikko wrote:
On 08/01/2026 16:22, olcott wrote:
On 1/8/2026 4:22 AM, Mikko wrote:
On 07/01/2026 13:54, olcott wrote:
On 1/7/2026 5:49 AM, Mikko wrote:Depends on whether the word "truth" is interpeted in the >>>>>>>>>>> standard
On 07/01/2026 06:44, olcott wrote:*if undecidability is correct then truth itself is broken* >>>>>>>>>>>
All deciders essentially: Transform finite string
inputs by finite string transformation rules into
{Accept, Reject} values.
The counter-example input to requires more than
can be derived from finite string transformation
rules applied to this specific input thus the
Halting Problem requires too much.
In a sense the halting problem asks too much: the problem >>>>>>>>>>>>> is proven to
be unsolvable. In another sense it asks too little: usually >>>>>>>>>>>>> we want to
know whether a method halts on every input, not just one. >>>>>>>>>>>>>
Although the halting problem is unsolvable, there are >>>>>>>>>>>>> partial solutions
to the halting problem. In particular, every counter- >>>>>>>>>>>>> example to the
full solution is correctly solved by some partial deciders. >>>>>>>>>>>>
sense or in Olcott's sense.
Undecidability is misconception. Self-contradictory
expressions are correctly rejected as semantically
incoherent thus form no undecidability or incompleteness.
The misconception is yours. No expression in the language of >>>>>>>>> the first
order group theory is self-contradictory. But the first order >>>>>>>>> goupr
theory is incomplete: it is impossible to prove that AB = BA is >>>>>>>>> true
for every A and every B but it is also impossible to prove that >>>>>>>>> AB = BA
is false for some A and some B.
All deciders essentially: Transform finite string
inputs by finite string transformation rules into
{Accept, Reject} values.
When a required result cannot be derived by applying
finite string transformation rules to actual finite
string inputs, then the required result exceeds the
scope of computation and must be rejected as an
incorrect requirement.
No, that does not follow. If a required result cannot be derived by >>>>>>> appying a finite string transformation then the it it is
uncomputable.
Of course, it one can prove that the required result is not
computable
then that helps to avoid wasting effort to try the impossible. The >>>>>>> situation is worse if it is not known that the required result is >>>>>>> not
computable.
That something is not computable does not mean that there is anyting >>>>>>> "incorrect" in the requirement. In order to claim that a requirement >>>>>>> is incorrect one must at least prove that the requirement does not >>>>>>> serve its intended purpose. Even then it is possible that the
requirement serves some other purpose. Even if a requirement serves >>>>>>> no purpose that need not mean that it be "incorrect", only that it >>>>>>> is useless.
*Computation and Undecidability*
Any result that cannot be derived as a pure function of
finite strings is outside the scope of computation. What
has been construed as decision problem undecidability
has always actually been requirements that are outside
of the scope of computation.
https://www.researchgate.net/
publication/399111881_Computation_and_Undecidability
So why isn't DD() -> Halts (since your HHH(DD) returns 0) not a
pure function of the input.
Now, if your DD doesn't include the code for HHH, then you show
your problem, your input isn't that of a program, and thus out of
sco[e.
The Halting Problem only talks about the behavior of PROGRAMS,
which requires that the input specify ALL of the algorith/code used >>>>> by it. so your "C function" DD isn't a valid input without also
specifying the SPECIFIC HHH that it calls.
A shorter link that won't get unintentionally chopped off.
*Computation and Undecidability*
https://philpapers.org/go.pl?aid=OLCCAU
*ChatGPT explains how and why I am correct*
*Reinterpretation of undecidability*
The example of P and H demonstrates that what is
often called “undecidable” is better understood as
ill-posed with respect to computable semantics.
When the specification is constrained to properties
detectable via finite simulation and finite pattern
recognition, computation proceeds normally and
correctly. Undecidability only appears when the
specification overreaches that boundary.
Which just shows it doesn't know what "undecidability" is.
And neither do you, or how LLMs work.
Note, your "criteria" means you can't ask a question about computing
you don't know the answer to.
This shows how stupid you are.
It doesn't say anything like that.
You seem to have a reason comprehension problem.
Proof Theoretic Semantics perfectly agrees with me.
That you never heard of that is not a rebuttal.
No, you are just showing your stupidity.
How can you determine if a given problem is in the scope of Computation Theory? (If you don't already have the answer).
Is the problem of, "given an even Natural Number, return two prime
numbers that sum to it" in the scope of computation theory by your definition?
We don't know if this is POSSIBLE, but seems like it likely is.
How do you handle questions and deciding if they are "in scope", if you haven't done any analysis yet of the problem, and how can you do
analysis of a question you don't know if it is even valid in the field
to see if it is valid.
On 1/10/26 9:20 PM, olcott wrote:
On 1/10/2026 8:03 PM, Richard Damon wrote:
On 1/10/26 8:03 PM, olcott wrote:
On 1/10/2026 6:35 PM, Richard Damon wrote:
On 1/10/26 6:19 PM, olcott wrote:
On 1/10/2026 2:23 AM, Mikko wrote:
On 09/01/2026 17:52, olcott wrote:
On 1/9/2026 3:59 AM, Mikko wrote:
On 08/01/2026 16:22, olcott wrote:
On 1/8/2026 4:22 AM, Mikko wrote:
On 07/01/2026 13:54, olcott wrote:
On 1/7/2026 5:49 AM, Mikko wrote:Depends on whether the word "truth" is interpeted in the >>>>>>>>>>> standard
On 07/01/2026 06:44, olcott wrote:*if undecidability is correct then truth itself is broken* >>>>>>>>>>>
All deciders essentially: Transform finite string
inputs by finite string transformation rules into
{Accept, Reject} values.
The counter-example input to requires more than
can be derived from finite string transformation
rules applied to this specific input thus the
Halting Problem requires too much.
In a sense the halting problem asks too much: the problem >>>>>>>>>>>>> is proven to
be unsolvable. In another sense it asks too little: usually >>>>>>>>>>>>> we want to
know whether a method halts on every input, not just one. >>>>>>>>>>>>>
Although the halting problem is unsolvable, there are >>>>>>>>>>>>> partial solutions
to the halting problem. In particular, every counter- >>>>>>>>>>>>> example to the
full solution is correctly solved by some partial deciders. >>>>>>>>>>>>
sense or in Olcott's sense.
Undecidability is misconception. Self-contradictory
expressions are correctly rejected as semantically
incoherent thus form no undecidability or incompleteness.
The misconception is yours. No expression in the language of >>>>>>>>> the first
order group theory is self-contradictory. But the first order >>>>>>>>> goupr
theory is incomplete: it is impossible to prove that AB = BA is >>>>>>>>> true
for every A and every B but it is also impossible to prove that >>>>>>>>> AB = BA
is false for some A and some B.
All deciders essentially: Transform finite string
inputs by finite string transformation rules into
{Accept, Reject} values.
When a required result cannot be derived by applying
finite string transformation rules to actual finite
string inputs, then the required result exceeds the
scope of computation and must be rejected as an
incorrect requirement.
No, that does not follow. If a required result cannot be derived by >>>>>>> appying a finite string transformation then the it it is
uncomputable.
Of course, it one can prove that the required result is not
computable
then that helps to avoid wasting effort to try the impossible. The >>>>>>> situation is worse if it is not known that the required result is >>>>>>> not
computable.
That something is not computable does not mean that there is anyting >>>>>>> "incorrect" in the requirement. In order to claim that a requirement >>>>>>> is incorrect one must at least prove that the requirement does not >>>>>>> serve its intended purpose. Even then it is possible that the
requirement serves some other purpose. Even if a requirement serves >>>>>>> no purpose that need not mean that it be "incorrect", only that it >>>>>>> is useless.
*Computation and Undecidability*
Any result that cannot be derived as a pure function of
finite strings is outside the scope of computation. What
has been construed as decision problem undecidability
has always actually been requirements that are outside
of the scope of computation.
https://www.researchgate.net/
publication/399111881_Computation_and_Undecidability
*Computation and Undecidability*
https://philpapers.org/go.pl?aid=OLCCAU
Which just shows you don't know what you are talking about.
You said:
Any result that cannot be derived as a pure function of finite
strings is outside the scope of computation. What has been construed
as decision problem undecidability has always actually been
requirements that are outside of the scope of computation.
Which is just a LIE, based on not knowing what you are talking about.
The "Scope of Computation", as in what scope of problems that
Compuation Theory looks at, are the mappings of one domain (often
limited to a countably infinite domain so it is representable as a
finte string) to another domain.
You merely are not bothering to pay close enough
attention to the exact meaning of my words.
No, the problem is YOU don't know the actual meaning of your words.
The primary question of that domain, is which mapping can be computed
by a finite machine using a specific fully defined algorithm.
Yes you are correct about this, yet that is a mere
paraphrase of my own words.
Which means YOUR WORDS are the incorrect paraphrase.
What you can your "Scope of Computation" is the range of what is
computable.
Yes that is still correct.
Nops, which just shows you don't know the actual meaning of your words.
In other words, the "Scope" of what we want to be able to do,
Not at all you are totally incorrect and the regulars
that know comp.theory will confirm this.
We will see.
and thus the set of problems that ARE computable.
You don't seem to understand the differnce between the problem of
determining Computability and what is actually computable, just like
you don't understand the difference between Truth and Knowledge.
I proved that I do understand by creating my
own formal definition that is consistent with
standard definitions.
Nope.
That you think it is, just shows youy are just a pathological liar.
All deciders essentially: Transform finite string
inputs by finite string transformation rules into
{Accept, Reject} values.
Right, which is irrelevant for the scope of the field, it shows the capabilities of the machines, which the field is trying to determine.
On 1/10/26 9:22 PM, olcott wrote:
INPUT FINITE STRINGS
And the code of DD isn't a Finite String given as the input?
It seems you don't know what the words mean.
On 1/10/2026 8:33 PM, Richard Damon wrote:
On 1/10/26 9:09 PM, olcott wrote:
On 1/10/2026 8:03 PM, Richard Damon wrote:
On 1/10/26 8:05 PM, olcott wrote:
On 1/10/2026 6:35 PM, Richard Damon wrote:
On 1/10/26 6:19 PM, olcott wrote:
On 1/10/2026 2:23 AM, Mikko wrote:
On 09/01/2026 17:52, olcott wrote:
On 1/9/2026 3:59 AM, Mikko wrote:
On 08/01/2026 16:22, olcott wrote:
On 1/8/2026 4:22 AM, Mikko wrote:The misconception is yours. No expression in the language of >>>>>>>>>> the first
On 07/01/2026 13:54, olcott wrote:
On 1/7/2026 5:49 AM, Mikko wrote:Depends on whether the word "truth" is interpeted in the >>>>>>>>>>>> standard
On 07/01/2026 06:44, olcott wrote:*if undecidability is correct then truth itself is broken* >>>>>>>>>>>>
All deciders essentially: Transform finite string >>>>>>>>>>>>>>> inputs by finite string transformation rules into >>>>>>>>>>>>>>> {Accept, Reject} values.
The counter-example input to requires more than
can be derived from finite string transformation >>>>>>>>>>>>>>> rules applied to this specific input thus the
Halting Problem requires too much.
In a sense the halting problem asks too much: the problem >>>>>>>>>>>>>> is proven to
be unsolvable. In another sense it asks too little: >>>>>>>>>>>>>> usually we want to
know whether a method halts on every input, not just one. >>>>>>>>>>>>>>
Although the halting problem is unsolvable, there are >>>>>>>>>>>>>> partial solutions
to the halting problem. In particular, every counter- >>>>>>>>>>>>>> example to the
full solution is correctly solved by some partial deciders. >>>>>>>>>>>>>
sense or in Olcott's sense.
Undecidability is misconception. Self-contradictory
expressions are correctly rejected as semantically
incoherent thus form no undecidability or incompleteness. >>>>>>>>>>
order group theory is self-contradictory. But the first order >>>>>>>>>> goupr
theory is incomplete: it is impossible to prove that AB = BA >>>>>>>>>> is true
for every A and every B but it is also impossible to prove >>>>>>>>>> that AB = BA
is false for some A and some B.
All deciders essentially: Transform finite string
inputs by finite string transformation rules into
{Accept, Reject} values.
When a required result cannot be derived by applying
finite string transformation rules to actual finite
string inputs, then the required result exceeds the
scope of computation and must be rejected as an
incorrect requirement.
No, that does not follow. If a required result cannot be derived by >>>>>>>> appying a finite string transformation then the it it is
uncomputable.
Of course, it one can prove that the required result is not
computable
then that helps to avoid wasting effort to try the impossible. The >>>>>>>> situation is worse if it is not known that the required result >>>>>>>> is not
computable.
That something is not computable does not mean that there is
anyting
"incorrect" in the requirement. In order to claim that a
requirement
is incorrect one must at least prove that the requirement does not >>>>>>>> serve its intended purpose. Even then it is possible that the
requirement serves some other purpose. Even if a requirement serves >>>>>>>> no purpose that need not mean that it be "incorrect", only that it >>>>>>>> is useless.
*Computation and Undecidability*
Any result that cannot be derived as a pure function of
finite strings is outside the scope of computation. What
has been construed as decision problem undecidability
has always actually been requirements that are outside
of the scope of computation.
https://www.researchgate.net/
publication/399111881_Computation_and_Undecidability
So why isn't DD() -> Halts (since your HHH(DD) returns 0) not a
pure function of the input.
Now, if your DD doesn't include the code for HHH, then you show
your problem, your input isn't that of a program, and thus out of >>>>>> sco[e.
The Halting Problem only talks about the behavior of PROGRAMS,
which requires that the input specify ALL of the algorith/code
used by it. so your "C function" DD isn't a valid input without
also specifying the SPECIFIC HHH that it calls.
A shorter link that won't get unintentionally chopped off.
*Computation and Undecidability*
https://philpapers.org/go.pl?aid=OLCCAU
*ChatGPT explains how and why I am correct*
*Reinterpretation of undecidability*
The example of P and H demonstrates that what is
often called “undecidable” is better understood as
ill-posed with respect to computable semantics.
When the specification is constrained to properties
detectable via finite simulation and finite pattern
recognition, computation proceeds normally and
correctly. Undecidability only appears when the
specification overreaches that boundary.
Which just shows it doesn't know what "undecidability" is.
And neither do you, or how LLMs work.
Note, your "criteria" means you can't ask a question about computing
you don't know the answer to.
This shows how stupid you are.
It doesn't say anything like that.
You seem to have a reason comprehension problem.
Proof Theoretic Semantics perfectly agrees with me.
That you never heard of that is not a rebuttal.
No, you are just showing your stupidity.
How can you determine if a given problem is in the scope of
Computation Theory? (If you don't already have the answer).
Its like the whole world has been a freaking moron
for thousands of years. The Liar Paradox has lots
of opinions yet not one accepted formal resolution.
This is f-cking nuts !!!
Is the problem of, "given an even Natural Number, return two prime
numbers that sum to it" in the scope of computation theory by your
definition?
We don't know if this is POSSIBLE, but seems like it likely is.
How do you handle questions and deciding if they are "in scope", if
you haven't done any analysis yet of the problem, and how can you do
analysis of a question you don't know if it is even valid in the field
to see if it is valid.
On 1/10/2026 8:33 PM, Richard Damon wrote:
On 1/10/26 9:09 PM, olcott wrote:
On 1/10/2026 8:03 PM, Richard Damon wrote:
On 1/10/26 8:05 PM, olcott wrote:
On 1/10/2026 6:35 PM, Richard Damon wrote:
On 1/10/26 6:19 PM, olcott wrote:
On 1/10/2026 2:23 AM, Mikko wrote:
On 09/01/2026 17:52, olcott wrote:
On 1/9/2026 3:59 AM, Mikko wrote:
On 08/01/2026 16:22, olcott wrote:
On 1/8/2026 4:22 AM, Mikko wrote:The misconception is yours. No expression in the language of >>>>>>>>>> the first
On 07/01/2026 13:54, olcott wrote:
On 1/7/2026 5:49 AM, Mikko wrote:Depends on whether the word "truth" is interpeted in the >>>>>>>>>>>> standard
On 07/01/2026 06:44, olcott wrote:*if undecidability is correct then truth itself is broken* >>>>>>>>>>>>
All deciders essentially: Transform finite string >>>>>>>>>>>>>>> inputs by finite string transformation rules into >>>>>>>>>>>>>>> {Accept, Reject} values.
The counter-example input to requires more than
can be derived from finite string transformation >>>>>>>>>>>>>>> rules applied to this specific input thus the
Halting Problem requires too much.
In a sense the halting problem asks too much: the problem >>>>>>>>>>>>>> is proven to
be unsolvable. In another sense it asks too little: >>>>>>>>>>>>>> usually we want to
know whether a method halts on every input, not just one. >>>>>>>>>>>>>>
Although the halting problem is unsolvable, there are >>>>>>>>>>>>>> partial solutions
to the halting problem. In particular, every counter- >>>>>>>>>>>>>> example to the
full solution is correctly solved by some partial deciders. >>>>>>>>>>>>>
sense or in Olcott's sense.
Undecidability is misconception. Self-contradictory
expressions are correctly rejected as semantically
incoherent thus form no undecidability or incompleteness. >>>>>>>>>>
order group theory is self-contradictory. But the first order >>>>>>>>>> goupr
theory is incomplete: it is impossible to prove that AB = BA >>>>>>>>>> is true
for every A and every B but it is also impossible to prove >>>>>>>>>> that AB = BA
is false for some A and some B.
All deciders essentially: Transform finite string
inputs by finite string transformation rules into
{Accept, Reject} values.
When a required result cannot be derived by applying
finite string transformation rules to actual finite
string inputs, then the required result exceeds the
scope of computation and must be rejected as an
incorrect requirement.
No, that does not follow. If a required result cannot be derived by >>>>>>>> appying a finite string transformation then the it it is
uncomputable.
Of course, it one can prove that the required result is not
computable
then that helps to avoid wasting effort to try the impossible. The >>>>>>>> situation is worse if it is not known that the required result >>>>>>>> is not
computable.
That something is not computable does not mean that there is
anyting
"incorrect" in the requirement. In order to claim that a
requirement
is incorrect one must at least prove that the requirement does not >>>>>>>> serve its intended purpose. Even then it is possible that the
requirement serves some other purpose. Even if a requirement serves >>>>>>>> no purpose that need not mean that it be "incorrect", only that it >>>>>>>> is useless.
*Computation and Undecidability*
Any result that cannot be derived as a pure function of
finite strings is outside the scope of computation. What
has been construed as decision problem undecidability
has always actually been requirements that are outside
of the scope of computation.
https://www.researchgate.net/
publication/399111881_Computation_and_Undecidability
So why isn't DD() -> Halts (since your HHH(DD) returns 0) not a
pure function of the input.
Now, if your DD doesn't include the code for HHH, then you show
your problem, your input isn't that of a program, and thus out of >>>>>> sco[e.
The Halting Problem only talks about the behavior of PROGRAMS,
which requires that the input specify ALL of the algorith/code
used by it. so your "C function" DD isn't a valid input without
also specifying the SPECIFIC HHH that it calls.
A shorter link that won't get unintentionally chopped off.
*Computation and Undecidability*
https://philpapers.org/go.pl?aid=OLCCAU
*ChatGPT explains how and why I am correct*
*Reinterpretation of undecidability*
The example of P and H demonstrates that what is
often called “undecidable” is better understood as
ill-posed with respect to computable semantics.
When the specification is constrained to properties
detectable via finite simulation and finite pattern
recognition, computation proceeds normally and
correctly. Undecidability only appears when the
specification overreaches that boundary.
Which just shows it doesn't know what "undecidability" is.
And neither do you, or how LLMs work.
Note, your "criteria" means you can't ask a question about computing
you don't know the answer to.
This shows how stupid you are.
It doesn't say anything like that.
You seem to have a reason comprehension problem.
Proof Theoretic Semantics perfectly agrees with me.
That you never heard of that is not a rebuttal.
No, you are just showing your stupidity.
Its like the whole world has been a freaking moron
for thousands of years. The Liar Paradox has lots
of opinions yet not one accepted formal resolution.
This is f-cking nuts !!!
How can you determine if a given problem is in the scope of
Computation Theory? (If you don't already have the answer).
Is the problem of, "given an even Natural Number, return two prime
numbers that sum to it" in the scope of computation theory by your
definition?
We don't know if this is POSSIBLE, but seems like it likely is.
How do you handle questions and deciding if they are "in scope", if
you haven't done any analysis yet of the problem, and how can you do
analysis of a question you don't know if it is even valid in the field
to see if it is valid.
On 1/10/2026 8:33 PM, Richard Damon wrote:
On 1/10/26 9:20 PM, olcott wrote:
On 1/10/2026 8:03 PM, Richard Damon wrote:
On 1/10/26 8:03 PM, olcott wrote:
On 1/10/2026 6:35 PM, Richard Damon wrote:
On 1/10/26 6:19 PM, olcott wrote:
On 1/10/2026 2:23 AM, Mikko wrote:
On 09/01/2026 17:52, olcott wrote:
On 1/9/2026 3:59 AM, Mikko wrote:
On 08/01/2026 16:22, olcott wrote:
On 1/8/2026 4:22 AM, Mikko wrote:The misconception is yours. No expression in the language of >>>>>>>>>> the first
On 07/01/2026 13:54, olcott wrote:
On 1/7/2026 5:49 AM, Mikko wrote:Depends on whether the word "truth" is interpeted in the >>>>>>>>>>>> standard
On 07/01/2026 06:44, olcott wrote:*if undecidability is correct then truth itself is broken* >>>>>>>>>>>>
All deciders essentially: Transform finite string >>>>>>>>>>>>>>> inputs by finite string transformation rules into >>>>>>>>>>>>>>> {Accept, Reject} values.
The counter-example input to requires more than
can be derived from finite string transformation >>>>>>>>>>>>>>> rules applied to this specific input thus the
Halting Problem requires too much.
In a sense the halting problem asks too much: the problem >>>>>>>>>>>>>> is proven to
be unsolvable. In another sense it asks too little: >>>>>>>>>>>>>> usually we want to
know whether a method halts on every input, not just one. >>>>>>>>>>>>>>
Although the halting problem is unsolvable, there are >>>>>>>>>>>>>> partial solutions
to the halting problem. In particular, every counter- >>>>>>>>>>>>>> example to the
full solution is correctly solved by some partial deciders. >>>>>>>>>>>>>
sense or in Olcott's sense.
Undecidability is misconception. Self-contradictory
expressions are correctly rejected as semantically
incoherent thus form no undecidability or incompleteness. >>>>>>>>>>
order group theory is self-contradictory. But the first order >>>>>>>>>> goupr
theory is incomplete: it is impossible to prove that AB = BA >>>>>>>>>> is true
for every A and every B but it is also impossible to prove >>>>>>>>>> that AB = BA
is false for some A and some B.
All deciders essentially: Transform finite string
inputs by finite string transformation rules into
{Accept, Reject} values.
When a required result cannot be derived by applying
finite string transformation rules to actual finite
string inputs, then the required result exceeds the
scope of computation and must be rejected as an
incorrect requirement.
No, that does not follow. If a required result cannot be derived by >>>>>>>> appying a finite string transformation then the it it is
uncomputable.
Of course, it one can prove that the required result is not
computable
then that helps to avoid wasting effort to try the impossible. The >>>>>>>> situation is worse if it is not known that the required result >>>>>>>> is not
computable.
That something is not computable does not mean that there is
anyting
"incorrect" in the requirement. In order to claim that a
requirement
is incorrect one must at least prove that the requirement does not >>>>>>>> serve its intended purpose. Even then it is possible that the
requirement serves some other purpose. Even if a requirement serves >>>>>>>> no purpose that need not mean that it be "incorrect", only that it >>>>>>>> is useless.
*Computation and Undecidability*
Any result that cannot be derived as a pure function of
finite strings is outside the scope of computation. What
has been construed as decision problem undecidability
has always actually been requirements that are outside
of the scope of computation.
https://www.researchgate.net/
publication/399111881_Computation_and_Undecidability
*Computation and Undecidability*
https://philpapers.org/go.pl?aid=OLCCAU
Which just shows you don't know what you are talking about.
You said:
Any result that cannot be derived as a pure function of finite
strings is outside the scope of computation. What has been construed
as decision problem undecidability has always actually been
requirements that are outside of the scope of computation.
Which is just a LIE, based on not knowing what you are talking about.
The "Scope of Computation", as in what scope of problems that
Compuation Theory looks at, are the mappings of one domain (often
limited to a countably infinite domain so it is representable as a
finte string) to another domain.
You merely are not bothering to pay close enough
attention to the exact meaning of my words.
No, the problem is YOU don't know the actual meaning of your words.
The primary question of that domain, is which mapping can be
computed by a finite machine using a specific fully defined algorithm. >>>>
Yes you are correct about this, yet that is a mere
paraphrase of my own words.
Which means YOUR WORDS are the incorrect paraphrase.
What you can your "Scope of Computation" is the range of what is
computable.
Yes that is still correct.
Nops, which just shows you don't know the actual meaning of your words.
In other words, the "Scope" of what we want to be able to do,
Not at all you are totally incorrect and the regulars
that know comp.theory will confirm this.
We will see.
and thus the set of problems that ARE computable.
You don't seem to understand the differnce between the problem of
determining Computability and what is actually computable, just like
you don't understand the difference between Truth and Knowledge.
I proved that I do understand by creating my
own formal definition that is consistent with
standard definitions.
Nope.
That you think it is, just shows youy are just a pathological liar.
All deciders essentially: Transform finite string
inputs by finite string transformation rules into
{Accept, Reject} values.
Right, which is irrelevant for the scope of the field, it shows the
capabilities of the machines, which the field is trying to determine.
IT IS THE SCOPE OF THE FIELD
On 1/10/2026 8:34 PM, Richard Damon wrote:
On 1/10/26 9:22 PM, olcott wrote:
*Computation and Undecidability*
https://philpapers.org/go.pl?aid=OLCCAU
*ChatGPT explains how and why I am correct*
*Reinterpretation of undecidability*
The example of P and H demonstrates that what is
often called “undecidable” is better understood as
ill-posed with respect to computable semantics.
When the specification is constrained to properties
detectable via finite simulation and finite pattern
recognition, computation proceeds normally and
correctly. Undecidability only appears when the
specification overreaches that boundary.
INPUT FINITE STRINGS
And the code of DD isn't a Finite String given as the input?
It seems you don't know what the words mean.
The paper that I linked uses H(P) not HHH(DD).
To see that it totally proves my point
you have to actually look at it.
On 1/10/26 10:16 PM, olcott wrote:
On 1/10/2026 8:33 PM, Richard Damon wrote:
On 1/10/26 9:09 PM, olcott wrote:
On 1/10/2026 8:03 PM, Richard Damon wrote:
On 1/10/26 8:05 PM, olcott wrote:
On 1/10/2026 6:35 PM, Richard Damon wrote:
On 1/10/26 6:19 PM, olcott wrote:
On 1/10/2026 2:23 AM, Mikko wrote:
On 09/01/2026 17:52, olcott wrote:
On 1/9/2026 3:59 AM, Mikko wrote:
On 08/01/2026 16:22, olcott wrote:
On 1/8/2026 4:22 AM, Mikko wrote:The misconception is yours. No expression in the language of >>>>>>>>>>> the first
On 07/01/2026 13:54, olcott wrote:
On 1/7/2026 5:49 AM, Mikko wrote:Depends on whether the word "truth" is interpeted in the >>>>>>>>>>>>> standard
On 07/01/2026 06:44, olcott wrote:*if undecidability is correct then truth itself is broken* >>>>>>>>>>>>>
All deciders essentially: Transform finite string >>>>>>>>>>>>>>>> inputs by finite string transformation rules into >>>>>>>>>>>>>>>> {Accept, Reject} values.
The counter-example input to requires more than >>>>>>>>>>>>>>>> can be derived from finite string transformation >>>>>>>>>>>>>>>> rules applied to this specific input thus the
Halting Problem requires too much.
In a sense the halting problem asks too much: the problem >>>>>>>>>>>>>>> is proven to
be unsolvable. In another sense it asks too little: >>>>>>>>>>>>>>> usually we want to
know whether a method halts on every input, not just one. >>>>>>>>>>>>>>>
Although the halting problem is unsolvable, there are >>>>>>>>>>>>>>> partial solutions
to the halting problem. In particular, every counter- >>>>>>>>>>>>>>> example to the
full solution is correctly solved by some partial deciders. >>>>>>>>>>>>>>
sense or in Olcott's sense.
Undecidability is misconception. Self-contradictory
expressions are correctly rejected as semantically
incoherent thus form no undecidability or incompleteness. >>>>>>>>>>>
order group theory is self-contradictory. But the first order >>>>>>>>>>> goupr
theory is incomplete: it is impossible to prove that AB = BA >>>>>>>>>>> is true
for every A and every B but it is also impossible to prove >>>>>>>>>>> that AB = BA
is false for some A and some B.
All deciders essentially: Transform finite string
inputs by finite string transformation rules into
{Accept, Reject} values.
When a required result cannot be derived by applying
finite string transformation rules to actual finite
string inputs, then the required result exceeds the
scope of computation and must be rejected as an
incorrect requirement.
No, that does not follow. If a required result cannot be
derived by
appying a finite string transformation then the it it is
uncomputable.
Of course, it one can prove that the required result is not >>>>>>>>> computable
then that helps to avoid wasting effort to try the impossible. The >>>>>>>>> situation is worse if it is not known that the required result >>>>>>>>> is not
computable.
That something is not computable does not mean that there is >>>>>>>>> anyting
"incorrect" in the requirement. In order to claim that a
requirement
is incorrect one must at least prove that the requirement does not >>>>>>>>> serve its intended purpose. Even then it is possible that the >>>>>>>>> requirement serves some other purpose. Even if a requirement >>>>>>>>> serves
no purpose that need not mean that it be "incorrect", only that it >>>>>>>>> is useless.
*Computation and Undecidability*
Any result that cannot be derived as a pure function of
finite strings is outside the scope of computation. What
has been construed as decision problem undecidability
has always actually been requirements that are outside
of the scope of computation.
https://www.researchgate.net/
publication/399111881_Computation_and_Undecidability
So why isn't DD() -> Halts (since your HHH(DD) returns 0) not a >>>>>>> pure function of the input.
Now, if your DD doesn't include the code for HHH, then you show >>>>>>> your problem, your input isn't that of a program, and thus out of >>>>>>> sco[e.
The Halting Problem only talks about the behavior of PROGRAMS,
which requires that the input specify ALL of the algorith/code
used by it. so your "C function" DD isn't a valid input without >>>>>>> also specifying the SPECIFIC HHH that it calls.
A shorter link that won't get unintentionally chopped off.
*Computation and Undecidability*
https://philpapers.org/go.pl?aid=OLCCAU
*ChatGPT explains how and why I am correct*
*Reinterpretation of undecidability*
The example of P and H demonstrates that what is
often called “undecidable” is better understood as
ill-posed with respect to computable semantics.
When the specification is constrained to properties
detectable via finite simulation and finite pattern
recognition, computation proceeds normally and
correctly. Undecidability only appears when the
specification overreaches that boundary.
Which just shows it doesn't know what "undecidability" is.
And neither do you, or how LLMs work.
Note, your "criteria" means you can't ask a question about
computing you don't know the answer to.
This shows how stupid you are.
It doesn't say anything like that.
You seem to have a reason comprehension problem.
Proof Theoretic Semantics perfectly agrees with me.
That you never heard of that is not a rebuttal.
No, you are just showing your stupidity.
How can you determine if a given problem is in the scope of
Computation Theory? (If you don't already have the answer).
Its like the whole world has been a freaking moron
for thousands of years. The Liar Paradox has lots
of opinions yet not one accepted formal resolution.
This is f-cking nuts !!!
No, it is just you who is the freaking moron.
Your problem is you just don't understand the concept of Context, and confuse the loosy-goosy philosophers who can't prove anything with the Formal Logician who has rules that define things.
You are just too stupid to see your stupidity.
On 1/10/2026 2:23 AM, Mikko wrote:
On 09/01/2026 17:52, olcott wrote:
On 1/9/2026 3:59 AM, Mikko wrote:
On 08/01/2026 16:22, olcott wrote:
On 1/8/2026 4:22 AM, Mikko wrote:
On 07/01/2026 13:54, olcott wrote:
On 1/7/2026 5:49 AM, Mikko wrote:
On 07/01/2026 06:44, olcott wrote:
All deciders essentially: Transform finite string
inputs by finite string transformation rules into
{Accept, Reject} values.
The counter-example input to requires more than
can be derived from finite string transformation
rules applied to this specific input thus the
Halting Problem requires too much.
In a sense the halting problem asks too much: the problem is
proven to
be unsolvable. In another sense it asks too little: usually we >>>>>>>> want to
know whether a method halts on every input, not just one.
Although the halting problem is unsolvable, there are partial >>>>>>>> solutions
to the halting problem. In particular, every counter-example to the >>>>>>>> full solution is correctly solved by some partial deciders.
*if undecidability is correct then truth itself is broken*
Depends on whether the word "truth" is interpeted in the standard
sense or in Olcott's sense.
Undecidability is misconception. Self-contradictory
expressions are correctly rejected as semantically
incoherent thus form no undecidability or incompleteness.
The misconception is yours. No expression in the language of the first >>>> order group theory is self-contradictory. But the first order goupr
theory is incomplete: it is impossible to prove that AB = BA is true
for every A and every B but it is also impossible to prove that AB = BA >>>> is false for some A and some B.
All deciders essentially: Transform finite string
inputs by finite string transformation rules into
{Accept, Reject} values.
When a required result cannot be derived by applying
finite string transformation rules to actual finite
string inputs, then the required result exceeds the
scope of computation and must be rejected as an
incorrect requirement.
No, that does not follow. If a required result cannot be derived by
appying a finite string transformation then the it it is uncomputable.
Right. Outside the scope of computation. Requiring anything
outside the scope of computation is an incorrect requirement.
Of course, it one can prove that the required result is not computable
then that helps to avoid wasting effort to try the impossible. The
situation is worse if it is not known that the required result is not
computable.
That something is not computable does not mean that there is anyting
"incorrect" in the requirement.
Yes it certainly does. Requiring the impossible is always an error.
Requiring an answer to a yes/no question that has no correct yes/no
answer is an incorrect question that must be rejected.
In order to claim that a requirement
is incorrect one must at least prove that the requirement does not
serve its intended purpose.
Requiring the impossible cannot possibly serve any purpose
except perhaps to exemplify one's own ignorance.
Even then it is possible that the
requirement serves some other purpose. Even if a requirement serves
no purpose that need not mean that it be "incorrect", only that it
is useless.
On 1/10/2026 2:23 AM, Mikko wrote:
On 09/01/2026 17:52, olcott wrote:
On 1/9/2026 3:59 AM, Mikko wrote:
On 08/01/2026 16:22, olcott wrote:
On 1/8/2026 4:22 AM, Mikko wrote:
On 07/01/2026 13:54, olcott wrote:
On 1/7/2026 5:49 AM, Mikko wrote:
On 07/01/2026 06:44, olcott wrote:
All deciders essentially: Transform finite string
inputs by finite string transformation rules into
{Accept, Reject} values.
The counter-example input to requires more than
can be derived from finite string transformation
rules applied to this specific input thus the
Halting Problem requires too much.
In a sense the halting problem asks too much: the problem is
proven to
be unsolvable. In another sense it asks too little: usually we >>>>>>>> want to
know whether a method halts on every input, not just one.
Although the halting problem is unsolvable, there are partial >>>>>>>> solutions
to the halting problem. In particular, every counter-example to the >>>>>>>> full solution is correctly solved by some partial deciders.
*if undecidability is correct then truth itself is broken*
Depends on whether the word "truth" is interpeted in the standard
sense or in Olcott's sense.
Undecidability is misconception. Self-contradictory
expressions are correctly rejected as semantically
incoherent thus form no undecidability or incompleteness.
The misconception is yours. No expression in the language of the first >>>> order group theory is self-contradictory. But the first order goupr
theory is incomplete: it is impossible to prove that AB = BA is true
for every A and every B but it is also impossible to prove that AB = BA >>>> is false for some A and some B.
All deciders essentially: Transform finite string
inputs by finite string transformation rules into
{Accept, Reject} values.
When a required result cannot be derived by applying
finite string transformation rules to actual finite
string inputs, then the required result exceeds the
scope of computation and must be rejected as an
incorrect requirement.
No, that does not follow. If a required result cannot be derived by
appying a finite string transformation then the it it is uncomputable.
Right. Outside the scope of computation. Requiring anything
outside the scope of computation is an incorrect requirement.
Of course, it one can prove that the required result is not computable
then that helps to avoid wasting effort to try the impossible. The
situation is worse if it is not known that the required result is not
computable.
That something is not computable does not mean that there is anyting
"incorrect" in the requirement.
Yes it certainly does. Requiring the impossible is always an error.
On 1/10/2026 9:28 PM, Richard Damon wrote:
On 1/10/26 10:16 PM, olcott wrote:
On 1/10/2026 8:33 PM, Richard Damon wrote:
On 1/10/26 9:09 PM, olcott wrote:
On 1/10/2026 8:03 PM, Richard Damon wrote:
On 1/10/26 8:05 PM, olcott wrote:
On 1/10/2026 6:35 PM, Richard Damon wrote:
On 1/10/26 6:19 PM, olcott wrote:
On 1/10/2026 2:23 AM, Mikko wrote:
On 09/01/2026 17:52, olcott wrote:
On 1/9/2026 3:59 AM, Mikko wrote:
On 08/01/2026 16:22, olcott wrote:
On 1/8/2026 4:22 AM, Mikko wrote:The misconception is yours. No expression in the language of >>>>>>>>>>>> the first
On 07/01/2026 13:54, olcott wrote:
On 1/7/2026 5:49 AM, Mikko wrote:Depends on whether the word "truth" is interpeted in the >>>>>>>>>>>>>> standard
On 07/01/2026 06:44, olcott wrote:*if undecidability is correct then truth itself is broken* >>>>>>>>>>>>>>
All deciders essentially: Transform finite string >>>>>>>>>>>>>>>>> inputs by finite string transformation rules into >>>>>>>>>>>>>>>>> {Accept, Reject} values.
The counter-example input to requires more than >>>>>>>>>>>>>>>>> can be derived from finite string transformation >>>>>>>>>>>>>>>>> rules applied to this specific input thus the >>>>>>>>>>>>>>>>> Halting Problem requires too much.
In a sense the halting problem asks too much: the >>>>>>>>>>>>>>>> problem is proven to
be unsolvable. In another sense it asks too little: >>>>>>>>>>>>>>>> usually we want to
know whether a method halts on every input, not just one. >>>>>>>>>>>>>>>>
Although the halting problem is unsolvable, there are >>>>>>>>>>>>>>>> partial solutions
to the halting problem. In particular, every counter- >>>>>>>>>>>>>>>> example to the
full solution is correctly solved by some partial deciders. >>>>>>>>>>>>>>>
sense or in Olcott's sense.
Undecidability is misconception. Self-contradictory
expressions are correctly rejected as semantically
incoherent thus form no undecidability or incompleteness. >>>>>>>>>>>>
order group theory is self-contradictory. But the first >>>>>>>>>>>> order goupr
theory is incomplete: it is impossible to prove that AB = BA >>>>>>>>>>>> is true
for every A and every B but it is also impossible to prove >>>>>>>>>>>> that AB = BA
is false for some A and some B.
All deciders essentially: Transform finite string
inputs by finite string transformation rules into
{Accept, Reject} values.
When a required result cannot be derived by applying
finite string transformation rules to actual finite
string inputs, then the required result exceeds the
scope of computation and must be rejected as an
incorrect requirement.
No, that does not follow. If a required result cannot be
derived by
appying a finite string transformation then the it it is
uncomputable.
Of course, it one can prove that the required result is not >>>>>>>>>> computable
then that helps to avoid wasting effort to try the impossible. >>>>>>>>>> The
situation is worse if it is not known that the required result >>>>>>>>>> is not
computable.
That something is not computable does not mean that there is >>>>>>>>>> anyting
"incorrect" in the requirement. In order to claim that a
requirement
is incorrect one must at least prove that the requirement does >>>>>>>>>> not
serve its intended purpose. Even then it is possible that the >>>>>>>>>> requirement serves some other purpose. Even if a requirement >>>>>>>>>> serves
no purpose that need not mean that it be "incorrect", only >>>>>>>>>> that it
is useless.
*Computation and Undecidability*
Any result that cannot be derived as a pure function of
finite strings is outside the scope of computation. What
has been construed as decision problem undecidability
has always actually been requirements that are outside
of the scope of computation.
https://www.researchgate.net/
publication/399111881_Computation_and_Undecidability
So why isn't DD() -> Halts (since your HHH(DD) returns 0) not a >>>>>>>> pure function of the input.
Now, if your DD doesn't include the code for HHH, then you show >>>>>>>> your problem, your input isn't that of a program, and thus out >>>>>>>> of sco[e.
The Halting Problem only talks about the behavior of PROGRAMS, >>>>>>>> which requires that the input specify ALL of the algorith/code >>>>>>>> used by it. so your "C function" DD isn't a valid input without >>>>>>>> also specifying the SPECIFIC HHH that it calls.
A shorter link that won't get unintentionally chopped off.
*Computation and Undecidability*
https://philpapers.org/go.pl?aid=OLCCAU
*ChatGPT explains how and why I am correct*
*Reinterpretation of undecidability*
The example of P and H demonstrates that what is
often called “undecidable” is better understood as
ill-posed with respect to computable semantics.
When the specification is constrained to properties
detectable via finite simulation and finite pattern
recognition, computation proceeds normally and
correctly. Undecidability only appears when the
specification overreaches that boundary.
Which just shows it doesn't know what "undecidability" is.
And neither do you, or how LLMs work.
Note, your "criteria" means you can't ask a question about
computing you don't know the answer to.
This shows how stupid you are.
It doesn't say anything like that.
You seem to have a reason comprehension problem.
Proof Theoretic Semantics perfectly agrees with me.
That you never heard of that is not a rebuttal.
No, you are just showing your stupidity.
How can you determine if a given problem is in the scope of
Computation Theory? (If you don't already have the answer).
Its like the whole world has been a freaking moron
for thousands of years. The Liar Paradox has lots
of opinions yet not one accepted formal resolution.
This is f-cking nuts !!!
No, it is just you who is the freaking moron.
Your problem is you just don't understand the concept of Context, and
confuse the loosy-goosy philosophers who can't prove anything with the
Formal Logician who has rules that define things.
You are just too stupid to see your stupidity.
Not one person from any field or combination of
fields has presented any formal resolution of
the Liar Paradox that has been officially accepted.
Did you know that?
After more than 2000 years no one figured out that
a self-contradictory expression has no truth value.
On 1/10/26 10:34 PM, olcott wrote:
On 1/10/2026 9:28 PM, Richard Damon wrote:
On 1/10/26 10:16 PM, olcott wrote:
On 1/10/2026 8:33 PM, Richard Damon wrote:
On 1/10/26 9:09 PM, olcott wrote:
On 1/10/2026 8:03 PM, Richard Damon wrote:
On 1/10/26 8:05 PM, olcott wrote:
On 1/10/2026 6:35 PM, Richard Damon wrote:
On 1/10/26 6:19 PM, olcott wrote:
On 1/10/2026 2:23 AM, Mikko wrote:
On 09/01/2026 17:52, olcott wrote:
On 1/9/2026 3:59 AM, Mikko wrote:
On 08/01/2026 16:22, olcott wrote:
On 1/8/2026 4:22 AM, Mikko wrote:The misconception is yours. No expression in the language >>>>>>>>>>>>> of the first
On 07/01/2026 13:54, olcott wrote:
On 1/7/2026 5:49 AM, Mikko wrote:Depends on whether the word "truth" is interpeted in the >>>>>>>>>>>>>>> standard
On 07/01/2026 06:44, olcott wrote:
All deciders essentially: Transform finite string >>>>>>>>>>>>>>>>>> inputs by finite string transformation rules into >>>>>>>>>>>>>>>>>> {Accept, Reject} values.
The counter-example input to requires more than >>>>>>>>>>>>>>>>>> can be derived from finite string transformation >>>>>>>>>>>>>>>>>> rules applied to this specific input thus the >>>>>>>>>>>>>>>>>> Halting Problem requires too much.
In a sense the halting problem asks too much: the >>>>>>>>>>>>>>>>> problem is proven to
be unsolvable. In another sense it asks too little: >>>>>>>>>>>>>>>>> usually we want to
know whether a method halts on every input, not just one. >>>>>>>>>>>>>>>>>
Although the halting problem is unsolvable, there are >>>>>>>>>>>>>>>>> partial solutions
to the halting problem. In particular, every counter- >>>>>>>>>>>>>>>>> example to the
full solution is correctly solved by some partial >>>>>>>>>>>>>>>>> deciders.
*if undecidability is correct then truth itself is broken* >>>>>>>>>>>>>>>
sense or in Olcott's sense.
Undecidability is misconception. Self-contradictory >>>>>>>>>>>>>> expressions are correctly rejected as semantically >>>>>>>>>>>>>> incoherent thus form no undecidability or incompleteness. >>>>>>>>>>>>>
order group theory is self-contradictory. But the first >>>>>>>>>>>>> order goupr
theory is incomplete: it is impossible to prove that AB = >>>>>>>>>>>>> BA is true
for every A and every B but it is also impossible to prove >>>>>>>>>>>>> that AB = BA
is false for some A and some B.
All deciders essentially: Transform finite string
inputs by finite string transformation rules into
{Accept, Reject} values.
When a required result cannot be derived by applying
finite string transformation rules to actual finite
string inputs, then the required result exceeds the
scope of computation and must be rejected as an
incorrect requirement.
No, that does not follow. If a required result cannot be >>>>>>>>>>> derived by
appying a finite string transformation then the it it is >>>>>>>>>>> uncomputable.
Of course, it one can prove that the required result is not >>>>>>>>>>> computable
then that helps to avoid wasting effort to try the
impossible. The
situation is worse if it is not known that the required >>>>>>>>>>> result is not
computable.
That something is not computable does not mean that there is >>>>>>>>>>> anyting
"incorrect" in the requirement. In order to claim that a >>>>>>>>>>> requirement
is incorrect one must at least prove that the requirement >>>>>>>>>>> does not
serve its intended purpose. Even then it is possible that the >>>>>>>>>>> requirement serves some other purpose. Even if a requirement >>>>>>>>>>> serves
no purpose that need not mean that it be "incorrect", only >>>>>>>>>>> that it
is useless.
*Computation and Undecidability*
Any result that cannot be derived as a pure function of
finite strings is outside the scope of computation. What
has been construed as decision problem undecidability
has always actually been requirements that are outside
of the scope of computation.
https://www.researchgate.net/
publication/399111881_Computation_and_Undecidability
So why isn't DD() -> Halts (since your HHH(DD) returns 0) not a >>>>>>>>> pure function of the input.
Now, if your DD doesn't include the code for HHH, then you show >>>>>>>>> your problem, your input isn't that of a program, and thus out >>>>>>>>> of sco[e.
The Halting Problem only talks about the behavior of PROGRAMS, >>>>>>>>> which requires that the input specify ALL of the algorith/code >>>>>>>>> used by it. so your "C function" DD isn't a valid input without >>>>>>>>> also specifying the SPECIFIC HHH that it calls.
A shorter link that won't get unintentionally chopped off.
*Computation and Undecidability*
https://philpapers.org/go.pl?aid=OLCCAU
*ChatGPT explains how and why I am correct*
*Reinterpretation of undecidability*
The example of P and H demonstrates that what is
often called “undecidable” is better understood as
ill-posed with respect to computable semantics.
When the specification is constrained to properties
detectable via finite simulation and finite pattern
recognition, computation proceeds normally and
correctly. Undecidability only appears when the
specification overreaches that boundary.
Which just shows it doesn't know what "undecidability" is.
And neither do you, or how LLMs work.
Note, your "criteria" means you can't ask a question about
computing you don't know the answer to.
This shows how stupid you are.
It doesn't say anything like that.
You seem to have a reason comprehension problem.
Proof Theoretic Semantics perfectly agrees with me.
That you never heard of that is not a rebuttal.
No, you are just showing your stupidity.
How can you determine if a given problem is in the scope of
Computation Theory? (If you don't already have the answer).
Its like the whole world has been a freaking moron
for thousands of years. The Liar Paradox has lots
of opinions yet not one accepted formal resolution.
This is f-cking nuts !!!
No, it is just you who is the freaking moron.
Your problem is you just don't understand the concept of Context, and
confuse the loosy-goosy philosophers who can't prove anything with
the Formal Logician who has rules that define things.
You are just too stupid to see your stupidity.
Not one person from any field or combination of
fields has presented any formal resolution of
the Liar Paradox that has been officially accepted.
Did you know that?
WRONG.
It has been well know in the field of Formal Logic that statements like
it just don't have a truth value.
Your problem is you live in a world of blinders and only "understand"--
the talking of philosophers that like to debate such things, but have no rules that allow anything difinitive to be said.
Part of your problem is that, by not understanding what (formal)
Semanitcs actually mean, you don't understand that not all syntactic sentences HAVE semantics, and thus that not all (formal) sentences need
to actually have a truth value.
After more than 2000 years no one figured out that
a self-contradictory expression has no truth value.
Sure they have.
On 10/01/2026 17:47, olcott wrote:
On 1/10/2026 2:23 AM, Mikko wrote:
On 09/01/2026 17:52, olcott wrote:
On 1/9/2026 3:59 AM, Mikko wrote:
On 08/01/2026 16:22, olcott wrote:
On 1/8/2026 4:22 AM, Mikko wrote:
On 07/01/2026 13:54, olcott wrote:
On 1/7/2026 5:49 AM, Mikko wrote:
On 07/01/2026 06:44, olcott wrote:
All deciders essentially: Transform finite string
inputs by finite string transformation rules into
{Accept, Reject} values.
The counter-example input to requires more than
can be derived from finite string transformation
rules applied to this specific input thus the
Halting Problem requires too much.
In a sense the halting problem asks too much: the problem is >>>>>>>>> proven to
be unsolvable. In another sense it asks too little: usually we >>>>>>>>> want to
know whether a method halts on every input, not just one.
Although the halting problem is unsolvable, there are partial >>>>>>>>> solutions
to the halting problem. In particular, every counter-example to >>>>>>>>> the
full solution is correctly solved by some partial deciders.
*if undecidability is correct then truth itself is broken*
Depends on whether the word "truth" is interpeted in the standard >>>>>>> sense or in Olcott's sense.
Undecidability is misconception. Self-contradictory
expressions are correctly rejected as semantically
incoherent thus form no undecidability or incompleteness.
The misconception is yours. No expression in the language of the first >>>>> order group theory is self-contradictory. But the first order goupr
theory is incomplete: it is impossible to prove that AB = BA is true >>>>> for every A and every B but it is also impossible to prove that AB
= BA
is false for some A and some B.
All deciders essentially: Transform finite string
inputs by finite string transformation rules into
{Accept, Reject} values.
When a required result cannot be derived by applying
finite string transformation rules to actual finite
string inputs, then the required result exceeds the
scope of computation and must be rejected as an
incorrect requirement.
No, that does not follow. If a required result cannot be derived by
appying a finite string transformation then the it it is uncomputable.
Right. Outside the scope of computation. Requiring anything
outside the scope of computation is an incorrect requirement.
You can't determine whether the required result is computable before
you have the requirement.
Of course, it one can prove that the required result is not computable
then that helps to avoid wasting effort to try the impossible. The
situation is worse if it is not known that the required result is not
computable.
That something is not computable does not mean that there is anyting
"incorrect" in the requirement.
Yes it certainly does. Requiring the impossible is always an error.
Requiring an answer to a yes/no question that has no correct yes/no
answer is an incorrect question that must be rejected.
In order to claim that a requirement
is incorrect one must at least prove that the requirement does not
serve its intended purpose.
Requiring the impossible cannot possibly serve any purpose
except perhaps to exemplify one's own ignorance.
Even then it is possible that the
requirement serves some other purpose. Even if a requirement serves
no purpose that need not mean that it be "incorrect", only that it
is useless.
On 10/01/2026 17:47, olcott wrote:
On 1/10/2026 2:23 AM, Mikko wrote:
On 09/01/2026 17:52, olcott wrote:
On 1/9/2026 3:59 AM, Mikko wrote:
On 08/01/2026 16:22, olcott wrote:
On 1/8/2026 4:22 AM, Mikko wrote:
On 07/01/2026 13:54, olcott wrote:
On 1/7/2026 5:49 AM, Mikko wrote:
On 07/01/2026 06:44, olcott wrote:
All deciders essentially: Transform finite string
inputs by finite string transformation rules into
{Accept, Reject} values.
The counter-example input to requires more than
can be derived from finite string transformation
rules applied to this specific input thus the
Halting Problem requires too much.
In a sense the halting problem asks too much: the problem is >>>>>>>>> proven to
be unsolvable. In another sense it asks too little: usually we >>>>>>>>> want to
know whether a method halts on every input, not just one.
Although the halting problem is unsolvable, there are partial >>>>>>>>> solutions
to the halting problem. In particular, every counter-example to >>>>>>>>> the
full solution is correctly solved by some partial deciders.
*if undecidability is correct then truth itself is broken*
Depends on whether the word "truth" is interpeted in the standard >>>>>>> sense or in Olcott's sense.
Undecidability is misconception. Self-contradictory
expressions are correctly rejected as semantically
incoherent thus form no undecidability or incompleteness.
The misconception is yours. No expression in the language of the first >>>>> order group theory is self-contradictory. But the first order goupr
theory is incomplete: it is impossible to prove that AB = BA is true >>>>> for every A and every B but it is also impossible to prove that AB
= BA
is false for some A and some B.
All deciders essentially: Transform finite string
inputs by finite string transformation rules into
{Accept, Reject} values.
When a required result cannot be derived by applying
finite string transformation rules to actual finite
string inputs, then the required result exceeds the
scope of computation and must be rejected as an
incorrect requirement.
No, that does not follow. If a required result cannot be derived by
appying a finite string transformation then the it it is uncomputable.
Right. Outside the scope of computation. Requiring anything
outside the scope of computation is an incorrect requirement.
Of course, it one can prove that the required result is not computable
then that helps to avoid wasting effort to try the impossible. The
situation is worse if it is not known that the required result is not
computable.
That something is not computable does not mean that there is anyting
"incorrect" in the requirement.
Yes it certainly does. Requiring the impossible is always an error.
It is a perfectly valid question to ask whther a particular reuqirement
is satisfiable.
On 11/01/2026 11:31, Richard Damon wrote:
Not one person from any field or combination of
fields has presented any formal resolution of
the Liar Paradox that has been officially accepted.
Did you know that?
WRONG.
What does "officially accepted" mean? His Majesty's crown court has
found that the resolution is so with prejudice? His Majesty's memoirs
"My Liar Paradox and I" has the resolution in it? His Majesty published
a decree in The London Gazette?
You have to pay 500% attention to the actual words Olcott actually uses.
On 11/01/2026 18:12, olcott wrote:
On 1/11/2026 8:39 AM, Tristan Wibberley wrote:
What does "officially accepted" mean?
Basically a broad consensus of conventional wisdom
agrees that the Liar Paradox is an open question
that has never been resolved.
"Officially" doesn't refer to any consensus nor to any convention. It's basically the opposite of consensus and convention; that's the purpose
of the word.
If Princeton has a position statement on it, maybe that would do.
On 1/11/2026 4:13 AM, Mikko wrote:
On 10/01/2026 17:47, olcott wrote:
On 1/10/2026 2:23 AM, Mikko wrote:
On 09/01/2026 17:52, olcott wrote:
On 1/9/2026 3:59 AM, Mikko wrote:
On 08/01/2026 16:22, olcott wrote:
On 1/8/2026 4:22 AM, Mikko wrote:
On 07/01/2026 13:54, olcott wrote:
On 1/7/2026 5:49 AM, Mikko wrote:
On 07/01/2026 06:44, olcott wrote:*if undecidability is correct then truth itself is broken*
All deciders essentially: Transform finite string
inputs by finite string transformation rules into
{Accept, Reject} values.
The counter-example input to requires more than
can be derived from finite string transformation
rules applied to this specific input thus the
Halting Problem requires too much.
In a sense the halting problem asks too much: the problem is >>>>>>>>>> proven to
be unsolvable. In another sense it asks too little: usually we >>>>>>>>>> want to
know whether a method halts on every input, not just one.
Although the halting problem is unsolvable, there are partial >>>>>>>>>> solutions
to the halting problem. In particular, every counter-example >>>>>>>>>> to the
full solution is correctly solved by some partial deciders. >>>>>>>>>
Depends on whether the word "truth" is interpeted in the standard >>>>>>>> sense or in Olcott's sense.
Undecidability is misconception. Self-contradictory
expressions are correctly rejected as semantically
incoherent thus form no undecidability or incompleteness.
The misconception is yours. No expression in the language of the
first
order group theory is self-contradictory. But the first order goupr >>>>>> theory is incomplete: it is impossible to prove that AB = BA is true >>>>>> for every A and every B but it is also impossible to prove that AB >>>>>> = BA
is false for some A and some B.
All deciders essentially: Transform finite string
inputs by finite string transformation rules into
{Accept, Reject} values.
When a required result cannot be derived by applying
finite string transformation rules to actual finite
string inputs, then the required result exceeds the
scope of computation and must be rejected as an
incorrect requirement.
No, that does not follow. If a required result cannot be derived by
appying a finite string transformation then the it it is uncomputable.
Right. Outside the scope of computation. Requiring anything
outside the scope of computation is an incorrect requirement.
You can't determine whether the required result is computable before
you have the requirement.
*Computation and Undecidability*
https://philpapers.org/go.pl?aid=OLCCAU
We know that there does not exist any finite
string transformations that H can apply to its
input P to derive the halt status of any P
that does the opposite of whatever H returns.
*ChatGPT explains how and why I am correct*
*Reinterpretation of undecidability*
The example of P and H demonstrates that what is
often called “undecidable” is better understood as
ill-posed with respect to computable semantics.
When the specification is constrained to properties
detectable via finite simulation and finite pattern
recognition, computation proceeds normally and
correctly. Undecidability only appears when the
specification overreaches that boundary.
On 1/11/2026 4:22 AM, Mikko wrote:
On 10/01/2026 17:47, olcott wrote:
On 1/10/2026 2:23 AM, Mikko wrote:
On 09/01/2026 17:52, olcott wrote:
On 1/9/2026 3:59 AM, Mikko wrote:
On 08/01/2026 16:22, olcott wrote:
On 1/8/2026 4:22 AM, Mikko wrote:
On 07/01/2026 13:54, olcott wrote:
On 1/7/2026 5:49 AM, Mikko wrote:
On 07/01/2026 06:44, olcott wrote:*if undecidability is correct then truth itself is broken*
All deciders essentially: Transform finite string
inputs by finite string transformation rules into
{Accept, Reject} values.
The counter-example input to requires more than
can be derived from finite string transformation
rules applied to this specific input thus the
Halting Problem requires too much.
In a sense the halting problem asks too much: the problem is >>>>>>>>>> proven to
be unsolvable. In another sense it asks too little: usually we >>>>>>>>>> want to
know whether a method halts on every input, not just one.
Although the halting problem is unsolvable, there are partial >>>>>>>>>> solutions
to the halting problem. In particular, every counter-example >>>>>>>>>> to the
full solution is correctly solved by some partial deciders. >>>>>>>>>
Depends on whether the word "truth" is interpeted in the standard >>>>>>>> sense or in Olcott's sense.
Undecidability is misconception. Self-contradictory
expressions are correctly rejected as semantically
incoherent thus form no undecidability or incompleteness.
The misconception is yours. No expression in the language of the
first
order group theory is self-contradictory. But the first order goupr >>>>>> theory is incomplete: it is impossible to prove that AB = BA is true >>>>>> for every A and every B but it is also impossible to prove that AB >>>>>> = BA
is false for some A and some B.
All deciders essentially: Transform finite string
inputs by finite string transformation rules into
{Accept, Reject} values.
When a required result cannot be derived by applying
finite string transformation rules to actual finite
string inputs, then the required result exceeds the
scope of computation and must be rejected as an
incorrect requirement.
No, that does not follow. If a required result cannot be derived by
appying a finite string transformation then the it it is uncomputable.
Right. Outside the scope of computation. Requiring anything
outside the scope of computation is an incorrect requirement.
Of course, it one can prove that the required result is not computable >>>> then that helps to avoid wasting effort to try the impossible. The
situation is worse if it is not known that the required result is not
computable.
That something is not computable does not mean that there is anyting
"incorrect" in the requirement.
Yes it certainly does. Requiring the impossible is always an error.
It is a perfectly valid question to ask whther a particular reuqirement
is satisfiable.
Any yes/no question lacking a correct yes/no answer
is an incorrect question that must be rejected on
that basis.
On 11/01/2026 16:18, olcott wrote:
On 1/11/2026 4:13 AM, Mikko wrote:
On 10/01/2026 17:47, olcott wrote:
On 1/10/2026 2:23 AM, Mikko wrote:
On 09/01/2026 17:52, olcott wrote:Right. Outside the scope of computation. Requiring anything
On 1/9/2026 3:59 AM, Mikko wrote:
On 08/01/2026 16:22, olcott wrote:
On 1/8/2026 4:22 AM, Mikko wrote:
On 07/01/2026 13:54, olcott wrote:
On 1/7/2026 5:49 AM, Mikko wrote:
On 07/01/2026 06:44, olcott wrote:*if undecidability is correct then truth itself is broken*
All deciders essentially: Transform finite string
inputs by finite string transformation rules into
{Accept, Reject} values.
The counter-example input to requires more than
can be derived from finite string transformation
rules applied to this specific input thus the
Halting Problem requires too much.
In a sense the halting problem asks too much: the problem is >>>>>>>>>>> proven to
be unsolvable. In another sense it asks too little: usually >>>>>>>>>>> we want to
know whether a method halts on every input, not just one. >>>>>>>>>>>
Although the halting problem is unsolvable, there are partial >>>>>>>>>>> solutions
to the halting problem. In particular, every counter-example >>>>>>>>>>> to the
full solution is correctly solved by some partial deciders. >>>>>>>>>>
Depends on whether the word "truth" is interpeted in the standard >>>>>>>>> sense or in Olcott's sense.
Undecidability is misconception. Self-contradictory
expressions are correctly rejected as semantically
incoherent thus form no undecidability or incompleteness.
The misconception is yours. No expression in the language of the >>>>>>> first
order group theory is self-contradictory. But the first order goupr >>>>>>> theory is incomplete: it is impossible to prove that AB = BA is true >>>>>>> for every A and every B but it is also impossible to prove that >>>>>>> AB = BA
is false for some A and some B.
All deciders essentially: Transform finite string
inputs by finite string transformation rules into
{Accept, Reject} values.
When a required result cannot be derived by applying
finite string transformation rules to actual finite
string inputs, then the required result exceeds the
scope of computation and must be rejected as an
incorrect requirement.
No, that does not follow. If a required result cannot be derived by
appying a finite string transformation then the it it is uncomputable. >>>>
outside the scope of computation is an incorrect requirement.
You can't determine whether the required result is computable before
you have the requirement.
*Computation and Undecidability*
https://philpapers.org/go.pl?aid=OLCCAU
We know that there does not exist any finite
string transformations that H can apply to its
input P to derive the halt status of any P
that does the opposite of whatever H returns.
Which only nmakes sense when the requirement that H must determine
whether the computation presented by its input halts has already
been presented.
*ChatGPT explains how and why I am correct*
*Reinterpretation of undecidability*
The example of P and H demonstrates that what is
often called “undecidable” is better understood as
ill-posed with respect to computable semantics.
When the specification is constrained to properties
detectable via finite simulation and finite pattern
recognition, computation proceeds normally and
correctly. Undecidability only appears when the
specification overreaches that boundary.
It tries to explain but it does not prove.
On 11/01/2026 16:24, Tristan Wibberley wrote:
On 11/01/2026 10:13, Mikko wrote:
On 10/01/2026 17:47, olcott wrote:
On 1/10/2026 2:23 AM, Mikko wrote:
No, that does not follow. If a required result cannot be derived byRight. Outside the scope of computation. Requiring anything
appying a finite string transformation then the it it is uncomputable. >>>>
outside the scope of computation is an incorrect requirement.
You can't determine whether the required result is computable before
you have the requirement.
Right, it is /in/ scope for computer science... for the /ology/. Olcott
here uses "computation" to refer to the practice. You give the
requirement to the /ologist/ who correctly decides that it is not for
computation because it is not computable.
You two so often violently agree; I find it warming to the heart.
For pracitcal programming it is useful to know what is known to be uncomputable in order to avoid wasting time in attemlpts to do the impossible.
On 11/01/2026 16:23, olcott wrote:
On 1/11/2026 4:22 AM, Mikko wrote:
On 10/01/2026 17:47, olcott wrote:
On 1/10/2026 2:23 AM, Mikko wrote:
On 09/01/2026 17:52, olcott wrote:Right. Outside the scope of computation. Requiring anything
On 1/9/2026 3:59 AM, Mikko wrote:
On 08/01/2026 16:22, olcott wrote:
On 1/8/2026 4:22 AM, Mikko wrote:
On 07/01/2026 13:54, olcott wrote:
On 1/7/2026 5:49 AM, Mikko wrote:
On 07/01/2026 06:44, olcott wrote:*if undecidability is correct then truth itself is broken*
All deciders essentially: Transform finite string
inputs by finite string transformation rules into
{Accept, Reject} values.
The counter-example input to requires more than
can be derived from finite string transformation
rules applied to this specific input thus the
Halting Problem requires too much.
In a sense the halting problem asks too much: the problem is >>>>>>>>>>> proven to
be unsolvable. In another sense it asks too little: usually >>>>>>>>>>> we want to
know whether a method halts on every input, not just one. >>>>>>>>>>>
Although the halting problem is unsolvable, there are partial >>>>>>>>>>> solutions
to the halting problem. In particular, every counter-example >>>>>>>>>>> to the
full solution is correctly solved by some partial deciders. >>>>>>>>>>
Depends on whether the word "truth" is interpeted in the standard >>>>>>>>> sense or in Olcott's sense.
Undecidability is misconception. Self-contradictory
expressions are correctly rejected as semantically
incoherent thus form no undecidability or incompleteness.
The misconception is yours. No expression in the language of the >>>>>>> first
order group theory is self-contradictory. But the first order goupr >>>>>>> theory is incomplete: it is impossible to prove that AB = BA is true >>>>>>> for every A and every B but it is also impossible to prove that >>>>>>> AB = BA
is false for some A and some B.
All deciders essentially: Transform finite string
inputs by finite string transformation rules into
{Accept, Reject} values.
When a required result cannot be derived by applying
finite string transformation rules to actual finite
string inputs, then the required result exceeds the
scope of computation and must be rejected as an
incorrect requirement.
No, that does not follow. If a required result cannot be derived by
appying a finite string transformation then the it it is uncomputable. >>>>
outside the scope of computation is an incorrect requirement.
Of course, it one can prove that the required result is not computable >>>>> then that helps to avoid wasting effort to try the impossible. The
situation is worse if it is not known that the required result is not >>>>> computable.
That something is not computable does not mean that there is anyting >>>>> "incorrect" in the requirement.
Yes it certainly does. Requiring the impossible is always an error.
It is a perfectly valid question to ask whther a particular reuqirement
is satisfiable.
Any yes/no question lacking a correct yes/no answer
is an incorrect question that must be rejected on
that basis.
Irrelevant. The question whether a particular requirement is satisfiable
does have an answer that is either "yes" or "no". In some ases it is
not known whether it is "yes" or "no" and there may be no known way to
find out be even then either "yes" or "no" is the correct answer.
On 1/12/2026 4:44 AM, Mikko wrote:
On 11/01/2026 16:18, olcott wrote:
On 1/11/2026 4:13 AM, Mikko wrote:
On 10/01/2026 17:47, olcott wrote:
On 1/10/2026 2:23 AM, Mikko wrote:
On 09/01/2026 17:52, olcott wrote:
On 1/9/2026 3:59 AM, Mikko wrote:
On 08/01/2026 16:22, olcott wrote:
On 1/8/2026 4:22 AM, Mikko wrote:
On 07/01/2026 13:54, olcott wrote:
On 1/7/2026 5:49 AM, Mikko wrote:Depends on whether the word "truth" is interpeted in the standard >>>>>>>>>> sense or in Olcott's sense.
On 07/01/2026 06:44, olcott wrote:*if undecidability is correct then truth itself is broken* >>>>>>>>>>
All deciders essentially: Transform finite string
inputs by finite string transformation rules into
{Accept, Reject} values.
The counter-example input to requires more than
can be derived from finite string transformation
rules applied to this specific input thus the
Halting Problem requires too much.
In a sense the halting problem asks too much: the problem is >>>>>>>>>>>> proven to
be unsolvable. In another sense it asks too little: usually >>>>>>>>>>>> we want to
know whether a method halts on every input, not just one. >>>>>>>>>>>>
Although the halting problem is unsolvable, there are >>>>>>>>>>>> partial solutions
to the halting problem. In particular, every counter-example >>>>>>>>>>>> to the
full solution is correctly solved by some partial deciders. >>>>>>>>>>>
Undecidability is misconception. Self-contradictory
expressions are correctly rejected as semantically
incoherent thus form no undecidability or incompleteness.
The misconception is yours. No expression in the language of the >>>>>>>> first
order group theory is self-contradictory. But the first order goupr >>>>>>>> theory is incomplete: it is impossible to prove that AB = BA is >>>>>>>> true
for every A and every B but it is also impossible to prove that >>>>>>>> AB = BA
is false for some A and some B.
All deciders essentially: Transform finite string
inputs by finite string transformation rules into
{Accept, Reject} values.
When a required result cannot be derived by applying
finite string transformation rules to actual finite
string inputs, then the required result exceeds the
scope of computation and must be rejected as an
incorrect requirement.
No, that does not follow. If a required result cannot be derived by >>>>>> appying a finite string transformation then the it it is
uncomputable.
Right. Outside the scope of computation. Requiring anything
outside the scope of computation is an incorrect requirement.
You can't determine whether the required result is computable before
you have the requirement.
*Computation and Undecidability*
https://philpapers.org/go.pl?aid=OLCCAU
We know that there does not exist any finite
string transformations that H can apply to its
input P to derive the halt status of any P
that does the opposite of whatever H returns.
Which only nmakes sense when the requirement that H must determine
whether the computation presented by its input halts has already
been presented.
*ChatGPT explains how and why I am correct*
*Reinterpretation of undecidability*
The example of P and H demonstrates that what is
often called “undecidable” is better understood as
ill-posed with respect to computable semantics.
When the specification is constrained to properties
detectable via finite simulation and finite pattern
recognition, computation proceeds normally and
correctly. Undecidability only appears when the
specification overreaches that boundary.
It tries to explain but it does not prove.
Its the same thing that I have been saying for years.
It is not that a universal halt decider cannot exist.
It is that an input that does the opposite of whatever
value the halt decider returns is non-well-founded
within proof-theoretic semantics.
On 1/12/2026 4:47 AM, Mikko wrote:
On 11/01/2026 16:24, Tristan Wibberley wrote:
On 11/01/2026 10:13, Mikko wrote:
On 10/01/2026 17:47, olcott wrote:
On 1/10/2026 2:23 AM, Mikko wrote:
No, that does not follow. If a required result cannot be derived by >>>>>> appying a finite string transformation then the it it is
uncomputable.
Right. Outside the scope of computation. Requiring anything
outside the scope of computation is an incorrect requirement.
You can't determine whether the required result is computable before
you have the requirement.
Right, it is /in/ scope for computer science... for the /ology/. Olcott
here uses "computation" to refer to the practice. You give the
requirement to the /ologist/ who correctly decides that it is not for
computation because it is not computable.
You two so often violently agree; I find it warming to the heart.
For pracitcal programming it is useful to know what is known to be
uncomputable in order to avoid wasting time in attemlpts to do the
impossible.
It f-cking nuts that after more than 2000 years
people still don't understand that self-contradictory
expressions: "This sentence is not true" have no
truth value. A smart high school student should have
figured this out 2000 years ago.
On 1/12/2026 4:51 AM, Mikko wrote:
On 11/01/2026 16:23, olcott wrote:
On 1/11/2026 4:22 AM, Mikko wrote:
On 10/01/2026 17:47, olcott wrote:
On 1/10/2026 2:23 AM, Mikko wrote:
On 09/01/2026 17:52, olcott wrote:
On 1/9/2026 3:59 AM, Mikko wrote:
On 08/01/2026 16:22, olcott wrote:
On 1/8/2026 4:22 AM, Mikko wrote:
On 07/01/2026 13:54, olcott wrote:
On 1/7/2026 5:49 AM, Mikko wrote:Depends on whether the word "truth" is interpeted in the standard >>>>>>>>>> sense or in Olcott's sense.
On 07/01/2026 06:44, olcott wrote:*if undecidability is correct then truth itself is broken* >>>>>>>>>>
All deciders essentially: Transform finite string
inputs by finite string transformation rules into
{Accept, Reject} values.
The counter-example input to requires more than
can be derived from finite string transformation
rules applied to this specific input thus the
Halting Problem requires too much.
In a sense the halting problem asks too much: the problem is >>>>>>>>>>>> proven to
be unsolvable. In another sense it asks too little: usually >>>>>>>>>>>> we want to
know whether a method halts on every input, not just one. >>>>>>>>>>>>
Although the halting problem is unsolvable, there are >>>>>>>>>>>> partial solutions
to the halting problem. In particular, every counter-example >>>>>>>>>>>> to the
full solution is correctly solved by some partial deciders. >>>>>>>>>>>
Undecidability is misconception. Self-contradictory
expressions are correctly rejected as semantically
incoherent thus form no undecidability or incompleteness.
The misconception is yours. No expression in the language of the >>>>>>>> first
order group theory is self-contradictory. But the first order goupr >>>>>>>> theory is incomplete: it is impossible to prove that AB = BA is >>>>>>>> true
for every A and every B but it is also impossible to prove that >>>>>>>> AB = BA
is false for some A and some B.
All deciders essentially: Transform finite string
inputs by finite string transformation rules into
{Accept, Reject} values.
When a required result cannot be derived by applying
finite string transformation rules to actual finite
string inputs, then the required result exceeds the
scope of computation and must be rejected as an
incorrect requirement.
No, that does not follow. If a required result cannot be derived by >>>>>> appying a finite string transformation then the it it is
uncomputable.
Right. Outside the scope of computation. Requiring anything
outside the scope of computation is an incorrect requirement.
Of course, it one can prove that the required result is not
computable
then that helps to avoid wasting effort to try the impossible. The >>>>>> situation is worse if it is not known that the required result is not >>>>>> computable.
That something is not computable does not mean that there is anyting >>>>>> "incorrect" in the requirement.
Yes it certainly does. Requiring the impossible is always an error.
It is a perfectly valid question to ask whther a particular reuqirement >>>> is satisfiable.
Any yes/no question lacking a correct yes/no answer
is an incorrect question that must be rejected on
that basis.
Irrelevant. The question whether a particular requirement is satisfiable
does have an answer that is either "yes" or "no". In some ases it is
not known whether it is "yes" or "no" and there may be no known way to
find out be even then either "yes" or "no" is the correct answer.
Now that I finally have the standard terminology:
Proof-theoretic semantics has always been the correct
formal system to handle decision problems.
When it is asked a yes/no question lacking a correct
yes/no answer it correctly determines non-well-founded.
I have been correct all along and merely lacked the
standard terminology.
On 1/12/2026 4:51 AM, Mikko wrote:
On 11/01/2026 16:23, olcott wrote:
On 1/11/2026 4:22 AM, Mikko wrote:
On 10/01/2026 17:47, olcott wrote:
On 1/10/2026 2:23 AM, Mikko wrote:
On 09/01/2026 17:52, olcott wrote:
On 1/9/2026 3:59 AM, Mikko wrote:
On 08/01/2026 16:22, olcott wrote:
On 1/8/2026 4:22 AM, Mikko wrote:
On 07/01/2026 13:54, olcott wrote:
On 1/7/2026 5:49 AM, Mikko wrote:Depends on whether the word "truth" is interpeted in the standard >>>>>>>>>> sense or in Olcott's sense.
On 07/01/2026 06:44, olcott wrote:*if undecidability is correct then truth itself is broken* >>>>>>>>>>
All deciders essentially: Transform finite string
inputs by finite string transformation rules into
{Accept, Reject} values.
The counter-example input to requires more than
can be derived from finite string transformation
rules applied to this specific input thus the
Halting Problem requires too much.
In a sense the halting problem asks too much: the problem is >>>>>>>>>>>> proven to
be unsolvable. In another sense it asks too little: usually >>>>>>>>>>>> we want to
know whether a method halts on every input, not just one. >>>>>>>>>>>>
Although the halting problem is unsolvable, there are >>>>>>>>>>>> partial solutions
to the halting problem. In particular, every counter-example >>>>>>>>>>>> to the
full solution is correctly solved by some partial deciders. >>>>>>>>>>>
Undecidability is misconception. Self-contradictory
expressions are correctly rejected as semantically
incoherent thus form no undecidability or incompleteness.
The misconception is yours. No expression in the language of the >>>>>>>> first
order group theory is self-contradictory. But the first order goupr >>>>>>>> theory is incomplete: it is impossible to prove that AB = BA is >>>>>>>> true
for every A and every B but it is also impossible to prove that >>>>>>>> AB = BA
is false for some A and some B.
All deciders essentially: Transform finite string
inputs by finite string transformation rules into
{Accept, Reject} values.
When a required result cannot be derived by applying
finite string transformation rules to actual finite
string inputs, then the required result exceeds the
scope of computation and must be rejected as an
incorrect requirement.
No, that does not follow. If a required result cannot be derived by >>>>>> appying a finite string transformation then the it it is
uncomputable.
Right. Outside the scope of computation. Requiring anything
outside the scope of computation is an incorrect requirement.
Of course, it one can prove that the required result is not
computable
then that helps to avoid wasting effort to try the impossible. The >>>>>> situation is worse if it is not known that the required result is not >>>>>> computable.
That something is not computable does not mean that there is anyting >>>>>> "incorrect" in the requirement.
Yes it certainly does. Requiring the impossible is always an error.
It is a perfectly valid question to ask whther a particular reuqirement >>>> is satisfiable.
Any yes/no question lacking a correct yes/no answer
is an incorrect question that must be rejected on
that basis.
Irrelevant. The question whether a particular requirement is satisfiable
does have an answer that is either "yes" or "no". In some ases it is
not known whether it is "yes" or "no" and there may be no known way to
find out be even then either "yes" or "no" is the correct answer.
Now that I finally have the standard terminology:
Proof-theoretic semantics has always been the correct
formal system to handle decision problems.
When it is asked a yes/no question lacking a correct
yes/no answer it correctly determines non-well-founded.
I have been correct all along and merely lacked the
standard terminology.
On 1/12/2026 4:44 AM, Mikko wrote:
On 11/01/2026 16:18, olcott wrote:
On 1/11/2026 4:13 AM, Mikko wrote:
On 10/01/2026 17:47, olcott wrote:
On 1/10/2026 2:23 AM, Mikko wrote:
On 09/01/2026 17:52, olcott wrote:
On 1/9/2026 3:59 AM, Mikko wrote:
On 08/01/2026 16:22, olcott wrote:
On 1/8/2026 4:22 AM, Mikko wrote:
On 07/01/2026 13:54, olcott wrote:
On 1/7/2026 5:49 AM, Mikko wrote:Depends on whether the word "truth" is interpeted in the standard >>>>>>>>>> sense or in Olcott's sense.
On 07/01/2026 06:44, olcott wrote:*if undecidability is correct then truth itself is broken* >>>>>>>>>>
All deciders essentially: Transform finite string
inputs by finite string transformation rules into
{Accept, Reject} values.
The counter-example input to requires more than
can be derived from finite string transformation
rules applied to this specific input thus the
Halting Problem requires too much.
In a sense the halting problem asks too much: the problem is >>>>>>>>>>>> proven to
be unsolvable. In another sense it asks too little: usually >>>>>>>>>>>> we want to
know whether a method halts on every input, not just one. >>>>>>>>>>>>
Although the halting problem is unsolvable, there are >>>>>>>>>>>> partial solutions
to the halting problem. In particular, every counter-example >>>>>>>>>>>> to the
full solution is correctly solved by some partial deciders. >>>>>>>>>>>
Undecidability is misconception. Self-contradictory
expressions are correctly rejected as semantically
incoherent thus form no undecidability or incompleteness.
The misconception is yours. No expression in the language of the >>>>>>>> first
order group theory is self-contradictory. But the first order goupr >>>>>>>> theory is incomplete: it is impossible to prove that AB = BA is >>>>>>>> true
for every A and every B but it is also impossible to prove that >>>>>>>> AB = BA
is false for some A and some B.
All deciders essentially: Transform finite string
inputs by finite string transformation rules into
{Accept, Reject} values.
When a required result cannot be derived by applying
finite string transformation rules to actual finite
string inputs, then the required result exceeds the
scope of computation and must be rejected as an
incorrect requirement.
No, that does not follow. If a required result cannot be derived by >>>>>> appying a finite string transformation then the it it is
uncomputable.
Right. Outside the scope of computation. Requiring anything
outside the scope of computation is an incorrect requirement.
You can't determine whether the required result is computable before
you have the requirement.
*Computation and Undecidability*
https://philpapers.org/go.pl?aid=OLCCAU
We know that there does not exist any finite
string transformations that H can apply to its
input P to derive the halt status of any P
that does the opposite of whatever H returns.
Which only nmakes sense when the requirement that H must determine
whether the computation presented by its input halts has already
been presented.
*ChatGPT explains how and why I am correct*
*Reinterpretation of undecidability*
The example of P and H demonstrates that what is
often called “undecidable” is better understood as
ill-posed with respect to computable semantics.
When the specification is constrained to properties
detectable via finite simulation and finite pattern
recognition, computation proceeds normally and
correctly. Undecidability only appears when the
specification overreaches that boundary.
It tries to explain but it does not prove.
Its the same thing that I have been saying for years.
It is not that a universal halt decider cannot exist.
It is that an input that does the opposite of whatever
value the halt decider returns is non-well-founded
within proof-theoretic semantics.
On 1/12/2026 4:47 AM, Mikko wrote:
On 11/01/2026 16:24, Tristan Wibberley wrote:
On 11/01/2026 10:13, Mikko wrote:
On 10/01/2026 17:47, olcott wrote:
On 1/10/2026 2:23 AM, Mikko wrote:
No, that does not follow. If a required result cannot be derived by >>>>>> appying a finite string transformation then the it it is
uncomputable.
Right. Outside the scope of computation. Requiring anything
outside the scope of computation is an incorrect requirement.
You can't determine whether the required result is computable before
you have the requirement.
Right, it is /in/ scope for computer science... for the /ology/. Olcott
here uses "computation" to refer to the practice. You give the
requirement to the /ologist/ who correctly decides that it is not for
computation because it is not computable.
You two so often violently agree; I find it warming to the heart.
For pracitcal programming it is useful to know what is known to be
uncomputable in order to avoid wasting time in attemlpts to do the
impossible.
It f-cking nuts that after more than 2000 years
people still don't understand that self-contradictory
expressions: "This sentence is not true" have no
truth value. A smart high school student should have
figured this out 2000 years ago.
On 12/01/2026 16:43, olcott wrote:
On 1/12/2026 4:51 AM, Mikko wrote:
On 11/01/2026 16:23, olcott wrote:
On 1/11/2026 4:22 AM, Mikko wrote:
On 10/01/2026 17:47, olcott wrote:
On 1/10/2026 2:23 AM, Mikko wrote:It is a perfectly valid question to ask whther a particular
On 09/01/2026 17:52, olcott wrote:
On 1/9/2026 3:59 AM, Mikko wrote:
On 08/01/2026 16:22, olcott wrote:
On 1/8/2026 4:22 AM, Mikko wrote:
On 07/01/2026 13:54, olcott wrote:
On 1/7/2026 5:49 AM, Mikko wrote:Depends on whether the word "truth" is interpeted in the >>>>>>>>>>> standard
On 07/01/2026 06:44, olcott wrote:*if undecidability is correct then truth itself is broken* >>>>>>>>>>>
All deciders essentially: Transform finite string
inputs by finite string transformation rules into
{Accept, Reject} values.
The counter-example input to requires more than
can be derived from finite string transformation
rules applied to this specific input thus the
Halting Problem requires too much.
In a sense the halting problem asks too much: the problem >>>>>>>>>>>>> is proven to
be unsolvable. In another sense it asks too little: usually >>>>>>>>>>>>> we want to
know whether a method halts on every input, not just one. >>>>>>>>>>>>>
Although the halting problem is unsolvable, there are >>>>>>>>>>>>> partial solutions
to the halting problem. In particular, every counter- >>>>>>>>>>>>> example to the
full solution is correctly solved by some partial deciders. >>>>>>>>>>>>
sense or in Olcott's sense.
Undecidability is misconception. Self-contradictory
expressions are correctly rejected as semantically
incoherent thus form no undecidability or incompleteness.
The misconception is yours. No expression in the language of >>>>>>>>> the first
order group theory is self-contradictory. But the first order >>>>>>>>> goupr
theory is incomplete: it is impossible to prove that AB = BA is >>>>>>>>> true
for every A and every B but it is also impossible to prove that >>>>>>>>> AB = BA
is false for some A and some B.
All deciders essentially: Transform finite string
inputs by finite string transformation rules into
{Accept, Reject} values.
When a required result cannot be derived by applying
finite string transformation rules to actual finite
string inputs, then the required result exceeds the
scope of computation and must be rejected as an
incorrect requirement.
No, that does not follow. If a required result cannot be derived by >>>>>>> appying a finite string transformation then the it it is
uncomputable.
Right. Outside the scope of computation. Requiring anything
outside the scope of computation is an incorrect requirement.
Of course, it one can prove that the required result is not
computable
then that helps to avoid wasting effort to try the impossible. The >>>>>>> situation is worse if it is not known that the required result is >>>>>>> not
computable.
That something is not computable does not mean that there is anyting >>>>>>> "incorrect" in the requirement.
Yes it certainly does. Requiring the impossible is always an error. >>>>>
reuqirement
is satisfiable.
Any yes/no question lacking a correct yes/no answer
is an incorrect question that must be rejected on
that basis.
Irrelevant. The question whether a particular requirement is satisfiable >>> does have an answer that is either "yes" or "no". In some ases it is
not known whether it is "yes" or "no" and there may be no known way to
find out be even then either "yes" or "no" is the correct answer.
Now that I finally have the standard terminology:
Proof-theoretic semantics has always been the correct
formal system to handle decision problems.
When it is asked a yes/no question lacking a correct
yes/no answer it correctly determines non-well-founded.
I have been correct all along and merely lacked the
standard terminology.
Irrelevant, as already noted above.
On 12/01/2026 16:29, olcott wrote:
On 1/12/2026 4:44 AM, Mikko wrote:
On 11/01/2026 16:18, olcott wrote:
On 1/11/2026 4:13 AM, Mikko wrote:
On 10/01/2026 17:47, olcott wrote:
On 1/10/2026 2:23 AM, Mikko wrote:
On 09/01/2026 17:52, olcott wrote:
On 1/9/2026 3:59 AM, Mikko wrote:
On 08/01/2026 16:22, olcott wrote:
On 1/8/2026 4:22 AM, Mikko wrote:
On 07/01/2026 13:54, olcott wrote:
On 1/7/2026 5:49 AM, Mikko wrote:Depends on whether the word "truth" is interpeted in the >>>>>>>>>>> standard
On 07/01/2026 06:44, olcott wrote:*if undecidability is correct then truth itself is broken* >>>>>>>>>>>
All deciders essentially: Transform finite string
inputs by finite string transformation rules into
{Accept, Reject} values.
The counter-example input to requires more than
can be derived from finite string transformation
rules applied to this specific input thus the
Halting Problem requires too much.
In a sense the halting problem asks too much: the problem >>>>>>>>>>>>> is proven to
be unsolvable. In another sense it asks too little: usually >>>>>>>>>>>>> we want to
know whether a method halts on every input, not just one. >>>>>>>>>>>>>
Although the halting problem is unsolvable, there are >>>>>>>>>>>>> partial solutions
to the halting problem. In particular, every counter- >>>>>>>>>>>>> example to the
full solution is correctly solved by some partial deciders. >>>>>>>>>>>>
sense or in Olcott's sense.
Undecidability is misconception. Self-contradictory
expressions are correctly rejected as semantically
incoherent thus form no undecidability or incompleteness.
The misconception is yours. No expression in the language of >>>>>>>>> the first
order group theory is self-contradictory. But the first order >>>>>>>>> goupr
theory is incomplete: it is impossible to prove that AB = BA is >>>>>>>>> true
for every A and every B but it is also impossible to prove that >>>>>>>>> AB = BA
is false for some A and some B.
All deciders essentially: Transform finite string
inputs by finite string transformation rules into
{Accept, Reject} values.
When a required result cannot be derived by applying
finite string transformation rules to actual finite
string inputs, then the required result exceeds the
scope of computation and must be rejected as an
incorrect requirement.
No, that does not follow. If a required result cannot be derived by >>>>>>> appying a finite string transformation then the it it is
uncomputable.
Right. Outside the scope of computation. Requiring anything
outside the scope of computation is an incorrect requirement.
You can't determine whether the required result is computable before >>>>> you have the requirement.
*Computation and Undecidability*
https://philpapers.org/go.pl?aid=OLCCAU
We know that there does not exist any finite
string transformations that H can apply to its
input P to derive the halt status of any P
that does the opposite of whatever H returns.
Which only nmakes sense when the requirement that H must determine
whether the computation presented by its input halts has already
been presented.
*ChatGPT explains how and why I am correct*
*Reinterpretation of undecidability*
The example of P and H demonstrates that what is
often called “undecidable” is better understood as
ill-posed with respect to computable semantics.
When the specification is constrained to properties
detectable via finite simulation and finite pattern
recognition, computation proceeds normally and
correctly. Undecidability only appears when the
specification overreaches that boundary.
It tries to explain but it does not prove.
Its the same thing that I have been saying for years.
It is not that a universal halt decider cannot exist.
It is proven that an universal halt decider does not exist.
A Turing
machine cannot determine the halting of all Turing machines and is
therefore not an universla halt decider.
An oracle machine may be
able to determine the haltinf of all Turing machines but not of all
oracle machines with the same oracle (or oracles) so it is not
universal.
It is that an input that does the opposite of whatever
value the halt decider returns is non-well-founded
within proof-theoretic semantics.
Yes, it is. What the "halt decider" returns is determinable: just run
it and see what it returns. From that the rest can be proven with a
well founded proof. In particular, there is a well-founded proof that
the "halt decider" is not a halt decider.
On 12/01/2026 16:32, olcott wrote:
On 1/12/2026 4:47 AM, Mikko wrote:
On 11/01/2026 16:24, Tristan Wibberley wrote:
On 11/01/2026 10:13, Mikko wrote:
On 10/01/2026 17:47, olcott wrote:
On 1/10/2026 2:23 AM, Mikko wrote:
No, that does not follow. If a required result cannot be derived by >>>>>>> appying a finite string transformation then the it it is
uncomputable.
Right. Outside the scope of computation. Requiring anything
outside the scope of computation is an incorrect requirement.
You can't determine whether the required result is computable before >>>>> you have the requirement.
Right, it is /in/ scope for computer science... for the /ology/. Olcott >>>> here uses "computation" to refer to the practice. You give the
requirement to the /ologist/ who correctly decides that it is not for
computation because it is not computable.
You two so often violently agree; I find it warming to the heart.
For pracitcal programming it is useful to know what is known to be
uncomputable in order to avoid wasting time in attemlpts to do the
impossible.
It f-cking nuts that after more than 2000 years
people still don't understand that self-contradictory
expressions: "This sentence is not true" have no
truth value. A smart high school student should have
figured this out 2000 years ago.
Irrelevant. For practical programming that question needn't be answered.
On 13/01/2026 09:11, Mikko wrote:
An oracle machine may be
able to determine the haltinf of all Turing machines but not of all
oracle machines with the same oracle (or oracles) so it is not
universal.
What's the formal definition of "an oracle machine" ?
I would have thought an oracle always halts because it's an oracle it
answers every question that has an answer with either "HasAnswer answer"
or "HasNoAnswer".
On 1/13/2026 8:23 AM, Tristan Wibberley wrote:
On 13/01/2026 09:11, Mikko wrote:
An oracle machine may be
able to determine the haltinf of all Turing machines but not of all
oracle machines with the same oracle (or oracles) so it is not
universal.
What's the formal definition of "an oracle machine" ?
I would have thought an oracle always halts because it's an oracle it
answers every question that has an answer with either "HasAnswer answer"
or "HasNoAnswer".
It seems outside of computer science and into fantasy. https://en.wikipedia.org/wiki/Oracle_machine
On 13/01/2026 14:34, olcott wrote:
On 1/13/2026 8:23 AM, Tristan Wibberley wrote:
On 13/01/2026 09:11, Mikko wrote:
An oracle machine may be
able to determine the haltinf of all Turing machines but not of all
oracle machines with the same oracle (or oracles) so it is not
universal.
What's the formal definition of "an oracle machine" ?
I would have thought an oracle always halts because it's an oracle it
answers every question that has an answer with either "HasAnswer answer" >>> or "HasNoAnswer".
It seems outside of computer science and into fantasy.
https://en.wikipedia.org/wiki/Oracle_machine
Perhaps a halting oracle is real computer science, if it's own actions
are nondeterministic (ie, use bits of entropy from the environment via /dev/random to guide its search through confluent paths) then it could
always find whether a deterministic program halts because no
deterministic program has the oracle as a subprogram.
Then we have a new but different problem of making sure no two oracles receive the same sequence of entropy bits so an oracle can report on a program that contains it.
On 1/13/2026 3:11 AM, Mikko wrote:
On 12/01/2026 16:29, olcott wrote:
On 1/12/2026 4:44 AM, Mikko wrote:
On 11/01/2026 16:18, olcott wrote:
On 1/11/2026 4:13 AM, Mikko wrote:
On 10/01/2026 17:47, olcott wrote:
On 1/10/2026 2:23 AM, Mikko wrote:
On 09/01/2026 17:52, olcott wrote:
On 1/9/2026 3:59 AM, Mikko wrote:
On 08/01/2026 16:22, olcott wrote:
On 1/8/2026 4:22 AM, Mikko wrote:The misconception is yours. No expression in the language of >>>>>>>>>> the first
On 07/01/2026 13:54, olcott wrote:
On 1/7/2026 5:49 AM, Mikko wrote:Depends on whether the word "truth" is interpeted in the >>>>>>>>>>>> standard
On 07/01/2026 06:44, olcott wrote:*if undecidability is correct then truth itself is broken* >>>>>>>>>>>>
All deciders essentially: Transform finite string >>>>>>>>>>>>>>> inputs by finite string transformation rules into >>>>>>>>>>>>>>> {Accept, Reject} values.
The counter-example input to requires more than
can be derived from finite string transformation >>>>>>>>>>>>>>> rules applied to this specific input thus the
Halting Problem requires too much.
In a sense the halting problem asks too much: the problem >>>>>>>>>>>>>> is proven to
be unsolvable. In another sense it asks too little: >>>>>>>>>>>>>> usually we want to
know whether a method halts on every input, not just one. >>>>>>>>>>>>>>
Although the halting problem is unsolvable, there are >>>>>>>>>>>>>> partial solutions
to the halting problem. In particular, every counter- >>>>>>>>>>>>>> example to the
full solution is correctly solved by some partial deciders. >>>>>>>>>>>>>
sense or in Olcott's sense.
Undecidability is misconception. Self-contradictory
expressions are correctly rejected as semantically
incoherent thus form no undecidability or incompleteness. >>>>>>>>>>
order group theory is self-contradictory. But the first order >>>>>>>>>> goupr
theory is incomplete: it is impossible to prove that AB = BA >>>>>>>>>> is true
for every A and every B but it is also impossible to prove >>>>>>>>>> that AB = BA
is false for some A and some B.
All deciders essentially: Transform finite string
inputs by finite string transformation rules into
{Accept, Reject} values.
When a required result cannot be derived by applying
finite string transformation rules to actual finite
string inputs, then the required result exceeds the
scope of computation and must be rejected as an
incorrect requirement.
No, that does not follow. If a required result cannot be derived by >>>>>>>> appying a finite string transformation then the it it is
uncomputable.
Right. Outside the scope of computation. Requiring anything
outside the scope of computation is an incorrect requirement.
You can't determine whether the required result is computable before >>>>>> you have the requirement.
*Computation and Undecidability*
https://philpapers.org/go.pl?aid=OLCCAU
We know that there does not exist any finite
string transformations that H can apply to its
input P to derive the halt status of any P
that does the opposite of whatever H returns.
Which only nmakes sense when the requirement that H must determine
whether the computation presented by its input halts has already
been presented.
*ChatGPT explains how and why I am correct*
*Reinterpretation of undecidability*
The example of P and H demonstrates that what is
often called “undecidable” is better understood as
ill-posed with respect to computable semantics.
When the specification is constrained to properties
detectable via finite simulation and finite pattern
recognition, computation proceeds normally and
correctly. Undecidability only appears when the
specification overreaches that boundary.
It tries to explain but it does not prove.
Its the same thing that I have been saying for years.
It is not that a universal halt decider cannot exist.
It is proven that an universal halt decider does not exist.
“The system adopts Proof-Theoretic Semantics: meaning is determined by inferential role, and truth is internal to the theory. A theory T is
defined by a finite set of stipulated atomic statements together with
all expressions derivable from them under the inference rules. The statements belonging to T constitute its theorems, and these are exactly
the statements that are true-in-T.”
Under a system like the above rough draft all inputs
having pathological self reference such as the halting
problem counter-example input are simply rejected as
non-well-founded. Tarski Undefinability, Gödel's
incompleteness and the halting problem cease to exist.
A Turing
machine cannot determine the halting of all Turing machines and is
therefore not an universla halt decider.
This is not true in Proof Theoretic Semantics. I
still have to refine my words. I may not have said
that exactly correctly. The result is that in Proof
Theoretic Semantics the counter-example is rejected
as non-well-founded.
On 1/13/2026 2:46 AM, Mikko wrote:Yes, it is. How to handle questions that lack a yes/no answer is
On 12/01/2026 16:43, olcott wrote:
On 1/12/2026 4:51 AM, Mikko wrote:
On 11/01/2026 16:23, olcott wrote:
On 1/11/2026 4:22 AM, Mikko wrote:
On 10/01/2026 17:47, olcott wrote:
On 1/10/2026 2:23 AM, Mikko wrote:It is a perfectly valid question to ask whther a particular
On 09/01/2026 17:52, olcott wrote:
On 1/9/2026 3:59 AM, Mikko wrote:
On 08/01/2026 16:22, olcott wrote:
On 1/8/2026 4:22 AM, Mikko wrote:The misconception is yours. No expression in the language of >>>>>>>>>> the first
On 07/01/2026 13:54, olcott wrote:
On 1/7/2026 5:49 AM, Mikko wrote:Depends on whether the word "truth" is interpeted in the >>>>>>>>>>>> standard
On 07/01/2026 06:44, olcott wrote:*if undecidability is correct then truth itself is broken* >>>>>>>>>>>>
All deciders essentially: Transform finite string >>>>>>>>>>>>>>> inputs by finite string transformation rules into >>>>>>>>>>>>>>> {Accept, Reject} values.
The counter-example input to requires more than
can be derived from finite string transformation >>>>>>>>>>>>>>> rules applied to this specific input thus the
Halting Problem requires too much.
In a sense the halting problem asks too much: the problem >>>>>>>>>>>>>> is proven to
be unsolvable. In another sense it asks too little: >>>>>>>>>>>>>> usually we want to
know whether a method halts on every input, not just one. >>>>>>>>>>>>>>
Although the halting problem is unsolvable, there are >>>>>>>>>>>>>> partial solutions
to the halting problem. In particular, every counter- >>>>>>>>>>>>>> example to the
full solution is correctly solved by some partial deciders. >>>>>>>>>>>>>
sense or in Olcott's sense.
Undecidability is misconception. Self-contradictory
expressions are correctly rejected as semantically
incoherent thus form no undecidability or incompleteness. >>>>>>>>>>
order group theory is self-contradictory. But the first order >>>>>>>>>> goupr
theory is incomplete: it is impossible to prove that AB = BA >>>>>>>>>> is true
for every A and every B but it is also impossible to prove >>>>>>>>>> that AB = BA
is false for some A and some B.
All deciders essentially: Transform finite string
inputs by finite string transformation rules into
{Accept, Reject} values.
When a required result cannot be derived by applying
finite string transformation rules to actual finite
string inputs, then the required result exceeds the
scope of computation and must be rejected as an
incorrect requirement.
No, that does not follow. If a required result cannot be derived by >>>>>>>> appying a finite string transformation then the it it is
uncomputable.
Right. Outside the scope of computation. Requiring anything
outside the scope of computation is an incorrect requirement.
Of course, it one can prove that the required result is not
computable
then that helps to avoid wasting effort to try the impossible. The >>>>>>>> situation is worse if it is not known that the required result >>>>>>>> is not
computable.
That something is not computable does not mean that there is
anyting
"incorrect" in the requirement.
Yes it certainly does. Requiring the impossible is always an error. >>>>>>
reuqirement
is satisfiable.
Any yes/no question lacking a correct yes/no answer
is an incorrect question that must be rejected on
that basis.
Irrelevant. The question whether a particular requirement is
satisfiable
does have an answer that is either "yes" or "no". In some ases it is
not known whether it is "yes" or "no" and there may be no known way to >>>> find out be even then either "yes" or "no" is the correct answer.
Now that I finally have the standard terminology:
Proof-theoretic semantics has always been the correct
formal system to handle decision problems.
When it is asked a yes/no question lacking a correct
yes/no answer it correctly determines non-well-founded.
I have been correct all along and merely lacked the
standard terminology.
Irrelevant, as already noted above.
On 1/13/2026 8:23 AM, Tristan Wibberley wrote:
On 13/01/2026 09:11, Mikko wrote:
An oracle machine may be
able to determine the haltinf of all Turing machines but not of all
oracle machines with the same oracle (or oracles) so it is not
universal.
What's the formal definition of "an oracle machine" ?
I would have thought an oracle always halts because it's an oracle it
answers every question that has an answer with either "HasAnswer answer"
or "HasNoAnswer".
It seems outside of computer science and into fantasy. https://en.wikipedia.org/wiki/Oracle_machine
On 13/01/2026 14:34, olcott wrote:
On 1/13/2026 8:23 AM, Tristan Wibberley wrote:
On 13/01/2026 09:11, Mikko wrote:
An oracle machine may be
able to determine the haltinf of all Turing machines but not of all
oracle machines with the same oracle (or oracles) so it is not
universal.
What's the formal definition of "an oracle machine" ?
I would have thought an oracle always halts because it's an oracle it
answers every question that has an answer with either "HasAnswer answer" >>> or "HasNoAnswer".
It seems outside of computer science and into fantasy.
https://en.wikipedia.org/wiki/Oracle_machine
Perhaps a halting oracle is real computer science, if it's own actions
are nondeterministic (ie, use bits of entropy from the environment via /dev/random to guide its search through confluent paths) then it could
always find whether a deterministic program halts because no
deterministic program has the oracle as a subprogram.
Then we have a new but different problem of making sure no two oracles receive the same sequence of entropy bits so an oracle can report on a program that contains it.
On 1/13/2026 3:13 AM, Mikko wrote:
On 12/01/2026 16:32, olcott wrote:
On 1/12/2026 4:47 AM, Mikko wrote:
On 11/01/2026 16:24, Tristan Wibberley wrote:
On 11/01/2026 10:13, Mikko wrote:
On 10/01/2026 17:47, olcott wrote:
On 1/10/2026 2:23 AM, Mikko wrote:
No, that does not follow. If a required result cannot be derived by >>>>>>>> appying a finite string transformation then the it it is
uncomputable.
Right. Outside the scope of computation. Requiring anything
outside the scope of computation is an incorrect requirement.
You can't determine whether the required result is computable before >>>>>> you have the requirement.
Right, it is /in/ scope for computer science... for the /ology/.
Olcott
here uses "computation" to refer to the practice. You give the
requirement to the /ologist/ who correctly decides that it is not for >>>>> computation because it is not computable.
You two so often violently agree; I find it warming to the heart.
For pracitcal programming it is useful to know what is known to be
uncomputable in order to avoid wasting time in attemlpts to do the
impossible.
It f-cking nuts that after more than 2000 years
people still don't understand that self-contradictory
expressions: "This sentence is not true" have no
truth value. A smart high school student should have
figured this out 2000 years ago.
Irrelevant. For practical programming that question needn't be answered.
The halting problem counter-example input is anchored
in the Liar Paradox. Proof Theoretic Semantics rejects
those two and Gödel's incompleteness and a bunch more
as merely non-well-founded inputs.
On 1/13/2026 2:46 AM, Mikko wrote:
On 12/01/2026 16:43, olcott wrote:
On 1/12/2026 4:51 AM, Mikko wrote:
On 11/01/2026 16:23, olcott wrote:
On 1/11/2026 4:22 AM, Mikko wrote:
On 10/01/2026 17:47, olcott wrote:
On 1/10/2026 2:23 AM, Mikko wrote:It is a perfectly valid question to ask whther a particular
On 09/01/2026 17:52, olcott wrote:
On 1/9/2026 3:59 AM, Mikko wrote:
On 08/01/2026 16:22, olcott wrote:
On 1/8/2026 4:22 AM, Mikko wrote:The misconception is yours. No expression in the language of >>>>>>>>>> the first
On 07/01/2026 13:54, olcott wrote:
On 1/7/2026 5:49 AM, Mikko wrote:Depends on whether the word "truth" is interpeted in the >>>>>>>>>>>> standard
On 07/01/2026 06:44, olcott wrote:*if undecidability is correct then truth itself is broken* >>>>>>>>>>>>
All deciders essentially: Transform finite string >>>>>>>>>>>>>>> inputs by finite string transformation rules into >>>>>>>>>>>>>>> {Accept, Reject} values.
The counter-example input to requires more than
can be derived from finite string transformation >>>>>>>>>>>>>>> rules applied to this specific input thus the
Halting Problem requires too much.
In a sense the halting problem asks too much: the problem >>>>>>>>>>>>>> is proven to
be unsolvable. In another sense it asks too little: >>>>>>>>>>>>>> usually we want to
know whether a method halts on every input, not just one. >>>>>>>>>>>>>>
Although the halting problem is unsolvable, there are >>>>>>>>>>>>>> partial solutions
to the halting problem. In particular, every counter- >>>>>>>>>>>>>> example to the
full solution is correctly solved by some partial deciders. >>>>>>>>>>>>>
sense or in Olcott's sense.
Undecidability is misconception. Self-contradictory
expressions are correctly rejected as semantically
incoherent thus form no undecidability or incompleteness. >>>>>>>>>>
order group theory is self-contradictory. But the first order >>>>>>>>>> goupr
theory is incomplete: it is impossible to prove that AB = BA >>>>>>>>>> is true
for every A and every B but it is also impossible to prove >>>>>>>>>> that AB = BA
is false for some A and some B.
All deciders essentially: Transform finite string
inputs by finite string transformation rules into
{Accept, Reject} values.
When a required result cannot be derived by applying
finite string transformation rules to actual finite
string inputs, then the required result exceeds the
scope of computation and must be rejected as an
incorrect requirement.
No, that does not follow. If a required result cannot be derived by >>>>>>>> appying a finite string transformation then the it it is
uncomputable.
Right. Outside the scope of computation. Requiring anything
outside the scope of computation is an incorrect requirement.
Of course, it one can prove that the required result is not
computable
then that helps to avoid wasting effort to try the impossible. The >>>>>>>> situation is worse if it is not known that the required result >>>>>>>> is not
computable.
That something is not computable does not mean that there is
anyting
"incorrect" in the requirement.
Yes it certainly does. Requiring the impossible is always an error. >>>>>>
reuqirement
is satisfiable.
Any yes/no question lacking a correct yes/no answer
is an incorrect question that must be rejected on
that basis.
Irrelevant. The question whether a particular requirement is
satisfiable
does have an answer that is either "yes" or "no". In some ases it is
not known whether it is "yes" or "no" and there may be no known way to >>>> find out be even then either "yes" or "no" is the correct answer.
Now that I finally have the standard terminology:
Proof-theoretic semantics has always been the correct
formal system to handle decision problems.
When it is asked a yes/no question lacking a correct
yes/no answer it correctly determines non-well-founded.
I have been correct all along and merely lacked the
standard terminology.
Irrelevant, as already noted above.
It is not irrelevant at all. Most all of undecidability
cease to exist in this system:
Definition: An abstract machine with access to an "oracle"—a black box
that provides immediate answers to complex, even undecidable, problems
(like the Halting Problem). AKA a majick genie.
For a non-deterministic machine there are three possibilities: it may
halt always, sometimes, or never. THere is no oracle that can find the
right answer about every meachne that contains the same oracle.
On 13/01/2026 18:50, olcott wrote:
Definition: An abstract machine with access to an "oracle"—a black box
that provides immediate answers to complex, even undecidable, problems
(like the Halting Problem). AKA a majick genie.
What's it called when its almost an oracle but is arbitrarily slow?
On 13/01/2026 16:27, olcott wrote:
On 1/13/2026 3:11 AM, Mikko wrote:
On 12/01/2026 16:29, olcott wrote:
On 1/12/2026 4:44 AM, Mikko wrote:
On 11/01/2026 16:18, olcott wrote:
On 1/11/2026 4:13 AM, Mikko wrote:
On 10/01/2026 17:47, olcott wrote:
On 1/10/2026 2:23 AM, Mikko wrote:
On 09/01/2026 17:52, olcott wrote:
On 1/9/2026 3:59 AM, Mikko wrote:
On 08/01/2026 16:22, olcott wrote:
On 1/8/2026 4:22 AM, Mikko wrote:The misconception is yours. No expression in the language of >>>>>>>>>>> the first
On 07/01/2026 13:54, olcott wrote:
On 1/7/2026 5:49 AM, Mikko wrote:Depends on whether the word "truth" is interpeted in the >>>>>>>>>>>>> standard
On 07/01/2026 06:44, olcott wrote:*if undecidability is correct then truth itself is broken* >>>>>>>>>>>>>
All deciders essentially: Transform finite string >>>>>>>>>>>>>>>> inputs by finite string transformation rules into >>>>>>>>>>>>>>>> {Accept, Reject} values.
The counter-example input to requires more than >>>>>>>>>>>>>>>> can be derived from finite string transformation >>>>>>>>>>>>>>>> rules applied to this specific input thus the
Halting Problem requires too much.
In a sense the halting problem asks too much: the problem >>>>>>>>>>>>>>> is proven to
be unsolvable. In another sense it asks too little: >>>>>>>>>>>>>>> usually we want to
know whether a method halts on every input, not just one. >>>>>>>>>>>>>>>
Although the halting problem is unsolvable, there are >>>>>>>>>>>>>>> partial solutions
to the halting problem. In particular, every counter- >>>>>>>>>>>>>>> example to the
full solution is correctly solved by some partial deciders. >>>>>>>>>>>>>>
sense or in Olcott's sense.
Undecidability is misconception. Self-contradictory
expressions are correctly rejected as semantically
incoherent thus form no undecidability or incompleteness. >>>>>>>>>>>
order group theory is self-contradictory. But the first order >>>>>>>>>>> goupr
theory is incomplete: it is impossible to prove that AB = BA >>>>>>>>>>> is true
for every A and every B but it is also impossible to prove >>>>>>>>>>> that AB = BA
is false for some A and some B.
All deciders essentially: Transform finite string
inputs by finite string transformation rules into
{Accept, Reject} values.
When a required result cannot be derived by applying
finite string transformation rules to actual finite
string inputs, then the required result exceeds the
scope of computation and must be rejected as an
incorrect requirement.
No, that does not follow. If a required result cannot be
derived by
appying a finite string transformation then the it it is
uncomputable.
Right. Outside the scope of computation. Requiring anything
outside the scope of computation is an incorrect requirement.
You can't determine whether the required result is computable before >>>>>>> you have the requirement.
*Computation and Undecidability*
https://philpapers.org/go.pl?aid=OLCCAU
We know that there does not exist any finite
string transformations that H can apply to its
input P to derive the halt status of any P
that does the opposite of whatever H returns.
Which only nmakes sense when the requirement that H must determine
whether the computation presented by its input halts has already
been presented.
*ChatGPT explains how and why I am correct*
*Reinterpretation of undecidability*
The example of P and H demonstrates that what is
often called “undecidable” is better understood as
ill-posed with respect to computable semantics.
When the specification is constrained to properties
detectable via finite simulation and finite pattern
recognition, computation proceeds normally and
correctly. Undecidability only appears when the
specification overreaches that boundary.
It tries to explain but it does not prove.
Its the same thing that I have been saying for years.
It is not that a universal halt decider cannot exist.
It is proven that an universal halt decider does not exist.
“The system adopts Proof-Theoretic Semantics: meaning is determined by
inferential role, and truth is internal to the theory. A theory T is
defined by a finite set of stipulated atomic statements together with
all expressions derivable from them under the inference rules. The
statements belonging to T constitute its theorems, and these are
exactly the statements that are true-in-T.”
Under a system like the above rough draft all inputs
having pathological self reference such as the halting
problem counter-example input are simply rejected as
non-well-founded. Tarski Undefinability, Gödel's
incompleteness and the halting problem cease to exist.
A Turing
machine cannot determine the halting of all Turing machines and is
therefore not an universla halt decider.
This is not true in Proof Theoretic Semantics. I
still have to refine my words. I may not have said
that exactly correctly. The result is that in Proof
Theoretic Semantics the counter-example is rejected
as non-well-founded.
That no Turing machine is a halt decider is a proven theorem and a
truth about Turing machines. If your "Proof Thoeretic Semnatics"
does not regard it as true then your "Proof Theoretic Semantics"
is incomplete.
On 13/01/2026 16:17, olcott wrote:
On 1/13/2026 2:46 AM, Mikko wrote:Yes, it is. How to handle questions that lack a yes/no answer is
On 12/01/2026 16:43, olcott wrote:
On 1/12/2026 4:51 AM, Mikko wrote:
On 11/01/2026 16:23, olcott wrote:
On 1/11/2026 4:22 AM, Mikko wrote:
On 10/01/2026 17:47, olcott wrote:
On 1/10/2026 2:23 AM, Mikko wrote:It is a perfectly valid question to ask whther a particular
On 09/01/2026 17:52, olcott wrote:
On 1/9/2026 3:59 AM, Mikko wrote:
On 08/01/2026 16:22, olcott wrote:
On 1/8/2026 4:22 AM, Mikko wrote:The misconception is yours. No expression in the language of >>>>>>>>>>> the first
On 07/01/2026 13:54, olcott wrote:
On 1/7/2026 5:49 AM, Mikko wrote:Depends on whether the word "truth" is interpeted in the >>>>>>>>>>>>> standard
On 07/01/2026 06:44, olcott wrote:*if undecidability is correct then truth itself is broken* >>>>>>>>>>>>>
All deciders essentially: Transform finite string >>>>>>>>>>>>>>>> inputs by finite string transformation rules into >>>>>>>>>>>>>>>> {Accept, Reject} values.
The counter-example input to requires more than >>>>>>>>>>>>>>>> can be derived from finite string transformation >>>>>>>>>>>>>>>> rules applied to this specific input thus the
Halting Problem requires too much.
In a sense the halting problem asks too much: the problem >>>>>>>>>>>>>>> is proven to
be unsolvable. In another sense it asks too little: >>>>>>>>>>>>>>> usually we want to
know whether a method halts on every input, not just one. >>>>>>>>>>>>>>>
Although the halting problem is unsolvable, there are >>>>>>>>>>>>>>> partial solutions
to the halting problem. In particular, every counter- >>>>>>>>>>>>>>> example to the
full solution is correctly solved by some partial deciders. >>>>>>>>>>>>>>
sense or in Olcott's sense.
Undecidability is misconception. Self-contradictory
expressions are correctly rejected as semantically
incoherent thus form no undecidability or incompleteness. >>>>>>>>>>>
order group theory is self-contradictory. But the first order >>>>>>>>>>> goupr
theory is incomplete: it is impossible to prove that AB = BA >>>>>>>>>>> is true
for every A and every B but it is also impossible to prove >>>>>>>>>>> that AB = BA
is false for some A and some B.
All deciders essentially: Transform finite string
inputs by finite string transformation rules into
{Accept, Reject} values.
When a required result cannot be derived by applying
finite string transformation rules to actual finite
string inputs, then the required result exceeds the
scope of computation and must be rejected as an
incorrect requirement.
No, that does not follow. If a required result cannot be
derived by
appying a finite string transformation then the it it is
uncomputable.
Right. Outside the scope of computation. Requiring anything
outside the scope of computation is an incorrect requirement.
Of course, it one can prove that the required result is not >>>>>>>>> computable
then that helps to avoid wasting effort to try the impossible. The >>>>>>>>> situation is worse if it is not known that the required result >>>>>>>>> is not
computable.
That something is not computable does not mean that there is >>>>>>>>> anyting
"incorrect" in the requirement.
Yes it certainly does. Requiring the impossible is always an error. >>>>>>>
reuqirement
is satisfiable.
Any yes/no question lacking a correct yes/no answer
is an incorrect question that must be rejected on
that basis.
Irrelevant. The question whether a particular requirement is
satisfiable
does have an answer that is either "yes" or "no". In some ases it is >>>>> not known whether it is "yes" or "no" and there may be no known way to >>>>> find out be even then either "yes" or "no" is the correct answer.
Now that I finally have the standard terminology:
Proof-theoretic semantics has always been the correct
formal system to handle decision problems.
When it is asked a yes/no question lacking a correct
yes/no answer it correctly determines non-well-founded.
I have been correct all along and merely lacked the
standard terminology.
Irrelevant, as already noted above.
irrelevant when discussing questions that do have a yes/no asnwer.
Whether a particular requirement is satisriable always has a yes/no
answer, so it is irrelevat how to handle questions that don't.
On 13/01/2026 16:31, olcott wrote:
On 1/13/2026 3:13 AM, Mikko wrote:
On 12/01/2026 16:32, olcott wrote:
On 1/12/2026 4:47 AM, Mikko wrote:
On 11/01/2026 16:24, Tristan Wibberley wrote:
On 11/01/2026 10:13, Mikko wrote:
On 10/01/2026 17:47, olcott wrote:
On 1/10/2026 2:23 AM, Mikko wrote:
No, that does not follow. If a required result cannot be
derived by
appying a finite string transformation then the it it is
uncomputable.
Right. Outside the scope of computation. Requiring anything
outside the scope of computation is an incorrect requirement.
You can't determine whether the required result is computable before >>>>>>> you have the requirement.
Right, it is /in/ scope for computer science... for the /ology/.
Olcott
here uses "computation" to refer to the practice. You give the
requirement to the /ologist/ who correctly decides that it is not for >>>>>> computation because it is not computable.
You two so often violently agree; I find it warming to the heart.
For pracitcal programming it is useful to know what is known to be
uncomputable in order to avoid wasting time in attemlpts to do the
impossible.
It f-cking nuts that after more than 2000 years
people still don't understand that self-contradictory
expressions: "This sentence is not true" have no
truth value. A smart high school student should have
figured this out 2000 years ago.
Irrelevant. For practical programming that question needn't be answered.
The halting problem counter-example input is anchored
in the Liar Paradox. Proof Theoretic Semantics rejects
those two and Gödel's incompleteness and a bunch more
as merely non-well-founded inputs.
For every Turing machine the halting problem counter-example provably
exists.
From the existence of the counter-example it is provable that
the first Turing machine is not a halting decider. With universal quationfication follows that no Turing machine is a halting decider.
Besides, there are other ways to prove that halting is not Turing
decidable.
On 13/01/2026 16:17, olcott wrote:
On 1/13/2026 2:46 AM, Mikko wrote:
On 12/01/2026 16:43, olcott wrote:
On 1/12/2026 4:51 AM, Mikko wrote:
On 11/01/2026 16:23, olcott wrote:
On 1/11/2026 4:22 AM, Mikko wrote:
On 10/01/2026 17:47, olcott wrote:
On 1/10/2026 2:23 AM, Mikko wrote:It is a perfectly valid question to ask whther a particular
On 09/01/2026 17:52, olcott wrote:
On 1/9/2026 3:59 AM, Mikko wrote:
On 08/01/2026 16:22, olcott wrote:
On 1/8/2026 4:22 AM, Mikko wrote:The misconception is yours. No expression in the language of >>>>>>>>>>> the first
On 07/01/2026 13:54, olcott wrote:
On 1/7/2026 5:49 AM, Mikko wrote:Depends on whether the word "truth" is interpeted in the >>>>>>>>>>>>> standard
On 07/01/2026 06:44, olcott wrote:*if undecidability is correct then truth itself is broken* >>>>>>>>>>>>>
All deciders essentially: Transform finite string >>>>>>>>>>>>>>>> inputs by finite string transformation rules into >>>>>>>>>>>>>>>> {Accept, Reject} values.
The counter-example input to requires more than >>>>>>>>>>>>>>>> can be derived from finite string transformation >>>>>>>>>>>>>>>> rules applied to this specific input thus the
Halting Problem requires too much.
In a sense the halting problem asks too much: the problem >>>>>>>>>>>>>>> is proven to
be unsolvable. In another sense it asks too little: >>>>>>>>>>>>>>> usually we want to
know whether a method halts on every input, not just one. >>>>>>>>>>>>>>>
Although the halting problem is unsolvable, there are >>>>>>>>>>>>>>> partial solutions
to the halting problem. In particular, every counter- >>>>>>>>>>>>>>> example to the
full solution is correctly solved by some partial deciders. >>>>>>>>>>>>>>
sense or in Olcott's sense.
Undecidability is misconception. Self-contradictory
expressions are correctly rejected as semantically
incoherent thus form no undecidability or incompleteness. >>>>>>>>>>>
order group theory is self-contradictory. But the first order >>>>>>>>>>> goupr
theory is incomplete: it is impossible to prove that AB = BA >>>>>>>>>>> is true
for every A and every B but it is also impossible to prove >>>>>>>>>>> that AB = BA
is false for some A and some B.
All deciders essentially: Transform finite string
inputs by finite string transformation rules into
{Accept, Reject} values.
When a required result cannot be derived by applying
finite string transformation rules to actual finite
string inputs, then the required result exceeds the
scope of computation and must be rejected as an
incorrect requirement.
No, that does not follow. If a required result cannot be
derived by
appying a finite string transformation then the it it is
uncomputable.
Right. Outside the scope of computation. Requiring anything
outside the scope of computation is an incorrect requirement.
Of course, it one can prove that the required result is not >>>>>>>>> computable
then that helps to avoid wasting effort to try the impossible. The >>>>>>>>> situation is worse if it is not known that the required result >>>>>>>>> is not
computable.
That something is not computable does not mean that there is >>>>>>>>> anyting
"incorrect" in the requirement.
Yes it certainly does. Requiring the impossible is always an error. >>>>>>>
reuqirement
is satisfiable.
Any yes/no question lacking a correct yes/no answer
is an incorrect question that must be rejected on
that basis.
Irrelevant. The question whether a particular requirement is
satisfiable
does have an answer that is either "yes" or "no". In some ases it is >>>>> not known whether it is "yes" or "no" and there may be no known way to >>>>> find out be even then either "yes" or "no" is the correct answer.
Now that I finally have the standard terminology:
Proof-theoretic semantics has always been the correct
formal system to handle decision problems.
When it is asked a yes/no question lacking a correct
yes/no answer it correctly determines non-well-founded.
I have been correct all along and merely lacked the
standard terminology.
Irrelevant, as already noted above.
It is not irrelevant at all. Most all of undecidability
cease to exist in this system:
It does not help if the system is not sound. Or if the particuar undecidability that one happens to care about does not cease to
exist.
On 1/12/26 9:29 AM, olcott wrote:
On 1/12/2026 4:44 AM, Mikko wrote:
On 11/01/2026 16:18, olcott wrote:
On 1/11/2026 4:13 AM, Mikko wrote:
On 10/01/2026 17:47, olcott wrote:
On 1/10/2026 2:23 AM, Mikko wrote:
On 09/01/2026 17:52, olcott wrote:
On 1/9/2026 3:59 AM, Mikko wrote:
On 08/01/2026 16:22, olcott wrote:
On 1/8/2026 4:22 AM, Mikko wrote:
On 07/01/2026 13:54, olcott wrote:
On 1/7/2026 5:49 AM, Mikko wrote:Depends on whether the word "truth" is interpeted in the >>>>>>>>>>> standard
On 07/01/2026 06:44, olcott wrote:*if undecidability is correct then truth itself is broken* >>>>>>>>>>>
All deciders essentially: Transform finite string
inputs by finite string transformation rules into
{Accept, Reject} values.
The counter-example input to requires more than
can be derived from finite string transformation
rules applied to this specific input thus the
Halting Problem requires too much.
In a sense the halting problem asks too much: the problem >>>>>>>>>>>>> is proven to
be unsolvable. In another sense it asks too little: usually >>>>>>>>>>>>> we want to
know whether a method halts on every input, not just one. >>>>>>>>>>>>>
Although the halting problem is unsolvable, there are >>>>>>>>>>>>> partial solutions
to the halting problem. In particular, every counter- >>>>>>>>>>>>> example to the
full solution is correctly solved by some partial deciders. >>>>>>>>>>>>
sense or in Olcott's sense.
Undecidability is misconception. Self-contradictory
expressions are correctly rejected as semantically
incoherent thus form no undecidability or incompleteness.
The misconception is yours. No expression in the language of >>>>>>>>> the first
order group theory is self-contradictory. But the first order >>>>>>>>> goupr
theory is incomplete: it is impossible to prove that AB = BA is >>>>>>>>> true
for every A and every B but it is also impossible to prove that >>>>>>>>> AB = BA
is false for some A and some B.
All deciders essentially: Transform finite string
inputs by finite string transformation rules into
{Accept, Reject} values.
When a required result cannot be derived by applying
finite string transformation rules to actual finite
string inputs, then the required result exceeds the
scope of computation and must be rejected as an
incorrect requirement.
No, that does not follow. If a required result cannot be derived by >>>>>>> appying a finite string transformation then the it it is
uncomputable.
Right. Outside the scope of computation. Requiring anything
outside the scope of computation is an incorrect requirement.
You can't determine whether the required result is computable before >>>>> you have the requirement.
*Computation and Undecidability*
https://philpapers.org/go.pl?aid=OLCCAU
We know that there does not exist any finite
string transformations that H can apply to its
input P to derive the halt status of any P
that does the opposite of whatever H returns.
Which only nmakes sense when the requirement that H must determine
whether the computation presented by its input halts has already
been presented.
*ChatGPT explains how and why I am correct*
*Reinterpretation of undecidability*
The example of P and H demonstrates that what is
often called “undecidable” is better understood as
ill-posed with respect to computable semantics.
When the specification is constrained to properties
detectable via finite simulation and finite pattern
recognition, computation proceeds normally and
correctly. Undecidability only appears when the
specification overreaches that boundary.
It tries to explain but it does not prove.
Its the same thing that I have been saying for years.
It is not that a universal halt decider cannot exist.
It is that an input that does the opposite of whatever
value the halt decider returns is non-well-founded
within proof-theoretic semantics.
But the problem is that Computation is not a proof-theoretic semantic system, and thus those rules don't apply.
On 1/12/2026 9:19 PM, Richard Damon wrote:
On 1/12/26 9:29 AM, olcott wrote:
On 1/12/2026 4:44 AM, Mikko wrote:
On 11/01/2026 16:18, olcott wrote:
On 1/11/2026 4:13 AM, Mikko wrote:
On 10/01/2026 17:47, olcott wrote:
On 1/10/2026 2:23 AM, Mikko wrote:
On 09/01/2026 17:52, olcott wrote:
On 1/9/2026 3:59 AM, Mikko wrote:
On 08/01/2026 16:22, olcott wrote:
On 1/8/2026 4:22 AM, Mikko wrote:The misconception is yours. No expression in the language of >>>>>>>>>> the first
On 07/01/2026 13:54, olcott wrote:
On 1/7/2026 5:49 AM, Mikko wrote:Depends on whether the word "truth" is interpeted in the >>>>>>>>>>>> standard
On 07/01/2026 06:44, olcott wrote:*if undecidability is correct then truth itself is broken* >>>>>>>>>>>>
All deciders essentially: Transform finite string >>>>>>>>>>>>>>> inputs by finite string transformation rules into >>>>>>>>>>>>>>> {Accept, Reject} values.
The counter-example input to requires more than
can be derived from finite string transformation >>>>>>>>>>>>>>> rules applied to this specific input thus the
Halting Problem requires too much.
In a sense the halting problem asks too much: the problem >>>>>>>>>>>>>> is proven to
be unsolvable. In another sense it asks too little: >>>>>>>>>>>>>> usually we want to
know whether a method halts on every input, not just one. >>>>>>>>>>>>>>
Although the halting problem is unsolvable, there are >>>>>>>>>>>>>> partial solutions
to the halting problem. In particular, every counter- >>>>>>>>>>>>>> example to the
full solution is correctly solved by some partial deciders. >>>>>>>>>>>>>
sense or in Olcott's sense.
Undecidability is misconception. Self-contradictory
expressions are correctly rejected as semantically
incoherent thus form no undecidability or incompleteness. >>>>>>>>>>
order group theory is self-contradictory. But the first order >>>>>>>>>> goupr
theory is incomplete: it is impossible to prove that AB = BA >>>>>>>>>> is true
for every A and every B but it is also impossible to prove >>>>>>>>>> that AB = BA
is false for some A and some B.
All deciders essentially: Transform finite string
inputs by finite string transformation rules into
{Accept, Reject} values.
When a required result cannot be derived by applying
finite string transformation rules to actual finite
string inputs, then the required result exceeds the
scope of computation and must be rejected as an
incorrect requirement.
No, that does not follow. If a required result cannot be derived by >>>>>>>> appying a finite string transformation then the it it is
uncomputable.
Right. Outside the scope of computation. Requiring anything
outside the scope of computation is an incorrect requirement.
You can't determine whether the required result is computable before >>>>>> you have the requirement.
*Computation and Undecidability*
https://philpapers.org/go.pl?aid=OLCCAU
We know that there does not exist any finite
string transformations that H can apply to its
input P to derive the halt status of any P
that does the opposite of whatever H returns.
Which only nmakes sense when the requirement that H must determine
whether the computation presented by its input halts has already
been presented.
*ChatGPT explains how and why I am correct*
*Reinterpretation of undecidability*
The example of P and H demonstrates that what is
often called “undecidable” is better understood as
ill-posed with respect to computable semantics.
When the specification is constrained to properties
detectable via finite simulation and finite pattern
recognition, computation proceeds normally and
correctly. Undecidability only appears when the
specification overreaches that boundary.
It tries to explain but it does not prove.
Its the same thing that I have been saying for years.
It is not that a universal halt decider cannot exist.
It is that an input that does the opposite of whatever
value the halt decider returns is non-well-founded
within proof-theoretic semantics.
But the problem is that Computation is not a proof-theoretic semantic
system, and thus those rules don't apply.
The dumbed down version is that the halting problem asks
a question outside of the scope of finite string transformations.
The halting problem proof does not fail because finite computation
is too weak. It fails because it asks finite computation to
decide a judgment that is not finitely grounded under operational
semantics.
By operational semantics I mean the standard proof‑theoretic
account of program meaning, where execution judgments are
given by inference rules and termination corresponds to the
existence of a finite derivation.
By proof‑theoretic semantics I mean the approach in which the
meaning of a statement is determined by its rules of proof
rather than by truth conditions in an external model.
Operational semantics fits this pattern: programs have meaning
through their execution rules, not through abstract denotations.
By denotational semantics I mean any semantics that assigns
mathematical objects—functions, truth values, domains-to programs independently of how they are executed or proved. This contrasts
with operational or proof‑theoretic semantics, where meaning is
grounded in the structure of derivations rather than in an abstract mathematical object.
I use “denotational semantics” simply to refer to any framework
that assigns meanings independently of operational behavior.
On 1/14/2026 3:04 AM, Mikko wrote:
On 13/01/2026 16:17, olcott wrote:
On 1/13/2026 2:46 AM, Mikko wrote:
On 12/01/2026 16:43, olcott wrote:
On 1/12/2026 4:51 AM, Mikko wrote:
On 11/01/2026 16:23, olcott wrote:
On 1/11/2026 4:22 AM, Mikko wrote:
On 10/01/2026 17:47, olcott wrote:
On 1/10/2026 2:23 AM, Mikko wrote:
On 09/01/2026 17:52, olcott wrote:
On 1/9/2026 3:59 AM, Mikko wrote:
On 08/01/2026 16:22, olcott wrote:
On 1/8/2026 4:22 AM, Mikko wrote:The misconception is yours. No expression in the language of >>>>>>>>>>>> the first
On 07/01/2026 13:54, olcott wrote:
On 1/7/2026 5:49 AM, Mikko wrote:Depends on whether the word "truth" is interpeted in the >>>>>>>>>>>>>> standard
On 07/01/2026 06:44, olcott wrote:*if undecidability is correct then truth itself is broken* >>>>>>>>>>>>>>
All deciders essentially: Transform finite string >>>>>>>>>>>>>>>>> inputs by finite string transformation rules into >>>>>>>>>>>>>>>>> {Accept, Reject} values.
The counter-example input to requires more than >>>>>>>>>>>>>>>>> can be derived from finite string transformation >>>>>>>>>>>>>>>>> rules applied to this specific input thus the >>>>>>>>>>>>>>>>> Halting Problem requires too much.
In a sense the halting problem asks too much: the >>>>>>>>>>>>>>>> problem is proven to
be unsolvable. In another sense it asks too little: >>>>>>>>>>>>>>>> usually we want to
know whether a method halts on every input, not just one. >>>>>>>>>>>>>>>>
Although the halting problem is unsolvable, there are >>>>>>>>>>>>>>>> partial solutions
to the halting problem. In particular, every counter- >>>>>>>>>>>>>>>> example to the
full solution is correctly solved by some partial deciders. >>>>>>>>>>>>>>>
sense or in Olcott's sense.
Undecidability is misconception. Self-contradictory
expressions are correctly rejected as semantically
incoherent thus form no undecidability or incompleteness. >>>>>>>>>>>>
order group theory is self-contradictory. But the first >>>>>>>>>>>> order goupr
theory is incomplete: it is impossible to prove that AB = BA >>>>>>>>>>>> is true
for every A and every B but it is also impossible to prove >>>>>>>>>>>> that AB = BA
is false for some A and some B.
All deciders essentially: Transform finite string
inputs by finite string transformation rules into
{Accept, Reject} values.
When a required result cannot be derived by applying
finite string transformation rules to actual finite
string inputs, then the required result exceeds the
scope of computation and must be rejected as an
incorrect requirement.
No, that does not follow. If a required result cannot be
derived by
appying a finite string transformation then the it it is
uncomputable.
Right. Outside the scope of computation. Requiring anything
outside the scope of computation is an incorrect requirement. >>>>>>>>>
Of course, it one can prove that the required result is not >>>>>>>>>> computable
then that helps to avoid wasting effort to try the impossible. >>>>>>>>>> The
situation is worse if it is not known that the required result >>>>>>>>>> is not
computable.
That something is not computable does not mean that there is >>>>>>>>>> anyting
"incorrect" in the requirement.
Yes it certainly does. Requiring the impossible is always an >>>>>>>>> error.
It is a perfectly valid question to ask whther a particular
reuqirement
is satisfiable.
Any yes/no question lacking a correct yes/no answer
is an incorrect question that must be rejected on
that basis.
Irrelevant. The question whether a particular requirement is
satisfiable
does have an answer that is either "yes" or "no". In some ases it is >>>>>> not known whether it is "yes" or "no" and there may be no known
way to
find out be even then either "yes" or "no" is the correct answer.
Now that I finally have the standard terminology:
Proof-theoretic semantics has always been the correct
formal system to handle decision problems.
When it is asked a yes/no question lacking a correct
yes/no answer it correctly determines non-well-founded.
I have been correct all along and merely lacked the
standard terminology.
Irrelevant, as already noted above.
It is not irrelevant at all. Most all of undecidability
cease to exist in this system:
It does not help if the system is not sound. Or if the particuar
undecidability that one happens to care about does not cease to
exist.
Soundness is exactly why proof‑theoretic semantics matters here.
When meaning is grounded in inferential structure and truth is anchored
in an axiomatic base, only well‑founded expressions are admissible.
On 14/01/2026 08:53, Mikko wrote:
For a non-deterministic machine there are three possibilities: it may
halt always, sometimes, or never. THere is no oracle that can find the
right answer about every meachne that contains the same oracle.
We well into Turing c-machine territory here aren't we?
On 1/14/2026 3:01 AM, Mikko wrote:
On 13/01/2026 16:31, olcott wrote:
On 1/13/2026 3:13 AM, Mikko wrote:
On 12/01/2026 16:32, olcott wrote:
On 1/12/2026 4:47 AM, Mikko wrote:
On 11/01/2026 16:24, Tristan Wibberley wrote:
On 11/01/2026 10:13, Mikko wrote:For pracitcal programming it is useful to know what is known to be >>>>>> uncomputable in order to avoid wasting time in attemlpts to do the >>>>>> impossible.
On 10/01/2026 17:47, olcott wrote:
On 1/10/2026 2:23 AM, Mikko wrote:
You can't determine whether the required result is computable >>>>>>>> beforeNo, that does not follow. If a required result cannot be
derived by
appying a finite string transformation then the it it is
uncomputable.
Right. Outside the scope of computation. Requiring anything
outside the scope of computation is an incorrect requirement. >>>>>>>>
you have the requirement.
Right, it is /in/ scope for computer science... for the /ology/. >>>>>>> Olcott
here uses "computation" to refer to the practice. You give the
requirement to the /ologist/ who correctly decides that it is not >>>>>>> for
computation because it is not computable.
You two so often violently agree; I find it warming to the heart. >>>>>>
It f-cking nuts that after more than 2000 years
people still don't understand that self-contradictory
expressions: "This sentence is not true" have no
truth value. A smart high school student should have
figured this out 2000 years ago.
Irrelevant. For practical programming that question needn't be
answered.
The halting problem counter-example input is anchored
in the Liar Paradox. Proof Theoretic Semantics rejects
those two and Gödel's incompleteness and a bunch more
as merely non-well-founded inputs.
For every Turing machine the halting problem counter-example provably
exists.
Not when using Proof Theoretic Semantics grounded
in the specification language. In this case the
pathological input is simply rejected as ungrounded.
On 1/14/2026 1:58 AM, Mikko wrote:
On 13/01/2026 16:17, olcott wrote:
On 1/13/2026 2:46 AM, Mikko wrote:Yes, it is. How to handle questions that lack a yes/no answer is
On 12/01/2026 16:43, olcott wrote:
On 1/12/2026 4:51 AM, Mikko wrote:
On 11/01/2026 16:23, olcott wrote:
On 1/11/2026 4:22 AM, Mikko wrote:
On 10/01/2026 17:47, olcott wrote:
On 1/10/2026 2:23 AM, Mikko wrote:
On 09/01/2026 17:52, olcott wrote:
On 1/9/2026 3:59 AM, Mikko wrote:
On 08/01/2026 16:22, olcott wrote:
On 1/8/2026 4:22 AM, Mikko wrote:The misconception is yours. No expression in the language of >>>>>>>>>>>> the first
On 07/01/2026 13:54, olcott wrote:
On 1/7/2026 5:49 AM, Mikko wrote:Depends on whether the word "truth" is interpeted in the >>>>>>>>>>>>>> standard
On 07/01/2026 06:44, olcott wrote:*if undecidability is correct then truth itself is broken* >>>>>>>>>>>>>>
All deciders essentially: Transform finite string >>>>>>>>>>>>>>>>> inputs by finite string transformation rules into >>>>>>>>>>>>>>>>> {Accept, Reject} values.
The counter-example input to requires more than >>>>>>>>>>>>>>>>> can be derived from finite string transformation >>>>>>>>>>>>>>>>> rules applied to this specific input thus the >>>>>>>>>>>>>>>>> Halting Problem requires too much.
In a sense the halting problem asks too much: the >>>>>>>>>>>>>>>> problem is proven to
be unsolvable. In another sense it asks too little: >>>>>>>>>>>>>>>> usually we want to
know whether a method halts on every input, not just one. >>>>>>>>>>>>>>>>
Although the halting problem is unsolvable, there are >>>>>>>>>>>>>>>> partial solutions
to the halting problem. In particular, every counter- >>>>>>>>>>>>>>>> example to the
full solution is correctly solved by some partial deciders. >>>>>>>>>>>>>>>
sense or in Olcott's sense.
Undecidability is misconception. Self-contradictory
expressions are correctly rejected as semantically
incoherent thus form no undecidability or incompleteness. >>>>>>>>>>>>
order group theory is self-contradictory. But the first >>>>>>>>>>>> order goupr
theory is incomplete: it is impossible to prove that AB = BA >>>>>>>>>>>> is true
for every A and every B but it is also impossible to prove >>>>>>>>>>>> that AB = BA
is false for some A and some B.
All deciders essentially: Transform finite string
inputs by finite string transformation rules into
{Accept, Reject} values.
When a required result cannot be derived by applying
finite string transformation rules to actual finite
string inputs, then the required result exceeds the
scope of computation and must be rejected as an
incorrect requirement.
No, that does not follow. If a required result cannot be
derived by
appying a finite string transformation then the it it is
uncomputable.
Right. Outside the scope of computation. Requiring anything
outside the scope of computation is an incorrect requirement. >>>>>>>>>
Of course, it one can prove that the required result is not >>>>>>>>>> computable
then that helps to avoid wasting effort to try the impossible. >>>>>>>>>> The
situation is worse if it is not known that the required result >>>>>>>>>> is not
computable.
That something is not computable does not mean that there is >>>>>>>>>> anyting
"incorrect" in the requirement.
Yes it certainly does. Requiring the impossible is always an >>>>>>>>> error.
It is a perfectly valid question to ask whther a particular
reuqirement
is satisfiable.
Any yes/no question lacking a correct yes/no answer
is an incorrect question that must be rejected on
that basis.
Irrelevant. The question whether a particular requirement is
satisfiable
does have an answer that is either "yes" or "no". In some ases it is >>>>>> not known whether it is "yes" or "no" and there may be no known
way to
find out be even then either "yes" or "no" is the correct answer.
Now that I finally have the standard terminology:
Proof-theoretic semantics has always been the correct
formal system to handle decision problems.
When it is asked a yes/no question lacking a correct
yes/no answer it correctly determines non-well-founded.
I have been correct all along and merely lacked the
standard terminology.
Irrelevant, as already noted above.
irrelevant when discussing questions that do have a yes/no asnwer.
Whether a particular requirement is satisriable always has a yes/no
answer, so it is irrelevat how to handle questions that don't.
The classical diagonal argument for the Halting Problem asks a halt
decider H to evaluate a program D whose behavior depends on H’s own output.
On 1/14/2026 1:40 AM, Mikko wrote:
On 13/01/2026 16:27, olcott wrote:
On 1/13/2026 3:11 AM, Mikko wrote:
On 12/01/2026 16:29, olcott wrote:
On 1/12/2026 4:44 AM, Mikko wrote:
On 11/01/2026 16:18, olcott wrote:
On 1/11/2026 4:13 AM, Mikko wrote:
On 10/01/2026 17:47, olcott wrote:
On 1/10/2026 2:23 AM, Mikko wrote:You can't determine whether the required result is computable >>>>>>>> before
On 09/01/2026 17:52, olcott wrote:
On 1/9/2026 3:59 AM, Mikko wrote:
On 08/01/2026 16:22, olcott wrote:
On 1/8/2026 4:22 AM, Mikko wrote:The misconception is yours. No expression in the language of >>>>>>>>>>>> the first
On 07/01/2026 13:54, olcott wrote:
On 1/7/2026 5:49 AM, Mikko wrote:Depends on whether the word "truth" is interpeted in the >>>>>>>>>>>>>> standard
On 07/01/2026 06:44, olcott wrote:*if undecidability is correct then truth itself is broken* >>>>>>>>>>>>>>
All deciders essentially: Transform finite string >>>>>>>>>>>>>>>>> inputs by finite string transformation rules into >>>>>>>>>>>>>>>>> {Accept, Reject} values.
The counter-example input to requires more than >>>>>>>>>>>>>>>>> can be derived from finite string transformation >>>>>>>>>>>>>>>>> rules applied to this specific input thus the >>>>>>>>>>>>>>>>> Halting Problem requires too much.
In a sense the halting problem asks too much: the >>>>>>>>>>>>>>>> problem is proven to
be unsolvable. In another sense it asks too little: >>>>>>>>>>>>>>>> usually we want to
know whether a method halts on every input, not just one. >>>>>>>>>>>>>>>>
Although the halting problem is unsolvable, there are >>>>>>>>>>>>>>>> partial solutions
to the halting problem. In particular, every counter- >>>>>>>>>>>>>>>> example to the
full solution is correctly solved by some partial deciders. >>>>>>>>>>>>>>>
sense or in Olcott's sense.
Undecidability is misconception. Self-contradictory
expressions are correctly rejected as semantically
incoherent thus form no undecidability or incompleteness. >>>>>>>>>>>>
order group theory is self-contradictory. But the first >>>>>>>>>>>> order goupr
theory is incomplete: it is impossible to prove that AB = BA >>>>>>>>>>>> is true
for every A and every B but it is also impossible to prove >>>>>>>>>>>> that AB = BA
is false for some A and some B.
All deciders essentially: Transform finite string
inputs by finite string transformation rules into
{Accept, Reject} values.
When a required result cannot be derived by applying
finite string transformation rules to actual finite
string inputs, then the required result exceeds the
scope of computation and must be rejected as an
incorrect requirement.
No, that does not follow. If a required result cannot be
derived by
appying a finite string transformation then the it it is
uncomputable.
Right. Outside the scope of computation. Requiring anything
outside the scope of computation is an incorrect requirement. >>>>>>>>
you have the requirement.
*Computation and Undecidability*
https://philpapers.org/go.pl?aid=OLCCAU
We know that there does not exist any finite
string transformations that H can apply to its
input P to derive the halt status of any P
that does the opposite of whatever H returns.
Which only nmakes sense when the requirement that H must determine >>>>>> whether the computation presented by its input halts has already
been presented.
*ChatGPT explains how and why I am correct*
*Reinterpretation of undecidability*
The example of P and H demonstrates that what is
often called “undecidable” is better understood as
ill-posed with respect to computable semantics.
When the specification is constrained to properties
detectable via finite simulation and finite pattern
recognition, computation proceeds normally and
correctly. Undecidability only appears when the
specification overreaches that boundary.
It tries to explain but it does not prove.
Its the same thing that I have been saying for years.
It is not that a universal halt decider cannot exist.
It is proven that an universal halt decider does not exist.
“The system adopts Proof-Theoretic Semantics: meaning is determined
by inferential role, and truth is internal to the theory. A theory T
is defined by a finite set of stipulated atomic statements together
with all expressions derivable from them under the inference rules.
The statements belonging to T constitute its theorems, and these are
exactly the statements that are true-in-T.”
Under a system like the above rough draft all inputs
having pathological self reference such as the halting
problem counter-example input are simply rejected as
non-well-founded. Tarski Undefinability, Gödel's
incompleteness and the halting problem cease to exist.
A Turing
machine cannot determine the halting of all Turing machines and is
therefore not an universla halt decider.
This is not true in Proof Theoretic Semantics. I
still have to refine my words. I may not have said
that exactly correctly. The result is that in Proof
Theoretic Semantics the counter-example is rejected
as non-well-founded.
That no Turing machine is a halt decider is a proven theorem and a
truth about Turing machines. If your "Proof Thoeretic Semnatics"
does not regard it as true then your "Proof Theoretic Semantics"
is incomplete.
My long‑term goal is to make ‘true on the basis of meaning’ computable.
A system is useful only if admissibility is computable with a known algorithm.
On 1/14/26 8:25 PM, olcott wrote:
By operational semantics I mean the standard proof‑theoretic
account of program meaning, where execution judgments are
given by inference rules and termination corresponds to the
existence of a finite derivation.
Which is just incorrect. Since infinite derivation has meaning in the
field.
On 1/14/26 8:25 PM, olcott wrote:
On 1/12/2026 9:19 PM, Richard Damon wrote:
On 1/12/26 9:29 AM, olcott wrote:
On 1/12/2026 4:44 AM, Mikko wrote:
On 11/01/2026 16:18, olcott wrote:
On 1/11/2026 4:13 AM, Mikko wrote:
On 10/01/2026 17:47, olcott wrote:
On 1/10/2026 2:23 AM, Mikko wrote:
On 09/01/2026 17:52, olcott wrote:
On 1/9/2026 3:59 AM, Mikko wrote:
On 08/01/2026 16:22, olcott wrote:
On 1/8/2026 4:22 AM, Mikko wrote:The misconception is yours. No expression in the language of >>>>>>>>>>> the first
On 07/01/2026 13:54, olcott wrote:
On 1/7/2026 5:49 AM, Mikko wrote:Depends on whether the word "truth" is interpeted in the >>>>>>>>>>>>> standard
On 07/01/2026 06:44, olcott wrote:*if undecidability is correct then truth itself is broken* >>>>>>>>>>>>>
All deciders essentially: Transform finite string >>>>>>>>>>>>>>>> inputs by finite string transformation rules into >>>>>>>>>>>>>>>> {Accept, Reject} values.
The counter-example input to requires more than >>>>>>>>>>>>>>>> can be derived from finite string transformation >>>>>>>>>>>>>>>> rules applied to this specific input thus the
Halting Problem requires too much.
In a sense the halting problem asks too much: the problem >>>>>>>>>>>>>>> is proven to
be unsolvable. In another sense it asks too little: >>>>>>>>>>>>>>> usually we want to
know whether a method halts on every input, not just one. >>>>>>>>>>>>>>>
Although the halting problem is unsolvable, there are >>>>>>>>>>>>>>> partial solutions
to the halting problem. In particular, every counter- >>>>>>>>>>>>>>> example to the
full solution is correctly solved by some partial deciders. >>>>>>>>>>>>>>
sense or in Olcott's sense.
Undecidability is misconception. Self-contradictory
expressions are correctly rejected as semantically
incoherent thus form no undecidability or incompleteness. >>>>>>>>>>>
order group theory is self-contradictory. But the first order >>>>>>>>>>> goupr
theory is incomplete: it is impossible to prove that AB = BA >>>>>>>>>>> is true
for every A and every B but it is also impossible to prove >>>>>>>>>>> that AB = BA
is false for some A and some B.
All deciders essentially: Transform finite string
inputs by finite string transformation rules into
{Accept, Reject} values.
When a required result cannot be derived by applying
finite string transformation rules to actual finite
string inputs, then the required result exceeds the
scope of computation and must be rejected as an
incorrect requirement.
No, that does not follow. If a required result cannot be
derived by
appying a finite string transformation then the it it is
uncomputable.
Right. Outside the scope of computation. Requiring anything
outside the scope of computation is an incorrect requirement.
You can't determine whether the required result is computable before >>>>>>> you have the requirement.
*Computation and Undecidability*
https://philpapers.org/go.pl?aid=OLCCAU
We know that there does not exist any finite
string transformations that H can apply to its
input P to derive the halt status of any P
that does the opposite of whatever H returns.
Which only nmakes sense when the requirement that H must determine
whether the computation presented by its input halts has already
been presented.
*ChatGPT explains how and why I am correct*
*Reinterpretation of undecidability*
The example of P and H demonstrates that what is
often called “undecidable” is better understood as
ill-posed with respect to computable semantics.
When the specification is constrained to properties
detectable via finite simulation and finite pattern
recognition, computation proceeds normally and
correctly. Undecidability only appears when the
specification overreaches that boundary.
It tries to explain but it does not prove.
Its the same thing that I have been saying for years.
It is not that a universal halt decider cannot exist.
It is that an input that does the opposite of whatever
value the halt decider returns is non-well-founded
within proof-theoretic semantics.
But the problem is that Computation is not a proof-theoretic semantic
system, and thus those rules don't apply.
The dumbed down version is that the halting problem asks
a question outside of the scope of finite string transformations.
But it doesn't, not unless you think that programs can't be represented
as finite strings.
The halting problem proof does not fail because finite computation
is too weak. It fails because it asks finite computation to
decide a judgment that is not finitely grounded under operational
semantics.
But that is the issue, Operational Semantics for Programs are not
actually finitely based, since programs can be non-halting.
Just shows you don't know what your words actually mean.
By operational semantics I mean the standard proof‑theoretic
account of program meaning, where execution judgments are
given by inference rules and termination corresponds to the
existence of a finite derivation.
Which is just incorrect. Since infinite derivation has meaning in the
field.
On 1/14/26 8:25 PM, olcott wrote:
On 1/12/2026 9:19 PM, Richard Damon wrote:
On 1/12/26 9:29 AM, olcott wrote:
On 1/12/2026 4:44 AM, Mikko wrote:
On 11/01/2026 16:18, olcott wrote:
On 1/11/2026 4:13 AM, Mikko wrote:
On 10/01/2026 17:47, olcott wrote:
On 1/10/2026 2:23 AM, Mikko wrote:
On 09/01/2026 17:52, olcott wrote:
On 1/9/2026 3:59 AM, Mikko wrote:
On 08/01/2026 16:22, olcott wrote:
On 1/8/2026 4:22 AM, Mikko wrote:The misconception is yours. No expression in the language of >>>>>>>>>>> the first
On 07/01/2026 13:54, olcott wrote:
On 1/7/2026 5:49 AM, Mikko wrote:Depends on whether the word "truth" is interpeted in the >>>>>>>>>>>>> standard
On 07/01/2026 06:44, olcott wrote:*if undecidability is correct then truth itself is broken* >>>>>>>>>>>>>
All deciders essentially: Transform finite string >>>>>>>>>>>>>>>> inputs by finite string transformation rules into >>>>>>>>>>>>>>>> {Accept, Reject} values.
The counter-example input to requires more than >>>>>>>>>>>>>>>> can be derived from finite string transformation >>>>>>>>>>>>>>>> rules applied to this specific input thus the
Halting Problem requires too much.
In a sense the halting problem asks too much: the problem >>>>>>>>>>>>>>> is proven to
be unsolvable. In another sense it asks too little: >>>>>>>>>>>>>>> usually we want to
know whether a method halts on every input, not just one. >>>>>>>>>>>>>>>
Although the halting problem is unsolvable, there are >>>>>>>>>>>>>>> partial solutions
to the halting problem. In particular, every counter- >>>>>>>>>>>>>>> example to the
full solution is correctly solved by some partial deciders. >>>>>>>>>>>>>>
sense or in Olcott's sense.
Undecidability is misconception. Self-contradictory
expressions are correctly rejected as semantically
incoherent thus form no undecidability or incompleteness. >>>>>>>>>>>
order group theory is self-contradictory. But the first order >>>>>>>>>>> goupr
theory is incomplete: it is impossible to prove that AB = BA >>>>>>>>>>> is true
for every A and every B but it is also impossible to prove >>>>>>>>>>> that AB = BA
is false for some A and some B.
All deciders essentially: Transform finite string
inputs by finite string transformation rules into
{Accept, Reject} values.
When a required result cannot be derived by applying
finite string transformation rules to actual finite
string inputs, then the required result exceeds the
scope of computation and must be rejected as an
incorrect requirement.
No, that does not follow. If a required result cannot be
derived by
appying a finite string transformation then the it it is
uncomputable.
Right. Outside the scope of computation. Requiring anything
outside the scope of computation is an incorrect requirement.
You can't determine whether the required result is computable before >>>>>>> you have the requirement.
*Computation and Undecidability*
https://philpapers.org/go.pl?aid=OLCCAU
We know that there does not exist any finite
string transformations that H can apply to its
input P to derive the halt status of any P
that does the opposite of whatever H returns.
Which only nmakes sense when the requirement that H must determine
whether the computation presented by its input halts has already
been presented.
*ChatGPT explains how and why I am correct*
*Reinterpretation of undecidability*
The example of P and H demonstrates that what is
often called “undecidable” is better understood as
ill-posed with respect to computable semantics.
When the specification is constrained to properties
detectable via finite simulation and finite pattern
recognition, computation proceeds normally and
correctly. Undecidability only appears when the
specification overreaches that boundary.
It tries to explain but it does not prove.
Its the same thing that I have been saying for years.
It is not that a universal halt decider cannot exist.
It is that an input that does the opposite of whatever
value the halt decider returns is non-well-founded
within proof-theoretic semantics.
But the problem is that Computation is not a proof-theoretic semantic
system, and thus those rules don't apply.
The dumbed down version is that the halting problem asks
a question outside of the scope of finite string transformations.
But it doesn't, not unless you think that programs can't be represented
as finite strings.
The halting problem proof does not fail because finite computation
is too weak. It fails because it asks finite computation to
decide a judgment that is not finitely grounded under operational
semantics.
But that is the issue, Operational Semantics for Programs are not
actually finitely based, since programs can be non-halting.
Just shows you don't know what your words actually mean.
By operational semantics I mean the standard proof‑theoretic
account of program meaning, where execution judgments are
given by inference rules and termination corresponds to the
existence of a finite derivation.
Which is just incorrect. Since infinite derivation has meaning in the
field.
On 14/01/2026 21:32, olcott wrote:
On 1/14/2026 3:01 AM, Mikko wrote:
On 13/01/2026 16:31, olcott wrote:
On 1/13/2026 3:13 AM, Mikko wrote:
On 12/01/2026 16:32, olcott wrote:
On 1/12/2026 4:47 AM, Mikko wrote:
On 11/01/2026 16:24, Tristan Wibberley wrote:
On 11/01/2026 10:13, Mikko wrote:For pracitcal programming it is useful to know what is known to be >>>>>>> uncomputable in order to avoid wasting time in attemlpts to do the >>>>>>> impossible.
On 10/01/2026 17:47, olcott wrote:
On 1/10/2026 2:23 AM, Mikko wrote:
You can't determine whether the required result is computable >>>>>>>>> beforeNo, that does not follow. If a required result cannot be >>>>>>>>>>> derived by
appying a finite string transformation then the it it is >>>>>>>>>>> uncomputable.
Right. Outside the scope of computation. Requiring anything >>>>>>>>>> outside the scope of computation is an incorrect requirement. >>>>>>>>>
you have the requirement.
Right, it is /in/ scope for computer science... for the /ology/. >>>>>>>> Olcott
here uses "computation" to refer to the practice. You give the >>>>>>>> requirement to the /ologist/ who correctly decides that it is >>>>>>>> not for
computation because it is not computable.
You two so often violently agree; I find it warming to the heart. >>>>>>>
It f-cking nuts that after more than 2000 years
people still don't understand that self-contradictory
expressions: "This sentence is not true" have no
truth value. A smart high school student should have
figured this out 2000 years ago.
Irrelevant. For practical programming that question needn't be
answered.
The halting problem counter-example input is anchored
in the Liar Paradox. Proof Theoretic Semantics rejects
those two and Gödel's incompleteness and a bunch more
as merely non-well-founded inputs.
For every Turing machine the halting problem counter-example provably
exists.
Not when using Proof Theoretic Semantics grounded
in the specification language. In this case the
pathological input is simply rejected as ungrounded.
Then your "Proof Theoretic Semantics" is not useful for discussion of
Turing machines. For every Turing machine a counter example exists.
And so exists a Turing machine that writes the counter example when
given a Turing machine as input.
On 14/01/2026 19:28, olcott wrote:
On 1/14/2026 1:40 AM, Mikko wrote:
On 13/01/2026 16:27, olcott wrote:
On 1/13/2026 3:11 AM, Mikko wrote:
On 12/01/2026 16:29, olcott wrote:
On 1/12/2026 4:44 AM, Mikko wrote:
On 11/01/2026 16:18, olcott wrote:
On 1/11/2026 4:13 AM, Mikko wrote:
On 10/01/2026 17:47, olcott wrote:
On 1/10/2026 2:23 AM, Mikko wrote:You can't determine whether the required result is computable >>>>>>>>> before
On 09/01/2026 17:52, olcott wrote:
On 1/9/2026 3:59 AM, Mikko wrote:
On 08/01/2026 16:22, olcott wrote:
On 1/8/2026 4:22 AM, Mikko wrote:The misconception is yours. No expression in the language >>>>>>>>>>>>> of the first
On 07/01/2026 13:54, olcott wrote:
On 1/7/2026 5:49 AM, Mikko wrote:Depends on whether the word "truth" is interpeted in the >>>>>>>>>>>>>>> standard
On 07/01/2026 06:44, olcott wrote:
All deciders essentially: Transform finite string >>>>>>>>>>>>>>>>>> inputs by finite string transformation rules into >>>>>>>>>>>>>>>>>> {Accept, Reject} values.
The counter-example input to requires more than >>>>>>>>>>>>>>>>>> can be derived from finite string transformation >>>>>>>>>>>>>>>>>> rules applied to this specific input thus the >>>>>>>>>>>>>>>>>> Halting Problem requires too much.
In a sense the halting problem asks too much: the >>>>>>>>>>>>>>>>> problem is proven to
be unsolvable. In another sense it asks too little: >>>>>>>>>>>>>>>>> usually we want to
know whether a method halts on every input, not just one. >>>>>>>>>>>>>>>>>
Although the halting problem is unsolvable, there are >>>>>>>>>>>>>>>>> partial solutions
to the halting problem. In particular, every counter- >>>>>>>>>>>>>>>>> example to the
full solution is correctly solved by some partial >>>>>>>>>>>>>>>>> deciders.
*if undecidability is correct then truth itself is broken* >>>>>>>>>>>>>>>
sense or in Olcott's sense.
Undecidability is misconception. Self-contradictory >>>>>>>>>>>>>> expressions are correctly rejected as semantically >>>>>>>>>>>>>> incoherent thus form no undecidability or incompleteness. >>>>>>>>>>>>>
order group theory is self-contradictory. But the first >>>>>>>>>>>>> order goupr
theory is incomplete: it is impossible to prove that AB = >>>>>>>>>>>>> BA is true
for every A and every B but it is also impossible to prove >>>>>>>>>>>>> that AB = BA
is false for some A and some B.
All deciders essentially: Transform finite string
inputs by finite string transformation rules into
{Accept, Reject} values.
When a required result cannot be derived by applying
finite string transformation rules to actual finite
string inputs, then the required result exceeds the
scope of computation and must be rejected as an
incorrect requirement.
No, that does not follow. If a required result cannot be >>>>>>>>>>> derived by
appying a finite string transformation then the it it is >>>>>>>>>>> uncomputable.
Right. Outside the scope of computation. Requiring anything >>>>>>>>>> outside the scope of computation is an incorrect requirement. >>>>>>>>>
you have the requirement.
*Computation and Undecidability*
https://philpapers.org/go.pl?aid=OLCCAU
We know that there does not exist any finite
string transformations that H can apply to its
input P to derive the halt status of any P
that does the opposite of whatever H returns.
Which only nmakes sense when the requirement that H must determine >>>>>>> whether the computation presented by its input halts has already >>>>>>> been presented.
*ChatGPT explains how and why I am correct*
*Reinterpretation of undecidability*
The example of P and H demonstrates that what is
often called “undecidable” is better understood as
ill-posed with respect to computable semantics.
When the specification is constrained to properties
detectable via finite simulation and finite pattern
recognition, computation proceeds normally and
correctly. Undecidability only appears when the
specification overreaches that boundary.
It tries to explain but it does not prove.
Its the same thing that I have been saying for years.
It is not that a universal halt decider cannot exist.
It is proven that an universal halt decider does not exist.
“The system adopts Proof-Theoretic Semantics: meaning is determined >>>> by inferential role, and truth is internal to the theory. A theory T
is defined by a finite set of stipulated atomic statements together
with all expressions derivable from them under the inference rules.
The statements belonging to T constitute its theorems, and these are
exactly the statements that are true-in-T.”
Under a system like the above rough draft all inputs
having pathological self reference such as the halting
problem counter-example input are simply rejected as
non-well-founded. Tarski Undefinability, Gödel's
incompleteness and the halting problem cease to exist.
A Turing
machine cannot determine the halting of all Turing machines and is
therefore not an universla halt decider.
This is not true in Proof Theoretic Semantics. I
still have to refine my words. I may not have said
that exactly correctly. The result is that in Proof
Theoretic Semantics the counter-example is rejected
as non-well-founded.
That no Turing machine is a halt decider is a proven theorem and a
truth about Turing machines. If your "Proof Thoeretic Semnatics"
does not regard it as true then your "Proof Theoretic Semantics"
is incomplete.
My long‑term goal is to make ‘true on the basis of meaning’ computable.
As meaning is not computable, how can "true on the balsis of meaning"
be commputable?
On 1/14/2026 9:51 PM, Richard Damon wrote:
On 1/14/26 8:25 PM, olcott wrote:
On 1/12/2026 9:19 PM, Richard Damon wrote:
On 1/12/26 9:29 AM, olcott wrote:
On 1/12/2026 4:44 AM, Mikko wrote:
On 11/01/2026 16:18, olcott wrote:
On 1/11/2026 4:13 AM, Mikko wrote:
On 10/01/2026 17:47, olcott wrote:
On 1/10/2026 2:23 AM, Mikko wrote:You can't determine whether the required result is computable >>>>>>>> before
On 09/01/2026 17:52, olcott wrote:
On 1/9/2026 3:59 AM, Mikko wrote:
On 08/01/2026 16:22, olcott wrote:
On 1/8/2026 4:22 AM, Mikko wrote:The misconception is yours. No expression in the language of >>>>>>>>>>>> the first
On 07/01/2026 13:54, olcott wrote:
On 1/7/2026 5:49 AM, Mikko wrote:Depends on whether the word "truth" is interpeted in the >>>>>>>>>>>>>> standard
On 07/01/2026 06:44, olcott wrote:*if undecidability is correct then truth itself is broken* >>>>>>>>>>>>>>
All deciders essentially: Transform finite string >>>>>>>>>>>>>>>>> inputs by finite string transformation rules into >>>>>>>>>>>>>>>>> {Accept, Reject} values.
The counter-example input to requires more than >>>>>>>>>>>>>>>>> can be derived from finite string transformation >>>>>>>>>>>>>>>>> rules applied to this specific input thus the >>>>>>>>>>>>>>>>> Halting Problem requires too much.
In a sense the halting problem asks too much: the >>>>>>>>>>>>>>>> problem is proven to
be unsolvable. In another sense it asks too little: >>>>>>>>>>>>>>>> usually we want to
know whether a method halts on every input, not just one. >>>>>>>>>>>>>>>>
Although the halting problem is unsolvable, there are >>>>>>>>>>>>>>>> partial solutions
to the halting problem. In particular, every counter- >>>>>>>>>>>>>>>> example to the
full solution is correctly solved by some partial deciders. >>>>>>>>>>>>>>>
sense or in Olcott's sense.
Undecidability is misconception. Self-contradictory
expressions are correctly rejected as semantically
incoherent thus form no undecidability or incompleteness. >>>>>>>>>>>>
order group theory is self-contradictory. But the first >>>>>>>>>>>> order goupr
theory is incomplete: it is impossible to prove that AB = BA >>>>>>>>>>>> is true
for every A and every B but it is also impossible to prove >>>>>>>>>>>> that AB = BA
is false for some A and some B.
All deciders essentially: Transform finite string
inputs by finite string transformation rules into
{Accept, Reject} values.
When a required result cannot be derived by applying
finite string transformation rules to actual finite
string inputs, then the required result exceeds the
scope of computation and must be rejected as an
incorrect requirement.
No, that does not follow. If a required result cannot be
derived by
appying a finite string transformation then the it it is
uncomputable.
Right. Outside the scope of computation. Requiring anything
outside the scope of computation is an incorrect requirement. >>>>>>>>
you have the requirement.
*Computation and Undecidability*
https://philpapers.org/go.pl?aid=OLCCAU
We know that there does not exist any finite
string transformations that H can apply to its
input P to derive the halt status of any P
that does the opposite of whatever H returns.
Which only nmakes sense when the requirement that H must determine >>>>>> whether the computation presented by its input halts has already
been presented.
*ChatGPT explains how and why I am correct*
*Reinterpretation of undecidability*
The example of P and H demonstrates that what is
often called “undecidable” is better understood as
ill-posed with respect to computable semantics.
When the specification is constrained to properties
detectable via finite simulation and finite pattern
recognition, computation proceeds normally and
correctly. Undecidability only appears when the
specification overreaches that boundary.
It tries to explain but it does not prove.
Its the same thing that I have been saying for years.
It is not that a universal halt decider cannot exist.
It is that an input that does the opposite of whatever
value the halt decider returns is non-well-founded
within proof-theoretic semantics.
But the problem is that Computation is not a proof-theoretic
semantic system, and thus those rules don't apply.
The dumbed down version is that the halting problem asks
a question outside of the scope of finite string transformations.
But it doesn't, not unless you think that programs can't be
represented as finite strings.
The halting problem proof does not fail because finite computation
is too weak. It fails because it asks finite computation to
decide a judgment that is not finitely grounded under operational
semantics.
But that is the issue, Operational Semantics for Programs are not
actually finitely based, since programs can be non-halting.
Just shows you don't know what your words actually mean.
By operational semantics I mean the standard proof‑theoretic
account of program meaning, where execution judgments are
given by inference rules and termination corresponds to the
existence of a finite derivation.
Which is just incorrect. Since infinite derivation has meaning in the
field.
The halting problem is not undecidable because computation is weak, but because the classical formulation uses a denotational semantics that is
too permissive.
In operational/proof‑theoretic semantics, where meaning is grounded in finite derivations, the halting predicate is not a well‑formed judgment — just as unrestricted comprehension was not a well‑formed judgment in naïve set theory.
On 1/15/26 12:34 PM, olcott wrote:
On 1/14/2026 9:51 PM, Richard Damon wrote:
On 1/14/26 8:25 PM, olcott wrote:
On 1/12/2026 9:19 PM, Richard Damon wrote:
On 1/12/26 9:29 AM, olcott wrote:
On 1/12/2026 4:44 AM, Mikko wrote:
On 11/01/2026 16:18, olcott wrote:
On 1/11/2026 4:13 AM, Mikko wrote:
On 10/01/2026 17:47, olcott wrote:
On 1/10/2026 2:23 AM, Mikko wrote:You can't determine whether the required result is computable >>>>>>>>> before
On 09/01/2026 17:52, olcott wrote:
On 1/9/2026 3:59 AM, Mikko wrote:
On 08/01/2026 16:22, olcott wrote:
On 1/8/2026 4:22 AM, Mikko wrote:The misconception is yours. No expression in the language >>>>>>>>>>>>> of the first
On 07/01/2026 13:54, olcott wrote:
On 1/7/2026 5:49 AM, Mikko wrote:Depends on whether the word "truth" is interpeted in the >>>>>>>>>>>>>>> standard
On 07/01/2026 06:44, olcott wrote:
All deciders essentially: Transform finite string >>>>>>>>>>>>>>>>>> inputs by finite string transformation rules into >>>>>>>>>>>>>>>>>> {Accept, Reject} values.
The counter-example input to requires more than >>>>>>>>>>>>>>>>>> can be derived from finite string transformation >>>>>>>>>>>>>>>>>> rules applied to this specific input thus the >>>>>>>>>>>>>>>>>> Halting Problem requires too much.
In a sense the halting problem asks too much: the >>>>>>>>>>>>>>>>> problem is proven to
be unsolvable. In another sense it asks too little: >>>>>>>>>>>>>>>>> usually we want to
know whether a method halts on every input, not just one. >>>>>>>>>>>>>>>>>
Although the halting problem is unsolvable, there are >>>>>>>>>>>>>>>>> partial solutions
to the halting problem. In particular, every counter- >>>>>>>>>>>>>>>>> example to the
full solution is correctly solved by some partial >>>>>>>>>>>>>>>>> deciders.
*if undecidability is correct then truth itself is broken* >>>>>>>>>>>>>>>
sense or in Olcott's sense.
Undecidability is misconception. Self-contradictory >>>>>>>>>>>>>> expressions are correctly rejected as semantically >>>>>>>>>>>>>> incoherent thus form no undecidability or incompleteness. >>>>>>>>>>>>>
order group theory is self-contradictory. But the first >>>>>>>>>>>>> order goupr
theory is incomplete: it is impossible to prove that AB = >>>>>>>>>>>>> BA is true
for every A and every B but it is also impossible to prove >>>>>>>>>>>>> that AB = BA
is false for some A and some B.
All deciders essentially: Transform finite string
inputs by finite string transformation rules into
{Accept, Reject} values.
When a required result cannot be derived by applying
finite string transformation rules to actual finite
string inputs, then the required result exceeds the
scope of computation and must be rejected as an
incorrect requirement.
No, that does not follow. If a required result cannot be >>>>>>>>>>> derived by
appying a finite string transformation then the it it is >>>>>>>>>>> uncomputable.
Right. Outside the scope of computation. Requiring anything >>>>>>>>>> outside the scope of computation is an incorrect requirement. >>>>>>>>>
you have the requirement.
*Computation and Undecidability*
https://philpapers.org/go.pl?aid=OLCCAU
We know that there does not exist any finite
string transformations that H can apply to its
input P to derive the halt status of any P
that does the opposite of whatever H returns.
Which only nmakes sense when the requirement that H must determine >>>>>>> whether the computation presented by its input halts has already >>>>>>> been presented.
*ChatGPT explains how and why I am correct*
*Reinterpretation of undecidability*
The example of P and H demonstrates that what is
often called “undecidable” is better understood as
ill-posed with respect to computable semantics.
When the specification is constrained to properties
detectable via finite simulation and finite pattern
recognition, computation proceeds normally and
correctly. Undecidability only appears when the
specification overreaches that boundary.
It tries to explain but it does not prove.
Its the same thing that I have been saying for years.
It is not that a universal halt decider cannot exist.
It is that an input that does the opposite of whatever
value the halt decider returns is non-well-founded
within proof-theoretic semantics.
But the problem is that Computation is not a proof-theoretic
semantic system, and thus those rules don't apply.
The dumbed down version is that the halting problem asks
a question outside of the scope of finite string transformations.
But it doesn't, not unless you think that programs can't be
represented as finite strings.
The halting problem proof does not fail because finite computation
is too weak. It fails because it asks finite computation to
decide a judgment that is not finitely grounded under operational
semantics.
But that is the issue, Operational Semantics for Programs are not
actually finitely based, since programs can be non-halting.
Just shows you don't know what your words actually mean.
By operational semantics I mean the standard proof‑theoretic
account of program meaning, where execution judgments are
given by inference rules and termination corresponds to the
existence of a finite derivation.
Which is just incorrect. Since infinite derivation has meaning in the
field.
The halting problem is not undecidable because computation is weak,
but because the classical formulation uses a denotational semantics
that is too permissive.
Nope.
In operational/proof‑theoretic semantics, where meaning is grounded in
finite derivations, the halting predicate is not a well‑formed
judgment — just as unrestricted comprehension was not a well‑formed
judgment in naïve set theory.
In other words, by trying to enforce your interpreation, you system
becomes unworkable, as you can't tell if you can ask a question.
The problem is that systems like this grow faster in power to generate--
than your logic grow in power to decide, and either you accept that some truths are unprovable (and thus accept the truth-conditional view) or
you need to just abandon the ability to actually work in the system as
you can't tell what questions are reasonable.
All you are doing is proving that you are just too stupid to understand
the implications of what you are talking about, because you never really understood what the words actually mean.
On 1/15/2026 3:48 AM, Mikko wrote:
On 14/01/2026 19:28, olcott wrote:
On 1/14/2026 1:40 AM, Mikko wrote:
On 13/01/2026 16:27, olcott wrote:
On 1/13/2026 3:11 AM, Mikko wrote:
On 12/01/2026 16:29, olcott wrote:
On 1/12/2026 4:44 AM, Mikko wrote:
On 11/01/2026 16:18, olcott wrote:
On 1/11/2026 4:13 AM, Mikko wrote:
On 10/01/2026 17:47, olcott wrote:
On 1/10/2026 2:23 AM, Mikko wrote:You can't determine whether the required result is computable >>>>>>>>>> before
On 09/01/2026 17:52, olcott wrote:
On 1/9/2026 3:59 AM, Mikko wrote:
On 08/01/2026 16:22, olcott wrote:
On 1/8/2026 4:22 AM, Mikko wrote:The misconception is yours. No expression in the language >>>>>>>>>>>>>> of the first
On 07/01/2026 13:54, olcott wrote:
On 1/7/2026 5:49 AM, Mikko wrote:Depends on whether the word "truth" is interpeted in the >>>>>>>>>>>>>>>> standard
On 07/01/2026 06:44, olcott wrote:
All deciders essentially: Transform finite string >>>>>>>>>>>>>>>>>>> inputs by finite string transformation rules into >>>>>>>>>>>>>>>>>>> {Accept, Reject} values.
The counter-example input to requires more than >>>>>>>>>>>>>>>>>>> can be derived from finite string transformation >>>>>>>>>>>>>>>>>>> rules applied to this specific input thus the >>>>>>>>>>>>>>>>>>> Halting Problem requires too much.
In a sense the halting problem asks too much: the >>>>>>>>>>>>>>>>>> problem is proven to
be unsolvable. In another sense it asks too little: >>>>>>>>>>>>>>>>>> usually we want to
know whether a method halts on every input, not just one. >>>>>>>>>>>>>>>>>>
Although the halting problem is unsolvable, there are >>>>>>>>>>>>>>>>>> partial solutions
to the halting problem. In particular, every counter- >>>>>>>>>>>>>>>>>> example to the
full solution is correctly solved by some partial >>>>>>>>>>>>>>>>>> deciders.
*if undecidability is correct then truth itself is broken* >>>>>>>>>>>>>>>>
sense or in Olcott's sense.
Undecidability is misconception. Self-contradictory >>>>>>>>>>>>>>> expressions are correctly rejected as semantically >>>>>>>>>>>>>>> incoherent thus form no undecidability or incompleteness. >>>>>>>>>>>>>>
order group theory is self-contradictory. But the first >>>>>>>>>>>>>> order goupr
theory is incomplete: it is impossible to prove that AB = >>>>>>>>>>>>>> BA is true
for every A and every B but it is also impossible to prove >>>>>>>>>>>>>> that AB = BA
is false for some A and some B.
All deciders essentially: Transform finite string
inputs by finite string transformation rules into
{Accept, Reject} values.
When a required result cannot be derived by applying >>>>>>>>>>>>> finite string transformation rules to actual finite
string inputs, then the required result exceeds the
scope of computation and must be rejected as an
incorrect requirement.
No, that does not follow. If a required result cannot be >>>>>>>>>>>> derived by
appying a finite string transformation then the it it is >>>>>>>>>>>> uncomputable.
Right. Outside the scope of computation. Requiring anything >>>>>>>>>>> outside the scope of computation is an incorrect requirement. >>>>>>>>>>
you have the requirement.
*Computation and Undecidability*
https://philpapers.org/go.pl?aid=OLCCAU
We know that there does not exist any finite
string transformations that H can apply to its
input P to derive the halt status of any P
that does the opposite of whatever H returns.
Which only nmakes sense when the requirement that H must determine >>>>>>>> whether the computation presented by its input halts has already >>>>>>>> been presented.
*ChatGPT explains how and why I am correct*
*Reinterpretation of undecidability*
The example of P and H demonstrates that what is
often called “undecidable” is better understood as
ill-posed with respect to computable semantics.
When the specification is constrained to properties
detectable via finite simulation and finite pattern
recognition, computation proceeds normally and
correctly. Undecidability only appears when the
specification overreaches that boundary.
It tries to explain but it does not prove.
Its the same thing that I have been saying for years.
It is not that a universal halt decider cannot exist.
It is proven that an universal halt decider does not exist.
“The system adopts Proof-Theoretic Semantics: meaning is determined >>>>> by inferential role, and truth is internal to the theory. A theory
T is defined by a finite set of stipulated atomic statements
together with all expressions derivable from them under the
inference rules. The statements belonging to T constitute its
theorems, and these are exactly the statements that are true-in-T.” >>>>>
Under a system like the above rough draft all inputs
having pathological self reference such as the halting
problem counter-example input are simply rejected as
non-well-founded. Tarski Undefinability, Gödel's
incompleteness and the halting problem cease to exist.
A Turing
machine cannot determine the halting of all Turing machines and is >>>>>> therefore not an universla halt decider.
This is not true in Proof Theoretic Semantics. I
still have to refine my words. I may not have said
that exactly correctly. The result is that in Proof
Theoretic Semantics the counter-example is rejected
as non-well-founded.
That no Turing machine is a halt decider is a proven theorem and a
truth about Turing machines. If your "Proof Thoeretic Semnatics"
does not regard it as true then your "Proof Theoretic Semantics"
is incomplete.
My long‑term goal is to make ‘true on the basis of meaning’ computable.
As meaning is not computable, how can "true on the balsis of meaning"
be commputable?
Under *proof‑theoretic semantics*
"true on the basis of meaning expressed in language"
has always been entirely computable.
On 15/01/2026 09:21, Mikko wrote:
A system is useful only if admissibility is computable with a known
algorithm.
Is that a definition of "useful" ?
On 1/15/2026 3:34 AM, Mikko wrote:
On 14/01/2026 21:32, olcott wrote:
On 1/14/2026 3:01 AM, Mikko wrote:
On 13/01/2026 16:31, olcott wrote:
On 1/13/2026 3:13 AM, Mikko wrote:
On 12/01/2026 16:32, olcott wrote:
On 1/12/2026 4:47 AM, Mikko wrote:
On 11/01/2026 16:24, Tristan Wibberley wrote:
On 11/01/2026 10:13, Mikko wrote:For pracitcal programming it is useful to know what is known to be >>>>>>>> uncomputable in order to avoid wasting time in attemlpts to do the >>>>>>>> impossible.
On 10/01/2026 17:47, olcott wrote:
On 1/10/2026 2:23 AM, Mikko wrote:
You can't determine whether the required result is computable >>>>>>>>>> beforeNo, that does not follow. If a required result cannot be >>>>>>>>>>>> derived by
appying a finite string transformation then the it it is >>>>>>>>>>>> uncomputable.
Right. Outside the scope of computation. Requiring anything >>>>>>>>>>> outside the scope of computation is an incorrect requirement. >>>>>>>>>>
you have the requirement.
Right, it is /in/ scope for computer science... for the /
ology/. Olcott
here uses "computation" to refer to the practice. You give the >>>>>>>>> requirement to the /ologist/ who correctly decides that it is >>>>>>>>> not for
computation because it is not computable.
You two so often violently agree; I find it warming to the heart. >>>>>>>>
It f-cking nuts that after more than 2000 years
people still don't understand that self-contradictory
expressions: "This sentence is not true" have no
truth value. A smart high school student should have
figured this out 2000 years ago.
Irrelevant. For practical programming that question needn't be
answered.
The halting problem counter-example input is anchored
in the Liar Paradox. Proof Theoretic Semantics rejects
those two and Gödel's incompleteness and a bunch more
as merely non-well-founded inputs.
For every Turing machine the halting problem counter-example provably
exists.
Not when using Proof Theoretic Semantics grounded
in the specification language. In this case the
pathological input is simply rejected as ungrounded.
Then your "Proof Theoretic Semantics" is not useful for discussion of
Turing machines. For every Turing machine a counter example exists.
And so exists a Turing machine that writes the counter example when
given a Turing machine as input.
It is "not useful" in the same way that ZFC was
"not useful" for addressing Russell's Paradox.
On 16/01/2026 01:38, olcott wrote:
On 1/15/2026 3:48 AM, Mikko wrote:
On 14/01/2026 19:28, olcott wrote:
On 1/14/2026 1:40 AM, Mikko wrote:
On 13/01/2026 16:27, olcott wrote:
On 1/13/2026 3:11 AM, Mikko wrote:
On 12/01/2026 16:29, olcott wrote:
On 1/12/2026 4:44 AM, Mikko wrote:
On 11/01/2026 16:18, olcott wrote:
On 1/11/2026 4:13 AM, Mikko wrote:
On 10/01/2026 17:47, olcott wrote:
On 1/10/2026 2:23 AM, Mikko wrote:You can't determine whether the required result is computable >>>>>>>>>>> before
On 09/01/2026 17:52, olcott wrote:
On 1/9/2026 3:59 AM, Mikko wrote:
On 08/01/2026 16:22, olcott wrote:
On 1/8/2026 4:22 AM, Mikko wrote:The misconception is yours. No expression in the language >>>>>>>>>>>>>>> of the first
On 07/01/2026 13:54, olcott wrote:
On 1/7/2026 5:49 AM, Mikko wrote:
On 07/01/2026 06:44, olcott wrote:
All deciders essentially: Transform finite string >>>>>>>>>>>>>>>>>>>> inputs by finite string transformation rules into >>>>>>>>>>>>>>>>>>>> {Accept, Reject} values.
The counter-example input to requires more than >>>>>>>>>>>>>>>>>>>> can be derived from finite string transformation >>>>>>>>>>>>>>>>>>>> rules applied to this specific input thus the >>>>>>>>>>>>>>>>>>>> Halting Problem requires too much.
In a sense the halting problem asks too much: the >>>>>>>>>>>>>>>>>>> problem is proven to
be unsolvable. In another sense it asks too little: >>>>>>>>>>>>>>>>>>> usually we want to
know whether a method halts on every input, not just >>>>>>>>>>>>>>>>>>> one.
Although the halting problem is unsolvable, there are >>>>>>>>>>>>>>>>>>> partial solutions
to the halting problem. In particular, every counter- >>>>>>>>>>>>>>>>>>> example to the
full solution is correctly solved by some partial >>>>>>>>>>>>>>>>>>> deciders.
*if undecidability is correct then truth itself is >>>>>>>>>>>>>>>>>> broken*
Depends on whether the word "truth" is interpeted in >>>>>>>>>>>>>>>>> the standard
sense or in Olcott's sense.
Undecidability is misconception. Self-contradictory >>>>>>>>>>>>>>>> expressions are correctly rejected as semantically >>>>>>>>>>>>>>>> incoherent thus form no undecidability or incompleteness. >>>>>>>>>>>>>>>
order group theory is self-contradictory. But the first >>>>>>>>>>>>>>> order goupr
theory is incomplete: it is impossible to prove that AB = >>>>>>>>>>>>>>> BA is true
for every A and every B but it is also impossible to >>>>>>>>>>>>>>> prove that AB = BA
is false for some A and some B.
All deciders essentially: Transform finite string
inputs by finite string transformation rules into
{Accept, Reject} values.
When a required result cannot be derived by applying >>>>>>>>>>>>>> finite string transformation rules to actual finite >>>>>>>>>>>>>> string inputs, then the required result exceeds the >>>>>>>>>>>>>> scope of computation and must be rejected as an
incorrect requirement.
No, that does not follow. If a required result cannot be >>>>>>>>>>>>> derived by
appying a finite string transformation then the it it is >>>>>>>>>>>>> uncomputable.
Right. Outside the scope of computation. Requiring anything >>>>>>>>>>>> outside the scope of computation is an incorrect requirement. >>>>>>>>>>>
you have the requirement.
*Computation and Undecidability*
https://philpapers.org/go.pl?aid=OLCCAU
We know that there does not exist any finite
string transformations that H can apply to its
input P to derive the halt status of any P
that does the opposite of whatever H returns.
Which only nmakes sense when the requirement that H must determine >>>>>>>>> whether the computation presented by its input halts has already >>>>>>>>> been presented.
*ChatGPT explains how and why I am correct*
*Reinterpretation of undecidability*
The example of P and H demonstrates that what is
often called “undecidable” is better understood as >>>>>>>>>> ill-posed with respect to computable semantics.
When the specification is constrained to properties
detectable via finite simulation and finite pattern
recognition, computation proceeds normally and
correctly. Undecidability only appears when the
specification overreaches that boundary.
It tries to explain but it does not prove.
Its the same thing that I have been saying for years.
It is not that a universal halt decider cannot exist.
It is proven that an universal halt decider does not exist.
“The system adopts Proof-Theoretic Semantics: meaning is
determined by inferential role, and truth is internal to the
theory. A theory T is defined by a finite set of stipulated atomic >>>>>> statements together with all expressions derivable from them under >>>>>> the inference rules. The statements belonging to T constitute its >>>>>> theorems, and these are exactly the statements that are true-in-T.” >>>>>>
Under a system like the above rough draft all inputs
having pathological self reference such as the halting
problem counter-example input are simply rejected as
non-well-founded. Tarski Undefinability, Gödel's
incompleteness and the halting problem cease to exist.
A Turing
machine cannot determine the halting of all Turing machines and is >>>>>>> therefore not an universla halt decider.
This is not true in Proof Theoretic Semantics. I
still have to refine my words. I may not have said
that exactly correctly. The result is that in Proof
Theoretic Semantics the counter-example is rejected
as non-well-founded.
That no Turing machine is a halt decider is a proven theorem and a
truth about Turing machines. If your "Proof Thoeretic Semnatics"
does not regard it as true then your "Proof Theoretic Semantics"
is incomplete.
My long‑term goal is to make ‘true on the basis of meaning’ computable.
As meaning is not computable, how can "true on the balsis of meaning"
be commputable?
Under *proof‑theoretic semantics*
"true on the basis of meaning expressed in language"
has always been entirely computable.
Have you already put the algorithm to some web page?
On 16/01/2026 01:38, olcott wrote:
On 1/15/2026 3:48 AM, Mikko wrote:
On 14/01/2026 19:28, olcott wrote:
On 1/14/2026 1:40 AM, Mikko wrote:
On 13/01/2026 16:27, olcott wrote:
On 1/13/2026 3:11 AM, Mikko wrote:
On 12/01/2026 16:29, olcott wrote:
On 1/12/2026 4:44 AM, Mikko wrote:
On 11/01/2026 16:18, olcott wrote:
On 1/11/2026 4:13 AM, Mikko wrote:
On 10/01/2026 17:47, olcott wrote:
On 1/10/2026 2:23 AM, Mikko wrote:You can't determine whether the required result is computable >>>>>>>>>>> before
On 09/01/2026 17:52, olcott wrote:
On 1/9/2026 3:59 AM, Mikko wrote:
On 08/01/2026 16:22, olcott wrote:
On 1/8/2026 4:22 AM, Mikko wrote:The misconception is yours. No expression in the language >>>>>>>>>>>>>>> of the first
On 07/01/2026 13:54, olcott wrote:
On 1/7/2026 5:49 AM, Mikko wrote:
On 07/01/2026 06:44, olcott wrote:
All deciders essentially: Transform finite string >>>>>>>>>>>>>>>>>>>> inputs by finite string transformation rules into >>>>>>>>>>>>>>>>>>>> {Accept, Reject} values.
The counter-example input to requires more than >>>>>>>>>>>>>>>>>>>> can be derived from finite string transformation >>>>>>>>>>>>>>>>>>>> rules applied to this specific input thus the >>>>>>>>>>>>>>>>>>>> Halting Problem requires too much.
In a sense the halting problem asks too much: the >>>>>>>>>>>>>>>>>>> problem is proven to
be unsolvable. In another sense it asks too little: >>>>>>>>>>>>>>>>>>> usually we want to
know whether a method halts on every input, not just >>>>>>>>>>>>>>>>>>> one.
Although the halting problem is unsolvable, there are >>>>>>>>>>>>>>>>>>> partial solutions
to the halting problem. In particular, every counter- >>>>>>>>>>>>>>>>>>> example to the
full solution is correctly solved by some partial >>>>>>>>>>>>>>>>>>> deciders.
*if undecidability is correct then truth itself is >>>>>>>>>>>>>>>>>> broken*
Depends on whether the word "truth" is interpeted in >>>>>>>>>>>>>>>>> the standard
sense or in Olcott's sense.
Undecidability is misconception. Self-contradictory >>>>>>>>>>>>>>>> expressions are correctly rejected as semantically >>>>>>>>>>>>>>>> incoherent thus form no undecidability or incompleteness. >>>>>>>>>>>>>>>
order group theory is self-contradictory. But the first >>>>>>>>>>>>>>> order goupr
theory is incomplete: it is impossible to prove that AB = >>>>>>>>>>>>>>> BA is true
for every A and every B but it is also impossible to >>>>>>>>>>>>>>> prove that AB = BA
is false for some A and some B.
All deciders essentially: Transform finite string
inputs by finite string transformation rules into
{Accept, Reject} values.
When a required result cannot be derived by applying >>>>>>>>>>>>>> finite string transformation rules to actual finite >>>>>>>>>>>>>> string inputs, then the required result exceeds the >>>>>>>>>>>>>> scope of computation and must be rejected as an
incorrect requirement.
No, that does not follow. If a required result cannot be >>>>>>>>>>>>> derived by
appying a finite string transformation then the it it is >>>>>>>>>>>>> uncomputable.
Right. Outside the scope of computation. Requiring anything >>>>>>>>>>>> outside the scope of computation is an incorrect requirement. >>>>>>>>>>>
you have the requirement.
*Computation and Undecidability*
https://philpapers.org/go.pl?aid=OLCCAU
We know that there does not exist any finite
string transformations that H can apply to its
input P to derive the halt status of any P
that does the opposite of whatever H returns.
Which only nmakes sense when the requirement that H must determine >>>>>>>>> whether the computation presented by its input halts has already >>>>>>>>> been presented.
*ChatGPT explains how and why I am correct*
*Reinterpretation of undecidability*
The example of P and H demonstrates that what is
often called “undecidable” is better understood as >>>>>>>>>> ill-posed with respect to computable semantics.
When the specification is constrained to properties
detectable via finite simulation and finite pattern
recognition, computation proceeds normally and
correctly. Undecidability only appears when the
specification overreaches that boundary.
It tries to explain but it does not prove.
Its the same thing that I have been saying for years.
It is not that a universal halt decider cannot exist.
It is proven that an universal halt decider does not exist.
“The system adopts Proof-Theoretic Semantics: meaning is
determined by inferential role, and truth is internal to the
theory. A theory T is defined by a finite set of stipulated atomic >>>>>> statements together with all expressions derivable from them under >>>>>> the inference rules. The statements belonging to T constitute its >>>>>> theorems, and these are exactly the statements that are true-in-T.” >>>>>>
Under a system like the above rough draft all inputs
having pathological self reference such as the halting
problem counter-example input are simply rejected as
non-well-founded. Tarski Undefinability, Gödel's
incompleteness and the halting problem cease to exist.
A Turing
machine cannot determine the halting of all Turing machines and is >>>>>>> therefore not an universla halt decider.
This is not true in Proof Theoretic Semantics. I
still have to refine my words. I may not have said
that exactly correctly. The result is that in Proof
Theoretic Semantics the counter-example is rejected
as non-well-founded.
That no Turing machine is a halt decider is a proven theorem and a
truth about Turing machines. If your "Proof Thoeretic Semnatics"
does not regard it as true then your "Proof Theoretic Semantics"
is incomplete.
My long‑term goal is to make ‘true on the basis of meaning’ computable.
As meaning is not computable, how can "true on the balsis of meaning"
be commputable?
Under *proof‑theoretic semantics*
"true on the basis of meaning expressed in language"
has always been entirely computable.
Have you already put the algorithm to some web page?
On 15/01/2026 22:30, olcott wrote:
On 1/15/2026 3:34 AM, Mikko wrote:
On 14/01/2026 21:32, olcott wrote:
On 1/14/2026 3:01 AM, Mikko wrote:
On 13/01/2026 16:31, olcott wrote:
On 1/13/2026 3:13 AM, Mikko wrote:
On 12/01/2026 16:32, olcott wrote:
On 1/12/2026 4:47 AM, Mikko wrote:
On 11/01/2026 16:24, Tristan Wibberley wrote:
On 11/01/2026 10:13, Mikko wrote:For pracitcal programming it is useful to know what is known to be >>>>>>>>> uncomputable in order to avoid wasting time in attemlpts to do the >>>>>>>>> impossible.
On 10/01/2026 17:47, olcott wrote:
On 1/10/2026 2:23 AM, Mikko wrote:
You can't determine whether the required result is computable >>>>>>>>>>> beforeNo, that does not follow. If a required result cannot be >>>>>>>>>>>>> derived by
appying a finite string transformation then the it it is >>>>>>>>>>>>> uncomputable.
Right. Outside the scope of computation. Requiring anything >>>>>>>>>>>> outside the scope of computation is an incorrect requirement. >>>>>>>>>>>
you have the requirement.
Right, it is /in/ scope for computer science... for the / >>>>>>>>>> ology/. Olcott
here uses "computation" to refer to the practice. You give the >>>>>>>>>> requirement to the /ologist/ who correctly decides that it is >>>>>>>>>> not for
computation because it is not computable.
You two so often violently agree; I find it warming to the heart. >>>>>>>>>
It f-cking nuts that after more than 2000 years
people still don't understand that self-contradictory
expressions: "This sentence is not true" have no
truth value. A smart high school student should have
figured this out 2000 years ago.
Irrelevant. For practical programming that question needn't be
answered.
The halting problem counter-example input is anchored
in the Liar Paradox. Proof Theoretic Semantics rejects
those two and Gödel's incompleteness and a bunch more
as merely non-well-founded inputs.
For every Turing machine the halting problem counter-example provably >>>>> exists.
Not when using Proof Theoretic Semantics grounded
in the specification language. In this case the
pathological input is simply rejected as ungrounded.
Then your "Proof Theoretic Semantics" is not useful for discussion of
Turing machines. For every Turing machine a counter example exists.
And so exists a Turing machine that writes the counter example when
given a Turing machine as input.
It is "not useful" in the same way that ZFC was
"not useful" for addressing Russell's Paradox.
ZF or ZFC is to some extent useful for addressing Russell's paradox.
It is an example of a set theory where Russell's paradox is avoided.
If your "Proof Theretic Semantics" cannot handle the existence of
a counter example for every Turing decider then it is not usefule
for those who work on practical problems of program correctness.
On 1/15/2026 9:27 PM, Richard Damon wrote:
On 1/15/26 12:34 PM, olcott wrote:
On 1/14/2026 9:51 PM, Richard Damon wrote:
On 1/14/26 8:25 PM, olcott wrote:
On 1/12/2026 9:19 PM, Richard Damon wrote:
On 1/12/26 9:29 AM, olcott wrote:
On 1/12/2026 4:44 AM, Mikko wrote:
On 11/01/2026 16:18, olcott wrote:
On 1/11/2026 4:13 AM, Mikko wrote:
On 10/01/2026 17:47, olcott wrote:
On 1/10/2026 2:23 AM, Mikko wrote:You can't determine whether the required result is computable >>>>>>>>>> before
On 09/01/2026 17:52, olcott wrote:
On 1/9/2026 3:59 AM, Mikko wrote:
On 08/01/2026 16:22, olcott wrote:
On 1/8/2026 4:22 AM, Mikko wrote:The misconception is yours. No expression in the language >>>>>>>>>>>>>> of the first
On 07/01/2026 13:54, olcott wrote:
On 1/7/2026 5:49 AM, Mikko wrote:Depends on whether the word "truth" is interpeted in the >>>>>>>>>>>>>>>> standard
On 07/01/2026 06:44, olcott wrote:
All deciders essentially: Transform finite string >>>>>>>>>>>>>>>>>>> inputs by finite string transformation rules into >>>>>>>>>>>>>>>>>>> {Accept, Reject} values.
The counter-example input to requires more than >>>>>>>>>>>>>>>>>>> can be derived from finite string transformation >>>>>>>>>>>>>>>>>>> rules applied to this specific input thus the >>>>>>>>>>>>>>>>>>> Halting Problem requires too much.
In a sense the halting problem asks too much: the >>>>>>>>>>>>>>>>>> problem is proven to
be unsolvable. In another sense it asks too little: >>>>>>>>>>>>>>>>>> usually we want to
know whether a method halts on every input, not just one. >>>>>>>>>>>>>>>>>>
Although the halting problem is unsolvable, there are >>>>>>>>>>>>>>>>>> partial solutions
to the halting problem. In particular, every counter- >>>>>>>>>>>>>>>>>> example to the
full solution is correctly solved by some partial >>>>>>>>>>>>>>>>>> deciders.
*if undecidability is correct then truth itself is broken* >>>>>>>>>>>>>>>>
sense or in Olcott's sense.
Undecidability is misconception. Self-contradictory >>>>>>>>>>>>>>> expressions are correctly rejected as semantically >>>>>>>>>>>>>>> incoherent thus form no undecidability or incompleteness. >>>>>>>>>>>>>>
order group theory is self-contradictory. But the first >>>>>>>>>>>>>> order goupr
theory is incomplete: it is impossible to prove that AB = >>>>>>>>>>>>>> BA is true
for every A and every B but it is also impossible to prove >>>>>>>>>>>>>> that AB = BA
is false for some A and some B.
All deciders essentially: Transform finite string
inputs by finite string transformation rules into
{Accept, Reject} values.
When a required result cannot be derived by applying >>>>>>>>>>>>> finite string transformation rules to actual finite
string inputs, then the required result exceeds the
scope of computation and must be rejected as an
incorrect requirement.
No, that does not follow. If a required result cannot be >>>>>>>>>>>> derived by
appying a finite string transformation then the it it is >>>>>>>>>>>> uncomputable.
Right. Outside the scope of computation. Requiring anything >>>>>>>>>>> outside the scope of computation is an incorrect requirement. >>>>>>>>>>
you have the requirement.
*Computation and Undecidability*
https://philpapers.org/go.pl?aid=OLCCAU
We know that there does not exist any finite
string transformations that H can apply to its
input P to derive the halt status of any P
that does the opposite of whatever H returns.
Which only nmakes sense when the requirement that H must determine >>>>>>>> whether the computation presented by its input halts has already >>>>>>>> been presented.
*ChatGPT explains how and why I am correct*
*Reinterpretation of undecidability*
The example of P and H demonstrates that what is
often called “undecidable” is better understood as
ill-posed with respect to computable semantics.
When the specification is constrained to properties
detectable via finite simulation and finite pattern
recognition, computation proceeds normally and
correctly. Undecidability only appears when the
specification overreaches that boundary.
It tries to explain but it does not prove.
Its the same thing that I have been saying for years.
It is not that a universal halt decider cannot exist.
It is that an input that does the opposite of whatever
value the halt decider returns is non-well-founded
within proof-theoretic semantics.
But the problem is that Computation is not a proof-theoretic
semantic system, and thus those rules don't apply.
The dumbed down version is that the halting problem asks
a question outside of the scope of finite string transformations.
But it doesn't, not unless you think that programs can't be
represented as finite strings.
The halting problem proof does not fail because finite computation
is too weak. It fails because it asks finite computation to
decide a judgment that is not finitely grounded under operational
semantics.
But that is the issue, Operational Semantics for Programs are not
actually finitely based, since programs can be non-halting.
Just shows you don't know what your words actually mean.
By operational semantics I mean the standard proof‑theoretic
account of program meaning, where execution judgments are
given by inference rules and termination corresponds to the
existence of a finite derivation.
Which is just incorrect. Since infinite derivation has meaning in
the field.
The halting problem is not undecidable because computation is weak,
but because the classical formulation uses a denotational semantics
that is too permissive.
Nope.
In operational/proof‑theoretic semantics, where meaning is grounded
in finite derivations, the halting predicate is not a well‑formed
judgment — just as unrestricted comprehension was not a well‑formed >>> judgment in naïve set theory.
In other words, by trying to enforce your interpreation, you system
becomes unworkable, as you can't tell if you can ask a question.
It is the same ∀x ∈ T ((True(T, x) ≡ (T ⊢ x))
that I have been talking about for years except that
it is now grounded in well-founded proof‑theoretic
semantics.
The problem is that systems like this grow faster in power to generate
than your logic grow in power to decide, and either you accept that
some truths are unprovable (and thus accept the truth-conditional
view) or you need to just abandon the ability to actually work in the
system as you can't tell what questions are reasonable.
All you are doing is proving that you are just too stupid to
understand the implications of what you are talking about, because you
never really understood what the words actually mean.
On 1/16/2026 3:17 AM, Mikko wrote:
On 16/01/2026 01:38, olcott wrote:
On 1/15/2026 3:48 AM, Mikko wrote:
On 14/01/2026 19:28, olcott wrote:
On 1/14/2026 1:40 AM, Mikko wrote:
On 13/01/2026 16:27, olcott wrote:
On 1/13/2026 3:11 AM, Mikko wrote:
On 12/01/2026 16:29, olcott wrote:
On 1/12/2026 4:44 AM, Mikko wrote:
On 11/01/2026 16:18, olcott wrote:
On 1/11/2026 4:13 AM, Mikko wrote:
On 10/01/2026 17:47, olcott wrote:
On 1/10/2026 2:23 AM, Mikko wrote:You can't determine whether the required result is
On 09/01/2026 17:52, olcott wrote:
On 1/9/2026 3:59 AM, Mikko wrote:
On 08/01/2026 16:22, olcott wrote:
On 1/8/2026 4:22 AM, Mikko wrote:The misconception is yours. No expression in the >>>>>>>>>>>>>>>> language of the first
On 07/01/2026 13:54, olcott wrote:
On 1/7/2026 5:49 AM, Mikko wrote:
On 07/01/2026 06:44, olcott wrote:
All deciders essentially: Transform finite string >>>>>>>>>>>>>>>>>>>>> inputs by finite string transformation rules into >>>>>>>>>>>>>>>>>>>>> {Accept, Reject} values.
The counter-example input to requires more than >>>>>>>>>>>>>>>>>>>>> can be derived from finite string transformation >>>>>>>>>>>>>>>>>>>>> rules applied to this specific input thus the >>>>>>>>>>>>>>>>>>>>> Halting Problem requires too much.
In a sense the halting problem asks too much: the >>>>>>>>>>>>>>>>>>>> problem is proven to
be unsolvable. In another sense it asks too little: >>>>>>>>>>>>>>>>>>>> usually we want to
know whether a method halts on every input, not just >>>>>>>>>>>>>>>>>>>> one.
Although the halting problem is unsolvable, there >>>>>>>>>>>>>>>>>>>> are partial solutions
to the halting problem. In particular, every >>>>>>>>>>>>>>>>>>>> counter- example to the
full solution is correctly solved by some partial >>>>>>>>>>>>>>>>>>>> deciders.
*if undecidability is correct then truth itself is >>>>>>>>>>>>>>>>>>> broken*
Depends on whether the word "truth" is interpeted in >>>>>>>>>>>>>>>>>> the standard
sense or in Olcott's sense.
Undecidability is misconception. Self-contradictory >>>>>>>>>>>>>>>>> expressions are correctly rejected as semantically >>>>>>>>>>>>>>>>> incoherent thus form no undecidability or incompleteness. >>>>>>>>>>>>>>>>
order group theory is self-contradictory. But the first >>>>>>>>>>>>>>>> order goupr
theory is incomplete: it is impossible to prove that AB >>>>>>>>>>>>>>>> = BA is true
for every A and every B but it is also impossible to >>>>>>>>>>>>>>>> prove that AB = BA
is false for some A and some B.
All deciders essentially: Transform finite string >>>>>>>>>>>>>>> inputs by finite string transformation rules into >>>>>>>>>>>>>>> {Accept, Reject} values.
When a required result cannot be derived by applying >>>>>>>>>>>>>>> finite string transformation rules to actual finite >>>>>>>>>>>>>>> string inputs, then the required result exceeds the >>>>>>>>>>>>>>> scope of computation and must be rejected as an
incorrect requirement.
No, that does not follow. If a required result cannot be >>>>>>>>>>>>>> derived by
appying a finite string transformation then the it it is >>>>>>>>>>>>>> uncomputable.
Right. Outside the scope of computation. Requiring anything >>>>>>>>>>>>> outside the scope of computation is an incorrect requirement. >>>>>>>>>>>>
computable before
you have the requirement.
*Computation and Undecidability*
https://philpapers.org/go.pl?aid=OLCCAU
We know that there does not exist any finite
string transformations that H can apply to its
input P to derive the halt status of any P
that does the opposite of whatever H returns.
Which only nmakes sense when the requirement that H must
determine
whether the computation presented by its input halts has already >>>>>>>>>> been presented.
*ChatGPT explains how and why I am correct*
*Reinterpretation of undecidability*
The example of P and H demonstrates that what is
often called “undecidable” is better understood as >>>>>>>>>>> ill-posed with respect to computable semantics.
When the specification is constrained to properties >>>>>>>>>>> detectable via finite simulation and finite pattern >>>>>>>>>>> recognition, computation proceeds normally and
correctly. Undecidability only appears when the
specification overreaches that boundary.
It tries to explain but it does not prove.
Its the same thing that I have been saying for years.
It is not that a universal halt decider cannot exist.
It is proven that an universal halt decider does not exist.
“The system adopts Proof-Theoretic Semantics: meaning is
determined by inferential role, and truth is internal to the
theory. A theory T is defined by a finite set of stipulated
atomic statements together with all expressions derivable from
them under the inference rules. The statements belonging to T
constitute its theorems, and these are exactly the statements
that are true-in-T.”
Under a system like the above rough draft all inputs
having pathological self reference such as the halting
problem counter-example input are simply rejected as
non-well-founded. Tarski Undefinability, Gödel's
incompleteness and the halting problem cease to exist.
A Turing
machine cannot determine the halting of all Turing machines and is >>>>>>>> therefore not an universla halt decider.
This is not true in Proof Theoretic Semantics. I
still have to refine my words. I may not have said
that exactly correctly. The result is that in Proof
Theoretic Semantics the counter-example is rejected
as non-well-founded.
That no Turing machine is a halt decider is a proven theorem and a >>>>>> truth about Turing machines. If your "Proof Thoeretic Semnatics"
does not regard it as true then your "Proof Theoretic Semantics"
is incomplete.
My long‑term goal is to make ‘true on the basis of meaning’
computable.
As meaning is not computable, how can "true on the balsis of meaning"
be commputable?
Under *proof‑theoretic semantics*
"true on the basis of meaning expressed in language"
has always been entirely computable.
Have you already put the algorithm to some web page?
I am still working on refining the presentation.
On 1/16/2026 3:17 AM, Mikko wrote:
On 16/01/2026 01:38, olcott wrote:
On 1/15/2026 3:48 AM, Mikko wrote:
On 14/01/2026 19:28, olcott wrote:
On 1/14/2026 1:40 AM, Mikko wrote:
On 13/01/2026 16:27, olcott wrote:
On 1/13/2026 3:11 AM, Mikko wrote:
On 12/01/2026 16:29, olcott wrote:
On 1/12/2026 4:44 AM, Mikko wrote:
On 11/01/2026 16:18, olcott wrote:
On 1/11/2026 4:13 AM, Mikko wrote:
On 10/01/2026 17:47, olcott wrote:
On 1/10/2026 2:23 AM, Mikko wrote:You can't determine whether the required result is
On 09/01/2026 17:52, olcott wrote:
On 1/9/2026 3:59 AM, Mikko wrote:
On 08/01/2026 16:22, olcott wrote:
On 1/8/2026 4:22 AM, Mikko wrote:The misconception is yours. No expression in the >>>>>>>>>>>>>>>> language of the first
On 07/01/2026 13:54, olcott wrote:
On 1/7/2026 5:49 AM, Mikko wrote:
On 07/01/2026 06:44, olcott wrote:
All deciders essentially: Transform finite string >>>>>>>>>>>>>>>>>>>>> inputs by finite string transformation rules into >>>>>>>>>>>>>>>>>>>>> {Accept, Reject} values.
The counter-example input to requires more than >>>>>>>>>>>>>>>>>>>>> can be derived from finite string transformation >>>>>>>>>>>>>>>>>>>>> rules applied to this specific input thus the >>>>>>>>>>>>>>>>>>>>> Halting Problem requires too much.
In a sense the halting problem asks too much: the >>>>>>>>>>>>>>>>>>>> problem is proven to
be unsolvable. In another sense it asks too little: >>>>>>>>>>>>>>>>>>>> usually we want to
know whether a method halts on every input, not just >>>>>>>>>>>>>>>>>>>> one.
Although the halting problem is unsolvable, there >>>>>>>>>>>>>>>>>>>> are partial solutions
to the halting problem. In particular, every >>>>>>>>>>>>>>>>>>>> counter- example to the
full solution is correctly solved by some partial >>>>>>>>>>>>>>>>>>>> deciders.
*if undecidability is correct then truth itself is >>>>>>>>>>>>>>>>>>> broken*
Depends on whether the word "truth" is interpeted in >>>>>>>>>>>>>>>>>> the standard
sense or in Olcott's sense.
Undecidability is misconception. Self-contradictory >>>>>>>>>>>>>>>>> expressions are correctly rejected as semantically >>>>>>>>>>>>>>>>> incoherent thus form no undecidability or incompleteness. >>>>>>>>>>>>>>>>
order group theory is self-contradictory. But the first >>>>>>>>>>>>>>>> order goupr
theory is incomplete: it is impossible to prove that AB >>>>>>>>>>>>>>>> = BA is true
for every A and every B but it is also impossible to >>>>>>>>>>>>>>>> prove that AB = BA
is false for some A and some B.
All deciders essentially: Transform finite string >>>>>>>>>>>>>>> inputs by finite string transformation rules into >>>>>>>>>>>>>>> {Accept, Reject} values.
When a required result cannot be derived by applying >>>>>>>>>>>>>>> finite string transformation rules to actual finite >>>>>>>>>>>>>>> string inputs, then the required result exceeds the >>>>>>>>>>>>>>> scope of computation and must be rejected as an
incorrect requirement.
No, that does not follow. If a required result cannot be >>>>>>>>>>>>>> derived by
appying a finite string transformation then the it it is >>>>>>>>>>>>>> uncomputable.
Right. Outside the scope of computation. Requiring anything >>>>>>>>>>>>> outside the scope of computation is an incorrect requirement. >>>>>>>>>>>>
computable before
you have the requirement.
*Computation and Undecidability*
https://philpapers.org/go.pl?aid=OLCCAU
We know that there does not exist any finite
string transformations that H can apply to its
input P to derive the halt status of any P
that does the opposite of whatever H returns.
Which only nmakes sense when the requirement that H must
determine
whether the computation presented by its input halts has already >>>>>>>>>> been presented.
*ChatGPT explains how and why I am correct*
*Reinterpretation of undecidability*
The example of P and H demonstrates that what is
often called “undecidable” is better understood as >>>>>>>>>>> ill-posed with respect to computable semantics.
When the specification is constrained to properties >>>>>>>>>>> detectable via finite simulation and finite pattern >>>>>>>>>>> recognition, computation proceeds normally and
correctly. Undecidability only appears when the
specification overreaches that boundary.
It tries to explain but it does not prove.
Its the same thing that I have been saying for years.
It is not that a universal halt decider cannot exist.
It is proven that an universal halt decider does not exist.
“The system adopts Proof-Theoretic Semantics: meaning is
determined by inferential role, and truth is internal to the
theory. A theory T is defined by a finite set of stipulated
atomic statements together with all expressions derivable from
them under the inference rules. The statements belonging to T
constitute its theorems, and these are exactly the statements
that are true-in-T.”
Under a system like the above rough draft all inputs
having pathological self reference such as the halting
problem counter-example input are simply rejected as
non-well-founded. Tarski Undefinability, Gödel's
incompleteness and the halting problem cease to exist.
A Turing
machine cannot determine the halting of all Turing machines and is >>>>>>>> therefore not an universla halt decider.
This is not true in Proof Theoretic Semantics. I
still have to refine my words. I may not have said
that exactly correctly. The result is that in Proof
Theoretic Semantics the counter-example is rejected
as non-well-founded.
That no Turing machine is a halt decider is a proven theorem and a >>>>>> truth about Turing machines. If your "Proof Thoeretic Semnatics"
does not regard it as true then your "Proof Theoretic Semantics"
is incomplete.
My long‑term goal is to make ‘true on the basis of meaning’
computable.
As meaning is not computable, how can "true on the balsis of meaning"
be commputable?
Under *proof‑theoretic semantics*
"true on the basis of meaning expressed in language"
has always been entirely computable.
Have you already put the algorithm to some web page?
Proof Theoretic Semantics Blocks Pathological Self-Reference https://philpapers.org/rec/OLCPTS
On 1/16/2026 3:17 AM, Mikko wrote:
On 16/01/2026 01:38, olcott wrote:
On 1/15/2026 3:48 AM, Mikko wrote:
On 14/01/2026 19:28, olcott wrote:
On 1/14/2026 1:40 AM, Mikko wrote:
On 13/01/2026 16:27, olcott wrote:
On 1/13/2026 3:11 AM, Mikko wrote:
On 12/01/2026 16:29, olcott wrote:
On 1/12/2026 4:44 AM, Mikko wrote:
On 11/01/2026 16:18, olcott wrote:
On 1/11/2026 4:13 AM, Mikko wrote:
On 10/01/2026 17:47, olcott wrote:
On 1/10/2026 2:23 AM, Mikko wrote:You can't determine whether the required result is
On 09/01/2026 17:52, olcott wrote:
On 1/9/2026 3:59 AM, Mikko wrote:
On 08/01/2026 16:22, olcott wrote:
On 1/8/2026 4:22 AM, Mikko wrote:The misconception is yours. No expression in the >>>>>>>>>>>>>>>> language of the first
On 07/01/2026 13:54, olcott wrote:
On 1/7/2026 5:49 AM, Mikko wrote:
On 07/01/2026 06:44, olcott wrote:
All deciders essentially: Transform finite string >>>>>>>>>>>>>>>>>>>>> inputs by finite string transformation rules into >>>>>>>>>>>>>>>>>>>>> {Accept, Reject} values.
The counter-example input to requires more than >>>>>>>>>>>>>>>>>>>>> can be derived from finite string transformation >>>>>>>>>>>>>>>>>>>>> rules applied to this specific input thus the >>>>>>>>>>>>>>>>>>>>> Halting Problem requires too much.
In a sense the halting problem asks too much: the >>>>>>>>>>>>>>>>>>>> problem is proven to
be unsolvable. In another sense it asks too little: >>>>>>>>>>>>>>>>>>>> usually we want to
know whether a method halts on every input, not just >>>>>>>>>>>>>>>>>>>> one.
Although the halting problem is unsolvable, there >>>>>>>>>>>>>>>>>>>> are partial solutions
to the halting problem. In particular, every >>>>>>>>>>>>>>>>>>>> counter- example to the
full solution is correctly solved by some partial >>>>>>>>>>>>>>>>>>>> deciders.
*if undecidability is correct then truth itself is >>>>>>>>>>>>>>>>>>> broken*
Depends on whether the word "truth" is interpeted in >>>>>>>>>>>>>>>>>> the standard
sense or in Olcott's sense.
Undecidability is misconception. Self-contradictory >>>>>>>>>>>>>>>>> expressions are correctly rejected as semantically >>>>>>>>>>>>>>>>> incoherent thus form no undecidability or incompleteness. >>>>>>>>>>>>>>>>
order group theory is self-contradictory. But the first >>>>>>>>>>>>>>>> order goupr
theory is incomplete: it is impossible to prove that AB >>>>>>>>>>>>>>>> = BA is true
for every A and every B but it is also impossible to >>>>>>>>>>>>>>>> prove that AB = BA
is false for some A and some B.
All deciders essentially: Transform finite string >>>>>>>>>>>>>>> inputs by finite string transformation rules into >>>>>>>>>>>>>>> {Accept, Reject} values.
When a required result cannot be derived by applying >>>>>>>>>>>>>>> finite string transformation rules to actual finite >>>>>>>>>>>>>>> string inputs, then the required result exceeds the >>>>>>>>>>>>>>> scope of computation and must be rejected as an
incorrect requirement.
No, that does not follow. If a required result cannot be >>>>>>>>>>>>>> derived by
appying a finite string transformation then the it it is >>>>>>>>>>>>>> uncomputable.
Right. Outside the scope of computation. Requiring anything >>>>>>>>>>>>> outside the scope of computation is an incorrect requirement. >>>>>>>>>>>>
computable before
you have the requirement.
*Computation and Undecidability*
https://philpapers.org/go.pl?aid=OLCCAU
We know that there does not exist any finite
string transformations that H can apply to its
input P to derive the halt status of any P
that does the opposite of whatever H returns.
Which only nmakes sense when the requirement that H must
determine
whether the computation presented by its input halts has already >>>>>>>>>> been presented.
*ChatGPT explains how and why I am correct*
*Reinterpretation of undecidability*
The example of P and H demonstrates that what is
often called “undecidable” is better understood as >>>>>>>>>>> ill-posed with respect to computable semantics.
When the specification is constrained to properties >>>>>>>>>>> detectable via finite simulation and finite pattern >>>>>>>>>>> recognition, computation proceeds normally and
correctly. Undecidability only appears when the
specification overreaches that boundary.
It tries to explain but it does not prove.
Its the same thing that I have been saying for years.
It is not that a universal halt decider cannot exist.
It is proven that an universal halt decider does not exist.
“The system adopts Proof-Theoretic Semantics: meaning is
determined by inferential role, and truth is internal to the
theory. A theory T is defined by a finite set of stipulated
atomic statements together with all expressions derivable from
them under the inference rules. The statements belonging to T
constitute its theorems, and these are exactly the statements
that are true-in-T.”
Under a system like the above rough draft all inputs
having pathological self reference such as the halting
problem counter-example input are simply rejected as
non-well-founded. Tarski Undefinability, Gödel's
incompleteness and the halting problem cease to exist.
A Turing
machine cannot determine the halting of all Turing machines and is >>>>>>>> therefore not an universla halt decider.
This is not true in Proof Theoretic Semantics. I
still have to refine my words. I may not have said
that exactly correctly. The result is that in Proof
Theoretic Semantics the counter-example is rejected
as non-well-founded.
That no Turing machine is a halt decider is a proven theorem and a >>>>>> truth about Turing machines. If your "Proof Thoeretic Semnatics"
does not regard it as true then your "Proof Theoretic Semantics"
is incomplete.
My long‑term goal is to make ‘true on the basis of meaning’
computable.
As meaning is not computable, how can "true on the balsis of meaning"
be commputable?
Under *proof‑theoretic semantics*
"true on the basis of meaning expressed in language"
has always been entirely computable.
Have you already put the algorithm to some web page?
Proof Theoretic Semantics Blocks Pathological Self-Reference https://philpapers.org/rec/OLCPTS
| Sysop: | datGSguy |
|---|---|
| Location: | Eugene, OR |
| Users: | 7 |
| Nodes: | 4 (0 / 4) |
| Uptime: | 219:20:43 |
| Calls: | 361 |
| Calls today: | 34 |
| Files: | 14 |
| D/L today: |
70 files (1,117K bytes) |
| Messages: | 5,751 |
| Posted today: | 1 |