Groups | Search | Server Info | Keyboard shortcuts | Login | Register [http] [https] [nntp] [nntps]
Groups > comp.theory > #104638 > unrolled thread
| Started by | olcott <polcott333@gmail.com> |
|---|---|
| First post | 2024-05-10 21:36 -0500 |
| Last post | 2024-05-14 10:26 -0500 |
| Articles | 20 on this page of 156 — 6 participants |
Back to article view | Back to comp.theory
True on the basis of meaning olcott <polcott333@gmail.com> - 2024-05-10 21:36 -0500
Re: True on the basis of meaning Richard Damon <richard@damon-family.org> - 2024-05-10 23:16 -0400
Re: True on the basis of meaning olcott <polcott333@gmail.com> - 2024-05-10 22:35 -0500
Re: True on the basis of meaning Richard Damon <richard@damon-family.org> - 2024-05-10 23:49 -0400
Re: True on the basis of meaning olcott <polcott333@gmail.com> - 2024-05-10 23:27 -0500
Re: True on the basis of meaning Richard Damon <richard@damon-family.org> - 2024-05-11 11:36 -0400
Re: True on the basis of meaning olcott <polcott333@gmail.com> - 2024-05-12 09:22 -0500
Re: True on the basis of meaning olcott <polcott333@gmail.com> - 2024-05-12 12:19 -0500
Re: True on the basis of meaning Richard Damon <richard@damon-family.org> - 2024-05-12 13:52 -0400
Re: True on the basis of meaning olcott <polcott333@gmail.com> - 2024-05-12 13:06 -0500
Re: True on the basis of meaning Richard Damon <richard@damon-family.org> - 2024-05-12 14:22 -0400
Re: True on the basis of meaning olcott <polcott333@gmail.com> - 2024-05-12 13:36 -0500
Re: True on the basis of meaning Richard Damon <richard@damon-family.org> - 2024-05-12 16:33 -0400
Re: True on the basis of meaning olcott <polcott333@gmail.com> - 2024-05-12 16:54 -0500
Re: True on the basis of meaning Richard Damon <richard@damon-family.org> - 2024-05-12 18:40 -0400
Re: True on the basis of meaning olcott <polcott333@gmail.com> - 2024-05-12 17:56 -0500
Re: True on the basis of meaning Richard Damon <richard@damon-family.org> - 2024-05-12 19:02 -0400
Re: True on the basis of meaning olcott <polcott333@gmail.com> - 2024-05-12 18:22 -0500
Re: True on the basis of meaning olcott <polcott333@gmail.com> - 2024-05-12 18:53 -0500
Re: True on the basis of meaning Richard Damon <richard@damon-family.org> - 2024-05-12 20:06 -0400
Re: True on the basis of meaning Richard Damon <richard@damon-family.org> - 2024-05-12 19:55 -0400
Re: True on the basis of meaning olcott <polcott333@gmail.com> - 2024-05-12 19:07 -0500
Re: True on the basis of meaning Richard Damon <richard@damon-family.org> - 2024-05-12 20:35 -0400
Re: True on the basis of meaning olcott <polcott333@gmail.com> - 2024-05-12 22:41 -0500
Re: True on the basis of meaning Richard Damon <richard@damon-family.org> - 2024-05-13 07:18 -0400
Re: True on the basis of meaning --- Good job Richard ! olcott <polcott333@gmail.com> - 2024-05-13 10:04 -0500
Re: True on the basis of meaning --- Good job Richard ! Richard Damon <richard@damon-family.org> - 2024-05-13 20:29 -0400
Re: True on the basis of meaning --- Good job Richard ! olcott <polcott333@gmail.com> - 2024-05-13 19:48 -0500
Re: True on the basis of meaning --- Good job Richard ! Richard Damon <richard@damon-family.org> - 2024-05-13 21:52 -0400
Re: True on the basis of meaning --- Good job Richard ! ---Socratic method olcott <polcott333@gmail.com> - 2024-05-13 21:03 -0500
Re: True on the basis of meaning --- Good job Richard ! ---Socratic method Richard Damon <richard@damon-family.org> - 2024-05-13 22:31 -0400
Re: True on the basis of meaning --- Good job Richard ! ---Socratic method olcott <polcott333@gmail.com> - 2024-05-13 21:49 -0500
Re: True on the basis of meaning --- Good job Richard ! ---Socratic method Richard Damon <richard@damon-family.org> - 2024-05-13 23:16 -0400
Re: True on the basis of meaning --- Good job Richard ! ---Socratic method olcott <polcott333@gmail.com> - 2024-05-13 22:36 -0500
Re: True on the basis of meaning --- Good job Richard ! ---Socratic method Richard Damon <richard@damon-family.org> - 2024-05-14 07:31 -0400
Re: True on the basis of meaning --- Good job Richard ! ---Socratic method wij <wyniijj5@gmail.com> - 2024-05-14 20:02 +0800
Re: True on the basis of meaning --- Good job Richard ! ---Socratic method olcott <polcott333@gmail.com> - 2024-05-14 08:53 -0500
Re: True on the basis of meaning --- Good job Richard ! ---Socratic method Richard Damon <richard@damon-family.org> - 2024-05-14 22:16 -0400
Re: True on the basis of meaning --- Good job Richard ! ---Socratic method olcott <polcott333@gmail.com> - 2024-05-14 21:59 -0500
Re: True on the basis of meaning --- Good job Richard ! ---Socratic method Richard Damon <richard@damon-family.org> - 2024-05-14 23:44 -0400
Re: True on the basis of meaning --- Good job Richard ! ---Socratic method olcott <polcott333@gmail.com> - 2024-05-14 23:11 -0500
Re: True on the basis of meaning --- Good job Richard ! ---Socratic method Richard Damon <richard@damon-family.org> - 2024-05-15 07:16 -0400
Re: True on the basis of meaning --- Good job Richard ! ---Socratic method olcott <polcott333@gmail.com> - 2024-05-15 08:48 -0500
Re: True on the basis of meaning --- Good job Richard ! ---Socratic method Richard Damon <richard@damon-family.org> - 2024-05-15 20:26 -0400
Re: True on the basis of meaning --- Good job Richard ! ---Socratic method olcott <polcott333@gmail.com> - 2024-05-15 19:36 -0500
Re: True on the basis of meaning --- Good job Richard ! ---Socratic method Richard Damon <richard@damon-family.org> - 2024-05-15 20:52 -0400
Re: True on the basis of meaning --- Good job Richard ! ---Socratic method immibis <news@immibis.com> - 2024-05-16 05:38 +0200
Re: True on the basis of meaning --- Good job Richard ! ---Socratic method olcott <polcott333@gmail.com> - 2024-05-15 22:58 -0500
Re: True on the basis of meaning --- Good job Richard ! ---Socratic method olcott <polcott333@gmail.com> - 2024-05-15 20:20 -0500
Re: True on the basis of meaning --- Good job Richard ! ---Socratic method Richard Damon <richard@damon-family.org> - 2024-05-15 21:39 -0400
Re: True on the basis of meaning --- Good job Richard ! ---Socratic method olcott <polcott333@gmail.com> - 2024-05-15 20:57 -0500
Re: True on the basis of meaning --- Good job Richard ! ---Socratic method Richard Damon <richard@damon-family.org> - 2024-05-15 22:07 -0400
Re: True on the basis of meaning --- Good job Richard ! ---Socratic method olcott <polcott333@gmail.com> - 2024-05-15 21:17 -0500
Re: True on the basis of meaning --- Good job Richard ! ---Socratic method Richard Damon <richard@damon-family.org> - 2024-05-15 22:33 -0400
Re: True on the basis of meaning --- Good job Richard ! ---Socratic method olcott <polcott333@gmail.com> - 2024-05-15 21:42 -0500
Re: True on the basis of meaning --- Good job Richard ! ---Socratic method Richard Damon <richard@damon-family.org> - 2024-05-15 23:17 -0400
Re: True on the basis of meaning --- Good job Richard ! ---Socratic method olcott <polcott333@gmail.com> - 2024-05-15 22:33 -0500
Re: True on the basis of meaning --- Good job Richard ! ---Socratic method Richard Damon <richard@damon-family.org> - 2024-05-16 07:29 -0400
Re: True on the basis of meaning --- Good job Richard ! ---Socratic method olcott <polcott333@gmail.com> - 2024-05-16 08:37 -0500
Re: True on the basis of meaning --- Good job Richard ! ---Socratic method Richard Damon <richard@damon-family.org> - 2024-05-16 22:29 -0400
Re: True on the basis of meaning --- Good job Richard ! ---Socratic method olcott <polcott333@gmail.com> - 2024-05-16 21:38 -0500
Re: True on the basis of meaning --- Good job Richard ! ---Socratic method olcott <polcott333@gmail.com> - 2024-05-15 23:44 -0500
Re: True on the basis of meaning --- Good job Richard ! ---Socratic method Richard Damon <richard@damon-family.org> - 2024-05-16 07:32 -0400
Re: True on the basis of meaning --- Good job Richard ! ---Socratic method olcott <polcott333@gmail.com> - 2024-05-16 08:59 -0500
Re: True on the basis of meaning --- Good job Richard ! ---Socratic method Richard Damon <richard@damon-family.org> - 2024-05-16 22:29 -0400
Re: True on the basis of meaning --- Good job Richard ! ---Socratic method olcott <polcott333@gmail.com> - 2024-05-16 21:44 -0500
Re: True on the basis of meaning --- Good job Richard ! ---Socratic method Richard Damon <richard@damon-family.org> - 2024-05-16 22:54 -0400
Re: True on the basis of meaning --- Good job Richard ! ---Socratic method olcott <polcott333@gmail.com> - 2024-05-16 22:20 -0500
Re: True on the basis of meaning --- Good job Richard ! ---Socratic method Richard Damon <richard@damon-family.org> - 2024-05-16 23:29 -0400
Re: True on the basis of meaning --- Good job Richard ! ---Socratic method olcott <polcott333@gmail.com> - 2024-05-16 22:51 -0500
Re: True on the basis of meaning --- Good job Richard ! ---Socratic method Richard Damon <richard@damon-family.org> - 2024-05-17 07:41 -0400
Re: True on the basis of meaning --- Good job Richard ! ---Socratic method olcott <polcott333@gmail.com> - 2024-05-17 09:32 -0500
Re: True on the basis of meaning --- Good job Richard ! ---Socratic method Richard Damon <richard@damon-family.org> - 2024-05-17 21:07 -0400
Re: True on the basis of meaning --- Good job Richard ! ---Socratic method olcott <polcott333@gmail.com> - 2024-05-17 20:22 -0500
Re: True on the basis of meaning --- Good job Richard ! ---Socratic method Richard Damon <richard@damon-family.org> - 2024-05-17 21:33 -0400
Re: True on the basis of meaning --- Good job Richard ! ---Socratic method olcott <polcott333@gmail.com> - 2024-05-17 21:19 -0500
Re: True on the basis of meaning --- Good job Richard ! ---Socratic method Richard Damon <richard@damon-family.org> - 2024-05-17 22:40 -0400
Re: True on the basis of meaning --- Good job Richard ! ---Socratic method olcott <polcott333@gmail.com> - 2024-05-17 22:35 -0500
Re: True on the basis of meaning --- Good job Richard ! ---Socratic method Richard Damon <richard@damon-family.org> - 2024-05-18 08:43 -0400
Re: True on the basis of meaning --- Good job Richard ! ---Socratic method olcott <polcott333@gmail.com> - 2024-05-18 09:15 -0500
Re: True on the basis of meaning --- Good job Richard ! ---Socratic method Richard Damon <richard@damon-family.org> - 2024-05-18 10:32 -0400
Re: True on the basis of meaning --- Good job Richard ! ---Socratic method olcott <polcott333@gmail.com> - 2024-05-18 11:48 -0500
Re: True on the basis of meaning --- Good job Richard ! ---Socratic method Richard Damon <richard@damon-family.org> - 2024-05-18 12:56 -0400
Re: True on the basis of meaning --- Good job Richard ! ---Socratic method olcott <polcott333@gmail.com> - 2024-05-18 12:26 -0500
Re: True on the basis of meaning --- Good job Richard ! ---Socratic method Richard Damon <richard@damon-family.org> - 2024-05-18 13:38 -0400
Re: True on the basis of meaning --- Good job Richard ! ---Socratic method olcott <polcott333@gmail.com> - 2024-05-18 14:35 -0500
Re: True on the basis of meaning --- Good job Richard ! ---Socratic method Richard Damon <richard@damon-family.org> - 2024-05-18 15:54 -0400
Re: True on the basis of meaning --- Good job Richard ! ---Socratic method olcott <polcott333@gmail.com> - 2024-05-18 14:46 -0500
Re: True on the basis of meaning --- Good job Richard ! ---Socratic method Richard Damon <richard@damon-family.org> - 2024-05-18 15:57 -0400
Re: True on the basis of meaning --- Good job Richard ! ---Socratic method olcott <polcott333@gmail.com> - 2024-05-18 15:00 -0500
Re: True on the basis of meaning --- Good job Richard ! ---Socratic method Richard Damon <richard@damon-family.org> - 2024-05-18 18:22 -0400
Re: True on the basis of meaning --- Good job Richard ! ---Socratic method olcott <polcott333@gmail.com> - 2024-05-18 17:47 -0500
Re: True on the basis of meaning --- Good job Richard ! ---Socratic method Richard Damon <richard@damon-family.org> - 2024-05-18 19:04 -0400
Re: True on the basis of meaning --- Good job Richard ! ---Socratic method olcott <polcott333@gmail.com> - 2024-05-18 22:47 -0500
Re: True on the basis of meaning --- Good job Richard ! ---Socratic method Richard Damon <richard@damon-family.org> - 2024-05-19 07:55 -0400
Re: True on the basis of meaning --- Good job Richard ! ---Socratic method olcott <polcott333@gmail.com> - 2024-05-19 08:41 -0500
Re: True on the basis of meaning --- Good job Richard ! ---Socratic method Richard Damon <richard@damon-family.org> - 2024-05-19 13:17 -0400
Re: True on the basis of meaning --- Good job Richard ! ---Socratic method olcott <polcott333@gmail.com> - 2024-05-19 15:12 -0500
Re: True on the basis of meaning --- Good job Richard ! ---Socratic method Richard Damon <richard@damon-family.org> - 2024-05-19 19:30 -0400
Re: True on the basis of meaning --- Good job Richard ! ---Socratic method olcott <polcott333@gmail.com> - 2024-05-20 13:59 -0500
Re: True on the basis of meaning --- Good job Richard ! ---Socratic method Richard Damon <richard@damon-family.org> - 2024-05-20 20:57 -0400
Re: True on the basis of meaning --- Good job Richard ! ---Socratic method olcott <polcott333@gmail.com> - 2024-05-20 20:54 -0500
Re: True on the basis of meaning --- Good job Richard ! ---Socratic method Richard Damon <richard@damon-family.org> - 2024-05-20 22:24 -0400
Re: True on the basis of meaning --- Good job Richard ! ---Socratic method olcott <polcott333@gmail.com> - 2024-05-20 21:56 -0500
Re: True on the basis of meaning --- Good job Richard ! ---Socratic method Richard Damon <richard@damon-family.org> - 2024-05-20 23:37 -0400
Re: True on the basis of meaning --- Good job Richard ! ---Socratic method olcott <polcott333@gmail.com> - 2024-05-21 00:52 -0500
Re: True on the basis of meaning --- Good job Richard ! ---Socratic method Richard Damon <richard@damon-family.org> - 2024-05-21 07:50 -0400
Re: True on the basis of meaning --- Good job Richard ! ---Socratic method olcott <polcott333@gmail.com> - 2024-05-21 10:00 -0500
Re: True on the basis of meaning --- Good job Richard ! ---Socratic method immibis <news@immibis.com> - 2024-05-21 18:08 +0200
Re: True on the basis of meaning --- Good job Richard ! ---Socratic method Richard Damon <richard@damon-family.org> - 2024-05-21 21:46 -0400
Re: True on the basis of meaning --- Good job Richard ! ---Socratic method immibis <news@immibis.com> - 2024-05-20 13:29 +0200
Re: True on the basis of meaning --- Good job Richard ! ---Socratic method olcott <polcott333@gmail.com> - 2024-05-20 12:48 -0500
Re: True on the basis of meaning --- Good job Richard ! ---Socratic method (agreement) olcott <polcott333@gmail.com> - 2024-05-22 14:52 -0500
Re: True on the basis of meaning --- Good job Richard ! ---Socratic method (agreement) Richard Damon <richard@damon-family.org> - 2024-05-22 19:01 -0400
Re: True on the basis of meaning --- Good job Richard ! ---Socratic method (agreement) olcott <polcott333@gmail.com> - 2024-05-22 18:55 -0500
Re: True on the basis of meaning --- Good job Richard ! ---Socratic method (agreement) Richard Damon <richard@damon-family.org> - 2024-05-22 21:03 -0400
Re: True on the basis of meaning --- Good job Richard ! ---Socratic method (agreement) olcott <polcott333@gmail.com> - 2024-05-22 20:36 -0500
Re: True on the basis of meaning --- Good job Richard ! ---Socratic method (agreement) Richard Damon <richard@damon-family.org> - 2024-05-22 22:31 -0400
Re: True on the basis of meaning --- Good job Richard ! ---Socratic method (agreement) olcott <polcott333@gmail.com> - 2024-05-22 22:45 -0500
Re: True on the basis of meaning --- Good job Richard ! ---Socratic method (agreement) Richard Damon <richard@damon-family.org> - 2024-05-23 07:29 -0400
Re: True on the basis of meaning --- Good job Richard ! ---Socratic method (agreement) olcott <polcott333@gmail.com> - 2024-05-23 08:46 -0500
Re: True on the basis of meaning --- Good job Richard ! ---Socratic method (agreement) Richard Damon <richard@damon-family.org> - 2024-05-23 21:44 -0400
Re: True on the basis of meaning --- Good job Richard ! ---Socratic method (agreement) olcott <polcott333@gmail.com> - 2024-05-25 13:13 -0500
Re: True on the basis of meaning --- Good job Richard ! ---Socratic method (agreement) olcott <polcott333@gmail.com> - 2024-05-27 09:15 -0500
Re: True on the basis of meaning --- Good job Richard ! ---Socratic method MTT olcott <polcott333@gmail.com> - 2024-05-27 09:34 -0500
Re: True on the basis of meaning --- Good job Richard ! ---Socratic method MTT olcott <polcott333@gmail.com> - 2024-05-28 09:59 -0500
Re: True on the basis of meaning --- Good job Richard ! ---Socratic method MTT Richard Damon <richard@damon-family.org> - 2024-05-28 22:04 -0400
Re: True on the basis of meaning --- Good job Richard ! ---Socratic method MTT olcott <polcott333@gmail.com> - 2024-05-28 21:39 -0500
Re: True on the basis of meaning --- Good job Richard ! ---Socratic method MTT Richard Damon <richard@damon-family.org> - 2024-05-28 23:38 -0400
Re: True on the basis of meaning --- Good job Richard ! ---Socratic method MTT olcott <polcott333@gmail.com> - 2024-05-28 22:54 -0500
Re: True on the basis of meaning --- Good job Richard ! ---Socratic method MTT Richard Damon <richard@damon-family.org> - 2024-05-29 07:31 -0400
Re: True on the basis of meaning --- Good job Richard ! ---Socratic method MTT olcott <polcott333@gmail.com> - 2024-05-29 09:00 -0500
Re: True on the basis of meaning --- Good job Richard ! ---Socratic method MTT Richard Damon <richard@damon-family.org> - 2024-05-29 19:47 -0400
Re: True on the basis of meaning --- Good job Richard ! ---Socratic method MTT Python <python@invalid.org> - 2024-05-29 09:01 +0200
Re: True on the basis of meaning --- Good job Richard ! ---Socratic method MTT olcott <polcott333@gmail.com> - 2024-05-29 08:11 -0500
Re: True on the basis of meaning --- Good job Richard ! ---Socratic method MTT Richard Damon <richard@damon-family.org> - 2024-05-29 19:47 -0400
Re: True on the basis of meaning --- Good job Richard ! ---Socratic method (agreement) olcott <polcott333@gmail.com> - 2024-05-22 20:07 -0500
Re: True on the basis of meaning --- Good job Richard ! ---Socratic method olcott <polcott333@gmail.com> - 2024-05-17 00:28 -0500
Re: True on the basis of meaning --- Good job Richard ! ---Socratic method Richard Damon <richard@damon-family.org> - 2024-05-17 07:41 -0400
Re: True on the basis of meaning olcott <polcott333@gmail.com> - 2024-05-13 09:48 -0500
Re: True on the basis of meaning Richard Damon <richard@damon-family.org> - 2024-05-13 20:29 -0400
Re: True on the basis of meaning olcott <polcott333@gmail.com> - 2024-05-14 09:42 -0500
Re: True on the basis of meaning Richard Damon <richard@damon-family.org> - 2024-05-14 22:16 -0400
Re: True on the basis of meaning olcott <polcott333@gmail.com> - 2024-05-15 09:27 -0500
Re: True on the basis of meaning Richard Damon <richard@damon-family.org> - 2024-05-15 20:25 -0400
Re: True on the basis of meaning olcott <polcott333@gmail.com> - 2024-05-17 12:23 -0500
Re: True on the basis of meaning Richard Damon <richard@damon-family.org> - 2024-05-17 21:07 -0400
Re: True on the basis of meaning Mikko <mikko.levanto@iki.fi> - 2024-05-13 11:52 +0300
Re: True on the basis of meaning --- Tarski olcott <polcott333@gmail.com> - 2024-05-13 09:34 -0500
Re: True on the basis of meaning --- Tarski olcott <polcott333@gmail.com> - 2024-05-14 10:18 -0500
Re: True on the basis of meaning --- Tarski Richard Damon <richard@damon-family.org> - 2024-05-14 22:16 -0400
Re: True on the basis of meaning --- Tarski olcott <polcott333@gmail.com> - 2024-05-15 09:31 -0500
Re: True on the basis of meaning --- Tarski Richard Damon <richard@damon-family.org> - 2024-05-15 20:26 -0400
Re: True on the basis of meaning --- Tarski olcott <polcott333@gmail.com> - 2024-05-17 12:28 -0500
Re: True on the basis of meaning --- Tarski Richard Damon <richard@damon-family.org> - 2024-05-17 21:07 -0400
Re: True on the basis of meaning --- Tarski olcott <polcott333@gmail.com> - 2024-05-14 10:26 -0500
Page 6 of 8 — ← Prev page 1 2 3 4 5 [6] 7 8 Next page →
| From | Richard Damon <richard@damon-family.org> |
|---|---|
| Date | 2024-05-20 20:57 -0400 |
| Subject | Re: True on the basis of meaning --- Good job Richard ! ---Socratic method |
| Message-ID | <v2grhe$1kiah$1@i2pn2.org> |
| In reply to | #105305 |
On 5/20/24 2:59 PM, olcott wrote:
> On 5/19/2024 6:30 PM, Richard Damon wrote:
>> On 5/19/24 4:12 PM, olcott wrote:
>>> On 5/19/2024 12:17 PM, Richard Damon wrote:
>>>> On 5/19/24 9:41 AM, olcott wrote:
>>>>>
>>>>> True(L,x) is always a truth bearer.
>>>>> when x is defined as True(L,x) then x is not a truth bearer.
>>>>
>>>> So, x being DEFINED to be a certain sentence doesn't make x to have
>>>> the same meaning as the sentence itself?
>>>>
>>>> What does it mean to define a name to a given sentence, if not that
>>>> such a name referes to exactly that sentence?
>>>>
>>>
>>> p = ~True(L,p) // p is not a truth bearer because its refers to itself
>>
>> Then ~True(L,p) can't be a truth beared as they are the SAME
>> STATEMENT, just using different "names".
>
>
> Truthbearer(L,x) ≡ (True(L,x) ∨ True(L,~x))
> p = ~True(L,p) Truthbearer(L,p) is false
> q = ~True(L,p) Truthbearer(L,q) is true
Irrelvent.
If Truthbearer(L, p) is FALSE, and since p is just a NAME for the
statement ~True(L, p), that means that True(L. p) is not a truth bearer
and True has failed to be the required truth predicate.
If you are defining your "=" symbol to be "is defined as" so the left
side is now a name for the right side, you statement above just PROVES
that your logic system is inconsistant as the same expression (with just
different names) has contradicory values.
You are just showing you utter lack of understanding of the fundamentals
of Formal Logic.
>>
>> Just like (with context) YOU can be refered to a PO, Peter, Peter
>> Olcott or Olcott, and all the reference get to the exact same entity,
>> so any "name" for the express
>>
>>> True(L,p) is false
>>> True(L,~p) is false
>>>
>>
>> So since True(L, p) is false, then ~True(L, p) is true.
>>
>>> ~True(True(L,p)) is true and is referring to the p that refers
>>> to itself it is not referring to its own self.
>>>
>>> *ONE LEVEL OF INDIRECT REFERENCE MAKES ALL THE DIFFERENCE*
>>
>> Why add the indirection? p is the NAME of the statement, which means
>> exactly the same thing as the statement itself.
>>
>
> p = ~True(L,p)
> does not mean that same thing as True(L, ~True(L,p))
> The above ~True(L, p) has another ~True(L,p) embedded in p.
>
>> Is the definition of an English word one level LESS of indirection
>> than the word itself?
>>
>
> This sentence is not true("This sentence is not true") is true.
Right, that is a sentence about another sentence (that is part of itself)
p defined as ~True(L, p) isn't a sentence refering to ~True(L, p), it is
assigning a name to the sentence to allow OTHER sentences to refer to it
by name,
>
>> I don't think you understand what it means to define something.
>>
>
> x := y means x is defined to be another name for y
> https://en.wikipedia.org/wiki/List_of_logic_symbols
>
> LP := ~True(L, LP)
> specifies ~True(~True(~True(~True(~True(...)))))
Nope.
It means that LP is defined to be the sentence ~True(L, LP)
replacing the LP in the sentence with a copy of LP IS a level of
indirection, so you can get the infinite expansion if you keep or
derefencing the reference in the statement.
>
>> "Definition by example" is worse than "Proof by example", at least
>> proof by example can be correct if the assertion is that there exists,
>> and not for all.
>>
>
> A simpler isomorphism of the same thing is proof by analogy.
>
Which isn't a valid proof in a formal system. You seem to think Formal
System are a loosy goosy with proofs as Philosophy.
>> A level of indirection:
>>
>> p: "This sentence is true", which is exactly the same as "p is true"
>> since "this sentence" IS p
>>
>
> p := True(L,p)
> specifies True(True(True(True(True(...)))))
Nope, it is equivelent to that, but doesn't SPECIFY that.
As I said above that is expanding levels of indirecction.
>
> *Prolog sees the same infinite recursion and rejects it*
> ?- TT = true(TT).
> TT = true(TT).
>
> ?- unify_with_occurs_check(TT, true(TT)).
> false.
>
Right, because prolog can't handle any levels of self referencing, and
thus is not suitable for logic that can do that.
You have been told this, but don't seem to understand it. My guess is
you can't understand any logic more complicated than what Prolog
handles, so don't realize how much it just doesn't handle.
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2024-05-20 20:54 -0500 |
| Subject | Re: True on the basis of meaning --- Good job Richard ! ---Socratic method |
| Message-ID | <v2gusf$ctu7$1@dont-email.me> |
| In reply to | #105311 |
On 5/20/2024 7:57 PM, Richard Damon wrote:
> On 5/20/24 2:59 PM, olcott wrote:
>> On 5/19/2024 6:30 PM, Richard Damon wrote:
>>> On 5/19/24 4:12 PM, olcott wrote:
>>>> On 5/19/2024 12:17 PM, Richard Damon wrote:
>>>>> On 5/19/24 9:41 AM, olcott wrote:
>>>>>>
>>>>>> True(L,x) is always a truth bearer.
>>>>>> when x is defined as True(L,x) then x is not a truth bearer.
>>>>>
>>>>> So, x being DEFINED to be a certain sentence doesn't make x to have
>>>>> the same meaning as the sentence itself?
>>>>>
>>>>> What does it mean to define a name to a given sentence, if not that
>>>>> such a name referes to exactly that sentence?
>>>>>
>>>>
>>>> p = ~True(L,p) // p is not a truth bearer because its refers to itself
>>>
>>> Then ~True(L,p) can't be a truth beared as they are the SAME
>>> STATEMENT, just using different "names".
>>
>>
>> Truthbearer(L,x) ≡ (True(L,x) ∨ True(L,~x))
>> p = ~True(L,p) Truthbearer(L,p) is false
>> q = ~True(L,p) Truthbearer(L,q) is true
>
> Irrelvent.
>
> If Truthbearer(L, p) is FALSE, and since p is just a NAME for the
> statement ~True(L, p), that means that True(L. p) is not a truth bearer
> and True has failed to be the required truth predicate.
>
That is the same thing as saying that
True(English, "this sentence is not true") is false
proves that True(L,x) is not a truthbearer.
> If you are defining your "=" symbol to be "is defined as" so the left
> side is now a name for the right side, you statement above just PROVES
> that your logic system is inconsistant as the same expression (with just
> different names) has contradicory values.
>
> You are just showing you utter lack of understanding of the fundamentals
> of Formal Logic.
>
ϕ(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
No what it shows is that formal logic gets the wrong answer because
formal logic does not evaluate actual self-reference.
>
>>>
>>> Just like (with context) YOU can be refered to a PO, Peter, Peter
>>> Olcott or Olcott, and all the reference get to the exact same entity,
>>> so any "name" for the express
>>>
>>>> True(L,p) is false
>>>> True(L,~p) is false
>>>>
>>>
>>> So since True(L, p) is false, then ~True(L, p) is true.
>>>
>>>> ~True(True(L,p)) is true and is referring to the p that refers
>>>> to itself it is not referring to its own self.
>>>>
>>>> *ONE LEVEL OF INDIRECT REFERENCE MAKES ALL THE DIFFERENCE*
>>>
>>> Why add the indirection? p is the NAME of the statement, which means
>>> exactly the same thing as the statement itself.
>>>
>>
>> p = ~True(L,p)
>> does not mean that same thing as True(L, ~True(L,p))
>> The above ~True(L, p) has another ~True(L,p) embedded in p.
>>
>>> Is the definition of an English word one level LESS of indirection
>>> than the word itself?
>>>
>>
>> This sentence is not true("This sentence is not true") is true.
>
> Right, that is a sentence about another sentence (that is part of itself)
>
Likewise with ~True(L, ~True(L, p)) where p is defined as ~True(L, p)
> p defined as ~True(L, p) isn't a sentence refering to ~True(L, p), it is
> assigning a name to the sentence to allow OTHER sentences to refer to it
> by name,
>
Yet when p refers to its own name this creates infinite recursion.
>
>>
>>> I don't think you understand what it means to define something.
>>>
>>
>> x := y means x is defined to be another name for y
>> https://en.wikipedia.org/wiki/List_of_logic_symbols
>>
>> LP := ~True(L, LP)
>> specifies ~True(~True(~True(~True(~True(...)))))
>
> Nope.
>
When LP refers to its own name this creates infinite recursion.
> It means that LP is defined to be the sentence ~True(L, LP)
>
> replacing the LP in the sentence with a copy of LP IS a level of
> indirection, so you can get the infinite expansion if you keep or
> derefencing the reference in the statement.
>
>
>>
>>> "Definition by example" is worse than "Proof by example", at least
>>> proof by example can be correct if the assertion is that there
>>> exists, and not for all.
>>>
>>
>> A simpler isomorphism of the same thing is proof by analogy.
>>
>
> Which isn't a valid proof in a formal system. You seem to think Formal
> System are a loosy goosy with proofs as Philosophy.
>
True(English, "this sentence is not true") is false
Is 100% perfectly isomorphic to its formalized version
LP is defined as ~True(L, LP)
True(L, LP) is false
It is merely easier to see that "this sentence is not true"
cannot be true because that makes it false and
can't be false because that makes it true.
LP is defined as ~True(L, LP)
works this same yet yet it is not as intuitive.
So we see that the above is a correct formalization
of the English and that gives us the cognitive leverage
of intuition.
>>> A level of indirection:
>>>
>>> p: "This sentence is true", which is exactly the same as "p is true"
>>> since "this sentence" IS p
>>>
>>
>> p := True(L,p)
>> specifies True(True(True(True(True(...)))))
>
> Nope, it is equivelent to that, but doesn't SPECIFY that.
>
LP := ~True(L, LP) means that every instance of LP
in the RHS is the same as the RHS.
Clocksin & Mellish say this same thing.
BEGIN:(Clocksin & Mellish 2003:254)
Finally, a note about how Prolog matching sometimes differs from the
unification used in Resolution. Most Prolog systems will allow you to
satisfy goals like:
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)
> As I said above that is expanding levels of indirecction.
>
>
>>
>> *Prolog sees the same infinite recursion and rejects it*
>> ?- TT = true(TT).
>> TT = true(TT).
>>
>> ?- unify_with_occurs_check(TT, true(TT)).
>> false.
>>
>
> Right, because prolog can't handle any levels of self referencing, and
> thus is not suitable for logic that can do that.
>
Nothing can handle "some kind of infinite structure."
> You have been told this, but don't seem to understand it. My guess is
> you can't understand any logic more complicated than what Prolog
> handles, so don't realize how much it just doesn't handle.
No the whole problem seems to be that you simply don't
bother to pay close enough attention the EXACTLY what I say.
When I prove my point you simply ignore that I proved my point
and baselessly assume that I must be wrong. You will probably
completely "forget" my Clocksin & Mellish quote immediately after
you read it, or skip over it and assume that they are wrong.
--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
[toc] | [prev] | [next] | [standalone]
| From | Richard Damon <richard@damon-family.org> |
|---|---|
| Date | 2024-05-20 22:24 -0400 |
| Subject | Re: True on the basis of meaning --- Good job Richard ! ---Socratic method |
| Message-ID | <v2h0lf$1kiah$13@i2pn2.org> |
| In reply to | #105323 |
On 5/20/24 9:54 PM, olcott wrote:
> On 5/20/2024 7:57 PM, Richard Damon wrote:
>> On 5/20/24 2:59 PM, olcott wrote:
>>> On 5/19/2024 6:30 PM, Richard Damon wrote:
>>>> On 5/19/24 4:12 PM, olcott wrote:
>>>>> On 5/19/2024 12:17 PM, Richard Damon wrote:
>>>>>> On 5/19/24 9:41 AM, olcott wrote:
>>>>>>>
>>>>>>> True(L,x) is always a truth bearer.
>>>>>>> when x is defined as True(L,x) then x is not a truth bearer.
>>>>>>
>>>>>> So, x being DEFINED to be a certain sentence doesn't make x to
>>>>>> have the same meaning as the sentence itself?
>>>>>>
>>>>>> What does it mean to define a name to a given sentence, if not
>>>>>> that such a name referes to exactly that sentence?
>>>>>>
>>>>>
>>>>> p = ~True(L,p) // p is not a truth bearer because its refers to itself
>>>>
>>>> Then ~True(L,p) can't be a truth beared as they are the SAME
>>>> STATEMENT, just using different "names".
>>>
>>>
>>> Truthbearer(L,x) ≡ (True(L,x) ∨ True(L,~x))
>>> p = ~True(L,p) Truthbearer(L,p) is false
>>> q = ~True(L,p) Truthbearer(L,q) is true
>>
>> Irrelvent.
>>
>> If Truthbearer(L, p) is FALSE, and since p is just a NAME for the
>> statement ~True(L, p), that means that True(L. p) is not a truth
>> bearer and True has failed to be the required truth predicate.
>>
>
> That is the same thing as saying that
> True(English, "this sentence is not true") is false
> proves that True(L,x) is not a truthbearer.
Nope, why do you say that?
What logic are you even TRYING to use to get there?
I think you don't understand what defining a label to represent a
statement means.
>
>> If you are defining your "=" symbol to be "is defined as" so the left
>> side is now a name for the right side, you statement above just PROVES
>> that your logic system is inconsistant as the same expression (with
>> just different names) has contradicory values.
>>
>> You are just showing you utter lack of understanding of the
>> fundamentals of Formal Logic.
>>
>
> ϕ(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
So? Can you show that it is NOT true? or is it just that you don't want
it to be true, so you assume it isn't?
>
> No what it shows is that formal logic gets the wrong answer because
> formal logic does not evaluate actual self-reference.
No, you don't understand what you are talking about.
>
>
>>
>>>>
>>>> Just like (with context) YOU can be refered to a PO, Peter, Peter
>>>> Olcott or Olcott, and all the reference get to the exact same
>>>> entity, so any "name" for the express
>>>>
>>>>> True(L,p) is false
>>>>> True(L,~p) is false
>>>>>
>>>>
>>>> So since True(L, p) is false, then ~True(L, p) is true.
>>>>
>>>>> ~True(True(L,p)) is true and is referring to the p that refers
>>>>> to itself it is not referring to its own self.
>>>>>
>>>>> *ONE LEVEL OF INDIRECT REFERENCE MAKES ALL THE DIFFERENCE*
>>>>
>>>> Why add the indirection? p is the NAME of the statement, which means
>>>> exactly the same thing as the statement itself.
>>>>
>>>
>>> p = ~True(L,p)
>>> does not mean that same thing as True(L, ~True(L,p))
>>> The above ~True(L, p) has another ~True(L,p) embedded in p.
>>>
>>>> Is the definition of an English word one level LESS of indirection
>>>> than the word itself?
>>>>
>>>
>>> This sentence is not true("This sentence is not true") is true.
>>
>> Right, that is a sentence about another sentence (that is part of itself)
>>
>
> Likewise with ~True(L, ~True(L, p)) where p is defined as ~True(L, p)
>
So? Yes ~True(L, ~True(L, p)) IS a different sentence than ~True(L, p)
even with p defined a ~True(L, p), BUT they are logically connected as
the first follows as a consequence of the second and the definition of p.
>> p defined as ~True(L, p) isn't a sentence refering to ~True(L, p), it
>> is assigning a name to the sentence to allow OTHER sentences to refer
>> to it by name,
>>
>
> Yet when p refers to its own name this creates infinite recursion.
>
So? What's wrong with that? Note, it is recursion that doesn't HAVE to
be followed. You seem to be stuck at counting the fingers level math,
while trying to talk about trigonometry.
>>
>>>
>>>> I don't think you understand what it means to define something.
>>>>
>>>
>>> x := y means x is defined to be another name for y
>>> https://en.wikipedia.org/wiki/List_of_logic_symbols
>>>
>>> LP := ~True(L, LP)
>>> specifies ~True(~True(~True(~True(~True(...)))))
>>
>> Nope.
>>
>
> When LP refers to its own name this creates infinite recursion.
So? As I said, it doesn't HAVE to be fully expanded, as each level is
doing a logical step of indirection
>
>> It means that LP is defined to be the sentence ~True(L, LP)
>>
>> replacing the LP in the sentence with a copy of LP IS a level of
>> indirection, so you can get the infinite expansion if you keep or
>> derefencing the reference in the statement.
>>
>>
>>>
>>>> "Definition by example" is worse than "Proof by example", at least
>>>> proof by example can be correct if the assertion is that there
>>>> exists, and not for all.
>>>>
>>>
>>> A simpler isomorphism of the same thing is proof by analogy.
>>>
>>
>> Which isn't a valid proof in a formal system. You seem to think Formal
>> System are a loosy goosy with proofs as Philosophy.
>>
>
> True(English, "this sentence is not true") is false
> Is 100% perfectly isomorphic to its formalized version
>
> LP is defined as ~True(L, LP)
> True(L, LP) is false
Nope. Because "this sentence" refers to the statement in quotes, not the
logical statement using True.
>
> It is merely easier to see that "this sentence is not true"
> cannot be true because that makes it false and
> can't be false because that makes it true.
And it is a different sentence.
>
> LP is defined as ~True(L, LP)
> works this same yet yet it is not as intuitive.
You are right that it causes problems, and the problem it causes is that
it shows that the True Predicate can not exist.
>
> So we see that the above is a correct formalization
> of the English and that gives us the cognitive leverage
> of intuition.
Nope, can't because the English sentence doesn't attach a "name" to the
whole expression.
>
>>>> A level of indirection:
>>>>
>>>> p: "This sentence is true", which is exactly the same as "p is true"
>>>> since "this sentence" IS p
>>>>
>>>
>>> p := True(L,p)
>>> specifies True(True(True(True(True(...)))))
>>
>> Nope, it is equivelent to that, but doesn't SPECIFY that.
>>
>
> LP := ~True(L, LP) means that every instance of LP
> in the RHS is the same as the RHS.
>
> Clocksin & Mellish say this same thing.
>
> BEGIN:(Clocksin & Mellish 2003:254)
> Finally, a note about how Prolog matching sometimes differs from the
> unification used in Resolution. Most Prolog systems will allow you to
> satisfy goals like:
And how Prolog does it is irrelevent,
>
> 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)
>
>> As I said above that is expanding levels of indirecction.
>>
>>
>>>
>>> *Prolog sees the same infinite recursion and rejects it*
>>> ?- TT = true(TT).
>>> TT = true(TT).
>>>
>>> ?- unify_with_occurs_check(TT, true(TT)).
>>> false.
>>>
>>
>> Right, because prolog can't handle any levels of self referencing, and
>> thus is not suitable for logic that can do that.
>>
>
> Nothing can handle "some kind of infinite structure."
Wrong. There are lots of logics that handle certain "infinte
structures". After all, Mathematics is BASED on logic on infinite
structures.
>
>> You have been told this, but don't seem to understand it. My guess is
>> you can't understand any logic more complicated than what Prolog
>> handles, so don't realize how much it just doesn't handle.
>
> No the whole problem seems to be that you simply don't
> bother to pay close enough attention the EXACTLY what I say.
No, you don't use the words in the way they are properly defined, so of
course people can't understand what you mean.
We have to guess, and point out the errors that are clearly there.
>
> When I prove my point you simply ignore that I proved my point
> and baselessly assume that I must be wrong. You will probably
> completely "forget" my Clocksin & Mellish quote immediately after
> you read it, or skip over it and assume that they are wrong.
>
Nope, you have yet to present an actual Formal proof. You seem to think
that a Philosophical Arguement can substitute for a Formal Proof. YOu
are just using the wrong tools that don't work in the system.
Maybe if you actually tried to pay attention to what people say an not
assume that your ideas, built on your assumptions of how things must
work, have to be correct.
It seems you don't even have the tools to try to explain what you mean,
but just like to throw out snipits quoted from places that you don;t
really understand, but seem to say something sort of like what you are
trying to say.
All you have done is proved your ignorance.
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2024-05-20 21:56 -0500 |
| Subject | Re: True on the basis of meaning --- Good job Richard ! ---Socratic method |
| Message-ID | <v2h2hs$dgea$1@dont-email.me> |
| In reply to | #105324 |
On 5/20/2024 9:24 PM, Richard Damon wrote:
> On 5/20/24 9:54 PM, olcott wrote:
>> On 5/20/2024 7:57 PM, Richard Damon wrote:
>>> On 5/20/24 2:59 PM, olcott wrote:
>>>> On 5/19/2024 6:30 PM, Richard Damon wrote:
>>>>> On 5/19/24 4:12 PM, olcott wrote:
>>>>>> On 5/19/2024 12:17 PM, Richard Damon wrote:
>>>>>>> On 5/19/24 9:41 AM, olcott wrote:
>>>>>>>>
>>>>>>>> True(L,x) is always a truth bearer.
>>>>>>>> when x is defined as True(L,x) then x is not a truth bearer.
>>>>>>>
>>>>>>> So, x being DEFINED to be a certain sentence doesn't make x to
>>>>>>> have the same meaning as the sentence itself?
>>>>>>>
>>>>>>> What does it mean to define a name to a given sentence, if not
>>>>>>> that such a name referes to exactly that sentence?
>>>>>>>
>>>>>>
>>>>>> p = ~True(L,p) // p is not a truth bearer because its refers to
>>>>>> itself
>>>>>
>>>>> Then ~True(L,p) can't be a truth beared as they are the SAME
>>>>> STATEMENT, just using different "names".
>>>>
>>>>
>>>> Truthbearer(L,x) ≡ (True(L,x) ∨ True(L,~x))
>>>> p = ~True(L,p) Truthbearer(L,p) is false
>>>> q = ~True(L,p) Truthbearer(L,q) is true
>>>
>>> Irrelvent.
>>>
>>> If Truthbearer(L, p) is FALSE, and since p is just a NAME for the
>>> statement ~True(L, p), that means that True(L. p) is not a truth
>>> bearer and True has failed to be the required truth predicate.
>>>
>>
>> That is the same thing as saying that
>> True(English, "this sentence is not true") is false
>> proves that True(L,x) is not a truthbearer.
>
> Nope, why do you say that?
>
> What logic are you even TRYING to use to get there?
>
> I think you don't understand what defining a label to represent a
> statement means.
>
I did not said the above part exactly precisely to address
your objection.
p is defined as ~True(L,p)
LP is defined as "this sentence is not true" in English.
Thus True(L,p) ≡ True(English,LP) and
Thus True(L,~p) ≡ True(English,~LP)
>>
>>> If you are defining your "=" symbol to be "is defined as" so the left
>>> side is now a name for the right side, you statement above just
>>> PROVES that your logic system is inconsistant as the same expression
>>> (with just different names) has contradicory values.
>>>
>>> You are just showing you utter lack of understanding of the
>>> fundamentals of Formal Logic.
>>>
>>
>> ϕ(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
>
> So? Can you show that it is NOT true? or is it just that you don't want
> it to be true, so you assume it isn't?
>
defined as is the way to go.
>>
>> No what it shows is that formal logic gets the wrong answer because
>> formal logic does not evaluate actual self-reference.
>
> No, you don't understand what you are talking about.
>
Formal logic NEVER EVER gets to
epistemological antinomies ARE NOT TRUTH BEARERS
>>
>>
>>>
>>>>>
>>>>> Just like (with context) YOU can be refered to a PO, Peter, Peter
>>>>> Olcott or Olcott, and all the reference get to the exact same
>>>>> entity, so any "name" for the express
>>>>>
>>>>>> True(L,p) is false
>>>>>> True(L,~p) is false
>>>>>>
>>>>>
>>>>> So since True(L, p) is false, then ~True(L, p) is true.
>>>>>
>>>>>> ~True(True(L,p)) is true and is referring to the p that refers
>>>>>> to itself it is not referring to its own self.
>>>>>>
>>>>>> *ONE LEVEL OF INDIRECT REFERENCE MAKES ALL THE DIFFERENCE*
>>>>>
>>>>> Why add the indirection? p is the NAME of the statement, which
>>>>> means exactly the same thing as the statement itself.
>>>>>
>>>>
>>>> p = ~True(L,p)
>>>> does not mean that same thing as True(L, ~True(L,p))
>>>> The above ~True(L, p) has another ~True(L,p) embedded in p.
>>>>
>>>>> Is the definition of an English word one level LESS of indirection
>>>>> than the word itself?
>>>>>
>>>>
>>>> This sentence is not true("This sentence is not true") is true.
>>>
>>> Right, that is a sentence about another sentence (that is part of
>>> itself)
>>>
>>
>> Likewise with ~True(L, ~True(L, p)) where p is defined as ~True(L, p)
>>
>
> So? Yes ~True(L, ~True(L, p)) IS a different sentence than ~True(L, p)
> even with p defined a ~True(L, p), BUT they are logically connected as
> the first follows as a consequence of the second and the definition of p.
>
>>> p defined as ~True(L, p) isn't a sentence refering to ~True(L, p), it
>>> is assigning a name to the sentence to allow OTHER sentences to refer
>>> to it by name,
>>>
>>
>> Yet when p refers to its own name this creates infinite recursion.
>>
>
> So? What's wrong with that?
Sure any programs that get stuck in infinite loops are a feature that
everyone likes even when it means that payroll is two weeks late and
you missed your mortgage payment.
> Note, it is recursion that doesn't HAVE to
> be followed. You seem to be stuck at counting the fingers level math,
> while trying to talk about trigonometry.
>
Any expression "standing for some kind of infinite structure."
CANNOT BE EVALUATED THUS CANNOT POSSIBLY BE A TRUTH BEARER
THUS <IS> A TYPE MISMATCH ERROR FOR EVERY SYSTEM OF BIVALENT LOGIC
>>>
>>>>
>>>>> I don't think you understand what it means to define something.
>>>>>
>>>>
>>>> x := y means x is defined to be another name for y
>>>> https://en.wikipedia.org/wiki/List_of_logic_symbols
>>>>
>>>> LP := ~True(L, LP)
>>>> specifies ~True(~True(~True(~True(~True(...)))))
>>>
>>> Nope.
>>>
>>
>> When LP refers to its own name this creates infinite recursion.
>
> So? As I said, it doesn't HAVE to be fully expanded, as each level is
> doing a logical step of indirection
>
>>
>>> It means that LP is defined to be the sentence ~True(L, LP)
>>>
>>> replacing the LP in the sentence with a copy of LP IS a level of
>>> indirection, so you can get the infinite expansion if you keep or
>>> derefencing the reference in the statement.
>>>
>>>
>>>>
>>>>> "Definition by example" is worse than "Proof by example", at least
>>>>> proof by example can be correct if the assertion is that there
>>>>> exists, and not for all.
>>>>>
>>>>
>>>> A simpler isomorphism of the same thing is proof by analogy.
>>>>
>>>
>>> Which isn't a valid proof in a formal system. You seem to think
>>> Formal System are a loosy goosy with proofs as Philosophy.
>>>
>>
>> True(English, "this sentence is not true") is false
>> Is 100% perfectly isomorphic to its formalized version
>>
>> LP is defined as ~True(L, LP)
>> True(L, LP) is false
>
> Nope. Because "this sentence" refers to the statement in quotes, not the
> logical statement using True.
>
The English is formalized as LP is defined as ~True(L, LP)
before it is analyzed.
>>
>> It is merely easier to see that "this sentence is not true"
>> cannot be true because that makes it false and
>> can't be false because that makes it true.
>
> And it is a different sentence.
>
No it is not.
The English is formalized as
LP is defined as ~True(L, LP) before it is analyzed.
>>
>> LP is defined as ~True(L, LP)
>> works this same yet yet it is not as intuitive.
>
> You are right that it causes problems, and the problem it causes is that
> it shows that the True Predicate can not exist.
>
Not at all.
It shows that no truth bearers must be rejected as
a type mismatch error for any system of bivalent logic.
>>
>> So we see that the above is a correct formalization
>> of the English and that gives us the cognitive leverage
>> of intuition.
>
> Nope, can't because the English sentence doesn't attach a "name" to the
> whole expression.
>
>>
>>>>> A level of indirection:
>>>>>
>>>>> p: "This sentence is true", which is exactly the same as "p is
>>>>> true" since "this sentence" IS p
>>>>>
>>>>
>>>> p := True(L,p)
>>>> specifies True(True(True(True(True(...)))))
>>>
>>> Nope, it is equivelent to that, but doesn't SPECIFY that.
>>>
>>
>> LP := ~True(L, LP) means that every instance of LP
>> in the RHS is the same as the RHS.
>>
>> Clocksin & Mellish say this same thing.
>>
>> BEGIN:(Clocksin & Mellish 2003:254)
>> Finally, a note about how Prolog matching sometimes differs from the
>> unification used in Resolution. Most Prolog systems will allow you to
>> satisfy goals like:
>
> And how Prolog does it is irrelevent,
>
Not at all.
Prolog sees that LP is defined as ~True(LP) is nonsense
and rejects it.
>>
>> 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)
>>
>>> As I said above that is expanding levels of indirecction.
>>>
>>>
>>>>
>>>> *Prolog sees the same infinite recursion and rejects it*
>>>> ?- TT = true(TT).
>>>> TT = true(TT).
>>>>
>>>> ?- unify_with_occurs_check(TT, true(TT)).
>>>> false.
>>>>
>>>
>>> Right, because prolog can't handle any levels of self referencing,
>>> and thus is not suitable for logic that can do that.
>>>
>>
>> Nothing can handle "some kind of infinite structure."
>
> Wrong. There are lots of logics that handle certain "infinte
> structures". After all, Mathematics is BASED on logic on infinite
> structures.
>
No expression that itself has an infinite structure can be
evaluated in finite time. that is what "infinite structure"
is defined to mean.
>>
>>> You have been told this, but don't seem to understand it. My guess is
>>> you can't understand any logic more complicated than what Prolog
>>> handles, so don't realize how much it just doesn't handle.
>>
>> No the whole problem seems to be that you simply don't
>> bother to pay close enough attention the EXACTLY what I say.
>
> No, you don't use the words in the way they are properly defined, so of
> course people can't understand what you mean.
>
> We have to guess, and point out the errors that are clearly there.
>
>>
>> When I prove my point you simply ignore that I proved my point
>> and baselessly assume that I must be wrong. You will probably
>> completely "forget" my Clocksin & Mellish quote immediately after
>> you read it, or skip over it and assume that they are wrong.
>>
>
> Nope, you have yet to present an actual Formal proof.
A proof need not be formal.
A proof is any statement where its negation is unsatisfiable.
> You seem to think
> that a Philosophical Arguement can substitute for a Formal Proof. YOu
> are just using the wrong tools that don't work in the system.
>
> Maybe if you actually tried to pay attention to what people say an not
> assume that your ideas, built on your assumptions of how things must
> work, have to be correct.
>
Try to "prove" that "2" really does stand for a number
without resorting to any definitions.
The definition itself is the complete proof, no steps required.
> It seems you don't even have the tools to try to explain what you mean,
> but just like to throw out snipits quoted from places that you don;t
> really understand, but seem to say something sort of like what you are
> trying to say.
>
> All you have done is proved your ignorance.
Most of the best experts in the world are not sure that the Liar Paradox
is not a truth bearer. At least you know this much.
When we get to the formalized Liar Paradox this seems too difficult
for you, yet you are still doing better than most experts in the world.
You are even better at formalizing the Liar Paradox than most experts
in the field. They try to get away with this crap: LP ↔ ~True(LP).
You understand that this is the correct way: p defined as ~True(L, p).
So it is still: Good job Richard !
--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
[toc] | [prev] | [next] | [standalone]
| From | Richard Damon <richard@damon-family.org> |
|---|---|
| Date | 2024-05-20 23:37 -0400 |
| Subject | Re: True on the basis of meaning --- Good job Richard ! ---Socratic method |
| Message-ID | <v2h4ui$1kiag$1@i2pn2.org> |
| In reply to | #105327 |
On 5/20/24 10:56 PM, olcott wrote:
> On 5/20/2024 9:24 PM, Richard Damon wrote:
>> On 5/20/24 9:54 PM, olcott wrote:
>>> On 5/20/2024 7:57 PM, Richard Damon wrote:
>>>> On 5/20/24 2:59 PM, olcott wrote:
>>>>> On 5/19/2024 6:30 PM, Richard Damon wrote:
>>>>>> On 5/19/24 4:12 PM, olcott wrote:
>>>>>>> On 5/19/2024 12:17 PM, Richard Damon wrote:
>>>>>>>> On 5/19/24 9:41 AM, olcott wrote:
>>>>>>>>>
>>>>>>>>> True(L,x) is always a truth bearer.
>>>>>>>>> when x is defined as True(L,x) then x is not a truth bearer.
>>>>>>>>
>>>>>>>> So, x being DEFINED to be a certain sentence doesn't make x to
>>>>>>>> have the same meaning as the sentence itself?
>>>>>>>>
>>>>>>>> What does it mean to define a name to a given sentence, if not
>>>>>>>> that such a name referes to exactly that sentence?
>>>>>>>>
>>>>>>>
>>>>>>> p = ~True(L,p) // p is not a truth bearer because its refers to
>>>>>>> itself
>>>>>>
>>>>>> Then ~True(L,p) can't be a truth beared as they are the SAME
>>>>>> STATEMENT, just using different "names".
>>>>>
>>>>>
>>>>> Truthbearer(L,x) ≡ (True(L,x) ∨ True(L,~x))
>>>>> p = ~True(L,p) Truthbearer(L,p) is false
>>>>> q = ~True(L,p) Truthbearer(L,q) is true
>>>>
>>>> Irrelvent.
>>>>
>>>> If Truthbearer(L, p) is FALSE, and since p is just a NAME for the
>>>> statement ~True(L, p), that means that True(L. p) is not a truth
>>>> bearer and True has failed to be the required truth predicate.
>>>>
>>>
>>> That is the same thing as saying that
>>> True(English, "this sentence is not true") is false
>>> proves that True(L,x) is not a truthbearer.
>>
>> Nope, why do you say that?
>>
>> What logic are you even TRYING to use to get there?
>>
>> I think you don't understand what defining a label to represent a
>> statement means.
>>
>
> I did not said the above part exactly precisely to address
> your objection.
>
> p is defined as ~True(L,p)
> LP is defined as "this sentence is not true" in English.
> Thus True(L,p) ≡ True(English,LP) and
> Thus True(L,~p) ≡ True(English,~LP)
So, you admit that you did not answer the problem.
And that you think Strawmen and Red Herring are valid forms of logic.
How does p defined as ~True(L, p) NOT generate the shown contradiction
when you begin by saying True(L, p) must not be true (and thus false)
because p has not chain to truthbears?
You are just showing that you think it is ok for logical system to have
contradictions in them.
>
>>>
>>>> If you are defining your "=" symbol to be "is defined as" so the
>>>> left side is now a name for the right side, you statement above just
>>>> PROVES that your logic system is inconsistant as the same expression
>>>> (with just different names) has contradicory values.
>>>>
>>>> You are just showing you utter lack of understanding of the
>>>> fundamentals of Formal Logic.
>>>>
>>>
>>> ϕ(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
>>
>> So? Can you show that it is NOT true? or is it just that you don't
>> want it to be true, so you assume it isn't?
>>
>
> defined as is the way to go.
Which mean?
And what does it have to do with the original statement?
Remember, if your goal is to just show that conventonal logic is just
broken, you are going to need to make a much more convincing arguement
to scrap it, unless you have a FULLY DEVELOPED alternative that does better.
Just remember, once you throw out the foundations, you need to start
from a brand new foundation, and unless you have been lying about your
prognossis, and sand-bagging about your logical abilities, your chance
of actually proving somethiing like that is just about zero.
>
>>>
>>> No what it shows is that formal logic gets the wrong answer because
>>> formal logic does not evaluate actual self-reference.
>>
>> No, you don't understand what you are talking about.
>>
>
> Formal logic NEVER EVER gets to
> epistemological antinomies ARE NOT TRUTH BEARERS
Of course it does.
You just don't understand what you are reading.
In fact, Tarski points out the BECAUSE he can show that the existance of
a Truth Primative forces an epistemological antinomy to have a truth
value, that there can not be an existing Truth Primative.
YOU just don't understand logic,
>
>>>
>>>
>>>>
>>>>>>
>>>>>> Just like (with context) YOU can be refered to a PO, Peter, Peter
>>>>>> Olcott or Olcott, and all the reference get to the exact same
>>>>>> entity, so any "name" for the express
>>>>>>
>>>>>>> True(L,p) is false
>>>>>>> True(L,~p) is false
>>>>>>>
>>>>>>
>>>>>> So since True(L, p) is false, then ~True(L, p) is true.
>>>>>>
>>>>>>> ~True(True(L,p)) is true and is referring to the p that refers
>>>>>>> to itself it is not referring to its own self.
>>>>>>>
>>>>>>> *ONE LEVEL OF INDIRECT REFERENCE MAKES ALL THE DIFFERENCE*
>>>>>>
>>>>>> Why add the indirection? p is the NAME of the statement, which
>>>>>> means exactly the same thing as the statement itself.
>>>>>>
>>>>>
>>>>> p = ~True(L,p)
>>>>> does not mean that same thing as True(L, ~True(L,p))
>>>>> The above ~True(L, p) has another ~True(L,p) embedded in p.
>>>>>
>>>>>> Is the definition of an English word one level LESS of indirection
>>>>>> than the word itself?
>>>>>>
>>>>>
>>>>> This sentence is not true("This sentence is not true") is true.
>>>>
>>>> Right, that is a sentence about another sentence (that is part of
>>>> itself)
>>>>
>>>
>>> Likewise with ~True(L, ~True(L, p)) where p is defined as ~True(L, p)
>>>
>>
>> So? Yes ~True(L, ~True(L, p)) IS a different sentence than ~True(L, p)
>> even with p defined a ~True(L, p), BUT they are logically connected as
>> the first follows as a consequence of the second and the definition of p.
>>
>>>> p defined as ~True(L, p) isn't a sentence refering to ~True(L, p),
>>>> it is assigning a name to the sentence to allow OTHER sentences to
>>>> refer to it by name,
>>>>
>>>
>>> Yet when p refers to its own name this creates infinite recursion.
>>>
>>
>> So? What's wrong with that?
>
> Sure any programs that get stuck in infinite loops are a feature that
> everyone likes even when it means that payroll is two weeks late and
> you missed your mortgage payment.
Which has nothing to do with the Halting Problem.
>
>> Note, it is recursion that doesn't HAVE to be followed. You seem to be
>> stuck at counting the fingers level math, while trying to talk about
>> trigonometry.
>>
>
> Any expression "standing for some kind of infinite structure."
> CANNOT BE EVALUATED THUS CANNOT POSSIBLY BE A TRUTH BEARER
> THUS <IS> A TYPE MISMATCH ERROR FOR EVERY SYSTEM OF BIVALENT LOGIC
So, I guess you don't beleive in mathematics.
And the value of Pi doesn't exist, or the square root of 2.
You are just incapable of understanding how infinities CAN work.
There is no NEED to expand the reference loop to infinity, so that isn't
actually a problem.
>
>>>>
>>>>>
>>>>>> I don't think you understand what it means to define something.
>>>>>>
>>>>>
>>>>> x := y means x is defined to be another name for y
>>>>> https://en.wikipedia.org/wiki/List_of_logic_symbols
>>>>>
>>>>> LP := ~True(L, LP)
>>>>> specifies ~True(~True(~True(~True(~True(...)))))
>>>>
>>>> Nope.
>>>>
>>>
>>> When LP refers to its own name this creates infinite recursion.
>>
>> So? As I said, it doesn't HAVE to be fully expanded, as each level is
>> doing a logical step of indirection
>>
>>>
>>>> It means that LP is defined to be the sentence ~True(L, LP)
>>>>
>>>> replacing the LP in the sentence with a copy of LP IS a level of
>>>> indirection, so you can get the infinite expansion if you keep or
>>>> derefencing the reference in the statement.
>>>>
>>>>
>>>>>
>>>>>> "Definition by example" is worse than "Proof by example", at least
>>>>>> proof by example can be correct if the assertion is that there
>>>>>> exists, and not for all.
>>>>>>
>>>>>
>>>>> A simpler isomorphism of the same thing is proof by analogy.
>>>>>
>>>>
>>>> Which isn't a valid proof in a formal system. You seem to think
>>>> Formal System are a loosy goosy with proofs as Philosophy.
>>>>
>>>
>>> True(English, "this sentence is not true") is false
>>> Is 100% perfectly isomorphic to its formalized version
>>>
>>> LP is defined as ~True(L, LP)
>>> True(L, LP) is false
>>
>> Nope. Because "this sentence" refers to the statement in quotes, not
>> the logical statement using True.
>>
>
> The English is formalized as LP is defined as ~True(L, LP)
> before it is analyzed.
Nope, because the English doesn't carry the meaning of being a Truth
Predicate. But, since you don't seem to understand what that means, you
can't tell the difference, but it proves your own ignorance to make the
claim.
>
>>>
>>> It is merely easier to see that "this sentence is not true"
>>> cannot be true because that makes it false and
>>> can't be false because that makes it true.
>>
>> And it is a different sentence.
>>
>
> No it is not.
> The English is formalized as
> LP is defined as ~True(L, LP) before it is analyzed.
Nope, You can't make that claim.
>
>>>
>>> LP is defined as ~True(L, LP)
>>> works this same yet yet it is not as intuitive.
>>
>> You are right that it causes problems, and the problem it causes is
>> that it shows that the True Predicate can not exist.
>>
>
> Not at all.
> It shows that no truth bearers must be rejected as
> a type mismatch error for any system of bivalent logic.
Which isn't allowed.
You seem to have this problem with things defined to work on ALL
statements expressable in the languge.
It is DEFINED how the Truth predicate is to work on non-truth bearers,
and that to return the false value.
It is basically defined similar to Sipser Decider, in that it turns
"non-answers" into a defined answer, and that requirement is what make
it not possible, but that requirement is a fundamental part of the problem.
>
>>>
>>> So we see that the above is a correct formalization
>>> of the English and that gives us the cognitive leverage
>>> of intuition.
>>
>> Nope, can't because the English sentence doesn't attach a "name" to
>> the whole expression.
>>
>>>
>>>>>> A level of indirection:
>>>>>>
>>>>>> p: "This sentence is true", which is exactly the same as "p is
>>>>>> true" since "this sentence" IS p
>>>>>>
>>>>>
>>>>> p := True(L,p)
>>>>> specifies True(True(True(True(True(...)))))
>>>>
>>>> Nope, it is equivelent to that, but doesn't SPECIFY that.
>>>>
>>>
>>> LP := ~True(L, LP) means that every instance of LP
>>> in the RHS is the same as the RHS.
>>>
>>> Clocksin & Mellish say this same thing.
>>>
>>> BEGIN:(Clocksin & Mellish 2003:254)
>>> Finally, a note about how Prolog matching sometimes differs from the
>>> unification used in Resolution. Most Prolog systems will allow you to
>>> satisfy goals like:
>>
>> And how Prolog does it is irrelevent,
>>
>
>
> Not at all.
> Prolog sees that LP is defined as ~True(LP) is nonsense
> and rejects it.
And thus proves that it can't handle the logic.
>
>>>
>>> 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)
>>>
>>>> As I said above that is expanding levels of indirecction.
>>>>
>>>>
>>>>>
>>>>> *Prolog sees the same infinite recursion and rejects it*
>>>>> ?- TT = true(TT).
>>>>> TT = true(TT).
>>>>>
>>>>> ?- unify_with_occurs_check(TT, true(TT)).
>>>>> false.
>>>>>
>>>>
>>>> Right, because prolog can't handle any levels of self referencing,
>>>> and thus is not suitable for logic that can do that.
>>>>
>>>
>>> Nothing can handle "some kind of infinite structure."
>>
>> Wrong. There are lots of logics that handle certain "infinte
>> structures". After all, Mathematics is BASED on logic on infinite
>> structures.
>>
>
> No expression that itself has an infinite structure can be
> evaluated in finite time. that is what "infinite structure"
> is defined to mean.
Wrong. One clear counter are infinite structures that turn out to have
an induction property. That can colapse the infinite structure into
something finite. As can limit theory. Or somethings a Meta-Theory can
deduce something to colapse the structure.
We can't always tell to begin with if such a method exists.
Note also, TRUTH can be establish by non-computable / infinte sequences,
and make the statement True.
We can not know that it is True, until we find a path that demonstrates
it, but our ability to KNOW the truth does not affect the actual truth
of the statement. This seems to be something beyond your comprehension.
The "Truth" of a statement doesn't change from "Non-Truth-Bearing" to
True (of False) just because we found a proof (or refuation) of the
statement. The statement was ALWAYS that True or False, but we just
didn't know the truth value of it, so its truth value was "Unknown" NOT
"Not-A-Truth-Bearer".
>
>>>
>>>> You have been told this, but don't seem to understand it. My guess
>>>> is you can't understand any logic more complicated than what Prolog
>>>> handles, so don't realize how much it just doesn't handle.
>>>
>>> No the whole problem seems to be that you simply don't
>>> bother to pay close enough attention the EXACTLY what I say.
>>
>> No, you don't use the words in the way they are properly defined, so
>> of course people can't understand what you mean.
>>
>> We have to guess, and point out the errors that are clearly there.
>>
>>>
>>> When I prove my point you simply ignore that I proved my point
>>> and baselessly assume that I must be wrong. You will probably
>>> completely "forget" my Clocksin & Mellish quote immediately after
>>> you read it, or skip over it and assume that they are wrong.
>>>
>>
>> Nope, you have yet to present an actual Formal proof.
>
> A proof need not be formal.
It does in Formal Logic, or it isn't really a proof.
Can you show an actual REFERENCE to that, that specifically is talking
about a FORMAL system, and not some other branch of ligiv ro
> A proof is any statement where its negation is unsatisfiable.
Nope.
And I think you don't understand what satisfiablity / unsatisfiable mean.
Now, if you can Logical PROVE that its negation is False (and is a
truth-bearer so you can apply negation) then you have a proof.
>
>> You seem to think that a Philosophical Arguement can substitute for a
>> Formal Proof. YOu are just using the wrong tools that don't work in
>> the system.
>>
>> Maybe if you actually tried to pay attention to what people say an not
>> assume that your ideas, built on your assumptions of how things must
>> work, have to be correct.
>>
>
> Try to "prove" that "2" really does stand for a number
> without resorting to any definitions.
>
> The definition itself is the complete proof, no steps required.
So, give the definitions. Your problem is that you don't actually know
the precise defintion of that which you talk about.
Like you confusion of "Computable Functions" with "Programs" which is
just a type error.
Program COMPUTE the mapping of the Computable Function, but they are not
it themselves.
>
>> It seems you don't even have the tools to try to explain what you
>> mean, but just like to throw out snipits quoted from places that you
>> don;t really understand, but seem to say something sort of like what
>> you are trying to say.
>>
>> All you have done is proved your ignorance.
>
> Most of the best experts in the world are not sure that the Liar Paradox
> is not a truth bearer. At least you know this much.
I think you under estimate the experts of the world, but then, your
problem is you are too stupid tdo understand what they are syaing.
>
> When we get to the formalized Liar Paradox this seems too difficult
> for you, yet you are still doing better than most experts in the world.
No, the problem is you think "English" is just the same as "Formalize
English" which it isn't
>
> You are even better at formalizing the Liar Paradox than most experts
> in the field. They try to get away with this crap: LP ↔ ~True(LP).
> You understand that this is the correct way: p defined as ~True(L, p).
> So it is still: Good job Richard !
>
No, you just don't understand what they are saying there, again, because
you are too stupid, and latch on to piece that seem to match the few
pieces you mislearned by rote.
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2024-05-21 00:52 -0500 |
| Subject | Re: True on the basis of meaning --- Good job Richard ! ---Socratic method |
| Message-ID | <v2hcqa$f1og$1@dont-email.me> |
| In reply to | #105328 |
On 5/20/2024 10:37 PM, Richard Damon wrote:
> On 5/20/24 10:56 PM, olcott wrote:
>> On 5/20/2024 9:24 PM, Richard Damon wrote:
>>> On 5/20/24 9:54 PM, olcott wrote:
>>>> On 5/20/2024 7:57 PM, Richard Damon wrote:
>>>>> On 5/20/24 2:59 PM, olcott wrote:
>>>>>> On 5/19/2024 6:30 PM, Richard Damon wrote:
>>>>>>> On 5/19/24 4:12 PM, olcott wrote:
>>>>>>>> On 5/19/2024 12:17 PM, Richard Damon wrote:
>>>>>>>>> On 5/19/24 9:41 AM, olcott wrote:
>>>>>>>>>>
>>>>>>>>>> True(L,x) is always a truth bearer.
>>>>>>>>>> when x is defined as True(L,x) then x is not a truth bearer.
>>>>>>>>>
>>>>>>>>> So, x being DEFINED to be a certain sentence doesn't make x to
>>>>>>>>> have the same meaning as the sentence itself?
>>>>>>>>>
>>>>>>>>> What does it mean to define a name to a given sentence, if not
>>>>>>>>> that such a name referes to exactly that sentence?
>>>>>>>>>
>>>>>>>>
>>>>>>>> p = ~True(L,p) // p is not a truth bearer because its refers to
>>>>>>>> itself
>>>>>>>
>>>>>>> Then ~True(L,p) can't be a truth beared as they are the SAME
>>>>>>> STATEMENT, just using different "names".
>>>>>>
>>>>>>
>>>>>> Truthbearer(L,x) ≡ (True(L,x) ∨ True(L,~x))
>>>>>> p = ~True(L,p) Truthbearer(L,p) is false
>>>>>> q = ~True(L,p) Truthbearer(L,q) is true
>>>>>
>>>>> Irrelvent.
>>>>>
>>>>> If Truthbearer(L, p) is FALSE, and since p is just a NAME for the
>>>>> statement ~True(L, p), that means that True(L. p) is not a truth
>>>>> bearer and True has failed to be the required truth predicate.
>>>>>
>>>>
>>>> That is the same thing as saying that
>>>> True(English, "this sentence is not true") is false
>>>> proves that True(L,x) is not a truthbearer.
>>>
>>> Nope, why do you say that?
>>>
>>> What logic are you even TRYING to use to get there?
>>>
>>> I think you don't understand what defining a label to represent a
>>> statement means.
>>>
>>
>> I did not said the above part exactly precisely to address
>> your objection.
>>
>> p is defined as ~True(L,p)
>> LP is defined as "this sentence is not true" in English.
>> Thus True(L,p) ≡ True(English,LP) and
>> Thus True(L,~p) ≡ True(English,~LP)
>
> So, you admit that you did not answer the problem.
>
> And that you think Strawmen and Red Herring are valid forms of logic.
>
> How does p defined as ~True(L, p) NOT generate the shown contradiction
> when you begin by saying True(L, p) must not be true (and thus false)
> because p has not chain to truthbears?
>
p := ~True(L, p) is false
p := ~True(L, ~p) is false
p is tossed out on its ass as a type mismatch error for every system
of bivalent logic before it gets any chance to be evaluated in any
other way.
If your gas can for you lawnmower is filled with water
do you use it anyway or dump it out?
> You are just showing that you think it is ok for logical system to have
> contradictions in them.
>
You are failing to pay enough attention or forgetting
what I told you even after telling you many times.
Truthbearer(L,x) ≡ (True(L,x) ∨ True(L,~x))
p defined as ~True(L, p)
if (~Truthbearer(L,p))
printf("%s is rejected as not a truth bearer\n", "p");
>>
>>>>
>>>>> If you are defining your "=" symbol to be "is defined as" so the
>>>>> left side is now a name for the right side, you statement above
>>>>> just PROVES that your logic system is inconsistant as the same
>>>>> expression (with just different names) has contradicory values.
>>>>>
>>>>> You are just showing you utter lack of understanding of the
>>>>> fundamentals of Formal Logic.
>>>>>
>>>>
>>>> ϕ(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
>>>
>>> So? Can you show that it is NOT true? or is it just that you don't
>>> want it to be true, so you assume it isn't?
>>>
>>
>> defined as is the way to go.
>
> Which mean?
>
p defined as ~True(L, p)
Is much better than the incorrect conventional way: p ↔ ~True(L, p)
> And what does it have to do with the original statement?
>
>
> Remember, if your goal is to just show that conventonal logic is just
> broken, you are going to need to make a much more convincing arguement
> to scrap it, unless you have a FULLY DEVELOPED alternative that does
> better.
>
Truthbearer(L,x) ≡ (True(L,x) ∨ True(L,~x))
Expressions that are {true on the basis of meaning} are ONLY
(a) A set of finite string semantic meanings that form an accurate
model of the general knowledge of the actual world.
(b) Expressions derived by applying truth preserving operations to (a).
The above algorithm specifies True(L,x) and True(L,~x).
> Just remember, once you throw out the foundations, you need to start
> from a brand new foundation, and unless you have been lying about your
> prognossis, and sand-bagging about your logical abilities, your chance
> of actually proving somethiing like that is just about zero.
>
In other words you totally forgot that you already understood
the algorithm.
>>
>>>>
>>>> No what it shows is that formal logic gets the wrong answer because
>>>> formal logic does not evaluate actual self-reference.
>>>
>>> No, you don't understand what you are talking about.
>>>
>>
>> Formal logic NEVER EVER gets to
>> epistemological antinomies ARE NOT TRUTH BEARERS
>
> Of course it does.
>
> You just don't understand what you are reading.
>
> In fact, Tarski points out the BECAUSE he can show that the existance of
> a Truth Primative forces an epistemological antinomy to have a truth
> value, that there can not be an existing Truth Primative.
>
> YOU just don't understand logic,
>
I understand that the received view is proven to be incorrect on the
basis of its incoherence. The system of (a) and (b) is self-evidently
correct.
>>
>>>>
>>>>
>>>>>
>>>>>>>
>>>>>>> Just like (with context) YOU can be refered to a PO, Peter, Peter
>>>>>>> Olcott or Olcott, and all the reference get to the exact same
>>>>>>> entity, so any "name" for the express
>>>>>>>
>>>>>>>> True(L,p) is false
>>>>>>>> True(L,~p) is false
>>>>>>>>
>>>>>>>
>>>>>>> So since True(L, p) is false, then ~True(L, p) is true.
>>>>>>>
>>>>>>>> ~True(True(L,p)) is true and is referring to the p that refers
>>>>>>>> to itself it is not referring to its own self.
>>>>>>>>
>>>>>>>> *ONE LEVEL OF INDIRECT REFERENCE MAKES ALL THE DIFFERENCE*
>>>>>>>
>>>>>>> Why add the indirection? p is the NAME of the statement, which
>>>>>>> means exactly the same thing as the statement itself.
>>>>>>>
>>>>>>
>>>>>> p = ~True(L,p)
>>>>>> does not mean that same thing as True(L, ~True(L,p))
>>>>>> The above ~True(L, p) has another ~True(L,p) embedded in p.
>>>>>>
>>>>>>> Is the definition of an English word one level LESS of
>>>>>>> indirection than the word itself?
>>>>>>>
>>>>>>
>>>>>> This sentence is not true("This sentence is not true") is true.
>>>>>
>>>>> Right, that is a sentence about another sentence (that is part of
>>>>> itself)
>>>>>
>>>>
>>>> Likewise with ~True(L, ~True(L, p)) where p is defined as ~True(L, p)
>>>>
>>>
>>> So? Yes ~True(L, ~True(L, p)) IS a different sentence than ~True(L,
>>> p) even with p defined a ~True(L, p), BUT they are logically
>>> connected as the first follows as a consequence of the second and the
>>> definition of p.
>>>
>>>>> p defined as ~True(L, p) isn't a sentence refering to ~True(L, p),
>>>>> it is assigning a name to the sentence to allow OTHER sentences to
>>>>> refer to it by name,
>>>>>
>>>>
>>>> Yet when p refers to its own name this creates infinite recursion.
>>>>
>>>
>>> So? What's wrong with that?
>>
>> Sure any programs that get stuck in infinite loops are a feature that
>> everyone likes even when it means that payroll is two weeks late and
>> you missed your mortgage payment.
>
> Which has nothing to do with the Halting Problem.
>
You said there is nothing wrong with loops and I countered
with a loop that could force you to skip paying your mortgage.
>>
>>> Note, it is recursion that doesn't HAVE to be followed. You seem to
>>> be stuck at counting the fingers level math, while trying to talk
>>> about trigonometry.
>>>
>>
>> Any expression "standing for some kind of infinite structure."
>> CANNOT BE EVALUATED THUS CANNOT POSSIBLY BE A TRUTH BEARER
>> THUS <IS> A TYPE MISMATCH ERROR FOR EVERY SYSTEM OF BIVALENT LOGIC
>
> So, I guess you don't beleive in mathematics.
>
Those are not required to be derived from a set of truth
preserving operations that have a cycle in the directed
graph of their evaluation sequence.
> And the value of Pi doesn't exist, or the square root of 2.
>
> You are just incapable of understanding how infinities CAN work.
>
> There is no NEED to expand the reference loop to infinity, so that isn't
> actually a problem.
>
>
>>
>>>>>
>>>>>>
>>>>>>> I don't think you understand what it means to define something.
>>>>>>>
>>>>>>
>>>>>> x := y means x is defined to be another name for y
>>>>>> https://en.wikipedia.org/wiki/List_of_logic_symbols
>>>>>>
>>>>>> LP := ~True(L, LP)
>>>>>> specifies ~True(~True(~True(~True(~True(...)))))
>>>>>
>>>>> Nope.
>>>>>
>>>>
>>>> When LP refers to its own name this creates infinite recursion.
>>>
>>> So? As I said, it doesn't HAVE to be fully expanded, as each level is
>>> doing a logical step of indirection
>>>
>>>>
>>>>> It means that LP is defined to be the sentence ~True(L, LP)
>>>>>
>>>>> replacing the LP in the sentence with a copy of LP IS a level of
>>>>> indirection, so you can get the infinite expansion if you keep or
>>>>> derefencing the reference in the statement.
>>>>>
>>>>>
>>>>>>
>>>>>>> "Definition by example" is worse than "Proof by example", at
>>>>>>> least proof by example can be correct if the assertion is that
>>>>>>> there exists, and not for all.
>>>>>>>
>>>>>>
>>>>>> A simpler isomorphism of the same thing is proof by analogy.
>>>>>>
>>>>>
>>>>> Which isn't a valid proof in a formal system. You seem to think
>>>>> Formal System are a loosy goosy with proofs as Philosophy.
>>>>>
>>>>
>>>> True(English, "this sentence is not true") is false
>>>> Is 100% perfectly isomorphic to its formalized version
>>>>
>>>> LP is defined as ~True(L, LP)
>>>> True(L, LP) is false
>>>
>>> Nope. Because "this sentence" refers to the statement in quotes, not
>>> the logical statement using True.
>>>
>>
>> The English is formalized as LP is defined as ~True(L, LP)
>> before it is analyzed.
>
> Nope, because the English doesn't carry the meaning of being a Truth
> Predicate.
In other words
True(English, "Puppies are fifteen story office buildings")
is not false?
> But, since you don't seem to understand what that means, you
> can't tell the difference, but it proves your own ignorance to make the
> claim.
>
>>
>>>>
>>>> It is merely easier to see that "this sentence is not true"
>>>> cannot be true because that makes it false and
>>>> can't be false because that makes it true.
>>>
>>> And it is a different sentence.
>>>
>>
>> No it is not.
>> The English is formalized as
>> LP is defined as ~True(L, LP) before it is analyzed.
>
> Nope, You can't make that claim.
I am correct and you can't show otherwise.
>>
>>>>
>>>> LP is defined as ~True(L, LP)
>>>> works this same yet yet it is not as intuitive.
>>>
>>> You are right that it causes problems, and the problem it causes is
>>> that it shows that the True Predicate can not exist.
>>>
>>
>> Not at all.
>> It shows that NON truth bearers must be rejected as
>> a type mismatch error for any system of bivalent logic.
>
> Which isn't allowed.
I had a typo : NON truth bearers must be rejected
Truthbearer(L,x) ≡ (True(L,x) ∨ False(L,x))
>
> You seem to have this problem with things defined to work on ALL
> statements expressable in the languge.
>
My system recognizes and reject epistemological antinomies.
> It is DEFINED how the Truth predicate is to work on non-truth bearers,
> and that to return the false value.
>
Truthbearer(L,x) ≡ (True(L,x) ∨ False(L,x))
> It is basically defined similar to Sipser Decider, in that it turns
> "non-answers" into a defined answer, and that requirement is what make
> it not possible, but that requirement is a fundamental part of the problem.
>
Are there a sequence of truth preserving operations that derive
x from
(a) A set of finite string semantic meanings that form an accurate
model of the general knowledge of the actual world.
No means x is not true.
>>
>>>>
>>>> So we see that the above is a correct formalization
>>>> of the English and that gives us the cognitive leverage
>>>> of intuition.
>>>
>>> Nope, can't because the English sentence doesn't attach a "name" to
>>> the whole expression.
>>>
>>>>
>>>>>>> A level of indirection:
>>>>>>>
>>>>>>> p: "This sentence is true", which is exactly the same as "p is
>>>>>>> true" since "this sentence" IS p
>>>>>>>
>>>>>>
>>>>>> p := True(L,p)
>>>>>> specifies True(True(True(True(True(...)))))
>>>>>
>>>>> Nope, it is equivelent to that, but doesn't SPECIFY that.
>>>>>
>>>>
>>>> LP := ~True(L, LP) means that every instance of LP
>>>> in the RHS is the same as the RHS.
>>>>
>>>> Clocksin & Mellish say this same thing.
>>>>
>>>> BEGIN:(Clocksin & Mellish 2003:254)
>>>> Finally, a note about how Prolog matching sometimes differs from the
>>>> unification used in Resolution. Most Prolog systems will allow you to
>>>> satisfy goals like:
>>>
>>> And how Prolog does it is irrelevent,
>>>
>>
>>
>> Not at all.
>> Prolog sees that LP is defined as ~True(LP) is nonsense
>> and rejects it.
>
> And thus proves that it can't handle the logic.
*THE FREAKING INPUT IS FREAKING WRONG*
*THE FREAKING INPUT IS FREAKING WRONG*
*THE FREAKING INPUT IS FREAKING WRONG*
--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
[toc] | [prev] | [next] | [standalone]
| From | Richard Damon <richard@damon-family.org> |
|---|---|
| Date | 2024-05-21 07:50 -0400 |
| Subject | Re: True on the basis of meaning --- Good job Richard ! ---Socratic method |
| Message-ID | <v2i1qk$1kiah$15@i2pn2.org> |
| In reply to | #105338 |
On 5/21/24 1:52 AM, olcott wrote:
> On 5/20/2024 10:37 PM, Richard Damon wrote:
>> On 5/20/24 10:56 PM, olcott wrote:
>>> On 5/20/2024 9:24 PM, Richard Damon wrote:
>>>> On 5/20/24 9:54 PM, olcott wrote:
>>>>> On 5/20/2024 7:57 PM, Richard Damon wrote:
>>>>>> On 5/20/24 2:59 PM, olcott wrote:
>>>>>>> On 5/19/2024 6:30 PM, Richard Damon wrote:
>>>>>>>> On 5/19/24 4:12 PM, olcott wrote:
>>>>>>>>> On 5/19/2024 12:17 PM, Richard Damon wrote:
>>>>>>>>>> On 5/19/24 9:41 AM, olcott wrote:
>>>>>>>>>>>
>>>>>>>>>>> True(L,x) is always a truth bearer.
>>>>>>>>>>> when x is defined as True(L,x) then x is not a truth bearer.
>>>>>>>>>>
>>>>>>>>>> So, x being DEFINED to be a certain sentence doesn't make x to
>>>>>>>>>> have the same meaning as the sentence itself?
>>>>>>>>>>
>>>>>>>>>> What does it mean to define a name to a given sentence, if not
>>>>>>>>>> that such a name referes to exactly that sentence?
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> p = ~True(L,p) // p is not a truth bearer because its refers to
>>>>>>>>> itself
>>>>>>>>
>>>>>>>> Then ~True(L,p) can't be a truth beared as they are the SAME
>>>>>>>> STATEMENT, just using different "names".
>>>>>>>
>>>>>>>
>>>>>>> Truthbearer(L,x) ≡ (True(L,x) ∨ True(L,~x))
>>>>>>> p = ~True(L,p) Truthbearer(L,p) is false
>>>>>>> q = ~True(L,p) Truthbearer(L,q) is true
>>>>>>
>>>>>> Irrelvent.
>>>>>>
>>>>>> If Truthbearer(L, p) is FALSE, and since p is just a NAME for the
>>>>>> statement ~True(L, p), that means that True(L. p) is not a truth
>>>>>> bearer and True has failed to be the required truth predicate.
>>>>>>
>>>>>
>>>>> That is the same thing as saying that
>>>>> True(English, "this sentence is not true") is false
>>>>> proves that True(L,x) is not a truthbearer.
>>>>
>>>> Nope, why do you say that?
>>>>
>>>> What logic are you even TRYING to use to get there?
>>>>
>>>> I think you don't understand what defining a label to represent a
>>>> statement means.
>>>>
>>>
>>> I did not said the above part exactly precisely to address
>>> your objection.
>>>
>>> p is defined as ~True(L,p)
>>> LP is defined as "this sentence is not true" in English.
>>> Thus True(L,p) ≡ True(English,LP) and
>>> Thus True(L,~p) ≡ True(English,~LP)
>>
>> So, you admit that you did not answer the problem.
>>
>> And that you think Strawmen and Red Herring are valid forms of logic.
>>
>> How does p defined as ~True(L, p) NOT generate the shown contradiction
>> when you begin by saying True(L, p) must not be true (and thus false)
>> because p has not chain to truthbears?
>>
>
> p := ~True(L, p) is false
> p := ~True(L, ~p) is false
>
> p is tossed out on its ass as a type mismatch error for every system
> of bivalent logic before it gets any chance to be evaluated in any
> other way.
Not ALLOWED. p is DEFINED to be something, so it is that/.
or, what you are saying is you have tossed out the whole logic system,
which actually would explaim you problem, you have NO logic to work
with, because you threw it out without having a replacement.
>
> If your gas can for you lawnmower is filled with water
> do you use it anyway or dump it out?
I don't have a gas can for my lawnmower.
You are just resorting again to Strawmen and Red Herrings, becaause you
have no real logic to work with, because you never learned any.
>
>> You are just showing that you think it is ok for logical system to
>> have contradictions in them.
>>
>
> You are failing to pay enough attention or forgetting
> what I told you even after telling you many times.
>
> Truthbearer(L,x) ≡ (True(L,x) ∨ True(L,~x))
> p defined as ~True(L, p)
>
> if (~Truthbearer(L,p))
> printf("%s is rejected as not a truth bearer\n", "p");
And you logic system is thus broken as True in now not a Truth Bearer.
PERIOD.
Try to refute that statement or you are just admitting your stupidity.
>
>>>
>>>>>
>>>>>> If you are defining your "=" symbol to be "is defined as" so the
>>>>>> left side is now a name for the right side, you statement above
>>>>>> just PROVES that your logic system is inconsistant as the same
>>>>>> expression (with just different names) has contradicory values.
>>>>>>
>>>>>> You are just showing you utter lack of understanding of the
>>>>>> fundamentals of Formal Logic.
>>>>>>
>>>>>
>>>>> ϕ(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
>>>>
>>>> So? Can you show that it is NOT true? or is it just that you don't
>>>> want it to be true, so you assume it isn't?
>>>>
>>>
>>> defined as is the way to go.
>>
>> Which mean?
>>
>
> p defined as ~True(L, p)
> Is much better than the incorrect conventional way: p ↔ ~True(L, p)
Which is saying a different thing,
They are different statements with different meaning,
>
>> And what does it have to do with the original statement?
>>
>>
>> Remember, if your goal is to just show that conventonal logic is just
>> broken, you are going to need to make a much more convincing arguement
>> to scrap it, unless you have a FULLY DEVELOPED alternative that does
>> better.
>>
>
> Truthbearer(L,x) ≡ (True(L,x) ∨ True(L,~x))
>
> Expressions that are {true on the basis of meaning} are ONLY
> (a) A set of finite string semantic meanings that form an accurate
> model of the general knowledge of the actual world.
>
> (b) Expressions derived by applying truth preserving operations to (a).
> The above algorithm specifies True(L,x) and True(L,~x).
And if you use that, and the assumption that True is a Truth Predicate,
you get a contradiction, so you logic is broken.
PERIOD.
If the x above is defined in L as ~True(L, x), and by your logic, there
is no way to derive its truth from the truthmakers of L to x, and thus
by your definition True(L, x) is false, that means that this conclusion
ESTABLISHED a path to ~True(L, x) as if w is false then ~w is true, so
there must be such a path to ~w, and thus to ~True(L, x), which is what
x is defined to be.
Since now there IS a path of truth preserving operations to x, we have
that True(L, x) must be true, and thus we have a contradiction.
>
>> Just remember, once you throw out the foundations, you need to start
>> from a brand new foundation, and unless you have been lying about your
>> prognossis, and sand-bagging about your logical abilities, your chance
>> of actually proving somethiing like that is just about zero.
>>
>
> In other words you totally forgot that you already understood
> the algorithm.
What algorithm are you talking about?
Your broken definition of True?
The one that proves p to be both true and false
The one that declairs a Truth Primative, that by definition must always
be a truth bearer to be a non-truth-bearer.
No, if you want to try to fix this, you need to do more than your one
paragraph sketch of what you are thinking of.
You need to do a full formal derivation, but the likely problems are that
1) You don't have the skill to do that, and
2) Even if you did, your ideas don't actually solve the problem, because
you just don't understand the nature of logic.
>
>>>
>>>>>
>>>>> No what it shows is that formal logic gets the wrong answer because
>>>>> formal logic does not evaluate actual self-reference.
>>>>
>>>> No, you don't understand what you are talking about.
>>>>
>>>
>>> Formal logic NEVER EVER gets to
>>> epistemological antinomies ARE NOT TRUTH BEARERS
>>
>> Of course it does.
>>
>> You just don't understand what you are reading.
>>
>> In fact, Tarski points out the BECAUSE he can show that the existance
>> of a Truth Primative forces an epistemological antinomy to have a
>> truth value, that there can not be an existing Truth Primative.
>>
>> YOU just don't understand logic,
>>
>
> I understand that the received view is proven to be incorrect on the
> basis of its incoherence. The system of (a) and (b) is self-evidently
> correct.
Nope, you just don't understand logic, because you are just too stupid.
>
>>>
>>>>>
>>>>>
>>>>>>
>>>>>>>>
>>>>>>>> Just like (with context) YOU can be refered to a PO, Peter,
>>>>>>>> Peter Olcott or Olcott, and all the reference get to the exact
>>>>>>>> same entity, so any "name" for the express
>>>>>>>>
>>>>>>>>> True(L,p) is false
>>>>>>>>> True(L,~p) is false
>>>>>>>>>
>>>>>>>>
>>>>>>>> So since True(L, p) is false, then ~True(L, p) is true.
>>>>>>>>
>>>>>>>>> ~True(True(L,p)) is true and is referring to the p that refers
>>>>>>>>> to itself it is not referring to its own self.
>>>>>>>>>
>>>>>>>>> *ONE LEVEL OF INDIRECT REFERENCE MAKES ALL THE DIFFERENCE*
>>>>>>>>
>>>>>>>> Why add the indirection? p is the NAME of the statement, which
>>>>>>>> means exactly the same thing as the statement itself.
>>>>>>>>
>>>>>>>
>>>>>>> p = ~True(L,p)
>>>>>>> does not mean that same thing as True(L, ~True(L,p))
>>>>>>> The above ~True(L, p) has another ~True(L,p) embedded in p.
>>>>>>>
>>>>>>>> Is the definition of an English word one level LESS of
>>>>>>>> indirection than the word itself?
>>>>>>>>
>>>>>>>
>>>>>>> This sentence is not true("This sentence is not true") is true.
>>>>>>
>>>>>> Right, that is a sentence about another sentence (that is part of
>>>>>> itself)
>>>>>>
>>>>>
>>>>> Likewise with ~True(L, ~True(L, p)) where p is defined as ~True(L, p)
>>>>>
>>>>
>>>> So? Yes ~True(L, ~True(L, p)) IS a different sentence than ~True(L,
>>>> p) even with p defined a ~True(L, p), BUT they are logically
>>>> connected as the first follows as a consequence of the second and
>>>> the definition of p.
>>>>
>>>>>> p defined as ~True(L, p) isn't a sentence refering to ~True(L, p),
>>>>>> it is assigning a name to the sentence to allow OTHER sentences to
>>>>>> refer to it by name,
>>>>>>
>>>>>
>>>>> Yet when p refers to its own name this creates infinite recursion.
>>>>>
>>>>
>>>> So? What's wrong with that?
>>>
>>> Sure any programs that get stuck in infinite loops are a feature that
>>> everyone likes even when it means that payroll is two weeks late and
>>> you missed your mortgage payment.
>>
>> Which has nothing to do with the Halting Problem.
>>
>
> You said there is nothing wrong with loops and I countered
> with a loop that could force you to skip paying your mortgage.
That is NOT what I said, but then you are just too stupid to understand.
We were not talking about loops in programs, but recursive definitions,
that turn out to be usable without needing to get into your infinite
expansion loop.
I guess you have just put yourself on the loop in eternity where you
will just keep on trying to redo your statement 1 step farther each time
>
>>>
>>>> Note, it is recursion that doesn't HAVE to be followed. You seem to
>>>> be stuck at counting the fingers level math, while trying to talk
>>>> about trigonometry.
>>>>
>>>
>>> Any expression "standing for some kind of infinite structure."
>>> CANNOT BE EVALUATED THUS CANNOT POSSIBLY BE A TRUTH BEARER
>>> THUS <IS> A TYPE MISMATCH ERROR FOR EVERY SYSTEM OF BIVALENT LOGIC
>>
>> So, I guess you don't beleive in mathematics.
>>
>
> Those are not required to be derived from a set of truth
> preserving operations that have a cycle in the directed
> graph of their evaluation sequence.
But they need to be, and have been actually PROVEN.
Something beyond what you understand though, it seems.
You just don't understand what you are talking about.
>
>
>> And the value of Pi doesn't exist, or the square root of 2.
>>
>> You are just incapable of understanding how infinities CAN work.
>>
>> There is no NEED to expand the reference loop to infinity, so that
>> isn't actually a problem.
>>
>>
>>>
>>>>>>
>>>>>>>
>>>>>>>> I don't think you understand what it means to define something.
>>>>>>>>
>>>>>>>
>>>>>>> x := y means x is defined to be another name for y
>>>>>>> https://en.wikipedia.org/wiki/List_of_logic_symbols
>>>>>>>
>>>>>>> LP := ~True(L, LP)
>>>>>>> specifies ~True(~True(~True(~True(~True(...)))))
>>>>>>
>>>>>> Nope.
>>>>>>
>>>>>
>>>>> When LP refers to its own name this creates infinite recursion.
>>>>
>>>> So? As I said, it doesn't HAVE to be fully expanded, as each level
>>>> is doing a logical step of indirection
>>>>
>>>>>
>>>>>> It means that LP is defined to be the sentence ~True(L, LP)
>>>>>>
>>>>>> replacing the LP in the sentence with a copy of LP IS a level of
>>>>>> indirection, so you can get the infinite expansion if you keep or
>>>>>> derefencing the reference in the statement.
>>>>>>
>>>>>>
>>>>>>>
>>>>>>>> "Definition by example" is worse than "Proof by example", at
>>>>>>>> least proof by example can be correct if the assertion is that
>>>>>>>> there exists, and not for all.
>>>>>>>>
>>>>>>>
>>>>>>> A simpler isomorphism of the same thing is proof by analogy.
>>>>>>>
>>>>>>
>>>>>> Which isn't a valid proof in a formal system. You seem to think
>>>>>> Formal System are a loosy goosy with proofs as Philosophy.
>>>>>>
>>>>>
>>>>> True(English, "this sentence is not true") is false
>>>>> Is 100% perfectly isomorphic to its formalized version
>>>>>
>>>>> LP is defined as ~True(L, LP)
>>>>> True(L, LP) is false
>>>>
>>>> Nope. Because "this sentence" refers to the statement in quotes, not
>>>> the logical statement using True.
>>>>
>>>
>>> The English is formalized as LP is defined as ~True(L, LP)
>>> before it is analyzed.
>>
>> Nope, because the English doesn't carry the meaning of being a Truth
>> Predicate.
>
> In other words
> True(English, "Puppies are fifteen story office buildings")
> is not false?
STRAWMAN.
Not what I said, and the fact that you said it shows your ignorance of
logic.
>
>> But, since you don't seem to understand what that means, you can't
>> tell the difference, but it proves your own ignorance to make the claim.
>>
>>>
>>>>>
>>>>> It is merely easier to see that "this sentence is not true"
>>>>> cannot be true because that makes it false and
>>>>> can't be false because that makes it true.
>>>>
>>>> And it is a different sentence.
>>>>
>>>
>>> No it is not.
>>> The English is formalized as
>>> LP is defined as ~True(L, LP) before it is analyzed.
>>
>> Nope, You can't make that claim.
>
> I am correct and you can't show otherwise.
Of course I can, there is NO REQUIREMENT when looking at an English
sentence to "formalize it", In fact, the system "English" is different
than the system "Formalize English".
>
>>>
>>>>>
>>>>> LP is defined as ~True(L, LP)
>>>>> works this same yet yet it is not as intuitive.
>>>>
>>>> You are right that it causes problems, and the problem it causes is
>>>> that it shows that the True Predicate can not exist.
>>>>
>>>
>>> Not at all.
>>> It shows that NON truth bearers must be rejected as
>>> a type mismatch error for any system of bivalent logic.
>>
>> Which isn't allowed.
>
> I had a typo : NON truth bearers must be rejected
> Truthbearer(L,x) ≡ (True(L,x) ∨ False(L,x))
True(L, x) isn't allowed to "reject" a statement, only answer that the
statement is "true" or that it isn't true, meaning either false, or a
non-truth-bearer.
So, your answer is just like someone asking of 1 + 1 is 2 and you answer
"Apple Pie"
>
>>
>> You seem to have this problem with things defined to work on ALL
>> statements expressable in the languge.
>>
>
> My system recognizes and reject epistemological antinomies.
No, you haven't defined your system, you have defined a few rules that
you are adding to the existing system (since that is all that we have)
that make the system inconsistant. Note, you can ADD to an existing
system by adding a axiom to it, you can not remove something from the
system without rebuilding it from scratch.
If you want to have a different basis of logic, you need to do the work
to actually build it, which seems to be totally out of your ability
>
>> It is DEFINED how the Truth predicate is to work on non-truth bearers,
>> and that to return the false value.
>>
>
> Truthbearer(L,x) ≡ (True(L,x) ∨ False(L,x))
STRAWMAN.
Doesnt' fix the problem.
>
>> It is basically defined similar to Sipser Decider, in that it turns
>> "non-answers" into a defined answer, and that requirement is what make
>> it not possible, but that requirement is a fundamental part of the
>> problem.
>>
>
> Are there a sequence of truth preserving operations that derive
> x from
>
> (a) A set of finite string semantic meanings that form an accurate
> model of the general knowledge of the actual world.
> No means x is not true.
But if x is ~True(L, x) then if True(L, x) is false, then there IS a
sequence of truth perserving operations that derive x from the truth
maker established in True.
Thus, your system is inconsistant.
That you can't understand that just shows your stupidity.
>
>>>
>>>>>
>>>>> So we see that the above is a correct formalization
>>>>> of the English and that gives us the cognitive leverage
>>>>> of intuition.
>>>>
>>>> Nope, can't because the English sentence doesn't attach a "name" to
>>>> the whole expression.
>>>>
>>>>>
>>>>>>>> A level of indirection:
>>>>>>>>
>>>>>>>> p: "This sentence is true", which is exactly the same as "p is
>>>>>>>> true" since "this sentence" IS p
>>>>>>>>
>>>>>>>
>>>>>>> p := True(L,p)
>>>>>>> specifies True(True(True(True(True(...)))))
>>>>>>
>>>>>> Nope, it is equivelent to that, but doesn't SPECIFY that.
>>>>>>
>>>>>
>>>>> LP := ~True(L, LP) means that every instance of LP
>>>>> in the RHS is the same as the RHS.
>>>>>
>>>>> Clocksin & Mellish say this same thing.
>>>>>
>>>>> BEGIN:(Clocksin & Mellish 2003:254)
>>>>> Finally, a note about how Prolog matching sometimes differs from the
>>>>> unification used in Resolution. Most Prolog systems will allow you to
>>>>> satisfy goals like:
>>>>
>>>> And how Prolog does it is irrelevent,
>>>>
>>>
>>>
>>> Not at all.
>>> Prolog sees that LP is defined as ~True(LP) is nonsense
>>> and rejects it.
>>
>> And thus proves that it can't handle the logic.
>
> *THE FREAKING INPUT IS FREAKING WRONG*
> *THE FREAKING INPUT IS FREAKING WRONG*
> *THE FREAKING INPUT IS FREAKING WRONG*
>
>
There is no "wrong" input to True if it is syntactically correct.
You just don't understand the requirements, because you don't understand
logic, or apparently ANYTHING you have done in the last 20 years.
(Well, maybe you understand kiddie porn and what it does to you)
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2024-05-21 10:00 -0500 |
| Subject | Re: True on the basis of meaning --- Good job Richard ! ---Socratic method |
| Message-ID | <v2icua$l65b$1@dont-email.me> |
| In reply to | #105347 |
On 5/21/2024 6:50 AM, Richard Damon wrote: > On 5/21/24 1:52 AM, olcott wrote: >> On 5/20/2024 10:37 PM, Richard Damon wrote: >>> On 5/20/24 10:56 PM, olcott wrote: >>>> On 5/20/2024 9:24 PM, Richard Damon wrote: >>>>> On 5/20/24 9:54 PM, olcott wrote: >>>>>> On 5/20/2024 7:57 PM, Richard Damon wrote: >>>>>>> On 5/20/24 2:59 PM, olcott wrote: >>>>>>>> On 5/19/2024 6:30 PM, Richard Damon wrote: >>>>>>>>> On 5/19/24 4:12 PM, olcott wrote: >>>>>>>>>> On 5/19/2024 12:17 PM, Richard Damon wrote: >>>>>>>>>>> On 5/19/24 9:41 AM, olcott wrote: >>>>>>>>>>>> >>>>>>>>>>>> True(L,x) is always a truth bearer. >>>>>>>>>>>> when x is defined as True(L,x) then x is not a truth bearer. >>>>>>>>>>> >>>>>>>>>>> So, x being DEFINED to be a certain sentence doesn't make x >>>>>>>>>>> to have the same meaning as the sentence itself? >>>>>>>>>>> >>>>>>>>>>> What does it mean to define a name to a given sentence, if >>>>>>>>>>> not that such a name referes to exactly that sentence? >>>>>>>>>>> >>>>>>>>>> >>>>>>>>>> p = ~True(L,p) // p is not a truth bearer because its refers >>>>>>>>>> to itself >>>>>>>>> >>>>>>>>> Then ~True(L,p) can't be a truth beared as they are the SAME >>>>>>>>> STATEMENT, just using different "names". >>>>>>>> >>>>>>>> >>>>>>>> Truthbearer(L,x) ≡ (True(L,x) ∨ True(L,~x)) >>>>>>>> p = ~True(L,p) Truthbearer(L,p) is false >>>>>>>> q = ~True(L,p) Truthbearer(L,q) is true >>>>>>> >>>>>>> Irrelvent. >>>>>>> >>>>>>> If Truthbearer(L, p) is FALSE, and since p is just a NAME for the >>>>>>> statement ~True(L, p), that means that True(L. p) is not a truth >>>>>>> bearer and True has failed to be the required truth predicate. >>>>>>> >>>>>> >>>>>> That is the same thing as saying that >>>>>> True(English, "this sentence is not true") is false >>>>>> proves that True(L,x) is not a truthbearer. >>>>> >>>>> Nope, why do you say that? >>>>> >>>>> What logic are you even TRYING to use to get there? >>>>> >>>>> I think you don't understand what defining a label to represent a >>>>> statement means. >>>>> >>>> >>>> I did not said the above part exactly precisely to address >>>> your objection. >>>> >>>> p is defined as ~True(L,p) >>>> LP is defined as "this sentence is not true" in English. >>>> Thus True(L,p) ≡ True(English,LP) and >>>> Thus True(L,~p) ≡ True(English,~LP) >>> >>> So, you admit that you did not answer the problem. >>> >>> And that you think Strawmen and Red Herring are valid forms of logic. >>> >>> How does p defined as ~True(L, p) NOT generate the shown >>> contradiction when you begin by saying True(L, p) must not be true >>> (and thus false) because p has not chain to truthbears? >>> >> >> p := ~True(L, p) is false >> p := ~True(L, ~p) is false >> >> p is tossed out on its ass as a type mismatch error for every system >> of bivalent logic before it gets any chance to be evaluated in any >> other way. > > Not ALLOWED. p is DEFINED to be something, so it is that/. > 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. On 5/13/2024 7:29 PM, Richard Damon wrote: > Remember, p defined as ~True(L, p) is BY DEFINITION a > truth bearer, as True must return a Truth Value for > all inputs, and ~ a truth valus is always the other > truth value. p defined as ~True(L, p) is rejected as a syntax error. https://www.swi-prolog.org/pldoc/man?predicate=unify_with_occurs_check/2 or rejected as equal(X, X). ?- equal(foo(Y), Y). ... So Y ends up standing for some kind of infinite structure. (Clocksin & Mellish 2003:254) By The SWI-Prolog implementation of unify_with_occurs_check/2 is cycle-safe and only guards against creating cycles, https://www.swi-prolog.org/pldoc/man?predicate=unify_with_occurs_check/2 -- Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius hits a target no one else can see." Arthur Schopenhauer
[toc] | [prev] | [next] | [standalone]
| From | immibis <news@immibis.com> |
|---|---|
| Date | 2024-05-21 18:08 +0200 |
| Subject | Re: True on the basis of meaning --- Good job Richard ! ---Socratic method |
| Message-ID | <v2igtb$lqek$1@dont-email.me> |
| In reply to | #105357 |
On 21/05/24 17:00, olcott wrote: > 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. What if it is not defined as ~True(L, p) but we could prove that A ⇒ (p ⇔ ~True(L, p)) then it would prove that A is false. > On 5/13/2024 7:29 PM, Richard Damon wrote: > > Remember, p defined as ~True(L, p) is BY DEFINITION a > > truth bearer, as True must return a Truth Value for > > all inputs, and ~ a truth valus is always the other > > truth value. > > p defined as ~True(L, p) is rejected as a syntax error. "this sentence is false" defined as ¬True(English, "this sentence is false") is rejected as a syntax error? so ¬True(English, "this sentence is false") is a syntax error? I thought you said ¬True(English, "this sentence is false") is false.
[toc] | [prev] | [next] | [standalone]
| From | Richard Damon <richard@damon-family.org> |
|---|---|
| Date | 2024-05-21 21:46 -0400 |
| Subject | Re: True on the basis of meaning --- Good job Richard ! ---Socratic method |
| Message-ID | <v2jiqa$1no6v$6@i2pn2.org> |
| In reply to | #105357 |
On 5/21/24 11:00 AM, olcott wrote: > On 5/21/2024 6:50 AM, Richard Damon wrote: >> On 5/21/24 1:52 AM, olcott wrote: >>> On 5/20/2024 10:37 PM, Richard Damon wrote: >>>> On 5/20/24 10:56 PM, olcott wrote: >>>>> On 5/20/2024 9:24 PM, Richard Damon wrote: >>>>>> On 5/20/24 9:54 PM, olcott wrote: >>>>>>> On 5/20/2024 7:57 PM, Richard Damon wrote: >>>>>>>> On 5/20/24 2:59 PM, olcott wrote: >>>>>>>>> On 5/19/2024 6:30 PM, Richard Damon wrote: >>>>>>>>>> On 5/19/24 4:12 PM, olcott wrote: >>>>>>>>>>> On 5/19/2024 12:17 PM, Richard Damon wrote: >>>>>>>>>>>> On 5/19/24 9:41 AM, olcott wrote: >>>>>>>>>>>>> >>>>>>>>>>>>> True(L,x) is always a truth bearer. >>>>>>>>>>>>> when x is defined as True(L,x) then x is not a truth bearer. >>>>>>>>>>>> >>>>>>>>>>>> So, x being DEFINED to be a certain sentence doesn't make x >>>>>>>>>>>> to have the same meaning as the sentence itself? >>>>>>>>>>>> >>>>>>>>>>>> What does it mean to define a name to a given sentence, if >>>>>>>>>>>> not that such a name referes to exactly that sentence? >>>>>>>>>>>> >>>>>>>>>>> >>>>>>>>>>> p = ~True(L,p) // p is not a truth bearer because its refers >>>>>>>>>>> to itself >>>>>>>>>> >>>>>>>>>> Then ~True(L,p) can't be a truth beared as they are the SAME >>>>>>>>>> STATEMENT, just using different "names". >>>>>>>>> >>>>>>>>> >>>>>>>>> Truthbearer(L,x) ≡ (True(L,x) ∨ True(L,~x)) >>>>>>>>> p = ~True(L,p) Truthbearer(L,p) is false >>>>>>>>> q = ~True(L,p) Truthbearer(L,q) is true >>>>>>>> >>>>>>>> Irrelvent. >>>>>>>> >>>>>>>> If Truthbearer(L, p) is FALSE, and since p is just a NAME for >>>>>>>> the statement ~True(L, p), that means that True(L. p) is not a >>>>>>>> truth bearer and True has failed to be the required truth >>>>>>>> predicate. >>>>>>>> >>>>>>> >>>>>>> That is the same thing as saying that >>>>>>> True(English, "this sentence is not true") is false >>>>>>> proves that True(L,x) is not a truthbearer. >>>>>> >>>>>> Nope, why do you say that? >>>>>> >>>>>> What logic are you even TRYING to use to get there? >>>>>> >>>>>> I think you don't understand what defining a label to represent a >>>>>> statement means. >>>>>> >>>>> >>>>> I did not said the above part exactly precisely to address >>>>> your objection. >>>>> >>>>> p is defined as ~True(L,p) >>>>> LP is defined as "this sentence is not true" in English. >>>>> Thus True(L,p) ≡ True(English,LP) and >>>>> Thus True(L,~p) ≡ True(English,~LP) >>>> >>>> So, you admit that you did not answer the problem. >>>> >>>> And that you think Strawmen and Red Herring are valid forms of logic. >>>> >>>> How does p defined as ~True(L, p) NOT generate the shown >>>> contradiction when you begin by saying True(L, p) must not be true >>>> (and thus false) because p has not chain to truthbears? >>>> >>> >>> p := ~True(L, p) is false >>> p := ~True(L, ~p) is false >>> >>> p is tossed out on its ass as a type mismatch error for every system >>> of bivalent logic before it gets any chance to be evaluated in any >>> other way. >> >> Not ALLOWED. p is DEFINED to be something, so it is that/. >> > > 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. > > On 5/13/2024 7:29 PM, Richard Damon wrote: > > Remember, p defined as ~True(L, p) is BY DEFINITION a > > truth bearer, as True must return a Truth Value for > > all inputs, and ~ a truth valus is always the other > > truth value. > > p defined as ~True(L, p) is rejected as a syntax error. NOT ALLOWED. So, your are just admitting that your logic system doesn't meet the requirements of Tarski, and thus your claims are just blatant lies. > > https://www.swi-prolog.org/pldoc/man?predicate=unify_with_occurs_check/2 > or rejected as > > equal(X, X). > ?- equal(foo(Y), Y). ... > So Y ends up standing for some kind of infinite structure. > (Clocksin & Mellish 2003:254) > > By > > The SWI-Prolog implementation of unify_with_occurs_check/2 is cycle-safe > and only guards against creating cycles, > https://www.swi-prolog.org/pldoc/man?predicate=unify_with_occurs_check/2 > And PROLOG is not the definition of what is allowed, so you just prove that you are too stupid to understand logic.
[toc] | [prev] | [next] | [standalone]
| From | immibis <news@immibis.com> |
|---|---|
| Date | 2024-05-20 13:29 +0200 |
| Subject | Re: True on the basis of meaning --- Good job Richard ! ---Socratic method |
| Message-ID | <v2fc73$3v3p1$1@dont-email.me> |
| In reply to | #105256 |
On 19/05/24 22:12, olcott wrote: > On 5/19/2024 12:17 PM, Richard Damon wrote: >> On 5/19/24 9:41 AM, olcott wrote: >>> >>> True(L,x) is always a truth bearer. >>> when x is defined as True(L,x) then x is not a truth bearer. >> >> So, x being DEFINED to be a certain sentence doesn't make x to have >> the same meaning as the sentence itself? >> >> What does it mean to define a name to a given sentence, if not that >> such a name referes to exactly that sentence? >> > > p = ~True(L,p) // p is not a truth bearer because its refers to itself > True(L,p) is false > True(L,~p) is false > > ~True(True(L,p)) is true and is referring to the p that refers > to itself it is not referring to its own self. > > *ONE LEVEL OF INDIRECT REFERENCE MAKES ALL THE DIFFERENCE* > >>> >>> ~True(L,x) is always a truth bearer. >>> when x is defined as ~True(L,x) then x is not a truth bearer. >> >> Again, what does "Defined as" mean to you? >> > > x := y means x is defined to be another name for y > https://en.wikipedia.org/wiki/List_of_logic_symbols > > LP := ~True(L,LP) > means ~True(~True(~True(~True(~True(...))))) > > It is the common convention to encode self-reference incorrectly. > LP ↔ ~True(L, LP) This is not self-reference.
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2024-05-20 12:48 -0500 |
| Subject | Re: True on the basis of meaning --- Good job Richard ! ---Socratic method |
| Message-ID | <v2g2dp$3ugq$1@dont-email.me> |
| In reply to | #105234 |
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(...)))) TT := True(L, TT) expands to True(True(True(True(...)))) > 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* ?- LP = not(true_(LP)). LP = not(true(LP)). ?- unify_with_occurs_check(LP, not(true(LP))). false. ?- TT = true(TT). TT = true(TT). ?- unify_with_occurs_check(TT, true(TT)). false. -- Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius hits a target no one else can see." Arthur Schopenhauer
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2024-05-22 14:52 -0500 |
| Subject | Re: True on the basis of meaning --- Good job Richard ! ---Socratic method (agreement) |
| Message-ID | <v2lies$1b4kp$1@dont-email.me> |
| In reply to | #105294 |
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 > 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. LP := "This sentence is not true" True(English, LP) is false because LP is not a truth bearer ~True(English, LP) is true because LP is not a truth bearer "This sentence is not true". is not true. This sentence is not true: "This sentence is not true". is true >> https://en.wikipedia.org/wiki/List_of_logic_symbols >> Thus p := ~True(L, p) >> >>>> *That is great. That means that you agree with me using different >>>> words* >>> >>> Saying that you have a syntax error does not mean agreement. >> >> Saying this it is any kind of error is sufficient agreement. >> Clocksin & Mellish also agree that it is an error: > > I don't agree with your errors. > I am talking about the syntax error that you pointed out and the *So Y ends up standing for some kind of infinite structure* that Clocksin & Mellish pointed out, neither of these are my error. -- Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius hits a target no one else can see." Arthur Schopenhauer
[toc] | [prev] | [next] | [standalone]
| From | Richard Damon <richard@damon-family.org> |
|---|---|
| Date | 2024-05-22 19:01 -0400 |
| Subject | Re: True on the basis of meaning --- Good job Richard ! ---Socratic method (agreement) |
| Message-ID | <v2ltgl$1nrfv$2@i2pn2.org> |
| In reply to | #105404 |
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. > > LP := "This sentence is not true" > True(English, LP) is false because LP is not a truth bearer > ~True(English, LP) is true because LP is not a truth bearer > > "This sentence is not true". is not true. > This sentence is not true: "This sentence is not true". is true > > >>> https://en.wikipedia.org/wiki/List_of_logic_symbols >>> Thus p := ~True(L, p) >>> >>>>> *That is great. That means that you agree with me using different >>>>> words* >>>> >>>> Saying that you have a syntax error does not mean agreement. >>> >>> Saying this it is any kind of error is sufficient agreement. >>> Clocksin & Mellish also agree that it is an error: >> >> I don't agree with your errors. >> > > I am talking about the syntax error that you pointed out and > the *So Y ends up standing for some kind of infinite structure* > that Clocksin & Mellish pointed out, neither of these are > my error. >
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2024-05-22 18:55 -0500 |
| Subject | Re: True on the basis of meaning --- Good job Richard ! ---Socratic method (agreement) |
| Message-ID | <v2m0m5$1dcof$2@dont-email.me> |
| In reply to | #105406 |
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(...)))) > > No, it doesn't. It is a syntax error to have the same symbol on > both sides ":=" so the expansion is not justified. >> >> LP := "This sentence is not true" >> True(English, LP) is false because LP is not a truth bearer >> ~True(English, LP) is true because LP is not a truth bearer >> >> "This sentence is not true". is not true. >> This sentence is not true: "This sentence is not true". is true >> >> >>>> https://en.wikipedia.org/wiki/List_of_logic_symbols >>>> Thus p := ~True(L, p) >>>> >>>>>> *That is great. That means that you agree with me using different >>>>>> words* >>>>> >>>>> Saying that you have a syntax error does not mean agreement. >>>> >>>> Saying this it is any kind of error is sufficient agreement. >>>> Clocksin & Mellish also agree that it is an error: >>> >>> I don't agree with your errors. >>> >> >> I am talking about the syntax error that you pointed out and >> the *So Y ends up standing for some kind of infinite structure* >> that Clocksin & Mellish pointed out, neither of these are >> my error. >> > -- Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius hits a target no one else can see." Arthur Schopenhauer
[toc] | [prev] | [next] | [standalone]
| From | Richard Damon <richard@damon-family.org> |
|---|---|
| Date | 2024-05-22 21:03 -0400 |
| Subject | Re: True on the basis of meaning --- Good job Richard ! ---Socratic method (agreement) |
| Message-ID | <v2m4lg$1qo0t$1@i2pn2.org> |
| In reply to | #105410 |
On 5/22/24 7:55 PM, olcott wrote: > On 5/22/2024 6:01 PM, Richard Damon wrote: >> On 5/22/24 3:52 PM, olcott wrote: >>> On 5/22/2024 11:58 AM, Mikko wrote: >>>> On 2024-05-22 15:55:39 +0000, olcott said: >>>> >>>>> On 5/22/2024 2:57 AM, Mikko wrote: >>>>>> On 2024-05-21 14:36:29 +0000, olcott said: >>>>>> >>>>>>> On 5/21/2024 3:05 AM, Mikko wrote: >>>>>>>> On 2024-05-20 17:48:40 +0000, olcott said: >>>>>>>> >>>>>>>>> On 5/20/2024 2:55 AM, Mikko wrote: >>>>>>>>>> On 2024-05-19 14:15:51 +0000, olcott said: >>>>>>>>>> >>>>>>>>>>> On 5/19/2024 9:03 AM, Mikko wrote: >>>>>>>>>>>> On 2024-05-19 13:41:56 +0000, olcott said: >>>>>>>>>>>> >>>>>>>>>>>>> On 5/19/2024 6:55 AM, Richard Damon wrote: >>>>>>>>>>>>>> On 5/18/24 11:47 PM, olcott wrote: >>>>>>>>>>>>>>> On 5/18/2024 6:04 PM, Richard Damon wrote: >>>>>>>>>>>>>>>> On 5/18/24 6:47 PM, olcott wrote: >>>>>>>>>>>>>>>>> On 5/18/2024 5:22 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>> On 5/18/24 4:00 PM, olcott wrote: >>>>>>>>>>>>>>>>>>> On 5/18/2024 2:57 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>> On 5/18/24 3:46 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>> On 5/18/2024 12:38 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>> On 5/18/24 1:26 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>> On 5/18/2024 11:56 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>> On 5/18/24 12:48 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>> On 5/18/2024 9:32 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> On 5/18/24 10:15 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/18/2024 7:43 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>> No, your system contradicts itself. >>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>> You have never shown this. >>>>>>>>>>>>>>>>>>>>>>>>>>> The most you have shown is a lack of >>>>>>>>>>>>>>>>>>>>>>>>>>> understanding of the >>>>>>>>>>>>>>>>>>>>>>>>>>> Truth Teller Paradox. >>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>> No, I have, but you don't understand the >>>>>>>>>>>>>>>>>>>>>>>>>> proof, it seems because you don't know what a >>>>>>>>>>>>>>>>>>>>>>>>>> "Truth Predicate" has been defined to be. >>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>> My True(L,x) predicate is defined to return >>>>>>>>>>>>>>>>>>>>>>>>> true or false for every >>>>>>>>>>>>>>>>>>>>>>>>> finite string x on the basis of the existence >>>>>>>>>>>>>>>>>>>>>>>>> of a sequence of truth >>>>>>>>>>>>>>>>>>>>>>>>> preserving operations that derive x from >>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>> And thus, When True(L, p) established a sequence >>>>>>>>>>>>>>>>>>>>>>>> of truth preserving operations eminationg from >>>>>>>>>>>>>>>>>>>>>>>> ~True(L, p) by returning false, it contradicts >>>>>>>>>>>>>>>>>>>>>>>> itself. The problem is that True, in making an >>>>>>>>>>>>>>>>>>>>>>>> answer of false, has asserted that such a >>>>>>>>>>>>>>>>>>>>>>>> sequence exists. >>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>> On 5/13/2024 9:31 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>> > On 5/13/24 10:03 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>> >> On 5/13/2024 7:29 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>> >>> >>>>>>>>>>>>>>>>>>>>>>> >>> Remember, p defined as ~True(L, p) ... >>>>>>>>>>>>>>>>>>>>>>> >> >>>>>>>>>>>>>>>>>>>>>>> >> Can a sequence of true preserving operations >>>>>>>>>>>>>>>>>>>>>>> applied >>>>>>>>>>>>>>>>>>>>>>> >> to expressions that are stipulated to be true >>>>>>>>>>>>>>>>>>>>>>> derive p? >>>>>>>>>>>>>>>>>>>>>>> > No, so True(L, p) is false >>>>>>>>>>>>>>>>>>>>>>> >> >>>>>>>>>>>>>>>>>>>>>>> >> Can a sequence of true preserving operations >>>>>>>>>>>>>>>>>>>>>>> applied >>>>>>>>>>>>>>>>>>>>>>> >> to expressions that are stipulated to be true >>>>>>>>>>>>>>>>>>>>>>> derive ~p? >>>>>>>>>>>>>>>>>>>>>>> > >>>>>>>>>>>>>>>>>>>>>>> > No, so False(L, p) is false, >>>>>>>>>>>>>>>>>>>>>>> > >>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>> *To help you concentrate I repeated this* >>>>>>>>>>>>>>>>>>>>>>> The Liar Paradox and your formalized Liar Paradox >>>>>>>>>>>>>>>>>>>>>>> both >>>>>>>>>>>>>>>>>>>>>>> contradict themselves that is why they must be >>>>>>>>>>>>>>>>>>>>>>> screened >>>>>>>>>>>>>>>>>>>>>>> out as type mismatch error non-truth-bearers >>>>>>>>>>>>>>>>>>>>>>> *BEFORE THAT OCCURS* >>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>> And the Truth Predicate isn't allowed to "filter" >>>>>>>>>>>>>>>>>>>>>> out expressions. >>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>> YOU ALREADY KNOW THAT IT DOESN'T >>>>>>>>>>>>>>>>>>>>> WE HAVE BEEN OVER THIS AGAIN AND AGAIN >>>>>>>>>>>>>>>>>>>>> THE FORMAL SYSTEM USES THE TRUE AND FALSE PREDICATE >>>>>>>>>>>>>>>>>>>>> TO FILTER OUT TYPE MISMATCH ERROR >>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>> The first thing that the formal system does with any >>>>>>>>>>>>>>>>>>>>> arbitrary finite string input is see if it is a >>>>>>>>>>>>>>>>>>>>> Truth-bearer: >>>>>>>>>>>>>>>>>>>>> Truthbearer(L,x) ≡ (True(L,x) ∨ True(L,~x)) >>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>> No, we can ask True(L, x) for any expression x and >>>>>>>>>>>>>>>>>>>> get an answer. >>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>> The system is designed so you can ask this, yet >>>>>>>>>>>>>>>>>>> non-truth-bearers >>>>>>>>>>>>>>>>>>> are rejected before True(L, x) is allowed to be called. >>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>> Not allowed. >>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>> My True(L,x) predicate is defined to return true or >>>>>>>>>>>>>>>>> false for every >>>>>>>>>>>>>>>>> finite string x on the basis of the existence of a >>>>>>>>>>>>>>>>> sequence of truth >>>>>>>>>>>>>>>>> preserving operations that derive x from >>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>> A set of finite string semantic meanings that form an >>>>>>>>>>>>>>>>> accurate >>>>>>>>>>>>>>>>> verbal model of the general knowledge of the actual >>>>>>>>>>>>>>>>> world that >>>>>>>>>>>>>>>>> form a finite set of finite strings that are stipulated >>>>>>>>>>>>>>>>> to have >>>>>>>>>>>>>>>>> the semantic value of Boolean true. >>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>> *This is computable* Truthbearer(L,x) ≡ (True(L,x) ∨ >>>>>>>>>>>>>>>>> True(L,~x)) >>>>>>>>>>>>>>>>> *This is computable* Truthbearer(L,x) ≡ (True(L,x) ∨ >>>>>>>>>>>>>>>>> True(L,~x)) >>>>>>>>>>>>>>>>> *This is computable* Truthbearer(L,x) ≡ (True(L,x) ∨ >>>>>>>>>>>>>>>>> True(L,~x)) >>>>>>>>>>>>>>>>> *This is computable* Truthbearer(L,x) ≡ (True(L,x) ∨ >>>>>>>>>>>>>>>>> True(L,~x)) >>>>>>>>>>>>>>>>> *This is computable* Truthbearer(L,x) ≡ (True(L,x) ∨ >>>>>>>>>>>>>>>>> True(L,~x)) >>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>> So, for a statement x to be false, it says that there >>>>>>>>>>>>>>>> must be a sequence of truth perserving operations that >>>>>>>>>>>>>>>> derive ~x from, right? >>>>>>>>>>>>>>>> >>>>>>>>>>>>>>> Yes we must build from mutual agreement, good. >>>>>>>>>>>>>>> >>>>>>>>>>>>>>>> So do you still say that for p defined in L as ~True(L, >>>>>>>>>>>>>>>> p) that your definition will say that True(L, p) will >>>>>>>>>>>>>>>> return false? >>>>>>>>>>>>>>>> >>>>>>>>>>>>>>> >>>>>>>>>>>>>>> It is the perfectly isomorphic to this: >>>>>>>>>>>>>>> True(English, "This sentence is not true") >>>>>>>>>>>>>>> >>>>>>>>>>>>>> >>>>>>>>>>>>>> >>>>>>>>>>>>>> Nope, Because "This sentece is not true" can be a >>>>>>>>>>>>>> non-truth-bearer, but by its definition, True(L, x) can not. >>>>>>>>>>>>>> >>>>>>>>>>>>> >>>>>>>>>>>>> True(L,x) is always a truth bearer. >>>>>>>>>>>>> when x is defined as True(L,x) then x is not a truth bearer. >>>>>>>>>>>> >>>>>>>>>>>> When x is defined as True(L,x) then x is what True(L,x) is, >>>>>>>>>>>> in this case a truth bearer. >>>>>>>>>> >>>>>>>>>>> This is known as the Truth Teller Paradox >>>>>>>>>> >>>>>>>>>> Doesn't matter. But ir you say that "x is not a truth bearer" >>>>>>>>>> then, >>>>>>>>>> by a truth preserving transformation, you imply that True(L,x) is >>>>>>>>> >>>>>>>>> True(English, "a cat is an animal) is true >>>>>>>>> LP := ~True(L, LP) expands to ~True(~True(~True(~True(...)))) >>>>>>>> >>>>>>>> No, it doesn't. It is a syntax error to have the same symbol on >>>>>>>> both sides ":=" so the expansion is not justified. >>>>>>> >>>>>>> ϕ(x) there is a sentence ψ such that S ⊢ ψ ↔ ϕ⟨ψ⟩. >>>>>>> *The sentence ψ is of course not self-referential in a strict >>>>>>> sense*, >>>>>>> but mathematically it behaves like one. >>>>>>> https://plato.stanford.edu/entries/self-reference/#ConSemPar >>>>>> >>>>>> Your quote omitted important details. One is that the claim is not >>>>>> true about every theory but is about first order arithmetic and its >>>>>> extension. Another one is that ϕ(x) is that the claim is about >>>>>> every formula ϕ(x). >>>>>> >>>>> >>>>> *The whole article is about self-reference* >>>>> The ONLY detail that I am referring to is that it is conventional >>>>> to formalize self-reference incorrectly. >>>>> >>>>> *Richard and both fixed that* >>>>> >>>>> On 5/13/2024 9:31 PM, Richard Damon wrote: >>>>> > On 5/13/24 10:03 PM, olcott wrote: >>>>> >> On 5/13/2024 7:29 PM, Richard Damon wrote: >>>>> >>> >>>>> >>> Remember, p defined as ~True(L, p) ... >>>>> >>>>> x := y means x is defined to be another name for y >>>> >>>> Another name for the meaning of y. Therefore any pair of sentences that >>>> are otherwise equal but one contains x where rhe other contains y is >>>> a pair >>>> of equally true sentences. For example, if p defined as ~True(L, ⟨p⟩) >>> >>> I have no idea what you mean by the weird ⟨p⟩ quotes. >>> I AM ABSOLUTELY NOT TALKING ABOUT ANY FREAKING Gödel NUMBERS >>> I AM ABSOLUTELY NOT TALKING ABOUT ANY FREAKING Gödel NUMBERS >>> I AM ABSOLUTELY NOT TALKING ABOUT ANY FREAKING Gödel NUMBERS >>> >>> I AM TALKING ABOUT THE EXISTENCE OR NON-EXISTENCE OF >>> AN ACTUAL SEQUENCE OF TRUTH PRESERVING OPERATIONS FROM >>> EXPRESSIONS OF LANGUAGE KNOWN TO BE TRUE >> >> So, you aren't talking about Tarski's proof of the impossibility to >> define a Truth Predicate per his definition? >> >>> >>>> then Truthbearer(L,p) has the same truth value as >>>> Truthbearer(L,~True(L, ⟨p⟩)). >>>> >>> >>> When p defined as ~True(L, p) >>> Then ~True(L, p) is true, thus a truth-bearer. >> >> Which means that True(L, p) is false, so your True just erred in >> describing a true statement as false. >> >> Remeber, you just said that ~True(L, p) which has been given the name >> of p IS a truth-bearer. >> > > *You are just not paying close enough attention again* > > When p defined as ~True(L, p) > True(L,p) is false > True(L,~p) is false > ~True(L,~p) is true > > x := y means x is defined to be another name for y > https://en.wikipedia.org/wiki/List_of_logic_symbols Right, so since p is DEFINED to be ~True(L, p), which since True(L, p) is false, must be true, that means that you are claiming that T(L, <a statement that has been shown to be true>) is false. Thus your True predicat is just broken. > > You ignored the part where Mikko agreed that > p defined as ~True(L, p) > is a syntax error: So, what it the "Syntax Error"? Are we not allowed to negate an expression Or are we not allowed to assign an expression to a name. Note, "Syntax Error", by its definition doesn't look at Semantics, > > On 5/21/2024 3:05 AM, Mikko wrote: > > On 2024-05-20 17:48:40 +0000, olcott said: > >> True(English, "a cat is an animal) is true > >> LP := ~True(L, LP) expands to ~True(~True(~True(~True(...)))) > > > > No, it doesn't. It is a syntax error to have the same symbol on > > both sides ":=" so the expansion is not justified. But it isn't. It is for PROLOG, which can't handle recursive definitions, but Tarski has, as part of the requireements of L, that it can handle such definition. So, it goes back to the fact that you don't understand what you are talking about, and don't understand the level of logic being used, but only much simpler systems. > >>> >>> LP := "This sentence is not true" >>> True(English, LP) is false because LP is not a truth bearer >>> ~True(English, LP) is true because LP is not a truth bearer >>> >>> "This sentence is not true". is not true. >>> This sentence is not true: "This sentence is not true". is true >>> >>> >>>>> https://en.wikipedia.org/wiki/List_of_logic_symbols >>>>> Thus p := ~True(L, p) >>>>> >>>>>>> *That is great. That means that you agree with me using different >>>>>>> words* >>>>>> >>>>>> Saying that you have a syntax error does not mean agreement. >>>>> >>>>> Saying this it is any kind of error is sufficient agreement. >>>>> Clocksin & Mellish also agree that it is an error: >>>> >>>> I don't agree with your errors. >>>> >>> >>> I am talking about the syntax error that you pointed out and >>> the *So Y ends up standing for some kind of infinite structure* >>> that Clocksin & Mellish pointed out, neither of these are >>> my error. >>> >>
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2024-05-22 20:36 -0500 |
| Subject | Re: True on the basis of meaning --- Good job Richard ! ---Socratic method (agreement) |
| Message-ID | <v2m6i9$1i4sg$1@dont-email.me> |
| In reply to | #105411 |
On 5/22/2024 8:03 PM, Richard Damon wrote: > On 5/22/24 7:55 PM, olcott wrote: >> *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. > Let's use the more intuitive name lp so that we incorporate by reference (instead of ignore) all of the material about the liar paradox. lp := ~True(L, lp) You already said that you know the Liar Paradox is neither true nor false, thus not a truth-bearer. You proved that you know more about self-reference than all of the standard literature On 5/13/2024 7:29 PM, Richard Damon wrote: > Remember, p defined as ~True(L, p) Those two things by themselves put you ahead of most experts in the field. The very best expert in the field that I know of does not know these two things and they only think that the Liar Paradox might not be a truth-bearer, they do not know it is not. >> >> 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. > *Mikko rejects p := ~True(L,p) as a syntax error* *which rejects p defined as ~True(L, p) as a syntax error* -- Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius hits a target no one else can see." Arthur Schopenhauer
[toc] | [prev] | [next] | [standalone]
| From | Richard Damon <richard@damon-family.org> |
|---|---|
| Date | 2024-05-22 22:31 -0400 |
| Subject | Re: True on the basis of meaning --- Good job Richard ! ---Socratic method (agreement) |
| Message-ID | <v2m9q9$1qo0t$3@i2pn2.org> |
| In reply to | #105413 |
On 5/22/24 9:36 PM, olcott wrote: > On 5/22/2024 8:03 PM, Richard Damon wrote: >> On 5/22/24 7:55 PM, olcott wrote: >>> *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. >> > > Let's use the more intuitive name lp so that we incorporate by > reference (instead of ignore) all of the material about the liar paradox. > > lp := ~True(L, lp) But that isn't the traditional "Liar's Paradix", because it is not normally stated in terms of a Truth Predicate. The "Liar's paradox" is a statement that asserts that it is false. That is NOT what the above statement says, or even means. > > You already said that you know the Liar Paradox is neither true > nor false, thus not a truth-bearer. You proved that you know > more about self-reference than all of the standard literature Nope, shows you don't understand what the literature is saying. > > On 5/13/2024 7:29 PM, Richard Damon wrote: > > Remember, p defined as ~True(L, p) > > Those two things by themselves put you ahead of most experts > in the field. The very best expert in the field that I know of > does not know these two things and they only think that the Liar > Paradox might not be a truth-bearer, they do not know it is not. Nope, just proves your stupidity, > >>> >>> 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. >> > > *Mikko rejects p := ~True(L,p) as a syntax error* > *which rejects p defined as ~True(L, p) as a syntax error* > But he is wrong, there is no syntax error for it in the logic field that Tarski is working in, as he assumes that logic is powerful enough to encode references, even to self, into the logical statements of the field.
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2024-05-22 22:45 -0500 |
| Subject | Re: True on the basis of meaning --- Good job Richard ! ---Socratic method (agreement) |
| Message-ID | <v2me5h$1j7n1$1@dont-email.me> |
| In reply to | #105417 |
On 5/22/2024 9:31 PM, Richard Damon wrote: > On 5/22/24 9:36 PM, olcott wrote: >> On 5/22/2024 8:03 PM, Richard Damon wrote: >>> On 5/22/24 7:55 PM, olcott wrote: >>>> *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. >>> >> >> Let's use the more intuitive name lp so that we incorporate by >> reference (instead of ignore) all of the material about the liar paradox. >> >> lp := ~True(L, lp) > > But that isn't the traditional "Liar's Paradix", because it is not > normally stated in terms of a Truth Predicate. > > The "Liar's paradox" is a statement that asserts that it is false. > > That is NOT what the above statement says, or even means. > The Strengthened Liar Paradox (also called the Strong Liar Paradox) can begin with a Strengthened Liar Sentence such as: This sentence is not true, https://iep.utm.edu/liar-paradox/#SH1a I spent 20,000 hours on this since 2004 and you glance at a couple of my words and guess that I must be wrong. >> >> You already said that you know the Liar Paradox is neither true >> nor false, thus not a truth-bearer. You proved that you know >> more about self-reference than all of the standard literature > > Nope, shows you don't understand what the literature is saying. > YOU ARE ALREADY AHEAD OF THE LITERATURE. THE LITERATURE CANNOT EVEN GET SELF-REFERENCE CORRECTLY ϕ(x) there is a sentence ψ such that S ⊢ ψ ↔ ϕ⟨ψ⟩. *The sentence ψ is of course not self-referential in a strict sense*, https://plato.stanford.edu/entries/self-reference/#ConSemPar On 5/13/2024 7:29 PM, Richard Damon wrote: > Remember, p defined as ~True(L, p) We will now call this lp defined as ~True(L, lp) or lp := ~True(L, lp) >> *Mikko rejects p := ~True(L,p) as a syntax error* >> *which rejects p defined as ~True(L, p) as a syntax error* >> > > But he is wrong, there is no syntax error for it in the logic field that > Tarski is working in, *That Tarski was aware of* < as he assumes that logic is powerful enough to > encode references, even to self, into the logical statements of the field. He didn't bother to THINK THIS ALL-THE-WAY THROUGH -- Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius hits a target no one else can see." Arthur Schopenhauer
[toc] | [prev] | [next] | [standalone]
| From | Richard Damon <richard@damon-family.org> |
|---|---|
| Date | 2024-05-23 07:29 -0400 |
| Subject | Re: True on the basis of meaning --- Good job Richard ! ---Socratic method (agreement) |
| Message-ID | <v2n9bl$1qo0t$7@i2pn2.org> |
| In reply to | #105422 |
On 5/22/24 11:45 PM, olcott wrote: > On 5/22/2024 9:31 PM, Richard Damon wrote: >> On 5/22/24 9:36 PM, olcott wrote: >>> On 5/22/2024 8:03 PM, Richard Damon wrote: >>>> On 5/22/24 7:55 PM, olcott wrote: >>>>> *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. >>>> >>> >>> Let's use the more intuitive name lp so that we incorporate by >>> reference (instead of ignore) all of the material about the liar >>> paradox. >>> >>> lp := ~True(L, lp) >> >> But that isn't the traditional "Liar's Paradix", because it is not >> normally stated in terms of a Truth Predicate. >> >> The "Liar's paradox" is a statement that asserts that it is false. >> >> That is NOT what the above statement says, or even means. >> > > The Strengthened Liar Paradox (also called the Strong Liar Paradox) > can begin with a Strengthened Liar Sentence such as: This sentence > is not true, > https://iep.utm.edu/liar-paradox/#SH1a > > I spent 20,000 hours on this since 2004 and you glance at a couple > of my words and guess that I must be wrong. Which was wasted since you didn't learn what a True Predicate is. > >>> >>> You already said that you know the Liar Paradox is neither true >>> nor false, thus not a truth-bearer. You proved that you know >>> more about self-reference than all of the standard literature >> >> Nope, shows you don't understand what the literature is saying. >> > > YOU ARE ALREADY AHEAD OF THE LITERATURE. > THE LITERATURE CANNOT EVEN GET SELF-REFERENCE CORRECTLY No, you don't understand the literature. I just know the need to phrase things for stupid people. Most of the literature is written for people who know the meaning of the words they are reading. > > ϕ(x) there is a sentence ψ such that S ⊢ ψ ↔ ϕ⟨ψ⟩. > *The sentence ψ is of course not self-referential in a strict sense*, > https://plato.stanford.edu/entries/self-reference/#ConSemPar > > On 5/13/2024 7:29 PM, Richard Damon wrote: > > Remember, p defined as ~True(L, p) > > We will now call this > lp defined as ~True(L, lp) or > lp := ~True(L, lp) > > >>> *Mikko rejects p := ~True(L,p) as a syntax error* >>> *which rejects p defined as ~True(L, p) as a syntax error* >>> >> >> But he is wrong, there is no syntax error for it in the logic field >> that Tarski is working in, > > *That Tarski was aware of* Nope. AS DEFINED. > > < as he assumes that logic is powerful enough to >> encode references, even to self, into the logical statements of the >> field. > > He didn't bother to THINK THIS ALL-THE-WAY THROUGH > Nope, you don't understand what he was saying because he was using log above your understanding. Sort of like sending a first grader that understands a bit of basic arithmetic, and putting them into a calculus class, they don't understand what is being talked about.
[toc] | [prev] | [next] | [standalone]
Page 6 of 8 — ← Prev page 1 2 3 4 5 [6] 7 8 Next page →
Back to top | Article view | comp.theory
csiph-web