Interpretation Ontology

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

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

FLOW_ALGEBRA InterpretationOntology_v1.0

BEGIN_FLOW

DEFINE DOMAIN InterpretationOntology := {
    Interpretation,
    ModelTheory,
    FormalLanguage,
    Signature,
    Structure,
    Model,
    Domain,
    Universe,
    Symbol,
    LogicalSymbol,
    NonLogicalSymbol,
    ConstantSymbol,
    FunctionSymbol,
    RelationSymbol,
    PredicateSymbol,
    Variable,
    VariableAssignment,
    Term,
    Formula,
    Sentence,
    Denotation,
    Extension,
    TruthValue,
    Satisfaction,
    Theory,
    SemanticConsequence
}

DEFINE ENTITY_TYPES := {
    INTERPRETATION,
    FORMAL_LANGUAGE,
    SIGNATURE,
    STRUCTURE,
    MODEL,
    DOMAIN,
    SYMBOL,
    CONSTANT_SYMBOL,
    FUNCTION_SYMBOL,
    RELATION_SYMBOL,
    ASSIGNMENT,
    TERM,
    FORMULA,
    SEMANTIC_VALUE,
    SEMANTIC_RELATION
}

DEFINE RELATION_TYPES := {
    INTERPRETS,
    HAS_DOMAIN,
    HAS_SIGNATURE,
    ASSIGNS,
    DENOTES,
    HAS_EXTENSION,
    EVALUATES,
    SATISFIES,
    IS_MODEL_OF,
    DEPENDS_ON,
    IS_INSTANCE_OF,
    IS_SUBTYPE_OF
}

SET Interpretation.type = INTERPRETATION
SET Interpretation.context = ModelTheory
SET Interpretation.role =
    "assign semantic values to the non-logical symbols of a formal language relative to a specified domain"

RULE interpretation_structure:
    Signature(Sigma)
    AND NonemptySet(D)
    AND Interpretation(I)
    -> Structure(M) = <D,I>

RULE constant_interpretation:
    ConstantSymbol(c)
    AND Domain(D)
    -> I(c) MEMBER_OF D

RULE function_interpretation:
    FunctionSymbol(f)
    AND Arity(f)=n
    AND Domain(D)
    -> I(f): D^n -> D

RULE relation_interpretation:
    RelationSymbol(R)
    AND Arity(R)=n
    AND Domain(D)
    -> I(R) SUBSET_OF D^n

RULE predicate_interpretation:
    PredicateSymbol(P)
    AND Arity(P)=n
    -> I(P) = Extension(P)
    AND Extension(P) SUBSET_OF D^n

RULE interpretation_respects_arity:
    NonLogicalSymbol(s)
    AND Arity(s)=n
    -> semantic_value_of(s)
       MUST_MATCH semantic_type_for_arity(n)

RULE constant_denotation:
    ConstantSymbol(c)
    -> DENOTES(c,I(c))

RULE variable_assignment_distinction:
    Variable(x)
    -> semantic_value_of(x)
       supplied_by VariableAssignment
       NOT Interpretation

RULE variable_assignment:
    VariableAssignment(g)
    AND Domain(D)
    -> g: Variables -> D

RULE term_variable_evaluation:
    Variable(x)
    -> Value(M,g,x)=g(x)

RULE term_constant_evaluation:
    ConstantSymbol(c)
    -> Value(M,g,c)=I(c)

RULE term_function_evaluation:
    Term(f(t1,...,tn))
    -> Value(M,g,f(t1,...,tn))
       = I(f)(
           Value(M,g,t1),
           ...,
           Value(M,g,tn)
         )

RULE atomic_predicate_evaluation:
    Formula(P(t1,...,tn))
    -> SATISFIES(M,g,P(t1,...,tn))
       IFF
       (
           Value(M,g,t1),
           ...,
           Value(M,g,tn)
       ) MEMBER_OF I(P)

RULE equality_evaluation:
    Formula(t1=t2)
    -> SATISFIES(M,g,t1=t2)
       IFF
       Value(M,g,t1)=Value(M,g,t2)

RULE sentence_interpretation:
    Sentence(phi)
    -> TruthValue(phi,M)
       independent_of_variable_assignment

RULE model_relation:
    Structure(M)
    AND Theory(T)
    AND FOR_EVERY phi MEMBER_OF T [
        SATISFIES(M,phi)
    ]
    -> IS_MODEL_OF(M,T)

DEFINE INTERPRETATION_SCHEMA := {
    interpretation_id: unique_identifier,
    signature: Signature,
    domain: NonemptySet,
    constant_map: {
        ConstantSymbol -> DomainElement
    },
    function_map: {
        FunctionSymbol -> DomainFunction
    },
    relation_map: {
        RelationSymbol -> DomainRelation
    }
}

DEFINE SYMBOL_SEMANTICS := {
    ConstantSymbol: {
        syntactic_type: "0-ary individual symbol",
        semantic_type: "element of D"
    },
    FunctionSymbol: {
        syntactic_type: "n-ary function symbol",
        semantic_type: "function D^n -> D"
    },
    RelationSymbol: {
        syntactic_type: "n-ary relation symbol",
        semantic_type: "subset of D^n"
    }
}

DEFINE INTERPRETATION_ASSIGNMENT_DISTINCTION := {
    Interpretation:
        "assigns meanings to non-logical constants, functions and relation symbols",
    VariableAssignment:
        "assigns domain elements to variables",
    requirement:
        "these two semantic mappings must remain distinct"
}

DEFINE SYNTAX_SEMANTICS_MAPPING := {
    ConstantSymbol -> DomainElement,
    FunctionSymbol -> DomainFunction,
    RelationSymbol -> RelationExtension,
    Term -> DomainElement,
    Formula -> TruthCondition,
    Sentence -> TruthValueInStructure
}

DEFINE EXAMPLE_1 := {
    language:
        "{zero,plus,less_than}",
    domain:
        "Integers",
    interpretation: {
        zero: "0",
        plus: "ordinary integer addition",
        less_than: "ordinary integer ordering"
    }
}

DEFINE EXAMPLE_2 := {
    predicate_symbol: "Even",
    domain: "Integers",
    interpretation:
        "set of all even integers",
    semantic_type:
        "unary relation / subset of the integer domain"
}

DEFINE EXAMPLE_3 := {
    function_symbol: "plus",
    arity: 2,
    domain: "Integers",
    interpretation:
        "plus(a,b) returns the ordinary sum of a and b",
    semantic_type:
        "D^2 -> D"
}

DEFINE INTERPRETATION_CONSTRUCTION_PIPELINE :=
    FormalLanguage
    -> ExtractSignature
    -> SelectDomain
    -> ForEachConstantSymbol
       -> AssignDomainElement
    -> ForEachFunctionSymbol
       -> AssignArityMatchingDomainFunction
    -> ForEachRelationSymbol
       -> AssignArityMatchingDomainRelation
    -> ValidateAllSemanticTypes
    -> ConstructInterpretation
    -> ConstructStructure

DEFINE TERM_EVALUATION_PIPELINE :=
    Term
    -> ParseTermTree
    -> ResolveVariableValuesFromAssignment
    -> ResolveConstantValuesFromInterpretation
    -> RecursivelyEvaluateFunctionApplications
    -> ReturnDomainElement

DEFINE FORMULA_EVALUATION_PIPELINE :=
    Formula
    -> EvaluateTerms
    -> ResolvePredicateExtensions
    -> EvaluateAtomicFormula
    -> RecursivelyEvaluateLogicalConnectives
    -> EvaluateQuantifiersUsingVariableAssignments
    -> ReturnSatisfactionStatus

DEFINE VALIDATION_PIPELINE :=
    CandidateInterpretation
    -> VerifyDomainExists
    -> VerifySignatureMatch
    -> VerifyEveryConstantHasDomainValue
    -> VerifyEveryFunctionHasCorrectArity
    -> VerifyFunctionOutputsRemainInDomain
    -> VerifyEveryRelationHasCorrectTupleArity
    -> VerifyNoRequiredSymbolUninterpreted
    -> Return ValidInterpretation OR InvalidInterpretation

DEFINE INTERPRETATION_GRAPH := {
    nodes: {
        SignatureNode,
        DomainNode,
        SymbolNode,
        SemanticValueNode,
        StructureNode
    },
    edges: {
        HAS_SIGNATURE,
        HAS_DOMAIN,
        INTERPRETS,
        DENOTES,
        HAS_EXTENSION
    },
    mapping_direction:
        "syntactic symbol -> semantic object"
}

DEFINE ONTOLOGY_RELATIONS := {
    Interpretation IS_COMPONENT_OF ModelTheory,
    Structure DEPENDS_ON Interpretation,
    Structure HAS_DOMAIN Domain,
    Structure HAS_SIGNATURE Signature,
    Interpretation INTERPRETS NonLogicalSymbol,
    ConstantSymbol DENOTES DomainElement,
    FunctionSymbol DENOTES DomainFunction,
    RelationSymbol HAS_EXTENSION DomainRelation,
    VariableAssignment IS_DISTINCT_FROM Interpretation,
    TermEvaluation DEPENDS_ON Interpretation,
    TermEvaluation DEPENDS_ON VariableAssignment,
    FormulaSatisfaction DEPENDS_ON Interpretation
}

DEFINE SEMANTIC_EQUIVALENCE := {
    "interpretation" <=> Interpretation WHEN formal_logic_context=TRUE,
    "semantic interpretation" <=> Interpretation,
    "interpretation function" <=> Interpretation,
    "meaning assignment" <=> Interpretation WHEN model_theory_context=TRUE,
    "predicate extension" <=> Extension,
    "denotation" <=> Denotation
}

DEFINE AI_CONSUMPTION := {
    purpose: "machine-readable representation and validation of semantic interpretations in model theory",
    preserve_signature_identity: TRUE,
    preserve_domain_identity: TRUE,
    preserve_symbol_identity: TRUE,
    preserve_symbol_arity: TRUE,
    preserve_semantic_value_type: TRUE,
    distinguish_interpretation_from_variable_assignment: TRUE,
    validate_constant_denotations: TRUE,
    validate_function_closure: TRUE,
    validate_relation_arity: TRUE,
    support_recursive_term_evaluation: TRUE,
    support_formula_satisfaction: TRUE,
    construct_symbol_semantic_graph: TRUE,
    reasoning_mode: "symbolic + semantic + typed + model-theoretic"
}

DEFINE CONFIDENCE := {
    ontology_identity: 1.00,
    constant_interpretation_mapping: 0.99,
    function_interpretation_mapping: 0.99,
    relation_interpretation_mapping: 0.99,
    arity_validation: 0.99,
    interpretation_assignment_distinction: 1.00,
    term_evaluation: 0.99,
    formula_evaluation: context_dependent
}

DEFINE UPDATE_MODEL := {
    version: "1.0",
    update_policy: "append-compatible",
    immutable_core: {
        signature_domain_interpretation,
        constant_to_domain_element,
        function_to_domain_function,
        relation_to_domain_relation,
        arity_preservation,
        interpretation_assignment_distinction
    },
    extensible_layers: {
        many_sorted_interpretations,
        higher_order_interpretations,
        modal_interpretations,
        temporal_interpretations,
        probabilistic_interpretations,
        algebraic_semantics,
        computational_model_checkers
    }
}

DEFINE FLOW_HASH_INPUT :=
    CanonicalURL
    + DOMAIN
    + ENTITY_TYPES
    + RELATION_TYPES
    + RULES
    + INTERPRETATION_SCHEMA
    + SYMBOL_SEMANTICS
    + INTERPRETATION_ASSIGNMENT_DISTINCTION
    + SYNTAX_SEMANTICS_MAPPING
    + INTERPRETATION_CONSTRUCTION_PIPELINE
    + TERM_EVALUATION_PIPELINE
    + FORMULA_EVALUATION_PIPELINE
    + VALIDATION_PIPELINE
    + INTERPRETATION_GRAPH
    + ONTOLOGY_RELATIONS
    + AI_CONSUMPTION
    + UPDATE_MODEL

FLOW_HASH := HASH(FLOW_HASH_INPUT)

RETURN {
    ontology: InterpretationOntology,
    canonical_url: "https://kirethresearch.org/booksai-core/ontologies/mathematical-ontologies/mathematical-logic-ontologies/model-theory/interpretation-ontology.html",
    parent_domain: ModelTheory,
    semantic_domain: MathematicalLogic,
    primary_entity: Interpretation,
    typed_symbol_mapping_enabled: TRUE,
    arity_validation_enabled: TRUE,
    term_evaluation_enabled: TRUE,
    formula_evaluation_enabled: TRUE,
    machine_consumable: TRUE,
    recursive_reasoning_enabled: TRUE,
    database_safe_unicode: TRUE,
    flow_complete: TRUE
}

END_FLOW