Re: Mathematical incompleteness has always been a misconception --- Tarski

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

On 3/5/2025 5:41 PM, Richard Damon wrote:

On 3/5/25 9:25 AM, olcott wrote:

On 3/4/2025 10:59 PM, Richard Damon wrote:

On 3/4/25 9:25 PM, olcott wrote:

On 3/4/2025 5:45 PM, Richard Damon wrote:

On 3/4/25 9:47 AM, olcott wrote:

On 3/4/2025 6:29 AM, Richard Damon wrote:

On 3/3/25 10:24 PM, olcott wrote:

On 3/3/2025 7:07 PM, Richard Damon wrote:

On 3/3/25 7:38 PM, olcott wrote:

On 3/3/2025 9:05 AM, Mikko wrote:

On 2025-03-01 19:42:50 +0000, olcott said:
>

On 3/1/2025 2:37 AM, Mikko wrote:

On 2025-02-28 21:58:34 +0000, olcott said:
>

On 2/28/2025 3:56 AM, Mikko wrote:

On 2025-02-26 14:42:23 +0000, olcott said:
>

On 2/26/2025 3:12 AM, Mikko wrote:

On 2025-02-25 21:07:31 +0000, olcott said:
>

On 2/25/2025 9:27 AM, Mikko wrote:

On 2025-02-24 21:31:26 +0000, olcott said:
>

On 2/24/2025 2:51 AM, Mikko wrote:

On 2025-02-22 17:24:59 +0000, olcott said:
>

On 2/22/2025 3:12 AM, Mikko wrote:

On 2025-02-21 23:22:23 +0000, olcott said:
>

On 2/20/2025 3:01 AM, Mikko wrote:

On 2025-02-18 13:50:22 +0000, olcott said:
>

There is nothing like that in the following concrete example:
LP := ~True(LP)
>
In other words you are saying the Prolog is incorrect
to reject the Liar Paradox.
>
Above translated to Prolog
>
?- LP = not(true(LP)).
LP = not(true(LP)).

>
According to Prolog rules LP = not(true(LP)) is permitted to fail.
If it succeeds the operations using LP may misbehave. A memory
leak is also possible.
>

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

>
This merely means that the result of unification would be that LP conains
itself. It could be a selmantically valid result but is not in the scope
of Prolog language.
>

>
It does not mean that. You are wrong.

>
It does in the context where it was presented. More generally,
unify_with_occurs_check also fails if the arguments are not
unfiable. But this possibility is already excluded by their
successfull unification.

>
IT CANNOT POSSIBLY BE SEMANTICALLY VALID

>
Of course it is. Its semantics is well defined by the Prolog standard.

>
Go freaking read the Clocksin and Mellish.
an "infinite term" means NOT SEMANTICALLY VALID.

>
Prolog does not define any semantics other than the execution semantics
of a prolog program. Therefore no data structure has any own semantics.
>
The result of the exectution of an instruction like LP == not(true(LP))
is not fully defined by the standard so we may say that that instruction
is semantically invalid.
>

>
When we ask for Prolog to determine whether an expression
in Prolog is true according to its facts and rules and the
evaluation of the expression gets stuck in an infinite loop
then this expression IS SEMANTICALLY INCORRECT.

>
Which is not done anywhere above.
>

>
In other words you can't remember things that I said
a few messages ago and I have to endlessly repeat everything
every time?

>
Is this just an instance or your favorite sin? If not, what do you think
I didn't remember?
>

page 3 has the liar paradox and the Cloksin & Mellish Quote
https://www.researchgate.net/ publication/350789898_Prolog_detects_and_rejects_pathological_self_reference_in_the_Godel_sentence

>
It just says that your prolog system is defective as it does not reject
your LP = not(true(LP)). The Prolog standard says that this operation may
but need not fail. It also cortectly says that
 LP = not(true(LP)), write(LP)
would not work.

>
There is no "need not fail" Clocksin and Mellish says
impossible to succeed (paraphrase).

>
No, that is not said. In a footnote they say that the behaviour is undefined,
i.e., an implementation may choose what to do. They do say that a typical
implementation does not fail, which implies "need not fail".
>

More precisely it says that there is a cycle in the
directed graph of the evaluation sequence of the expression.

>
Assuming that the unification does not fail.
>

That you fail to understands that the following means this
is your lack of understanding not my mistake.
>
?- LP = not(true(LP)).
LP = not(true(LP)).

>
It means that the pariticular implementation you used exploited the
"need not fail" permission, producing a cycle in the data structure.
>

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

>
For this operation there is no "need not fail". The standard specifies that
the operation must fail.
>

Because the Prolog Liar Paradox has an “uninstantiated subterm of itself” we can know that unification will fail because it specifies “some kind of infinite structure.”

>
Wrong. You above said that the unification LP = not(true(LP)) did not
fail. It may fail on another implementation but that is not required.
>

Go back and read the Clocksin and Mellish example and quote on
the same page until you totally understand it. You only need
example the yellow highlighted text.

>
The supreme authority is not Clocksin and Mellish but ISO/ IEC 13211.

>
Clocksin and Mellish concretely show the result of the
infinitely recursive structure of their concrete example.

>
Irrelevant.
>

>
Your above replies prove that you do not understand this
thus cannot correctly say that it is irrelevant.
>
Prolog determines that all expressions that are
isomorphic to their concrete example are semantically
incorrect because these expressions have an infinitely
recursive structure.
>
>
>

>
In the logic that Prolog supports, which is very limited.

>
No that is not it. You don't seem to understand
the idea that an infinite loop is an error.

>
No, an infinite loop is NOT and error for determining truth, it would be for a proof.
>
>
For instance, the fact that G is made true by the infinite loop of testing with a finite test for EVERY Natural Number,

>
The infinite loop prevents any testing from being performed
LP := ~True(LP)  specifies: ~True(~True(~True(~True(~True(~True(...))))))
As Clocksin and Mellish show on their example.
>

>
Nope. Because the concept of that substitution is just invalid.
>

>
Ignoring Closksin and Mellish is a dishonest rebuttal
>

>
Closksin and Mellish are talking PROLOG, not LOGIC.
>

>
They are talking about a specific generic logical an anomaly
that applies to the entire class of decision problems having
pathological self-reference they are using Prolog to make their
explanation concrete.

>
Which isn't the class of problems we are talking about.
>

 LP := ~True(LP)
 

Which is the SIMPIFIED form of the expresion.
read what Tarski actually wrote.
The actual "expression" for p was not given, just that it was shown to have the property that its value was the opposite of True(p).
This is based on the same sort of logic that Godel's G is built on, that we can express a lot of logic as mathematics.
Of course, when you can't understand that basis, you misunderstand the simplifications given.