Sujet : Re: True on the basis of meaning --- Good job Richard ! ---Socratic method (agreement)
De : richard (at) *nospam* damon-family.org (Richard Damon)
Groupes : sci.logic comp.theoryDate : 23. May 2024, 03:03:44
Autres entêtes
Organisation : i2pn2 (i2pn.org)
Message-ID : <v2m4lg$1qo0t$1@i2pn2.org>
References : 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33
User-Agent : Mozilla Thunderbird
On 5/22/24 7:55 PM, olcott wrote:
On 5/22/2024 6:01 PM, Richard Damon wrote:
On 5/22/24 3:52 PM, olcott wrote:
On 5/22/2024 11:58 AM, Mikko wrote:
On 2024-05-22 15:55:39 +0000, olcott said:
>
On 5/22/2024 2:57 AM, Mikko wrote:
On 2024-05-21 14:36:29 +0000, olcott said:
>
On 5/21/2024 3:05 AM, Mikko wrote:
On 2024-05-20 17:48:40 +0000, olcott said:
>
On 5/20/2024 2:55 AM, Mikko wrote:
On 2024-05-19 14:15:51 +0000, olcott said:
>
On 5/19/2024 9:03 AM, Mikko wrote:
On 2024-05-19 13:41:56 +0000, olcott said:
>
On 5/19/2024 6:55 AM, Richard Damon wrote:
On 5/18/24 11:47 PM, olcott wrote:
On 5/18/2024 6:04 PM, Richard Damon wrote:
On 5/18/24 6:47 PM, olcott wrote:
On 5/18/2024 5:22 PM, Richard Damon wrote:
On 5/18/24 4:00 PM, olcott wrote:
On 5/18/2024 2:57 PM, Richard Damon wrote:
On 5/18/24 3:46 PM, olcott wrote:
On 5/18/2024 12:38 PM, Richard Damon wrote:
On 5/18/24 1:26 PM, olcott wrote:
On 5/18/2024 11:56 AM, Richard Damon wrote:
On 5/18/24 12:48 PM, olcott wrote:
On 5/18/2024 9:32 AM, Richard Damon wrote:
On 5/18/24 10:15 AM, olcott wrote:
On 5/18/2024 7:43 AM, Richard Damon wrote:
No, your system contradicts itself.
>
>
You have never shown this.
The most you have shown is a lack of understanding of the
Truth Teller Paradox.
>
No, I have, but you don't understand the proof, it seems because you don't know what a "Truth Predicate" has been defined to be.
>
>
My True(L,x) predicate is defined to return true or false for every
finite string x on the basis of the existence of a sequence of truth
preserving operations that derive x from
>
And thus, When True(L, p) established a sequence of truth preserving operations eminationg from ~True(L, p) by returning false, it contradicts itself. The problem is that True, in making an answer of false, has asserted that such a sequence exists.
>
On 5/13/2024 9:31 PM, Richard Damon wrote:
> On 5/13/24 10:03 PM, olcott wrote:
>> On 5/13/2024 7:29 PM, Richard Damon wrote:
>>>
>>> Remember, p defined as ~True(L, p) ...
>>
>> Can a sequence of true preserving operations applied
>> to expressions that are stipulated to be true derive p?
> No, so True(L, p) is false
>>
>> Can a sequence of true preserving operations applied
>> to expressions that are stipulated to be true derive ~p?
>
> No, so False(L, p) is false,
>
>
*To help you concentrate I repeated this*
The Liar Paradox and your formalized Liar Paradox both
contradict themselves that is why they must be screened
out as type mismatch error non-truth-bearers *BEFORE THAT OCCURS*
>
And the Truth Predicate isn't allowed to "filter" out expressions.
>
>
YOU ALREADY KNOW THAT IT DOESN'T
WE HAVE BEEN OVER THIS AGAIN AND AGAIN
THE FORMAL SYSTEM USES THE TRUE AND FALSE PREDICATE
TO FILTER OUT TYPE MISMATCH ERROR
>
The first thing that the formal system does with any
arbitrary finite string input is see if it is a Truth-bearer:
Truthbearer(L,x) ≡ (True(L,x) ∨ True(L,~x))
>
No, we can ask True(L, x) for any expression x and get an answer.
>
>
The system is designed so you can ask this, yet non-truth-bearers
are rejected before True(L, x) is allowed to be called.
>
>
>
>
Not allowed.
>
>
My True(L,x) predicate is defined to return true or false for every
finite string x on the basis of the existence of a sequence of truth
preserving operations that derive x from
>
A set of finite string semantic meanings that form an accurate
verbal model of the general knowledge of the actual world that
form a finite set of finite strings that are stipulated to have
the semantic value of Boolean true.
>
*This is computable* Truthbearer(L,x) ≡ (True(L,x) ∨ True(L,~x))
*This is computable* Truthbearer(L,x) ≡ (True(L,x) ∨ True(L,~x))
*This is computable* Truthbearer(L,x) ≡ (True(L,x) ∨ True(L,~x))
*This is computable* Truthbearer(L,x) ≡ (True(L,x) ∨ True(L,~x))
*This is computable* Truthbearer(L,x) ≡ (True(L,x) ∨ True(L,~x))
>
>
>
So, for a statement x to be false, it says that there must be a sequence of truth perserving operations that derive ~x from, right?
>
Yes we must build from mutual agreement, good.
>
So do you still say that for p defined in L as ~True(L, p) that your definition will say that True(L, p) will return false?
>
>
It is the perfectly isomorphic to this:
True(English, "This sentence is not true")
>
>
>
Nope, Because "This sentece is not true" can be a non-truth-bearer, but by its definition, True(L, x) can not.
>
>
True(L,x) is always a truth bearer.
when x is defined as True(L,x) then x is not a truth bearer.
>
When x is defined as True(L,x) then x is what True(L,x) is,
in this case a truth bearer.
>
This is known as the Truth Teller Paradox
>
Doesn't matter. But ir you say that "x is not a truth bearer" then,
by a truth preserving transformation, you imply that True(L,x) is
>
True(English, "a cat is an animal) is true
LP := ~True(L, LP) expands to ~True(~True(~True(~True(...))))
>
No, it doesn't. It is a syntax error to have the same symbol on
both sides ":=" so the expansion is not justified.
>
ϕ(x) there is a sentence ψ such that S ⊢ ψ ↔ ϕ⟨ψ⟩.
*The sentence ψ is of course not self-referential in a strict sense*,
but mathematically it behaves like one.
https://plato.stanford.edu/entries/self-reference/#ConSemPar
>
Your quote omitted important details. One is that the claim is not
true about every theory but is about first order arithmetic and its
extension. Another one is that ϕ(x) is that the claim is about
every formula ϕ(x).
>
>
*The whole article is about self-reference*
The ONLY detail that I am referring to is that it is conventional to formalize self-reference incorrectly.
>
*Richard and both fixed that*
>
On 5/13/2024 9:31 PM, Richard Damon wrote:
> On 5/13/24 10:03 PM, olcott wrote:
>> On 5/13/2024 7:29 PM, Richard Damon wrote:
>>>
>>> Remember, p defined as ~True(L, p) ...
>
x := y means x is defined to be another name for y
>
Another name for the meaning of y. Therefore any pair of sentences that
are otherwise equal but one contains x where rhe other contains y is a pair
of equally true sentences. For example, if p defined as ~True(L, ⟨p⟩)
>
I have no idea what you mean by the weird ⟨p⟩ quotes.
I AM ABSOLUTELY NOT TALKING ABOUT ANY FREAKING Gödel NUMBERS
I AM ABSOLUTELY NOT TALKING ABOUT ANY FREAKING Gödel NUMBERS
I AM ABSOLUTELY NOT TALKING ABOUT ANY FREAKING Gödel NUMBERS
>
I AM TALKING ABOUT THE EXISTENCE OR NON-EXISTENCE OF
AN ACTUAL SEQUENCE OF TRUTH PRESERVING OPERATIONS FROM
EXPRESSIONS OF LANGUAGE KNOWN TO BE TRUE
>
So, you aren't talking about Tarski's proof of the impossibility to define a Truth Predicate per his definition?
>
>
then Truthbearer(L,p) has the same truth value as Truthbearer(L,~True(L, ⟨p⟩)).
>
>
When p defined as ~True(L, p)
Then ~True(L, p) is true, thus a truth-bearer.
>
Which means that True(L, p) is false, so your True just erred in describing a true statement as false.
>
Remeber, you just said that ~True(L, p) which has been given the name of p IS a truth-bearer.
>
*You are just not paying close enough attention again*
When p defined as ~True(L, p)
True(L,p) is false
True(L,~p) is false
~True(L,~p) is true
x := y means x is defined to be another name for y
https://en.wikipedia.org/wiki/List_of_logic_symbols
Right, so since p is DEFINED to be ~True(L, p), which since True(L, p) is false, must be true, that means that you are claiming that
T(L, <a statement that has been shown to be true>) is false.
Thus your True predicat is just broken.
You ignored the part where Mikko agreed that
p defined as ~True(L, p)
is a syntax error:
So, what it the "Syntax Error"?
Are we not allowed to negate an expression
Or are we not allowed to assign an expression to a name.
Note, "Syntax Error", by its definition doesn't look at Semantics,
On 5/21/2024 3:05 AM, Mikko wrote:
> On 2024-05-20 17:48:40 +0000, olcott said:
>> True(English, "a cat is an animal) is true
>> LP := ~True(L, LP) expands to ~True(~True(~True(~True(...))))
>
> No, it doesn't. It is a syntax error to have the same symbol on
> both sides ":=" so the expansion is not justified.
But it isn't.
It is for PROLOG, which can't handle recursive definitions, but Tarski has, as part of the requireements of L, that it can handle such definition.
So, it goes back to the fact that you don't understand what you are talking about, and don't understand the level of logic being used, but only much simpler systems.
>
LP := "This sentence is not true"
True(English, LP) is false because LP is not a truth bearer
~True(English, LP) is true because LP is not a truth bearer
>
"This sentence is not true". is not true.
This sentence is not true: "This sentence is not true". is true
>
>
https://en.wikipedia.org/wiki/List_of_logic_symbols
Thus p := ~True(L, p)
>
*That is great. That means that you agree with me using different words*
>
Saying that you have a syntax error does not mean agreement.
>
Saying this it is any kind of error is sufficient agreement.
Clocksin & Mellish also agree that it is an error:
>
I don't agree with your errors.
>
>
I am talking about the syntax error that you pointed out and
the *So Y ends up standing for some kind of infinite structure*
that Clocksin & Mellish pointed out, neither of these are
my error.
>
>
Re: True on the basis of meaning --- Good job Richard !
Re: True on the basis of meaning --- Good job Richard !