On 12/27/2025 7:06 AM, Richard Damon wrote:
On 12/26/25 11:54 PM, olcott wrote:
On 12/26/2025 10:37 PM, Richard Damon wrote:
On 12/26/25 10:48 PM, olcott wrote:
Deciders are a pure function of their inputs
proving that H(P)==0 is correct and the requirement
is not a pure function of the input to H(P)
is an incorrect requirement within the definition:
*Deciders are a pure function of their inputs*
Doesn't follow.
That H generates a 0 result with the input P only says that is what
H computes.
H reports on the actual behavior that its
actual finite string input actually specifies
Then you admit your string was wrong for the question that P was
supposed to make, and thus you LIED that you followed the proof.
All deciders essentially: Transform finite string
inputs by finite string transformation rules into
{Accept, Reject} values.
Yes, but to be a HALT deciders, that mapping needs to match the HALT
function,
That mapping does not exist in the input to H(P)
thus it is an incorrect question for H(P).
Undecidability has always been an error in the
specification.
Halting misconceived?
Bill Stoddart
August 25, 2017
http://www.euroforth.org/ef17/papers/stoddart.pdf
which is whether the machine so described halts when run, or
equivalently, if UTM applied to that input will halt. (NOT a non-UTM
decider, and since H's transform doesn't match the behavior of the
machine the input was said to represent, it isn't a UTM)
P simulated by H is the only correct way of an
infinite set of ways for H to correctly determine
It may be the best it can do, but it isn't sufficient.
Just like if asked someone about the sum of seven and eight, but they
only do arithmatic on their fingers, so they answer "many", the answer
gotten isn't correct.
the actual behavior that its actual finite string
input actually specifies
Nope, that behavior comes from its definition.
Either you admit you LIED that your input was proper for the quesiton,
or that you LIED that H correctly analyized the string.
P was SUPPOSED to be asking H about the behavior of P when run,
If the string you gave was correct for that, H's only correct answer
would be halting.
If the string you specifies a non-halting computation, then it
couldn't have been a specifing the behavior of P when run.
You just don't know what you are talking about.
on the basis of finite string transformation rules
applied to its input finite string.
It may be the only method for H, but isn't the definition of the
property.
All you are doing is PROVING you don't understand the basic concepts
of the problem, like what a Program is, what Behavior is, What a
Representation is, or even what Truth is.
Sorry, but you are just proving your utter stupidity and inability to
learn basic facts.
That doesn't make it the correct answer for a Halt Decider.
You are just proving you (1) don't know what you are talking about,
and (2) don't really care, as you don't try to learn, and thus (3)
you are just proving that you are a stupid and ignorant
pathologically lying idiot.
Why do you think the requirement is not a pure function of its input?
Do you even know what that means?
The Halting function maps THIS P (the one based on your H that says
H(P) -> 0) to Halting.
IT maps EVERY possible machine/input to Halting or Not Halting based
solely on that defined machine/input.
Thus, it *IS* a "Pure Function" of that input.
All you are doing is proving how low your intelegence is as you keep
on repeating your errors, and just refuse to even try to actually
defend your idea, you just repeat the statement that proves you wrong. >>>>
You are likely down to -50 IQ by now, by any scale that measure
logically ability.
On 12/27/25 8:20 AM, olcott wrote:
On 12/27/2025 7:06 AM, Richard Damon wrote:
On 12/26/25 11:54 PM, olcott wrote:
On 12/26/2025 10:37 PM, Richard Damon wrote:
On 12/26/25 10:48 PM, olcott wrote:
Deciders are a pure function of their inputs
proving that H(P)==0 is correct and the requirement
is not a pure function of the input to H(P)
is an incorrect requirement within the definition:
*Deciders are a pure function of their inputs*
Doesn't follow.
That H generates a 0 result with the input P only says that is what >>>>> H computes.
H reports on the actual behavior that its
actual finite string input actually specifies
Then you admit your string was wrong for the question that P was
supposed to make, and thus you LIED that you followed the proof.
All deciders essentially: Transform finite string
inputs by finite string transformation rules into
{Accept, Reject} values.
Yes, but to be a HALT deciders, that mapping needs to match the HALT
function,
That mapping does not exist in the input to H(P)
thus it is an incorrect question for H(P).
Sure it does, or your H just doesn't support a sufficient language.
The existance of UTM says that the sufficient language exists.
Do you not understand the the program P will either Halt or Not, at
least if it IS a program?
That is part of your problem, you have tried to define you P not to be a program, because your H isn't a program, and thus your whole argument is just a stupid category error because you are too stupid to know what you
are supposed to be talking about.
Undecidability has always been an error in the
specification.
Nope, you are just showing you don't know what you are talking about.
Halting misconceived?
Bill Stoddart
August 25, 2017
http://www.euroforth.org/ef17/papers/stoddart.pdf
Shows he doesn't understand the meaning of the terms, as questions to deciders are not allowed to be subjective, or that programs are wholly self-contained, and not make an external reference.
Erroneous arguments do not prove anything, so failing to use the
established definitions negates the arguement,
All you are doing is saying you are too stupid to learn the basics of
the theory, and will just accept what ever someone who mistakenly agrees with you says.
which is whether the machine so described halts when run, or
equivalently, if UTM applied to that input will halt. (NOT a non-UTM
decider, and since H's transform doesn't match the behavior of the
machine the input was said to represent, it isn't a UTM)
P simulated by H is the only correct way of an
infinite set of ways for H to correctly determine
It may be the best it can do, but it isn't sufficient.
Just like if asked someone about the sum of seven and eight, but they
only do arithmatic on their fingers, so they answer "many", the
answer gotten isn't correct.
the actual behavior that its actual finite string
input actually specifies
Nope, that behavior comes from its definition.
Either you admit you LIED that your input was proper for the
quesiton, or that you LIED that H correctly analyized the string.
P was SUPPOSED to be asking H about the behavior of P when run,
If the string you gave was correct for that, H's only correct answer
would be halting.
If the string you specifies a non-halting computation, then it
couldn't have been a specifing the behavior of P when run.
You just don't know what you are talking about.
on the basis of finite string transformation rules
applied to its input finite string.
It may be the only method for H, but isn't the definition of the
property.
All you are doing is PROVING you don't understand the basic concepts
of the problem, like what a Program is, what Behavior is, What a
Representation is, or even what Truth is.
Sorry, but you are just proving your utter stupidity and inability to
learn basic facts.
That doesn't make it the correct answer for a Halt Decider.
You are just proving you (1) don't know what you are talking about, >>>>> and (2) don't really care, as you don't try to learn, and thus (3)
you are just proving that you are a stupid and ignorant
pathologically lying idiot.
Why do you think the requirement is not a pure function of its input? >>>>>
Do you even know what that means?
The Halting function maps THIS P (the one based on your H that says >>>>> H(P) -> 0) to Halting.
IT maps EVERY possible machine/input to Halting or Not Halting
based solely on that defined machine/input.
Thus, it *IS* a "Pure Function" of that input.
All you are doing is proving how low your intelegence is as you
keep on repeating your errors, and just refuse to even try to
actually defend your idea, you just repeat the statement that
proves you wrong.
You are likely down to -50 IQ by now, by any scale that measure
logically ability.
On 12/27/2025 7:35 AM, Richard Damon wrote:
On 12/27/25 8:20 AM, olcott wrote:
On 12/27/2025 7:06 AM, Richard Damon wrote:
On 12/26/25 11:54 PM, olcott wrote:
On 12/26/2025 10:37 PM, Richard Damon wrote:
On 12/26/25 10:48 PM, olcott wrote:
Deciders are a pure function of their inputs
proving that H(P)==0 is correct and the requirement
is not a pure function of the input to H(P)
is an incorrect requirement within the definition:
*Deciders are a pure function of their inputs*
Doesn't follow.
That H generates a 0 result with the input P only says that is
what H computes.
H reports on the actual behavior that its
actual finite string input actually specifies
Then you admit your string was wrong for the question that P was
supposed to make, and thus you LIED that you followed the proof.
All deciders essentially: Transform finite string
inputs by finite string transformation rules into
{Accept, Reject} values.
Yes, but to be a HALT deciders, that mapping needs to match the HALT
function,
That mapping does not exist in the input to H(P)
thus it is an incorrect question for H(P).
Sure it does, or your H just doesn't support a sufficient language.
Show the mapping that H computes on the basis of the
semantics of C to the behavior of UTM(P).
The existance of UTM says that the sufficient language exists.
Do you not understand the the program P will either Halt or Not, at
least if it IS a program?
That is part of your problem, you have tried to define you P not to be
a program, because your H isn't a program, and thus your whole
argument is just a stupid category error because you are too stupid to
know what you are supposed to be talking about.
Undecidability has always been an error in the
specification.
Nope, you are just showing you don't know what you are talking about.
Halting misconceived?
Bill Stoddart
August 25, 2017
http://www.euroforth.org/ef17/papers/stoddart.pdf
Shows he doesn't understand the meaning of the terms, as questions to
deciders are not allowed to be subjective, or that programs are wholly
self-contained, and not make an external reference.
He is a PhD computer science professor
and you don't ever have a bachelors in computer science
Erroneous arguments do not prove anything, so failing to use the
established definitions negates the arguement,
All you are doing is saying you are too stupid to learn the basics of
the theory, and will just accept what ever someone who mistakenly
agrees with you says.
which is whether the machine so described halts when run, or
equivalently, if UTM applied to that input will halt. (NOT a non-UTM
decider, and since H's transform doesn't match the behavior of the
machine the input was said to represent, it isn't a UTM)
P simulated by H is the only correct way of an
infinite set of ways for H to correctly determine
It may be the best it can do, but it isn't sufficient.
Just like if asked someone about the sum of seven and eight, but
they only do arithmatic on their fingers, so they answer "many", the
answer gotten isn't correct.
the actual behavior that its actual finite string
input actually specifies
Nope, that behavior comes from its definition.
Either you admit you LIED that your input was proper for the
quesiton, or that you LIED that H correctly analyized the string.
P was SUPPOSED to be asking H about the behavior of P when run,
If the string you gave was correct for that, H's only correct answer
would be halting.
If the string you specifies a non-halting computation, then it
couldn't have been a specifing the behavior of P when run.
You just don't know what you are talking about.
on the basis of finite string transformation rules
applied to its input finite string.
It may be the only method for H, but isn't the definition of the
property.
All you are doing is PROVING you don't understand the basic concepts
of the problem, like what a Program is, what Behavior is, What a
Representation is, or even what Truth is.
Sorry, but you are just proving your utter stupidity and inability
to learn basic facts.
That doesn't make it the correct answer for a Halt Decider.
You are just proving you (1) don't know what you are talking
about, and (2) don't really care, as you don't try to learn, and
thus (3) you are just proving that you are a stupid and ignorant
pathologically lying idiot.
Why do you think the requirement is not a pure function of its input? >>>>>>
Do you even know what that means?
The Halting function maps THIS P (the one based on your H that
says H(P) -> 0) to Halting.
IT maps EVERY possible machine/input to Halting or Not Halting
based solely on that defined machine/input.
Thus, it *IS* a "Pure Function" of that input.
All you are doing is proving how low your intelegence is as you
keep on repeating your errors, and just refuse to even try to
actually defend your idea, you just repeat the statement that
proves you wrong.
You are likely down to -50 IQ by now, by any scale that measure
logically ability.
On 12/27/25 9:07 AM, olcott wrote:
On 12/27/2025 7:35 AM, Richard Damon wrote:
On 12/27/25 8:20 AM, olcott wrote:
On 12/27/2025 7:06 AM, Richard Damon wrote:
On 12/26/25 11:54 PM, olcott wrote:
On 12/26/2025 10:37 PM, Richard Damon wrote:
On 12/26/25 10:48 PM, olcott wrote:
Deciders are a pure function of their inputs
proving that H(P)==0 is correct and the requirement
is not a pure function of the input to H(P)
is an incorrect requirement within the definition:
*Deciders are a pure function of their inputs*
Doesn't follow.
That H generates a 0 result with the input P only says that is
what H computes.
H reports on the actual behavior that its
actual finite string input actually specifies
Then you admit your string was wrong for the question that P was
supposed to make, and thus you LIED that you followed the proof.
All deciders essentially: Transform finite string
inputs by finite string transformation rules into
{Accept, Reject} values.
Yes, but to be a HALT deciders, that mapping needs to match the
HALT function,
That mapping does not exist in the input to H(P)
thus it is an incorrect question for H(P).
Sure it does, or your H just doesn't support a sufficient language.
Show the mapping that H computes on the basis of the
semantics of C to the behavior of UTM(P).
It doesn't, that is why it is wrong.
H only computes the mapping that it was programed with, and if that
isn't the right mapping, it is just wrong.
On 12/27/2025 8:24 AM, Richard Damon wrote:
On 12/27/25 9:07 AM, olcott wrote:
On 12/27/2025 7:35 AM, Richard Damon wrote:
On 12/27/25 8:20 AM, olcott wrote:
On 12/27/2025 7:06 AM, Richard Damon wrote:
On 12/26/25 11:54 PM, olcott wrote:
On 12/26/2025 10:37 PM, Richard Damon wrote:
On 12/26/25 10:48 PM, olcott wrote:
Deciders are a pure function of their inputs
proving that H(P)==0 is correct and the requirement
is not a pure function of the input to H(P)
is an incorrect requirement within the definition:
*Deciders are a pure function of their inputs*
Doesn't follow.
That H generates a 0 result with the input P only says that is >>>>>>>> what H computes.
H reports on the actual behavior that its
actual finite string input actually specifies
Then you admit your string was wrong for the question that P was
supposed to make, and thus you LIED that you followed the proof.
All deciders essentially: Transform finite string
inputs by finite string transformation rules into
{Accept, Reject} values.
Yes, but to be a HALT deciders, that mapping needs to match the
HALT function,
That mapping does not exist in the input to H(P)
thus it is an incorrect question for H(P).
Sure it does, or your H just doesn't support a sufficient language.
Show the mapping that H computes on the basis of the
semantics of C to the behavior of UTM(P).
It doesn't, that is why it is wrong.
H only computes the mapping that it was programed with, and if that
isn't the right mapping, it is just wrong.
H is required to compute a mapping that does not exist.
There are no finite string transformation rules from
the input to H(P) to the behavior of UTM(P) that H can
possibly apply to P.
Uncomputable literally means outside the scope of
computation.
On 12/27/25 10:01 AM, olcott wrote:
On 12/27/2025 8:24 AM, Richard Damon wrote:
On 12/27/25 9:07 AM, olcott wrote:
On 12/27/2025 7:35 AM, Richard Damon wrote:
On 12/27/25 8:20 AM, olcott wrote:
On 12/27/2025 7:06 AM, Richard Damon wrote:
On 12/26/25 11:54 PM, olcott wrote:
On 12/26/2025 10:37 PM, Richard Damon wrote:
On 12/26/25 10:48 PM, olcott wrote:
Deciders are a pure function of their inputs
proving that H(P)==0 is correct and the requirement
is not a pure function of the input to H(P)
is an incorrect requirement within the definition:
*Deciders are a pure function of their inputs*
Doesn't follow.
That H generates a 0 result with the input P only says that is >>>>>>>>> what H computes.
H reports on the actual behavior that its
actual finite string input actually specifies
Then you admit your string was wrong for the question that P was >>>>>>> supposed to make, and thus you LIED that you followed the proof. >>>>>>>
All deciders essentially: Transform finite string
inputs by finite string transformation rules into
{Accept, Reject} values.
Yes, but to be a HALT deciders, that mapping needs to match the >>>>>>> HALT function,
That mapping does not exist in the input to H(P)
thus it is an incorrect question for H(P).
Sure it does, or your H just doesn't support a sufficient language.
Show the mapping that H computes on the basis of the
semantics of C to the behavior of UTM(P).
It doesn't, that is why it is wrong.
H only computes the mapping that it was programed with, and if that
isn't the right mapping, it is just wrong.
H is required to compute a mapping that does not exist.
The MAPPING EXISTS.
The part it can't compute is [P] -> HALTING, because you defined it to
map that input to non-halting.
You are just showing you are stupid.
There are no finite string transformation rules from
the input to H(P) to the behavior of UTM(P) that H can
possibly apply to P.
Sure there are,
On 12/27/2025 9:10 AM, Richard Damon wrote:
On 12/27/25 10:01 AM, olcott wrote:
On 12/27/2025 8:24 AM, Richard Damon wrote:
On 12/27/25 9:07 AM, olcott wrote:
On 12/27/2025 7:35 AM, Richard Damon wrote:
On 12/27/25 8:20 AM, olcott wrote:
On 12/27/2025 7:06 AM, Richard Damon wrote:
On 12/26/25 11:54 PM, olcott wrote:
On 12/26/2025 10:37 PM, Richard Damon wrote:
On 12/26/25 10:48 PM, olcott wrote:
Deciders are a pure function of their inputs
proving that H(P)==0 is correct and the requirement
is not a pure function of the input to H(P)
is an incorrect requirement within the definition:
*Deciders are a pure function of their inputs*
Doesn't follow.
That H generates a 0 result with the input P only says that is >>>>>>>>>> what H computes.
H reports on the actual behavior that its
actual finite string input actually specifies
Then you admit your string was wrong for the question that P was >>>>>>>> supposed to make, and thus you LIED that you followed the proof. >>>>>>>>
All deciders essentially: Transform finite string
inputs by finite string transformation rules into
{Accept, Reject} values.
Yes, but to be a HALT deciders, that mapping needs to match the >>>>>>>> HALT function,
That mapping does not exist in the input to H(P)
thus it is an incorrect question for H(P).
Sure it does, or your H just doesn't support a sufficient language. >>>>>>
Show the mapping that H computes on the basis of the
semantics of C to the behavior of UTM(P).
It doesn't, that is why it is wrong.
H only computes the mapping that it was programed with, and if that
isn't the right mapping, it is just wrong.
H is required to compute a mapping that does not exist.
The MAPPING EXISTS.
The part it can't compute is [P] -> HALTING, because you defined it to
map that input to non-halting.
You are just showing you are stupid.
There are no finite string transformation rules from
the input to H(P) to the behavior of UTM(P) that H can
possibly apply to P.
Sure there are,
You know that it is categorically impossible
for any decider H to correctly report on the
behavior of input P that does the opposite of
whatever H reports.
https://chatgpt.com/share/694dcae3-a210-8011-b12f-a74007045a4a
On 12/27/25 11:13 AM, olcott wrote:
On 12/27/2025 9:10 AM, Richard Damon wrote:
On 12/27/25 10:01 AM, olcott wrote:
On 12/27/2025 8:24 AM, Richard Damon wrote:
On 12/27/25 9:07 AM, olcott wrote:
On 12/27/2025 7:35 AM, Richard Damon wrote:
On 12/27/25 8:20 AM, olcott wrote:
On 12/27/2025 7:06 AM, Richard Damon wrote:
On 12/26/25 11:54 PM, olcott wrote:
On 12/26/2025 10:37 PM, Richard Damon wrote:
On 12/26/25 10:48 PM, olcott wrote:
Deciders are a pure function of their inputs
proving that H(P)==0 is correct and the requirement
is not a pure function of the input to H(P)
is an incorrect requirement within the definition:
*Deciders are a pure function of their inputs*
Doesn't follow.
That H generates a 0 result with the input P only says that >>>>>>>>>>> is what H computes.
H reports on the actual behavior that its
actual finite string input actually specifies
Then you admit your string was wrong for the question that P >>>>>>>>> was supposed to make, and thus you LIED that you followed the >>>>>>>>> proof.
All deciders essentially: Transform finite string
inputs by finite string transformation rules into
{Accept, Reject} values.
Yes, but to be a HALT deciders, that mapping needs to match the >>>>>>>>> HALT function,
That mapping does not exist in the input to H(P)
thus it is an incorrect question for H(P).
Sure it does, or your H just doesn't support a sufficient language. >>>>>>>
Show the mapping that H computes on the basis of the
semantics of C to the behavior of UTM(P).
It doesn't, that is why it is wrong.
H only computes the mapping that it was programed with, and if that >>>>> isn't the right mapping, it is just wrong.
H is required to compute a mapping that does not exist.
The MAPPING EXISTS.
The part it can't compute is [P] -> HALTING, because you defined it
to map that input to non-halting.
You are just showing you are stupid.
There are no finite string transformation rules from
the input to H(P) to the behavior of UTM(P) that H can
possibly apply to P.
Sure there are,
You know that it is categorically impossible
for any decider H to correctly report on the
behavior of input P that does the opposite of
whatever H reports.
So?
That is what makes the problem uncomputable. Nothing wrong with that.
And that is your problem, you don't understand that some things just
can't be done, even though we may want to do them, and are even allowed
to do it, we just can't.
Just like no law prohibits you from jumping 1000 feet into the air on--
your own, you just aren't able to.
This is why your statements are just proving your stupidity, you keep on trying to say that because H can't actually do that, it is incorrect to
set up a problem that asks it, and you pervert the actual definitions of things to try to make it seem incorrect to do so.
The problem is, as explained, your statement that deciders perform
finite string transformations, while technical correct, is a basically worthless statement, as, since you don't try to describe the limits/
methods of transformations allowed, mean you allow ANY transformation, including the uncomputable ones.
There IS a "transformation" (literally, a changing) that correctly
converts the string that represents the program P to Halting (correct as that is what P does when run), so you can't use your "definition" to say
the question is wrong.
Your problem is you fundamentally don't understand the language of the field, and seem to be grabbing words at random to put together a jargon sentence that you try to force to have a meaning it doesn't have.
The questions that are valid to ask a decider to compute are any total/ complete mapping of input to output.
Note, this sort of mapping CAN be described as a "transform" too.
The issue is that computability, requires that the transform can be
built out of a finite sequence of computable atoms of transformation,
namely a description of a Turing Machine. But this seems beyond your
ability to understand.
It seems part of the problem is you don't understand that H needs to be
*A* program, (as P can't call a set of programs) and thus has *A*
behavior and algorithm, and thus can only do what it is programmed to
do, and thus what it did can't be the criteria for what is allowed, as
it doesn't exist when the question it is designed to answer is posed.
So, what CAN'T be used as a definition of the criteria is what it ends
up doing, which is what you want to to be the requirement.
There ARE programs that can correctly compute the answer for this
particular P, this H, the one that P was built on, just isn't one of
them. Thus, the question about this P *IS* computable, just not by this particular H that gets it wrong.
On 12/25/2025 5:39 PM, olcott wrote:
https://chatgpt.com/share/694dcae3-a210-8011-b12f-a74007045a4a
*Now as a five page PDF file*
https://www.researchgate.net/ publication/399111881_Computation_and_Undecidability
Unfulfilled logical impossibilities are defining
a requirement outside the scope of computation.
Undecidability has always been a misnomer for
unfulfilled logical impossibilities.
It has never been any actual limit to computation.
It has always been a requirement outside the scope
of computation.
On 12/27/25 11:49 AM, olcott wrote:
On 12/25/2025 5:39 PM, olcott wrote:
https://chatgpt.com/share/694dcae3-a210-8011-b12f-a74007045a4a
*Now as a five page PDF file*
https://www.researchgate.net/
publication/399111881_Computation_and_Undecidability
But since Halting *IS* a "Pure Function of finite strings" it isn't
outside the scope of computing for that reason.
On 12/27/25 11:57 AM, olcott wrote:
Unfulfilled logical impossibilities are definingYou are just misusing gobbledygook jargon that doesn't means anything because you just don't understand what you are saying.
a requirement outside the scope of computation.
Undecidability has always been a misnomer for
unfulfilled logical impossibilities.
It has never been any actual limit to computation.
It has always been a requirement outside the scope
of computation.
You have effectively admitted this because you fail to every try to make
a detailed comment about an error pointed out in your statements,
because you are at least subconciously aware that going one level below
your statements to try to explain will make your errors so obvious that
even in your own stupidity you might understand, so your brainwashing
won't let you go there.
Sorry, you have KIILED your reputation, and buried it under your pile of POOP and sent it to that burning lake of fire where you will eventually accompany it for eternity trying to work out how it could possibly be correct, and every time you make one step forward, the truth will be
shown and you go two steps backwards.
On 12/27/2025 11:06 AM, Richard Damon wrote:
On 12/27/25 11:49 AM, olcott wrote:
On 12/25/2025 5:39 PM, olcott wrote:
https://chatgpt.com/share/694dcae3-a210-8011-b12f-a74007045a4a
*Now as a five page PDF file*
https://www.researchgate.net/
publication/399111881_Computation_and_Undecidability
But since Halting *IS* a "Pure Function of finite strings" it isn't
outside the scope of computing for that reason.
Halting *IS* a "Pure Function of finite string INPUTS.
It was never a function of finite string NON-INPUTS.
No one has bothered to notice that for 90 years.
On 12/27/2025 11:11 AM, Richard Damon wrote:
On 12/27/25 11:57 AM, olcott wrote:
Unfulfilled logical impossibilities are definingYou are just misusing gobbledygook jargon that doesn't means anything
a requirement outside the scope of computation.
Undecidability has always been a misnomer for
unfulfilled logical impossibilities.
It has never been any actual limit to computation.
It has always been a requirement outside the scope
of computation.
because you just don't understand what you are saying.
In other words the term: {logically impossible}
is over-your-head. I don't believe that.
You know that the set of square circles in the
same two dimensional plane is empty.
You are merely pretending to not understand
words that conclusively prove that you are wrong.
You have effectively admitted this because you fail to every try to
make a detailed comment about an error pointed out in your statements,
because you are at least subconciously aware that going one level
below your statements to try to explain will make your errors so
obvious that even in your own stupidity you might understand, so your
brainwashing won't let you go there.
Sorry, you have KIILED your reputation, and buried it under your pile
of POOP and sent it to that burning lake of fire where you will
eventually accompany it for eternity trying to work out how it could
possibly be correct, and every time you make one step forward, the
truth will be shown and you go two steps backwards.
I have known that credibility is a fake measure
of correctness since I was a 14 year old boy.
On 12/27/25 12:11 PM, olcott wrote:
On 12/27/2025 11:06 AM, Richard Damon wrote:
On 12/27/25 11:49 AM, olcott wrote:
On 12/25/2025 5:39 PM, olcott wrote:
https://chatgpt.com/share/694dcae3-a210-8011-b12f-a74007045a4a
*Now as a five page PDF file*
https://www.researchgate.net/
publication/399111881_Computation_and_Undecidability
But since Halting *IS* a "Pure Function of finite strings" it isn't
outside the scope of computing for that reason.
Halting *IS* a "Pure Function of finite string INPUTS.
It was never a function of finite string NON-INPUTS.
No one has bothered to notice that for 90 years.
Right.
The Halting function is defined for a string based on the representation rules the decider defines, and the steps of the program so represented
when run.
Thus it *IS* a function of the string that was given to the halt--
decider, assuming your "Halt Decider" is capable of being given the
suitible string.
It seems you don't understand what that means.
The string doesn't change when it is also given to a different machine,
and thus UTM(x) can define the meaning of x to H.
It there isn't a UTM that can use the same representation that your
decider uses, then you decider just can't be given the proper input and
just fails to be a halt decider as a category error.
That is like asking a calculator to give you the meaning of a word.
Since you can't give it words, it can't answer.
If you decider can't take actual fully encoded descriptions of a program (which would allow a UTM to exist) it can't be asked about programs, and thus can't be in the category of a halt decider.
That is like saying your calculator is a perfect dictionary, as it give
the correct definition for every word you enter, since you can't enter words, it is never wrong.
Sorry, you are just proving how stupid you are.
On 12/27/2025 11:23 AM, Richard Damon wrote:
On 12/27/25 12:11 PM, olcott wrote:
On 12/27/2025 11:06 AM, Richard Damon wrote:
On 12/27/25 11:49 AM, olcott wrote:
On 12/25/2025 5:39 PM, olcott wrote:
https://chatgpt.com/share/694dcae3-a210-8011-b12f-a74007045a4a
*Now as a five page PDF file*
https://www.researchgate.net/
publication/399111881_Computation_and_Undecidability
But since Halting *IS* a "Pure Function of finite strings" it isn't
outside the scope of computing for that reason.
Halting *IS* a "Pure Function of finite string INPUTS.
It was never a function of finite string NON-INPUTS.
No one has bothered to notice that for 90 years.
Right.
The Halting function is defined for a string based on the
representation rules the decider defines, and the steps of the program
so represented when run.
Insufficiently precise.
The Halting function computes the mapping from an
actual input finite string to the actual behavior
that this actual input finite string actually specifies.
Thus it *IS* a function of the string that was given to the halt
decider, assuming your "Halt Decider" is capable of being given the
suitible string.
It seems you don't understand what that means.
The string doesn't change when it is also given to a different
machine, and thus UTM(x) can define the meaning of x to H.
It there isn't a UTM that can use the same representation that your
decider uses, then you decider just can't be given the proper input
and just fails to be a halt decider as a category error.
That is like asking a calculator to give you the meaning of a word.
Since you can't give it words, it can't answer.
If you decider can't take actual fully encoded descriptions of a
program (which would allow a UTM to exist) it can't be asked about
programs, and thus can't be in the category of a halt decider.
That is like saying your calculator is a perfect dictionary, as it
give the correct definition for every word you enter, since you can't
enter words, it is never wrong.
Sorry, you are just proving how stupid you are.
On 12/27/25 12:11 PM, olcott wrote:
On 12/27/2025 11:06 AM, Richard Damon wrote:
On 12/27/25 11:49 AM, olcott wrote:
On 12/25/2025 5:39 PM, olcott wrote:
https://chatgpt.com/share/694dcae3-a210-8011-b12f-a74007045a4a
*Now as a five page PDF file*
https://www.researchgate.net/
publication/399111881_Computation_and_Undecidability
But since Halting *IS* a "Pure Function of finite strings" it isn't
outside the scope of computing for that reason.
Halting *IS* a "Pure Function of finite string INPUTS.
It was never a function of finite string NON-INPUTS.
No one has bothered to notice that for 90 years.
Right.
The Halting function is defined for a string based on the representation rules the decider defines, and the steps of the program so represented
when run.
Thus it *IS* a function of the string that was given to the halt--
decider, assuming your "Halt Decider" is capable of being given the
suitible string.
It seems you don't understand what that means.
The string doesn't change when it is also given to a different machine,
and thus UTM(x) can define the meaning of x to H.
It there isn't a UTM that can use the same representation that your
decider uses, then you decider just can't be given the proper input and
just fails to be a halt decider as a category error.
That is like asking a calculator to give you the meaning of a word.
Since you can't give it words, it can't answer.
If you decider can't take actual fully encoded descriptions of a program (which would allow a UTM to exist) it can't be asked about programs, and thus can't be in the category of a halt decider.
That is like saying your calculator is a perfect dictionary, as it give
the correct definition for every word you enter, since you can't enter words, it is never wrong.
Sorry, you are just proving how stupid you are.
On 12/27/2025 11:23 AM, Richard Damon wrote:
On 12/27/25 12:11 PM, olcott wrote:
On 12/27/2025 11:06 AM, Richard Damon wrote:
On 12/27/25 11:49 AM, olcott wrote:
On 12/25/2025 5:39 PM, olcott wrote:
https://chatgpt.com/share/694dcae3-a210-8011-b12f-a74007045a4a
*Now as a five page PDF file*
https://www.researchgate.net/
publication/399111881_Computation_and_Undecidability
But since Halting *IS* a "Pure Function of finite strings" it isn't
outside the scope of computing for that reason.
Halting *IS* a "Pure Function of finite string INPUTS.
It was never a function of finite string NON-INPUTS.
No one has bothered to notice that for 90 years.
Right.
The Halting function is defined for a string based on the
representation rules the decider defines, and the steps of the program
so represented when run.
Insufficiently precise.
[Deciders only] compute the mapping from an
actual input finite string to the actual behavior
that this actual input finite string actually specifies.
Thus it *IS* a function of the string that was given to the halt
decider, assuming your "Halt Decider" is capable of being given the
suitible string.
It seems you don't understand what that means.
The string doesn't change when it is also given to a different
machine, and thus UTM(x) can define the meaning of x to H.
It there isn't a UTM that can use the same representation that your
decider uses, then you decider just can't be given the proper input
and just fails to be a halt decider as a category error.
That is like asking a calculator to give you the meaning of a word.
Since you can't give it words, it can't answer.
If you decider can't take actual fully encoded descriptions of a
program (which would allow a UTM to exist) it can't be asked about
programs, and thus can't be in the category of a halt decider.
That is like saying your calculator is a perfect dictionary, as it
give the correct definition for every word you enter, since you can't
enter words, it is never wrong.
Sorry, you are just proving how stupid you are.
On 12/27/25 1:19 PM, olcott wrote:
On 12/27/2025 11:23 AM, Richard Damon wrote:
On 12/27/25 12:11 PM, olcott wrote:
On 12/27/2025 11:06 AM, Richard Damon wrote:
On 12/27/25 11:49 AM, olcott wrote:
On 12/25/2025 5:39 PM, olcott wrote:
https://chatgpt.com/share/694dcae3-a210-8011-b12f-a74007045a4a
*Now as a five page PDF file*
https://www.researchgate.net/
publication/399111881_Computation_and_Undecidability
But since Halting *IS* a "Pure Function of finite strings" it isn't >>>>> outside the scope of computing for that reason.
Halting *IS* a "Pure Function of finite string INPUTS.
It was never a function of finite string NON-INPUTS.
No one has bothered to notice that for 90 years.
Right.
The Halting function is defined for a string based on the
representation rules the decider defines, and the steps of the
program so represented when run.
Insufficiently precise.
[Deciders only] compute the mapping from an
actual input finite string to the actual behavior
that this actual input finite string actually specifies.
But you seem to confuse Deciders with the Function they are trying to compute.
Probably because you are only a junior programmer, and thus think "functions" just are a programming language feature, instead of a core aspect of defining what we want to be computing.
And, as said, and you haven't defended, so I guess you conceed, if the
input "P" given to H when P calls H(P) doesn't specify the actual
behavior of the program P making that call, you just lied about your P
being the proof program.
And thus your claim that it does not, is just an admittion that your
whole arguement is based on the lie that you claimed it was the proof program, when you admit it wasn't.
Thus it *IS* a function of the string that was given to the halt
decider, assuming your "Halt Decider" is capable of being given the
suitible string.
It seems you don't understand what that means.
The string doesn't change when it is also given to a different
machine, and thus UTM(x) can define the meaning of x to H.
It there isn't a UTM that can use the same representation that your
decider uses, then you decider just can't be given the proper input
and just fails to be a halt decider as a category error.
That is like asking a calculator to give you the meaning of a word.
Since you can't give it words, it can't answer.
If you decider can't take actual fully encoded descriptions of a
program (which would allow a UTM to exist) it can't be asked about
programs, and thus can't be in the category of a halt decider.
That is like saying your calculator is a perfect dictionary, as it
give the correct definition for every word you enter, since you can't
enter words, it is never wrong.
Sorry, you are just proving how stupid you are.
On 12/27/2025 12:27 PM, Richard Damon wrote:
On 12/27/25 1:19 PM, olcott wrote:
On 12/27/2025 11:23 AM, Richard Damon wrote:
On 12/27/25 12:11 PM, olcott wrote:
On 12/27/2025 11:06 AM, Richard Damon wrote:
On 12/27/25 11:49 AM, olcott wrote:
On 12/25/2025 5:39 PM, olcott wrote:
https://chatgpt.com/share/694dcae3-a210-8011-b12f-a74007045a4a >>>>>>>>
*Now as a five page PDF file*
https://www.researchgate.net/
publication/399111881_Computation_and_Undecidability
But since Halting *IS* a "Pure Function of finite strings" it
isn't outside the scope of computing for that reason.
Halting *IS* a "Pure Function of finite string INPUTS.
It was never a function of finite string NON-INPUTS.
No one has bothered to notice that for 90 years.
Right.
The Halting function is defined for a string based on the
representation rules the decider defines, and the steps of the
program so represented when run.
Insufficiently precise.
[Deciders only] compute the mapping from an
actual input finite string to the actual behavior
that this actual input finite string actually specifies.
But you seem to confuse Deciders with the Function they are trying to
compute.
A Truth predicate returns TRUE when an input
finite string is TRUE and FALSE when an input
finite string is FALSE.
True("What time it is?")
True("This sentence is false.")
When we restrict the domain to coherent English
statements this issue (and Tarski Undefinability)
goes away.
The error of the definition of a halt decider has
this same issue. The domain is the set of finite
strings such that the behavior specified by the
INPUT finite string rf?Mrf- is equivalent to UTM(rf?Mrf-).
Probably because you are only a junior programmer, and thus think
"functions" just are a programming language feature, instead of a core
aspect of defining what we want to be computing.
And, as said, and you haven't defended, so I guess you conceed, if the
input "P" given to H when P calls H(P) doesn't specify the actual
behavior of the program P making that call, you just lied about your P
being the proof program.
And thus your claim that it does not, is just an admittion that your
whole arguement is based on the lie that you claimed it was the proof
program, when you admit it wasn't.
Thus it *IS* a function of the string that was given to the halt
decider, assuming your "Halt Decider" is capable of being given the
suitible string.
It seems you don't understand what that means.
The string doesn't change when it is also given to a different
machine, and thus UTM(x) can define the meaning of x to H.
It there isn't a UTM that can use the same representation that your
decider uses, then you decider just can't be given the proper input
and just fails to be a halt decider as a category error.
That is like asking a calculator to give you the meaning of a word.
Since you can't give it words, it can't answer.
If you decider can't take actual fully encoded descriptions of a
program (which would allow a UTM to exist) it can't be asked about
programs, and thus can't be in the category of a halt decider.
That is like saying your calculator is a perfect dictionary, as it
give the correct definition for every word you enter, since you
can't enter words, it is never wrong.
Sorry, you are just proving how stupid you are.
On 12/27/25 1:39 PM, olcott wrote:
On 12/27/2025 12:27 PM, Richard Damon wrote:
On 12/27/25 1:19 PM, olcott wrote:
On 12/27/2025 11:23 AM, Richard Damon wrote:
On 12/27/25 12:11 PM, olcott wrote:
On 12/27/2025 11:06 AM, Richard Damon wrote:
On 12/27/25 11:49 AM, olcott wrote:
On 12/25/2025 5:39 PM, olcott wrote:
https://chatgpt.com/share/694dcae3-a210-8011-b12f-a74007045a4a >>>>>>>>>
*Now as a five page PDF file*
https://www.researchgate.net/
publication/399111881_Computation_and_Undecidability
But since Halting *IS* a "Pure Function of finite strings" it
isn't outside the scope of computing for that reason.
Halting *IS* a "Pure Function of finite string INPUTS.
It was never a function of finite string NON-INPUTS.
No one has bothered to notice that for 90 years.
Right.
The Halting function is defined for a string based on the
representation rules the decider defines, and the steps of the
program so represented when run.
Insufficiently precise.
[Deciders only] compute the mapping from an
actual input finite string to the actual behavior
that this actual input finite string actually specifies.
But you seem to confuse Deciders with the Function they are trying to
compute.
A Truth predicate returns TRUE when an input
finite string is TRUE and FALSE when an input
finite string is FALSE.
No, it returns TRUE when the input finite string is TRUE, and falso otherwise, whether it is FALSE or a non-truth-bearer.
True("What time it is?")
True("This sentence is false.")
When we restrict the domain to coherent English
statements this issue (and Tarski Undefinability)
goes away.
Nope. The problem is the domain is NOT "English statements", but
statements within the field and language of the Formal Logic System.
Something you seem to not understand, because "Formal Logic" has RULES, which you just can't stand.
The error of the definition of a halt decider has
this same issue. The domain is the set of finite
strings such that the behavior specified by the
INPUT finite string rf?Mrf- is equivalent to UTM(rf?Mrf-).
And what is wrong with that?
It ALWAYS has a correct answer.
UTM((M)) will halt if and only if the machine M halts.
A purely objective fact with a binary answer, so suitible for a decision problem.
Probably because you are only a junior programmer, and thus think
"functions" just are a programming language feature, instead of a
core aspect of defining what we want to be computing.
And, as said, and you haven't defended, so I guess you conceed, if
the input "P" given to H when P calls H(P) doesn't specify the actual
behavior of the program P making that call, you just lied about your
P being the proof program.
And thus your claim that it does not, is just an admittion that your
whole arguement is based on the lie that you claimed it was the proof
program, when you admit it wasn't.
Thus it *IS* a function of the string that was given to the halt
decider, assuming your "Halt Decider" is capable of being given the >>>>> suitible string.
It seems you don't understand what that means.
The string doesn't change when it is also given to a different
machine, and thus UTM(x) can define the meaning of x to H.
It there isn't a UTM that can use the same representation that your >>>>> decider uses, then you decider just can't be given the proper input >>>>> and just fails to be a halt decider as a category error.
That is like asking a calculator to give you the meaning of a word. >>>>> Since you can't give it words, it can't answer.
If you decider can't take actual fully encoded descriptions of a
program (which would allow a UTM to exist) it can't be asked about
programs, and thus can't be in the category of a halt decider.
That is like saying your calculator is a perfect dictionary, as it
give the correct definition for every word you enter, since you
can't enter words, it is never wrong.
Sorry, you are just proving how stupid you are.
On 12/27/2025 12:50 PM, Richard Damon wrote:
On 12/27/25 1:39 PM, olcott wrote:
On 12/27/2025 12:27 PM, Richard Damon wrote:
On 12/27/25 1:19 PM, olcott wrote:
On 12/27/2025 11:23 AM, Richard Damon wrote:
On 12/27/25 12:11 PM, olcott wrote:
On 12/27/2025 11:06 AM, Richard Damon wrote:
On 12/27/25 11:49 AM, olcott wrote:
On 12/25/2025 5:39 PM, olcott wrote:
https://chatgpt.com/share/694dcae3-a210-8011-b12f-a74007045a4a >>>>>>>>>>
*Now as a five page PDF file*
https://www.researchgate.net/
publication/399111881_Computation_and_Undecidability
But since Halting *IS* a "Pure Function of finite strings" it >>>>>>>> isn't outside the scope of computing for that reason.
Halting *IS* a "Pure Function of finite string INPUTS.
It was never a function of finite string NON-INPUTS.
No one has bothered to notice that for 90 years.
Right.
The Halting function is defined for a string based on the
representation rules the decider defines, and the steps of the
program so represented when run.
Insufficiently precise.
[Deciders only] compute the mapping from an
actual input finite string to the actual behavior
that this actual input finite string actually specifies.
But you seem to confuse Deciders with the Function they are trying
to compute.
A Truth predicate returns TRUE when an input
finite string is TRUE and FALSE when an input
finite string is FALSE.
No, it returns TRUE when the input finite string is TRUE, and falso
otherwise, whether it is FALSE or a non-truth-bearer.
That would seem to make Tarski wrong before he even got started.
True("What time it is?")
True("This sentence is false.")
When we restrict the domain to coherent English
statements this issue (and Tarski Undefinability)
goes away.
Nope. The problem is the domain is NOT "English statements", but
statements within the field and language of the Formal Logic System.
Something you seem to not understand, because "Formal Logic" has
RULES, which you just can't stand.
This is not it.
The notion that when all semantics fully encoded
syntactically such that True(L,x) is always
Provable(L, x) eliminates undecidability is
more than the "learned by rote memorization" people
can begin to fathom.
The error of the definition of a halt decider has
this same issue. The domain is the set of finite
strings such that the behavior specified by the
INPUT finite string rf?Mrf- is equivalent to UTM(rf?Mrf-).
And what is wrong with that?
It ALWAYS has a correct answer.
UTM((M)) will halt if and only if the machine M halts.
A purely objective fact with a binary answer, so suitible for a
decision problem.
Probably because you are only a junior programmer, and thus think
"functions" just are a programming language feature, instead of a
core aspect of defining what we want to be computing.
And, as said, and you haven't defended, so I guess you conceed, if
the input "P" given to H when P calls H(P) doesn't specify the
actual behavior of the program P making that call, you just lied
about your P being the proof program.
And thus your claim that it does not, is just an admittion that your
whole arguement is based on the lie that you claimed it was the
proof program, when you admit it wasn't.
Thus it *IS* a function of the string that was given to the halt
decider, assuming your "Halt Decider" is capable of being given
the suitible string.
It seems you don't understand what that means.
The string doesn't change when it is also given to a different
machine, and thus UTM(x) can define the meaning of x to H.
It there isn't a UTM that can use the same representation that
your decider uses, then you decider just can't be given the proper >>>>>> input and just fails to be a halt decider as a category error.
That is like asking a calculator to give you the meaning of a
word. Since you can't give it words, it can't answer.
If you decider can't take actual fully encoded descriptions of a
program (which would allow a UTM to exist) it can't be asked about >>>>>> programs, and thus can't be in the category of a halt decider.
That is like saying your calculator is a perfect dictionary, as it >>>>>> give the correct definition for every word you enter, since you
can't enter words, it is never wrong.
Sorry, you are just proving how stupid you are.
On 12/27/25 2:04 PM, olcott wrote:
On 12/27/2025 12:50 PM, Richard Damon wrote:
On 12/27/25 1:39 PM, olcott wrote:
On 12/27/2025 12:27 PM, Richard Damon wrote:
On 12/27/25 1:19 PM, olcott wrote:
On 12/27/2025 11:23 AM, Richard Damon wrote:
On 12/27/25 12:11 PM, olcott wrote:
On 12/27/2025 11:06 AM, Richard Damon wrote:
On 12/27/25 11:49 AM, olcott wrote:
On 12/25/2025 5:39 PM, olcott wrote:
https://chatgpt.com/share/694dcae3-a210-8011-b12f-a74007045a4a >>>>>>>>>>>
*Now as a five page PDF file*
https://www.researchgate.net/
publication/399111881_Computation_and_Undecidability
But since Halting *IS* a "Pure Function of finite strings" it >>>>>>>>> isn't outside the scope of computing for that reason.
Halting *IS* a "Pure Function of finite string INPUTS.
It was never a function of finite string NON-INPUTS.
No one has bothered to notice that for 90 years.
Right.
The Halting function is defined for a string based on the
representation rules the decider defines, and the steps of the
program so represented when run.
Insufficiently precise.
[Deciders only] compute the mapping from an
actual input finite string to the actual behavior
that this actual input finite string actually specifies.
But you seem to confuse Deciders with the Function they are trying
to compute.
A Truth predicate returns TRUE when an input
finite string is TRUE and FALSE when an input
finite string is FALSE.
No, it returns TRUE when the input finite string is TRUE, and falso
otherwise, whether it is FALSE or a non-truth-bearer.
That would seem to make Tarski wrong before he even got started.
Why do you say that?
Your problem is you don't know what you are talking about.
Your don't know what Truth means, particuarly within a Formal System, because you don't understand what that is.
True("What time it is?")
True("This sentence is false.")
When we restrict the domain to coherent English
statements this issue (and Tarski Undefinability)
goes away.
Nope. The problem is the domain is NOT "English statements", but
statements within the field and language of the Formal Logic System.
Something you seem to not understand, because "Formal Logic" has
RULES, which you just can't stand.
This is not it.
The notion that when all semantics fully encoded
syntactically such that True(L,x) is always
Provable(L, x) eliminates undecidability is
more than the "learned by rote memorization" people
can begin to fathom.
But he shows this doesn't work.
What has been shown is that if you logic system can support the
properties of the natural numbers, you can make a statement that must be true, but can't be proven in the system.
Your problem is you can't understand such a system, because your mind is just to small.
The error of the definition of a halt decider has
this same issue. The domain is the set of finite
strings such that the behavior specified by the
INPUT finite string rf?Mrf- is equivalent to UTM(rf?Mrf-).
And what is wrong with that?
It ALWAYS has a correct answer.
UTM((M)) will halt if and only if the machine M halts.
A purely objective fact with a binary answer, so suitible for a
decision problem.
Probably because you are only a junior programmer, and thus think
"functions" just are a programming language feature, instead of a
core aspect of defining what we want to be computing.
And, as said, and you haven't defended, so I guess you conceed, if
the input "P" given to H when P calls H(P) doesn't specify the
actual behavior of the program P making that call, you just lied
about your P being the proof program.
And thus your claim that it does not, is just an admittion that
your whole arguement is based on the lie that you claimed it was
the proof program, when you admit it wasn't.
Thus it *IS* a function of the string that was given to the halt >>>>>>> decider, assuming your "Halt Decider" is capable of being given >>>>>>> the suitible string.
It seems you don't understand what that means.
The string doesn't change when it is also given to a different
machine, and thus UTM(x) can define the meaning of x to H.
It there isn't a UTM that can use the same representation that
your decider uses, then you decider just can't be given the
proper input and just fails to be a halt decider as a category
error.
That is like asking a calculator to give you the meaning of a
word. Since you can't give it words, it can't answer.
If you decider can't take actual fully encoded descriptions of a >>>>>>> program (which would allow a UTM to exist) it can't be asked
about programs, and thus can't be in the category of a halt decider. >>>>>>>
That is like saying your calculator is a perfect dictionary, as >>>>>>> it give the correct definition for every word you enter, since
you can't enter words, it is never wrong.
Sorry, you are just proving how stupid you are.
On 12/27/2025 1:11 PM, Richard Damon wrote:
On 12/27/25 2:04 PM, olcott wrote:
On 12/27/2025 12:50 PM, Richard Damon wrote:
On 12/27/25 1:39 PM, olcott wrote:
On 12/27/2025 12:27 PM, Richard Damon wrote:
On 12/27/25 1:19 PM, olcott wrote:
On 12/27/2025 11:23 AM, Richard Damon wrote:
On 12/27/25 12:11 PM, olcott wrote:
On 12/27/2025 11:06 AM, Richard Damon wrote:
On 12/27/25 11:49 AM, olcott wrote:
On 12/25/2025 5:39 PM, olcott wrote:
https://chatgpt.com/share/694dcae3-a210-8011-b12f-a74007045a4a >>>>>>>>>>>>
*Now as a five page PDF file*
https://www.researchgate.net/
publication/399111881_Computation_and_Undecidability
But since Halting *IS* a "Pure Function of finite strings" it >>>>>>>>>> isn't outside the scope of computing for that reason.
Halting *IS* a "Pure Function of finite string INPUTS.
It was never a function of finite string NON-INPUTS.
No one has bothered to notice that for 90 years.
Right.
The Halting function is defined for a string based on the
representation rules the decider defines, and the steps of the >>>>>>>> program so represented when run.
Insufficiently precise.
[Deciders only] compute the mapping from an
actual input finite string to the actual behavior
that this actual input finite string actually specifies.
But you seem to confuse Deciders with the Function they are trying >>>>>> to compute.
A Truth predicate returns TRUE when an input
finite string is TRUE and FALSE when an input
finite string is FALSE.
No, it returns TRUE when the input finite string is TRUE, and falso
otherwise, whether it is FALSE or a non-truth-bearer.
That would seem to make Tarski wrong before he even got started.
Why do you say that?
Your problem is you don't know what you are talking about.
Your don't know what Truth means, particuarly within a Formal System,
because you don't understand what that is.
The issue is that formal systems do not know:
"true on the basis of meaning expressed in language"
On 12/27/25 2:26 PM, olcott wrote:
On 12/27/2025 1:11 PM, Richard Damon wrote:
On 12/27/25 2:04 PM, olcott wrote:
On 12/27/2025 12:50 PM, Richard Damon wrote:
On 12/27/25 1:39 PM, olcott wrote:
On 12/27/2025 12:27 PM, Richard Damon wrote:
On 12/27/25 1:19 PM, olcott wrote:
On 12/27/2025 11:23 AM, Richard Damon wrote:
On 12/27/25 12:11 PM, olcott wrote:
On 12/27/2025 11:06 AM, Richard Damon wrote:
On 12/27/25 11:49 AM, olcott wrote:
On 12/25/2025 5:39 PM, olcott wrote:
https://chatgpt.com/share/694dcae3-a210-8011-b12f-a74007045a4a >>>>>>>>>>>>>
*Now as a five page PDF file*
https://www.researchgate.net/
publication/399111881_Computation_and_Undecidability
But since Halting *IS* a "Pure Function of finite strings" it >>>>>>>>>>> isn't outside the scope of computing for that reason.
Halting *IS* a "Pure Function of finite string INPUTS.
It was never a function of finite string NON-INPUTS.
No one has bothered to notice that for 90 years.
Right.
The Halting function is defined for a string based on the
representation rules the decider defines, and the steps of the >>>>>>>>> program so represented when run.
Insufficiently precise.
[Deciders only] compute the mapping from an
actual input finite string to the actual behavior
that this actual input finite string actually specifies.
But you seem to confuse Deciders with the Function they are
trying to compute.
A Truth predicate returns TRUE when an input
finite string is TRUE and FALSE when an input
finite string is FALSE.
No, it returns TRUE when the input finite string is TRUE, and falso >>>>> otherwise, whether it is FALSE or a non-truth-bearer.
That would seem to make Tarski wrong before he even got started.
Why do you say that?
Your problem is you don't know what you are talking about.
Your don't know what Truth means, particuarly within a Formal System,
because you don't understand what that is.
The issue is that formal systems do not know:
"true on the basis of meaning expressed in language"
Sure they do, it is just the language isn't "English".
True is a formal system means that there is a (possible infinite)
sequence of the Truth Preserving operations (defined in the system) from
the Fundamental Truth Makers (axiom) of the system.
The problem is that any statement True by only an infinite sequence of
Truth Preserving operations can't be proven, as Proofs are defined as
Finite sequences.
On 12/27/2025 2:00 PM, Richard Damon wrote:
On 12/27/25 2:26 PM, olcott wrote:
On 12/27/2025 1:11 PM, Richard Damon wrote:
On 12/27/25 2:04 PM, olcott wrote:
On 12/27/2025 12:50 PM, Richard Damon wrote:
On 12/27/25 1:39 PM, olcott wrote:
On 12/27/2025 12:27 PM, Richard Damon wrote:
On 12/27/25 1:19 PM, olcott wrote:
On 12/27/2025 11:23 AM, Richard Damon wrote:
On 12/27/25 12:11 PM, olcott wrote:
On 12/27/2025 11:06 AM, Richard Damon wrote:
On 12/27/25 11:49 AM, olcott wrote:
On 12/25/2025 5:39 PM, olcott wrote:
https://chatgpt.com/share/694dcae3-a210-8011-b12f- >>>>>>>>>>>>>> a74007045a4a
*Now as a five page PDF file*
https://www.researchgate.net/
publication/399111881_Computation_and_Undecidability >>>>>>>>>>>>>
But since Halting *IS* a "Pure Function of finite strings" >>>>>>>>>>>> it isn't outside the scope of computing for that reason. >>>>>>>>>>>>
Halting *IS* a "Pure Function of finite string INPUTS.
It was never a function of finite string NON-INPUTS.
No one has bothered to notice that for 90 years.
Right.
The Halting function is defined for a string based on the >>>>>>>>>> representation rules the decider defines, and the steps of the >>>>>>>>>> program so represented when run.
Insufficiently precise.
[Deciders only] compute the mapping from an
actual input finite string to the actual behavior
that this actual input finite string actually specifies.
But you seem to confuse Deciders with the Function they are
trying to compute.
A Truth predicate returns TRUE when an input
finite string is TRUE and FALSE when an input
finite string is FALSE.
No, it returns TRUE when the input finite string is TRUE, and
falso otherwise, whether it is FALSE or a non-truth-bearer.
That would seem to make Tarski wrong before he even got started.
Why do you say that?
Your problem is you don't know what you are talking about.
Your don't know what Truth means, particuarly within a Formal
System, because you don't understand what that is.
The issue is that formal systems do not know:
"true on the basis of meaning expressed in language"
Sure they do, it is just the language isn't "English".
So you know of a formal system that has every single
detail of its full semantics fully encoded in its syntax
with no reference to any aspect of model theory is needed?
True is a formal system means that there is a (possible infinite)
sequence of the Truth Preserving operations (defined in the system)
from the Fundamental Truth Makers (axiom) of the system.
The problem is that any statement True by only an infinite sequence of
Truth Preserving operations can't be proven, as Proofs are defined as
Finite sequences.
On 12/27/25 3:13 PM, olcott wrote:
On 12/27/2025 2:00 PM, Richard Damon wrote:
On 12/27/25 2:26 PM, olcott wrote:
On 12/27/2025 1:11 PM, Richard Damon wrote:
On 12/27/25 2:04 PM, olcott wrote:
On 12/27/2025 12:50 PM, Richard Damon wrote:
On 12/27/25 1:39 PM, olcott wrote:
On 12/27/2025 12:27 PM, Richard Damon wrote:
On 12/27/25 1:19 PM, olcott wrote:
On 12/27/2025 11:23 AM, Richard Damon wrote:
On 12/27/25 12:11 PM, olcott wrote:
On 12/27/2025 11:06 AM, Richard Damon wrote:
On 12/27/25 11:49 AM, olcott wrote:
On 12/25/2025 5:39 PM, olcott wrote:
https://chatgpt.com/share/694dcae3-a210-8011-b12f- >>>>>>>>>>>>>>> a74007045a4a
*Now as a five page PDF file*
https://www.researchgate.net/
publication/399111881_Computation_and_Undecidability >>>>>>>>>>>>>>
But since Halting *IS* a "Pure Function of finite strings" >>>>>>>>>>>>> it isn't outside the scope of computing for that reason. >>>>>>>>>>>>>
Halting *IS* a "Pure Function of finite string INPUTS. >>>>>>>>>>>> It was never a function of finite string NON-INPUTS.
No one has bothered to notice that for 90 years.
Right.
The Halting function is defined for a string based on the >>>>>>>>>>> representation rules the decider defines, and the steps of >>>>>>>>>>> the program so represented when run.
Insufficiently precise.
[Deciders only] compute the mapping from an
actual input finite string to the actual behavior
that this actual input finite string actually specifies.
But you seem to confuse Deciders with the Function they are >>>>>>>>> trying to compute.
A Truth predicate returns TRUE when an input
finite string is TRUE and FALSE when an input
finite string is FALSE.
No, it returns TRUE when the input finite string is TRUE, and
falso otherwise, whether it is FALSE or a non-truth-bearer.
That would seem to make Tarski wrong before he even got started.
Why do you say that?
Your problem is you don't know what you are talking about.
Your don't know what Truth means, particuarly within a Formal
System, because you don't understand what that is.
The issue is that formal systems do not know:
"true on the basis of meaning expressed in language"
Sure they do, it is just the language isn't "English".
So you know of a formal system that has every single
detail of its full semantics fully encoded in its syntax
with no reference to any aspect of model theory is needed?
Sure, after all, its "semantics" are DEFINED by the logic rules it
defines, which are syntactic.
Many formal system might just define that they use one of the standard
logic formulations that Model Theory describe, because why should the
just repeat all the basic definitions.
Why do you want to avoid references to more basic systems that they
build on?
Would you expect every system that uses numbers to begin with ZFC and re-derive all the number systems they use?
Maybe you should try your own medicine, define YOUR logic system TOTALLY from the fundamental definitions, and not use any existing logical
terms, like semantic entailment, but actually DEFINE what you mean by that.
Try to DEFINE what you FORMALLY mean by semantics.
True is a formal system means that there is a (possible infinite)
sequence of the Truth Preserving operations (defined in the system)
from the Fundamental Truth Makers (axiom) of the system.
The problem is that any statement True by only an infinite sequence
of Truth Preserving operations can't be proven, as Proofs are defined
as Finite sequences.
On 12/27/25 3:13 PM, olcott wrote:
On 12/27/2025 2:00 PM, Richard Damon wrote:
On 12/27/25 2:26 PM, olcott wrote:
On 12/27/2025 1:11 PM, Richard Damon wrote:
On 12/27/25 2:04 PM, olcott wrote:
On 12/27/2025 12:50 PM, Richard Damon wrote:
On 12/27/25 1:39 PM, olcott wrote:
On 12/27/2025 12:27 PM, Richard Damon wrote:
On 12/27/25 1:19 PM, olcott wrote:
On 12/27/2025 11:23 AM, Richard Damon wrote:
On 12/27/25 12:11 PM, olcott wrote:
On 12/27/2025 11:06 AM, Richard Damon wrote:
On 12/27/25 11:49 AM, olcott wrote:
On 12/25/2025 5:39 PM, olcott wrote:
https://chatgpt.com/share/694dcae3-a210-8011-b12f- >>>>>>>>>>>>>>> a74007045a4a
*Now as a five page PDF file*
https://www.researchgate.net/
publication/399111881_Computation_and_Undecidability >>>>>>>>>>>>>>
But since Halting *IS* a "Pure Function of finite strings" >>>>>>>>>>>>> it isn't outside the scope of computing for that reason. >>>>>>>>>>>>>
Halting *IS* a "Pure Function of finite string INPUTS. >>>>>>>>>>>> It was never a function of finite string NON-INPUTS.
No one has bothered to notice that for 90 years.
Right.
The Halting function is defined for a string based on the >>>>>>>>>>> representation rules the decider defines, and the steps of >>>>>>>>>>> the program so represented when run.
Insufficiently precise.
[Deciders only] compute the mapping from an
actual input finite string to the actual behavior
that this actual input finite string actually specifies.
But you seem to confuse Deciders with the Function they are >>>>>>>>> trying to compute.
A Truth predicate returns TRUE when an input
finite string is TRUE and FALSE when an input
finite string is FALSE.
No, it returns TRUE when the input finite string is TRUE, and
falso otherwise, whether it is FALSE or a non-truth-bearer.
That would seem to make Tarski wrong before he even got started.
Why do you say that?
Your problem is you don't know what you are talking about.
Your don't know what Truth means, particuarly within a Formal
System, because you don't understand what that is.
The issue is that formal systems do not know:
"true on the basis of meaning expressed in language"
Sure they do, it is just the language isn't "English".
So you know of a formal system that has every single
detail of its full semantics fully encoded in its syntax
with no reference to any aspect of model theory is needed?
Sure, after all, its "semantics" are DEFINED by the logic rules it
defines, which are syntactic.
Many formal system might just define that they use one of the standard
logic formulations that Model Theory describe, because why should the
just repeat all the basic definitions.
Why do you want to avoid references to more basic systems that they
build on?
Would you expect every system that uses numbers to begin with ZFC and re-derive all the number systems they use?
Maybe you should try your own medicine, define YOUR logic system TOTALLY from the fundamental definitions, and not use any existing logical
terms, like semantic entailment, but actually DEFINE what you mean by that.
Try to DEFINE what you FORMALLY mean by semantics.
True is a formal system means that there is a (possible infinite)
sequence of the Truth Preserving operations (defined in the system)
from the Fundamental Truth Makers (axiom) of the system.
The problem is that any statement True by only an infinite sequence
of Truth Preserving operations can't be proven, as Proofs are defined
as Finite sequences.
On 12/27/2025 2:51 PM, Richard Damon wrote:
On 12/27/25 3:13 PM, olcott wrote:
On 12/27/2025 2:00 PM, Richard Damon wrote:
On 12/27/25 2:26 PM, olcott wrote:
On 12/27/2025 1:11 PM, Richard Damon wrote:
On 12/27/25 2:04 PM, olcott wrote:
On 12/27/2025 12:50 PM, Richard Damon wrote:
On 12/27/25 1:39 PM, olcott wrote:
On 12/27/2025 12:27 PM, Richard Damon wrote:
On 12/27/25 1:19 PM, olcott wrote:
On 12/27/2025 11:23 AM, Richard Damon wrote:
On 12/27/25 12:11 PM, olcott wrote:
On 12/27/2025 11:06 AM, Richard Damon wrote:
On 12/27/25 11:49 AM, olcott wrote:
On 12/25/2025 5:39 PM, olcott wrote:
https://chatgpt.com/share/694dcae3-a210-8011-b12f- >>>>>>>>>>>>>>>> a74007045a4a
*Now as a five page PDF file*
https://www.researchgate.net/
publication/399111881_Computation_and_Undecidability >>>>>>>>>>>>>>>
But since Halting *IS* a "Pure Function of finite strings" >>>>>>>>>>>>>> it isn't outside the scope of computing for that reason. >>>>>>>>>>>>>>
Halting *IS* a "Pure Function of finite string INPUTS. >>>>>>>>>>>>> It was never a function of finite string NON-INPUTS. >>>>>>>>>>>>> No one has bothered to notice that for 90 years.
Right.
The Halting function is defined for a string based on the >>>>>>>>>>>> representation rules the decider defines, and the steps of >>>>>>>>>>>> the program so represented when run.
Insufficiently precise.
[Deciders only] compute the mapping from an
actual input finite string to the actual behavior
that this actual input finite string actually specifies.
But you seem to confuse Deciders with the Function they are >>>>>>>>>> trying to compute.
A Truth predicate returns TRUE when an input
finite string is TRUE and FALSE when an input
finite string is FALSE.
No, it returns TRUE when the input finite string is TRUE, and >>>>>>>> falso otherwise, whether it is FALSE or a non-truth-bearer.
That would seem to make Tarski wrong before he even got started.
Why do you say that?
Your problem is you don't know what you are talking about.
Your don't know what Truth means, particuarly within a Formal
System, because you don't understand what that is.
The issue is that formal systems do not know:
"true on the basis of meaning expressed in language"
Sure they do, it is just the language isn't "English".
So you know of a formal system that has every single
detail of its full semantics fully encoded in its syntax
with no reference to any aspect of model theory is needed?
Sure, after all, its "semantics" are DEFINED by the logic rules it
defines, which are syntactic.
Many formal system might just define that they use one of the standard
logic formulations that Model Theory describe, because why should the
just repeat all the basic definitions.
Why do you want to avoid references to more basic systems that they
build on?
Would you expect every system that uses numbers to begin with ZFC and
re-derive all the number systems they use?
Maybe you should try your own medicine, define YOUR logic system
TOTALLY from the fundamental definitions, and not use any existing
logical terms, like semantic entailment, but actually DEFINE what you
mean by that.
Try to DEFINE what you FORMALLY mean by semantics.
A system such all semantic meaning of the formal
system is directly encoded in the syntax of the
formal language of the formal system making
reCx ree L (Provable(L,x) rei True(L,x))
True is a formal system means that there is a (possible infinite)
sequence of the Truth Preserving operations (defined in the system)
from the Fundamental Truth Makers (axiom) of the system.
The problem is that any statement True by only an infinite sequence
of Truth Preserving operations can't be proven, as Proofs are
defined as Finite sequences.
On 12/27/2025 2:51 PM, Richard Damon wrote:
On 12/27/25 3:13 PM, olcott wrote:
On 12/27/2025 2:00 PM, Richard Damon wrote:
On 12/27/25 2:26 PM, olcott wrote:
On 12/27/2025 1:11 PM, Richard Damon wrote:
On 12/27/25 2:04 PM, olcott wrote:
On 12/27/2025 12:50 PM, Richard Damon wrote:
On 12/27/25 1:39 PM, olcott wrote:
On 12/27/2025 12:27 PM, Richard Damon wrote:
On 12/27/25 1:19 PM, olcott wrote:
On 12/27/2025 11:23 AM, Richard Damon wrote:
On 12/27/25 12:11 PM, olcott wrote:
On 12/27/2025 11:06 AM, Richard Damon wrote:
On 12/27/25 11:49 AM, olcott wrote:
On 12/25/2025 5:39 PM, olcott wrote:
https://chatgpt.com/share/694dcae3-a210-8011-b12f- >>>>>>>>>>>>>>>> a74007045a4a
*Now as a five page PDF file*
https://www.researchgate.net/
publication/399111881_Computation_and_Undecidability >>>>>>>>>>>>>>>
But since Halting *IS* a "Pure Function of finite strings" >>>>>>>>>>>>>> it isn't outside the scope of computing for that reason. >>>>>>>>>>>>>>
Halting *IS* a "Pure Function of finite string INPUTS. >>>>>>>>>>>>> It was never a function of finite string NON-INPUTS. >>>>>>>>>>>>> No one has bothered to notice that for 90 years.
Right.
The Halting function is defined for a string based on the >>>>>>>>>>>> representation rules the decider defines, and the steps of >>>>>>>>>>>> the program so represented when run.
Insufficiently precise.
[Deciders only] compute the mapping from an
actual input finite string to the actual behavior
that this actual input finite string actually specifies.
But you seem to confuse Deciders with the Function they are >>>>>>>>>> trying to compute.
A Truth predicate returns TRUE when an input
finite string is TRUE and FALSE when an input
finite string is FALSE.
No, it returns TRUE when the input finite string is TRUE, and >>>>>>>> falso otherwise, whether it is FALSE or a non-truth-bearer.
That would seem to make Tarski wrong before he even got started.
Why do you say that?
Your problem is you don't know what you are talking about.
Your don't know what Truth means, particuarly within a Formal
System, because you don't understand what that is.
The issue is that formal systems do not know:
"true on the basis of meaning expressed in language"
Sure they do, it is just the language isn't "English".
So you know of a formal system that has every single
detail of its full semantics fully encoded in its syntax
with no reference to any aspect of model theory is needed?
Sure, after all, its "semantics" are DEFINED by the logic rules it
defines, which are syntactic.
That is not the full semantics that with formal
languages always requires a separate "interpretation"
in a model.
Many formal system might just define that they use one of the standard
logic formulations that Model Theory describe, because why should the
just repeat all the basic definitions.
Why do you want to avoid references to more basic systems that they
build on?
Would you expect every system that uses numbers to begin with ZFC and
re-derive all the number systems they use?
Maybe you should try your own medicine, define YOUR logic system
TOTALLY from the fundamental definitions, and not use any existing
logical terms, like semantic entailment, but actually DEFINE what you
mean by that.
Try to DEFINE what you FORMALLY mean by semantics.
True is a formal system means that there is a (possible infinite)
sequence of the Truth Preserving operations (defined in the system)
from the Fundamental Truth Makers (axiom) of the system.
The problem is that any statement True by only an infinite sequence
of Truth Preserving operations can't be proven, as Proofs are
defined as Finite sequences.
On 12/27/25 4:04 PM, olcott wrote:
On 12/27/2025 2:51 PM, Richard Damon wrote:
On 12/27/25 3:13 PM, olcott wrote:
On 12/27/2025 2:00 PM, Richard Damon wrote:
On 12/27/25 2:26 PM, olcott wrote:
On 12/27/2025 1:11 PM, Richard Damon wrote:
On 12/27/25 2:04 PM, olcott wrote:
On 12/27/2025 12:50 PM, Richard Damon wrote:Why do you say that?
On 12/27/25 1:39 PM, olcott wrote:
On 12/27/2025 12:27 PM, Richard Damon wrote:
On 12/27/25 1:19 PM, olcott wrote:
On 12/27/2025 11:23 AM, Richard Damon wrote:But you seem to confuse Deciders with the Function they are >>>>>>>>>>> trying to compute.
On 12/27/25 12:11 PM, olcott wrote:
On 12/27/2025 11:06 AM, Richard Damon wrote:
On 12/27/25 11:49 AM, olcott wrote:
On 12/25/2025 5:39 PM, olcott wrote:
https://chatgpt.com/share/694dcae3-a210-8011-b12f- >>>>>>>>>>>>>>>>> a74007045a4a
*Now as a five page PDF file*
https://www.researchgate.net/
publication/399111881_Computation_and_Undecidability >>>>>>>>>>>>>>>>
But since Halting *IS* a "Pure Function of finite >>>>>>>>>>>>>>> strings" it isn't outside the scope of computing for that >>>>>>>>>>>>>>> reason.
Halting *IS* a "Pure Function of finite string INPUTS. >>>>>>>>>>>>>> It was never a function of finite string NON-INPUTS. >>>>>>>>>>>>>> No one has bothered to notice that for 90 years.
Right.
The Halting function is defined for a string based on the >>>>>>>>>>>>> representation rules the decider defines, and the steps of >>>>>>>>>>>>> the program so represented when run.
Insufficiently precise.
[Deciders only] compute the mapping from an
actual input finite string to the actual behavior
that this actual input finite string actually specifies. >>>>>>>>>>>
A Truth predicate returns TRUE when an input
finite string is TRUE and FALSE when an input
finite string is FALSE.
No, it returns TRUE when the input finite string is TRUE, and >>>>>>>>> falso otherwise, whether it is FALSE or a non-truth-bearer.
That would seem to make Tarski wrong before he even got started. >>>>>>>
Your problem is you don't know what you are talking about.
Your don't know what Truth means, particuarly within a Formal
System, because you don't understand what that is.
The issue is that formal systems do not know:
"true on the basis of meaning expressed in language"
Sure they do, it is just the language isn't "English".
So you know of a formal system that has every single
detail of its full semantics fully encoded in its syntax
with no reference to any aspect of model theory is needed?
Sure, after all, its "semantics" are DEFINED by the logic rules it
defines, which are syntactic.
Many formal system might just define that they use one of the
standard logic formulations that Model Theory describe, because why
should the just repeat all the basic definitions.
Why do you want to avoid references to more basic systems that they
build on?
Would you expect every system that uses numbers to begin with ZFC and
re-derive all the number systems they use?
Maybe you should try your own medicine, define YOUR logic system
TOTALLY from the fundamental definitions, and not use any existing
logical terms, like semantic entailment, but actually DEFINE what you
mean by that.
Try to DEFINE what you FORMALLY mean by semantics.
A system such all semantic meaning of the formal
system is directly encoded in the syntax of the
formal language of the formal system making
reCx ree L (Provable(L,x) rei True(L,x))
Note, this doesn't DEFINE semantics, but gives a result of it.
And you don't understand that such a system CAN NOT (by proof)
understand the properties of the Natural Numbers?
For your requirement, ALL truths must derive from only a finite length sequence of operations, and thus is naturally limited in its power.
It can not handle most systems with a countably infinite domain of
regard, so not Natural Numbers, not Finite Strings, not Turing Complete Systems.
True is a formal system means that there is a (possible infinite)
sequence of the Truth Preserving operations (defined in the system) >>>>> from the Fundamental Truth Makers (axiom) of the system.
The problem is that any statement True by only an infinite sequence >>>>> of Truth Preserving operations can't be proven, as Proofs are
defined as Finite sequences.
On 12/27/2025 3:14 PM, Richard Damon wrote:
On 12/27/25 4:04 PM, olcott wrote:
On 12/27/2025 2:51 PM, Richard Damon wrote:
On 12/27/25 3:13 PM, olcott wrote:
On 12/27/2025 2:00 PM, Richard Damon wrote:
On 12/27/25 2:26 PM, olcott wrote:
On 12/27/2025 1:11 PM, Richard Damon wrote:
On 12/27/25 2:04 PM, olcott wrote:
On 12/27/2025 12:50 PM, Richard Damon wrote:Why do you say that?
On 12/27/25 1:39 PM, olcott wrote:
On 12/27/2025 12:27 PM, Richard Damon wrote:
On 12/27/25 1:19 PM, olcott wrote:
On 12/27/2025 11:23 AM, Richard Damon wrote:But you seem to confuse Deciders with the Function they are >>>>>>>>>>>> trying to compute.
On 12/27/25 12:11 PM, olcott wrote:
On 12/27/2025 11:06 AM, Richard Damon wrote:
On 12/27/25 11:49 AM, olcott wrote:
On 12/25/2025 5:39 PM, olcott wrote:
https://chatgpt.com/share/694dcae3-a210-8011-b12f- >>>>>>>>>>>>>>>>>> a74007045a4a
*Now as a five page PDF file*
https://www.researchgate.net/
publication/399111881_Computation_and_Undecidability >>>>>>>>>>>>>>>>>
But since Halting *IS* a "Pure Function of finite >>>>>>>>>>>>>>>> strings" it isn't outside the scope of computing for >>>>>>>>>>>>>>>> that reason.
Halting *IS* a "Pure Function of finite string INPUTS. >>>>>>>>>>>>>>> It was never a function of finite string NON-INPUTS. >>>>>>>>>>>>>>> No one has bothered to notice that for 90 years. >>>>>>>>>>>>>>>
Right.
The Halting function is defined for a string based on the >>>>>>>>>>>>>> representation rules the decider defines, and the steps of >>>>>>>>>>>>>> the program so represented when run.
Insufficiently precise.
[Deciders only] compute the mapping from an
actual input finite string to the actual behavior
that this actual input finite string actually specifies. >>>>>>>>>>>>
A Truth predicate returns TRUE when an input
finite string is TRUE and FALSE when an input
finite string is FALSE.
No, it returns TRUE when the input finite string is TRUE, and >>>>>>>>>> falso otherwise, whether it is FALSE or a non-truth-bearer. >>>>>>>>>>
That would seem to make Tarski wrong before he even got started. >>>>>>>>
Your problem is you don't know what you are talking about.
Your don't know what Truth means, particuarly within a Formal >>>>>>>> System, because you don't understand what that is.
The issue is that formal systems do not know:
"true on the basis of meaning expressed in language"
Sure they do, it is just the language isn't "English".
So you know of a formal system that has every single
detail of its full semantics fully encoded in its syntax
with no reference to any aspect of model theory is needed?
Sure, after all, its "semantics" are DEFINED by the logic rules it
defines, which are syntactic.
Many formal system might just define that they use one of the
standard logic formulations that Model Theory describe, because why
should the just repeat all the basic definitions.
Why do you want to avoid references to more basic systems that they
build on?
Would you expect every system that uses numbers to begin with ZFC
and re-derive all the number systems they use?
Maybe you should try your own medicine, define YOUR logic system
TOTALLY from the fundamental definitions, and not use any existing
logical terms, like semantic entailment, but actually DEFINE what
you mean by that.
Try to DEFINE what you FORMALLY mean by semantics.
A system such all semantic meaning of the formal
system is directly encoded in the syntax of the
formal language of the formal system making
reCx ree L (Provable(L,x) rei True(L,x))
Note, this doesn't DEFINE semantics, but gives a result of it.
And you don't understand that such a system CAN NOT (by proof)
understand the properties of the Natural Numbers?
Sure it can.
?- G = not(provable(F, G)).
G = not(provable(F, G)).
?- unify_with_occurs_check(G, not(provable(F, G))).
false.
All LLM systems totally understand exactly what
that means.
For your requirement, ALL truths must derive from only a finite length
sequence of operations, and thus is naturally limited in its power.
Limited to the entire body of general knowledge
+ any specific situation knowledge provided to them.
It can not handle most systems with a countably infinite domain of
regard, so not Natural Numbers, not Finite Strings, not Turing
Complete Systems.
It can handle them at least to the same extent
as humans minds. Algorithmic compression.
True is a formal system means that there is a (possible infinite) >>>>>> sequence of the Truth Preserving operations (defined in the
system) from the Fundamental Truth Makers (axiom) of the system.
The problem is that any statement True by only an infinite
sequence of Truth Preserving operations can't be proven, as Proofs >>>>>> are defined as Finite sequences.
On 12/27/25 4:50 PM, olcott wrote:
On 12/27/2025 3:14 PM, Richard Damon wrote:
On 12/27/25 4:04 PM, olcott wrote:
On 12/27/2025 2:51 PM, Richard Damon wrote:
On 12/27/25 3:13 PM, olcott wrote:
On 12/27/2025 2:00 PM, Richard Damon wrote:
On 12/27/25 2:26 PM, olcott wrote:
On 12/27/2025 1:11 PM, Richard Damon wrote:
On 12/27/25 2:04 PM, olcott wrote:
On 12/27/2025 12:50 PM, Richard Damon wrote:Why do you say that?
On 12/27/25 1:39 PM, olcott wrote:
On 12/27/2025 12:27 PM, Richard Damon wrote:
On 12/27/25 1:19 PM, olcott wrote:
On 12/27/2025 11:23 AM, Richard Damon wrote:But you seem to confuse Deciders with the Function they are >>>>>>>>>>>>> trying to compute.
On 12/27/25 12:11 PM, olcott wrote:
On 12/27/2025 11:06 AM, Richard Damon wrote:
On 12/27/25 11:49 AM, olcott wrote:
On 12/25/2025 5:39 PM, olcott wrote:
https://chatgpt.com/share/694dcae3-a210-8011-b12f- >>>>>>>>>>>>>>>>>>> a74007045a4a
*Now as a five page PDF file*
https://www.researchgate.net/
publication/399111881_Computation_and_Undecidability >>>>>>>>>>>>>>>>>>
But since Halting *IS* a "Pure Function of finite >>>>>>>>>>>>>>>>> strings" it isn't outside the scope of computing for >>>>>>>>>>>>>>>>> that reason.
Halting *IS* a "Pure Function of finite string INPUTS. >>>>>>>>>>>>>>>> It was never a function of finite string NON-INPUTS. >>>>>>>>>>>>>>>> No one has bothered to notice that for 90 years. >>>>>>>>>>>>>>>>
Right.
The Halting function is defined for a string based on the >>>>>>>>>>>>>>> representation rules the decider defines, and the steps >>>>>>>>>>>>>>> of the program so represented when run.
Insufficiently precise.
[Deciders only] compute the mapping from an
actual input finite string to the actual behavior
that this actual input finite string actually specifies. >>>>>>>>>>>>>
A Truth predicate returns TRUE when an input
finite string is TRUE and FALSE when an input
finite string is FALSE.
No, it returns TRUE when the input finite string is TRUE, and >>>>>>>>>>> falso otherwise, whether it is FALSE or a non-truth-bearer. >>>>>>>>>>>
That would seem to make Tarski wrong before he even got started. >>>>>>>>>
Your problem is you don't know what you are talking about.
Your don't know what Truth means, particuarly within a Formal >>>>>>>>> System, because you don't understand what that is.
The issue is that formal systems do not know:
"true on the basis of meaning expressed in language"
Sure they do, it is just the language isn't "English".
So you know of a formal system that has every single
detail of its full semantics fully encoded in its syntax
with no reference to any aspect of model theory is needed?
Sure, after all, its "semantics" are DEFINED by the logic rules it
defines, which are syntactic.
Many formal system might just define that they use one of the
standard logic formulations that Model Theory describe, because why >>>>> should the just repeat all the basic definitions.
Why do you want to avoid references to more basic systems that they >>>>> build on?
Would you expect every system that uses numbers to begin with ZFC
and re-derive all the number systems they use?
Maybe you should try your own medicine, define YOUR logic system
TOTALLY from the fundamental definitions, and not use any existing
logical terms, like semantic entailment, but actually DEFINE what
you mean by that.
Try to DEFINE what you FORMALLY mean by semantics.
A system such all semantic meaning of the formal
system is directly encoded in the syntax of the
formal language of the formal system making
reCx ree L (Provable(L,x) rei True(L,x))
Note, this doesn't DEFINE semantics, but gives a result of it.
And you don't understand that such a system CAN NOT (by proof)
understand the properties of the Natural Numbers?
Sure it can.
?- G = not(provable(F, G)).
That isn't G, that is an interpretation of G, only available in a mete- theory.
All you are doing is showing your stupidity.
G = not(provable(F, G)).
?- unify_with_occurs_check(G, not(provable(F, G))).
false.
Which just shows that Prolog can't handle your meaning.
All LLM systems totally understand exactly what
that means.
No, they can spit out words that make stupid you think they do.
For your requirement, ALL truths must derive from only a finite
length sequence of operations, and thus is naturally limited in its
power.
Limited to the entire body of general knowledge
+ any specific situation knowledge provided to them.
But still limited. And that isn't even a real system.
After all, General Knowledge is an inconsistent set of information
It can not handle most systems with a countably infinite domain of
regard, so not Natural Numbers, not Finite Strings, not Turing
Complete Systems.
It can handle them at least to the same extent
as humans minds. Algorithmic compression.
NOPE, As if it could handle Natural Numbers, then we could create the G
for the system, and it couldn't prove it.
Maybe it could handle everything YOU can comprehend, but that isn't much.
After all, you have shown you can't comprehend Godel's logic, or how infinity works, and it seems you don't actually understand how induction works, so nothine proven by it.
True is a formal system means that there is a (possible infinite) >>>>>>> sequence of the Truth Preserving operations (defined in the
system) from the Fundamental Truth Makers (axiom) of the system. >>>>>>>
The problem is that any statement True by only an infinite
sequence of Truth Preserving operations can't be proven, as
Proofs are defined as Finite sequences.
On 12/27/2025 4:07 PM, Richard Damon wrote:
On 12/27/25 4:50 PM, olcott wrote:
On 12/27/2025 3:14 PM, Richard Damon wrote:
On 12/27/25 4:04 PM, olcott wrote:
On 12/27/2025 2:51 PM, Richard Damon wrote:
On 12/27/25 3:13 PM, olcott wrote:
On 12/27/2025 2:00 PM, Richard Damon wrote:
On 12/27/25 2:26 PM, olcott wrote:
On 12/27/2025 1:11 PM, Richard Damon wrote:
On 12/27/25 2:04 PM, olcott wrote:
On 12/27/2025 12:50 PM, Richard Damon wrote:Why do you say that?
On 12/27/25 1:39 PM, olcott wrote:
On 12/27/2025 12:27 PM, Richard Damon wrote:
On 12/27/25 1:19 PM, olcott wrote:
On 12/27/2025 11:23 AM, Richard Damon wrote:But you seem to confuse Deciders with the Function they >>>>>>>>>>>>>> are trying to compute.
On 12/27/25 12:11 PM, olcott wrote:
On 12/27/2025 11:06 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>> On 12/27/25 11:49 AM, olcott wrote:
On 12/25/2025 5:39 PM, olcott wrote:
https://chatgpt.com/share/694dcae3-a210-8011-b12f- >>>>>>>>>>>>>>>>>>>> a74007045a4a
*Now as a five page PDF file*
https://www.researchgate.net/
publication/399111881_Computation_and_Undecidability >>>>>>>>>>>>>>>>>>>
But since Halting *IS* a "Pure Function of finite >>>>>>>>>>>>>>>>>> strings" it isn't outside the scope of computing for >>>>>>>>>>>>>>>>>> that reason.
Halting *IS* a "Pure Function of finite string INPUTS. >>>>>>>>>>>>>>>>> It was never a function of finite string NON-INPUTS. >>>>>>>>>>>>>>>>> No one has bothered to notice that for 90 years. >>>>>>>>>>>>>>>>>
Right.
The Halting function is defined for a string based on >>>>>>>>>>>>>>>> the representation rules the decider defines, and the >>>>>>>>>>>>>>>> steps of the program so represented when run.
Insufficiently precise.
[Deciders only] compute the mapping from an
actual input finite string to the actual behavior >>>>>>>>>>>>>>> that this actual input finite string actually specifies. >>>>>>>>>>>>>>
A Truth predicate returns TRUE when an input
finite string is TRUE and FALSE when an input
finite string is FALSE.
No, it returns TRUE when the input finite string is TRUE, >>>>>>>>>>>> and falso otherwise, whether it is FALSE or a non-truth-bearer. >>>>>>>>>>>>
That would seem to make Tarski wrong before he even got started. >>>>>>>>>>
Your problem is you don't know what you are talking about. >>>>>>>>>>
Your don't know what Truth means, particuarly within a Formal >>>>>>>>>> System, because you don't understand what that is.
The issue is that formal systems do not know:
"true on the basis of meaning expressed in language"
Sure they do, it is just the language isn't "English".
So you know of a formal system that has every single
detail of its full semantics fully encoded in its syntax
with no reference to any aspect of model theory is needed?
Sure, after all, its "semantics" are DEFINED by the logic rules it >>>>>> defines, which are syntactic.
Many formal system might just define that they use one of the
standard logic formulations that Model Theory describe, because
why should the just repeat all the basic definitions.
Why do you want to avoid references to more basic systems that
they build on?
Would you expect every system that uses numbers to begin with ZFC >>>>>> and re-derive all the number systems they use?
Maybe you should try your own medicine, define YOUR logic system
TOTALLY from the fundamental definitions, and not use any existing >>>>>> logical terms, like semantic entailment, but actually DEFINE what >>>>>> you mean by that.
Try to DEFINE what you FORMALLY mean by semantics.
A system such all semantic meaning of the formal
system is directly encoded in the syntax of the
formal language of the formal system making
reCx ree L (Provable(L,x) rei True(L,x))
Note, this doesn't DEFINE semantics, but gives a result of it.
And you don't understand that such a system CAN NOT (by proof)
understand the properties of the Natural Numbers?
Sure it can.
?- G = not(provable(F, G)).
That isn't G, that is an interpretation of G, only available in a
mete- theory.
All you are doing is showing your stupidity.
G = not(provable(F, G)).
?- unify_with_occurs_check(G, not(provable(F, G))).
false.
Which just shows that Prolog can't handle your meaning.
All LLM systems totally understand exactly what
that means.
No, they can spit out words that make stupid you think they do.
For your requirement, ALL truths must derive from only a finite
length sequence of operations, and thus is naturally limited in its
power.
Limited to the entire body of general knowledge
+ any specific situation knowledge provided to them.
But still limited. And that isn't even a real system.
After all, General Knowledge is an inconsistent set of information
You just can't comprehend that knowledge is
structured in an acyclic directed graph.
It can not handle most systems with a countably infinite domain of
regard, so not Natural Numbers, not Finite Strings, not Turing
Complete Systems.
It can handle them at least to the same extent
as humans minds. Algorithmic compression.
NOPE, As if it could handle Natural Numbers, then we could create the
G for the system, and it couldn't prove it.
It is merely that diagonalization hides the semantic
incoherence that reject's G.
Maybe it could handle everything YOU can comprehend, but that isn't much.
After all, you have shown you can't comprehend Godel's logic, or how
infinity works, and it seems you don't actually understand how
induction works, so nothine proven by it.
True is a formal system means that there is a (possible
infinite) sequence of the Truth Preserving operations (defined >>>>>>>> in the system) from the Fundamental Truth Makers (axiom) of the >>>>>>>> system.
The problem is that any statement True by only an infinite
sequence of Truth Preserving operations can't be proven, as
Proofs are defined as Finite sequences.
On 12/27/25 5:16 PM, olcott wrote:
On 12/27/2025 4:07 PM, Richard Damon wrote:
On 12/27/25 4:50 PM, olcott wrote:
On 12/27/2025 3:14 PM, Richard Damon wrote:
On 12/27/25 4:04 PM, olcott wrote:
On 12/27/2025 2:51 PM, Richard Damon wrote:
On 12/27/25 3:13 PM, olcott wrote:
On 12/27/2025 2:00 PM, Richard Damon wrote:
On 12/27/25 2:26 PM, olcott wrote:
On 12/27/2025 1:11 PM, Richard Damon wrote:
On 12/27/25 2:04 PM, olcott wrote:
On 12/27/2025 12:50 PM, Richard Damon wrote:
On 12/27/25 1:39 PM, olcott wrote:
On 12/27/2025 12:27 PM, Richard Damon wrote:
On 12/27/25 1:19 PM, olcott wrote:
On 12/27/2025 11:23 AM, Richard Damon wrote:But you seem to confuse Deciders with the Function they >>>>>>>>>>>>>>> are trying to compute.
On 12/27/25 12:11 PM, olcott wrote:
On 12/27/2025 11:06 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>> On 12/27/25 11:49 AM, olcott wrote:
On 12/25/2025 5:39 PM, olcott wrote:
https://chatgpt.com/share/694dcae3-a210-8011-b12f- >>>>>>>>>>>>>>>>>>>>> a74007045a4a
*Now as a five page PDF file*
https://www.researchgate.net/
publication/399111881_Computation_and_Undecidability >>>>>>>>>>>>>>>>>>>>
But since Halting *IS* a "Pure Function of finite >>>>>>>>>>>>>>>>>>> strings" it isn't outside the scope of computing for >>>>>>>>>>>>>>>>>>> that reason.
Halting *IS* a "Pure Function of finite string INPUTS. >>>>>>>>>>>>>>>>>> It was never a function of finite string NON-INPUTS. >>>>>>>>>>>>>>>>>> No one has bothered to notice that for 90 years. >>>>>>>>>>>>>>>>>>
Right.
The Halting function is defined for a string based on >>>>>>>>>>>>>>>>> the representation rules the decider defines, and the >>>>>>>>>>>>>>>>> steps of the program so represented when run. >>>>>>>>>>>>>>>>>
Insufficiently precise.
[Deciders only] compute the mapping from an
actual input finite string to the actual behavior >>>>>>>>>>>>>>>> that this actual input finite string actually specifies. >>>>>>>>>>>>>>>
A Truth predicate returns TRUE when an input
finite string is TRUE and FALSE when an input
finite string is FALSE.
No, it returns TRUE when the input finite string is TRUE, >>>>>>>>>>>>> and falso otherwise, whether it is FALSE or a non-truth- >>>>>>>>>>>>> bearer.
That would seem to make Tarski wrong before he even got >>>>>>>>>>>> started.
Why do you say that?
Your problem is you don't know what you are talking about. >>>>>>>>>>>
Your don't know what Truth means, particuarly within a Formal >>>>>>>>>>> System, because you don't understand what that is.
The issue is that formal systems do not know:
"true on the basis of meaning expressed in language"
Sure they do, it is just the language isn't "English".
So you know of a formal system that has every single
detail of its full semantics fully encoded in its syntax
with no reference to any aspect of model theory is needed?
Sure, after all, its "semantics" are DEFINED by the logic rules >>>>>>> it defines, which are syntactic.
Many formal system might just define that they use one of the
standard logic formulations that Model Theory describe, because >>>>>>> why should the just repeat all the basic definitions.
Why do you want to avoid references to more basic systems that
they build on?
Would you expect every system that uses numbers to begin with ZFC >>>>>>> and re-derive all the number systems they use?
Maybe you should try your own medicine, define YOUR logic system >>>>>>> TOTALLY from the fundamental definitions, and not use any
existing logical terms, like semantic entailment, but actually
DEFINE what you mean by that.
Try to DEFINE what you FORMALLY mean by semantics.
A system such all semantic meaning of the formal
system is directly encoded in the syntax of the
formal language of the formal system making
reCx ree L (Provable(L,x) rei True(L,x))
Note, this doesn't DEFINE semantics, but gives a result of it.
And you don't understand that such a system CAN NOT (by proof)
understand the properties of the Natural Numbers?
Sure it can.
?- G = not(provable(F, G)).
That isn't G, that is an interpretation of G, only available in a
mete- theory.
All you are doing is showing your stupidity.
G = not(provable(F, G)).
?- unify_with_occurs_check(G, not(provable(F, G))).
false.
Which just shows that Prolog can't handle your meaning.
All LLM systems totally understand exactly what
that means.
No, they can spit out words that make stupid you think they do.
For your requirement, ALL truths must derive from only a finite
length sequence of operations, and thus is naturally limited in its >>>>> power.
Limited to the entire body of general knowledge
+ any specific situation knowledge provided to them.
But still limited. And that isn't even a real system.
After all, General Knowledge is an inconsistent set of information
You just can't comprehend that knowledge is
structured in an acyclic directed graph.
Nope, it is cyclic,
as our base facts of knowledge are interrelated. The
is on one root fact.
It can not handle most systems with a countably infinite domain of
regard, so not Natural Numbers, not Finite Strings, not Turing
Complete Systems.
It can handle them at least to the same extent
as humans minds. Algorithmic compression.
NOPE, As if it could handle Natural Numbers, then we could create the
G for the system, and it couldn't prove it.
It is merely that diagonalization hides the semantic
incoherence that reject's G.
Nope. It seems you don't understand that G is just a statement that no number statisfies a specific (complicated) Primitive Recursive
Relationship. A Relationship that can ALWAYS, for ANY number, be
evaluated in finite time.
There is no "diagonalization" in G. You are confusing different proof.
The question of G is a pure mathematical question, either a number does
or does not satisfy it.
In other words, your "logic" says some questions with factual answers
are just wrong.
In other words, your logic is proven to be self-inconsistant, as
statements provably true are considered to be illogical.
On 12/27/2025 4:38 PM, Richard Damon wrote:
On 12/27/25 5:16 PM, olcott wrote:
On 12/27/2025 4:07 PM, Richard Damon wrote:
On 12/27/25 4:50 PM, olcott wrote:
On 12/27/2025 3:14 PM, Richard Damon wrote:
On 12/27/25 4:04 PM, olcott wrote:
On 12/27/2025 2:51 PM, Richard Damon wrote:
On 12/27/25 3:13 PM, olcott wrote:
On 12/27/2025 2:00 PM, Richard Damon wrote:
On 12/27/25 2:26 PM, olcott wrote:
On 12/27/2025 1:11 PM, Richard Damon wrote:
On 12/27/25 2:04 PM, olcott wrote:
On 12/27/2025 12:50 PM, Richard Damon wrote:
On 12/27/25 1:39 PM, olcott wrote:
On 12/27/2025 12:27 PM, Richard Damon wrote:
On 12/27/25 1:19 PM, olcott wrote:
On 12/27/2025 11:23 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>> On 12/27/25 12:11 PM, olcott wrote:But you seem to confuse Deciders with the Function they >>>>>>>>>>>>>>>> are trying to compute.
On 12/27/2025 11:06 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>> On 12/27/25 11:49 AM, olcott wrote:
On 12/25/2025 5:39 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>
https://chatgpt.com/share/694dcae3-a210-8011-b12f- >>>>>>>>>>>>>>>>>>>>>> a74007045a4a
*Now as a five page PDF file*
https://www.researchgate.net/
publication/399111881_Computation_and_Undecidability >>>>>>>>>>>>>>>>>>>>>
But since Halting *IS* a "Pure Function of finite >>>>>>>>>>>>>>>>>>>> strings" it isn't outside the scope of computing for >>>>>>>>>>>>>>>>>>>> that reason.
Halting *IS* a "Pure Function of finite string INPUTS. >>>>>>>>>>>>>>>>>>> It was never a function of finite string NON-INPUTS. >>>>>>>>>>>>>>>>>>> No one has bothered to notice that for 90 years. >>>>>>>>>>>>>>>>>>>
Right.
The Halting function is defined for a string based on >>>>>>>>>>>>>>>>>> the representation rules the decider defines, and the >>>>>>>>>>>>>>>>>> steps of the program so represented when run. >>>>>>>>>>>>>>>>>>
Insufficiently precise.
[Deciders only] compute the mapping from an
actual input finite string to the actual behavior >>>>>>>>>>>>>>>>> that this actual input finite string actually specifies. >>>>>>>>>>>>>>>>
A Truth predicate returns TRUE when an input
finite string is TRUE and FALSE when an input
finite string is FALSE.
No, it returns TRUE when the input finite string is TRUE, >>>>>>>>>>>>>> and falso otherwise, whether it is FALSE or a non-truth- >>>>>>>>>>>>>> bearer.
That would seem to make Tarski wrong before he even got >>>>>>>>>>>>> started.
Why do you say that?
Your problem is you don't know what you are talking about. >>>>>>>>>>>>
Your don't know what Truth means, particuarly within a >>>>>>>>>>>> Formal System, because you don't understand what that is. >>>>>>>>>>>>
The issue is that formal systems do not know:
"true on the basis of meaning expressed in language"
Sure they do, it is just the language isn't "English".
So you know of a formal system that has every single
detail of its full semantics fully encoded in its syntax
with no reference to any aspect of model theory is needed?
Sure, after all, its "semantics" are DEFINED by the logic rules >>>>>>>> it defines, which are syntactic.
Many formal system might just define that they use one of the >>>>>>>> standard logic formulations that Model Theory describe, because >>>>>>>> why should the just repeat all the basic definitions.
Why do you want to avoid references to more basic systems that >>>>>>>> they build on?
Would you expect every system that uses numbers to begin with >>>>>>>> ZFC and re-derive all the number systems they use?
Maybe you should try your own medicine, define YOUR logic system >>>>>>>> TOTALLY from the fundamental definitions, and not use any
existing logical terms, like semantic entailment, but actually >>>>>>>> DEFINE what you mean by that.
Try to DEFINE what you FORMALLY mean by semantics.
A system such all semantic meaning of the formal
system is directly encoded in the syntax of the
formal language of the formal system making
reCx ree L (Provable(L,x) rei True(L,x))
Note, this doesn't DEFINE semantics, but gives a result of it.
And you don't understand that such a system CAN NOT (by proof)
understand the properties of the Natural Numbers?
Sure it can.
?- G = not(provable(F, G)).
That isn't G, that is an interpretation of G, only available in a
mete- theory.
All you are doing is showing your stupidity.
G = not(provable(F, G)).
?- unify_with_occurs_check(G, not(provable(F, G))).
false.
Which just shows that Prolog can't handle your meaning.
All LLM systems totally understand exactly what
that means.
No, they can spit out words that make stupid you think they do.
For your requirement, ALL truths must derive from only a finite
length sequence of operations, and thus is naturally limited in
its power.
Limited to the entire body of general knowledge
+ any specific situation knowledge provided to them.
But still limited. And that isn't even a real system.
After all, General Knowledge is an inconsistent set of information
You just can't comprehend that knowledge is
structured in an acyclic directed graph.
Nope, it is cyclic,
Show a concrete example of knowledge itself being cyclic.
-aas our base facts of knowledge are interrelated. The is on one root
fact.
You have a type that makes your sentence gibberish.
It can not handle most systems with a countably infinite domain of >>>>>> regard, so not Natural Numbers, not Finite Strings, not Turing
Complete Systems.
It can handle them at least to the same extent
as humans minds. Algorithmic compression.
NOPE, As if it could handle Natural Numbers, then we could create
the G for the system, and it couldn't prove it.
It is merely that diagonalization hides the semantic
incoherence that reject's G.
Nope. It seems you don't understand that G is just a statement that no
number statisfies a specific (complicated) Primitive Recursive
Relationship. A Relationship that can ALWAYS, for ANY number, be
evaluated in finite time.
"that no number satisfies a specific (complicated) Primitive
Recursive Relationship" How is this shown?
There is no "diagonalization" in G. You are confusing different proof.
The question of G is a pure mathematical question, either a number
does or does not satisfy it.
In other words, your "logic" says some questions with factual answers
are just wrong.
In other words, your logic is proven to be self-inconsistant, as
statements provably true are considered to be illogical.
You know that the Liar Paradox: "This sentence is not true"
is not a truth bearer. None-the-less when we add one level
of indirect reference
This sentence is not true: "This sentence is not true"
it becomes true.
On 12/27/25 5:45 PM, olcott wrote:
On 12/27/2025 4:38 PM, Richard Damon wrote:
On 12/27/25 5:16 PM, olcott wrote:
On 12/27/2025 4:07 PM, Richard Damon wrote:
On 12/27/25 4:50 PM, olcott wrote:
On 12/27/2025 3:14 PM, Richard Damon wrote:
On 12/27/25 4:04 PM, olcott wrote:
On 12/27/2025 2:51 PM, Richard Damon wrote:
On 12/27/25 3:13 PM, olcott wrote:
On 12/27/2025 2:00 PM, Richard Damon wrote:
On 12/27/25 2:26 PM, olcott wrote:
On 12/27/2025 1:11 PM, Richard Damon wrote:
On 12/27/25 2:04 PM, olcott wrote:
On 12/27/2025 12:50 PM, Richard Damon wrote:
On 12/27/25 1:39 PM, olcott wrote:
On 12/27/2025 12:27 PM, Richard Damon wrote:
On 12/27/25 1:19 PM, olcott wrote:
On 12/27/2025 11:23 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>> On 12/27/25 12:11 PM, olcott wrote:But you seem to confuse Deciders with the Function they >>>>>>>>>>>>>>>>> are trying to compute.
On 12/27/2025 11:06 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>> On 12/27/25 11:49 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>> On 12/25/2025 5:39 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>
https://chatgpt.com/share/694dcae3-a210-8011- >>>>>>>>>>>>>>>>>>>>>>> b12f- a74007045a4a
*Now as a five page PDF file*
https://www.researchgate.net/
publication/399111881_Computation_and_Undecidability >>>>>>>>>>>>>>>>>>>>>>
But since Halting *IS* a "Pure Function of finite >>>>>>>>>>>>>>>>>>>>> strings" it isn't outside the scope of computing >>>>>>>>>>>>>>>>>>>>> for that reason.
Halting *IS* a "Pure Function of finite string INPUTS. >>>>>>>>>>>>>>>>>>>> It was never a function of finite string NON-INPUTS. >>>>>>>>>>>>>>>>>>>> No one has bothered to notice that for 90 years. >>>>>>>>>>>>>>>>>>>>
Right.
The Halting function is defined for a string based on >>>>>>>>>>>>>>>>>>> the representation rules the decider defines, and the >>>>>>>>>>>>>>>>>>> steps of the program so represented when run. >>>>>>>>>>>>>>>>>>>
Insufficiently precise.
[Deciders only] compute the mapping from an >>>>>>>>>>>>>>>>>> actual input finite string to the actual behavior >>>>>>>>>>>>>>>>>> that this actual input finite string actually specifies. >>>>>>>>>>>>>>>>>
A Truth predicate returns TRUE when an input
finite string is TRUE and FALSE when an input
finite string is FALSE.
No, it returns TRUE when the input finite string is TRUE, >>>>>>>>>>>>>>> and falso otherwise, whether it is FALSE or a non-truth- >>>>>>>>>>>>>>> bearer.
That would seem to make Tarski wrong before he even got >>>>>>>>>>>>>> started.
Why do you say that?
Your problem is you don't know what you are talking about. >>>>>>>>>>>>>
Your don't know what Truth means, particuarly within a >>>>>>>>>>>>> Formal System, because you don't understand what that is. >>>>>>>>>>>>>
The issue is that formal systems do not know:
"true on the basis of meaning expressed in language"
Sure they do, it is just the language isn't "English".
So you know of a formal system that has every single
detail of its full semantics fully encoded in its syntax
with no reference to any aspect of model theory is needed?
Sure, after all, its "semantics" are DEFINED by the logic rules >>>>>>>>> it defines, which are syntactic.
Many formal system might just define that they use one of the >>>>>>>>> standard logic formulations that Model Theory describe, because >>>>>>>>> why should the just repeat all the basic definitions.
Why do you want to avoid references to more basic systems that >>>>>>>>> they build on?
Would you expect every system that uses numbers to begin with >>>>>>>>> ZFC and re-derive all the number systems they use?
Maybe you should try your own medicine, define YOUR logic
system TOTALLY from the fundamental definitions, and not use >>>>>>>>> any existing logical terms, like semantic entailment, but
actually DEFINE what you mean by that.
Try to DEFINE what you FORMALLY mean by semantics.
A system such all semantic meaning of the formal
system is directly encoded in the syntax of the
formal language of the formal system making
reCx ree L (Provable(L,x) rei True(L,x))
Note, this doesn't DEFINE semantics, but gives a result of it.
And you don't understand that such a system CAN NOT (by proof)
understand the properties of the Natural Numbers?
Sure it can.
?- G = not(provable(F, G)).
That isn't G, that is an interpretation of G, only available in a
mete- theory.
All you are doing is showing your stupidity.
G = not(provable(F, G)).
?- unify_with_occurs_check(G, not(provable(F, G))).
false.
Which just shows that Prolog can't handle your meaning.
All LLM systems totally understand exactly what
that means.
No, they can spit out words that make stupid you think they do.
For your requirement, ALL truths must derive from only a finite >>>>>>> length sequence of operations, and thus is naturally limited in >>>>>>> its power.
Limited to the entire body of general knowledge
+ any specific situation knowledge provided to them.
But still limited. And that isn't even a real system.
After all, General Knowledge is an inconsistent set of information
You just can't comprehend that knowledge is
structured in an acyclic directed graph.
Nope, it is cyclic,
Show a concrete example of knowledge itself being cyclic.
Try to define ANY word, and the words used to define it, and so one till
you get to a word that just is without a defintion.
You will always eventually cycle back to a word you have already used.
-aas our base facts of knowledge are interrelated. The is on one root
fact.
You have a type that makes your sentence gibberish.
Yes, I have a typ*o*, as did you
There is no one root fact in our knowledge.
If every fact has other
facts that it is based on, there is no root fact, and the system, since
it is finite, is cyclical.
It can not handle most systems with a countably infinite domain >>>>>>> of regard, so not Natural Numbers, not Finite Strings, not Turing >>>>>>> Complete Systems.
It can handle them at least to the same extent
as humans minds. Algorithmic compression.
NOPE, As if it could handle Natural Numbers, then we could create
the G for the system, and it couldn't prove it.
It is merely that diagonalization hides the semantic
incoherence that reject's G.
Nope. It seems you don't understand that G is just a statement that
no number statisfies a specific (complicated) Primitive Recursive
Relationship. A Relationship that can ALWAYS, for ANY number, be
evaluated in finite time.
"that no number satisfies a specific (complicated) Primitive
Recursive Relationship" How is this shown?
In the meta-theory that undrstands the added meaning to the numbers.
In the base theory, the numbers do not have that meaning, but, since
this meta-theory developes a method to express as a single number ANY statement/collection of statements that can be expressed in the theory,
and, because of the structure of these numbers, can check if a given the given statement is a proof for another statement. And the PRR is an embodeyment of such an algorithm to check if a statement is a proof of
the statement G.
THus *ANY* proof of G, will create a number which will satisfy that PRR, thus making G false.
Since it is impossible for there to be a correct proof of a false
statement, there can not be a number that satisfies the PRR of G, as
that would lead to the contradiction.
This means that no number can staisfy that PRR, and thus G must be true.
This proof can only be done in the meta-system that has the knowledge of
the meaning of all the numbers, and there are an infinite number of
possible systems assigning meaning, so we can't just search them all.
The key is that the meta-system was specifically constructed so that statements, like that G, and its PRR, that do not reference the
additional "facts" the create the meaning, will have the same truth
values in the two systems.
Thus, since G and the PRR meet that requirement, our knowledge in the Meta-System transfers to the base system, but the proof, that uses that knowledge does not.
There is no "diagonalization" in G. You are confusing different proof.
The question of G is a pure mathematical question, either a number
does or does not satisfy it.
In other words, your "logic" says some questions with factual answers
are just wrong.
In other words, your logic is proven to be self-inconsistant, as
statements provably true are considered to be illogical.
You know that the Liar Paradox: "This sentence is not true"
is not a truth bearer. None-the-less when we add one level
of indirect reference
This sentence is not true: "This sentence is not true"
it becomes true.
Yes. So?
The statement G has a truth value, because no number does satisfy the
PRR, and thus it is true.
It can not be proven in the base system, as the only verification would require testing EVERY finite value, of which there are an infinite
number of them, so it doesn't form a proof, but does establish its truth.
This is not true of the Liar's paradox. It just can not have a truth value.
This comes from the fundamental difference between the statements of "I--
am not True" and "I am not Provable".
The first can not have a truth value, as either value creates a contradiction.
This is not true of the second. It can not be false, as if it is false,
then it is provable, so it must be true (as we can only prove true statements in a non-contradictory system),
It CAN be True, as there is no actual requirement of True statments
being provable, as Truth can come out of an infinite number of steps of implication.
It also can be a non-truth-bearer if there isn't anything that makes it true.
The key to the proof is that the statement isn't just a statement of
that form, but a statement that must have a truth value as it is a
statement is about something which follows the law of the excluded
middle, that only derives that meaning when we add additional
information from the meta-system.
On 12/27/2025 5:16 PM, Richard Damon wrote:
On 12/27/25 5:45 PM, olcott wrote:
On 12/27/2025 4:38 PM, Richard Damon wrote:
On 12/27/25 5:16 PM, olcott wrote:
On 12/27/2025 4:07 PM, Richard Damon wrote:
On 12/27/25 4:50 PM, olcott wrote:
On 12/27/2025 3:14 PM, Richard Damon wrote:
On 12/27/25 4:04 PM, olcott wrote:
On 12/27/2025 2:51 PM, Richard Damon wrote:
On 12/27/25 3:13 PM, olcott wrote:
On 12/27/2025 2:00 PM, Richard Damon wrote:Sure, after all, its "semantics" are DEFINED by the logic >>>>>>>>>> rules it defines, which are syntactic.
On 12/27/25 2:26 PM, olcott wrote:
On 12/27/2025 1:11 PM, Richard Damon wrote:
On 12/27/25 2:04 PM, olcott wrote:
On 12/27/2025 12:50 PM, Richard Damon wrote:
On 12/27/25 1:39 PM, olcott wrote:
On 12/27/2025 12:27 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>> On 12/27/25 1:19 PM, olcott wrote:
On 12/27/2025 11:23 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>> On 12/27/25 12:11 PM, olcott wrote:But you seem to confuse Deciders with the Function >>>>>>>>>>>>>>>>>> they are trying to compute.
On 12/27/2025 11:06 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>> On 12/27/25 11:49 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>> On 12/25/2025 5:39 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>
https://chatgpt.com/share/694dcae3-a210-8011- >>>>>>>>>>>>>>>>>>>>>>>> b12f- a74007045a4a
*Now as a five page PDF file*
https://www.researchgate.net/
publication/399111881_Computation_and_Undecidability >>>>>>>>>>>>>>>>>>>>>>>
But since Halting *IS* a "Pure Function of finite >>>>>>>>>>>>>>>>>>>>>> strings" it isn't outside the scope of computing >>>>>>>>>>>>>>>>>>>>>> for that reason.
Halting *IS* a "Pure Function of finite string INPUTS. >>>>>>>>>>>>>>>>>>>>> It was never a function of finite string NON-INPUTS. >>>>>>>>>>>>>>>>>>>>> No one has bothered to notice that for 90 years. >>>>>>>>>>>>>>>>>>>>>
Right.
The Halting function is defined for a string based >>>>>>>>>>>>>>>>>>>> on the representation rules the decider defines, and >>>>>>>>>>>>>>>>>>>> the steps of the program so represented when run. >>>>>>>>>>>>>>>>>>>>
Insufficiently precise.
[Deciders only] compute the mapping from an >>>>>>>>>>>>>>>>>>> actual input finite string to the actual behavior >>>>>>>>>>>>>>>>>>> that this actual input finite string actually specifies. >>>>>>>>>>>>>>>>>>
A Truth predicate returns TRUE when an input >>>>>>>>>>>>>>>>> finite string is TRUE and FALSE when an input >>>>>>>>>>>>>>>>> finite string is FALSE.
No, it returns TRUE when the input finite string is >>>>>>>>>>>>>>>> TRUE, and falso otherwise, whether it is FALSE or a non- >>>>>>>>>>>>>>>> truth- bearer.
That would seem to make Tarski wrong before he even got >>>>>>>>>>>>>>> started.
Why do you say that?
Your problem is you don't know what you are talking about. >>>>>>>>>>>>>>
Your don't know what Truth means, particuarly within a >>>>>>>>>>>>>> Formal System, because you don't understand what that is. >>>>>>>>>>>>>>
The issue is that formal systems do not know:
"true on the basis of meaning expressed in language"
Sure they do, it is just the language isn't "English". >>>>>>>>>>>>
So you know of a formal system that has every single
detail of its full semantics fully encoded in its syntax >>>>>>>>>>> with no reference to any aspect of model theory is needed? >>>>>>>>>>
Many formal system might just define that they use one of the >>>>>>>>>> standard logic formulations that Model Theory describe,
because why should the just repeat all the basic definitions. >>>>>>>>>>
Why do you want to avoid references to more basic systems that >>>>>>>>>> they build on?
Would you expect every system that uses numbers to begin with >>>>>>>>>> ZFC and re-derive all the number systems they use?
Maybe you should try your own medicine, define YOUR logic >>>>>>>>>> system TOTALLY from the fundamental definitions, and not use >>>>>>>>>> any existing logical terms, like semantic entailment, but >>>>>>>>>> actually DEFINE what you mean by that.
Try to DEFINE what you FORMALLY mean by semantics.
A system such all semantic meaning of the formal
system is directly encoded in the syntax of the
formal language of the formal system making
reCx ree L (Provable(L,x) rei True(L,x))
Note, this doesn't DEFINE semantics, but gives a result of it. >>>>>>>>
And you don't understand that such a system CAN NOT (by proof) >>>>>>>> understand the properties of the Natural Numbers?
Sure it can.
?- G = not(provable(F, G)).
That isn't G, that is an interpretation of G, only available in a >>>>>> mete- theory.
All you are doing is showing your stupidity.
G = not(provable(F, G)).
?- unify_with_occurs_check(G, not(provable(F, G))).
false.
Which just shows that Prolog can't handle your meaning.
All LLM systems totally understand exactly what
that means.
No, they can spit out words that make stupid you think they do.
For your requirement, ALL truths must derive from only a finite >>>>>>>> length sequence of operations, and thus is naturally limited in >>>>>>>> its power.
Limited to the entire body of general knowledge
+ any specific situation knowledge provided to them.
But still limited. And that isn't even a real system.
After all, General Knowledge is an inconsistent set of information >>>>>>
You just can't comprehend that knowledge is
structured in an acyclic directed graph.
Nope, it is cyclic,
Show a concrete example of knowledge itself being cyclic.
Try to define ANY word, and the words used to define it, and so one
till you get to a word that just is without a defintion.
You will always eventually cycle back to a word you have already used.
A concrete example is a specific word that does this.
-aas our base facts of knowledge are interrelated. The is on one root >>>> fact.
You have a type that makes your sentence gibberish.
Yes, I have a typ*o*, as did you
There is no one root fact in our knowledge.
{Thing} is the root of the knowledge ontology.
If every fact has other facts that it is based on, there is no root
fact, and the system, since it is finite, is cyclical.
It can not handle most systems with a countably infinite domain >>>>>>>> of regard, so not Natural Numbers, not Finite Strings, not
Turing Complete Systems.
It can handle them at least to the same extent
as humans minds. Algorithmic compression.
NOPE, As if it could handle Natural Numbers, then we could create >>>>>> the G for the system, and it couldn't prove it.
It is merely that diagonalization hides the semantic
incoherence that reject's G.
Nope. It seems you don't understand that G is just a statement that
no number statisfies a specific (complicated) Primitive Recursive
Relationship. A Relationship that can ALWAYS, for ANY number, be
evaluated in finite time.
"that no number satisfies a specific (complicated) Primitive
Recursive Relationship" How is this shown?
In the meta-theory that undrstands the added meaning to the numbers.
Is a separate thing thus not:
A system such all semantic meaning of the formal
system is directly encoded in the syntax of the
formal language of the formal system making
reCx ree L (Provable(L,x) rei True(L,x))
In the base theory, the numbers do not have that meaning, but, since
this meta-theory developes a method to express as a single number ANY
statement/collection of statements that can be expressed in the
theory, and, because of the structure of these numbers, can check if a
given the given statement is a proof for another statement. And the
PRR is an embodeyment of such an algorithm to check if a statement is
a proof of the statement G.
You merely ignored my specified requirements. (see above).
It is possible to defined f-cked up systems that are incomplete
That is not the same thing as all systems are necessarily incomplete.
THus *ANY* proof of G, will create a number which will satisfy that
PRR, thus making G false.
Since it is impossible for there to be a correct proof of a false
statement, there can not be a number that satisfies the PRR of G, as
that would lead to the contradiction.
This means that no number can staisfy that PRR, and thus G must be true.
This proof can only be done in the meta-system that has the knowledge
of the meaning of all the numbers, and there are an infinite number of
possible systems assigning meaning, so we can't just search them all.
The key is that the meta-system was specifically constructed so that
statements, like that G, and its PRR, that do not reference the
additional "facts" the create the meaning, will have the same truth
values in the two systems.
Thus, since G and the PRR meet that requirement, our knowledge in the
Meta-System transfers to the base system, but the proof, that uses
that knowledge does not.
There is no "diagonalization" in G. You are confusing different proof. >>>>
The question of G is a pure mathematical question, either a number
does or does not satisfy it.
In other words, your "logic" says some questions with factual
answers are just wrong.
In other words, your logic is proven to be self-inconsistant, as
statements provably true are considered to be illogical.
You know that the Liar Paradox: "This sentence is not true"
is not a truth bearer. None-the-less when we add one level
of indirect reference
This sentence is not true: "This sentence is not true"
it becomes true.
Yes. So?
The statement G has a truth value, because no number does satisfy the
PRR, and thus it is true.
It can not be proven in the base system, as the only verification
would require testing EVERY finite value, of which there are an
infinite number of them, so it doesn't form a proof, but does
establish its truth.
This is not true of the Liar's paradox. It just can not have a truth
value.
It does not have a truth value in the theory:
"This sentence is not true"
because of pathological self-reference
It does have a truth value in the meta-theory:
This sentence is not true: "This sentence is not true"
because of pathological self-reference has been eliminated.
This comes from the fundamental difference between the statements of
"I am not True" and "I am not Provable".
The first can not have a truth value, as either value creates a
contradiction.
This is not true of the second. It can not be false, as if it is
false, then it is provable, so it must be true (as we can only prove
true statements in a non-contradictory system),
It CAN be True, as there is no actual requirement of True statments
being provable, as Truth can come out of an infinite number of steps
of implication.
It also can be a non-truth-bearer if there isn't anything that makes
it true.
The key to the proof is that the statement isn't just a statement of
that form, but a statement that must have a truth value as it is a
statement is about something which follows the law of the excluded
middle, that only derives that meaning when we add additional
information from the meta-system.
On 12/27/25 5:45 PM, olcott wrote:
On 12/27/2025 4:38 PM, Richard Damon wrote:
On 12/27/25 5:16 PM, olcott wrote:>>>>
You just can't comprehend that knowledge is
structured in an acyclic directed graph.
Nope, it is cyclic,
Show a concrete example of knowledge itself being cyclic.
Try to define ANY word, and the words used to define it, and so one till
you get to a word that just is without a defintion.
You will always eventually cycle back to a word you have already used.
On 12/27/25 5:45 PM, olcott wrote:>>
You have a type that makes your sentence gibberish.
Yes, I have a typ*o*, as did you
There is no one root fact in our knowledge. If every fact has other
facts that it is based on, there is no root fact, and the system, since
it is finite, is cyclical.
On 12/27/2025 5:16 PM, Richard Damon wrote:
On 12/27/25 5:45 PM, olcott wrote:
On 12/27/2025 4:38 PM, Richard Damon wrote:
On 12/27/25 5:16 PM, olcott wrote:>>>>
You just can't comprehend that knowledge is
structured in an acyclic directed graph.
Nope, it is cyclic,
Show a concrete example of knowledge itself being cyclic.
Try to define ANY word, and the words used to define it, and so one
till you get to a word that just is without a defintion.
You will always eventually cycle back to a word you have already used.
Give me an actual word that does this.
On 12/27/2025 5:16 PM, Richard Damon wrote:
On 12/27/25 5:45 PM, olcott wrote:>>
You have a type that makes your sentence gibberish.
Yes, I have a typ*o*, as did you
There is no one root fact in our knowledge. If every fact has other
facts that it is based on, there is no root fact, and the system,
since it is finite, is cyclical.
The root of the
type hierarchy / knowledge ontology is: {Thing}
| Sysop: | Amessyroom |
|---|---|
| Location: | Fayetteville, NC |
| Users: | 54 |
| Nodes: | 6 (0 / 6) |
| Uptime: | 01:43:22 |
| Calls: | 743 |
| Files: | 1,218 |
| Messages: | 187,735 |