Content uploaded by PL Olcott

Author content

All content in this area was uploaded by PL Olcott on Apr 14, 2017

Content may be subject to copyright.

Minimal Type Theory (MTT)

Minimal type theory (MTT) is based on type theory in that it is agnostic about predicate logic

order and expressly disallows the evaluation of incompatible types. It is called minimal because

it has the fewest possible number of fundamental types, and has all of its syntax is expressed

entirely as directed paths between nodes of a directed acyclic graph (DAG).

Rudolf Carnap formalized the semantic meaning of otherwise meaningless propositional

variables in his (1952) Meaning Postulates. The axiom: Bachelor(x) ↔ ~Married(x) formalizes

the semantic meaning of one aspect of these two English words using FOPL.

Minimal type theory applies meaning postulates to formalize (in a knowledge ontology) the

semantic meaning of variables representing formal language abstractions. Sentential variables

are simply the DAG node number of the root node of an MTT sentence, allowing a sentence to

easily refer to itself.

MTT is a form of type theory that "borrows" its syntax from first order predicate logic (FOPL).

Relations of MTT (corresponding to FOPL predicates) are connected to their terms by outward

directed paths from the Relation to its terms. Every element of MTT corresponding to an

element of FOPL { Predicate, Term, Logical-Symbol } has its own a directed acyclic graph node.

MTT has only two basic types (units of sub-atomic semantic compositionality):

(1) Relations // Predicates of some finite order Predicate Logic

(2) Non-Relations // Nodes having no outward directed paths

Syntactic-Logical-Consequence(Γ, x) Is a binary predicate within FOPL syntax defined as:

A formula x is a syntactic consequence within some formal system L of a set Γ of formulas if

there is a formal proof in L of x from the set Γ. // short-hand: (Γ

x)

Formalism (philosophy of mathematics)

Every formal system referenced in this paper is analyzed entirely within the foundational

premise that all formal systems are comprised entirely of finite strings representing WFF that

specify finite string rewrite rules. Example: "P (P → Q)" can be rewritten as "Q". We use

finite strings as our basis only to avoid the presupposition that a finite string represents a WFF.

Types must be expressly stated in Minimal Type Theory

L Formal Systems, x L, Γ L | (Γ

x)

x L --- x is one element of the set of WFF of L.

Γ L --- Γ is a subset of the WFF of L.

Γ

x --- x is the syntactic logical consequence of Γ.

When-so-ever an expression requires the insertion of a cycle in the MTT (otherwise acyclic)

directed graph this cycle indicates pathological self-reference (PSR). Pathological self-reference

causes the evaluation of an expression to form an infinite loop.

Seven is greater than five. "Greater-Than(Seven, Five)"

(1) Greater-Than --->(2)(3) // binary tree, thus not an evaluation infinite loop

(2) Seven

(3) Five

1

Liar Paradox formalized as Predicate Logic syntax and semantics formalized as MTT.

// Defining Tarski’s (1933) Formal correctness of True: x True(x) ↔ φ(x)

L Formal Systems x finite strings, Γ L ( (Γ

x) ↔ True(x) )

The above formula template defines the semantic meaning of Boolean-True within the

metalanguage of MTT. This formula template is applied by establishing a bijective mathematical

mapping between the MTT formula template and the corresponding syntax of each individual

formal system’s object language, thus defining True(x) within each formal system.

"This sentence is not true" FOPL: x = "~True(x)"

Minimal Type Theory (MTT) Directed Acyclic Graph (DAG) of Liar Paradox

(1) Negation —> (2) // x is an alias for this node

(2) True —> (1) // cycle indicates error: evaluation infinite loop

"This sentence is not true" FOPL: x = "~ Γ L | (Γ

x)"

Minimal Type Theory (MTT) Directed Acyclic Graph (DAG) of Liar Paradox

(1) Negation —> (2) // x is an alias for this node

(2) There-Exists —> (3)(6)

(3) Subset of —> (4)(5)

(4) Γ

(5) L

(6) Such-That —> (7)

(7) Syntactic-Logical-Consequence —> (4)(1) // cycle indicates error: evaluation infinite loop

The above formalism proves that the Liar Paradox is not a truth bearer because it gets stuck in

an infinite evaluation loop. Because it is not a truth bearer, the Liar Paradox is not a

semantically correct logical sentence. This same analysis equally applies to the (Truth Teller

Paradox) Negation of the Liar Paradox: x = " Γ L | (Γ

x)".

2

1 2 3 45 6 7

1 2

Formalizing (the semantics of) Gödel’s (1931) incompleteness theorem using MTT

// Terminology comes from Nagel, Newman, and Hofstadter pages 96-97

// G = Gödel_Number( "~( x) | (x

G)" ) // Where G, x are Gödel numbers of PM

G = "~ x PM | (x

G)"

Minimal Type Theory (MTT) Directed Acyclic Graph (DAG) of Incompleteness Theorem

(1) Negation —> (2) // G is an alias for this node

(2) There-Exists —> (3)(6)

(3) Subset of —> (4)(5)

(4) x

(5) PM

(6) Such-That —> (7)

(7) Syntactic-Logical-Consequence —> (4)(1) // cycle indicates error: evaluation infinite loop

When we formalize Kurt Gödel’s (1931) first incompleteness theorem using MTT we see that

exactly like the Liar Paradox the expression named G above is not a logical sentence of any

formal system because its evaluation gets stuck in an loop.

https://plato.stanford.edu/entries/goedel-incompleteness/

The first incompleteness theorem states that in any consistent formal system F within which a

certain amount of arithmetic can be carried out, there are statements of the language of F which

can neither be proved nor disproved in F.

As the above Minimal Type Theory formalization of Kurt Gödel’s (1931) first incompleteness

theorem unequivocally shows the conclusion of this theorem is incorrect. Kurt Gödel really only

proved that some logical expressions that are not statements of the language of F cannot be

proved in F.

Kurt Gödel made this mistake because (at the time) there was no way to formalize the semantic

meaning of logical expressions, thus the correctness of this expression was only validated as a

syntactically WFF.

Concrete example for the specific Formal System of the Peano Arithmetic

Less-Than < operator defined using Peano Arithmetic

a < b ↔ c

| ( ( a ≠ b ) ( b = a + c ) )

x = "7 > 3" finite strings, Γ Peano Arithmetic ( (Γ

x) ↔ True(x) )

x = "7 < 3" finite strings, ~ Γ Peano Arithmetic ( (Γ

x) ↔ ~True(x) )

x = "7 < 3" finite strings, Γ Peano Arithmetic ( (Γ

~x) ↔ False(x) )

x = "jx2dr" finite strings, ~ Γ Peano Arithmetic ( (Γ

x) ↔ ~True(x) )

x = "jx2dr" finite strings, ~ Γ Peano Arithmetic ( (Γ

~x) ↔ ~False(x) )

Since we were able to complete Alfred Tarski’s (1933) formal correctness of True(x) formula,

(correctly refuting his (1936) undefinability theorem) when-so-ever the predicate Truth-Bearer(x)

evaluates to true, this simultaneously validates WFF(x) and Semantically-Correct(x) for any

finite string x.

Copyright 2016 and 2017 by Pete Olcott

3