Semantic Model Ontology

KIRETH RESEARCH - SEMANTIC LIBRARY
AI CORE -> ONTOLOGIES -> MATHEMATICAL ONTOLOGIES -> MATHEMATICAL LOGIC ONTOLOGIES
MODEL THEORY -> SEMANTIC MODEL ONTOLOGY

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

FLOW_ALGEBRA SemanticModelOntology_v1.0

BEGIN_FLOW

DEFINE DOMAIN SemanticModelOntology := {
    SemanticModel,
    LogicalModel,
    Model,
    ModelTheory,
    FormalLanguage,
    Signature,
    Structure,
    Domain,
    Universe,
    Interpretation,
    SemanticValue,
    Denotation,
    Extension,
    ConstantSymbol,
    FunctionSymbol,
    RelationSymbol,
    PredicateSymbol,
    Variable,
    VariableAssignment,
    Term,
    Formula,
    Sentence,
    Theory,
    Axiom,
    Satisfaction,
    TruthValue,
    SemanticConsequence,
    Satisfiability,
    Validity,
    ModelClass,
    Isomorphism,
    ElementaryEquivalence
}

DEFINE ENTITY_TYPES := {
    SEMANTIC_MODEL,
    MODEL,
    STRUCTURE,
    FORMAL_LANGUAGE,
    SIGNATURE,
    DOMAIN,
    INTERPRETATION,
    SEMANTIC_VALUE,
    SYMBOL,
    ASSIGNMENT,
    TERM,
    FORMULA,
    SENTENCE,
    THEORY,
    SEMANTIC_RELATION,
    MODEL_CLASS
}

DEFINE RELATION_TYPES := {
    HAS_SIGNATURE,
    HAS_DOMAIN,
    HAS_INTERPRETATION,
    INTERPRETS,
    DENOTES,
    HAS_EXTENSION,
    ASSIGNS,
    EVALUATES,
    SATISFIES,
    IS_MODEL_OF,
    ENTAILS,
    BELONGS_TO_MODEL_CLASS,
    ISOMORPHIC_TO,
    ELEMENTARILY_EQUIVALENT_TO,
    IS_INSTANCE_OF,
    IS_SUBTYPE_OF,
    DEPENDS_ON
}

SET SemanticModel.type = SEMANTIC_MODEL
SET SemanticModel.parent = LogicalModel
SET SemanticModel.context = ModelTheory
SET SemanticModel.role =
    "represent an interpretation-based mathematical structure in which formal expressions receive semantic values and formulas are evaluated for satisfaction and truth"

RULE semantic_model_structure:
    FormalLanguage(L)
    AND Signature(Sigma)
    AND NonemptySet(D)
    AND Interpretation(I)
    -> Structure(M)=<D,I>
    AND SemanticModelCandidate(M)

RULE semantic_model_of_theory:
    SemanticModelCandidate(M)
    AND Theory(T)
    AND FOR_EVERY Sentence(phi) MEMBER_OF T [
        SATISFIES(M,phi)
    ]
    -> SemanticModel(M)
    AND IS_MODEL_OF(M,T)

RULE constant_semantics:
    SemanticModel(M)
    AND ConstantSymbol(c)
    -> DENOTES(c,Interpretation_M(c))
    AND Interpretation_M(c) MEMBER_OF Domain(M)

RULE function_semantics:
    SemanticModel(M)
    AND FunctionSymbol(f)
    AND Arity(f)=n
    -> Interpretation_M(f):
       Domain(M)^n -> Domain(M)

RULE predicate_semantics:
    SemanticModel(M)
    AND PredicateSymbol(P)
    AND Arity(P)=n
    -> HAS_EXTENSION(
        P,
        Interpretation_M(P)
    )
    AND Interpretation_M(P)
        SUBSET_OF Domain(M)^n

RULE variable_semantics:
    VariableAssignment(s)
    AND Variable(x)
    -> ASSIGNS(s,x,s(x))
    AND s(x) MEMBER_OF Domain(M)

RULE term_semantics_variable:
    Variable(x)
    -> SemanticValue(M,s,x)=s(x)

RULE term_semantics_constant:
    ConstantSymbol(c)
    -> SemanticValue(M,s,c)=Interpretation_M(c)

RULE term_semantics_function:
    Term(f(t1,...,tn))
    -> SemanticValue(M,s,f(t1,...,tn))
       = Interpretation_M(f)(
           SemanticValue(M,s,t1),
           ...,
           SemanticValue(M,s,tn)
         )

RULE atomic_formula_semantics:
    Formula(P(t1,...,tn))
    -> SATISFIES(M,s,P(t1,...,tn))
       IFF
       (
           SemanticValue(M,s,t1),
           ...,
           SemanticValue(M,s,tn)
       ) MEMBER_OF Interpretation_M(P)

RULE equality_semantics:
    Formula(t1=t2)
    -> SATISFIES(M,s,t1=t2)
       IFF
       SemanticValue(M,s,t1)
       = SemanticValue(M,s,t2)

RULE negation_semantics:
    SATISFIES(M,s,NOT(phi))
    IFF
    NOT SATISFIES(M,s,phi)

RULE conjunction_semantics:
    SATISFIES(M,s,AND(phi,psi))
    IFF
    (
        SATISFIES(M,s,phi)
        AND
        SATISFIES(M,s,psi)
    )

RULE disjunction_semantics:
    SATISFIES(M,s,OR(phi,psi))
    IFF
    (
        SATISFIES(M,s,phi)
        OR
        SATISFIES(M,s,psi)
    )

RULE implication_semantics:
    SATISFIES(M,s,IMPLIES(phi,psi))
    IFF
    (
        NOT SATISFIES(M,s,phi)
        OR
        SATISFIES(M,s,psi)
    )

RULE universal_semantics:
    SATISFIES(M,s,FOR_ALL x phi)
    IFF
    FOR_EVERY a MEMBER_OF Domain(M) [
        SATISFIES(M,s[x:=a],phi)
    ]

RULE existential_semantics:
    SATISFIES(M,s,EXISTS x phi)
    IFF
    THERE_EXISTS a MEMBER_OF Domain(M) [
        SATISFIES(M,s[x:=a],phi)
    ]

RULE sentence_truth:
    Sentence(phi)
    -> TruthValueInModel(phi,M)
       = SatisfactionStatus(M,phi)

RULE model_class:
    Theory(T)
    -> ModelClass(T)
       = {
           M | IS_MODEL_OF(M,T)
       }

RULE satisfiability:
    Theory(T)
    AND ModelClass(T) != EMPTY
    -> Satisfiable(T)

RULE semantic_consequence:
    Theory(T)
    AND Sentence(phi)
    AND FOR_EVERY M MEMBER_OF ModelClass(T) [
        SATISFIES(M,phi)
    ]
    -> ENTAILS(T,phi)

RULE validity:
    Sentence(phi)
    AND FOR_EVERY SemanticModel(M) of_relevant_signature [
        SATISFIES(M,phi)
    ]
    -> Valid(phi)

RULE isomorphism_semantic_invariance:
    ISOMORPHIC_TO(M,N)
    -> FOR_EVERY Sentence(phi) [
        SATISFIES(M,phi)
        IFF
        SATISFIES(N,phi)
    ]

RULE elementary_equivalence:
    FOR_EVERY Sentence(phi) [
        SATISFIES(M,phi)
        IFF
        SATISFIES(N,phi)
    ]
    -> ELEMENTARILY_EQUIVALENT_TO(M,N)

DEFINE SEMANTIC_MODEL_SCHEMA := {
    model_id: unique_identifier,
    language: FormalLanguage,
    signature: Signature,
    domain: NonemptySet,
    interpretation: {
        constants: ConstantSemanticValues,
        functions: FunctionSemanticValues,
        relations: RelationExtensions
    },
    modelled_theory: optional_Theory,
    satisfaction_profile: SetOfSatisfiedSentences
}

DEFINE SEMANTIC_MAPPING_MODEL := {
    ConstantSymbol:
        "maps to one domain element",
    FunctionSymbol:
        "maps to an arity-preserving function over the domain",
    PredicateSymbol:
        "maps to an arity-preserving relation extension",
    Variable:
        "receives a domain element from a variable assignment",
    Term:
        "evaluates to a domain element",
    Formula:
        "evaluates to a satisfaction status",
    Sentence:
        "has a truth value in the model"
}

DEFINE MODEL_CLASS_MODEL := {
    notation:
        "Mod(T)",
    representation:
        "{M | M is a model of T}",
    semantic_consequence:
        "T entails phi when every member of Mod(T) satisfies phi"
}

DEFINE CRITICAL_DISTINCTIONS := {
    semantic_model_vs_syntactic_representation: {
        semantic_model:
            "assigns meanings and truth conditions",
        syntactic_representation:
            "contains formal symbols and formation rules",
        equivalence: FALSE
    },
    semantic_model_vs_structure: {
        structure:
            "domain plus interpretation",
        semantic_model:
            "structure considered as a semantic environment, often relative to formulas or a theory it satisfies"
    },
    semantic_value_vs_symbol: {
        symbol:
            "syntactic object",
        semantic_value:
            "object, function or relation assigned to the symbol"
    },
    truth_vs_provability: {
        truth:
            "semantic satisfaction in a model",
        provability:
            "syntactic derivability in a proof system",
        equivalence: FALSE_WITHOUT_META_THEOREM
    }
}

DEFINE EXAMPLE_1 := {
    language:
        "{zero,successor}",
    domain:
        "NaturalNumbers",
    interpretation: {
        zero: "0",
        successor: "n maps to n+1"
    },
    sentence:
        "FOR_ALL x successor(x) != zero",
    result:
        "true in the standard natural-number semantic model"
}

DEFINE EXAMPLE_2 := {
    predicate_symbol:
        "Prime",
    domain:
        "NaturalNumbers",
    semantic_extension:
        "{2,3,5,7,11,...}",
    formula:
        "Prime(x)",
    assignment:
        "x := 5",
    satisfaction:
        TRUE
}

DEFINE SEMANTIC_MODEL_CONSTRUCTION_PIPELINE :=
    FormalLanguage
    -> ExtractSignature
    -> SelectDomain
    -> BuildInterpretation
    -> ValidateConstantMappings
    -> ValidateFunctionMappings
    -> ValidatePredicateExtensions
    -> ConstructStructure
    -> EvaluateTargetTheoryIfPresent
    -> ConstructSemanticModel

DEFINE SEMANTIC_EVALUATION_PIPELINE :=
    SemanticModel
    -> InputExpression
    -> ParseAsTermFormulaOrSentence
    -> ResolveVariableAssignmentIfNeeded
    -> EvaluateTerms
    -> EvaluateAtomicFormulas
    -> RecursivelyEvaluateConnectives
    -> EvaluateQuantifiers
    -> ReturnSemanticValueOrTruthStatus

DEFINE MODEL_CLASS_PIPELINE :=
    Theory(T)
    -> IdentifyRelevantSignature
    -> GenerateOrReceiveCandidateSemanticModels
    -> TestTheorySatisfaction
    -> CollectSatisfyingModels
    -> ConstructModelClass(T)
    -> DetermineSatisfiability
    -> EvaluateSemanticConsequences

DEFINE MODEL_COMPARISON_PIPELINE :=
    SemanticModels(M,N)
    -> CompareSignatures
    -> CompareDomains
    -> CompareInterpretations
    -> TestIsomorphism
    -> CompareSentenceTruthProfiles
    -> DetermineElementaryEquivalence
    -> ReturnSemanticModelRelations

DEFINE SEMANTIC_MODEL_GRAPH := {
    node_types: {
        LanguageNode,
        SignatureNode,
        SemanticModelNode,
        DomainNode,
        SymbolNode,
        SemanticValueNode,
        FormulaNode,
        TheoryNode
    },
    edge_types: {
        HAS_SIGNATURE,
        HAS_DOMAIN,
        INTERPRETS,
        DENOTES,
        HAS_EXTENSION,
        SATISFIES,
        IS_MODEL_OF,
        ENTAILS,
        BELONGS_TO_MODEL_CLASS
    },
    recursive_semantics: TRUE
}

DEFINE ONTOLOGY_RELATIONS := {
    SemanticModel IS_SUBTYPE_OF LogicalModel,
    SemanticModel IS_COMPONENT_OF ModelTheory,
    SemanticModel HAS_SIGNATURE Signature,
    SemanticModel HAS_DOMAIN Domain,
    SemanticModel HAS_INTERPRETATION Interpretation,
    Interpretation INTERPRETS Symbol,
    ConstantSymbol DENOTES DomainElement,
    PredicateSymbol HAS_EXTENSION DomainRelation,
    SemanticModel SATISFIES Formula,
    SemanticModel IS_MODEL_OF Theory,
    SemanticModel BELONGS_TO_MODEL_CLASS ModelClass,
    SemanticConsequence DEPENDS_ON ModelClass,
    ElementaryEquivalence DEPENDS_ON SentenceTruthAgreement
}

DEFINE SEMANTIC_EQUIVALENCE := {
    "semantic model" <=> SemanticModel,
    "semantic interpretation model" <=> SemanticModel,
    "model-theoretic model" <=> SemanticModel WHEN formal_logic_context=TRUE,
    "semantic value" <=> SemanticValue,
    "predicate extension" <=> Extension,
    "model class" <=> ModelClass,
    "Mod(T)" <=> ModelClass(T)
}

DEFINE AI_CONSUMPTION := {
    purpose: "machine-readable representation of semantic models and model-based evaluation",
    preserve_model_identity: TRUE,
    preserve_language_identity: TRUE,
    preserve_signature_identity: TRUE,
    preserve_domain_identity: TRUE,
    preserve_symbol_identity: TRUE,
    preserve_semantic_values: TRUE,
    preserve_variable_assignments: TRUE,
    distinguish_symbols_from_semantic_values: TRUE,
    distinguish_truth_from_provability: TRUE,
    recursively_evaluate_formulas: TRUE,
    support_model_class_reasoning: TRUE,
    support_semantic_consequence: TRUE,
    support_isomorphism_invariance: TRUE,
    support_elementary_equivalence: TRUE,
    reasoning_mode: "symbolic + semantic + recursive + model-theoretic"
}

DEFINE CONFIDENCE := {
    ontology_identity: 1.00,
    semantic_mapping: 0.99,
    structure_model_mapping: 0.99,
    term_evaluation: 0.99,
    formula_satisfaction: 0.99,
    theory_model_mapping: 0.99,
    model_class_reasoning: 0.99,
    advanced_model_comparison: context_dependent
}

DEFINE UPDATE_MODEL := {
    version: "1.0",
    update_policy: "append-compatible",
    immutable_core: {
        language_signature_domain,
        symbol_semantic_mapping,
        interpretation,
        variable_assignment,
        recursive_satisfaction,
        model_of_theory,
        model_class,
        truth_provability_distinction
    },
    extensible_layers: {
        finite_semantic_models,
        infinite_semantic_models,
        modal_semantic_models,
        temporal_semantic_models,
        probabilistic_semantic_models,
        Kripke_models,
        algebraic_semantics,
        computational_model_checkers
    }
}

DEFINE FLOW_HASH_INPUT :=
    CanonicalURL
    + DOMAIN
    + ENTITY_TYPES
    + RELATION_TYPES
    + RULES
    + SEMANTIC_MODEL_SCHEMA
    + SEMANTIC_MAPPING_MODEL
    + MODEL_CLASS_MODEL
    + CRITICAL_DISTINCTIONS
    + SEMANTIC_MODEL_CONSTRUCTION_PIPELINE
    + SEMANTIC_EVALUATION_PIPELINE
    + MODEL_CLASS_PIPELINE
    + MODEL_COMPARISON_PIPELINE
    + SEMANTIC_MODEL_GRAPH
    + ONTOLOGY_RELATIONS
    + AI_CONSUMPTION
    + UPDATE_MODEL

FLOW_HASH := HASH(FLOW_HASH_INPUT)

RETURN {
    ontology: SemanticModelOntology,
    canonical_url: "https://kirethresearch.org/booksai-core/ontologies/mathematical-ontologies/mathematical-logic-ontologies/model-theory/semantic-model-ontology.html",
    parent_domain: ModelTheory,
    semantic_domain: MathematicalLogic,
    primary_entity: SemanticModel,
    semantic_mapping_enabled: TRUE,
    recursive_evaluation_enabled: TRUE,
    model_class_reasoning_enabled: TRUE,
    semantic_consequence_enabled: TRUE,
    model_comparison_enabled: TRUE,
    machine_consumable: TRUE,
    recursive_reasoning_enabled: TRUE,
    database_safe_unicode: TRUE,
    flow_complete: TRUE
}

END_FLOW