Conceptual Truth can be understood as math

[PeteOlcott]

I was being sarcastic about the actual need for model theory.

Well, that's ironic since in Tarski's universe English is the metalanguage and formalisms are the object language.

Yes this was his biggest mistake. There is no actual need to this distinction.
A language can define ALL of its own semantics. His whole undefinability
theorem is entirely based on the inability to prove that the liar paradox is true.

[Skepdick]

Yes this was his biggest mistake. There is no actual need to this distinction.

It's only an important analytic distinction in so far as you end up understanding homoiconicity

And you don't understand it!

A language can define ALL of its own semantics. His whole undefinability
theorem is entirely based on the inability to prove that the liar paradox is true.

Correct! You cannot build ANY system in which you can evaluate the Liar's paradox.

Do you understand the difference between definition and evaluation?

I can DEFINE 1+1+1
I need to EVALUATE it to 3.

You can DEFINE True to mean Boolean:True (just as well as you can DEFINE True to mean Integer:42)
But you cannot EVALUATE "This sentence is false" to Boolean:True, or Integer:42

https://en.wikipedia.org/wiki/Dependent_type

[PeteOlcott]

A language can define ALL of its own semantics. His whole undefinability
theorem is entirely based on the inability to prove that the liar paradox is true.

Correct! You cannot build ANY system in which you can evaluate the Liar's paradox.

I already designed the architecture of a system that evaluates the Liar Paradox
to be semantically incoherent for several different reasons.
(1) It is infinitely recursive.
(2) It is self-contradictory.

In neither case can it possibly have a Boolean property.

[Skepdick]

I already designed the architecture of a system that evaluates the Liar Paradox
to be semantically incoherent for several different reasons.
(1) It is infinitely recursive.

You are an idiot. We already covered the totality of recursive functions.

(2) It is self-contradictory.

Bullshit. The very definition of a 'contradiction' is P ∧ ¬P.

How do you determine whether a statement is 'contradictory' if you can't even determine it's truth (or falsity) value?

[PeteOlcott]

I already designed the architecture of a system that evaluates the Liar Paradox
to be semantically incoherent for several different reasons.
(1) It is infinitely recursive.

You are an idiot. We already covered the totality of recursive functions.

(2) It is self-contradictory.

Bullshit. The very definition of a 'contradiction' is P ∧ ¬P.

How do you determine whether a statement is 'contradictory' if you can't even determine it's truth (or falsity) value?

Infinitely recursive is the same as a function that gets stuck in an infinite loop:
bool True(std::string: LP)
{
return !True(LP);
}

When the Liar Paradox is defined as directly self-referential it gets stuck in infinite recursion and has no Boolean value.

When the Liar Paradox is defined a logically equivalent to the negation of its own truth value it
has no Boolean value because it is self-contradictory.

[Skepdick]

Infinitely recursive is the same as a function that gets stuck in an infinite loop:

You don't know if any particular function is stuck in an infinite loop, Pete.

The answer is either Maybe (because the function is still running), or "No" (because the function terminated).

How many bloody times do I have to explain totality to you ?!?

When the Liar Paradox is defined a logically equivalent to the negation of its own truth value it
has no Boolean value because it is self-contradictory.

How the fuck do you negate the truth-value of a function whose truth-value you haven't yet determined?

You are seriously planning to waste 20 years of my life also, aren't you?

[PeteOlcott]

Infinitely recursive is the same as a function that gets stuck in an infinite loop:

You don't know if any particular function is stuck in an infinite loop, Pete.

I DO KNOW THAT THE LIAR PARADOX SPECIFIES INFINITE RECURSION !!!

bool True(std::string: LP)
{
return !True(LP);
}

[Skepdick]

I DO KNOW THAT THE LIAR PARADOX SPECIFIES INFINITE RECURSION !!!

But there are OTHER FORMS OF RECURSION, whose infinity you cannot decide!

[PeteOlcott]

When the Liar Paradox is defined a logically equivalent to the negation of its own truth value it
has no Boolean value because it is self-contradictory.

How the fuck do you negate the truth-value of a function whose truth-value you haven't yet determined?

The Formalized Liar Paradox says that P is materially equivalent to Not True.
The truth table shows that this is self-contradictory.
P ↔ ¬True(P)
T--F-----F // When you hypothesize that it is True this is contradicted.
F--F-----T // When you hypothesize that it is False this is contradicted.

[Skepdick]

it has no Boolean value because it is self-contradictory.

Pete, the sentence above is false!

A contradiction is defined as P ∧ ¬P ⇔ False
If P does NOT have a Boolean value, then P ∧ ¬P IS NOT False!

https://repl.it/repls/HonestExtraneousObjectpool

Code: Select all

P = None
print(P and not P) # None
P = True
print(P and not P) # False
P = False
print(P and not P) # False

The Formalized Liar Paradox says that P is materially equivalent to Not True.

And in the "fuck you" version of the paradox, the string "This sentence is false" has no truth-value. It's your job to parse it and assign it one.

If you are assuming the truth-value of strings before you've even bothered to evaluated them - you might as well be flipping a coin.

[PeteOlcott]

it has no Boolean value because it is self-contradictory.

Pete, the sentence above is false!

A contradiction is defined as P ∧ ¬P ⇔ False
If P does NOT have a Boolean value, then P ∧ ¬P IS NOT False!

https://repl.it/repls/HonestExtraneousObjectpool

Code: Select all

P = None
print(P and not P) # None
P = True
print(P and not P) # False
P = False
print(P and not P) # False

The Formalized Liar Paradox says that P is materially equivalent to Not True.

And in the "fuck you" version of the paradox, the string "This sentence is false" has no truth-value. It's your job to parse it and assign it one.

If you are assuming the truth-value of strings before you've even bothered to evaluated them - you might as well be flipping a coin.

We can see in advance that neither truth value works for the Liar Paradox
because in each case the truth value of the expression's assertion contradicts
the truth value of its satisfaction.

This is my key unique insight copyright 2016 Pete Olcott

https://www.researchgate.net/publicatio ... ar_Paradox
When we explicitly divide mathematical propositions into their two semantic properties:
(1) Assertion // What it is claiming to be true
(2) Boolean.Value // Whether or not this assertion is satisfied

We sometimes find that the satisfaction of the assertion contradicts the assertion
itself, thus making the expression of language self contradictory. Whenever this
happens the expression is unsatisfiable and thus erroneous.

[Skepdick]

We can see in advance that neither truth value works for the Liar Paradox
because in each case the truth value of the expression's assertion contradicts
the truth value of its satisfaction.

WHAT TRUTH-VALUE?

You admitted that you can't EVALUATE the liar's paradox because it's an infinite loop. Right here:

I DO KNOW THAT THE LIAR PARADOX SPECIFIES INFINITE RECURSION !!!

HOW do you assign a truth-value to a statement that you haven't evaluated except by ASSUMING one?

https://repl.it/repls/VelvetyLightpinkIntroductory

Code: Select all

def true(p):
  return true(not p) 

# ASSUME P=False
p = False
true(p)
Traceback (most recent call last):
  File "main.py", line 2, in true
    return true(not p)
  [Previous line repeated 996 more times]
RecursionError: maximum recursion depth exceeded

[PeteOlcott]

We can see in advance that neither truth value works for the Liar Paradox
because in each case the truth value of the expression's assertion contradicts
the truth value of its satisfaction.

WHAT TRUTH-VALUE?

You admitted that you can't EVALUATE the liar's paradox because it's an infinite loop. Right here:

I DO KNOW THAT THE LIAR PARADOX SPECIFIES INFINITE RECURSION !!!

HOW do you assign a truth-value to a statement that you haven't evaluated except by ASSUMING one?

https://repl.it/repls/VelvetyLightpinkIntroductory

Code: Select all

def true(p):
  return true(not p) 

# ASSUME P=False
p = False
true(p)
Traceback (most recent call last):
  File "main.py", line 2, in true
    return true(not p)
  [Previous line repeated 996 more times]
RecursionError: maximum recursion depth exceeded

There are two distinctly different ways to evaluate the two distinctly different formalizations of the Liar Paradox:
LP := ~True(LP) // Actual self-reference derives infinite recursion.
LP ↔ ~True(LP) // Not Actual self-reference Logically equivalence to its own negation produces a contradiction

[Skepdick]

There are two distinctly different ways to evaluate the two distinctly different formalizations of the Liar Paradox:
LP := ~True(LP) // Actual self-reference derives infinite recursion.
LP ↔ ~True(LP) // Not Actual self-reference Logically equivalence to its own negation produces a contradiction

Pete, the return-type of the True() function is a Boolean! If True(String:X) returns Boolean:False, then ~True(String:X) evaluates to Boolean:True.
Even with a statically-typed language like C++ to hold your hand you keep making type errors. How far up your ass is your head?

String:True is not the same thing as Boolean:True is not the same thing as Function:True

https://repl.it/repls/KnobbyCarefulMap

[PeteOlcott]

There are two distinctly different ways to evaluate the two distinctly different formalizations of the Liar Paradox:
LP := ~True(LP) // Actual self-reference derives infinite recursion.
LP ↔ ~True(LP) // Not Actual self-reference Logically equivalence to its own negation produces a contradiction

Pete, the return-type of the True() function is a Boolean! If True(String:X) returns Boolean:False, then ~True(String:X) evaluates to Boolean:True.

You can't see that is self-contradictory ?