On 2025-03-17 01:50:24 +0000, olcott said:

On 3/16/2025 5:50 PM, Richard Damon wrote:

On 3/16/25 11:12 AM, olcott wrote:

On 3/16/2025 7:36 AM, joes wrote:

Am Sat, 15 Mar 2025 20:43:11 -0500 schrieb olcott:

We can define a correct True(X) predicate that always succeeds except >>>>> for unknowns and untruths, Tarski WAS WRONG !!!

That does not disprove Tarski.

He said that this is impossible and no
counter-examples exists that shows that I am wrong.
True(GC) == FALSE Cannot be proven true AKA unknown
True(LP) == FALSE Not a truth-bearer

But if x is what you are saying is

A True(X) predicate can be defined and Tarski never
showed that it cannot.

True(X) only returns TRUE when a a sequence of truth
preserving operations can derive X from the set of basic
facts and returns false otherwise.

By this criterion True("There is no truth predicate") is TRUE.

--
Mikko

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 3/17/25 8:54 AM, olcott wrote:

On 3/17/2025 3:57 AM, Mikko wrote:

On 2025-03-17 01:50:24 +0000, olcott said:

On 3/16/2025 5:50 PM, Richard Damon wrote:

On 3/16/25 11:12 AM, olcott wrote:

On 3/16/2025 7:36 AM, joes wrote:

Am Sat, 15 Mar 2025 20:43:11 -0500 schrieb olcott:

We can define a correct True(X) predicate that always succeeds
except
for unknowns and untruths, Tarski WAS WRONG !!!

That does not disprove Tarski.

He said that this is impossible and no
counter-examples exists that shows that I am wrong.
True(GC) == FALSE Cannot be proven true AKA unknown
True(LP) == FALSE Not a truth-bearer

But if x is what you are saying is

A True(X) predicate can be defined and Tarski never
showed that it cannot.

True(X) only returns TRUE when a a sequence of truth
preserving operations can derive X from the set of basic
facts and returns false otherwise.

By this criterion True("There is no truth predicate") is TRUE.

The True(X) predicate only takes formalized Natural Language so that
would  be rejected as false. LP := ~True(LP) would also be rejected
as ~TRUE. The Principle of explosion does not apply truth preserving operations.

ANd thus you admit that it isn't definable in the logic system that
Tarski as looking at, as it wasn't a "Natural Language" logic system.

In part, because such things aren't actually Formal Logic Systems.

All you are doing is proving that you have been lying about working
withing the parameters of the logic system described, and likely have no understand of what that actually means.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 2025-03-17 12:54:53 +0000, olcott said:

On 3/17/2025 3:57 AM, Mikko wrote:

On 2025-03-17 01:50:24 +0000, olcott said:

On 3/16/2025 5:50 PM, Richard Damon wrote:

On 3/16/25 11:12 AM, olcott wrote:

On 3/16/2025 7:36 AM, joes wrote:

Am Sat, 15 Mar 2025 20:43:11 -0500 schrieb olcott:

We can define a correct True(X) predicate that always succeeds except >>>>>>> for unknowns and untruths, Tarski WAS WRONG !!!

That does not disprove Tarski.

He said that this is impossible and no
counter-examples exists that shows that I am wrong.
True(GC) == FALSE Cannot be proven true AKA unknown
True(LP) == FALSE Not a truth-bearer

But if x is what you are saying is

A True(X) predicate can be defined and Tarski never
showed that it cannot.

True(X) only returns TRUE when a a sequence of truth
preserving operations can derive X from the set of basic
facts and returns false otherwise.

By this criterion True("There is no truth predicate") is TRUE.

The True(X) predicate only takes formalized Natural Language so that
would be rejected as false.

No, if we interprete "There is no truth predicate" to represent the
formalized natural language expression that means that there is no
turth predicate.

LP := ~True(LP) would also be rejected
as ~TRUE. The Principle of explosion does not apply truth preserving operations.

The expression LP := ~True(LP) should be rejected as a syntax error.

--
Mikko

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 3/18/25 11:28 AM, olcott wrote:

On 3/18/2025 9:34 AM, Mikko wrote:

On 2025-03-17 12:54:53 +0000, olcott said:

On 3/17/2025 3:57 AM, Mikko wrote:

On 2025-03-17 01:50:24 +0000, olcott said:

On 3/16/2025 5:50 PM, Richard Damon wrote:

On 3/16/25 11:12 AM, olcott wrote:

On 3/16/2025 7:36 AM, joes wrote:

Am Sat, 15 Mar 2025 20:43:11 -0500 schrieb olcott:

We can define a correct True(X) predicate that always succeeds >>>>>>>>> except
for unknowns and untruths, Tarski WAS WRONG !!!

That does not disprove Tarski.

He said that this is impossible and no
counter-examples exists that shows that I am wrong.
True(GC) == FALSE Cannot be proven true AKA unknown
True(LP) == FALSE Not a truth-bearer

But if x is what you are saying is

A True(X) predicate can be defined and Tarski never
showed that it cannot.

True(X) only returns TRUE when a a sequence of truth
preserving operations can derive X from the set of basic
facts and returns false otherwise.

By this criterion True("There is no truth predicate") is TRUE.

The True(X) predicate only takes formalized Natural Language so that
would  be rejected as false.

No, if we interprete "There is no truth predicate" to represent the
formalized natural language expression that means that there is no
turth predicate.

That is already accounted for by the Liar Paradox.
Every self-contradictory expression cannot be derived
from the set of basic facts by applying ONLY truth
preserving operations.

But it doesn't handle the fact that Tarski showed that the existance of
the Truth Predicate means we can prove that the Liar Paradox statement
must be true.

LP := ~True(LP) would also be rejected
as ~TRUE. The Principle of explosion does not apply truth preserving
operations.

The expression LP := ~True(LP) should be rejected as a syntax error.

Formalized natural language must be able to directly
encode the self-reference of the Liar Paradox
"This sentence is not true" or it is insufficiently
expressive.

So, why does your system have problems with it?

Note, just because the language can express the Liar's Paradox, doesn't
mean that we can't use a metalanguage to build an expression based on
the existance of your truth predicate that proves the liar's paradox
must be true as Tarski did.

Your problem is you just don't understand Tarski's logic enough to
understand what he did, but you just knee-jerk claim it can't be right,
because you can't stand that one of your favorite OPINIONS is proved to
be wrong. All you are doing is showing you don't understand how logic
works, and are too stupid to see your ignorance.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 2025-03-18 15:28:31 +0000, olcott said:

On 3/18/2025 9:34 AM, Mikko wrote:

On 2025-03-17 12:54:53 +0000, olcott said:

On 3/17/2025 3:57 AM, Mikko wrote:

On 2025-03-17 01:50:24 +0000, olcott said:

On 3/16/2025 5:50 PM, Richard Damon wrote:

On 3/16/25 11:12 AM, olcott wrote:

On 3/16/2025 7:36 AM, joes wrote:

Am Sat, 15 Mar 2025 20:43:11 -0500 schrieb olcott:

We can define a correct True(X) predicate that always succeeds except >>>>>>>>> for unknowns and untruths, Tarski WAS WRONG !!!

That does not disprove Tarski.

He said that this is impossible and no
counter-examples exists that shows that I am wrong.
True(GC) == FALSE Cannot be proven true AKA unknown
True(LP) == FALSE Not a truth-bearer

But if x is what you are saying is

A True(X) predicate can be defined and Tarski never
showed that it cannot.

True(X) only returns TRUE when a a sequence of truth
preserving operations can derive X from the set of basic
facts and returns false otherwise.

By this criterion True("There is no truth predicate") is TRUE.

The True(X) predicate only takes formalized Natural Language so that
would  be rejected as false.

No, if we interprete "There is no truth predicate" to represent the
formalized natural language expression that means that there is no
turth predicate.

That is already accounted for by the Liar Paradox.
Every self-contradictory expression cannot be derived
from the set of basic facts by applying ONLY truth
preserving operations.

That depends on "the set of basic facts". OK if they really are facts
but otherwise anything is possible.

LP := ~True(LP) would also be rejected
as ~TRUE. The Principle of explosion does not apply truth preserving
operations.

The expression LP := ~True(LP) should be rejected as a syntax error.

Formalized natural language must be able to directly
encode the self-reference of the Liar Paradox
"This sentence is not true" or it is insufficiently
expressive.

Depends on your definition of "sufficiently". The truth of a sentence
depends on interpretation, so it is not determined by the real world.

--
Mikko

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 3/19/25 7:36 PM, olcott wrote:

On 3/19/2025 9:09 AM, Mikko wrote:

On 2025-03-18 15:28:31 +0000, olcott said:

On 3/18/2025 9:34 AM, Mikko wrote:

On 2025-03-17 12:54:53 +0000, olcott said:

On 3/17/2025 3:57 AM, Mikko wrote:

On 2025-03-17 01:50:24 +0000, olcott said:

On 3/16/2025 5:50 PM, Richard Damon wrote:

On 3/16/25 11:12 AM, olcott wrote:

On 3/16/2025 7:36 AM, joes wrote:

Am Sat, 15 Mar 2025 20:43:11 -0500 schrieb olcott:

We can define a correct True(X) predicate that always
succeeds except
for unknowns and untruths, Tarski WAS WRONG !!!

That does not disprove Tarski.

He said that this is impossible and no
counter-examples exists that shows that I am wrong.
True(GC) == FALSE Cannot be proven true AKA unknown
True(LP) == FALSE Not a truth-bearer

But if x is what you are saying is

A True(X) predicate can be defined and Tarski never
showed that it cannot.

True(X) only returns TRUE when a a sequence of truth
preserving operations can derive X from the set of basic
facts and returns false otherwise.

By this criterion True("There is no truth predicate") is TRUE.

The True(X) predicate only takes formalized Natural Language so that >>>>> would  be rejected as false.

No, if we interprete "There is no truth predicate" to represent the
formalized natural language expression that means that there is no
turth predicate.

That is already accounted for by the Liar Paradox.
Every self-contradictory expression cannot be derived
from the set of basic facts by applying ONLY truth
preserving operations.

That depends on "the set of basic facts". OK if they really are facts
but otherwise anything is possible.

Yes they really are facts thus actual elements of the
set of human general knowledge that can be expressed
using language.

But most of "Human Knowledge" isn't "facts" but just agreed upon
opinions and arbitrary meanings given to words, not objectively true facts.

LP := ~True(LP) would also be rejected
as ~TRUE. The Principle of explosion does not apply truth preserving >>>>> operations.

The expression LP := ~True(LP) should be rejected as a syntax error.

Formalized natural language must be able to directly
encode the self-reference of the Liar Paradox
"This sentence is not true" or it is insufficiently
expressive.

Depends on your definition of "sufficiently". The truth of a sentence
depends on interpretation, so it is not determined by the real world.

The ONLY formal language that I know that can directly
express self-reference is the Minimal Type Theory that
I created for the purpose of directly expressing
self-reference.

Maybe because you are just too dumb to understand what a formal language actually is.

Tarski's Liar Paradox
x ∉ True if and only if p
where the symbol 'p' represents the whole sentence x https://liarparadox.org/Tarski_275_276.pdf

Expressed the self-reference in the English and
never formalized it in any formal language.

What isn't formalized in that expression?

LP := ~True(LP) directly encodes ~True(~True(~True(~True(~True(~True(~True(...)))))))

Which is a diffferent statement.

Note, Tarski's "x" has an actual definition as an actual formal
sentence, he just doesn't write it out there, but shows how to get it

Clocksin and Mellish saying the same thing.
  ?- equal(foo(Y), Y).

Y will stand for foo(Y), which is foo(foo(Y)) (because of what Y stands
for), which is foo(foo(foo(Y))), and soon. So Y ends up standing for
some kind of infinite structure.

thus directly encodes foo(foo(foo(foo(foo(foo(...))))))

Which shows they don't understand the problem either

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)