A junior high school level of understanding of logic

[Univalence]

This is two actual pages from Tarski's actual proof that says the inability to prove the Liar Paradox proves that True(x) is incomplete:
http://liarparadox.org/247_248.pdf

Tarski doesn't use a 4-value logic.

I know hardly anyone does. 4-value logic assumes the mathematical formalist approach
of considering everything a finite string instead of a WFF. If we assume that everything
has already been vetted as a WFF conventionally this is only two values of True and False
because everyone totally ignores the case of semantically incorrect WFF.

When we feed a self-contradictory WFF to Tarski's True(x), it cannot "decide" whether
or not the self-contradictory WFF is true or false. No one ever bothered to consider that
a self-contradictory expressions would be neither true nor false because they totally
ignore semantic error.

You are building a classifier.

Input: String
Output: {A,B,C,D}

You can have 4 buckets or 4 million. It doesn't matter. The hard part (and the algorithm I want to see) is the detection of the 'semantic error'.
So let me help you get started.
https://repl.it/repls/GiftedLastingTrials

Please fill in the blanks in the parser() function and make it raise(SemanticError) when appropriate.
I gave you a unit test and everything.

[PeteOlcott]

Tarski doesn't use a 4-value logic.

I know hardly anyone does. 4-value logic assumes the mathematical formalist approach
of considering everything a finite string instead of a WFF. If we assume that everything
has already been vetted as a WFF conventionally this is only two values of True and False
because everyone totally ignores the case of semantically incorrect WFF.

When we feed a self-contradictory WFF to Tarski's True(x), it cannot "decide" whether
or not the self-contradictory WFF is true or false. No one ever bothered to consider that
a self-contradictory expressions would be neither true nor false because they totally
ignore semantic error.

You are building a classifier.

Input: String
Output: {A,B,C,D}

You can have 4 buckets or 4 million. It doesn't matter. The hard part (and the algorithm I want to see) is the detection of the 'semantic error'.
So let me help you get started.
https://repl.it/repls/GiftedLastingTrials

Please fill in the blanks in the parser() function and make it raise(SemanticError) when appropriate.
I gave you a unit test and everything.

It is a tautology that sound deduction would partition every
element x of the exhaustively complete set of finite strings
into True(F, x) and ¬True(F, x) for every formal system F.

The fully operational parser spec, it took me 18 months to create this and the parser.
https://www.researchgate.net/publicatio ... y_YACC_BNF

[Univalence]

The fully operational parser spec, it took me 18 months to create this and the parser.
https://www.researchgate.net/publicatio ... y_YACC_BNF

What parser syntax is that? yacc ?

[PeteOlcott]

The fully operational parser spec, it took me 18 months to create this and the parser.
https://www.researchgate.net/publicatio ... y_YACC_BNF

What parser syntax is that? yacc ?

Yes that is YACC.

[Arising_uk]

...

Premise(A) All dogs are mammals.
Premise(B) All mammals breathe.
Conclusion(C) All dogs breathe.

A
B
{A, B} ⊢ C
-------------
∴ C

Just being picky but if we are using a junior school level of understanding logic then why are you using propostional logic and not predicate logic to represent an argument that uses universal quantifiers, can this even be done?

[Univalence]

Just being picky but if we are using a junior school level of understanding logic then why are you using propostional logic and not predicate logic to represent an argument that uses universal quantifiers, can this even be done?

I think all predicate logic is 2-valued. P(X) -> {0,1} ?

What he is doing is; P(X) -> {0,1, 2 ,3}

[PeteOlcott]

...

Premise(A) All dogs are mammals.
Premise(B) All mammals breathe.
Conclusion(C) All dogs breathe.

A
B
{A, B} ⊢ C
-------------
∴ C

Just being picky but if we are using a junior school level of understanding logic then why are you using propostional logic and not predicate logic to represent an argument that uses universal quantifiers, can this even be done?

This is the junior high school level
That the sound deductive inference model necessitates true
conclusions is known on the basis of the definition of the sound
deductive inference model, thus impossibly false.

[PeteOlcott]

Just being picky but if we are using a junior school level of understanding logic then why are you using propostional logic and not predicate logic to represent an argument that uses universal quantifiers, can this even be done?

I think all predicate logic is 2-valued. P(X) -> {0,1} ?

What he is doing is; P(X) -> {0,1, 2 ,3}

This is the junior high school level
That the sound deductive inference model necessitates true
conclusions is known on the basis of the definition of the sound
deductive inference model, thus impossibly false.

It divides every expression of language into True and ¬True such that
we end up with an exhaustive list of all true sentences.

[Arising_uk]

This is the junior high school level
That the sound deductive inference model necessitates true
conclusions is known on the basis of the definition of the sound
deductive inference model, thus impossibly false.

It divides every expression of language into True and ¬True such that
we end up with an exhaustive list of all true sentences.

I'm a touched confused here as apart from the contradictions and tautologies how can logic tell us which sentences are true or false? Also "every expression"? "Time flies furiously."?

[PeteOlcott]

This is the junior high school level
That the sound deductive inference model necessitates true
conclusions is known on the basis of the definition of the sound
deductive inference model, thus impossibly false.

It divides every expression of language into True and ¬True such that
we end up with an exhaustive list of all true sentences.

I'm a touched confused here as apart from the contradictions and tautologies how can logic tell us which sentences are true or false? Also "every expression"? "Time flies furiously."?

"apart from the contradictions and tautologies how can logic tell us which sentences are true or false?"
You have it exactly right, apart from contradictions (false) and tautologies (true) there is no true and false.

[Univalence]

You have it exactly right, apart from contradictions (false) and tautologies (true) there is no true and false.

Linguistically - true.
Conceptually - false.

The symbols contain no semantics.
The sentences contain no grammar.

It's only when you combine the symbols with the parser/interpreter do the concepts of "true", "false", GrammaticalError and SyntaxError appear.

Since you really are going out of your way to eliminate undecidability (e.g Turing completeness), I can't see how you are going to end up at anything other than total functions.

[PeteOlcott]

You have it exactly right, apart from contradictions (false) and tautologies (true) there is no true and false.

Linguistically - true.
Conceptually - false.

The symbols contain no semantics.
The sentences contain no grammar.

It's only when you combine the symbols with the parser/interpreter do the concepts of "true", "false", GrammaticalError and SyntaxError appear.

Since you really are going out of your way to eliminate undecidability (e.g Turing completeness), I can't see how you are going to end up at anything other than total functions.

http://mathworld.wolfram.com/TotalFunction.html
A function defined for all possible input values.

My system takes an infinite set of finite strings and selects the true
sentences of formal system F from these input strings.

This is to understand the gist of my idea so some of the ideas a simplistic to make them
easier to understand.

const int EMPTY = -1;
const int FALSE = 0;
const int TRUE = 1;

class Expression
{
std::string expression;
int Truth_Value = EMPTY;
};

std:vector<Expression> Axioms; // e.True_Value set to TRUE

bool Provable(Expression Consequence)
{
if (Formal_Proof(Axioms, Consequence))
{
Consequence.Truth_Value = TRUE;
return true;
}
return false;
}

[Univalence]

You have it exactly right, apart from contradictions (false) and tautologies (true) there is no true and false.

Linguistically - true.
Conceptually - false.

The symbols contain no semantics.
The sentences contain no grammar.

It's only when you combine the symbols with the parser/interpreter do the concepts of "true", "false", GrammaticalError and SyntaxError appear.

Since you really are going out of your way to eliminate undecidability (e.g Turing completeness), I can't see how you are going to end up at anything other than total functions.

http://mathworld.wolfram.com/TotalFunction.html
A function defined for all possible input values.

My system takes an infinite set of finite strings and selects the true
sentences of formal system F from these input strings.

This is to understand the gist of my idea so some of the ideas a simplistic to make them
easier to understand.

const int EMPTY = -1;
const int FALSE = 0;
const int TRUE = 1;

class Expression
{
std::string expression;
int Truth_Value = EMPTY;
};

std:vector<Expression> Axioms; // e.True_Value set to TRUE

bool Provable(Expression Consequence)
{
if (Formal_Proof(Axioms, Consequence))
{
Consequence.Truth_Value = TRUE;
return true;
}
return false;
}

Infinities..... OK.

How do you parse an infinitely-long string?

[PeteOlcott]

Linguistically - true.
Conceptually - false.

The symbols contain no semantics.
The sentences contain no grammar.

It's only when you combine the symbols with the parser/interpreter do the concepts of "true", "false", GrammaticalError and SyntaxError appear.

Since you really are going out of your way to eliminate undecidability (e.g Turing completeness), I can't see how you are going to end up at anything other than total functions.

http://mathworld.wolfram.com/TotalFunction.html
A function defined for all possible input values.

My system takes an infinite set of finite strings and selects the true
sentences of formal system F from these input strings.

This is to understand the gist of my idea so some of the ideas a simplistic to make them
easier to understand.

const int EMPTY = -1;
const int FALSE = 0;
const int TRUE = 1;

class Expression
{
std::string expression;
int Truth_Value = EMPTY;
};

std:vector<Expression> Axioms; // e.True_Value set to TRUE

bool Provable(Expression Consequence)
{
if (Formal_Proof(Axioms, Consequence))
{
Consequence.Truth_Value = TRUE;
return true;
}
return false;
}

Infinities..... OK.

How do you parse an infinitely-long string?

They are excluded from consideration.

[Univalence]

http://mathworld.wolfram.com/TotalFunction.html
A function defined for all possible input values.

My system takes an infinite set of finite strings and selects the true
sentences of formal system F from these input strings.

This is to understand the gist of my idea so some of the ideas a simplistic to make them
easier to understand.

const int EMPTY = -1;
const int FALSE = 0;
const int TRUE = 1;

class Expression
{
std::string expression;
int Truth_Value = EMPTY;
};

std:vector<Expression> Axioms; // e.True_Value set to TRUE

bool Provable(Expression Consequence)
{
if (Formal_Proof(Axioms, Consequence))
{
Consequence.Truth_Value = TRUE;
return true;
}
return false;
}

Infinities..... OK.

How do you parse an infinitely-long string?

They are excluded from consideration.

How?

How do you make sure that one of the strings in your infinite set aren’t infinite-length?

How do you check that the length of a string is infinite?