Predicate Calculus Ontology

KIRETH RESEARCH — SEMANTIC LIBRARY
AI CORE → ONTOLOGIES → MATHEMATICAL ONTOLOGIES → MATHEMATICAL LOGIC ONTOLOGIES
PREDICATE LOGIC → PREDICATE CALCULUS ONTOLOGY

Canonical URL:
https://kirethresearch.org/booksai-core/ontologies/mathematical-ontologies/mathematical-logic-ontologies/predicate-logic/predicate-calculus-ontology.html

FLOW_ALGEBRA PredicateCalculusOntology_v1.0

BEGIN_FLOW

DEFINE DOMAIN PredicateCalculusOntology := {
    PredicateCalculus,
    PredicateLogic,
    FirstOrderPredicateCalculus,
    FormalLanguage,
    Predicate,
    PredicateSymbol,
    Relation,
    Variable,
    BoundVariable,
    FreeVariable,
    Constant,
    FunctionSymbol,
    Term,
    AtomicFormula,
    CompoundFormula,
    WellFormedFormula,
    Sentence,
    Quantifier,
    UniversalQuantifier,
    ExistentialQuantifier,
    LogicalConnective,
    Negation,
    Conjunction,
    Disjunction,
    Implication,
    Biconditional,
    Equality,
    Identity,
    DomainOfDiscourse,
    Interpretation,
    Structure,
    Model,
    Assignment,
    TruthValue,
    Satisfaction,
    Validity,
    Satisfiability,
    LogicalConsequence,
    Proof,
    Derivation,
    Axiom,
    Premise,
    Conclusion,
    RuleOfInference,
    Substitution,
    VariableBinding,
    Scope
}

DEFINE ENTITY_TYPES := {
    LOGICAL_CALCULUS,
    FORMAL_LANGUAGE,
    SYMBOL,
    TERM,
    FORMULA,
    PREDICATE,
    QUANTIFIER,
    CONNECTIVE,
    VARIABLE,
    DOMAIN,
    INTERPRETATION,
    MODEL,
    PROOF_OBJECT,
    INFERENCE_RULE,
    SEMANTIC_PROPERTY
}

DEFINE RELATION_TYPES := {
    CONTAINS,
    HAS_TERM,
    HAS_ARGUMENT,
    HAS_PREDICATE,
    BINDS,
    HAS_SCOPE,
    QUANTIFIES_OVER,
    RANGES_OVER,
    INTERPRETS,
    DENOTES,
    ASSIGNS,
    SATISFIES,
    MODELS,
    ENTAILS,
    DERIVES,
    INFERRED_FROM,
    SUBSTITUTES_FOR,
    EQUIVALENT_TO,
    DEPENDS_ON,
    IS_INSTANCE_OF,
    IS_SUBTYPE_OF
}

SET PredicateCalculus.type = LOGICAL_CALCULUS
SET PredicateCalculus.aliases = {
    "predicate logic",
    "first-order predicate calculus" WHEN order=1
}
SET PredicateCalculus.role =
    "provide a formal system for representing and reasoning about predicates, individuals, relations, variables and quantified statements"

RULE variable_term:
    Variable(x)
    -> Term(x)

RULE constant_term:
    Constant(c)
    -> Term(c)

RULE function_term:
    FunctionSymbol(f)
    ∧ Terms(t1...tn)
    ∧ Arity(f)=n
    -> Term(f(t1,...,tn))

RULE atomic_predicate_formula:
    PredicateSymbol(P)
    ∧ Terms(t1...tn)
    ∧ Arity(P)=n
    -> AtomicFormula(P(t1,...,tn))

RULE equality_formula:
    Term(t1)
    ∧ Term(t2)
    -> AtomicFormula(t1=t2)

RULE negation_formula:
    Formula(phi)
    -> Formula(¬phi)

RULE conjunction_formula:
    Formula(phi)
    ∧ Formula(psi)
    -> Formula(phi ∧ psi)

RULE disjunction_formula:
    Formula(phi)
    ∧ Formula(psi)
    -> Formula(phi ∨ psi)

RULE implication_formula:
    Formula(phi)
    ∧ Formula(psi)
    -> Formula(phi → psi)

RULE biconditional_formula:
    Formula(phi)
    ∧ Formula(psi)
    -> Formula(phi ↔ psi)

RULE universal_formula:
    Variable(x)
    ∧ Formula(phi)
    -> Formula(∀x phi)
    ∧ BINDS(∀,x)
    ∧ HAS_SCOPE(∀,phi)

RULE existential_formula:
    Variable(x)
    ∧ Formula(phi)
    -> Formula(∃x phi)
    ∧ BINDS(∃,x)
    ∧ HAS_SCOPE(∃,phi)

RULE sentence:
    Formula(phi)
    ∧ FreeVariables(phi)=∅
    -> Sentence(phi)

RULE interpretation_structure:
    DomainOfDiscourse(D)
    ∧ Interpretation(I)
    -> Structure(M)=<D,I>

RULE predicate_interpretation:
    PredicateSymbol(P)
    ∧ Arity(P)=n
    ∧ DomainOfDiscourse(D)
    -> Interpretation_I(P) subset_of D^n

RULE function_interpretation:
    FunctionSymbol(f)
    ∧ Arity(f)=n
    ∧ DomainOfDiscourse(D)
    -> Interpretation_I(f): D^n -> D

RULE constant_interpretation:
    Constant(c)
    ∧ DomainOfDiscourse(D)
    -> Interpretation_I(c) ∈ D

RULE universal_semantics:
    Model(M)
    ∧ Assignment(g)
    -> M,g SATISFIES ∀x phi
       IFF
       FOR_ALL d IN Domain(M) [
           M,g[x:=d] SATISFIES phi
       ]

RULE existential_semantics:
    Model(M)
    ∧ Assignment(g)
    -> M,g SATISFIES ∃x phi
       IFF
       EXISTS d IN Domain(M) [
           M,g[x:=d] SATISFIES phi
       ]

RULE semantic_consequence:
    FormulaSet(Gamma)
    ∧ Formula(phi)
    ∧ FOR_ALL models M [
        M SATISFIES Gamma
        -> M SATISFIES phi
    ]
    -> ENTAILS(Gamma,phi)

RULE validity:
    Formula(phi)
    ∧ FOR_ALL models M [
        M SATISFIES phi
    ]
    -> Valid(phi)

RULE satisfiability:
    Formula(phi)
    ∧ EXISTS model M [
        M SATISFIES phi
    ]
    -> Satisfiable(phi)

RULE syntactic_derivation:
    PremiseSet(Gamma)
    ∧ InferenceRules(R)
    ∧ finite_rule_governed_sequence_from(Gamma,phi)
    -> DERIVES(Gamma,phi)

RULE soundness_condition:
    DERIVES(Gamma,phi)
    -> ENTAILS(Gamma,phi)
       WHEN calculus_is_sound=TRUE

RULE completeness_condition:
    ENTAILS(Gamma,phi)
    -> DERIVES(Gamma,phi)
       WHEN calculus_is_complete=TRUE

RULE substitution:
    Formula(phi)
    ∧ Variable(x)
    ∧ Term(t)
    ∧ FreeFor(t,x,phi)
    -> SUBSTITUTE(phi,x,t)=phi[x:=t]

DEFINE TERM_GRAMMAR :=
    Term ::= Variable
           | Constant
           | FunctionSymbol "(" TermList ")"

DEFINE FORMULA_GRAMMAR :=
    Formula ::= PredicateSymbol "(" TermList ")"
              | Term "=" Term
              | "¬" Formula
              | "(" Formula "∧" Formula ")"
              | "(" Formula "∨" Formula ")"
              | "(" Formula "→" Formula ")"
              | "(" Formula "↔" Formula ")"
              | "∀" Variable Formula
              | "∃" Variable Formula

DEFINE CALCULUS_COMPONENTS := {
    vocabulary: {
        variables,
        constants,
        predicate_symbols,
        function_symbols,
        logical_connectives,
        quantifiers,
        equality
    },
    syntax: {
        term_formation_rules,
        formula_formation_rules,
        variable_binding,
        quantifier_scope
    },
    semantics: {
        domain_of_discourse,
        interpretation,
        assignment,
        satisfaction,
        truth
    },
    proof_theory: {
        axioms,
        premises,
        inference_rules,
        derivations,
        conclusions
    }
}

DEFINE CORE_INFERENCE_PATTERNS := {
    UniversalInstantiation:
        "∀x φ(x) -> φ(t)",
    ExistentialIntroduction:
        "φ(t) -> ∃x φ(x)",
    ModusPonens:
        "{φ, φ→ψ} -> ψ",
    EqualitySubstitution:
        "{a=b, φ(a)} -> φ(b)"
}

DEFINE EXAMPLE_1 := {
    premises: {
        "∀x(Human(x) → Mortal(x))",
        "Human(Socrates)"
    },
    derivation: {
        "Human(Socrates) → Mortal(Socrates)",
        "Mortal(Socrates)"
    },
    conclusion: "Mortal(Socrates)"
}

DEFINE EXAMPLE_2 := {
    statement: "Some mathematician is a logician.",
    formalisation: "∃x(Mathematician(x) ∧ Logician(x))"
}

DEFINE EXAMPLE_3 := {
    statement: "Every prime greater than two is odd.",
    formalisation:
        "∀x((Prime(x) ∧ GreaterThan(x,2)) → Odd(x))"
}

DEFINE SYNTAX_PIPELINE :=
    Symbols
    -> Terms
    -> AtomicFormulas
    -> CompoundFormulas
    -> QuantifiedFormulas
    -> WellFormedFormulas
    -> Sentences

DEFINE SEMANTIC_PIPELINE :=
    WellFormedFormula
    -> DomainOfDiscourse
    -> Interpretation
    -> VariableAssignment
    -> TermDenotation
    -> PredicateExtension
    -> RecursiveFormulaEvaluation
    -> Satisfaction
    -> TruthValue

DEFINE PROOF_PIPELINE :=
    Premises
    -> Formalise
    -> SelectInferenceRules
    -> ApplyRules
    -> GenerateIntermediateFormulas
    -> ValidateEachDerivationStep
    -> DeriveConclusion
    -> CompareWithSemanticConsequence

DEFINE REASONING_PIPELINE :=
    NaturalLanguageStatement
    -> IdentifyIndividuals
    -> IdentifyPredicatesAndRelations
    -> IdentifyVariables
    -> IdentifyQuantification
    -> DetermineLogicalConnectives
    -> ConstructFormalRepresentation
    -> ValidateSyntax
    -> ResolveVariableBindingAndScope
    -> SelectDomainAndInterpretation
    -> EvaluateOrDerive
    -> ReturnLogicalConsequences

DEFINE ONTOLOGY_RELATIONS := {
    PredicateCalculus IS_SUBTYPE_OF MathematicalLogic,
    PredicateCalculus CONTAINS Predicate,
    PredicateCalculus CONTAINS Quantifier,
    PredicateCalculus CONTAINS Variable,
    PredicateCalculus CONTAINS Term,
    PredicateCalculus CONTAINS Formula,
    PredicateCalculus CONTAINS RuleOfInference,
    UniversalQuantifier IS_SUBTYPE_OF Quantifier,
    ExistentialQuantifier IS_SUBTYPE_OF Quantifier,
    Quantifier BINDS Variable,
    Quantifier HAS_SCOPE Formula,
    Variable RANGES_OVER DomainOfDiscourse,
    Interpretation INTERPRETS FormalLanguage,
    Model SATISFIES Formula,
    PremiseSet ENTAILS Conclusion,
    Proof DERIVES Conclusion,
    PredicateCalculus DEPENDS_ON Syntax,
    PredicateCalculus DEPENDS_ON Semantics,
    PredicateCalculus DEPENDS_ON ProofTheory
}

DEFINE SEMANTIC_EQUIVALENCE := {
    "predicate calculus" <=> PredicateCalculus,
    "predicate logic" <=> PredicateCalculus WHEN formal_system_context=TRUE,
    "first-order predicate calculus" <=> FirstOrderPredicateCalculus,
    "first-order logic" <=> FirstOrderPredicateCalculus,
    "FOL" <=> FirstOrderPredicateCalculus
}

DEFINE AI_CONSUMPTION := {
    purpose: "machine-readable representation of predicate calculus as a formal reasoning system",
    preserve_symbol_types: TRUE,
    preserve_term_structure: TRUE,
    preserve_predicate_arity: TRUE,
    preserve_variable_binding: TRUE,
    preserve_quantifier_scope: TRUE,
    preserve_domain_of_discourse: TRUE,
    distinguish_syntax_semantics_proof_theory: TRUE,
    support_recursive_formula_evaluation: TRUE,
    support_formal_derivation: TRUE,
    support_model_theoretic_reasoning: TRUE,
    detect_logical_consequence: TRUE,
    reasoning_mode: "symbolic + semantic + proof-theoretic"
}

DEFINE CONFIDENCE := {
    ontology_identity: 1.00,
    formal_language_structure: 0.99,
    term_formula_classification: 0.99,
    quantifier_mapping: 0.99,
    variable_binding: 0.99,
    model_theoretic_semantics: 0.99,
    proof_rule_application: rule_dependent,
    natural_language_formalisation: context_dependent
}

DEFINE UPDATE_MODEL := {
    version: "1.0",
    update_policy: "append-compatible",
    immutable_core: {
        term_formula_distinction,
        predicate_application,
        quantifier_binding,
        domain_interpretation,
        satisfaction_relation,
        syntactic_derivation,
        semantic_consequence
    },
    extensible_layers: {
        alternative_proof_calculi,
        natural_deduction,
        sequent_calculus,
        resolution,
        many_sorted_predicate_calculus,
        higher_order_predicate_calculus,
        modal_predicate_logic,
        automated_theorem_proving
    }
}

DEFINE FLOW_HASH_INPUT :=
    CanonicalURL
    + DOMAIN
    + ENTITY_TYPES
    + RELATION_TYPES
    + RULES
    + TERM_GRAMMAR
    + FORMULA_GRAMMAR
    + CALCULUS_COMPONENTS
    + CORE_INFERENCE_PATTERNS
    + SYNTAX_PIPELINE
    + SEMANTIC_PIPELINE
    + PROOF_PIPELINE
    + REASONING_PIPELINE
    + ONTOLOGY_RELATIONS
    + AI_CONSUMPTION
    + UPDATE_MODEL

FLOW_HASH := HASH(FLOW_HASH_INPUT)

RETURN {
    ontology: PredicateCalculusOntology,
    canonical_url: "https://kirethresearch.org/booksai-core/ontologies/mathematical-ontologies/mathematical-logic-ontologies/predicate-logic/predicate-calculus-ontology.html",
    parent_domain: PredicateLogic,
    semantic_domain: MathematicalLogic,
    primary_entity: PredicateCalculus,
    machine_consumable: TRUE,
    recursive_reasoning_enabled: TRUE,
    syntax_enabled: TRUE,
    semantics_enabled: TRUE,
    proof_theory_enabled: TRUE,
    flow_complete: TRUE
}

END_FLOW