1. Forum
  2. Usenet
  3. SCI.LOGIC

  • Re: True on the basis of meaning --- Good job Richard ! ---Socratic met

    From Mikko@21:1/5 to olcott on Sun May 19 17:03:05 2024
    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.

    --
    Mikko

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From Mikko@21:1/5 to olcott on Mon May 20 10:55:17 2024
    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
    not a truth bearer. As you already said that "True(L,x)" is always
    a truth bearer, you imply, by another truth preeserving transformation,
    that something both is and is not a truth bearer.

    --
    Mikko

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From Mikko@21:1/5 to olcott on Tue May 21 11:05:41 2024
    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.

    TT := True(L, TT) expands to True(True(True(True(...))))

    No, it doesn't, for the same reason.

    not a truth bearer. As you already said that "True(L,x)" is always
    a truth bearer, you imply, by another truth preeserving transformation,
    that something both is and is not a truth bearer.

    *Not at all*
    *Prolog sees the same infinite recursion and rejects it*

    Irrelevant.

    --
    Mikko

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From Mikko@21:1/5 to olcott on Wed May 22 10:57:12 2024
    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).

    *That is great. That means that you agree with me using different words*

    Saying that you have a syntax error does not mean agreement.

    --
    Mikko

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From Mikko@21:1/5 to olcott on Wed May 22 19:58:30 2024
    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⟩)
    then Truthbearer(L,p) has the same truth value as
    Truthbearer(L,~True(L, ⟨p⟩)).

    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.

    --
    Mikko

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From Mikko@21:1/5 to olcott on Thu May 23 10:54:36 2024
    On 2024-05-22 19:52:59 +0000, olcott said:

    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.

    You posted a pointer to a web page and qutoed (incorrectly) a piece
    of it. Notations borrower from that mean what they mean there.

    I AM ABSOLUTELY NOT TALKING ABOUT ANY FREAKING Gödel NUMBERS

    You did talk about quoted strings. A Gödel number is a name in
    the same sense as a quoted string is (although for quoted strings
    the interpretation as a name is more natural than for 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

    You have said very little about that.

    --
    Mikko

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From Mikko@21:1/5 to olcott on Thu May 23 11:05:03 2024
    On 2024-05-22 23:55:49 +0000, olcott said:

    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

    You ignored the part where Mikko agreed that
    p defined as ~True(L, p)
    is a syntax error:

    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(...))))

    The same syntax eroor is on the last line above, so that line
    is not true.

    Also note that the second last quoted line is not analogous:
    the expression "a cat is an animal" (assuming that is meant
    on that line) is a string term but LP is a formula.

    --
    Mikko

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From Mikko@21:1/5 to Richard Damon on Thu May 23 11:09:55 2024
    On 2024-05-23 01:03:44 +0000, Richard Damon said:

    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.

    By the usual rules a definition of a symbol in terms of itself is not
    an acceptable definition.

    --
    Mikko

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From Mikko@21:1/5 to olcott on Fri May 24 11:18:12 2024
    On 2024-05-23 13:32:51 +0000, olcott said:

    On 5/23/2024 3:09 AM, Mikko wrote:
    On 2024-05-23 01:03:44 +0000, Richard Damon said:

    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.

    By the usual rules a definition of a symbol in terms of itself is not
    an acceptable definition.


    One can either reject it as a syntax error or let it go ahead
    and infinitely expand and reject it as a semantic error.

    It is a syntax error by the usual rules. If you want to use a different
    syntax then you should specify one, preferably using a different symbol
    instead of ":=". It is OK to extend the syntax but one should avoid any conflict with the usual conventions. Also, if you change the syntax
    rules you should not call it a "definition".

    Or one can reject is as a self-contradictory epistemological antinomy
    having no truth value thus a type mismatch error for any formal
    system of bivalent logic.

    If that can be formulated as a syntax rule. Being an epistemological
    antinomy is semantics as is being true or false but type mismach can
    be handled as syntax error if the syntax rules have a type system.

    Most of the greatest experts in the field are not even sure
    that there is anything wrong with it.

    Nothing is inherently wrong in an uninterpreted formal system.
    Something may be unsuitable for some purpose but still useful
    for another purpose.

    --
    Mikko

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From Mikko@21:1/5 to olcott on Fri May 24 12:25:33 2024
    On 2024-05-23 13:23:54 +0000, olcott said:

    On 5/23/2024 2:54 AM, Mikko wrote:
    On 2024-05-22 19:52:59 +0000, olcott said:

    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.

    You posted a pointer to a web page and qutoed (incorrectly) a piece
    of it. Notations borrower from that mean what they mean there.

    I AM ABSOLUTELY NOT TALKING ABOUT ANY FREAKING Gödel NUMBERS

    You did talk about quoted strings. A Gödel number is a name in
    the same sense as a quoted string is (although for quoted strings
    the interpretation as a name is more natural than for 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

    You have said very little about that.


    Every expression of language that is {true on the basis of its meaning}
    is proven true by a sequence of truth preserving operations that derive
    this expression from its meaning.

    Not really. Truth preserving operations can only be applied to truth
    valued expressions but the meaning of such expression is not an expression. Usually the meaning of an expression is derived from the meanings of the constituents of the expression.

    --
    Mikko

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From Mikko@21:1/5 to olcott on Fri May 24 12:15:55 2024
    On 2024-05-23 13:27:43 +0000, olcott said:

    On 5/23/2024 3:05 AM, Mikko wrote:
    On 2024-05-22 23:55:49 +0000, olcott said:

    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

    You ignored the part where Mikko agreed that
      p defined as ~True(L, p)
    is a syntax error:

    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(...))))

    The same syntax eroor is on the last line above, so that line
    is not true.


    Yes you are correct.

    Does that mean that you retract your untrue claim?

    --
    Mikko

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From Mikko@21:1/5 to olcott on Sat May 25 11:01:49 2024
    On 2024-05-24 19:16:47 +0000, olcott said:

    On 5/24/2024 3:18 AM, Mikko wrote:
    On 2024-05-23 13:32:51 +0000, olcott said:

    On 5/23/2024 3:09 AM, Mikko wrote:
    On 2024-05-23 01:03:44 +0000, Richard Damon said:

    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.

    By the usual rules a definition of a symbol in terms of itself is not
    an acceptable definition.


    One can either reject it as a syntax error or let it go ahead
    and infinitely expand and reject it as a semantic error.

    It is a syntax error by the usual rules. If you want to use a different
    syntax then you should specify one, preferably using a different symbol
    instead of ":=". It is OK to extend the syntax but one should avoid any
    conflict with the usual conventions. Also, if you change the syntax
    rules you should not call it a "definition".


    LP := ~True(L, LP) is required to refer to itself on both sides
    that is what actual self-reference means.

    *THE ACTUAL Stanford ARTICLE ON SELF-REFERENCE SAYS*
    *THAT THEY MAKE SURE TO ENCODE IS INCORRECTLY*
    ϕ(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

    It is the standard convention throughout the literature to encode self-reference incorrectly. When the standard convention is to do
    these things incorrectly then the standard convention must be
    superseded and replaced.

    That is one of the reasons what correctly analyzing these this is
    so difficult.

    If you are correct that this is incorrect syntax
    LP := ~True(L, LP)
    that is yet another reason to reject the Liar Paradox
    (and every other self-reference paradox) as ill-formed.

    Or one can reject is as a self-contradictory epistemological antinomy
    having no truth value thus a type mismatch error for any formal
    system of bivalent logic.

    If that can be formulated as a syntax rule. Being an epistemological
    antinomy is semantics as is being true or false but type mismach can
    be handled as syntax error if the syntax rules have a type system.


    The formalized Liar Paradox
    LP := ~True(L, LP) <is> an epistemological antinomy because assuming
    that it is true makes it false and assuming that it is false makes it
    true.

    That you want to also call it a syntax error seems reasonable to me.

    If it is not rejected as a syntax error then it does recursively
    expand ~True(~True(~True(~True(~True(...))))) as Clocksin & Mellish
    point out.

    BEGIN:(Clocksin & Mellish 2003:254)
    equal(X, X).
    ?- equal(foo(Y), Y).

    that is, they will allow you to match a term against an uninstantiated
    subterm of itself. In this example, foo(Y) is matched against Y, which
    appears within it. As a result, Y will stand for foo(Y), which is
    foo(foo(Y)) (because of what Y stands for), which is foo(foo(foo(Y))),
    and so on. So Y ends up standing for some kind of infinite structure. END:(Clocksin & Mellish 2003:254)


    Most of the greatest experts in the field are not even sure
    that there is anything wrong with it.

    Nothing is inherently wrong in an uninterpreted formal system.
    Something may be unsuitable for some purpose but still useful
    for another purpose.


    You already said that this is a syntax error:
    LP := ~True(L, LP)
    please at least be consistent with yourself.

    I don't. Because of a syntax error "LP := ~True(L, LP)" is not an
    expression in the formal system and not in contradiction that there
    is nothing wrong in the formal system.

    --
    Mikko

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From Mikko@21:1/5 to olcott on Sun May 26 11:38:34 2024
    On 2024-05-25 18:13:02 +0000, olcott said:

    On 5/25/2024 3:01 AM, Mikko wrote:
    On 2024-05-24 19:16:47 +0000, olcott said:

    On 5/24/2024 3:18 AM, Mikko wrote:
    On 2024-05-23 13:32:51 +0000, olcott said:

    On 5/23/2024 3:09 AM, Mikko wrote:
    On 2024-05-23 01:03:44 +0000, Richard Damon said:

    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.

    By the usual rules a definition of a symbol in terms of itself is not >>>>>> an acceptable definition.


    One can either reject it as a syntax error or let it go ahead
    and infinitely expand and reject it as a semantic error.

    It is a syntax error by the usual rules. If you want to use a different >>>> syntax then you should specify one, preferably using a different symbol >>>> instead of ":=". It is OK to extend the syntax but one should avoid any >>>> conflict with the usual conventions. Also, if you change the syntax
    rules you should not call it a "definition".


    LP := ~True(L, LP) is required to refer to itself on both sides
    that is what actual self-reference means.

    *THE ACTUAL Stanford ARTICLE ON SELF-REFERENCE SAYS*
    *THAT THEY MAKE SURE TO ENCODE IS INCORRECTLY*
    ϕ(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

    It is the standard convention throughout the literature to encode
    self-reference incorrectly. When the standard convention is to do
    these things incorrectly then the standard convention must be
    superseded and replaced.

    That is one of the reasons what correctly analyzing these this is
    so difficult.

    If you are correct that this is incorrect syntax
    LP := ~True(L, LP)
    that is yet another reason to reject the Liar Paradox
    (and every other self-reference paradox) as ill-formed.

    Or one can reject is as a self-contradictory epistemological antinomy >>>>> having no truth value thus a type mismatch error for any formal
    system of bivalent logic.

    If that can be formulated as a syntax rule. Being an epistemological
    antinomy is semantics as is being true or false but type mismach can
    be handled as syntax error if the syntax rules have a type system.


    The formalized Liar Paradox
    LP := ~True(L, LP) <is> an epistemological antinomy because assuming
    that it is true makes it false and assuming that it is false makes it
    true.

    That you want to also call it a syntax error seems reasonable to me.

    If it is not rejected as a syntax error then it does recursively
    expand ~True(~True(~True(~True(~True(...))))) as Clocksin & Mellish
    point out.

    BEGIN:(Clocksin & Mellish 2003:254)
       equal(X, X).
       ?- equal(foo(Y), Y).

       that is, they will allow you to match a term against an uninstantiated >>>    subterm of itself. In this example, foo(Y) is matched against Y, which >>>    appears within it. As a result, Y will stand for foo(Y), which is
       foo(foo(Y)) (because of what Y stands for), which is foo(foo(foo(Y))), >>>    and so on. So Y ends up standing for some kind of infinite structure. >>> END:(Clocksin & Mellish 2003:254)


    Most of the greatest experts in the field are not even sure
    that there is anything wrong with it.

    Nothing is inherently wrong in an uninterpreted formal system.
    Something may be unsuitable for some purpose but still useful
    for another purpose.


    You already said that this is a syntax error:
    LP := ~True(L, LP)
    please at least be consistent with yourself.

    I don't. Because of a syntax error "LP := ~True(L, LP)" is not an
    expression in the formal system and not in contradiction that there
    is nothing wrong in the formal system.


    This is where Tarski says that his proof is anchored in the Liar Paradox https://liarparadox.org/Tarski_247_248.pdf

    Nothing to that page contradicts anything I have said above.

    When you look at my new thread (and completely understand what it says)
    You will see when we correctly formalize Tarski's clumsy formalization
    of the Liar Paradox

    You don't formalize it correctly with a string that is not in the
    language of the formnal system. A syntax error excludes all meaning
    and in prticular the meaning that Tarksi's expressions have.

    --
    Mikko

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From Mikko@21:1/5 to olcott on Mon May 27 11:00:29 2024
    On 2024-05-26 13:52:17 +0000, olcott said:

    On 5/26/2024 3:38 AM, Mikko wrote:
    On 2024-05-25 18:13:02 +0000, olcott said:

    On 5/25/2024 3:01 AM, Mikko wrote:
    On 2024-05-24 19:16:47 +0000, olcott said:

    On 5/24/2024 3:18 AM, Mikko wrote:
    On 2024-05-23 13:32:51 +0000, olcott said:

    On 5/23/2024 3:09 AM, Mikko wrote:
    On 2024-05-23 01:03:44 +0000, Richard Damon said:

    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.

    By the usual rules a definition of a symbol in terms of itself is not >>>>>>>> an acceptable definition.


    One can either reject it as a syntax error or let it go ahead
    and infinitely expand and reject it as a semantic error.

    It is a syntax error by the usual rules. If you want to use a different >>>>>> syntax then you should specify one, preferably using a different symbol >>>>>> instead of ":=". It is OK to extend the syntax but one should avoid any >>>>>> conflict with the usual conventions. Also, if you change the syntax >>>>>> rules you should not call it a "definition".


    LP := ~True(L, LP) is required to refer to itself on both sides
    that is what actual self-reference means.

    *THE ACTUAL Stanford ARTICLE ON SELF-REFERENCE SAYS*
    *THAT THEY MAKE SURE TO ENCODE IS INCORRECTLY*
    ϕ(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

    It is the standard convention throughout the literature to encode
    self-reference incorrectly. When the standard convention is to do
    these things incorrectly then the standard convention must be
    superseded and replaced.

    That is one of the reasons what correctly analyzing these this is
    so difficult.

    If you are correct that this is incorrect syntax
    LP := ~True(L, LP)
    that is yet another reason to reject the Liar Paradox
    (and every other self-reference paradox) as ill-formed.

    Or one can reject is as a self-contradictory epistemological antinomy >>>>>>> having no truth value thus a type mismatch error for any formal
    system of bivalent logic.

    If that can be formulated as a syntax rule. Being an epistemological >>>>>> antinomy is semantics as is being true or false but type mismach can >>>>>> be handled as syntax error if the syntax rules have a type system. >>>>>>

    The formalized Liar Paradox
    LP := ~True(L, LP) <is> an epistemological antinomy because assuming >>>>> that it is true makes it false and assuming that it is false makes it >>>>> true.

    That you want to also call it a syntax error seems reasonable to me. >>>>>
    If it is not rejected as a syntax error then it does recursively
    expand ~True(~True(~True(~True(~True(...))))) as Clocksin & Mellish
    point out.

    BEGIN:(Clocksin & Mellish 2003:254)
       equal(X, X).
       ?- equal(foo(Y), Y).

       that is, they will allow you to match a term against an uninstantiated
       subterm of itself. In this example, foo(Y) is matched against Y, which
       appears within it. As a result, Y will stand for foo(Y), which is >>>>>    foo(foo(Y)) (because of what Y stands for), which is foo(foo(foo(Y))),
       and so on. So Y ends up standing for some kind of infinite structure.
    END:(Clocksin & Mellish 2003:254)


    Most of the greatest experts in the field are not even sure
    that there is anything wrong with it.

    Nothing is inherently wrong in an uninterpreted formal system.
    Something may be unsuitable for some purpose but still useful
    for another purpose.


    You already said that this is a syntax error:
    LP := ~True(L, LP)
    please at least be consistent with yourself.

    I don't. Because of a syntax error "LP := ~True(L, LP)" is not an
    expression in the formal system and not in contradiction that there
    is nothing wrong in the formal system.


    This is where Tarski says that his proof is anchored in the Liar Paradox >>> https://liarparadox.org/Tarski_247_248.pdf

    Nothing to that page contradicts anything I have said above.

    When you look at my new thread (and completely understand what it says)
    You will see when we correctly formalize Tarski's clumsy formalization
    of the Liar Paradox

    You don't formalize it correctly with a string that is not in the
    language of the formnal system. A syntax error excludes all meaning
    and in prticular the meaning that Tarksi's expressions have.


    Back in 2019 I created a formal system for this purpose: https://www.researchgate.net/publication/331859461_Minimal_Type_Theory_YACC_BNF

    Initially it took any MTT expression and output the directed graph
    of the evaluation sequence of this expression. The current system
    only outputs the XML of the expression yet the directed graph can
    still be derived manually.

    Users of your MTT basically need two programs: one that checks whether
    the input is syntactiaclly correct and identifies at least one error
    if it is not, and one that checks whether a proof (that may but need
    not have unproven premises) is valid and identifies at least one error
    if it is not.

    --
    Mikko

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From Mikko@21:1/5 to olcott on Mon May 27 17:19:22 2024
    On 2024-05-27 14:15:57 +0000, olcott said:

    On 5/27/2024 3:00 AM, Mikko wrote:
    On 2024-05-26 13:52:17 +0000, olcott said:

    On 5/26/2024 3:38 AM, Mikko wrote:
    On 2024-05-25 18:13:02 +0000, olcott said:

    On 5/25/2024 3:01 AM, Mikko wrote:
    On 2024-05-24 19:16:47 +0000, olcott said:

    On 5/24/2024 3:18 AM, Mikko wrote:
    On 2024-05-23 13:32:51 +0000, olcott said:

    On 5/23/2024 3:09 AM, Mikko wrote:
    On 2024-05-23 01:03:44 +0000, Richard Damon said:

    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.

    By the usual rules a definition of a symbol in terms of itself is not
    an acceptable definition.


    One can either reject it as a syntax error or let it go ahead >>>>>>>>> and infinitely expand and reject it as a semantic error.

    It is a syntax error by the usual rules. If you want to use a different
    syntax then you should specify one, preferably using a different symbol
    instead of ":=". It is OK to extend the syntax but one should avoid any
    conflict with the usual conventions. Also, if you change the syntax >>>>>>>> rules you should not call it a "definition".


    LP := ~True(L, LP) is required to refer to itself on both sides
    that is what actual self-reference means.

    *THE ACTUAL Stanford ARTICLE ON SELF-REFERENCE SAYS*
    *THAT THEY MAKE SURE TO ENCODE IS INCORRECTLY*
    ϕ(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

    It is the standard convention throughout the literature to encode >>>>>>> self-reference incorrectly. When the standard convention is to do >>>>>>> these things incorrectly then the standard convention must be
    superseded and replaced.

    That is one of the reasons what correctly analyzing these this is >>>>>>> so difficult.

    If you are correct that this is incorrect syntax
    LP := ~True(L, LP)
    that is yet another reason to reject the Liar Paradox
    (and every other self-reference paradox) as ill-formed.

    Or one can reject is as a self-contradictory epistemological antinomy >>>>>>>>> having no truth value thus a type mismatch error for any formal >>>>>>>>> system of bivalent logic.

    If that can be formulated as a syntax rule. Being an epistemological >>>>>>>> antinomy is semantics as is being true or false but type mismach can >>>>>>>> be handled as syntax error if the syntax rules have a type system. >>>>>>>>

    The formalized Liar Paradox
    LP := ~True(L, LP) <is> an epistemological antinomy because assuming >>>>>>> that it is true makes it false and assuming that it is false makes it >>>>>>> true.

    That you want to also call it a syntax error seems reasonable to me. >>>>>>>
    If it is not rejected as a syntax error then it does recursively >>>>>>> expand ~True(~True(~True(~True(~True(...))))) as Clocksin & Mellish >>>>>>> point out.

    BEGIN:(Clocksin & Mellish 2003:254)
       equal(X, X).
       ?- equal(foo(Y), Y).

       that is, they will allow you to match a term against an uninstantiated
       subterm of itself. In this example, foo(Y) is matched against Y, which
       appears within it. As a result, Y will stand for foo(Y), which is >>>>>>>    foo(foo(Y)) (because of what Y stands for), which is foo(foo(foo(Y))),
       and so on. So Y ends up standing for some kind of infinite structure.
    END:(Clocksin & Mellish 2003:254)


    Most of the greatest experts in the field are not even sure
    that there is anything wrong with it.

    Nothing is inherently wrong in an uninterpreted formal system. >>>>>>>> Something may be unsuitable for some purpose but still useful
    for another purpose.


    You already said that this is a syntax error:
    LP := ~True(L, LP)
    please at least be consistent with yourself.

    I don't. Because of a syntax error "LP := ~True(L, LP)" is not an
    expression in the formal system and not in contradiction that there >>>>>> is nothing wrong in the formal system.


    This is where Tarski says that his proof is anchored in the Liar Paradox >>>>> https://liarparadox.org/Tarski_247_248.pdf

    Nothing to that page contradicts anything I have said above.

    When you look at my new thread (and completely understand what it says) >>>>> You will see when we correctly formalize Tarski's clumsy formalization >>>>> of the Liar Paradox

    You don't formalize it correctly with a string that is not in the
    language of the formnal system. A syntax error excludes all meaning
    and in prticular the meaning that Tarksi's expressions have.


    Back in 2019 I created a formal system for this purpose:
    https://www.researchgate.net/publication/331859461_Minimal_Type_Theory_YACC_BNF

    Initially it took any MTT expression and output the directed graph
    of the evaluation sequence of this expression. The current system
    only outputs the XML of the expression yet the directed graph can
    still be derived manually.

    Users of your MTT basically need two programs: one that checks whether
    the input is syntactiaclly correct and identifies at least one error
    if it is not, and one that checks whether a proof (that may but need
    not have unproven premises) is valid and identifies at least one error
    if it is not.


    MTT is build with YACC and LEX and outputs the XML of the
    input expression.

    LP := ~True(L, LP)

    definition_2 token="ASSIGN_ALIAS"
    | definition_2 token="IDENTIFIER" value="LP"
    | sentence_2 token="NOT"
    | | atomic_sentence_1 token="IDENTIFIER" value="True"
    | | | term_list_1
    | | | | term_2 token="IDENTIFIER" value="L"
    | | | | term_2 token="IDENTIFIER" value="LP"

    Directed graph of evaulation sequence of LP
    Nodes on the left edges on the right
    00 NOT 01
    01 True 02, 00 // cycle
    02 L

    <definition_2 token="ASSIGN_ALIAS">
    <definition_2 token="IDENTIFIER" value="LP"/>
    <sentence_2 token="NOT">
    <atomic_sentence_1 token="IDENTIFIER" value="True">
    <term_list_1>
    <term_2 token="IDENTIFIER" value="L"/>
    <term_2 token="IDENTIFIER" value="LP"/>
    </term_list_1>
    </atomic_sentence_1>
    </sentence_2>
    </definition_2>

    That is not far from useful. Much of the code could be reused for
    the more useful programs mentioned above.

    --
    Mikko

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From Mikko@21:1/5 to olcott on Tue May 28 09:59:13 2024
    On 2024-05-27 14:34:14 +0000, olcott said:

    ?- LP = not(true(LP)).
    LP = not(true(LP)).

    ?- unify_with_occurs_check(LP, not(true(LP))).
    false.

    In other words Prolog has detected a cycle in the directed graph of the evaluation sequence of the structure of the Liar Paradox. Experts seem
    to think that Prolog is taking "not" and "true" as meaningless and is
    only evaluating the structure of the expression.

    The words "not" and "true" of Prolog are meaningful in some contexts
    but not above. The word "true" is meaningful only when it has no arguments.

    You could try
    ?- LP = not(true(LP), true(LP).

    or
    ?- LP = not(true(LP), not(true(LP)).

    The predicate unify_with_occurs_check checks whether the resulting
    sructure is acyclic because that is its purpose. Whether a simple
    unification like LP = not(true(LP)) does same is implementation
    dependent as Prolog rules permit but do not require that. In a
    typical implementation a simple unification does not check for
    cycles.

    Anyway, none of this is relevant to the topic of this thread or
    topics of sci.logic.

    --
    Mikko

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From Mikko@21:1/5 to olcott on Thu May 30 09:52:23 2024
    On 2024-05-29 13:31:31 +0000, olcott said:

    On 5/29/2024 3:25 AM, Mikko wrote:
    On 2024-05-28 14:59:30 +0000, olcott said:

    On 5/28/2024 1:59 AM, Mikko wrote:
    On 2024-05-27 14:34:14 +0000, olcott said:

    ?- LP = not(true(LP)).
    LP = not(true(LP)).

    ?- unify_with_occurs_check(LP, not(true(LP))).
    false.

    In other words Prolog has detected a cycle in the directed graph of the >>>>> evaluation sequence of the structure of the Liar Paradox. Experts seem >>>>> to think that Prolog is taking "not" and "true" as meaningless and is >>>>> only evaluating the structure of the expression.

    The words "not" and "true" of Prolog are meaningful in some contexts
    but not above. The word "true" is meaningful only when it has no arguments.


    That Prolog construes any expression having the same structure as the
    Liar Paradox as having a cycle in the directed graph of its evaluation
    sequence already completely proves my point. In other words Prolog
    is saying that there is something wrong with the expression and it must
    be rejected.

    You could try
    ?- LP = not(true(LP), true(LP).

    or
    ?- LP = not(true(LP), not(true(LP)).

    The predicate unify_with_occurs_check checks whether the resulting
    sructure is acyclic because that is its purpose. Whether a simple

    Yes exactly. If I knew that Prolog did this then I would not have
    created Minimal Type Theory that does this same thing. That I did
    create MTT that does do this same thing makes my understanding much
    deeper.

    Prolog does not reject LP = not(true(LP)). It can accept it as
    syntactically valid. Thaat unify_with_occurs_check(LP, not(true(LP))
    fails does not mean anything except when it is used, and then it
    does not reject but simplu evaluates to false, just like 1 = 2
    is false but not erroneous.


    It correctly determines that there is a cycle in the directed graph
    of the evaluation sequence of the expression, which is like an
    infinite loop in a program.

    You can understand this or fail to understand this, disagreement is incorrect. If you have any disagreement then please back up your
    claims with proof.

    unification like LP = not(true(LP)) does same is implementation
    dependent as Prolog rules permit but do not require that. In a
    typical implementation a simple unification does not check for
    cycles.


    ISO Prolog implementations have the built-in predicate
    unify_with_occurs_check/2 for sound unification
    https://en.wikipedia.org/wiki/Occurs_check#Sound_unification

    Alternatively such expressions crash or remain stuck in infinite loops.

    Not necessarily. What happes depends on the implementation and on what
    you do with such structures. You already saw that your

    ?- LP = not(true(LP)).

    does not crash and does not remain stuck in infinite loop.

    Anyway, none of this is relevant to the topic of this thread or
    topics of sci.logic.

    If you want to talk nore about Prolog do it in comp.lang.prolog.


    It is relevant to sci.logic in that it exposes fundamental flaws
    with classical logic.

    It does not expose any flaw in classical logic. Flaws in your
    understanding of calssical logics are already sufficiently known.

    --
    Mikko

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From Mikko@21:1/5 to olcott on Fri May 31 10:17:12 2024
    On 2024-05-30 13:43:11 +0000, olcott said:

    On 5/30/2024 1:52 AM, Mikko wrote:
    On 2024-05-29 13:31:31 +0000, olcott said:

    On 5/29/2024 3:25 AM, Mikko wrote:
    On 2024-05-28 14:59:30 +0000, olcott said:

    On 5/28/2024 1:59 AM, Mikko wrote:
    On 2024-05-27 14:34:14 +0000, olcott said:

    ?- LP = not(true(LP)).
    LP = not(true(LP)).

    ?- unify_with_occurs_check(LP, not(true(LP))).
    false.

    In other words Prolog has detected a cycle in the directed graph of the >>>>>>> evaluation sequence of the structure of the Liar Paradox. Experts seem >>>>>>> to think that Prolog is taking "not" and "true" as meaningless and is >>>>>>> only evaluating the structure of the expression.

    The words "not" and "true" of Prolog are meaningful in some contexts >>>>>> but not above. The word "true" is meaningful only when it has no arguments.


    That Prolog construes any expression having the same structure as the >>>>> Liar Paradox as having a cycle in the directed graph of its evaluation >>>>> sequence already completely proves my point. In other words Prolog
    is saying that there is something wrong with the expression and it must >>>>> be rejected.

    You could try
    ?- LP = not(true(LP), true(LP).

    or
    ?- LP = not(true(LP), not(true(LP)).

    The predicate unify_with_occurs_check checks whether the resulting >>>>>> sructure is acyclic because that is its purpose. Whether a simple

    Yes exactly. If I knew that Prolog did this then I would not have
    created Minimal Type Theory that does this same thing. That I did
    create MTT that does do this same thing makes my understanding much
    deeper.

    Prolog does not reject LP = not(true(LP)). It can accept it as
    syntactically valid. Thaat unify_with_occurs_check(LP, not(true(LP))
    fails does not mean anything except when it is used, and then it
    does not reject but simplu evaluates to false, just like 1 = 2
    is false but not erroneous.


    It correctly determines that there is a cycle in the directed graph
    of the evaluation sequence of the expression, which is like an
    infinite loop in a program.

    You can understand this or fail to understand this, disagreement is
    incorrect. If you have any disagreement then please back up your
    claims with proof.

    unification like LP = not(true(LP)) does same is implementation
    dependent as Prolog rules permit but do not require that. In a
    typical implementation a simple unification does not check for
    cycles.


    ISO Prolog implementations have the built-in predicate
    unify_with_occurs_check/2 for sound unification
    https://en.wikipedia.org/wiki/Occurs_check#Sound_unification

    Alternatively such expressions crash or remain stuck in infinite loops. >>>>
    Not necessarily. What happes depends on the implementation and on what >>>> you do with such structures. You already saw that your

    ?- LP = not(true(LP)).

    does not crash and does not remain stuck in infinite loop.

    Anyway, none of this is relevant to the topic of this thread or
    topics of sci.logic.

    If you want to talk nore about Prolog do it in comp.lang.prolog.


    It is relevant to sci.logic in that it exposes fundamental flaws
    with classical logic.

    It does not expose any flaw in classical logic. Flaws in your
    understanding of calssical logics are already sufficiently known.

    What has now been shown is that L is true if, and only if, it is
    false. Since L must be one or the other, it is both.

    No, that has not been shown. Classical logic shows that no sentence
    is true if and only if it is false. If you assumoe otherwise then
    your assumption is false.

    --
    Mikko

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From Mikko@21:1/5 to olcott on Sat Jun 1 10:32:51 2024
    On 2024-05-31 15:47:31 +0000, olcott said:

    On 5/31/2024 2:17 AM, Mikko wrote:
    On 2024-05-30 13:43:11 +0000, olcott said:

    On 5/30/2024 1:52 AM, Mikko wrote:
    On 2024-05-29 13:31:31 +0000, olcott said:

    On 5/29/2024 3:25 AM, Mikko wrote:
    On 2024-05-28 14:59:30 +0000, olcott said:

    On 5/28/2024 1:59 AM, Mikko wrote:
    On 2024-05-27 14:34:14 +0000, olcott said:

    ?- LP = not(true(LP)).
    LP = not(true(LP)).

    ?- unify_with_occurs_check(LP, not(true(LP))).
    false.

    In other words Prolog has detected a cycle in the directed graph of the
    evaluation sequence of the structure of the Liar Paradox. Experts seem
    to think that Prolog is taking "not" and "true" as meaningless and is >>>>>>>>> only evaluating the structure of the expression.

    The words "not" and "true" of Prolog are meaningful in some contexts >>>>>>>> but not above. The word "true" is meaningful only when it has no arguments.


    That Prolog construes any expression having the same structure as the >>>>>>> Liar Paradox as having a cycle in the directed graph of its evaluation >>>>>>> sequence already completely proves my point. In other words Prolog >>>>>>> is saying that there is something wrong with the expression and it must >>>>>>> be rejected.

    You could try
    ?- LP = not(true(LP), true(LP).

    or
    ?- LP = not(true(LP), not(true(LP)).

    The predicate unify_with_occurs_check checks whether the resulting >>>>>>>> sructure is acyclic because that is its purpose. Whether a simple >>>>>>>
    Yes exactly. If I knew that Prolog did this then I would not have >>>>>>> created Minimal Type Theory that does this same thing. That I did >>>>>>> create MTT that does do this same thing makes my understanding much >>>>>>> deeper.

    Prolog does not reject LP = not(true(LP)). It can accept it as
    syntactically valid. Thaat unify_with_occurs_check(LP, not(true(LP)) >>>>>> fails does not mean anything except when it is used, and then it
    does not reject but simplu evaluates to false, just like 1 = 2
    is false but not erroneous.


    It correctly determines that there is a cycle in the directed graph
    of the evaluation sequence of the expression, which is like an
    infinite loop in a program.

    You can understand this or fail to understand this, disagreement is
    incorrect. If you have any disagreement then please back up your
    claims with proof.

    unification like LP = not(true(LP)) does same is implementation >>>>>>>> dependent as Prolog rules permit but do not require that. In a >>>>>>>> typical implementation a simple unification does not check for >>>>>>>> cycles.


    ISO Prolog implementations have the built-in predicate
    unify_with_occurs_check/2 for sound unification
    https://en.wikipedia.org/wiki/Occurs_check#Sound_unification

    Alternatively such expressions crash or remain stuck in infinite loops. >>>>>>
    Not necessarily. What happes depends on the implementation and on what >>>>>> you do with such structures. You already saw that your

    ?- LP = not(true(LP)).

    does not crash and does not remain stuck in infinite loop.

    Anyway, none of this is relevant to the topic of this thread or >>>>>>>> topics of sci.logic.

    If you want to talk nore about Prolog do it in comp.lang.prolog.


    It is relevant to sci.logic in that it exposes fundamental flaws
    with classical logic.

    It does not expose any flaw in classical logic. Flaws in your
    understanding of calssical logics are already sufficiently known.

        What has now been shown is that L is true if, and only if, it is
        false. Since L must be one or the other, it is both.

    No, that has not been shown. Classical logic shows that no sentence
    is true if and only if it is false. If you assumoe otherwise then
    your assumption is false.


    *You removed the relevant context that the principle of explosion*
    *of classical logic is shown to be the source of the issue*

    Principle of exposion is empirically true. It is not a problem of
    classical logic. You have not shown that any paraconsistent system,
    where principle of exposion does not apply, is any better.

    What has now been shown is that L is true if, and only if, it is
    false. Since L must be one or the other, it is both.

    No, you have not shown that for classical logic. You have not even defined
    what you mean by L, so whatever is said about it is said about nothing.

    That contradictory result apparently throws us into the lion’s den of
    semantic incoherence.

    You have not shown any contradictory result from classical logic.

    The incoherence is due to the fact that,
    according to the rules of classical logic, anything follows from a
    contradiction, even 1 + 1 = 3. https://iep.utm.edu/liar-paradox/

    Show us a situation where some contradiction is true and 1 + 1 = 3.
    Until then, we may consider classical logic empirically validated.

    --
    Mikko

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From Mikko@21:1/5 to olcott on Sun Jun 2 10:29:14 2024
    On 2024-06-01 15:41:46 +0000, olcott said:

    On 6/1/2024 2:32 AM, Mikko wrote:
    On 2024-05-31 15:47:31 +0000, olcott said:

    On 5/31/2024 2:17 AM, Mikko wrote:
    On 2024-05-30 13:43:11 +0000, olcott said:

    On 5/30/2024 1:52 AM, Mikko wrote:
    On 2024-05-29 13:31:31 +0000, olcott said:

    On 5/29/2024 3:25 AM, Mikko wrote:
    On 2024-05-28 14:59:30 +0000, olcott said:

    On 5/28/2024 1:59 AM, Mikko wrote:
    On 2024-05-27 14:34:14 +0000, olcott said:

    ?- LP = not(true(LP)).
    LP = not(true(LP)).

    ?- unify_with_occurs_check(LP, not(true(LP))).
    false.

    In other words Prolog has detected a cycle in the directed graph of the
    evaluation sequence of the structure of the Liar Paradox. Experts seem
    to think that Prolog is taking "not" and "true" as meaningless and is
    only evaluating the structure of the expression.

    The words "not" and "true" of Prolog are meaningful in some contexts >>>>>>>>>> but not above. The word "true" is meaningful only when it has no arguments.


    That Prolog construes any expression having the same structure as the >>>>>>>>> Liar Paradox as having a cycle in the directed graph of its evaluation
    sequence already completely proves my point. In other words Prolog >>>>>>>>> is saying that there is something wrong with the expression and it must
    be rejected.

    You could try
    ?- LP = not(true(LP), true(LP).

    or
    ?- LP = not(true(LP), not(true(LP)).

    The predicate unify_with_occurs_check checks whether the resulting >>>>>>>>>> sructure is acyclic because that is its purpose. Whether a simple >>>>>>>>>
    Yes exactly. If I knew that Prolog did this then I would not have >>>>>>>>> created Minimal Type Theory that does this same thing. That I did >>>>>>>>> create MTT that does do this same thing makes my understanding much >>>>>>>>> deeper.

    Prolog does not reject LP = not(true(LP)). It can accept it as >>>>>>>> syntactically valid. Thaat unify_with_occurs_check(LP, not(true(LP)) >>>>>>>> fails does not mean anything except when it is used, and then it >>>>>>>> does not reject but simplu evaluates to false, just like 1 = 2 >>>>>>>> is false but not erroneous.


    It correctly determines that there is a cycle in the directed graph >>>>>>> of the evaluation sequence of the expression, which is like an
    infinite loop in a program.

    You can understand this or fail to understand this, disagreement is >>>>>>> incorrect. If you have any disagreement then please back up your >>>>>>> claims with proof.

    unification like LP = not(true(LP)) does same is implementation >>>>>>>>>> dependent as Prolog rules permit but do not require that. In a >>>>>>>>>> typical implementation a simple unification does not check for >>>>>>>>>> cycles.


    ISO Prolog implementations have the built-in predicate
    unify_with_occurs_check/2 for sound unification
    https://en.wikipedia.org/wiki/Occurs_check#Sound_unification >>>>>>>>>
    Alternatively such expressions crash or remain stuck in infinite loops.

    Not necessarily. What happes depends on the implementation and on what >>>>>>>> you do with such structures. You already saw that your

    ?- LP = not(true(LP)).

    does not crash and does not remain stuck in infinite loop.

    Anyway, none of this is relevant to the topic of this thread or >>>>>>>>>> topics of sci.logic.

    If you want to talk nore about Prolog do it in comp.lang.prolog. >>>>>>>>

    It is relevant to sci.logic in that it exposes fundamental flaws >>>>>>> with classical logic.

    It does not expose any flaw in classical logic. Flaws in your
    understanding of calssical logics are already sufficiently known.

        What has now been shown is that L is true if, and only if, it is >>>>>     false. Since L must be one or the other, it is both.

    No, that has not been shown. Classical logic shows that no sentence
    is true if and only if it is false. If you assumoe otherwise then
    your assumption is false.


        *You removed the relevant context that the principle of explosion* >>>     *of classical logic is shown to be the source of the issue*

    Principle of exposion is empirically true. It is not a problem of
    classical logic. You have not shown that any paraconsistent system,
    where principle of exposion does not apply, is any better.


    The ONLY THING that can ever be correctly derived from a contradiction
    is FALSE. People taking classical logic as infallible by simply ignoring
    its inconsistencies are inherently incorrect.

    The inconsistencies are not inconsistencies of logic. No logic can
    prevent you from assuming an inconsistency but then it is your
    inconsistency.

    People taking classical logic as infallible do so because no situation
    where it is wrong has been observed.

    --
    Mikko

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From Mikko@21:1/5 to olcott on Mon Jun 3 10:19:35 2024
    On 2024-06-02 13:01:15 +0000, olcott said:

    On 6/2/2024 2:29 AM, Mikko wrote:
    On 2024-06-01 15:41:46 +0000, olcott said:

    On 6/1/2024 2:32 AM, Mikko wrote:
    On 2024-05-31 15:47:31 +0000, olcott said:

    On 5/31/2024 2:17 AM, Mikko wrote:
    On 2024-05-30 13:43:11 +0000, olcott said:

    On 5/30/2024 1:52 AM, Mikko wrote:
    On 2024-05-29 13:31:31 +0000, olcott said:

    On 5/29/2024 3:25 AM, Mikko wrote:
    On 2024-05-28 14:59:30 +0000, olcott said:

    On 5/28/2024 1:59 AM, Mikko wrote:
    On 2024-05-27 14:34:14 +0000, olcott said:

    ?- LP = not(true(LP)).
    LP = not(true(LP)).

    ?- unify_with_occurs_check(LP, not(true(LP))).
    false.

    In other words Prolog has detected a cycle in the directed graph of the
    evaluation sequence of the structure of the Liar Paradox. Experts seem
    to think that Prolog is taking "not" and "true" as meaningless and is
    only evaluating the structure of the expression.

    The words "not" and "true" of Prolog are meaningful in some contexts
    but not above. The word "true" is meaningful only when it has no arguments.


    That Prolog construes any expression having the same structure as the
    Liar Paradox as having a cycle in the directed graph of its evaluation
    sequence already completely proves my point. In other words Prolog >>>>>>>>>>> is saying that there is something wrong with the expression and it must
    be rejected.

    You could try
    ?- LP = not(true(LP), true(LP).

    or
    ?- LP = not(true(LP), not(true(LP)).

    The predicate unify_with_occurs_check checks whether the resulting >>>>>>>>>>>> sructure is acyclic because that is its purpose. Whether a simple >>>>>>>>>>>
    Yes exactly. If I knew that Prolog did this then I would not have >>>>>>>>>>> created Minimal Type Theory that does this same thing. That I did >>>>>>>>>>> create MTT that does do this same thing makes my understanding much >>>>>>>>>>> deeper.

    Prolog does not reject LP = not(true(LP)). It can accept it as >>>>>>>>>> syntactically valid. Thaat unify_with_occurs_check(LP, not(true(LP)) >>>>>>>>>> fails does not mean anything except when it is used, and then it >>>>>>>>>> does not reject but simplu evaluates to false, just like 1 = 2 >>>>>>>>>> is false but not erroneous.


    It correctly determines that there is a cycle in the directed graph >>>>>>>>> of the evaluation sequence of the expression, which is like an >>>>>>>>> infinite loop in a program.

    You can understand this or fail to understand this, disagreement is >>>>>>>>> incorrect. If you have any disagreement then please back up your >>>>>>>>> claims with proof.

    unification like LP = not(true(LP)) does same is implementation >>>>>>>>>>>> dependent as Prolog rules permit but do not require that. In a >>>>>>>>>>>> typical implementation a simple unification does not check for >>>>>>>>>>>> cycles.


    ISO Prolog implementations have the built-in predicate
    unify_with_occurs_check/2 for sound unification
    https://en.wikipedia.org/wiki/Occurs_check#Sound_unification >>>>>>>>>>>
    Alternatively such expressions crash or remain stuck in infinite loops.

    Not necessarily. What happes depends on the implementation and on what
    you do with such structures. You already saw that your

    ?- LP = not(true(LP)).

    does not crash and does not remain stuck in infinite loop. >>>>>>>>>>
    Anyway, none of this is relevant to the topic of this thread or >>>>>>>>>>>> topics of sci.logic.

    If you want to talk nore about Prolog do it in comp.lang.prolog. >>>>>>>>>>

    It is relevant to sci.logic in that it exposes fundamental flaws >>>>>>>>> with classical logic.

    It does not expose any flaw in classical logic. Flaws in your
    understanding of calssical logics are already sufficiently known. >>>>>>>
        What has now been shown is that L is true if, and only if, it is >>>>>>>     false. Since L must be one or the other, it is both.

    No, that has not been shown. Classical logic shows that no sentence >>>>>> is true if and only if it is false. If you assumoe otherwise then
    your assumption is false.


        *You removed the relevant context that the principle of explosion* >>>>>     *of classical logic is shown to be the source of the issue*

    Principle of exposion is empirically true. It is not a problem of
    classical logic. You have not shown that any paraconsistent system,
    where principle of exposion does not apply, is any better.


    The ONLY THING that can ever be correctly derived from a contradiction
    is FALSE. People taking classical logic as infallible by simply ignoring >>> its inconsistencies are inherently incorrect.

    The inconsistencies are not inconsistencies of logic. No logic can
    prevent you from assuming an inconsistency but then it is your
    inconsistency.

    People taking classical logic as infallible do so because no situation
    where it is wrong has been observed.

    *Three laws of logic apply to all propositions*
    ¬(p ∧ ¬p) Law of non-contradiction
    (p ∨ ¬p) Law of excluded middle
    p = p Law of identity

    Those laws don't prevent from assuming p. Those laws don't prevent
    from assuming ¬p. Assuming both is assuming something false. If
    something false is assumed then something false can be proven.
    Conversely, if you know that the conclusion is false then classical
    logic tells you that one of the preises is false (but does not
    tell which one).

    For propositions the law of identity should be written p <-> p.
    The = symbol is reserved for non-propositions (in a first order
    theory to individuals).

    The Principle of explosion violates the {Law of non-contradiction}.
    All premises must they themselves be propositions and POE simply
    ignores that.

    No, it does not. Each premise and the conclusion is either false
    or true but not both.

    Also the Liar Paradox violates the {Law of excluded middle}.

    In any ordinary formal logic the liar paradox cannot be expressed.
    If you want to use a system where it can then that is your problem.

    --
    Mikko

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From Mikko@21:1/5 to olcott on Mon Jun 3 17:14:13 2024
    On 2024-06-03 12:56:35 +0000, olcott said:

    On 6/3/2024 2:19 AM, Mikko wrote:
    On 2024-06-02 13:01:15 +0000, olcott said:

    On 6/2/2024 2:29 AM, Mikko wrote:
    On 2024-06-01 15:41:46 +0000, olcott said:

    On 6/1/2024 2:32 AM, Mikko wrote:
    On 2024-05-31 15:47:31 +0000, olcott said:

    On 5/31/2024 2:17 AM, Mikko wrote:
    On 2024-05-30 13:43:11 +0000, olcott said:

    On 5/30/2024 1:52 AM, Mikko wrote:
    On 2024-05-29 13:31:31 +0000, olcott said:

    On 5/29/2024 3:25 AM, Mikko wrote:
    On 2024-05-28 14:59:30 +0000, olcott said:

    On 5/28/2024 1:59 AM, Mikko wrote:
    On 2024-05-27 14:34:14 +0000, olcott said:

    ?- LP = not(true(LP)).
    LP = not(true(LP)).

    ?- unify_with_occurs_check(LP, not(true(LP))).
    false.

    In other words Prolog has detected a cycle in the directed graph of the
    evaluation sequence of the structure of the Liar Paradox. Experts seem
    to think that Prolog is taking "not" and "true" as meaningless and is
    only evaluating the structure of the expression.

    The words "not" and "true" of Prolog are meaningful in some contexts
    but not above. The word "true" is meaningful only when it has no arguments.


    That Prolog construes any expression having the same structure as the
    Liar Paradox as having a cycle in the directed graph of its evaluation
    sequence already completely proves my point. In other words Prolog
    is saying that there is something wrong with the expression and it must
    be rejected.

    You could try
    ?- LP = not(true(LP), true(LP).

    or
    ?- LP = not(true(LP), not(true(LP)).

    The predicate unify_with_occurs_check checks whether the resulting
    sructure is acyclic because that is its purpose. Whether a simple

    Yes exactly. If I knew that Prolog did this then I would not have >>>>>>>>>>>>> created Minimal Type Theory that does this same thing. That I did >>>>>>>>>>>>> create MTT that does do this same thing makes my understanding much
    deeper.

    Prolog does not reject LP = not(true(LP)). It can accept it as >>>>>>>>>>>> syntactically valid. Thaat unify_with_occurs_check(LP, not(true(LP))
    fails does not mean anything except when it is used, and then it >>>>>>>>>>>> does not reject but simplu evaluates to false, just like 1 = 2 >>>>>>>>>>>> is false but not erroneous.


    It correctly determines that there is a cycle in the directed graph >>>>>>>>>>> of the evaluation sequence of the expression, which is like an >>>>>>>>>>> infinite loop in a program.

    You can understand this or fail to understand this, disagreement is >>>>>>>>>>> incorrect. If you have any disagreement then please back up your >>>>>>>>>>> claims with proof.

    unification like LP = not(true(LP)) does same is implementation >>>>>>>>>>>>>> dependent as Prolog rules permit but do not require that. In a >>>>>>>>>>>>>> typical implementation a simple unification does not check for >>>>>>>>>>>>>> cycles.


    ISO Prolog implementations have the built-in predicate >>>>>>>>>>>>> unify_with_occurs_check/2 for sound unification
    https://en.wikipedia.org/wiki/Occurs_check#Sound_unification >>>>>>>>>>>>>
    Alternatively such expressions crash or remain stuck in infinite loops.

    Not necessarily. What happes depends on the implementation and on what
    you do with such structures. You already saw that your >>>>>>>>>>>>
    ?- LP = not(true(LP)).

    does not crash and does not remain stuck in infinite loop. >>>>>>>>>>>>
    Anyway, none of this is relevant to the topic of this thread or >>>>>>>>>>>>>> topics of sci.logic.

    If you want to talk nore about Prolog do it in comp.lang.prolog. >>>>>>>>>>>>

    It is relevant to sci.logic in that it exposes fundamental flaws >>>>>>>>>>> with classical logic.

    It does not expose any flaw in classical logic. Flaws in your >>>>>>>>>> understanding of calssical logics are already sufficiently known. >>>>>>>>>
        What has now been shown is that L is true if, and only if, it is
        false. Since L must be one or the other, it is both.

    No, that has not been shown. Classical logic shows that no sentence >>>>>>>> is true if and only if it is false. If you assumoe otherwise then >>>>>>>> your assumption is false.


        *You removed the relevant context that the principle of explosion*
        *of classical logic is shown to be the source of the issue* >>>>>>
    Principle of exposion is empirically true. It is not a problem of
    classical logic. You have not shown that any paraconsistent system, >>>>>> where principle of exposion does not apply, is any better.


    The ONLY THING that can ever be correctly derived from a contradiction >>>>> is FALSE. People taking classical logic as infallible by simply ignoring >>>>> its inconsistencies are inherently incorrect.

    The inconsistencies are not inconsistencies of logic. No logic can
    prevent you from assuming an inconsistency but then it is your
    inconsistency.

    People taking classical logic as infallible do so because no situation >>>> where it is wrong has been observed.

    *Three laws of logic apply to all propositions*
    ¬(p ∧ ¬p) Law of non-contradiction
      (p ∨ ¬p) Law of excluded middle
       p = p   Law of identity

    Those laws don't prevent from assuming p. Those laws don't prevent
    from assuming ¬p. Assuming both is assuming something false.


    (1) We know that "Not all lemons are yellow", as it has been assumed to
    be true.
    (2) We know that "All lemons are yellow", as it has been assumed to be true.

    No. To assume something does not make it true and does not make us
    to know whether it is true. A false assumption is false and if you
    assume otherwise you don't know.

    In order to return to the topic of the discussion we may note that
    may statment about knoing is true on the basis of meaning.

    (3) Therefore, the two-part statement "All lemons are yellow or
    unicorns exist" must also be true, since the first part of the
    statement ("All lemons are yellow") has already been assumed, and the
    use of "or" means that if even one part of the statement is true, the statement as a whole must be true as well.

    No, it need not be true as a mere assumption does change the color of lemons.

    There is nothing about the color of lemons that has anything to do
    with the existence of unicorns, thus the root cause of the huge mistake
    of classical logic is to allow semantics to be divorced from logic.

    People who have studied semantics and logic have found that more
    can be learned when they are studined separately.

    --
    Mikko

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