Groups | Search | Server Info | Keyboard shortcuts | Login | Register [http] [https] [nntp] [nntps]


Groups > comp.lang.prolog > #11795 > unrolled thread

Does this fail an occurs check: ?- equal(foo(X,Y), Y).

Started byolcott <NoOne@NoWhere.com>
First post2021-04-09 18:16 -0500
Last post2021-04-14 02:25 +0000
Articles 20 on this page of 71 — 6 participants

Back to article view | Back to comp.lang.prolog


Contents

  Does this fail an occurs check: ?- equal(foo(X,Y), Y). olcott <NoOne@NoWhere.com> - 2021-04-09 18:16 -0500
    Simplified Gödel sentence fails Prolog occurs check---> ?- G = not(provable(F, G)). olcott <NoOne@NoWhere.com> - 2021-04-10 22:26 -0500
      Re: Simplified Gödel sentence fails Prolog occurs check---> ?- G = not(provable(F, G)). Jeff Barnett <jbb@notatt.com> - 2021-04-10 22:27 -0600
        Re: Simplified Gödel sentence fails Prolog occurs check---> ?- G = not(provable(F, G)). olcott <NoOne@NoWhere.com> - 2021-04-11 00:12 -0500
          Re: Simplified Gödel sentence fails Prolog occurs check---> ?- G = not(provable(F, G)). Jeff Barnett <jbb@notatt.com> - 2021-04-10 23:50 -0600
            Re: Simplified Gödel sentence fails Prolog occurs check---> ?- G = not(provable(F, G)). olcott <NoOne@NoWhere.com> - 2021-04-11 09:29 -0500
              Re: Simplified Gödel sentence fails Prolog occurs check---> ?- G = not(provable(F, G)). Mostowski Collapse <bursejan@gmail.com> - 2021-04-11 09:10 -0700
              Re: Simplified Gödel sentence fails Prolog occurs check---> ?- G = not(provable(F, G)). olcott <NoOne@NoWhere.com> - 2021-04-11 12:06 -0500
              Re: Simplified Gödel sentence fails Prolog occurs check---> ?- G = not(provable(F, G)). olcott <NoOne@NoWhere.com> - 2021-04-11 14:34 -0500
                Re: Simplified Gödel sentence fails Prolog occurs check---> ?- G = not(provable(F, G)). Mostowski Collapse <bursejan@gmail.com> - 2021-04-11 12:54 -0700
                  Re: Simplified Gödel sentence fails Prolog occurs check---> ?- G = not(provable(F, G)). olcott <NoOne@NoWhere.com> - 2021-04-11 15:31 -0500
                    Re: Simplified Gödel sentence fails Prolog occurs check---> ?- G = not(provable(F, G)). Mostowski Collapse <bursejan@gmail.com> - 2021-04-11 15:39 -0700
                      Re: Simplified Gödel sentence fails Prolog occurs check---> ?- G = not(provable(F, G)). Mostowski Collapse <bursejan@gmail.com> - 2021-04-11 15:49 -0700
                        Re: Simplified Gödel sentence fails Prolog occurs check---> ?- G = not(provable(F, G)). Mostowski Collapse <bursejan@gmail.com> - 2021-04-11 16:08 -0700
                          Re: Simplified Gödel sentence fails Prolog occurs check---> ?- G = not(provable(F, G)). olcott <NoOne@NoWhere.com> - 2021-04-11 19:04 -0500
                            Re: Simplified Gödel sentence fails Prolog occurs check---> ?- G = not(provable(F, G)). Mostowski Collapse <bursejan@gmail.com> - 2021-04-12 01:16 -0700
                              Re: Simplified Gödel sentence fails Prolog occurs check---> ?- G = not(provable(F, G)). olcott <NoOne@NoWhere.com> - 2021-04-12 09:45 -0500
                        Re: Simplified Gödel sentence fails Prolog occurs check---> ?- G = not(provable(F, G)). olcott <NoOne@NoWhere.com> - 2021-04-11 18:57 -0500
                          Re: Simplified Gödel sentence fails Prolog occurs check---> ?- G = not(provable(F, G)). olcott <NoOne@NoWhere.com> - 2021-04-12 10:10 -0500
                            Re: Simplified Gödel sentence fails Prolog occurs check---> ?- G = not(provable(F, G)). Kaz Kylheku <563-365-8930@kylheku.com> - 2021-04-13 07:03 +0000
                              Re: Simplified Gödel sentence fails Prolog occurs check---> ?- G = not(provable(F, G)). olcott <NoOne@NoWhere.com> - 2021-04-14 11:46 -0500
                                Re: Simplified Gödel sentence fails Prolog occurs check---> ?- G = not(provable(F, G)). Kaz Kylheku <563-365-8930@kylheku.com> - 2021-04-15 00:25 +0000
                                  Re: Simplified Gödel sentence fails Prolog occurs check---> ?- G = not(provable(F, G)). olcott <NoOne@NoWhere.com> - 2021-04-15 09:58 -0500
                          Re: Simplified Gödel sentence fails Prolog occurs check---> ?- G = not(provable(F, G)). olcott <NoOne@NoWhere.com> - 2021-04-12 14:30 -0500
                            Re: Simplified Gödel sentence fails Prolog occurs check---> ?- G = not(provable(F, G)). olcott <NoOne@NoWhere.com> - 2021-04-12 17:02 -0500
                              Re: Simplified Gödel sentence fails Prolog occurs check---> ?- G = not(provable(F, G)). Mostowski Collapse <bursejan@gmail.com> - 2021-04-12 15:23 -0700
                                Re: Simplified Gödel sentence fails Prolog occurs check---> ?- G = not(provable(F, G)). olcott <NoOne@NoWhere.com> - 2021-04-12 19:52 -0500
                            Re: Simplified Gödel sentence fails Prolog occurs check---> ?- G = not(provable(F, G)). Kaz Kylheku <563-365-8930@kylheku.com> - 2021-04-13 06:57 +0000
                              Re: Simplified Gödel sentence fails Prolog occurs check---> ?- G = not(provable(F, G)). olcott <NoOne@NoWhere.com> - 2021-04-14 11:29 -0500
                                Re: Simplified Gödel sentence fails Prolog occurs check---> ?- G = not(provable(F, G)). Kaz Kylheku <563-365-8930@kylheku.com> - 2021-04-14 23:45 +0000
      Re: Simplified Gödel sentence fails Prolog occurs check---> ?- G = not(provable(F, G)). Kaz Kylheku <563-365-8930@kylheku.com> - 2021-04-12 01:27 +0000
        Re: Simplified Gödel sentence fails Prolog occurs check---> ?- G = not(provable(F, G)). olcott <NoOne@NoWhere.com> - 2021-04-12 09:56 -0500
          Re: Simplified Gödel sentence fails Prolog occurs check---> ?- G = not(provable(F, G)). Mostowski Collapse <bursejan@gmail.com> - 2021-04-12 08:21 -0700
            Re: Simplified Gödel sentence fails Prolog occurs check---> ?- G = not(provable(F, G)). Mostowski Collapse <bursejan@gmail.com> - 2021-04-12 08:24 -0700
            Re: Simplified Gödel sentence fails Prolog occurs check---> ?- G = not(provable(F, G)). olcott <NoOne@NoWhere.com> - 2021-04-12 11:12 -0500
              Re: Simplified Gödel sentence fails Prolog occurs check---> ?- G = not(provable(F, G)). Mostowski Collapse <bursejan@gmail.com> - 2021-04-12 12:57 -0700
                Re: Simplified Gödel sentence fails Prolog occurs check---> ?- G = not(provable(F, G)). Mostowski Collapse <bursejan@gmail.com> - 2021-04-12 13:04 -0700
                  Re: Simplified Gödel sentence fails Prolog occurs check---> ?- G = not(provable(F, G)). olcott <NoOne@NoWhere.com> - 2021-04-12 16:56 -0500
                    Re: Simplified Gödel sentence fails Prolog occurs check---> ?- G = not(provable(F, G)). olcott <NoOne@NoWhere.com> - 2021-04-12 22:35 -0500
                      Re: Simplified Gödel sentence fails Prolog occurs check---> ?- G = not(provable(F, G)). Kaz Kylheku <563-365-8930@kylheku.com> - 2021-04-13 06:38 +0000
                        Re: Simplified Gödel sentence fails Prolog occurs check---> ?- G = not(provable(F, G)). olcott <NoOne@NoWhere.com> - 2021-04-13 14:36 -0500
                          Re: Simplified Gödel sentence fails Prolog occurs check---> ?- G = not(provable(F, G)). Mostowski Collapse <bursejan@gmail.com> - 2021-04-13 14:59 -0700
                            Re: Simplified Gödel sentence fails Prolog occurs check---> ?- G = not(provable(F, G)). olcott <NoOne@NoWhere.com> - 2021-04-13 18:00 -0500
                              Re: Simplified Gödel sentence fails Prolog occurs check---> ?- G = not(provable(F, G)). Mostowski Collapse <bursejan@gmail.com> - 2021-04-13 18:03 -0700
                                Re: Simplified Gödel sentence fails Prolog occurs check---> ?- G = not(provable(F, G)). olcott <NoOne@NoWhere.com> - 2021-04-13 21:26 -0500
                Re: Simplified Gödel sentence fails Prolog occurs check---> ?- G = not(provable(F, G)). olcott <NoOne@NoWhere.com> - 2021-04-12 16:41 -0500
            Re: Simplified Gödel sentence fails Prolog occurs check---> ?- G = not(provable(F, G)). olcott <NoOne@NoWhere.com> - 2021-04-12 11:15 -0500
          Re: Simplified Gödel sentence fails Prolog occurs check---> ?- G = not(provable(F, G)). Kaz Kylheku <563-365-8930@kylheku.com> - 2021-04-13 06:27 +0000
            Re: Simplified Gödel sentence fails Prolog occurs check---> ?- G = not(provable(F, G)). olcott <NoOne@NoWhere.com> - 2021-04-13 12:03 -0500
              Re: Simplified Gödel sentence fails Prolog occurs check---> ?- G = not(provable(F, G)). Mostowski Collapse <janburse@fastmail.fm> - 2021-04-13 19:27 +0200
                Re: Simplified Gödel sentence fails Prolog occurs check---> ?- G = not(provable(F, G)). olcott <NoOne@NoWhere.com> - 2021-04-13 12:45 -0500
                  Re: Simplified Gödel sentence fails Prolog occurs check---> ?- G = not(provable(F, G)). Mostowski Collapse <bursejan@gmail.com> - 2021-04-13 10:54 -0700
                    Re: Simplified Gödel sentence fails Prolog occurs check---> ?- G = not(provable(F, G)). olcott <NoOne@NoWhere.com> - 2021-04-13 13:13 -0500
                      Re: Simplified Gödel sentence fails Prolog occurs check---> ?- G = not(provable(F, G)). Mostowski Collapse <bursejan@gmail.com> - 2021-04-13 11:21 -0700
                        Re: Simplified Gödel sentence fails Prolog occurs check---> ?- G = not(provable(F, G)). Mostowski Collapse <bursejan@gmail.com> - 2021-04-13 11:32 -0700
                          Re: Simplified Gödel sentence fails Prolog occurs check---> ?- G = not(provable(F, G)). olcott <NoOne@NoWhere.com> - 2021-04-13 14:30 -0500
                            Re: Simplified Gödel sentence fails Prolog occurs check---> ?- G = not(provable(F, G)). Kaz Kylheku <563-365-8930@kylheku.com> - 2021-04-14 02:28 +0000
                            Re: Simplified Gödel sentence fails Prolog occurs check---> ?- G = not(provable(F, G)). olcott <NoOne@NoWhere.com> - 2021-04-14 11:56 -0500
                              Re: Simplified Gödel sentence fails Prolog occurs check---> ?- G = not(provable(F, G)). André G. Isaak <agisaak@gm.invalid> - 2021-04-14 11:05 -0600
                                Re: Simplified Gödel sentence fails Prolog occurs check---> ?- G = not(provable(F, G)). olcott <NoOne@NoWhere.com> - 2021-04-14 12:09 -0500
                                  Re: Simplified Gödel sentence fails Prolog occurs check---> ?- G = not(provable(F, G)). Kaz Kylheku <563-365-8930@kylheku.com> - 2021-04-15 00:32 +0000
                                    Re: Simplified Gödel sentence fails Prolog occurs check---> ?- G = not(provable(F, G)). olcott <NoOne@NoWhere.com> - 2021-04-15 10:00 -0500
                                      Re: Simplified Gödel sentence fails Prolog occurs check---> ?- G = not(provable(F, G)). Mostowski Collapse <bursejan@gmail.com> - 2021-04-15 08:18 -0700
                                        Re: Simplified Gödel sentence fails Prolog occurs check---> ?- G = not(provable(F, G)). olcott <NoOne@NoWhere.com> - 2021-04-15 10:39 -0500
                                          Re: Simplified Gödel sentence fails Prolog occurs check---> ?- G = not(provable(F, G)). Mostowski Collapse <bursejan@gmail.com> - 2021-04-15 08:54 -0700
                                            Re: Simplified Gödel sentence fails Prolog occurs check---> ?- G = not(provable(F, G)). olcott <NoOne@NoWhere.com> - 2021-04-15 11:20 -0500
                                              Re: Simplified Gödel sentence fails Prolog occurs check---> ?- G = not(provable(F, G)). Mostowski Collapse <bursejan@gmail.com> - 2021-04-15 12:14 -0700
                                      Re: Simplified Gödel sentence fails Prolog occurs check---> ?- G = not(provable(F, G)). Kaz Kylheku <563-365-8930@kylheku.com> - 2021-04-15 15:43 +0000
                        Re: Simplified Gödel sentence fails Prolog occurs check---> ?- G = not(provable(F, G)). olcott <NoOne@NoWhere.com> - 2021-04-13 13:43 -0500
                          Re: Simplified Gödel sentence fails Prolog occurs check---> ?- G = not(provable(F, G)). Mostowski Collapse <bursejan@gmail.com> - 2021-04-13 11:50 -0700
                          Re: Simplified Gödel sentence fails Prolog occurs check---> ?- G = not(provable(F, G)). Kaz Kylheku <563-365-8930@kylheku.com> - 2021-04-14 02:25 +0000

Page 1 of 4  [1] 2 3 4  Next page →


#11795 — Does this fail an occurs check: ?- equal(foo(X,Y), Y).

Fromolcott <NoOne@NoWhere.com>
Date2021-04-09 18:16 -0500
SubjectDoes this fail an occurs check: ?- equal(foo(X,Y), Y).
Message-ID<YL-dncCl9PjBfe39nZ2dnUU7-KnNnZ2d@giganews.com>
Clocksin and Mellish says that this fails an occurs check:
?- equal(foo(Y), Y).

254 Chapter 10 The Relation of Prolog to Logic
Programming in Prolog Using the ISO Standard Fifth Edition by Clocksin 
and Mellish


Does that mean that this also fails an occurs check:
?- equal(foo(X,Y), Y).

-- 
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre 
minds." Einstein

[toc] | [next] | [standalone]


#11801 — Simplified Gödel sentence fails Prolog occurs check---> ?- G = not(provable(F, G)).

Fromolcott <NoOne@NoWhere.com>
Date2021-04-10 22:26 -0500
SubjectSimplified Gödel sentence fails Prolog occurs check---> ?- G = not(provable(F, G)).
Message-ID<v7mdnXOWLqrv8e_9nZ2dnUU7-ffNnZ2d@giganews.com>
In reply to#11795
On 4/9/2021 6:16 PM, olcott wrote:
> Clocksin and Mellish says that this fails an occurs check:
> ?- equal(foo(Y), Y).
> 
> 254 Chapter 10 The Relation of Prolog to Logic
> Programming in Prolog Using the ISO Standard Fifth Edition by Clocksin 
> and Mellish
> 
> 
> Does that mean that this also fails an occurs check:
> ?- equal(foo(X,Y), Y).
> 

?- G = not(provable(F, G)). 		% G = ¬(F ⊢ G)
?- unify_with_occurs_check(G, not(provable(F, G))).
false.

and its negation also fails

?- G = not(provable(F, not(G))). 	% G = ¬(F ⊢ ¬G)
?- unify_with_occurs_check(G, not(provable(F, not(G)))).
false.

Thus meeting this conventional definition of incompleteness:
Incomplete(T) ↔ ∃φ ((T ⊬ φ) ∧ (T ⊬ ¬φ))

Therefore proving equivalence to the actual Gödel sentence.

https://www.researchgate.net/publication/350789898_Prolog_detects_pathological_self_reference_in_the_Godel_sentence 


-- 
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre 
minds." Einstein

[toc] | [prev] | [next] | [standalone]


#11802 — Re: Simplified Gödel sentence fails Prolog occurs check---> ?- G = not(provable(F, G)).

FromJeff Barnett <jbb@notatt.com>
Date2021-04-10 22:27 -0600
SubjectRe: Simplified Gödel sentence fails Prolog occurs check---> ?- G = not(provable(F, G)).
Message-ID<s4ttrp$pn$1@dont-email.me>
In reply to#11801
On 4/10/2021 9:26 PM, olcott wrote:
> On 4/9/2021 6:16 PM, olcott wrote:
>> Clocksin and Mellish says that this fails an occurs check:
>> ?- equal(foo(Y), Y).
>>
>> 254 Chapter 10 The Relation of Prolog to Logic
>> Programming in Prolog Using the ISO Standard Fifth Edition by Clocksin 

>> and Mellish
>>
>>
>> Does that mean that this also fails an occurs check:
>> ?- equal(foo(X,Y), Y).
>>
> 
> ?- G = not(provable(F, G)).         % G = ¬(F ⊢ G)
> ?- unify_with_occurs_check(G, not(provable(F, G))).
> false.
> 
> and its negation also fails
> 
> ?- G = not(provable(F, not(G))).     % G = ¬(F ⊢ ¬G)
> ?- unify_with_occurs_check(G, not(provable(F, not(G)))).
> false.
> 
> Thus meeting this conventional definition of incompleteness:
> Incomplete(T) ↔ ∃φ ((T ⊬ φ) ∧ 
(T ⊬ ¬φ))
> 
> Therefore proving equivalence to the actual Gödel sentence.
> 
> https://www.researchgate.net/publication/350789898_Prolog_detects_pathological_self_reference_in_the_Godel_sentence 

Congratulations! You have added Prolog to the list of topics that you 
don't really understand. The above reminds me a bit of Wisenbaum's 
Eliza. (Also called the Doctor and a direct ancestor of Perry the 
Paranoid.) In the above, substitute the word "constipated" for 
"provable". Then your result reads:

      "?- unify_with_occurs_check(G, not(constipated(F, not(G))))"

and that shows exactly nothing to do with anything. So PO now has a 
theory of bowel movements but not those TM encodings promised so long 
ago. I suggest, to you, that you grab a book on logic and a bottle of 
Miralax and get on with it.
-- 
Jeff Barnett

[toc] | [prev] | [next] | [standalone]


#11803 — Re: Simplified Gödel sentence fails Prolog occurs check---> ?- G = not(provable(F, G)).

Fromolcott <NoOne@NoWhere.com>
Date2021-04-11 00:12 -0500
SubjectRe: Simplified Gödel sentence fails Prolog occurs check---> ?- G = not(provable(F, G)).
Message-ID<s4edndrMtKelGO_9nZ2dnUU7-fXNnZ2d@giganews.com>
In reply to#11802
On 4/10/2021 11:27 PM, Jeff Barnett wrote:
> On 4/10/2021 9:26 PM, olcott wrote:
>> On 4/9/2021 6:16 PM, olcott wrote:
>>> Clocksin and Mellish says that this fails an occurs check:
>>> ?- equal(foo(Y), Y).
>>>
>>> 254 Chapter 10 The Relation of Prolog to Logic
>>> Programming in Prolog Using the ISO Standard Fifth Edition by Clocksin 
> 
>>> and Mellish
>>>
>>>
>>> Does that mean that this also fails an occurs check:
>>> ?- equal(foo(X,Y), Y).
>>>
>>
>> ?- G = not(provable(F, G)).         % G = ¬(F ⊢ G)
>> ?- unify_with_occurs_check(G, not(provable(F, G))).
>> false.
>>
>> and its negation also fails
>>
>> ?- G = not(provable(F, not(G))).     % G = ¬(F ⊢ ¬G)
>> ?- unify_with_occurs_check(G, not(provable(F, not(G)))).
>> false.
>>
>> Thus meeting this conventional definition of incompleteness:
>> Incomplete(T) ↔ ∃φ ((T ⊬ φ) ∧ 
> (T ⊬ ¬φ))
>>
>> Therefore proving equivalence to the actual Gödel sentence.
>>
>> https://www.researchgate.net/publication/350789898_Prolog_detects_pathological_self_reference_in_the_Godel_sentence 
> 
> 
> Congratulations! You have added Prolog to the list of topics that you 
> don't really understand. The above reminds me a bit of Wisenbaum's 
> Eliza. (Also called the Doctor and a direct ancestor of Perry the 
> Paranoid.) In the above, substitute the word "constipated" for 
> "provable". Then your result reads:
> 
>      "?- unify_with_occurs_check(G, not(constipated(F, not(G))))"
> 
> and that shows exactly nothing to do with anything. So PO now has a 
> theory of bowel movements but not those TM encodings promised so long 
> ago. I suggest, to you, that you grab a book on logic and a bottle of 
> Miralax and get on with it.

Jackasses can be naysayers because it doesn't require any knowledge or 
intelligence.

I know that this particular understanding of Prolog is correct on the 
basis of a whole logic system that I created named Minimal Type Theory. 
This logic system translates expression of its language into directed 
graphs.

As I show in the above paper the logic sentence really is cyclic in both 
Minimal Type Theory (MTT) and Prolog.

Here is the formal YACC grammar for MTT:
https://www.researchgate.net/publication/331859461_Minimal_Type_Theory_YACC_BNF


-- 
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre 
minds." Einstein

[toc] | [prev] | [next] | [standalone]


#11804 — Re: Simplified Gödel sentence fails Prolog occurs check---> ?- G = not(provable(F, G)).

FromJeff Barnett <jbb@notatt.com>
Date2021-04-10 23:50 -0600
SubjectRe: Simplified Gödel sentence fails Prolog occurs check---> ?- G = not(provable(F, G)).
Message-ID<s4u2n7$tva$1@dont-email.me>
In reply to#11803
On 4/10/2021 11:12 PM, olcott wrote:
> On 4/10/2021 11:27 PM, Jeff Barnett wrote:
>> On 4/10/2021 9:26 PM, olcott wrote:
>>> On 4/9/2021 6:16 PM, olcott wrote:
>>>> Clocksin and Mellish says that this fails an occurs check:
>>>> ?- equal(foo(Y), Y).
>>>>
>>>> 254 Chapter 10 The Relation of Prolog to Logic
>>>> Programming in Prolog Using the ISO Standard Fifth Edition by Clocksin 
>>
>>>> and Mellish
>>>>
>>>>
>>>> Does that mean that this also fails an occurs check:
>>>> ?- equal(foo(X,Y), Y).
>>>>
>>>
>>> ?- G = not(provable(F, G)).         % G = ¬(F ⊢ G)
>>> ?- unify_with_occurs_check(G, not(provable(F, G))).
>>> false.
>>>
>>> and its negation also fails
>>>
>>> ?- G = not(provable(F, not(G))).     % G = ¬(F ⊢ ¬G)
>>> ?- unify_with_occurs_check(G, not(provable(F, not(G)))).
>>> false.
>>>
>>> Thus meeting this conventional definition of incompleteness:
>>> Incomplete(T) ↔ ∃φ ((T ⊬ φ) ∧ 

>> (T ⊬ ¬φ))
>>>
>>> Therefore proving equivalence to the actual Gödel sentence.
>>>
>>> https://www.researchgate.net/publication/350789898_Prolog_detects_pathological_self_reference_in_the_Godel_sentence 
>>
>>
>>
>> Congratulations! You have added Prolog to the list of topics that you 
>> don't really understand. The above reminds me a bit of Wisenbaum's 
>> Eliza. (Also called the Doctor and a direct ancestor of Perry the 
>> Paranoid.) In the above, substitute the word "constipated" for 
>> "provable". Then your result reads:
>>
>>      "?- unify_with_occurs_check(G, not(constipated(F, not(G))))"
>>
>> and that shows exactly nothing to do with anything. So PO now has a 
>> theory of bowel movements but not those TM encodings promised so long 
>> ago. I suggest, to you, that you grab a book on logic and a bottle of 
>> Miralax and get on with it.
> 
> Jackasses can be naysayers because it doesn't require any knowledge or 
> intelligence.
> 
> I know that this particular understanding of Prolog is correct on the 
> basis of a whole logic system that I created named Minimal Type Theory. 

> This logic system translates expression of its language into directed 
> graphs.
> 
> As I show in the above paper the logic sentence really is cyclic in both 
> Minimal Type Theory (MTT) and Prolog.
> 
> Here is the formal YACC grammar for MTT:
> https://www.researchgate.net/publication/331859461_Minimal_Type_Theory_YACC_BNF 
What does any of this have to do with my comments? Are you really so 
disassociated with reality? It's mind boggling. Did you try substituting 
"constipated" for "provable"? What did the expert find happening? Just 
curious. When I wrote the above, I began to wonder how much Eliza script 
would be needed to create a PO out of the vacuum. I think I might have 
some old Lisp code lying around; if I can find it, maybe I'll try to 
write that script. Then we can see if anyone can tell the difference. It 
would be a reverse Turing test: see if anyone can tell the difference 
between a duffus and the computer instead of a human and a computer. 
What do you think?
-- 
Jeff Barnett

[toc] | [prev] | [next] | [standalone]


#11805 — Re: Simplified Gödel sentence fails Prolog occurs check---> ?- G = not(provable(F, G)).

Fromolcott <NoOne@NoWhere.com>
Date2021-04-11 09:29 -0500
SubjectRe: Simplified Gödel sentence fails Prolog occurs check---> ?- G = not(provable(F, G)).
Message-ID<8YednRsWi7gumu79nZ2dnUU7-N3NnZ2d@giganews.com>
In reply to#11804
On 4/11/2021 12:50 AM, Jeff Barnett wrote:
> On 4/10/2021 11:12 PM, olcott wrote:
>> On 4/10/2021 11:27 PM, Jeff Barnett wrote:
>>> On 4/10/2021 9:26 PM, olcott wrote:
>>>> On 4/9/2021 6:16 PM, olcott wrote:
>>>>> Clocksin and Mellish says that this fails an occurs check:
>>>>> ?- equal(foo(Y), Y).
>>>>>
>>>>> 254 Chapter 10 The Relation of Prolog to Logic
>>>>> Programming in Prolog Using the ISO Standard Fifth Edition by Clocksin 
>>>
>>>>> and Mellish
>>>>>
>>>>>
>>>>> Does that mean that this also fails an occurs check:
>>>>> ?- equal(foo(X,Y), Y).
>>>>>
>>>>
>>>> ?- G = not(provable(F, G)).         % G = ¬(F ⊢ G)
>>>> ?- unify_with_occurs_check(G, not(provable(F, G))).
>>>> false.
>>>>
>>>> and its negation also fails
>>>>
>>>> ?- G = not(provable(F, not(G))).     % G = ¬(F ⊢ ¬G)
>>>> ?- unify_with_occurs_check(G, not(provable(F, not(G)))).
>>>> false.
>>>>
>>>> Thus meeting this conventional definition of incompleteness:
>>>> Incomplete(T) ↔ ∃φ ((T ⊬ φ) ∧ 
> 
>>> (T ⊬ ¬φ))
>>>>
>>>> Therefore proving equivalence to the actual Gödel sentence.
>>>>
>>>> https://www.researchgate.net/publication/350789898_Prolog_detects_pathological_self_reference_in_the_Godel_sentence 
>>>
>>>
>>>
>>>
>>> Congratulations! You have added Prolog to the list of topics that you 
>>> don't really understand. The above reminds me a bit of Wisenbaum's 
>>> Eliza. (Also called the Doctor and a direct ancestor of Perry the 
>>> Paranoid.) In the above, substitute the word "constipated" for 
>>> "provable". Then your result reads:
>>>
>>>      "?- unify_with_occurs_check(G, not(constipated(F, not(G))))"
>>>
>>> and that shows exactly nothing to do with anything. So PO now has a 
>>> theory of bowel movements but not those TM encodings promised so long 
>>> ago. I suggest, to you, that you grab a book on logic and a bottle of 
>>> Miralax and get on with it.
>>
>> Jackasses can be naysayers because it doesn't require any knowledge or 
>> intelligence.
>>
>> I know that this particular understanding of Prolog is correct on the 
>> basis of a whole logic system that I created named Minimal Type Theory. 
> 
>> This logic system translates expression of its language into directed 
>> graphs.
>>
>> As I show in the above paper the logic sentence really is cyclic in 
>> both Minimal Type Theory (MTT) and Prolog.
>>
>> Here is the formal YACC grammar for MTT:
>> https://www.researchgate.net/publication/331859461_Minimal_Type_Theory_YACC_BNF 
> 
> What does any of this have to do with my comments? Are you really so 
> disassociated with reality? It's mind boggling. Did you try substituting 
> "constipated" for "provable"? What did the expert find happening? Just 
> curious. When I wrote the above, I began to wonder how much Eliza script 
> would be needed to create a PO out of the vacuum. I think I might have 
> some old Lisp code lying around; if I can find it, maybe I'll try to 
> write that script. Then we can see if anyone can tell the difference. It 
> would be a reverse Turing test: see if anyone can tell the difference 
> between a duffus and the computer instead of a human and a computer. 
> What do you think?

The verifiable fact is that G = not(provable(F, G)). is indeed not 
provable and its negation is G = not(provable(F, not(G))). is not 
provable thus meeting the definition of Incompleteness:
Incomplete(T) ↔ ∃φ ((T ⊬ φ) ∧ (T ⊬ ¬φ))

Because this simplified expression and its negation meet the definition 
of incompleteness that proves that they are equivalent to Gödel's actual 
logic sentence.

The analogy between this result and Richard’s antinomy leaps to the eye; 
there is also a close relationship with the “liar” antinomy,14 since the 
undecidable proposition [R(q); q] states precisely that q belongs to K, 
i.e. according to (1), that [R(q); q] is not provable. We are therefore 
confronted with a proposition which asserts its own unprovability.15

14 Every epistemological antinomy can likewise be used for a similar 
undecidability proof. (Gödel:1931:40).

The key new knowledge is that we can know why they are not provable 
unlike diagonalization which only proves that they are unprovable.

They are unprovable because they have an infinitely recursive (cyclic) 
structure.

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

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

Godel, Kurt 1931. On Formally Undecidable Propositions of Principia 
Mathematica And Related Systems I, page 39-41.


-- 
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre 
minds." Einstein

[toc] | [prev] | [next] | [standalone]


#11806 — Re: Simplified Gödel sentence fails Prolog occurs check---> ?- G = not(provable(F, G)).

FromMostowski Collapse <bursejan@gmail.com>
Date2021-04-11 09:10 -0700
SubjectRe: Simplified Gödel sentence fails Prolog occurs check---> ?- G = not(provable(F, G)).
Message-ID<71185121-6b7f-4d94-b077-fed418aae1a2n@googlegroups.com>
In reply to#11805
Olcott misused Prolog. The outcome of LP = not(true(LP)) 
depends on the occurs check flag.

/* SWI-Prolog 8.3.21 */
?- set_prolog_flag(occurs_check, false).
true.

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

?- set_prolog_flag(occurs_check, true).
true.

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

But indeed nothing to do with Gödel, since (=)/2 in Prolog
is so called syntactic equality.

olcott schrieb am Sonntag, 11. April 2021 um 16:29:13 UTC+2:
> On 4/11/2021 12:50 AM, Jeff Barnett wrote: 
> > On 4/10/2021 11:12 PM, olcott wrote: 
> >> On 4/10/2021 11:27 PM, Jeff Barnett wrote: 
> >>> On 4/10/2021 9:26 PM, olcott wrote: 
> >>>> On 4/9/2021 6:16 PM, olcott wrote: 
> >>>>> Clocksin and Mellish says that this fails an occurs check: 
> >>>>> ?- equal(foo(Y), Y). 
> >>>>> 
> >>>>> 254 Chapter 10 The Relation of Prolog to Logic 
> >>>>> Programming in Prolog Using the ISO Standard Fifth Edition by Clocksin 
> >>> 
> >>>>> and Mellish 
> >>>>> 
> >>>>> 
> >>>>> Does that mean that this also fails an occurs check: 
> >>>>> ?- equal(foo(X,Y), Y). 
> >>>>> 
> >>>> 
> >>>> ?- G = not(provable(F, G)). % G = ¬(F ⊢ G) 
> >>>> ?- unify_with_occurs_check(G, not(provable(F, G))). 
> >>>> false. 
> >>>> 
> >>>> and its negation also fails 
> >>>> 
> >>>> ?- G = not(provable(F, not(G))). % G = ¬(F ⊢ ¬G) 
> >>>> ?- unify_with_occurs_check(G, not(provable(F, not(G)))). 
> >>>> false. 
> >>>> 
> >>>> Thus meeting this conventional definition of incompleteness: 
> >>>> Incomplete(T) ↔ ∃φ ((T ⊬ φ) ∧ 
> > 
> >>> (T ⊬ ¬φ)) 
> >>>> 
> >>>> Therefore proving equivalence to the actual Gödel sentence. 
> >>>> 
> >>>> https://www.researchgate.net/publication/350789898_Prolog_detects_pathological_self_reference_in_the_Godel_sentence 
> >>> 
> >>> 
> >>> 
> >>> 
> >>> Congratulations! You have added Prolog to the list of topics that you 
> >>> don't really understand. The above reminds me a bit of Wisenbaum's 
> >>> Eliza. (Also called the Doctor and a direct ancestor of Perry the 
> >>> Paranoid.) In the above, substitute the word "constipated" for 
> >>> "provable". Then your result reads: 
> >>> 
> >>> "?- unify_with_occurs_check(G, not(constipated(F, not(G))))" 
> >>> 
> >>> and that shows exactly nothing to do with anything. So PO now has a 
> >>> theory of bowel movements but not those TM encodings promised so long 
> >>> ago. I suggest, to you, that you grab a book on logic and a bottle of 
> >>> Miralax and get on with it. 
> >> 
> >> Jackasses can be naysayers because it doesn't require any knowledge or 
> >> intelligence. 
> >> 
> >> I know that this particular understanding of Prolog is correct on the 
> >> basis of a whole logic system that I created named Minimal Type Theory. 
> > 
> >> This logic system translates expression of its language into directed 
> >> graphs. 
> >> 
> >> As I show in the above paper the logic sentence really is cyclic in 
> >> both Minimal Type Theory (MTT) and Prolog. 
> >> 
> >> Here is the formal YACC grammar for MTT: 
> >> https://www.researchgate.net/publication/331859461_Minimal_Type_Theory_YACC_BNF 
> > 
> > What does any of this have to do with my comments? Are you really so 
> > disassociated with reality? It's mind boggling. Did you try substituting 
> > "constipated" for "provable"? What did the expert find happening? Just 
> > curious. When I wrote the above, I began to wonder how much Eliza script 
> > would be needed to create a PO out of the vacuum. I think I might have 
> > some old Lisp code lying around; if I can find it, maybe I'll try to 
> > write that script. Then we can see if anyone can tell the difference. It 
> > would be a reverse Turing test: see if anyone can tell the difference 
> > between a duffus and the computer instead of a human and a computer. 
> > What do you think?
> The verifiable fact is that G = not(provable(F, G)). is indeed not 
> provable and its negation is G = not(provable(F, not(G))). is not 
> provable thus meeting the definition of Incompleteness:
> Incomplete(T) ↔ ∃φ ((T ⊬ φ) ∧ (T ⊬ ¬φ))
> Because this simplified expression and its negation meet the definition 
> of incompleteness that proves that they are equivalent to Gödel's actual 
> logic sentence. 
> 
> The analogy between this result and Richard’s antinomy leaps to the eye; 
> there is also a close relationship with the “liar” antinomy,14 since the 
> undecidable proposition [R(q); q] states precisely that q belongs to K, 
> i.e. according to (1), that [R(q); q] is not provable. We are therefore 
> confronted with a proposition which asserts its own unprovability.15 
> 
> 14 Every epistemological antinomy can likewise be used for a similar 
> undecidability proof. (Gödel:1931:40). 
> 
> The key new knowledge is that we can know why they are not provable 
> unlike diagonalization which only proves that they are unprovable. 
> 
> They are unprovable because they have an infinitely recursive (cyclic) 
> structure. 
> 
> ?- LP = not(true(LP)). 
> LP = not(true(LP)). 
> 
> ?- unify_with_occurs_check(LP, not(true(LP))). 
> false. 
> 
> Godel, Kurt 1931. On Formally Undecidable Propositions of Principia 
> Mathematica And Related Systems I, page 39-41.
> -- 
> Copyright 2021 Pete Olcott 
> 
> "Great spirits have always encountered violent opposition from mediocre 
> minds." Einstein

[toc] | [prev] | [next] | [standalone]


#11807 — Re: Simplified Gödel sentence fails Prolog occurs check---> ?- G = not(provable(F, G)).

Fromolcott <NoOne@NoWhere.com>
Date2021-04-11 12:06 -0500
SubjectRe: Simplified Gödel sentence fails Prolog occurs check---> ?- G = not(provable(F, G)).
Message-ID<UvudnYHZCfE2se79nZ2dnUU7-b3NnZ2d@giganews.com>
In reply to#11805
On 4/11/2021 11:08 AM, Mostowski Collapse wrote:
> Olcott misused Prolog. The outcome of LP = not(true(LP))
> depends on the occurs check flag.
> 
> /* SWI-Prolog 8.3.21 */
> ?- set_prolog_flag(occurs_check, false).
> true.
> 
> ?- LP = not(true(LP)).
> LP = not(true(LP)).
> 
> ?- set_prolog_flag(occurs_check, true).
> true.
> 
> ?- LP = not(true(LP)).
> false.
> 
> But indeed nothing to do with Gödel, since (=)/2 in Prolog
> is so called syntactic equality.
> 

Setting the unification default has nothing to do with the assessment of 
whether a Prolog expression is or is not cyclic.
https://www.swi-prolog.org/pldoc/man?section=flags#flag:occurs_check

These three Prolog expressions being tested are not provable BECAUSE 
THEY ARE CYCLIC thus Erroneous:

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

?- unify_with_occurs_check(G, not(provable(F, G))).
false.

and its negation also fails

?- unify_with_occurs_check(G, not(provable(F, not(G)))).
false.

Since the latter pair meet the definition of Incompleteness:
Incomplete(T) ↔ ∃φ ((T ⊬ φ) ∧ (T ⊬ ¬φ))

That proves that they are logically equivalent to the Gödel sentence.

In this case instead of merely knowing that the sentence and its 
negation are unprovable we also know WHY THE SENTENCE AND ITS NEGATION 
ARE UNPROVABLE, THE SENTENCE AND ITS NEGATION ARE ERRONEOUS.

> Peter schrieb am Sonntag, 11. April 2021 um 17:32:13 UTC+2:
>> olcott wrote:
>>> On 4/11/2021 12:50 AM, Jeff Barnett wrote:
>>>> On 4/10/2021 11:12 PM, olcott wrote:
>>>>> On 4/10/2021 11:27 PM, Jeff Barnett wrote:
>>>>>> On 4/10/2021 9:26 PM, olcott wrote:
>>>>>>> On 4/9/2021 6:16 PM, olcott wrote:
>>>>>>>> Clocksin and Mellish says that this fails an occurs check:
>>>>>>>> ?- equal(foo(Y), Y).
>>>>>>>>
>>>>>>>> 254 Chapter 10 The Relation of Prolog to Logic
>>>>>>>> Programming in Prolog Using the ISO Standard Fifth Edition by
>>>>>>>> Clocksin
>>>>>>
>>>>>>>> and Mellish
>>>>>>>>
>>>>>>>>
>>>>>>>> Does that mean that this also fails an occurs check:
>>>>>>>> ?- equal(foo(X,Y), Y).
>>>>>>>>
>>>>>>>
>>>>>>> ?- G = not(provable(F, G)). % G = ¬(F ⊢ G)
>>>>>>> ?- unify_with_occurs_check(G, not(provable(F, G))).
>>>>>>> false.
>>>>>>>
>>>>>>> and its negation also fails
>>>>>>>
>>>>>>> ?- G = not(provable(F, not(G))). % G = ¬(F ⊢ ¬G)
>>>>>>> ?- unify_with_occurs_check(G, not(provable(F, not(G)))).
>>>>>>> false.
>>>>>>>
>>>>>>> Thus meeting this conventional definition of incompleteness:
>>>>>>> Incomplete(T) ↔ ∃φ ((T ⊬ φ) ∧
>>>>
>>>>>> (T ⊬ ¬φ))
>>>>>>>
>>>>>>> Therefore proving equivalence to the actual Gödel sentence.
>>>>>>>
>>>>>>> https://www.researchgate.net/publication/350789898_Prolog_detects_pathological_self_reference_in_the_Godel_sentence
>>>>>>
>>>>>>
>>>>>>
>>>>>>
>>>>>>
>>>>>> Congratulations! You have added Prolog to the list of topics that
>>>>>> you don't really understand. The above reminds me a bit of
>>>>>> Wisenbaum's Eliza. (Also called the Doctor and a direct ancestor of
>>>>>> Perry the Paranoid.) In the above, substitute the word "constipated"
>>>>>> for "provable". Then your result reads:
>>>>>>
>>>>>> "?- unify_with_occurs_check(G, not(constipated(F, not(G))))"
>>>>>>
>>>>>> and that shows exactly nothing to do with anything. So PO now has a
>>>>>> theory of bowel movements but not those TM encodings promised so
>>>>>> long ago. I suggest, to you, that you grab a book on logic and a
>>>>>> bottle of Miralax and get on with it.
>>>>>
>>>>> Jackasses can be naysayers because it doesn't require any knowledge
>>>>> or intelligence.
>>>>>
>>>>> I know that this particular understanding of Prolog is correct on the
>>>>> basis of a whole logic system that I created named Minimal Type Theory.
>>>>
>>>>> This logic system translates expression of its language into directed
>>>>> graphs.
>>>>>
>>>>> As I show in the above paper the logic sentence really is cyclic in
>>>>> both Minimal Type Theory (MTT) and Prolog.
>>>>>
>>>>> Here is the formal YACC grammar for MTT:
>>>>> https://www.researchgate.net/publication/331859461_Minimal_Type_Theory_YACC_BNF
>>>>
>>>>
>>>> What does any of this have to do with my comments? Are you really so
>>>> disassociated with reality? It's mind boggling. Did you try
>>>> substituting "constipated" for "provable"? What did the expert find
>>>> happening? Just curious. When I wrote the above, I began to wonder how
>>>> much Eliza script would be needed to create a PO out of the vacuum. I
>>>> think I might have some old Lisp code lying around; if I can find it,
>>>> maybe I'll try to write that script. Then we can see if anyone can
>>>> tell the difference. It would be a reverse Turing test: see if anyone
>>>> can tell the difference between a duffus and the computer instead of a
>>>> human and a computer. What do you think?
>>>
>>> The verifiable fact is that G = not(provable(F, G)). is indeed not
>>> provable and its negation is G = not(provable(F, not(G))). is not
>>> provable thus meeting the definition of Incompleteness:
>>> Incomplete(T) ↔ ∃φ ((T ⊬ φ) ∧ (T ⊬ ¬φ))
>>>
>>> Because this simplified expression and its negation meet the definition
>>> of incompleteness that proves that they are equivalent to Gödel's actual
>>> logic sentence.
>> Gödel's Bew(x) doesn't say x is provable. It says that x is the Gödel
>> number of a provable formula. It is often asserted that the Gödel
>> formula is
>>
>> I am not provable.
>>
>> It isn't. It can't be. Gödel is concerned with theories of arithmetic
>> and theories of arithmetic are about the natural numbers under addition
>> and multiplication. They are not about formulae and the provability or
>> otherwise of formulae. I have told you this a million times. Will you
>> never get it?
>>>
>>> The analogy between this result and Richard’s antinomy leaps to the eye;
>>> there is also a close relationship with the “liar” antinomy,14 since the
>>> undecidable proposition [R(q); q] states precisely that q belongs to K,
>>> i.e. according to (1), that [R(q); q] is not provable. We are therefore
>>> confronted with a proposition which asserts its own unprovability.15
>>>
>>> 14 Every epistemological antinomy can likewise be used for a similar
>>> undecidability proof. (Gödel:1931:40).
>> Why not quote footnote 15 while you're at it?
>>
>> "Contrary to appearances, such a proposition involves no faulty
>> circularity, for initially it [only] asserts that a certain well-defined
>> formula (namely the one obtained from the qth formula in the
>> lexicographical order by a certain substitution) is unprovable. Only
>> subsequently (and so to speak by chance) does it turn out that this
>> formula is precisely the one by which the proposition was itself expressed."
>>>
>>> The key new knowledge is that we can know why they are not provable
>>> unlike diagonalization which only proves that they are unprovable.
>>>
>>> They are unprovable because they have an infinitely recursive (cyclic)
>>> structure.
>>>
>>> ?- LP = not(true(LP)).
>>> LP = not(true(LP)).
>>>
>>> ?- unify_with_occurs_check(LP, not(true(LP))).
>>> false.
>>>
>>> Godel, Kurt 1931. On Formally Undecidable Propositions of Principia
>>> Mathematica And Related Systems I, page 39-41.
>>>
>>>
>>
>>
>> --
>> Just as 'beautiful' points the way for aesthetics and 'good' for ethics,
>> so do words like 'true' for logic. All sciences have truth as their
>> goal; but logic is also concerned with it in a quite different way:
>> logic has much the same relation to truth as physics has to weight or
>> heat. Frege in 'Thoughts' (Der Gedanke)


-- 
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre 
minds." Einstein

[toc] | [prev] | [next] | [standalone]


#11808 — Re: Simplified Gödel sentence fails Prolog occurs check---> ?- G = not(provable(F, G)).

Fromolcott <NoOne@NoWhere.com>
Date2021-04-11 14:34 -0500
SubjectRe: Simplified Gödel sentence fails Prolog occurs check---> ?- G = not(provable(F, G)).
Message-ID<Zv6dnW-lOaem0u79nZ2dnUU7-X-dnZ2d@giganews.com>
In reply to#11805
On 4/11/2021 11:08 AM, Mostowski Collapse wrote:
> Olcott misused Prolog. The outcome of LP = not(true(LP))
> depends on the occurs check flag.
> 
> /* SWI-Prolog 8.3.21 */
> ?- set_prolog_flag(occurs_check, false).
> true.
> 
> ?- LP = not(true(LP)).
> LP = not(true(LP)).
> 
> ?- set_prolog_flag(occurs_check, true).
> true.
> 
> ?- LP = not(true(LP)).
> false.
> 
> But indeed nothing to do with Gödel, since (=)/2 in Prolog
> is so called syntactic equality.
> 

Setting the unification default has nothing to do with the assessment of 
whether a Prolog expression is or is not cyclic.
https://www.swi-prolog.org/pldoc/man?section=flags#flag:occurs_check

These three Prolog expressions being tested are not provable BECAUSE 
THEY ARE CYCLIC thus Erroneous:

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

?- unify_with_occurs_check(G, not(provable(F, G))).
false.

and its negation also fails

?- unify_with_occurs_check(G, not(provable(F, not(G)))).
false.

Since the latter pair meet the definition of Incompleteness:
Incomplete(T) ↔ ∃φ ((T ⊬ φ) ∧ (T ⊬ ¬φ))

That proves that they are logically equivalent to the Gödel sentence.

In this case instead of merely knowing that the sentence and its 
negation are unprovable we also know WHY THE SENTENCE AND ITS NEGATION 
ARE UNPROVABLE, THE SENTENCE AND ITS NEGATION ARE ERRONEOUS.


> Peter schrieb am Sonntag, 11. April 2021 um 17:32:13 UTC+2:
>> olcott wrote:
>>> On 4/11/2021 12:50 AM, Jeff Barnett wrote:
>>>> On 4/10/2021 11:12 PM, olcott wrote:
>>>>> On 4/10/2021 11:27 PM, Jeff Barnett wrote:
>>>>>> On 4/10/2021 9:26 PM, olcott wrote:
>>>>>>> On 4/9/2021 6:16 PM, olcott wrote:
>>>>>>>> Clocksin and Mellish says that this fails an occurs check:
>>>>>>>> ?- equal(foo(Y), Y).
>>>>>>>>
>>>>>>>> 254 Chapter 10 The Relation of Prolog to Logic
>>>>>>>> Programming in Prolog Using the ISO Standard Fifth Edition by
>>>>>>>> Clocksin
>>>>>>
>>>>>>>> and Mellish
>>>>>>>>
>>>>>>>>
>>>>>>>> Does that mean that this also fails an occurs check:
>>>>>>>> ?- equal(foo(X,Y), Y).
>>>>>>>>
>>>>>>>
>>>>>>> ?- G = not(provable(F, G)). % G = ¬(F ⊢ G)
>>>>>>> ?- unify_with_occurs_check(G, not(provable(F, G))).
>>>>>>> false.
>>>>>>>
>>>>>>> and its negation also fails
>>>>>>>
>>>>>>> ?- G = not(provable(F, not(G))). % G = ¬(F ⊢ ¬G)
>>>>>>> ?- unify_with_occurs_check(G, not(provable(F, not(G)))).
>>>>>>> false.
>>>>>>>
>>>>>>> Thus meeting this conventional definition of incompleteness:
>>>>>>> Incomplete(T) ↔ ∃φ ((T ⊬ φ) ∧
>>>>
>>>>>> (T ⊬ ¬φ))
>>>>>>>
>>>>>>> Therefore proving equivalence to the actual Gödel sentence.
>>>>>>>
>>>>>>> https://www.researchgate.net/publication/350789898_Prolog_detects_pathological_self_reference_in_the_Godel_sentence
>>>>>>
>>>>>>
>>>>>>
>>>>>>
>>>>>>
>>>>>> Congratulations! You have added Prolog to the list of topics that
>>>>>> you don't really understand. The above reminds me a bit of
>>>>>> Wisenbaum's Eliza. (Also called the Doctor and a direct ancestor of
>>>>>> Perry the Paranoid.) In the above, substitute the word "constipated"
>>>>>> for "provable". Then your result reads:
>>>>>>
>>>>>> "?- unify_with_occurs_check(G, not(constipated(F, not(G))))"
>>>>>>
>>>>>> and that shows exactly nothing to do with anything. So PO now has a
>>>>>> theory of bowel movements but not those TM encodings promised so
>>>>>> long ago. I suggest, to you, that you grab a book on logic and a
>>>>>> bottle of Miralax and get on with it.
>>>>>
>>>>> Jackasses can be naysayers because it doesn't require any knowledge
>>>>> or intelligence.
>>>>>
>>>>> I know that this particular understanding of Prolog is correct on the
>>>>> basis of a whole logic system that I created named Minimal Type Theory.
>>>>
>>>>> This logic system translates expression of its language into directed
>>>>> graphs.
>>>>>
>>>>> As I show in the above paper the logic sentence really is cyclic in
>>>>> both Minimal Type Theory (MTT) and Prolog.
>>>>>
>>>>> Here is the formal YACC grammar for MTT:
>>>>> https://www.researchgate.net/publication/331859461_Minimal_Type_Theory_YACC_BNF
>>>>
>>>>
>>>> What does any of this have to do with my comments? Are you really so
>>>> disassociated with reality? It's mind boggling. Did you try
>>>> substituting "constipated" for "provable"? What did the expert find
>>>> happening? Just curious. When I wrote the above, I began to wonder how
>>>> much Eliza script would be needed to create a PO out of the vacuum. I
>>>> think I might have some old Lisp code lying around; if I can find it,
>>>> maybe I'll try to write that script. Then we can see if anyone can
>>>> tell the difference. It would be a reverse Turing test: see if anyone
>>>> can tell the difference between a duffus and the computer instead of a
>>>> human and a computer. What do you think?
>>>
>>> The verifiable fact is that G = not(provable(F, G)). is indeed not
>>> provable and its negation is G = not(provable(F, not(G))). is not
>>> provable thus meeting the definition of Incompleteness:
>>> Incomplete(T) ↔ ∃φ ((T ⊬ φ) ∧ (T ⊬ ¬φ))
>>>
>>> Because this simplified expression and its negation meet the definition
>>> of incompleteness that proves that they are equivalent to Gödel's actual
>>> logic sentence.
>> Gödel's Bew(x) doesn't say x is provable. It says that x is the Gödel
>> number of a provable formula. It is often asserted that the Gödel
>> formula is
>>
>> I am not provable.
>>
>> It isn't. It can't be. Gödel is concerned with theories of arithmetic
>> and theories of arithmetic are about the natural numbers under addition
>> and multiplication. They are not about formulae and the provability or
>> otherwise of formulae. I have told you this a million times. Will you
>> never get it?
>>>
>>> The analogy between this result and Richard’s antinomy leaps to the eye;
>>> there is also a close relationship with the “liar” antinomy,14 since the
>>> undecidable proposition [R(q); q] states precisely that q belongs to K,
>>> i.e. according to (1), that [R(q); q] is not provable. We are therefore
>>> confronted with a proposition which asserts its own unprovability.15
>>>
>>> 14 Every epistemological antinomy can likewise be used for a similar
>>> undecidability proof. (Gödel:1931:40).
>> Why not quote footnote 15 while you're at it?
>>
>> "Contrary to appearances, such a proposition involves no faulty
>> circularity, for initially it [only] asserts that a certain well-defined
>> formula (namely the one obtained from the qth formula in the
>> lexicographical order by a certain substitution) is unprovable. Only
>> subsequently (and so to speak by chance) does it turn out that this
>> formula is precisely the one by which the proposition was itself expressed."
>>>
>>> The key new knowledge is that we can know why they are not provable
>>> unlike diagonalization which only proves that they are unprovable.
>>>
>>> They are unprovable because they have an infinitely recursive (cyclic)
>>> structure.
>>>
>>> ?- LP = not(true(LP)).
>>> LP = not(true(LP)).
>>>
>>> ?- unify_with_occurs_check(LP, not(true(LP))).
>>> false.
>>>
>>> Godel, Kurt 1931. On Formally Undecidable Propositions of Principia
>>> Mathematica And Related Systems I, page 39-41.
>>>
>>>
>>
>>
>> --
>> Just as 'beautiful' points the way for aesthetics and 'good' for ethics,
>> so do words like 'true' for logic. All sciences have truth as their
>> goal; but logic is also concerned with it in a quite different way:
>> logic has much the same relation to truth as physics has to weight or
>> heat. Frege in 'Thoughts' (Der Gedanke)


-- 
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre 
minds." Einstein

[toc] | [prev] | [next] | [standalone]


#11809 — Re: Simplified Gödel sentence fails Prolog occurs check---> ?- G = not(provable(F, G)).

FromMostowski Collapse <bursejan@gmail.com>
Date2021-04-11 12:54 -0700
SubjectRe: Simplified Gödel sentence fails Prolog occurs check---> ?- G = not(provable(F, G)).
Message-ID<0221db30-a45f-4f96-9194-77598d8c1629n@googlegroups.com>
In reply to#11808
I guess you are highly confused and never understood Prolog
when you write the following:

> and its negation also fails
> ?- unify_with_occurs_check(G, not(provable(F, not(G)))).
> false. 

not(provable(F, not(G))) is just a syntax term tree:

                       not
                         |
                  provable
                   /        \
               F           not
                              |
                            G

What fails is not the negation. No negation is semantically
taken of anything. All that fails is syntactic unification,

the only predication that was invoked was unify_with_occurs_check/2.
No predication not/1 or provable/2 was invoked.

The unification fails, because the result of binding G to
the syntax term tree not(provable(F, not(G))) would result

in a loop, and the syntax term would not anymore be a tree:
                
                         v--------+
                       not          |
                         |            |
                  provable    |
                   /        \        |
               F           not    |
                              |        |
                            G         |
                             +-------+

olcott schrieb am Sonntag, 11. April 2021 um 21:34:25 UTC+2:
> On 4/11/2021 11:08 AM, Mostowski Collapse wrote: 
> > Olcott misused Prolog. The outcome of LP = not(true(LP)) 
> > depends on the occurs check flag. 
> > 
> > /* SWI-Prolog 8.3.21 */ 
> > ?- set_prolog_flag(occurs_check, false). 
> > true. 
> >
> > ?- LP = not(true(LP)). 
> > LP = not(true(LP)). 
> >
> > ?- set_prolog_flag(occurs_check, true). 
> > true. 
> > 
> > ?- LP = not(true(LP)). 
> > false. 
> > 
> > But indeed nothing to do with Gödel, since (=)/2 in Prolog 
> > is so called syntactic equality. 
> > 
> 
> Setting the unification default has nothing to do with the assessment of 
> whether a Prolog expression is or is not cyclic. 
> https://www.swi-prolog.org/pldoc/man?section=flags#flag:occurs_check 
> 
> These three Prolog expressions being tested are not provable BECAUSE 
> THEY ARE CYCLIC thus Erroneous: 
> 
> ?- unify_with_occurs_check(LP, not(true(LP))). 
> false.
> ?- unify_with_occurs_check(G, not(provable(F, G))). 
> false. 
> 
> and its negation also fails
> ?- unify_with_occurs_check(G, not(provable(F, not(G)))). 
> false.
> Since the latter pair meet the definition of Incompleteness:
> Incomplete(T) ↔ ∃φ ((T ⊬ φ) ∧ (T ⊬ ¬φ))
> That proves that they are logically equivalent to the Gödel sentence. 
> 
> In this case instead of merely knowing that the sentence and its 
> negation are unprovable we also know WHY THE SENTENCE AND ITS NEGATION 
> ARE UNPROVABLE, THE SENTENCE AND ITS NEGATION ARE ERRONEOUS. 
> 
> 
> > Peter schrieb am Sonntag, 11. April 2021 um 17:32:13 UTC+2: 
> >> olcott wrote:
> >>> On 4/11/2021 12:50 AM, Jeff Barnett wrote: 
> >>>> On 4/10/2021 11:12 PM, olcott wrote: 
> >>>>> On 4/10/2021 11:27 PM, Jeff Barnett wrote: 
> >>>>>> On 4/10/2021 9:26 PM, olcott wrote: 
> >>>>>>> On 4/9/2021 6:16 PM, olcott wrote: 
> >>>>>>>> Clocksin and Mellish says that this fails an occurs check: 
> >>>>>>>> ?- equal(foo(Y), Y). 
> >>>>>>>> 
> >>>>>>>> 254 Chapter 10 The Relation of Prolog to Logic 
> >>>>>>>> Programming in Prolog Using the ISO Standard Fifth Edition by 
> >>>>>>>> Clocksin 
> >>>>>> 
> >>>>>>>> and Mellish 
> >>>>>>>> 
> >>>>>>>> 
> >>>>>>>> Does that mean that this also fails an occurs check: 
> >>>>>>>> ?- equal(foo(X,Y), Y). 
> >>>>>>>> 
> >>>>>>> 
> >>>>>>> ?- G = not(provable(F, G)). % G = ¬(F ⊢ G) 
> >>>>>>> ?- unify_with_occurs_check(G, not(provable(F, G))). 
> >>>>>>> false. 
> >>>>>>> 
> >>>>>>> and its negation also fails 
> >>>>>>> 
> >>>>>>> ?- G = not(provable(F, not(G))). % G = ¬(F ⊢ ¬G) 
> >>>>>>> ?- unify_with_occurs_check(G, not(provable(F, not(G)))). 
> >>>>>>> false. 
> >>>>>>> 
> >>>>>>> Thus meeting this conventional definition of incompleteness: 
> >>>>>>> Incomplete(T) ↔ ∃φ ((T ⊬ φ) ∧ 
> >>>> 
> >>>>>> (T ⊬ ¬φ)) 
> >>>>>>> 
> >>>>>>> Therefore proving equivalence to the actual Gödel sentence. 
> >>>>>>> 
> >>>>>>> https://www.researchgate.net/publication/350789898_Prolog_detects_pathological_self_reference_in_the_Godel_sentence 
> >>>>>> 
> >>>>>> 
> >>>>>> 
> >>>>>> 
> >>>>>> 
> >>>>>> Congratulations! You have added Prolog to the list of topics that 
> >>>>>> you don't really understand. The above reminds me a bit of 
> >>>>>> Wisenbaum's Eliza. (Also called the Doctor and a direct ancestor of 
> >>>>>> Perry the Paranoid.) In the above, substitute the word "constipated" 
> >>>>>> for "provable". Then your result reads: 
> >>>>>> 
> >>>>>> "?- unify_with_occurs_check(G, not(constipated(F, not(G))))" 
> >>>>>> 
> >>>>>> and that shows exactly nothing to do with anything. So PO now has a 
> >>>>>> theory of bowel movements but not those TM encodings promised so 
> >>>>>> long ago. I suggest, to you, that you grab a book on logic and a 
> >>>>>> bottle of Miralax and get on with it. 
> >>>>> 
> >>>>> Jackasses can be naysayers because it doesn't require any knowledge 
> >>>>> or intelligence. 
> >>>>> 
> >>>>> I know that this particular understanding of Prolog is correct on the 
> >>>>> basis of a whole logic system that I created named Minimal Type Theory. 
> >>>> 
> >>>>> This logic system translates expression of its language into directed 
> >>>>> graphs. 
> >>>>> 
> >>>>> As I show in the above paper the logic sentence really is cyclic in 
> >>>>> both Minimal Type Theory (MTT) and Prolog. 
> >>>>> 
> >>>>> Here is the formal YACC grammar for MTT: 
> >>>>> https://www.researchgate.net/publication/331859461_Minimal_Type_Theory_YACC_BNF 
> >>>> 
> >>>> 
> >>>> What does any of this have to do with my comments? Are you really so 
> >>>> disassociated with reality? It's mind boggling. Did you try 
> >>>> substituting "constipated" for "provable"? What did the expert find 
> >>>> happening? Just curious. When I wrote the above, I began to wonder how 
> >>>> much Eliza script would be needed to create a PO out of the vacuum. I 
> >>>> think I might have some old Lisp code lying around; if I can find it, 
> >>>> maybe I'll try to write that script. Then we can see if anyone can 
> >>>> tell the difference. It would be a reverse Turing test: see if anyone 
> >>>> can tell the difference between a duffus and the computer instead of a 
> >>>> human and a computer. What do you think? 
> >>> 
> >>> The verifiable fact is that G = not(provable(F, G)). is indeed not 
> >>> provable and its negation is G = not(provable(F, not(G))). is not 
> >>> provable thus meeting the definition of Incompleteness: 
> >>> Incomplete(T) ↔ ∃φ ((T ⊬ φ) ∧ (T ⊬ ¬φ)) 
> >>> 
> >>> Because this simplified expression and its negation meet the definition 
> >>> of incompleteness that proves that they are equivalent to Gödel's actual 
> >>> logic sentence.
> >> Gödel's Bew(x) doesn't say x is provable. It says that x is the Gödel 
> >> number of a provable formula. It is often asserted that the Gödel 
> >> formula is 
> >> 
> >> I am not provable. 
> >> 
> >> It isn't. It can't be. Gödel is concerned with theories of arithmetic 
> >> and theories of arithmetic are about the natural numbers under addition 
> >> and multiplication. They are not about formulae and the provability or 
> >> otherwise of formulae. I have told you this a million times. Will you 
> >> never get it? 
> >>>
> >>> The analogy between this result and Richard’s antinomy leaps to the eye; 
> >>> there is also a close relationship with the “liar” antinomy,14 since the 
> >>> undecidable proposition [R(q); q] states precisely that q belongs to K, 
> >>> i.e. according to (1), that [R(q); q] is not provable. We are therefore 
> >>> confronted with a proposition which asserts its own unprovability.15 
> >>> 
> >>> 14 Every epistemological antinomy can likewise be used for a similar 
> >>> undecidability proof. (Gödel:1931:40).
> >> Why not quote footnote 15 while you're at it? 
> >> 
> >> "Contrary to appearances, such a proposition involves no faulty 
> >> circularity, for initially it [only] asserts that a certain well-defined 
> >> formula (namely the one obtained from the qth formula in the 
> >> lexicographical order by a certain substitution) is unprovable. Only 
> >> subsequently (and so to speak by chance) does it turn out that this 
> >> formula is precisely the one by which the proposition was itself expressed." 
> >>>
> >>> The key new knowledge is that we can know why they are not provable 
> >>> unlike diagonalization which only proves that they are unprovable. 
> >>> 
> >>> They are unprovable because they have an infinitely recursive (cyclic) 
> >>> structure. 
> >>> 
> >>> ?- LP = not(true(LP)). 
> >>> LP = not(true(LP)). 
> >>> 
> >>> ?- unify_with_occurs_check(LP, not(true(LP))). 
> >>> false. 
> >>> 
> >>> Godel, Kurt 1931. On Formally Undecidable Propositions of Principia 
> >>> Mathematica And Related Systems I, page 39-41. 
> >>> 
> >>> 
> >> 
> >> 
> >> --
> >> Just as 'beautiful' points the way for aesthetics and 'good' for ethics, 
> >> so do words like 'true' for logic. All sciences have truth as their 
> >> goal; but logic is also concerned with it in a quite different way: 
> >> logic has much the same relation to truth as physics has to weight or 
> >> heat. Frege in 'Thoughts' (Der Gedanke)
> -- 
> Copyright 2021 Pete Olcott 
> 
> "Great spirits have always encountered violent opposition from mediocre 
> minds." Einstein

[toc] | [prev] | [next] | [standalone]


#11810 — Re: Simplified Gödel sentence fails Prolog occurs check---> ?- G = not(provable(F, G)).

Fromolcott <NoOne@NoWhere.com>
Date2021-04-11 15:31 -0500
SubjectRe: Simplified Gödel sentence fails Prolog occurs check---> ?- G = not(provable(F, G)).
Message-ID<8OWdnauTLYEKwe79nZ2dnUU7-RXNnZ2d@giganews.com>
In reply to#11809
On 4/11/2021 2:54 PM, Mostowski Collapse wrote:
> I guess you are highly confused and never understood Prolog
> when you write the following:
> 
>> and its negation also fails
>> ?- unify_with_occurs_check(G, not(provable(F, not(G)))).
>> false.
> 
> not(provable(F, not(G))) is just a syntax term tree:
> 
>                         not
>                           |
>                    provable
>                     /        \
>                 F           not
>                                |
>                              G
> 
> What fails is not the negation. No negation is semantically
> taken of anything. All that fails is syntactic unification,
> 
> the only predication that was invoked was unify_with_occurs_check/2.
> No predication not/1 or provable/2 was invoked.
> 
> The unification fails, because the result of binding G to
> the syntax term tree not(provable(F, not(G))) would result
> 
> in a loop, and the syntax term would not anymore be a tree:
>                  
>                           v--------+
>                         not        |
>                           |        |
>                    provable        |
>                     /      \       |
>                    F       not     |
>                              |     |
>                              G     |
>                              +-----+
> 

Yes very good you understand it completely. I show this same thing on 
page (3) of my paper.

https://www.researchgate.net/publication/350789898_Prolog_detects_pathological_self_reference_in_the_Godel_sentence 


It cannot even be evaluated for provability because it has a cycle in 
its syntactic specification.

?- G = not(provable(F, G)).

Since it cannot even be evaluated for provability because of this cycle 
we can know that it is it neither provable nor disprovable because the 
process of provability or disprovability cannot even begin.

Since the expression can neither be proven nor disproven it exactly 
meets the conventional definition of Incompleteness:
Incomplete(T) ↔ ∃φ ((T ⊬ φ) ∧ (T ⊬ ¬φ))

This proves that the conventional definition of incompleteness decides 
that a formal system is incomplete on the basis that this formal system 
cannot prove erroneous expressions of a formal language.

The 1931 Gödel Incompleteness theorem proving that formal systems of 
arithmetic are incomplete is anchored faulty definition of 
"incompleteness".


> olcott schrieb am Sonntag, 11. April 2021 um 21:34:25 UTC+2:
>> On 4/11/2021 11:08 AM, Mostowski Collapse wrote:
>>> Olcott misused Prolog. The outcome of LP = not(true(LP))
>>> depends on the occurs check flag.
>>>
>>> /* SWI-Prolog 8.3.21 */
>>> ?- set_prolog_flag(occurs_check, false).
>>> true.
>>>
>>> ?- LP = not(true(LP)).
>>> LP = not(true(LP)).
>>>
>>> ?- set_prolog_flag(occurs_check, true).
>>> true.
>>>
>>> ?- LP = not(true(LP)).
>>> false.
>>>
>>> But indeed nothing to do with Gödel, since (=)/2 in Prolog
>>> is so called syntactic equality.
>>>
>>
>> Setting the unification default has nothing to do with the assessment of
>> whether a Prolog expression is or is not cyclic.
>> https://www.swi-prolog.org/pldoc/man?section=flags#flag:occurs_check
>>
>> These three Prolog expressions being tested are not provable BECAUSE
>> THEY ARE CYCLIC thus Erroneous:
>>
>> ?- unify_with_occurs_check(LP, not(true(LP))).
>> false.
>> ?- unify_with_occurs_check(G, not(provable(F, G))).
>> false.
>>
>> and its negation also fails
>> ?- unify_with_occurs_check(G, not(provable(F, not(G)))).
>> false.
>> Since the latter pair meet the definition of Incompleteness:
>> Incomplete(T) ↔ ∃φ ((T ⊬ φ) ∧ (T ⊬ ¬φ))
>> That proves that they are logically equivalent to the Gödel sentence.
>>
>> In this case instead of merely knowing that the sentence and its
>> negation are unprovable we also know WHY THE SENTENCE AND ITS NEGATION
>> ARE UNPROVABLE, THE SENTENCE AND ITS NEGATION ARE ERRONEOUS.
>>
>>
>>> Peter schrieb am Sonntag, 11. April 2021 um 17:32:13 UTC+2:
>>>> olcott wrote:
>>>>> On 4/11/2021 12:50 AM, Jeff Barnett wrote:
>>>>>> On 4/10/2021 11:12 PM, olcott wrote:
>>>>>>> On 4/10/2021 11:27 PM, Jeff Barnett wrote:
>>>>>>>> On 4/10/2021 9:26 PM, olcott wrote:
>>>>>>>>> On 4/9/2021 6:16 PM, olcott wrote:
>>>>>>>>>> Clocksin and Mellish says that this fails an occurs check:
>>>>>>>>>> ?- equal(foo(Y), Y).
>>>>>>>>>>
>>>>>>>>>> 254 Chapter 10 The Relation of Prolog to Logic
>>>>>>>>>> Programming in Prolog Using the ISO Standard Fifth Edition by
>>>>>>>>>> Clocksin
>>>>>>>>
>>>>>>>>>> and Mellish
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Does that mean that this also fails an occurs check:
>>>>>>>>>> ?- equal(foo(X,Y), Y).
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> ?- G = not(provable(F, G)). % G = ¬(F ⊢ G)
>>>>>>>>> ?- unify_with_occurs_check(G, not(provable(F, G))).
>>>>>>>>> false.
>>>>>>>>>
>>>>>>>>> and its negation also fails
>>>>>>>>>
>>>>>>>>> ?- G = not(provable(F, not(G))). % G = ¬(F ⊢ ¬G)
>>>>>>>>> ?- unify_with_occurs_check(G, not(provable(F, not(G)))).
>>>>>>>>> false.
>>>>>>>>>
>>>>>>>>> Thus meeting this conventional definition of incompleteness:
>>>>>>>>> Incomplete(T) ↔ ∃φ ((T ⊬ φ) ∧
>>>>>>
>>>>>>>> (T ⊬ ¬φ))
>>>>>>>>>
>>>>>>>>> Therefore proving equivalence to the actual Gödel sentence.
>>>>>>>>>
>>>>>>>>> https://www.researchgate.net/publication/350789898_Prolog_detects_pathological_self_reference_in_the_Godel_sentence
>>>>>>>>
>>>>>>>>
>>>>>>>>
>>>>>>>>
>>>>>>>>
>>>>>>>> Congratulations! You have added Prolog to the list of topics that
>>>>>>>> you don't really understand. The above reminds me a bit of
>>>>>>>> Wisenbaum's Eliza. (Also called the Doctor and a direct ancestor of
>>>>>>>> Perry the Paranoid.) In the above, substitute the word "constipated"
>>>>>>>> for "provable". Then your result reads:
>>>>>>>>
>>>>>>>> "?- unify_with_occurs_check(G, not(constipated(F, not(G))))"
>>>>>>>>
>>>>>>>> and that shows exactly nothing to do with anything. So PO now has a
>>>>>>>> theory of bowel movements but not those TM encodings promised so
>>>>>>>> long ago. I suggest, to you, that you grab a book on logic and a
>>>>>>>> bottle of Miralax and get on with it.
>>>>>>>
>>>>>>> Jackasses can be naysayers because it doesn't require any knowledge
>>>>>>> or intelligence.
>>>>>>>
>>>>>>> I know that this particular understanding of Prolog is correct on the
>>>>>>> basis of a whole logic system that I created named Minimal Type Theory.
>>>>>>
>>>>>>> This logic system translates expression of its language into directed
>>>>>>> graphs.
>>>>>>>
>>>>>>> As I show in the above paper the logic sentence really is cyclic in
>>>>>>> both Minimal Type Theory (MTT) and Prolog.
>>>>>>>
>>>>>>> Here is the formal YACC grammar for MTT:
>>>>>>> https://www.researchgate.net/publication/331859461_Minimal_Type_Theory_YACC_BNF
>>>>>>
>>>>>>
>>>>>> What does any of this have to do with my comments? Are you really so
>>>>>> disassociated with reality? It's mind boggling. Did you try
>>>>>> substituting "constipated" for "provable"? What did the expert find
>>>>>> happening? Just curious. When I wrote the above, I began to wonder how
>>>>>> much Eliza script would be needed to create a PO out of the vacuum. I
>>>>>> think I might have some old Lisp code lying around; if I can find it,
>>>>>> maybe I'll try to write that script. Then we can see if anyone can
>>>>>> tell the difference. It would be a reverse Turing test: see if anyone
>>>>>> can tell the difference between a duffus and the computer instead of a
>>>>>> human and a computer. What do you think?
>>>>>
>>>>> The verifiable fact is that G = not(provable(F, G)). is indeed not
>>>>> provable and its negation is G = not(provable(F, not(G))). is not
>>>>> provable thus meeting the definition of Incompleteness:
>>>>> Incomplete(T) ↔ ∃φ ((T ⊬ φ) ∧ (T ⊬ ¬φ))
>>>>>
>>>>> Because this simplified expression and its negation meet the definition
>>>>> of incompleteness that proves that they are equivalent to Gödel's actual
>>>>> logic sentence.
>>>> Gödel's Bew(x) doesn't say x is provable. It says that x is the Gödel
>>>> number of a provable formula. It is often asserted that the Gödel
>>>> formula is
>>>>
>>>> I am not provable.
>>>>
>>>> It isn't. It can't be. Gödel is concerned with theories of arithmetic
>>>> and theories of arithmetic are about the natural numbers under addition
>>>> and multiplication. They are not about formulae and the provability or
>>>> otherwise of formulae. I have told you this a million times. Will you
>>>> never get it?
>>>>>
>>>>> The analogy between this result and Richard’s antinomy leaps to the eye;
>>>>> there is also a close relationship with the “liar” antinomy,14 since the
>>>>> undecidable proposition [R(q); q] states precisely that q belongs to K,
>>>>> i.e. according to (1), that [R(q); q] is not provable. We are therefore
>>>>> confronted with a proposition which asserts its own unprovability.15
>>>>>
>>>>> 14 Every epistemological antinomy can likewise be used for a similar
>>>>> undecidability proof. (Gödel:1931:40).
>>>> Why not quote footnote 15 while you're at it?
>>>>
>>>> "Contrary to appearances, such a proposition involves no faulty
>>>> circularity, for initially it [only] asserts that a certain well-defined
>>>> formula (namely the one obtained from the qth formula in the
>>>> lexicographical order by a certain substitution) is unprovable. Only
>>>> subsequently (and so to speak by chance) does it turn out that this
>>>> formula is precisely the one by which the proposition was itself expressed."
>>>>>
>>>>> The key new knowledge is that we can know why they are not provable
>>>>> unlike diagonalization which only proves that they are unprovable.
>>>>>
>>>>> They are unprovable because they have an infinitely recursive (cyclic)
>>>>> structure.
>>>>>
>>>>> ?- LP = not(true(LP)).
>>>>> LP = not(true(LP)).
>>>>>
>>>>> ?- unify_with_occurs_check(LP, not(true(LP))).
>>>>> false.
>>>>>
>>>>> Godel, Kurt 1931. On Formally Undecidable Propositions of Principia
>>>>> Mathematica And Related Systems I, page 39-41.
>>>>>
>>>>>
>>>>
>>>>
>>>> --
>>>> Just as 'beautiful' points the way for aesthetics and 'good' for ethics,
>>>> so do words like 'true' for logic. All sciences have truth as their
>>>> goal; but logic is also concerned with it in a quite different way:
>>>> logic has much the same relation to truth as physics has to weight or
>>>> heat. Frege in 'Thoughts' (Der Gedanke)
>> -- 
>> Copyright 2021 Pete Olcott
>>
>> "Great spirits have always encountered violent opposition from mediocre
>> minds." Einstein


-- 
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre 
minds." Einstein

[toc] | [prev] | [next] | [standalone]


#11811 — Re: Simplified Gödel sentence fails Prolog occurs check---> ?- G = not(provable(F, G)).

FromMostowski Collapse <bursejan@gmail.com>
Date2021-04-11 15:39 -0700
SubjectRe: Simplified Gödel sentence fails Prolog occurs check---> ?- G = not(provable(F, G)).
Message-ID<e36d06d4-81a0-4d95-a7af-30ce1723dafbn@googlegroups.com>
In reply to#11810
Its not an undecidable sentence you moron. (=)/2 is 
decidable in Prolog. Just try this you moron:

?- set_prolog_flag(occurs_check, true).

?- dif(G, not(provable(F, not(G)))). 
true

olcott schrieb am Sonntag, 11. April 2021 um 22:31:26 UTC+2:
> On 4/11/2021 2:54 PM, Mostowski Collapse wrote: 
> > I guess you are highly confused and never understood Prolog 
> > when you write the following: 
> > 
> >> and its negation also fails 
> >> ?- unify_with_occurs_check(G, not(provable(F, not(G)))). 
> >> false. 
> > 
> > not(provable(F, not(G))) is just a syntax term tree: 
> > 
> > not 
> > | 
> > provable 
> > / \ 
> > F not 
> > | 
> > G 
> > 
> > What fails is not the negation. No negation is semantically 
> > taken of anything. All that fails is syntactic unification, 
> > 
> > the only predication that was invoked was unify_with_occurs_check/2. 
> > No predication not/1 or provable/2 was invoked. 
> > 
> > The unification fails, because the result of binding G to 
> > the syntax term tree not(provable(F, not(G))) would result 
> > 
> > in a loop, and the syntax term would not anymore be a tree: 
> > 
> > v--------+ 
> > not | 
> > | | 
> > provable | 
> > / \ | 
> > F not | 
> > | | 
> > G |
> > +-----+ 
> > 
> 
> Yes very good you understand it completely. I show this same thing on 
> page (3) of my paper. 
> 
> https://www.researchgate.net/publication/350789898_Prolog_detects_pathological_self_reference_in_the_Godel_sentence 
> 
> 
> It cannot even be evaluated for provability because it has a cycle in 
> its syntactic specification.
> ?- G = not(provable(F, G)).
> Since it cannot even be evaluated for provability because of this cycle 
> we can know that it is it neither provable nor disprovable because the 
> process of provability or disprovability cannot even begin. 
> 
> Since the expression can neither be proven nor disproven it exactly 
> meets the conventional definition of Incompleteness:
> Incomplete(T) ↔ ∃φ ((T ⊬ φ) ∧ (T ⊬ ¬φ))
> This proves that the conventional definition of incompleteness decides 
> that a formal system is incomplete on the basis that this formal system 
> cannot prove erroneous expressions of a formal language. 
> 
> The 1931 Gödel Incompleteness theorem proving that formal systems of 
> arithmetic are incomplete is anchored faulty definition of 
> "incompleteness".
> > olcott schrieb am Sonntag, 11. April 2021 um 21:34:25 UTC+2: 
> >> On 4/11/2021 11:08 AM, Mostowski Collapse wrote: 
> >>> Olcott misused Prolog. The outcome of LP = not(true(LP)) 
> >>> depends on the occurs check flag. 
> >>> 
> >>> /* SWI-Prolog 8.3.21 */ 
> >>> ?- set_prolog_flag(occurs_check, false). 
> >>> true. 
> >>> 
> >>> ?- LP = not(true(LP)). 
> >>> LP = not(true(LP)). 
> >>> 
> >>> ?- set_prolog_flag(occurs_check, true). 
> >>> true. 
> >>> 
> >>> ?- LP = not(true(LP)). 
> >>> false. 
> >>> 
> >>> But indeed nothing to do with Gödel, since (=)/2 in Prolog 
> >>> is so called syntactic equality. 
> >>> 
> >> 
> >> Setting the unification default has nothing to do with the assessment of 
> >> whether a Prolog expression is or is not cyclic. 
> >> https://www.swi-prolog.org/pldoc/man?section=flags#flag:occurs_check 
> >> 
> >> These three Prolog expressions being tested are not provable BECAUSE 
> >> THEY ARE CYCLIC thus Erroneous: 
> >> 
> >> ?- unify_with_occurs_check(LP, not(true(LP))). 
> >> false. 
> >> ?- unify_with_occurs_check(G, not(provable(F, G))). 
> >> false. 
> >> 
> >> and its negation also fails 
> >> ?- unify_with_occurs_check(G, not(provable(F, not(G)))). 
> >> false. 
> >> Since the latter pair meet the definition of Incompleteness: 
> >> Incomplete(T) ↔ ∃φ ((T ⊬ φ) ∧ (T ⊬ ¬φ)) 
> >> That proves that they are logically equivalent to the Gödel sentence. 
> >> 
> >> In this case instead of merely knowing that the sentence and its 
> >> negation are unprovable we also know WHY THE SENTENCE AND ITS NEGATION 
> >> ARE UNPROVABLE, THE SENTENCE AND ITS NEGATION ARE ERRONEOUS. 
> >> 
> >> 
> >>> Peter schrieb am Sonntag, 11. April 2021 um 17:32:13 UTC+2: 
> >>>> olcott wrote: 
> >>>>> On 4/11/2021 12:50 AM, Jeff Barnett wrote: 
> >>>>>> On 4/10/2021 11:12 PM, olcott wrote: 
> >>>>>>> On 4/10/2021 11:27 PM, Jeff Barnett wrote: 
> >>>>>>>> On 4/10/2021 9:26 PM, olcott wrote: 
> >>>>>>>>> On 4/9/2021 6:16 PM, olcott wrote: 
> >>>>>>>>>> Clocksin and Mellish says that this fails an occurs check: 
> >>>>>>>>>> ?- equal(foo(Y), Y). 
> >>>>>>>>>> 
> >>>>>>>>>> 254 Chapter 10 The Relation of Prolog to Logic 
> >>>>>>>>>> Programming in Prolog Using the ISO Standard Fifth Edition by 
> >>>>>>>>>> Clocksin 
> >>>>>>>> 
> >>>>>>>>>> and Mellish 
> >>>>>>>>>> 
> >>>>>>>>>> 
> >>>>>>>>>> Does that mean that this also fails an occurs check: 
> >>>>>>>>>> ?- equal(foo(X,Y), Y). 
> >>>>>>>>>> 
> >>>>>>>>> 
> >>>>>>>>> ?- G = not(provable(F, G)). % G = ¬(F ⊢ G) 
> >>>>>>>>> ?- unify_with_occurs_check(G, not(provable(F, G))). 
> >>>>>>>>> false. 
> >>>>>>>>> 
> >>>>>>>>> and its negation also fails 
> >>>>>>>>> 
> >>>>>>>>> ?- G = not(provable(F, not(G))). % G = ¬(F ⊢ ¬G) 
> >>>>>>>>> ?- unify_with_occurs_check(G, not(provable(F, not(G)))). 
> >>>>>>>>> false. 
> >>>>>>>>> 
> >>>>>>>>> Thus meeting this conventional definition of incompleteness: 
> >>>>>>>>> Incomplete(T) ↔ ∃φ ((T ⊬ φ) ∧ 
> >>>>>> 
> >>>>>>>> (T ⊬ ¬φ)) 
> >>>>>>>>> 
> >>>>>>>>> Therefore proving equivalence to the actual Gödel sentence. 
> >>>>>>>>> 
> >>>>>>>>> https://www.researchgate.net/publication/350789898_Prolog_detects_pathological_self_reference_in_the_Godel_sentence 
> >>>>>>>> 
> >>>>>>>> 
> >>>>>>>> 
> >>>>>>>> 
> >>>>>>>> 
> >>>>>>>> Congratulations! You have added Prolog to the list of topics that 
> >>>>>>>> you don't really understand. The above reminds me a bit of 
> >>>>>>>> Wisenbaum's Eliza. (Also called the Doctor and a direct ancestor of 
> >>>>>>>> Perry the Paranoid.) In the above, substitute the word "constipated" 
> >>>>>>>> for "provable". Then your result reads: 
> >>>>>>>> 
> >>>>>>>> "?- unify_with_occurs_check(G, not(constipated(F, not(G))))" 
> >>>>>>>> 
> >>>>>>>> and that shows exactly nothing to do with anything. So PO now has a 
> >>>>>>>> theory of bowel movements but not those TM encodings promised so 
> >>>>>>>> long ago. I suggest, to you, that you grab a book on logic and a 
> >>>>>>>> bottle of Miralax and get on with it. 
> >>>>>>> 
> >>>>>>> Jackasses can be naysayers because it doesn't require any knowledge 
> >>>>>>> or intelligence. 
> >>>>>>> 
> >>>>>>> I know that this particular understanding of Prolog is correct on the 
> >>>>>>> basis of a whole logic system that I created named Minimal Type Theory. 
> >>>>>> 
> >>>>>>> This logic system translates expression of its language into directed 
> >>>>>>> graphs. 
> >>>>>>> 
> >>>>>>> As I show in the above paper the logic sentence really is cyclic in 
> >>>>>>> both Minimal Type Theory (MTT) and Prolog. 
> >>>>>>> 
> >>>>>>> Here is the formal YACC grammar for MTT: 
> >>>>>>> https://www.researchgate.net/publication/331859461_Minimal_Type_Theory_YACC_BNF 
> >>>>>> 
> >>>>>> 
> >>>>>> What does any of this have to do with my comments? Are you really so 
> >>>>>> disassociated with reality? It's mind boggling. Did you try 
> >>>>>> substituting "constipated" for "provable"? What did the expert find 
> >>>>>> happening? Just curious. When I wrote the above, I began to wonder how 
> >>>>>> much Eliza script would be needed to create a PO out of the vacuum. I 
> >>>>>> think I might have some old Lisp code lying around; if I can find it, 
> >>>>>> maybe I'll try to write that script. Then we can see if anyone can 
> >>>>>> tell the difference. It would be a reverse Turing test: see if anyone 
> >>>>>> can tell the difference between a duffus and the computer instead of a 
> >>>>>> human and a computer. What do you think? 
> >>>>> 
> >>>>> The verifiable fact is that G = not(provable(F, G)). is indeed not 
> >>>>> provable and its negation is G = not(provable(F, not(G))). is not 
> >>>>> provable thus meeting the definition of Incompleteness: 
> >>>>> Incomplete(T) ↔ ∃φ ((T ⊬ φ) ∧ (T ⊬ ¬φ)) 
> >>>>> 
> >>>>> Because this simplified expression and its negation meet the definition 
> >>>>> of incompleteness that proves that they are equivalent to Gödel's actual 
> >>>>> logic sentence. 
> >>>> Gödel's Bew(x) doesn't say x is provable. It says that x is the Gödel 
> >>>> number of a provable formula. It is often asserted that the Gödel 
> >>>> formula is 
> >>>> 
> >>>> I am not provable. 
> >>>> 
> >>>> It isn't. It can't be. Gödel is concerned with theories of arithmetic 
> >>>> and theories of arithmetic are about the natural numbers under addition 
> >>>> and multiplication. They are not about formulae and the provability or 
> >>>> otherwise of formulae. I have told you this a million times. Will you 
> >>>> never get it? 
> >>>>> 
> >>>>> The analogy between this result and Richard’s antinomy leaps to the eye; 
> >>>>> there is also a close relationship with the “liar” antinomy,14 since the 
> >>>>> undecidable proposition [R(q); q] states precisely that q belongs to K, 
> >>>>> i.e. according to (1), that [R(q); q] is not provable. We are therefore 
> >>>>> confronted with a proposition which asserts its own unprovability.15 
> >>>>> 
> >>>>> 14 Every epistemological antinomy can likewise be used for a similar 
> >>>>> undecidability proof. (Gödel:1931:40). 
> >>>> Why not quote footnote 15 while you're at it? 
> >>>> 
> >>>> "Contrary to appearances, such a proposition involves no faulty 
> >>>> circularity, for initially it [only] asserts that a certain well-defined 
> >>>> formula (namely the one obtained from the qth formula in the 
> >>>> lexicographical order by a certain substitution) is unprovable. Only 
> >>>> subsequently (and so to speak by chance) does it turn out that this 
> >>>> formula is precisely the one by which the proposition was itself expressed." 
> >>>>> 
> >>>>> The key new knowledge is that we can know why they are not provable 
> >>>>> unlike diagonalization which only proves that they are unprovable. 
> >>>>> 
> >>>>> They are unprovable because they have an infinitely recursive (cyclic) 
> >>>>> structure. 
> >>>>> 
> >>>>> ?- LP = not(true(LP)). 
> >>>>> LP = not(true(LP)). 
> >>>>> 
> >>>>> ?- unify_with_occurs_check(LP, not(true(LP))). 
> >>>>> false. 
> >>>>> 
> >>>>> Godel, Kurt 1931. On Formally Undecidable Propositions of Principia 
> >>>>> Mathematica And Related Systems I, page 39-41. 
> >>>>> 
> >>>>> 
> >>>> 
> >>>> 
> >>>> -- 
> >>>> Just as 'beautiful' points the way for aesthetics and 'good' for ethics, 
> >>>> so do words like 'true' for logic. All sciences have truth as their 
> >>>> goal; but logic is also concerned with it in a quite different way: 
> >>>> logic has much the same relation to truth as physics has to weight or 
> >>>> heat. Frege in 'Thoughts' (Der Gedanke) 
> >> -- 
> >> Copyright 2021 Pete Olcott 
> >> 
> >> "Great spirits have always encountered violent opposition from mediocre 
> >> minds." Einstein 
> 
> 
> -- 
> Copyright 2021 Pete Olcott 
> 
> "Great spirits have always encountered violent opposition from mediocre 
> minds." Einstein

[toc] | [prev] | [next] | [standalone]


#11812 — Re: Simplified Gödel sentence fails Prolog occurs check---> ?- G = not(provable(F, G)).

FromMostowski Collapse <bursejan@gmail.com>
Date2021-04-11 15:49 -0700
SubjectRe: Simplified Gödel sentence fails Prolog occurs check---> ?- G = not(provable(F, G)).
Message-ID<8d3f49fe-cfd8-4b02-9c47-1f0dbbb6c8afn@googlegroups.com>
In reply to#11811
The unification algorithm is not a provability relation,
that only decides whether s=t holds. It can also decide
s≠t, versus so called Clark Equational Theory (CET),

which has these two axioms added to FOL with Equality:

f(x1,..,xn)≠g(y1,..,ym)      for f≠g or n≠m
x≠g(y1,..,yj,..,ym)              for x e yj

So when unification fails, it says a little more than s=t 
could not be proved. It basically says s≠t vesus CET. But
there are also some quantifiers involved, 

I am only mentioning the most basic fact about unification 
you seem not to know.

See also:
establish not only unifiability but also non-unifiability of terms
https://link.springer.com/chapter/10.1007/3-540-63045-7_21

Mostowski Collapse schrieb am Montag, 12. April 2021 um 00:39:02 UTC+2:
> Its not an undecidable sentence you moron. (=)/2 is 
> decidable in Prolog. Just try this you moron: 
> 
> ?- set_prolog_flag(occurs_check, true). 
> 
> ?- dif(G, not(provable(F, not(G)))). 
> true
> olcott schrieb am Sonntag, 11. April 2021 um 22:31:26 UTC+2: 
> > On 4/11/2021 2:54 PM, Mostowski Collapse wrote: 
> > > I guess you are highly confused and never understood Prolog 
> > > when you write the following: 
> > > 
> > >> and its negation also fails 
> > >> ?- unify_with_occurs_check(G, not(provable(F, not(G)))). 
> > >> false. 
> > > 
> > > not(provable(F, not(G))) is just a syntax term tree: 
> > > 
> > > not 
> > > | 
> > > provable 
> > > / \ 
> > > F not 
> > > | 
> > > G 
> > > 
> > > What fails is not the negation. No negation is semantically 
> > > taken of anything. All that fails is syntactic unification, 
> > > 
> > > the only predication that was invoked was unify_with_occurs_check/2. 
> > > No predication not/1 or provable/2 was invoked. 
> > > 
> > > The unification fails, because the result of binding G to 
> > > the syntax term tree not(provable(F, not(G))) would result 
> > > 
> > > in a loop, and the syntax term would not anymore be a tree: 
> > > 
> > > v--------+ 
> > > not | 
> > > | | 
> > > provable | 
> > > / \ | 
> > > F not | 
> > > | | 
> > > G | 
> > > +-----+ 
> > > 
> > 
> > Yes very good you understand it completely. I show this same thing on 
> > page (3) of my paper. 
> > 
> > https://www.researchgate.net/publication/350789898_Prolog_detects_pathological_self_reference_in_the_Godel_sentence 
> > 
> > 
> > It cannot even be evaluated for provability because it has a cycle in 
> > its syntactic specification. 
> > ?- G = not(provable(F, G)). 
> > Since it cannot even be evaluated for provability because of this cycle 
> > we can know that it is it neither provable nor disprovable because the 
> > process of provability or disprovability cannot even begin. 
> > 
> > Since the expression can neither be proven nor disproven it exactly 
> > meets the conventional definition of Incompleteness: 
> > Incomplete(T) ↔ ∃φ ((T ⊬ φ) ∧ (T ⊬ ¬φ)) 
> > This proves that the conventional definition of incompleteness decides 
> > that a formal system is incomplete on the basis that this formal system 
> > cannot prove erroneous expressions of a formal language. 
> > 
> > The 1931 Gödel Incompleteness theorem proving that formal systems of 
> > arithmetic are incomplete is anchored faulty definition of 
> > "incompleteness". 
> > > olcott schrieb am Sonntag, 11. April 2021 um 21:34:25 UTC+2: 
> > >> On 4/11/2021 11:08 AM, Mostowski Collapse wrote: 
> > >>> Olcott misused Prolog. The outcome of LP = not(true(LP)) 
> > >>> depends on the occurs check flag. 
> > >>> 
> > >>> /* SWI-Prolog 8.3.21 */ 
> > >>> ?- set_prolog_flag(occurs_check, false). 
> > >>> true. 
> > >>> 
> > >>> ?- LP = not(true(LP)). 
> > >>> LP = not(true(LP)). 
> > >>> 
> > >>> ?- set_prolog_flag(occurs_check, true). 
> > >>> true. 
> > >>> 
> > >>> ?- LP = not(true(LP)). 
> > >>> false. 
> > >>> 
> > >>> But indeed nothing to do with Gödel, since (=)/2 in Prolog 
> > >>> is so called syntactic equality. 
> > >>> 
> > >> 
> > >> Setting the unification default has nothing to do with the assessment of 
> > >> whether a Prolog expression is or is not cyclic. 
> > >> https://www.swi-prolog.org/pldoc/man?section=flags#flag:occurs_check 
> > >> 
> > >> These three Prolog expressions being tested are not provable BECAUSE 
> > >> THEY ARE CYCLIC thus Erroneous: 
> > >> 
> > >> ?- unify_with_occurs_check(LP, not(true(LP))). 
> > >> false. 
> > >> ?- unify_with_occurs_check(G, not(provable(F, G))). 
> > >> false. 
> > >> 
> > >> and its negation also fails 
> > >> ?- unify_with_occurs_check(G, not(provable(F, not(G)))). 
> > >> false. 
> > >> Since the latter pair meet the definition of Incompleteness: 
> > >> Incomplete(T) ↔ ∃φ ((T ⊬ φ) ∧ (T ⊬ ¬φ)) 
> > >> That proves that they are logically equivalent to the Gödel sentence. 
> > >> 
> > >> In this case instead of merely knowing that the sentence and its 
> > >> negation are unprovable we also know WHY THE SENTENCE AND ITS NEGATION 
> > >> ARE UNPROVABLE, THE SENTENCE AND ITS NEGATION ARE ERRONEOUS. 
> > >> 
> > >> 
> > >>> Peter schrieb am Sonntag, 11. April 2021 um 17:32:13 UTC+2: 
> > >>>> olcott wrote: 
> > >>>>> On 4/11/2021 12:50 AM, Jeff Barnett wrote: 
> > >>>>>> On 4/10/2021 11:12 PM, olcott wrote: 
> > >>>>>>> On 4/10/2021 11:27 PM, Jeff Barnett wrote: 
> > >>>>>>>> On 4/10/2021 9:26 PM, olcott wrote: 
> > >>>>>>>>> On 4/9/2021 6:16 PM, olcott wrote: 
> > >>>>>>>>>> Clocksin and Mellish says that this fails an occurs check: 
> > >>>>>>>>>> ?- equal(foo(Y), Y). 
> > >>>>>>>>>> 
> > >>>>>>>>>> 254 Chapter 10 The Relation of Prolog to Logic 
> > >>>>>>>>>> Programming in Prolog Using the ISO Standard Fifth Edition by 
> > >>>>>>>>>> Clocksin 
> > >>>>>>>> 
> > >>>>>>>>>> and Mellish 
> > >>>>>>>>>> 
> > >>>>>>>>>> 
> > >>>>>>>>>> Does that mean that this also fails an occurs check: 
> > >>>>>>>>>> ?- equal(foo(X,Y), Y). 
> > >>>>>>>>>> 
> > >>>>>>>>> 
> > >>>>>>>>> ?- G = not(provable(F, G)). % G = ¬(F ⊢ G) 
> > >>>>>>>>> ?- unify_with_occurs_check(G, not(provable(F, G))). 
> > >>>>>>>>> false. 
> > >>>>>>>>> 
> > >>>>>>>>> and its negation also fails 
> > >>>>>>>>> 
> > >>>>>>>>> ?- G = not(provable(F, not(G))). % G = ¬(F ⊢ ¬G) 
> > >>>>>>>>> ?- unify_with_occurs_check(G, not(provable(F, not(G)))). 
> > >>>>>>>>> false. 
> > >>>>>>>>> 
> > >>>>>>>>> Thus meeting this conventional definition of incompleteness: 
> > >>>>>>>>> Incomplete(T) ↔ ∃φ ((T ⊬ φ) ∧ 
> > >>>>>> 
> > >>>>>>>> (T ⊬ ¬φ)) 
> > >>>>>>>>> 
> > >>>>>>>>> Therefore proving equivalence to the actual Gödel sentence. 
> > >>>>>>>>> 
> > >>>>>>>>> https://www.researchgate.net/publication/350789898_Prolog_detects_pathological_self_reference_in_the_Godel_sentence 
> > >>>>>>>> 
> > >>>>>>>> 
> > >>>>>>>> 
> > >>>>>>>> 
> > >>>>>>>> 
> > >>>>>>>> Congratulations! You have added Prolog to the list of topics that 
> > >>>>>>>> you don't really understand. The above reminds me a bit of 
> > >>>>>>>> Wisenbaum's Eliza. (Also called the Doctor and a direct ancestor of 
> > >>>>>>>> Perry the Paranoid.) In the above, substitute the word "constipated" 
> > >>>>>>>> for "provable". Then your result reads: 
> > >>>>>>>> 
> > >>>>>>>> "?- unify_with_occurs_check(G, not(constipated(F, not(G))))" 
> > >>>>>>>> 
> > >>>>>>>> and that shows exactly nothing to do with anything. So PO now has a 
> > >>>>>>>> theory of bowel movements but not those TM encodings promised so 
> > >>>>>>>> long ago. I suggest, to you, that you grab a book on logic and a 
> > >>>>>>>> bottle of Miralax and get on with it. 
> > >>>>>>> 
> > >>>>>>> Jackasses can be naysayers because it doesn't require any knowledge 
> > >>>>>>> or intelligence. 
> > >>>>>>> 
> > >>>>>>> I know that this particular understanding of Prolog is correct on the 
> > >>>>>>> basis of a whole logic system that I created named Minimal Type Theory. 
> > >>>>>> 
> > >>>>>>> This logic system translates expression of its language into directed 
> > >>>>>>> graphs. 
> > >>>>>>> 
> > >>>>>>> As I show in the above paper the logic sentence really is cyclic in 
> > >>>>>>> both Minimal Type Theory (MTT) and Prolog. 
> > >>>>>>> 
> > >>>>>>> Here is the formal YACC grammar for MTT: 
> > >>>>>>> https://www.researchgate.net/publication/331859461_Minimal_Type_Theory_YACC_BNF 
> > >>>>>> 
> > >>>>>> 
> > >>>>>> What does any of this have to do with my comments? Are you really so 
> > >>>>>> disassociated with reality? It's mind boggling. Did you try 
> > >>>>>> substituting "constipated" for "provable"? What did the expert find 
> > >>>>>> happening? Just curious. When I wrote the above, I began to wonder how 
> > >>>>>> much Eliza script would be needed to create a PO out of the vacuum. I 
> > >>>>>> think I might have some old Lisp code lying around; if I can find it, 
> > >>>>>> maybe I'll try to write that script. Then we can see if anyone can 
> > >>>>>> tell the difference. It would be a reverse Turing test: see if anyone 
> > >>>>>> can tell the difference between a duffus and the computer instead of a 
> > >>>>>> human and a computer. What do you think? 
> > >>>>> 
> > >>>>> The verifiable fact is that G = not(provable(F, G)). is indeed not 
> > >>>>> provable and its negation is G = not(provable(F, not(G))). is not 
> > >>>>> provable thus meeting the definition of Incompleteness: 
> > >>>>> Incomplete(T) ↔ ∃φ ((T ⊬ φ) ∧ (T ⊬ ¬φ)) 
> > >>>>> 
> > >>>>> Because this simplified expression and its negation meet the definition 
> > >>>>> of incompleteness that proves that they are equivalent to Gödel's actual 
> > >>>>> logic sentence. 
> > >>>> Gödel's Bew(x) doesn't say x is provable. It says that x is the Gödel 
> > >>>> number of a provable formula. It is often asserted that the Gödel 
> > >>>> formula is 
> > >>>> 
> > >>>> I am not provable. 
> > >>>> 
> > >>>> It isn't. It can't be. Gödel is concerned with theories of arithmetic 
> > >>>> and theories of arithmetic are about the natural numbers under addition 
> > >>>> and multiplication. They are not about formulae and the provability or 
> > >>>> otherwise of formulae. I have told you this a million times. Will you 
> > >>>> never get it? 
> > >>>>> 
> > >>>>> The analogy between this result and Richard’s antinomy leaps to the eye; 
> > >>>>> there is also a close relationship with the “liar” antinomy,14 since the 
> > >>>>> undecidable proposition [R(q); q] states precisely that q belongs to K, 
> > >>>>> i.e. according to (1), that [R(q); q] is not provable. We are therefore 
> > >>>>> confronted with a proposition which asserts its own unprovability.15 
> > >>>>> 
> > >>>>> 14 Every epistemological antinomy can likewise be used for a similar 
> > >>>>> undecidability proof. (Gödel:1931:40). 
> > >>>> Why not quote footnote 15 while you're at it? 
> > >>>> 
> > >>>> "Contrary to appearances, such a proposition involves no faulty 
> > >>>> circularity, for initially it [only] asserts that a certain well-defined 
> > >>>> formula (namely the one obtained from the qth formula in the 
> > >>>> lexicographical order by a certain substitution) is unprovable. Only 
> > >>>> subsequently (and so to speak by chance) does it turn out that this 
> > >>>> formula is precisely the one by which the proposition was itself expressed." 
> > >>>>> 
> > >>>>> The key new knowledge is that we can know why they are not provable 
> > >>>>> unlike diagonalization which only proves that they are unprovable. 
> > >>>>> 
> > >>>>> They are unprovable because they have an infinitely recursive (cyclic) 
> > >>>>> structure. 
> > >>>>> 
> > >>>>> ?- LP = not(true(LP)). 
> > >>>>> LP = not(true(LP)). 
> > >>>>> 
> > >>>>> ?- unify_with_occurs_check(LP, not(true(LP))). 
> > >>>>> false. 
> > >>>>> 
> > >>>>> Godel, Kurt 1931. On Formally Undecidable Propositions of Principia 
> > >>>>> Mathematica And Related Systems I, page 39-41. 
> > >>>>> 
> > >>>>> 
> > >>>> 
> > >>>> 
> > >>>> -- 
> > >>>> Just as 'beautiful' points the way for aesthetics and 'good' for ethics, 
> > >>>> so do words like 'true' for logic. All sciences have truth as their 
> > >>>> goal; but logic is also concerned with it in a quite different way: 
> > >>>> logic has much the same relation to truth as physics has to weight or 
> > >>>> heat. Frege in 'Thoughts' (Der Gedanke) 
> > >> -- 
> > >> Copyright 2021 Pete Olcott 
> > >> 
> > >> "Great spirits have always encountered violent opposition from mediocre 
> > >> minds." Einstein 
> > 
> > 
> > -- 
> > Copyright 2021 Pete Olcott 
> > 
> > "Great spirits have always encountered violent opposition from mediocre 
> > minds." Einstein

[toc] | [prev] | [next] | [standalone]


#11813 — Re: Simplified Gödel sentence fails Prolog occurs check---> ?- G = not(provable(F, G)).

FromMostowski Collapse <bursejan@gmail.com>
Date2021-04-11 16:08 -0700
SubjectRe: Simplified Gödel sentence fails Prolog occurs check---> ?- G = not(provable(F, G)).
Message-ID<beec354f-a25a-4f7a-8927-62d33664b29cn@googlegroups.com>
In reply to#11812
Gödels Incompletness Theorem doesn't use as ambient logic
Prolog logic programming. Gödels Incompletness Theorem original
Paper uses some Higher Order Logic.

You cannot just go on and use some umbral reasoning and compare
apples with oranges. Prolog with Negation of Failure (NAF) has non-
unification. Whereby the meaning is as follows:

?-  s = t                means          |- ∃(s = t) ?
?- \+ s = t            means          |- ∀(s ≠ t) ?
?- dif(s, t)            means          |- ∃(s ≠ t) ?

Harrop with Negation as Inconsistency (NAI) has also non-unification,
but it could be that there is more control of quantifiers, have to check. 
In the past Kunen once even published quantifier elimination for

Clark Equational Theory (CET).

Mostowski Collapse schrieb am Montag, 12. April 2021 um 00:49:36 UTC+2:
> The unification algorithm is not a provability relation, 
> that only decides whether s=t holds. It can also decide 
> s≠t, versus so called Clark Equational Theory (CET), 
> 
> which has these two axioms added to FOL with Equality: 
> 
> f(x1,..,xn)≠g(y1,..,ym) for f≠g or n≠m 
> x≠g(y1,..,yj,..,ym) for x e yj 
> 
> So when unification fails, it says a little more than s=t 
> could not be proved. It basically says s≠t vesus CET. But 
> there are also some quantifiers involved, 
> 
> I am only mentioning the most basic fact about unification 
> you seem not to know. 
> 
> See also: 
> establish not only unifiability but also non-unifiability of terms 
> https://link.springer.com/chapter/10.1007/3-540-63045-7_21
> Mostowski Collapse schrieb am Montag, 12. April 2021 um 00:39:02 UTC+2: 
> > Its not an undecidable sentence you moron. (=)/2 is 
> > decidable in Prolog. Just try this you moron: 
> > 
> > ?- set_prolog_flag(occurs_check, true). 
> > 
> > ?- dif(G, not(provable(F, not(G)))). 
> > true 
> > olcott schrieb am Sonntag, 11. April 2021 um 22:31:26 UTC+2: 
> > > On 4/11/2021 2:54 PM, Mostowski Collapse wrote: 
> > > > I guess you are highly confused and never understood Prolog 
> > > > when you write the following: 
> > > > 
> > > >> and its negation also fails 
> > > >> ?- unify_with_occurs_check(G, not(provable(F, not(G)))). 
> > > >> false. 
> > > > 
> > > > not(provable(F, not(G))) is just a syntax term tree: 
> > > > 
> > > > not 
> > > > | 
> > > > provable 
> > > > / \ 
> > > > F not 
> > > > | 
> > > > G 
> > > > 
> > > > What fails is not the negation. No negation is semantically 
> > > > taken of anything. All that fails is syntactic unification, 
> > > > 
> > > > the only predication that was invoked was unify_with_occurs_check/2. 
> > > > No predication not/1 or provable/2 was invoked. 
> > > > 
> > > > The unification fails, because the result of binding G to 
> > > > the syntax term tree not(provable(F, not(G))) would result 
> > > > 
> > > > in a loop, and the syntax term would not anymore be a tree: 
> > > > 
> > > > v--------+ 
> > > > not | 
> > > > | | 
> > > > provable | 
> > > > / \ | 
> > > > F not | 
> > > > | | 
> > > > G | 
> > > > +-----+ 
> > > > 
> > > 
> > > Yes very good you understand it completely. I show this same thing on 
> > > page (3) of my paper. 
> > > 
> > > https://www.researchgate.net/publication/350789898_Prolog_detects_pathological_self_reference_in_the_Godel_sentence 
> > > 
> > > 
> > > It cannot even be evaluated for provability because it has a cycle in 
> > > its syntactic specification. 
> > > ?- G = not(provable(F, G)). 
> > > Since it cannot even be evaluated for provability because of this cycle 
> > > we can know that it is it neither provable nor disprovable because the 
> > > process of provability or disprovability cannot even begin. 
> > > 
> > > Since the expression can neither be proven nor disproven it exactly 
> > > meets the conventional definition of Incompleteness: 
> > > Incomplete(T) ↔ ∃φ ((T ⊬ φ) ∧ (T ⊬ ¬φ)) 
> > > This proves that the conventional definition of incompleteness decides 
> > > that a formal system is incomplete on the basis that this formal system 
> > > cannot prove erroneous expressions of a formal language. 
> > > 
> > > The 1931 Gödel Incompleteness theorem proving that formal systems of 
> > > arithmetic are incomplete is anchored faulty definition of 
> > > "incompleteness". 
> > > > olcott schrieb am Sonntag, 11. April 2021 um 21:34:25 UTC+2: 
> > > >> On 4/11/2021 11:08 AM, Mostowski Collapse wrote: 
> > > >>> Olcott misused Prolog. The outcome of LP = not(true(LP)) 
> > > >>> depends on the occurs check flag. 
> > > >>> 
> > > >>> /* SWI-Prolog 8.3.21 */ 
> > > >>> ?- set_prolog_flag(occurs_check, false). 
> > > >>> true. 
> > > >>> 
> > > >>> ?- LP = not(true(LP)). 
> > > >>> LP = not(true(LP)). 
> > > >>> 
> > > >>> ?- set_prolog_flag(occurs_check, true). 
> > > >>> true. 
> > > >>> 
> > > >>> ?- LP = not(true(LP)). 
> > > >>> false. 
> > > >>> 
> > > >>> But indeed nothing to do with Gödel, since (=)/2 in Prolog 
> > > >>> is so called syntactic equality. 
> > > >>> 
> > > >> 
> > > >> Setting the unification default has nothing to do with the assessment of 
> > > >> whether a Prolog expression is or is not cyclic. 
> > > >> https://www.swi-prolog.org/pldoc/man?section=flags#flag:occurs_check 
> > > >> 
> > > >> These three Prolog expressions being tested are not provable BECAUSE 
> > > >> THEY ARE CYCLIC thus Erroneous: 
> > > >> 
> > > >> ?- unify_with_occurs_check(LP, not(true(LP))). 
> > > >> false. 
> > > >> ?- unify_with_occurs_check(G, not(provable(F, G))). 
> > > >> false. 
> > > >> 
> > > >> and its negation also fails 
> > > >> ?- unify_with_occurs_check(G, not(provable(F, not(G)))). 
> > > >> false. 
> > > >> Since the latter pair meet the definition of Incompleteness: 
> > > >> Incomplete(T) ↔ ∃φ ((T ⊬ φ) ∧ (T ⊬ ¬φ)) 
> > > >> That proves that they are logically equivalent to the Gödel sentence. 
> > > >> 
> > > >> In this case instead of merely knowing that the sentence and its 
> > > >> negation are unprovable we also know WHY THE SENTENCE AND ITS NEGATION 
> > > >> ARE UNPROVABLE, THE SENTENCE AND ITS NEGATION ARE ERRONEOUS. 

[toc] | [prev] | [next] | [standalone]


#11815 — Re: Simplified Gödel sentence fails Prolog occurs check---> ?- G = not(provable(F, G)).

Fromolcott <NoOne@NoWhere.com>
Date2021-04-11 19:04 -0500
SubjectRe: Simplified Gödel sentence fails Prolog occurs check---> ?- G = not(provable(F, G)).
Message-ID<mMCdnUWjvJLrE-79nZ2dnUU7-IHNnZ2d@giganews.com>
In reply to#11813
On 4/11/2021 6:08 PM, Mostowski Collapse wrote:
> Gödels Incompletness Theorem doesn't use as ambient logic
> Prolog logic programming. Gödels Incompletness Theorem original
> Paper uses some Higher Order Logic.
> 

If we can duplicate his results by meeting the definition of 
incompleteness: Incomplete(T) ↔ ∃φ ((T ⊬ φ) ∧ (T ⊬ ¬φ))

on the basis of a term that is not provable because it represents: "some 
kind of infinite structure" then we have proven that the definition of 
Incompleteness has a fatal flaw.

This removes the key basis of the 1931 Incompleteness theorem: the 
definition of Incompleteness.


> You cannot just go on and use some umbral reasoning and compare
> apples with oranges. Prolog with Negation of Failure (NAF) has non-
> unification. Whereby the meaning is as follows:
> 
> ?-  s = t                means          |- ∃(s = t) ?
> ?- \+ s = t            means          |- ∀(s ≠ t) ?
> ?- dif(s, t)            means          |- ∃(s ≠ t) ?
> 
> Harrop with Negation as Inconsistency (NAI) has also non-unification,
> but it could be that there is more control of quantifiers, have to check.
> In the past Kunen once even published quantifier elimination for
> 
> Clark Equational Theory (CET).
> 
> Mostowski Collapse schrieb am Montag, 12. April 2021 um 00:49:36 UTC+2:
>> The unification algorithm is not a provability relation,
>> that only decides whether s=t holds. It can also decide
>> s≠t, versus so called Clark Equational Theory (CET),
>>
>> which has these two axioms added to FOL with Equality:
>>
>> f(x1,..,xn)≠g(y1,..,ym) for f≠g or n≠m
>> x≠g(y1,..,yj,..,ym) for x e yj
>>
>> So when unification fails, it says a little more than s=t
>> could not be proved. It basically says s≠t vesus CET. But
>> there are also some quantifiers involved,
>>
>> I am only mentioning the most basic fact about unification
>> you seem not to know.
>>
>> See also:
>> establish not only unifiability but also non-unifiability of terms
>> https://link.springer.com/chapter/10.1007/3-540-63045-7_21
>> Mostowski Collapse schrieb am Montag, 12. April 2021 um 00:39:02 UTC+2:
>>> Its not an undecidable sentence you moron. (=)/2 is
>>> decidable in Prolog. Just try this you moron:
>>>
>>> ?- set_prolog_flag(occurs_check, true).
>>>
>>> ?- dif(G, not(provable(F, not(G)))).
>>> true
>>> olcott schrieb am Sonntag, 11. April 2021 um 22:31:26 UTC+2:
>>>> On 4/11/2021 2:54 PM, Mostowski Collapse wrote:
>>>>> I guess you are highly confused and never understood Prolog
>>>>> when you write the following:
>>>>>
>>>>>> and its negation also fails
>>>>>> ?- unify_with_occurs_check(G, not(provable(F, not(G)))).
>>>>>> false.
>>>>>
>>>>> not(provable(F, not(G))) is just a syntax term tree:
>>>>>
>>>>> not
>>>>> |
>>>>> provable
>>>>> / \
>>>>> F not
>>>>> |
>>>>> G
>>>>>
>>>>> What fails is not the negation. No negation is semantically
>>>>> taken of anything. All that fails is syntactic unification,
>>>>>
>>>>> the only predication that was invoked was unify_with_occurs_check/2.
>>>>> No predication not/1 or provable/2 was invoked.
>>>>>
>>>>> The unification fails, because the result of binding G to
>>>>> the syntax term tree not(provable(F, not(G))) would result
>>>>>
>>>>> in a loop, and the syntax term would not anymore be a tree:
>>>>>
>>>>> v--------+
>>>>> not |
>>>>> | |
>>>>> provable |
>>>>> / \ |
>>>>> F not |
>>>>> | |
>>>>> G |
>>>>> +-----+
>>>>>
>>>>
>>>> Yes very good you understand it completely. I show this same thing on
>>>> page (3) of my paper.
>>>>
>>>> https://www.researchgate.net/publication/350789898_Prolog_detects_pathological_self_reference_in_the_Godel_sentence
>>>>
>>>>
>>>> It cannot even be evaluated for provability because it has a cycle in
>>>> its syntactic specification.
>>>> ?- G = not(provable(F, G)).
>>>> Since it cannot even be evaluated for provability because of this cycle
>>>> we can know that it is it neither provable nor disprovable because the
>>>> process of provability or disprovability cannot even begin.
>>>>
>>>> Since the expression can neither be proven nor disproven it exactly
>>>> meets the conventional definition of Incompleteness:
>>>> Incomplete(T) ↔ ∃φ ((T ⊬ φ) ∧ (T ⊬ ¬φ))
>>>> This proves that the conventional definition of incompleteness decides
>>>> that a formal system is incomplete on the basis that this formal system
>>>> cannot prove erroneous expressions of a formal language.
>>>>
>>>> The 1931 Gödel Incompleteness theorem proving that formal systems of
>>>> arithmetic are incomplete is anchored faulty definition of
>>>> "incompleteness".
>>>>> olcott schrieb am Sonntag, 11. April 2021 um 21:34:25 UTC+2:
>>>>>> On 4/11/2021 11:08 AM, Mostowski Collapse wrote:
>>>>>>> Olcott misused Prolog. The outcome of LP = not(true(LP))
>>>>>>> depends on the occurs check flag.
>>>>>>>
>>>>>>> /* SWI-Prolog 8.3.21 */
>>>>>>> ?- set_prolog_flag(occurs_check, false).
>>>>>>> true.
>>>>>>>
>>>>>>> ?- LP = not(true(LP)).
>>>>>>> LP = not(true(LP)).
>>>>>>>
>>>>>>> ?- set_prolog_flag(occurs_check, true).
>>>>>>> true.
>>>>>>>
>>>>>>> ?- LP = not(true(LP)).
>>>>>>> false.
>>>>>>>
>>>>>>> But indeed nothing to do with Gödel, since (=)/2 in Prolog
>>>>>>> is so called syntactic equality.
>>>>>>>
>>>>>>
>>>>>> Setting the unification default has nothing to do with the assessment of
>>>>>> whether a Prolog expression is or is not cyclic.
>>>>>> https://www.swi-prolog.org/pldoc/man?section=flags#flag:occurs_check
>>>>>>
>>>>>> These three Prolog expressions being tested are not provable BECAUSE
>>>>>> THEY ARE CYCLIC thus Erroneous:
>>>>>>
>>>>>> ?- unify_with_occurs_check(LP, not(true(LP))).
>>>>>> false.
>>>>>> ?- unify_with_occurs_check(G, not(provable(F, G))).
>>>>>> false.
>>>>>>
>>>>>> and its negation also fails
>>>>>> ?- unify_with_occurs_check(G, not(provable(F, not(G)))).
>>>>>> false.
>>>>>> Since the latter pair meet the definition of Incompleteness:
>>>>>> Incomplete(T) ↔ ∃φ ((T ⊬ φ) ∧ (T ⊬ ¬φ))
>>>>>> That proves that they are logically equivalent to the Gödel sentence.
>>>>>>
>>>>>> In this case instead of merely knowing that the sentence and its
>>>>>> negation are unprovable we also know WHY THE SENTENCE AND ITS NEGATION
>>>>>> ARE UNPROVABLE, THE SENTENCE AND ITS NEGATION ARE ERRONEOUS.


-- 
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre 
minds." Einstein

[toc] | [prev] | [next] | [standalone]


#11817 — Re: Simplified Gödel sentence fails Prolog occurs check---> ?- G = not(provable(F, G)).

FromMostowski Collapse <bursejan@gmail.com>
Date2021-04-12 01:16 -0700
SubjectRe: Simplified Gödel sentence fails Prolog occurs check---> ?- G = not(provable(F, G)).
Message-ID<02018120-b84d-42a0-8f03-de226fe121d3n@googlegroups.com>
In reply to#11815
Prolog has no ¬φ. Its based on Horn clauses which do not have ¬φ.
So your attempt is pretty useless, how is your not/1 defined?

olcott schrieb am Montag, 12. April 2021 um 02:04:13 UTC+2:
> On 4/11/2021 6:08 PM, Mostowski Collapse wrote: 
> > Gödels Incompletness Theorem doesn't use as ambient logic 
> > Prolog logic programming. Gödels Incompletness Theorem original 
> > Paper uses some Higher Order Logic. 
> >
> If we can duplicate his results by meeting the definition of 
> incompleteness: Incomplete(T) ↔ ∃φ ((T ⊬ φ) ∧ (T ⊬ ¬φ)) 
> 
> on the basis of a term that is not provable because it represents: "some 
> kind of infinite structure" then we have proven that the definition of 
> Incompleteness has a fatal flaw. 
> 
> This removes the key basis of the 1931 Incompleteness theorem: the 
> definition of Incompleteness.
> > You cannot just go on and use some umbral reasoning and compare 
> > apples with oranges. Prolog with Negation of Failure (NAF) has non- 
> > unification. Whereby the meaning is as follows: 
> > 
> > ?- s = t means |- ∃(s = t) ? 
> > ?- \+ s = t means |- ∀(s ≠ t) ? 
> > ?- dif(s, t) means |- ∃(s ≠ t) ? 
> > 
> > Harrop with Negation as Inconsistency (NAI) has also non-unification, 
> > but it could be that there is more control of quantifiers, have to check. 
> > In the past Kunen once even published quantifier elimination for 
> > 
> > Clark Equational Theory (CET). 
> > 
> > Mostowski Collapse schrieb am Montag, 12. April 2021 um 00:49:36 UTC+2: 
> >> The unification algorithm is not a provability relation, 
> >> that only decides whether s=t holds. It can also decide 
> >> s≠t, versus so called Clark Equational Theory (CET), 
> >> 
> >> which has these two axioms added to FOL with Equality: 
> >> 
> >> f(x1,..,xn)≠g(y1,..,ym) for f≠g or n≠m 
> >> x≠g(y1,..,yj,..,ym) for x e yj 
> >> 
> >> So when unification fails, it says a little more than s=t 
> >> could not be proved. It basically says s≠t vesus CET. But 
> >> there are also some quantifiers involved, 
> >> 
> >> I am only mentioning the most basic fact about unification 
> >> you seem not to know. 
> >> 
> >> See also: 
> >> establish not only unifiability but also non-unifiability of terms 
> >> https://link.springer.com/chapter/10.1007/3-540-63045-7_21 
> >> Mostowski Collapse schrieb am Montag, 12. April 2021 um 00:39:02 UTC+2: 
> >>> Its not an undecidable sentence you moron. (=)/2 is 
> >>> decidable in Prolog. Just try this you moron: 
> >>> 
> >>> ?- set_prolog_flag(occurs_check, true). 
> >>> 
> >>> ?- dif(G, not(provable(F, not(G)))). 
> >>> true 
> >>> olcott schrieb am Sonntag, 11. April 2021 um 22:31:26 UTC+2: 
> >>>> On 4/11/2021 2:54 PM, Mostowski Collapse wrote: 
> >>>>> I guess you are highly confused and never understood Prolog 
> >>>>> when you write the following: 
> >>>>> 
> >>>>>> and its negation also fails 
> >>>>>> ?- unify_with_occurs_check(G, not(provable(F, not(G)))). 
> >>>>>> false. 
> >>>>> 
> >>>>> not(provable(F, not(G))) is just a syntax term tree: 
> >>>>> 
> >>>>> not 
> >>>>> | 
> >>>>> provable 
> >>>>> / \ 
> >>>>> F not 
> >>>>> | 
> >>>>> G 
> >>>>> 
> >>>>> What fails is not the negation. No negation is semantically 
> >>>>> taken of anything. All that fails is syntactic unification, 
> >>>>> 
> >>>>> the only predication that was invoked was unify_with_occurs_check/2. 
> >>>>> No predication not/1 or provable/2 was invoked. 
> >>>>> 
> >>>>> The unification fails, because the result of binding G to 
> >>>>> the syntax term tree not(provable(F, not(G))) would result 
> >>>>> 
> >>>>> in a loop, and the syntax term would not anymore be a tree: 
> >>>>> 
> >>>>> v--------+ 
> >>>>> not | 
> >>>>> | | 
> >>>>> provable | 
> >>>>> / \ | 
> >>>>> F not | 
> >>>>> | | 
> >>>>> G | 
> >>>>> +-----+ 
> >>>>> 
> >>>> 
> >>>> Yes very good you understand it completely. I show this same thing on 
> >>>> page (3) of my paper. 
> >>>> 
> >>>> https://www.researchgate.net/publication/350789898_Prolog_detects_pathological_self_reference_in_the_Godel_sentence 
> >>>> 
> >>>> 
> >>>> It cannot even be evaluated for provability because it has a cycle in 
> >>>> its syntactic specification. 
> >>>> ?- G = not(provable(F, G)). 
> >>>> Since it cannot even be evaluated for provability because of this cycle 
> >>>> we can know that it is it neither provable nor disprovable because the 
> >>>> process of provability or disprovability cannot even begin. 
> >>>> 
> >>>> Since the expression can neither be proven nor disproven it exactly 
> >>>> meets the conventional definition of Incompleteness: 
> >>>> Incomplete(T) ↔ ∃φ ((T ⊬ φ) ∧ (T ⊬ ¬φ)) 
> >>>> This proves that the conventional definition of incompleteness decides 
> >>>> that a formal system is incomplete on the basis that this formal system 
> >>>> cannot prove erroneous expressions of a formal language. 
> >>>> 
> >>>> The 1931 Gödel Incompleteness theorem proving that formal systems of 
> >>>> arithmetic are incomplete is anchored faulty definition of 
> >>>> "incompleteness". 
> >>>>> olcott schrieb am Sonntag, 11. April 2021 um 21:34:25 UTC+2: 
> >>>>>> On 4/11/2021 11:08 AM, Mostowski Collapse wrote: 
> >>>>>>> Olcott misused Prolog. The outcome of LP = not(true(LP)) 
> >>>>>>> depends on the occurs check flag. 
> >>>>>>> 
> >>>>>>> /* SWI-Prolog 8.3.21 */ 
> >>>>>>> ?- set_prolog_flag(occurs_check, false). 
> >>>>>>> true. 
> >>>>>>> 
> >>>>>>> ?- LP = not(true(LP)). 
> >>>>>>> LP = not(true(LP)). 
> >>>>>>> 
> >>>>>>> ?- set_prolog_flag(occurs_check, true). 
> >>>>>>> true. 
> >>>>>>> 
> >>>>>>> ?- LP = not(true(LP)). 
> >>>>>>> false. 
> >>>>>>> 
> >>>>>>> But indeed nothing to do with Gödel, since (=)/2 in Prolog 
> >>>>>>> is so called syntactic equality. 
> >>>>>>> 
> >>>>>> 
> >>>>>> Setting the unification default has nothing to do with the assessment of 
> >>>>>> whether a Prolog expression is or is not cyclic. 
> >>>>>> https://www.swi-prolog.org/pldoc/man?section=flags#flag:occurs_check 
> >>>>>> 
> >>>>>> These three Prolog expressions being tested are not provable BECAUSE 
> >>>>>> THEY ARE CYCLIC thus Erroneous: 
> >>>>>> 
> >>>>>> ?- unify_with_occurs_check(LP, not(true(LP))). 
> >>>>>> false. 
> >>>>>> ?- unify_with_occurs_check(G, not(provable(F, G))). 
> >>>>>> false. 
> >>>>>> 
> >>>>>> and its negation also fails 
> >>>>>> ?- unify_with_occurs_check(G, not(provable(F, not(G)))). 
> >>>>>> false. 
> >>>>>> Since the latter pair meet the definition of Incompleteness: 
> >>>>>> Incomplete(T) ↔ ∃φ ((T ⊬ φ) ∧ (T ⊬ ¬φ)) 
> >>>>>> That proves that they are logically equivalent to the Gödel sentence. 
> >>>>>> 
> >>>>>> In this case instead of merely knowing that the sentence and its 
> >>>>>> negation are unprovable we also know WHY THE SENTENCE AND ITS NEGATION 
> >>>>>> ARE UNPROVABLE, THE SENTENCE AND ITS NEGATION ARE ERRONEOUS.
> -- 
> Copyright 2021 Pete Olcott 
> 
> "Great spirits have always encountered violent opposition from mediocre 
> minds." Einstein

[toc] | [prev] | [next] | [standalone]


#11818 — Re: Simplified Gödel sentence fails Prolog occurs check---> ?- G = not(provable(F, G)).

Fromolcott <NoOne@NoWhere.com>
Date2021-04-12 09:45 -0500
SubjectRe: Simplified Gödel sentence fails Prolog occurs check---> ?- G = not(provable(F, G)).
Message-ID<QPOdna-88P6WwOn9nZ2dnUU7-VHNnZ2d@giganews.com>
In reply to#11817
On 4/12/2021 3:16 AM, Mostowski Collapse wrote:
> Prolog has no ¬φ. Its based on Horn clauses which do not have ¬φ.
> So your attempt is pretty useless, how is your not/1 defined?
> 

You are saying the Prolog defines negation as failure and this is not 
the way that symbolic logic defines negation.

That should not make any difference. This is actually better than the 
way that symbolic logic does it. Symbolic logic takes not true as false. 
Prolog takes not true as false or erroneous.

> olcott schrieb am Montag, 12. April 2021 um 02:04:13 UTC+2:
>> On 4/11/2021 6:08 PM, Mostowski Collapse wrote:
>>> Gödels Incompletness Theorem doesn't use as ambient logic
>>> Prolog logic programming. Gödels Incompletness Theorem original
>>> Paper uses some Higher Order Logic.
>>>
>> If we can duplicate his results by meeting the definition of
>> incompleteness: Incomplete(T) ↔ ∃φ ((T ⊬ φ) ∧ (T ⊬ ¬φ))
>>
>> on the basis of a term that is not provable because it represents: "some
>> kind of infinite structure" then we have proven that the definition of
>> Incompleteness has a fatal flaw.
>>
>> This removes the key basis of the 1931 Incompleteness theorem: the
>> definition of Incompleteness.
>>> You cannot just go on and use some umbral reasoning and compare
>>> apples with oranges. Prolog with Negation of Failure (NAF) has non-
>>> unification. Whereby the meaning is as follows:
>>>
>>> ?- s = t means |- ∃(s = t) ?
>>> ?- \+ s = t means |- ∀(s ≠ t) ?
>>> ?- dif(s, t) means |- ∃(s ≠ t) ?
>>>
>>> Harrop with Negation as Inconsistency (NAI) has also non-unification,
>>> but it could be that there is more control of quantifiers, have to check.
>>> In the past Kunen once even published quantifier elimination for
>>>
>>> Clark Equational Theory (CET).
>>>
>>> Mostowski Collapse schrieb am Montag, 12. April 2021 um 00:49:36 UTC+2:
>>>> The unification algorithm is not a provability relation,
>>>> that only decides whether s=t holds. It can also decide
>>>> s≠t, versus so called Clark Equational Theory (CET),
>>>>
>>>> which has these two axioms added to FOL with Equality:
>>>>
>>>> f(x1,..,xn)≠g(y1,..,ym) for f≠g or n≠m
>>>> x≠g(y1,..,yj,..,ym) for x e yj
>>>>
>>>> So when unification fails, it says a little more than s=t
>>>> could not be proved. It basically says s≠t vesus CET. But
>>>> there are also some quantifiers involved,
>>>>
>>>> I am only mentioning the most basic fact about unification
>>>> you seem not to know.
>>>>
>>>> See also:
>>>> establish not only unifiability but also non-unifiability of terms
>>>> https://link.springer.com/chapter/10.1007/3-540-63045-7_21
>>>> Mostowski Collapse schrieb am Montag, 12. April 2021 um 00:39:02 UTC+2:
>>>>> Its not an undecidable sentence you moron. (=)/2 is
>>>>> decidable in Prolog. Just try this you moron:
>>>>>
>>>>> ?- set_prolog_flag(occurs_check, true).
>>>>>
>>>>> ?- dif(G, not(provable(F, not(G)))).
>>>>> true
>>>>> olcott schrieb am Sonntag, 11. April 2021 um 22:31:26 UTC+2:
>>>>>> On 4/11/2021 2:54 PM, Mostowski Collapse wrote:
>>>>>>> I guess you are highly confused and never understood Prolog
>>>>>>> when you write the following:
>>>>>>>
>>>>>>>> and its negation also fails
>>>>>>>> ?- unify_with_occurs_check(G, not(provable(F, not(G)))).
>>>>>>>> false.
>>>>>>>
>>>>>>> not(provable(F, not(G))) is just a syntax term tree:
>>>>>>>
>>>>>>> not
>>>>>>> |
>>>>>>> provable
>>>>>>> / \
>>>>>>> F not
>>>>>>> |
>>>>>>> G
>>>>>>>
>>>>>>> What fails is not the negation. No negation is semantically
>>>>>>> taken of anything. All that fails is syntactic unification,
>>>>>>>
>>>>>>> the only predication that was invoked was unify_with_occurs_check/2.
>>>>>>> No predication not/1 or provable/2 was invoked.
>>>>>>>
>>>>>>> The unification fails, because the result of binding G to
>>>>>>> the syntax term tree not(provable(F, not(G))) would result
>>>>>>>
>>>>>>> in a loop, and the syntax term would not anymore be a tree:
>>>>>>>
>>>>>>> v--------+
>>>>>>> not |
>>>>>>> | |
>>>>>>> provable |
>>>>>>> / \ |
>>>>>>> F not |
>>>>>>> | |
>>>>>>> G |
>>>>>>> +-----+
>>>>>>>
>>>>>>
>>>>>> Yes very good you understand it completely. I show this same thing on
>>>>>> page (3) of my paper.
>>>>>>
>>>>>> https://www.researchgate.net/publication/350789898_Prolog_detects_pathological_self_reference_in_the_Godel_sentence
>>>>>>
>>>>>>
>>>>>> It cannot even be evaluated for provability because it has a cycle in
>>>>>> its syntactic specification.
>>>>>> ?- G = not(provable(F, G)).
>>>>>> Since it cannot even be evaluated for provability because of this cycle
>>>>>> we can know that it is it neither provable nor disprovable because the
>>>>>> process of provability or disprovability cannot even begin.
>>>>>>
>>>>>> Since the expression can neither be proven nor disproven it exactly
>>>>>> meets the conventional definition of Incompleteness:
>>>>>> Incomplete(T) ↔ ∃φ ((T ⊬ φ) ∧ (T ⊬ ¬φ))
>>>>>> This proves that the conventional definition of incompleteness decides
>>>>>> that a formal system is incomplete on the basis that this formal system
>>>>>> cannot prove erroneous expressions of a formal language.
>>>>>>
>>>>>> The 1931 Gödel Incompleteness theorem proving that formal systems of
>>>>>> arithmetic are incomplete is anchored faulty definition of
>>>>>> "incompleteness".
>>>>>>> olcott schrieb am Sonntag, 11. April 2021 um 21:34:25 UTC+2:
>>>>>>>> On 4/11/2021 11:08 AM, Mostowski Collapse wrote:
>>>>>>>>> Olcott misused Prolog. The outcome of LP = not(true(LP))
>>>>>>>>> depends on the occurs check flag.
>>>>>>>>>
>>>>>>>>> /* SWI-Prolog 8.3.21 */
>>>>>>>>> ?- set_prolog_flag(occurs_check, false).
>>>>>>>>> true.
>>>>>>>>>
>>>>>>>>> ?- LP = not(true(LP)).
>>>>>>>>> LP = not(true(LP)).
>>>>>>>>>
>>>>>>>>> ?- set_prolog_flag(occurs_check, true).
>>>>>>>>> true.
>>>>>>>>>
>>>>>>>>> ?- LP = not(true(LP)).
>>>>>>>>> false.
>>>>>>>>>
>>>>>>>>> But indeed nothing to do with Gödel, since (=)/2 in Prolog
>>>>>>>>> is so called syntactic equality.
>>>>>>>>>
>>>>>>>>
>>>>>>>> Setting the unification default has nothing to do with the assessment of
>>>>>>>> whether a Prolog expression is or is not cyclic.
>>>>>>>> https://www.swi-prolog.org/pldoc/man?section=flags#flag:occurs_check
>>>>>>>>
>>>>>>>> These three Prolog expressions being tested are not provable BECAUSE
>>>>>>>> THEY ARE CYCLIC thus Erroneous:
>>>>>>>>
>>>>>>>> ?- unify_with_occurs_check(LP, not(true(LP))).
>>>>>>>> false.
>>>>>>>> ?- unify_with_occurs_check(G, not(provable(F, G))).
>>>>>>>> false.
>>>>>>>>
>>>>>>>> and its negation also fails
>>>>>>>> ?- unify_with_occurs_check(G, not(provable(F, not(G)))).
>>>>>>>> false.
>>>>>>>> Since the latter pair meet the definition of Incompleteness:
>>>>>>>> Incomplete(T) ↔ ∃φ ((T ⊬ φ) ∧ (T ⊬ ¬φ))
>>>>>>>> That proves that they are logically equivalent to the Gödel sentence.
>>>>>>>>
>>>>>>>> In this case instead of merely knowing that the sentence and its
>>>>>>>> negation are unprovable we also know WHY THE SENTENCE AND ITS NEGATION
>>>>>>>> ARE UNPROVABLE, THE SENTENCE AND ITS NEGATION ARE ERRONEOUS.
>> -- 
>> Copyright 2021 Pete Olcott
>>
>> "Great spirits have always encountered violent opposition from mediocre
>> minds." Einstein


-- 
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre 
minds." Einstein

[toc] | [prev] | [next] | [standalone]


#11814 — Re: Simplified Gödel sentence fails Prolog occurs check---> ?- G = not(provable(F, G)).

Fromolcott <NoOne@NoWhere.com>
Date2021-04-11 18:57 -0500
SubjectRe: Simplified Gödel sentence fails Prolog occurs check---> ?- G = not(provable(F, G)).
Message-ID<icydnYq2X7JSEe79nZ2dnUU7-UPNnZ2d@giganews.com>
In reply to#11812
On 4/11/2021 5:49 PM, Mostowski Collapse wrote:
> The unification algorithm is not a provability relation,
> that only decides whether s=t holds. It can also decide
> s≠t, versus so called Clark Equational Theory (CET),
> 
> which has these two axioms added to FOL with Equality:
> 
> f(x1,..,xn)≠g(y1,..,ym)      for f≠g or n≠m
> x≠g(y1,..,yj,..,ym)              for x e yj
> 
> So when unification fails, it says a little more than s=t
> could not be proved. 

I am not denigrating Prolog. I am applauding Prolog for its ability to 
detect the key error in Gödel's 1931 Incompleteness theorem.

Page (2) of my paper quotes page 254 of Clocksin and Mellish:
https://www.researchgate.net/publication/350789898_Prolog_detects_pathological_self_reference_in_the_Godel_sentence 


The key thing more that it does say is WHY s=t could not be proved.

?- equal(foo(Y), Y).
Y ends up standing for some kind of infinite structure.

The definition of incompleteness:
Incomplete(T) ↔ ∃φ ((T ⊬ φ) ∧ (T ⊬ ¬φ))

Doesn't give a rats ass WHY it couldn't be proved (that is its big 
mistake), it only cares THAT it couldn't be proved.

So if s=t cannot be proved and s=not(t) cannot be proved then the 
inherently erroneous definition of incompleteness that Gödel's 1931 
incompleteness theorem is based on PROVES THAT PROLOG IS INCOMPLETE on 
the basis of its inability to unify: "some kind of infinite structure."

> It basically says s≠t vesus CET. But
> there are also some quantifiers involved,
> 
> I am only mentioning the most basic fact about unification
> you seem not to know.
> 
> See also:
> establish not only unifiability but also non-unifiability of terms
> https://link.springer.com/chapter/10.1007/3-540-63045-7_21
> 
> Mostowski Collapse schrieb am Montag, 12. April 2021 um 00:39:02 UTC+2:
>> Its not an undecidable sentence you moron. (=)/2 is
>> decidable in Prolog. Just try this you moron:
>>
>> ?- set_prolog_flag(occurs_check, true).
>>
>> ?- dif(G, not(provable(F, not(G)))).
>> true
>> olcott schrieb am Sonntag, 11. April 2021 um 22:31:26 UTC+2:
>>> On 4/11/2021 2:54 PM, Mostowski Collapse wrote:
>>>> I guess you are highly confused and never understood Prolog
>>>> when you write the following:
>>>>
>>>>> and its negation also fails
>>>>> ?- unify_with_occurs_check(G, not(provable(F, not(G)))).
>>>>> false.
>>>>
>>>> not(provable(F, not(G))) is just a syntax term tree:
>>>>
>>>> not
>>>> |
>>>> provable
>>>> / \
>>>> F not
>>>> |
>>>> G
>>>>
>>>> What fails is not the negation. No negation is semantically
>>>> taken of anything. All that fails is syntactic unification,
>>>>
>>>> the only predication that was invoked was unify_with_occurs_check/2.
>>>> No predication not/1 or provable/2 was invoked.
>>>>
>>>> The unification fails, because the result of binding G to
>>>> the syntax term tree not(provable(F, not(G))) would result
>>>>
>>>> in a loop, and the syntax term would not anymore be a tree:
>>>>
>>>> v--------+
>>>> not |
>>>> | |
>>>> provable |
>>>> / \ |
>>>> F not |
>>>> | |
>>>> G |
>>>> +-----+
>>>>
>>>
>>> Yes very good you understand it completely. I show this same thing on
>>> page (3) of my paper.
>>>
>>> https://www.researchgate.net/publication/350789898_Prolog_detects_pathological_self_reference_in_the_Godel_sentence
>>>
>>>
>>> It cannot even be evaluated for provability because it has a cycle in
>>> its syntactic specification.
>>> ?- G = not(provable(F, G)).
>>> Since it cannot even be evaluated for provability because of this cycle
>>> we can know that it is it neither provable nor disprovable because the
>>> process of provability or disprovability cannot even begin.
>>>
>>> Since the expression can neither be proven nor disproven it exactly
>>> meets the conventional definition of Incompleteness:
>>> Incomplete(T) ↔ ∃φ ((T ⊬ φ) ∧ (T ⊬ ¬φ))
>>> This proves that the conventional definition of incompleteness decides
>>> that a formal system is incomplete on the basis that this formal system
>>> cannot prove erroneous expressions of a formal language.
>>>
>>> The 1931 Gödel Incompleteness theorem proving that formal systems of
>>> arithmetic are incomplete is anchored faulty definition of
>>> "incompleteness".
>>>> olcott schrieb am Sonntag, 11. April 2021 um 21:34:25 UTC+2:
>>>>> On 4/11/2021 11:08 AM, Mostowski Collapse wrote:
>>>>>> Olcott misused Prolog. The outcome of LP = not(true(LP))
>>>>>> depends on the occurs check flag.
>>>>>>
>>>>>> /* SWI-Prolog 8.3.21 */
>>>>>> ?- set_prolog_flag(occurs_check, false).
>>>>>> true.
>>>>>>
>>>>>> ?- LP = not(true(LP)).
>>>>>> LP = not(true(LP)).
>>>>>>
>>>>>> ?- set_prolog_flag(occurs_check, true).
>>>>>> true.
>>>>>>
>>>>>> ?- LP = not(true(LP)).
>>>>>> false.
>>>>>>
>>>>>> But indeed nothing to do with Gödel, since (=)/2 in Prolog
>>>>>> is so called syntactic equality.
>>>>>>
>>>>>
>>>>> Setting the unification default has nothing to do with the assessment of
>>>>> whether a Prolog expression is or is not cyclic.
>>>>> https://www.swi-prolog.org/pldoc/man?section=flags#flag:occurs_check
>>>>>
>>>>> These three Prolog expressions being tested are not provable BECAUSE
>>>>> THEY ARE CYCLIC thus Erroneous:
>>>>>
>>>>> ?- unify_with_occurs_check(LP, not(true(LP))).
>>>>> false.
>>>>> ?- unify_with_occurs_check(G, not(provable(F, G))).
>>>>> false.
>>>>>
>>>>> and its negation also fails
>>>>> ?- unify_with_occurs_check(G, not(provable(F, not(G)))).
>>>>> false.
>>>>> Since the latter pair meet the definition of Incompleteness:
>>>>> Incomplete(T) ↔ ∃φ ((T ⊬ φ) ∧ (T ⊬ ¬φ))
>>>>> That proves that they are logically equivalent to the Gödel sentence.
>>>>>
>>>>> In this case instead of merely knowing that the sentence and its
>>>>> negation are unprovable we also know WHY THE SENTENCE AND ITS NEGATION
>>>>> ARE UNPROVABLE, THE SENTENCE AND ITS NEGATION ARE ERRONEOUS.
>>>>>
>>>>>
>>>>>> Peter schrieb am Sonntag, 11. April 2021 um 17:32:13 UTC+2:
>>>>>>> olcott wrote:
>>>>>>>> On 4/11/2021 12:50 AM, Jeff Barnett wrote:
>>>>>>>>> On 4/10/2021 11:12 PM, olcott wrote:
>>>>>>>>>> On 4/10/2021 11:27 PM, Jeff Barnett wrote:
>>>>>>>>>>> On 4/10/2021 9:26 PM, olcott wrote:
>>>>>>>>>>>> On 4/9/2021 6:16 PM, olcott wrote:
>>>>>>>>>>>>> Clocksin and Mellish says that this fails an occurs check:
>>>>>>>>>>>>> ?- equal(foo(Y), Y).
>>>>>>>>>>>>>
>>>>>>>>>>>>> 254 Chapter 10 The Relation of Prolog to Logic
>>>>>>>>>>>>> Programming in Prolog Using the ISO Standard Fifth Edition by
>>>>>>>>>>>>> Clocksin
>>>>>>>>>>>
>>>>>>>>>>>>> and Mellish
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> Does that mean that this also fails an occurs check:
>>>>>>>>>>>>> ?- equal(foo(X,Y), Y).
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> ?- G = not(provable(F, G)). % G = ¬(F ⊢ G)
>>>>>>>>>>>> ?- unify_with_occurs_check(G, not(provable(F, G))).
>>>>>>>>>>>> false.
>>>>>>>>>>>>
>>>>>>>>>>>> and its negation also fails
>>>>>>>>>>>>
>>>>>>>>>>>> ?- G = not(provable(F, not(G))). % G = ¬(F ⊢ ¬G)
>>>>>>>>>>>> ?- unify_with_occurs_check(G, not(provable(F, not(G)))).
>>>>>>>>>>>> false.
>>>>>>>>>>>>
>>>>>>>>>>>> Thus meeting this conventional definition of incompleteness:
>>>>>>>>>>>> Incomplete(T) ↔ ∃φ ((T ⊬ φ) ∧
>>>>>>>>>
>>>>>>>>>>> (T ⊬ ¬φ))
>>>>>>>>>>>>
>>>>>>>>>>>> Therefore proving equivalence to the actual Gödel sentence.
>>>>>>>>>>>>
>>>>>>>>>>>> https://www.researchgate.net/publication/350789898_Prolog_detects_pathological_self_reference_in_the_Godel_sentence
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Congratulations! You have added Prolog to the list of topics that
>>>>>>>>>>> you don't really understand. The above reminds me a bit of
>>>>>>>>>>> Wisenbaum's Eliza. (Also called the Doctor and a direct ancestor of
>>>>>>>>>>> Perry the Paranoid.) In the above, substitute the word "constipated"
>>>>>>>>>>> for "provable". Then your result reads:
>>>>>>>>>>>
>>>>>>>>>>> "?- unify_with_occurs_check(G, not(constipated(F, not(G))))"
>>>>>>>>>>>
>>>>>>>>>>> and that shows exactly nothing to do with anything. So PO now has a
>>>>>>>>>>> theory of bowel movements but not those TM encodings promised so
>>>>>>>>>>> long ago. I suggest, to you, that you grab a book on logic and a
>>>>>>>>>>> bottle of Miralax and get on with it.
>>>>>>>>>>
>>>>>>>>>> Jackasses can be naysayers because it doesn't require any knowledge
>>>>>>>>>> or intelligence.
>>>>>>>>>>
>>>>>>>>>> I know that this particular understanding of Prolog is correct on the
>>>>>>>>>> basis of a whole logic system that I created named Minimal Type Theory.
>>>>>>>>>
>>>>>>>>>> This logic system translates expression of its language into directed
>>>>>>>>>> graphs.
>>>>>>>>>>
>>>>>>>>>> As I show in the above paper the logic sentence really is cyclic in
>>>>>>>>>> both Minimal Type Theory (MTT) and Prolog.
>>>>>>>>>>
>>>>>>>>>> Here is the formal YACC grammar for MTT:
>>>>>>>>>> https://www.researchgate.net/publication/331859461_Minimal_Type_Theory_YACC_BNF
>>>>>>>>>
>>>>>>>>>
>>>>>>>>> What does any of this have to do with my comments? Are you really so
>>>>>>>>> disassociated with reality? It's mind boggling. Did you try
>>>>>>>>> substituting "constipated" for "provable"? What did the expert find
>>>>>>>>> happening? Just curious. When I wrote the above, I began to wonder how
>>>>>>>>> much Eliza script would be needed to create a PO out of the vacuum. I
>>>>>>>>> think I might have some old Lisp code lying around; if I can find it,
>>>>>>>>> maybe I'll try to write that script. Then we can see if anyone can
>>>>>>>>> tell the difference. It would be a reverse Turing test: see if anyone
>>>>>>>>> can tell the difference between a duffus and the computer instead of a
>>>>>>>>> human and a computer. What do you think?
>>>>>>>>
>>>>>>>> The verifiable fact is that G = not(provable(F, G)). is indeed not
>>>>>>>> provable and its negation is G = not(provable(F, not(G))). is not
>>>>>>>> provable thus meeting the definition of Incompleteness:
>>>>>>>> Incomplete(T) ↔ ∃φ ((T ⊬ φ) ∧ (T ⊬ ¬φ))
>>>>>>>>
>>>>>>>> Because this simplified expression and its negation meet the definition
>>>>>>>> of incompleteness that proves that they are equivalent to Gödel's actual
>>>>>>>> logic sentence.
>>>>>>> Gödel's Bew(x) doesn't say x is provable. It says that x is the Gödel
>>>>>>> number of a provable formula. It is often asserted that the Gödel
>>>>>>> formula is
>>>>>>>
>>>>>>> I am not provable.
>>>>>>>
>>>>>>> It isn't. It can't be. Gödel is concerned with theories of arithmetic
>>>>>>> and theories of arithmetic are about the natural numbers under addition
>>>>>>> and multiplication. They are not about formulae and the provability or
>>>>>>> otherwise of formulae. I have told you this a million times. Will you
>>>>>>> never get it?
>>>>>>>>
>>>>>>>> The analogy between this result and Richard’s antinomy leaps to the eye;
>>>>>>>> there is also a close relationship with the “liar” antinomy,14 since the
>>>>>>>> undecidable proposition [R(q); q] states precisely that q belongs to K,
>>>>>>>> i.e. according to (1), that [R(q); q] is not provable. We are therefore
>>>>>>>> confronted with a proposition which asserts its own unprovability.15
>>>>>>>>
>>>>>>>> 14 Every epistemological antinomy can likewise be used for a similar
>>>>>>>> undecidability proof. (Gödel:1931:40).
>>>>>>> Why not quote footnote 15 while you're at it?
>>>>>>>
>>>>>>> "Contrary to appearances, such a proposition involves no faulty
>>>>>>> circularity, for initially it [only] asserts that a certain well-defined
>>>>>>> formula (namely the one obtained from the qth formula in the
>>>>>>> lexicographical order by a certain substitution) is unprovable. Only
>>>>>>> subsequently (and so to speak by chance) does it turn out that this
>>>>>>> formula is precisely the one by which the proposition was itself expressed."
>>>>>>>>
>>>>>>>> The key new knowledge is that we can know why they are not provable
>>>>>>>> unlike diagonalization which only proves that they are unprovable.
>>>>>>>>
>>>>>>>> They are unprovable because they have an infinitely recursive (cyclic)
>>>>>>>> structure.
>>>>>>>>
>>>>>>>> ?- LP = not(true(LP)).
>>>>>>>> LP = not(true(LP)).
>>>>>>>>
>>>>>>>> ?- unify_with_occurs_check(LP, not(true(LP))).
>>>>>>>> false.
>>>>>>>>
>>>>>>>> Godel, Kurt 1931. On Formally Undecidable Propositions of Principia
>>>>>>>> Mathematica And Related Systems I, page 39-41.
>>>>>>>>
>>>>>>>>
>>>>>>>
>>>>>>>
>>>>>>> -- 
>>>>>>> Just as 'beautiful' points the way for aesthetics and 'good' for ethics,
>>>>>>> so do words like 'true' for logic. All sciences have truth as their
>>>>>>> goal; but logic is also concerned with it in a quite different way:
>>>>>>> logic has much the same relation to truth as physics has to weight or
>>>>>>> heat. Frege in 'Thoughts' (Der Gedanke)
>>>>> -- 
>>>>> Copyright 2021 Pete Olcott
>>>>>
>>>>> "Great spirits have always encountered violent opposition from mediocre
>>>>> minds." Einstein
>>>
>>>
>>> -- 
>>> Copyright 2021 Pete Olcott
>>>
>>> "Great spirits have always encountered violent opposition from mediocre
>>> minds." Einstein


-- 
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre 
minds." Einstein

[toc] | [prev] | [next] | [standalone]


#11820 — Re: Simplified Gödel sentence fails Prolog occurs check---> ?- G = not(provable(F, G)).

Fromolcott <NoOne@NoWhere.com>
Date2021-04-12 10:10 -0500
SubjectRe: Simplified Gödel sentence fails Prolog occurs check---> ?- G = not(provable(F, G)).
Message-ID<Gb6dnc9DLpla_-n9nZ2dnUU7-fnNnZ2d@giganews.com>
In reply to#11814
On 4/11/2021 9:11 PM, Kaz Kylheku wrote:
> On 2021-04-12, André G  Isaak <agisaak@gm.invalid> wrote:
>> On 2021-04-11 17:57, olcott wrote:
>>> So if s=t cannot be proved and s=not(t) cannot be proved then the
>>> inherently erroneous definition of incompleteness that Gödel's 1931
>>
>> How on earth can a definition be 'inherently erroneous'? The definition
> 
> For instance, here is a dubious definition of a binary tree:
> 
>   - A binary tree consists of a finite number of nodes.
> 
>   - The root node of a binary tree is a node with two children, left and
>     right, which are also binary trees.
> 
> This definition is incomplete. It has only one constraint rule and one
> structural rule. The structural rule makes use of the definition itself,
> leading to nothing but infinite regress. That infinite regress could be
> acceptable by itself, but it implies an infinite number of nodes, which
> contradicts the structural rule.
> 
>> of incompleteness is what it is. You can argue about whether the
>> property it describes is interesting or not, but you can't claim that
>> the definition is 'erroneous'.
> 
> That simply because it isn't erroneous.

If a sentence in neither provable nor disprovable because the sentence 
is an erroneous infinite term then the formal system is deemed 
incomplete. It is incorrect to call a system incomplete when it is not 
in any way actually incomplete.

> 
> It potentially could have been, but in that case it would not be waiting
> almost a century for some dim-witted Usenet crank to identify that
> situation.
> 
> If you read enough mathematics papers from the 1930's, you can probably
> hit upon some erroneous definition. It's just vanishingly unlikely it
> would be anything that is still famous, influential and ground-breaking.
> 


-- 
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre 
minds." Einstein

[toc] | [prev] | [next] | [standalone]


#11837 — Re: Simplified Gödel sentence fails Prolog occurs check---> ?- G = not(provable(F, G)).

FromKaz Kylheku <563-365-8930@kylheku.com>
Date2021-04-13 07:03 +0000
SubjectRe: Simplified Gödel sentence fails Prolog occurs check---> ?- G = not(provable(F, G)).
Message-ID<20210412235752.487@kylheku.com>
In reply to#11820
["Followup-To:" header set to comp.theory.]
On 2021-04-12, olcott <NoOne@NoWhere.com> wrote:
> On 4/11/2021 9:11 PM, Kaz Kylheku wrote:
>> On 2021-04-12, André G  Isaak <agisaak@gm.invalid> wrote:
>>> On 2021-04-11 17:57, olcott wrote:
>>>> So if s=t cannot be proved and s=not(t) cannot be proved then the
>>>> inherently erroneous definition of incompleteness that Gödel's 1931
>>>
>>> How on earth can a definition be 'inherently erroneous'? The definition
>> 
>> For instance, here is a dubious definition of a binary tree:
>> 
>>   - A binary tree consists of a finite number of nodes.
>> 
>>   - The root node of a binary tree is a node with two children, left and
>>     right, which are also binary trees.
>> 
>> This definition is incomplete. It has only one constraint rule and one
>> structural rule. The structural rule makes use of the definition itself,
>> leading to nothing but infinite regress. That infinite regress could be
>> acceptable by itself, but it implies an infinite number of nodes, which
>> contradicts the structural rule.
>> 
>>> of incompleteness is what it is. You can argue about whether the
>>> property it describes is interesting or not, but you can't claim that
>>> the definition is 'erroneous'.
>> 
>> That simply because it isn't erroneous.
>
> If a sentence in neither provable nor disprovable because the sentence 
> is an erroneous infinite term then the formal system is deemed 

If a proposition is erroneous because of some issue of syntax, then
we can regard it as ill-formed and false.

You can't casually do that with Gödel's real sentence, though.

Gödel's sentence is fully constructed. It contains no references
at all, let alone unexpanded self-references.

That part of it that makes use of itself isn't a reference, but
a full blown, bit for bit verifiable copy, embedded right there
"by value" rather than "by reference".

> incomplete. It is incorrect to call a system incomplete when it is not 
> in any way actually incomplete.

It's incomplete when a perfectly well-formed proposition like
"The number 123739....439 doesn't belong to set Foo" cannot
be proven or disproven, when Foo is well defined, and numerous
integers can easily be tested whether they are in Foo or not
according to precise rules.


-- 
TXR Programming Language: http://nongnu.org/txr
Cygnal: Cygwin Native Application Library: http://kylheku.com/cygnal

[toc] | [prev] | [next] | [standalone]


Page 1 of 4  [1] 2 3 4  Next page →

Back to top | Article view | comp.lang.prolog


csiph-web