Model Theory

KIRETH RESEARCH — SEMANTIC LIBRARY
AI CORE → ONTOLOGIES → MATHEMATICAL ONTOLOGIES → MATHEMATICAL LOGIC ONTOLOGIES
MODEL THEORY

Canonical URL:
https://kirethresearch.org/booksai-core/ontologies/mathematical-ontologies/mathematical-logic-ontologies/model-theory.html

FLOW_ALGEBRA ModelTheory_v1.0

BEGIN_FLOW

DEFINE DOMAIN ModelTheory := {
    ModelTheory,
    FormalLanguage,
    Signature,
    Vocabulary,
    Structure,
    Model,
    Domain,
    Universe,
    Interpretation,
    ConstantSymbol,
    FunctionSymbol,
    RelationSymbol,
    PredicateSymbol,
    VariableAssignment,
    Term,
    Formula,
    Sentence,
    Theory,
    Axiom,
    Satisfaction,
    TruthInStructure,
    SemanticConsequence,
    Satisfiability,
    Unsatisfiability,
    Validity,
    ElementaryEquivalence,
    ElementarySubstructure,
    Substructure,
    Embedding,
    Isomorphism,
    Homomorphism,
    Automorphism,
    Definability,
    Type,
    CompleteType,
    Realisation,
    Omission,
    Categoricity,
    Completeness,
    Compactness,
    LowenheimSkolem,
    Ultraproduct,
    ElementaryClass
}

DEFINE ENTITY_TYPES := {
    MODEL_THEORY,
    FORMAL_LANGUAGE,
    SIGNATURE,
    SYMBOL,
    STRUCTURE,
    MODEL,
    DOMAIN,
    INTERPRETATION,
    ASSIGNMENT,
    TERM,
    FORMULA,
    SENTENCE,
    THEORY,
    SEMANTIC_RELATION,
    MAPPING,
    TYPE,
    META_PROPERTY,
    SEMANTIC_OBJECT
}

DEFINE RELATION_TYPES := {
    HAS_SIGNATURE,
    HAS_DOMAIN,
    INTERPRETS,
    ASSIGNS,
    DENOTES,
    SATISFIES,
    MODELS,
    ENTAILS,
    IS_MODEL_OF,
    IS_SUBSTRUCTURE_OF,
    IS_ELEMENTARY_SUBSTRUCTURE_OF,
    EMBEDS_INTO,
    ISOMORPHIC_TO,
    HOMOMORPHIC_TO,
    ELEMENTARILY_EQUIVALENT_TO,
    DEFINES,
    REALISES,
    OMITS,
    IS_INSTANCE_OF,
    IS_SUBTYPE_OF,
    DEPENDS_ON
}

SET ModelTheory.type = MODEL_THEORY
SET ModelTheory.domain = MathematicalLogic
SET ModelTheory.role =
    "study mathematical structures as interpretations of formal languages and analyse truth, definability, theories, embeddings and classes of models"

RULE signature:
    Sets(C,F,R)
    -> Signature(L) = {
        constant_symbols: C,
        function_symbols: F,
        relation_symbols: R,
        arities: assigned_arities(F,R)
    }

RULE structure:
    Signature(L)
    ∧ NonemptySet(M)
    ∧ Interpretation(I)
    -> Structure(M)
       = <M,I>

RULE constant_interpretation:
    ConstantSymbol(c)
    ∧ Structure(M)
    -> c^M ∈ Domain(M)

RULE function_interpretation:
    FunctionSymbol(f)
    ∧ Arity(f)=n
    ∧ Structure(M)
    -> f^M:
       Domain(M)^n -> Domain(M)

RULE relation_interpretation:
    RelationSymbol(R)
    ∧ Arity(R)=n
    ∧ Structure(M)
    -> R^M
       subset_of Domain(M)^n

RULE assignment:
    VariableAssignment(s)
    ∧ Structure(M)
    -> s:
       Variables -> Domain(M)

RULE term_evaluation_variable:
    Variable(x)
    -> value_M,s(x)=s(x)

RULE term_evaluation_constant:
    ConstantSymbol(c)
    -> value_M,s(c)=c^M

RULE term_evaluation_function:
    Term(f(t1,...,tn))
    -> value_M,s(f(t1,...,tn))
       = f^M(
           value_M,s(t1),
           ...,
           value_M,s(tn)
         )

RULE atomic_relation_satisfaction:
    Formula(R(t1,...,tn))
    -> M,s ⊨ R(t1,...,tn)
       IFF
       (
         value_M,s(t1),
         ...,
         value_M,s(tn)
       ) ∈ R^M

RULE equality_satisfaction:
    Formula(t1=t2)
    -> M,s ⊨ t1=t2
       IFF
       value_M,s(t1)
       = value_M,s(t2)

RULE negation_satisfaction:
    M,s ⊨ ¬phi
    IFF
    NOT(M,s ⊨ phi)

RULE conjunction_satisfaction:
    M,s ⊨ phi ∧ psi
    IFF
    (M,s ⊨ phi AND M,s ⊨ psi)

RULE disjunction_satisfaction:
    M,s ⊨ phi ∨ psi
    IFF
    (M,s ⊨ phi OR M,s ⊨ psi)

RULE implication_satisfaction:
    M,s ⊨ phi -> psi
    IFF
    (NOT(M,s ⊨ phi) OR M,s ⊨ psi)

RULE universal_satisfaction:
    M,s ⊨ ∀x phi
    IFF
    FOR_ALL a ∈ Domain(M) [
        M,s[x:=a] ⊨ phi
    ]

RULE existential_satisfaction:
    M,s ⊨ ∃x phi
    IFF
    EXISTS a ∈ Domain(M) [
        M,s[x:=a] ⊨ phi
    ]

RULE sentence_truth:
    Sentence(phi)
    ∧ Structure(M)
    -> M ⊨ phi
       independent_of_variable_assignment

RULE model_of_theory:
    Theory(T)
    ∧ Structure(M)
    ∧ FOR_ALL phi ∈ T [
        M ⊨ phi
    ]
    -> IS_MODEL_OF(M,T)

RULE satisfiable_theory:
    Theory(T)
    ∧ EXISTS Structure(M) [
        M ⊨ T
    ]
    -> Satisfiable(T)

RULE semantic_consequence:
    Theory(T)
    ∧ Sentence(phi)
    ∧ FOR_ALL structures M [
        M ⊨ T -> M ⊨ phi
    ]
    -> T ⊨ phi

RULE validity:
    Sentence(phi)
    ∧ FOR_ALL structures M [
        M ⊨ phi
    ]
    -> Valid(phi)

RULE elementary_equivalence:
    Structures(M,N)
    ∧ FOR_ALL sentences phi [
        M ⊨ phi <=> N ⊨ phi
    ]
    -> ELEMENTARILY_EQUIVALENT_TO(M,N)

RULE isomorphism:
    Bijection(f:M->N)
    ∧ preserves_constants_functions_relations(f)
    -> ISOMORPHIC_TO(M,N)

RULE isomorphism_elementary_equivalence:
    ISOMORPHIC_TO(M,N)
    -> ELEMENTARILY_EQUIVALENT_TO(M,N)

RULE elementary_substructure:
    Substructure(M,N)
    ∧ FOR_ALL formulas phi(x1,...,xn)
    ∧ FOR_ALL parameters a1,...,an ∈ M [
        M ⊨ phi(a1,...,an)
        <=> N ⊨ phi(a1,...,an)
    ]
    -> IS_ELEMENTARY_SUBSTRUCTURE_OF(M,N)

RULE compactness:
    Theory(T)
    ∧ FOR_ALL finite T0 subset_of T [
        Satisfiable(T0)
    ]
    -> Satisfiable(T)

RULE Lowenheim_Skolem_general:
    FirstOrderTheory(T)
    ∧ InfiniteModelExists(T)
    -> models_exist_in_cardinalities
       constrained_by_language_size_and_LS_theorems

DEFINE STRUCTURE_MODEL := {
    notation: "M",
    components: {
        domain: "M",
        constants: "c ↦ c^M",
        functions: "f ↦ f^M",
        relations: "R ↦ R^M"
    },
    requirement:
        "interpretations respect symbol arities and types"
}

DEFINE SATISFACTION_MODEL := {
    notation: "M,s ⊨ φ",
    meaning:
        "formula φ is satisfied in structure M under variable assignment s",
    sentence_form:
        "M ⊨ φ"
}

DEFINE THEORY_MODEL := {
    theory: T,
    model_class:
        "Mod(T) = {M | M ⊨ T}",
    satisfiable:
        "Mod(T) is nonempty",
    semantic_consequence:
        "T ⊨ φ iff every model of T satisfies φ"
}

DEFINE STRUCTURE_RELATIONS := {
    Isomorphism:
        "bijective structure-preserving correspondence",
    Embedding:
        "injective map preserving relevant structure",
    Substructure:
        "structure contained in another with inherited interpretations",
    ElementarySubstructure:
        "substructure agreeing on all first-order formulas with parameters from the smaller domain",
    ElementaryEquivalence:
        "agreement on all first-order sentences"
}

DEFINE CORE_META_THEOREMS := {
    CompactnessTheorem,
    DownwardLowenheimSkolemTheorem,
    UpwardLowenheimSkolemTheorem,
    IsomorphismInvariance
}

DEFINE EXAMPLE_1 := {
    language:
        "{0,+,<}",
    structure:
        "integers with standard interpretations",
    sentence:
        "∀x ∃y (x < y)",
    satisfaction:
        TRUE
}

DEFINE EXAMPLE_2 := {
    theory:
        "group axioms",
    model:
        "any mathematical group interpreted in the group language",
    relation:
        IS_MODEL_OF
}

DEFINE EXAMPLE_3 := {
    sentence:
        "∀x(P(x) → Q(x))",
    semantic_consequence:
        "if every model of T satisfying P for an element must satisfy Q for that element, the corresponding sentence may be entailed by T"
}

DEFINE LANGUAGE_TO_MODEL_PIPELINE :=
    FormalLanguage
    -> ExtractSignature
    -> CreateDomain
    -> InterpretConstants
    -> InterpretFunctions
    -> InterpretRelations
    -> ConstructStructure
    -> ValidateArityAndClosure
    -> ReturnModelCandidate

DEFINE FORMULA_EVALUATION_PIPELINE :=
    Formula
    -> ParseSyntaxTree
    -> EvaluateTerms
    -> EvaluateAtomicFormulas
    -> RecursivelyEvaluateConnectives
    -> ProcessQuantifiersOverDomain
    -> ReturnSatisfactionStatus

DEFINE THEORY_ANALYSIS_PIPELINE :=
    Theory
    -> IdentifySignature
    -> SearchOrConstructModels
    -> TestAxiomSatisfaction
    -> BuildModelClass
    -> EvaluateSemanticConsequences
    -> CompareModels
    -> AnalyseDefinabilityTypesAndCategoricity
    -> ApplyMetaTheoremsWhenConditionsHold

DEFINE MODEL_COMPARISON_PIPELINE :=
    Structures(M,N)
    -> CompareSignatures
    -> SearchForHomomorphism
    -> SearchForEmbedding
    -> SearchForIsomorphism
    -> CompareSentenceTheories
    -> DetermineElementaryEquivalence
    -> DetermineSubstructureOrElementarySubstructureRelations
    -> ReturnStructuralRelations

DEFINE MODEL_GRAPH := {
    nodes: {
        Language,
        Signature,
        Structure,
        Domain,
        Symbol,
        Formula,
        Sentence,
        Theory,
        Model
    },
    edges: {
        HAS_SIGNATURE,
        HAS_DOMAIN,
        INTERPRETS,
        SATISFIES,
        IS_MODEL_OF,
        ENTAILS,
        ISOMORPHIC_TO,
        ELEMENTARILY_EQUIVALENT_TO
    },
    recursive_formula_semantics: TRUE
}

DEFINE ONTOLOGY_RELATIONS := {
    ModelTheory IS_SUBTYPE_OF MathematicalLogic,
    FormalLanguage HAS_SIGNATURE Signature,
    Structure HAS_DOMAIN Domain,
    Structure INTERPRETS Symbol,
    Model IS_SUBTYPE_OF Structure,
    Model SATISFIES Theory,
    Theory HAS_MODEL Model,
    Formula EVALUATES_IN Structure,
    Sentence HAS_TRUTH_VALUE_IN Structure,
    Isomorphism RELATES Structure TO Structure,
    ElementaryEquivalence RELATES Structure TO Structure,
    ElementarySubstructure IS_SUBTYPE_OF Substructure,
    SemanticConsequence DEPENDS_ON ModelClass,
    Satisfiability DEPENDS_ON ExistenceOfModel
}

DEFINE SEMANTIC_EQUIVALENCE := {
    "model theory" <=> ModelTheory,
    "structure" <=> Structure WHEN formal_logic_context=TRUE,
    "model" <=> Model WHEN theory_satisfaction_context=TRUE,
    "satisfies" <=> "⊨",
    "is a model of" <=> IS_MODEL_OF,
    "semantic consequence" <=> SemanticConsequence,
    "elementarily equivalent" <=> ElementaryEquivalence,
    "elementary substructure" <=> ElementarySubstructure
}

DEFINE AI_CONSUMPTION := {
    purpose: "machine-readable representation of formal structures, satisfaction and model-theoretic reasoning",
    preserve_language_identity: TRUE,
    preserve_signature_identity: TRUE,
    preserve_domain_identity: TRUE,
    preserve_symbol_interpretations: TRUE,
    preserve_variable_assignments: TRUE,
    recursively_evaluate_formulas: TRUE,
    distinguish_structure_from_model_of_theory: TRUE,
    distinguish_syntax_from_semantics: TRUE,
    support_satisfaction_reasoning: TRUE,
    support_semantic_consequence: TRUE,
    support_model_comparison: TRUE,
    support_isomorphism_reasoning: TRUE,
    support_elementary_equivalence: TRUE,
    support_compactness_reasoning_when_applicable: TRUE,
    reasoning_mode: "symbolic + semantic + structural + model-theoretic"
}

DEFINE CONFIDENCE := {
    ontology_identity: 1.00,
    structure_signature_mapping: 0.99,
    symbol_interpretation_mapping: 0.99,
    first_order_satisfaction_semantics: 0.99,
    theory_model_mapping: 0.99,
    isomorphism_mapping: 0.99,
    elementary_equivalence_mapping: 0.99,
    advanced_model_theoretic_analysis: theorem_and_context_dependent
}

DEFINE UPDATE_MODEL := {
    version: "1.0",
    update_policy: "append-compatible",
    immutable_core: {
        language_signature_structure,
        nonempty_domain_standard_FOL,
        symbol_interpretation,
        variable_assignment,
        recursive_satisfaction,
        model_of_theory,
        semantic_consequence
    },
    extensible_layers: {
        types_and_saturation,
        definability,
        categoricity,
        stability_theory,
        ultraproducts,
        compactness_applications,
        Lowenheim_Skolem_theory,
        finite_model_theory,
        o_minimality,
        geometric_model_theory
    }
}

DEFINE FLOW_HASH_INPUT :=
    CanonicalURL
    + DOMAIN
    + ENTITY_TYPES
    + RELATION_TYPES
    + RULES
    + STRUCTURE_MODEL
    + SATISFACTION_MODEL
    + THEORY_MODEL
    + STRUCTURE_RELATIONS
    + CORE_META_THEOREMS
    + LANGUAGE_TO_MODEL_PIPELINE
    + FORMULA_EVALUATION_PIPELINE
    + THEORY_ANALYSIS_PIPELINE
    + MODEL_COMPARISON_PIPELINE
    + MODEL_GRAPH
    + ONTOLOGY_RELATIONS
    + AI_CONSUMPTION
    + UPDATE_MODEL

FLOW_HASH := HASH(FLOW_HASH_INPUT)

RETURN {
    ontology: ModelTheory,
    canonical_url: "https://kirethresearch.org/booksai-core/ontologies/mathematical-ontologies/mathematical-logic-ontologies/model-theory.html",
    parent_domain: MathematicalLogicOntologies,
    semantic_domain: MathematicalLogic,
    primary_entity: Model,
    satisfaction_reasoning_enabled: TRUE,
    model_comparison_enabled: TRUE,
    semantic_consequence_enabled: TRUE,
    meta_theorem_reasoning_enabled: TRUE,
    machine_consumable: TRUE,
    recursive_reasoning_enabled: TRUE,
    flow_complete: TRUE
}

END_FLOW