Satisfaction Ontology

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

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

FLOW_ALGEBRA SatisfactionOntology_v1.0

BEGIN_FLOW

DEFINE DOMAIN SatisfactionOntology := {
    Satisfaction,
    ModelTheory,
    Structure,
    LogicalModel,
    Model,
    FormalLanguage,
    Signature,
    Domain,
    Interpretation,
    VariableAssignment,
    Term,
    Formula,
    AtomicFormula,
    CompoundFormula,
    Sentence,
    Theory,
    TruthValue,
    SemanticConsequence,
    Satisfiability,
    Unsatisfiability,
    Validity,
    ConstantSymbol,
    FunctionSymbol,
    RelationSymbol,
    PredicateSymbol,
    Equality,
    Negation,
    Conjunction,
    Disjunction,
    Implication,
    UniversalQuantifier,
    ExistentialQuantifier
}

DEFINE ENTITY_TYPES := {
    SATISFACTION_RELATION,
    STRUCTURE,
    MODEL,
    FORMAL_LANGUAGE,
    DOMAIN,
    INTERPRETATION,
    ASSIGNMENT,
    TERM,
    FORMULA,
    SENTENCE,
    THEORY,
    SYMBOL,
    TRUTH_VALUE,
    SEMANTIC_PROPERTY
}

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

SET Satisfaction.type = SATISFACTION_RELATION
SET Satisfaction.context = ModelTheory
SET Satisfaction.role =
    "relate a structure and variable assignment to a formula when the formula is true under that interpretation"

RULE variable_term:
    Variable(x)
    -> Value(M,s,x)=s(x)

RULE constant_term:
    ConstantSymbol(c)
    -> Value(M,s,c)=Interpretation_M(c)

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

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

RULE equality_satisfaction:
    Formula(t1=t2)
    -> SATISFIES(M,s,t1=t2)
       IFF
       Value(M,s,t1)=Value(M,s,t2)

RULE negation_satisfaction:
    Formula(NOT(phi))
    -> SATISFIES(M,s,NOT(phi))
       IFF
       NOT SATISFIES(M,s,phi)

RULE conjunction_satisfaction:
    Formula(AND(phi,psi))
    -> SATISFIES(M,s,AND(phi,psi))
       IFF
       (
           SATISFIES(M,s,phi)
           AND
           SATISFIES(M,s,psi)
       )

RULE disjunction_satisfaction:
    Formula(OR(phi,psi))
    -> SATISFIES(M,s,OR(phi,psi))
       IFF
       (
           SATISFIES(M,s,phi)
           OR
           SATISFIES(M,s,psi)
       )

RULE implication_satisfaction:
    Formula(IMPLIES(phi,psi))
    -> SATISFIES(M,s,IMPLIES(phi,psi))
       IFF
       (
           NOT SATISFIES(M,s,phi)
           OR
           SATISFIES(M,s,psi)
       )

RULE biconditional_satisfaction:
    Formula(IFF(phi,psi))
    -> SATISFIES(M,s,IFF(phi,psi))
       IFF
       (
           SATISFIES(M,s,phi)
           AND SATISFIES(M,s,psi)
       )
       OR
       (
           NOT SATISFIES(M,s,phi)
           AND NOT SATISFIES(M,s,psi)
       )

RULE universal_satisfaction:
    Formula(FOR_ALL x phi)
    -> SATISFIES(M,s,FOR_ALL x phi)
       IFF
       FOR_EVERY a MEMBER_OF Domain(M) [
           SATISFIES(M,s[x:=a],phi)
       ]

RULE existential_satisfaction:
    Formula(EXISTS x phi)
    -> SATISFIES(M,s,EXISTS x phi)
       IFF
       THERE_EXISTS a MEMBER_OF Domain(M) [
           SATISFIES(M,s[x:=a],phi)
       ]

RULE free_variable_dependence:
    Formula(phi)
    AND x MEMBER_OF FreeVariables(phi)
    -> SatisfactionStatus(M,s,phi)
       MAY_DEPEND_ON s(x)

RULE sentence_assignment_independence:
    Sentence(phi)
    -> FOR_EVERY assignments s1,s2 [
        SATISFIES(M,s1,phi)
        IFF
        SATISFIES(M,s2,phi)
    ]

RULE sentence_satisfaction:
    Sentence(phi)
    -> SATISFIES(M,phi)
       IFF
       SATISFIES(M,s,phi)
       FOR any assignment s

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

RULE model_of_theory:
    SATISFIES(M,T)
    -> IS_MODEL_OF(M,T)

RULE satisfiable_formula:
    Formula(phi)
    AND THERE_EXISTS Structure(M)
    AND THERE_EXISTS Assignment(s) [
        SATISFIES(M,s,phi)
    ]
    -> Satisfiable(phi)

RULE satisfiable_sentence:
    Sentence(phi)
    AND THERE_EXISTS Structure(M) [
        SATISFIES(M,phi)
    ]
    -> Satisfiable(phi)

RULE satisfiable_theory:
    Theory(T)
    AND THERE_EXISTS Structure(M) [
        SATISFIES(M,T)
    ]
    -> Satisfiable(T)

RULE unsatisfiable_theory:
    Theory(T)
    AND NOT THERE_EXISTS Structure(M) [
        SATISFIES(M,T)
    ]
    -> Unsatisfiable(T)

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

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

DEFINE SATISFACTION_SCHEMA := {
    structure: M,
    assignment: s,
    formula: phi,
    relation:
        "SATISFIES(M,s,phi)",
    output:
        BooleanTruthStatus
}

DEFINE SENTENCE_SATISFACTION_SCHEMA := {
    structure: M,
    sentence: phi,
    relation:
        "SATISFIES(M,phi)",
    assignment_required:
        FALSE
}

DEFINE THEORY_SATISFACTION_SCHEMA := {
    structure: M,
    theory: T,
    relation:
        "SATISFIES(M,T)",
    condition:
        "M satisfies every sentence in T"
}

DEFINE RECURSIVE_SEMANTICS := {
    atomic:
        "evaluate terms and test relation membership or equality",
    negation:
        "invert satisfaction status",
    conjunction:
        "both subformulas must be satisfied",
    disjunction:
        "at least one subformula must be satisfied",
    implication:
        "antecedent false or consequent true",
    universal:
        "scoped formula satisfied under every domain reassignment of bound variable",
    existential:
        "scoped formula satisfied under at least one domain reassignment of bound variable"
}

DEFINE CRITICAL_DISTINCTIONS := {
    satisfaction_vs_truth: {
        satisfaction:
            "normally relates M, assignment s and formula phi",
        truth:
            "for a sentence, assignment dependence disappears and one may say phi is true in M"
    },
    satisfaction_vs_satisfiability: {
        satisfaction:
            "a particular structure/assignment satisfies a formula",
        satisfiability:
            "there exists at least one suitable structure/assignment satisfying it"
    },
    satisfaction_vs_validity: {
        satisfaction:
            "truth in a particular structure",
        validity:
            "truth in every relevant structure"
    },
    satisfaction_vs_derivability: {
        satisfaction:
            "semantic relation",
        derivability:
            "syntactic proof relation",
        equivalence: FALSE
    }
}

DEFINE EXAMPLE_1 := {
    domain:
        "{1,2,3}",
    predicate_interpretation:
        "Even = {2}",
    formula:
        "Even(x)",
    assignment:
        "x := 2",
    result:
        "SATISFIES(M,s,Even(x)) = TRUE"
}

DEFINE EXAMPLE_2 := {
    domain:
        "Integers",
    formula:
        "FOR_ALL x EXISTS y GreaterThan(y,x)",
    result:
        "satisfied in the standard integer structure"
}

DEFINE EXAMPLE_3 := {
    theory:
        "{phi1, phi2, phi3}",
    condition:
        "M satisfies phi1, phi2 and phi3",
    conclusion:
        "M satisfies the theory"
}

DEFINE TERM_EVALUATION_PIPELINE :=
    Term
    -> ParseTerm
    -> ResolveVariablesFromAssignment
    -> ResolveConstantsFromInterpretation
    -> RecursivelyEvaluateFunctionTerms
    -> ReturnDomainElement

DEFINE FORMULA_SATISFACTION_PIPELINE :=
    Formula
    -> ParseFormulaTree
    -> IF AtomicFormula
       THEN EvaluateTermsAndAtomicCondition
    -> IF CompoundFormula
       THEN RecursivelyEvaluateSubformulas
    -> IF QuantifiedFormula
       THEN GenerateRequiredVariableReassignments
    -> CombineAccordingToSemanticClause
    -> ReturnSatisfactionStatus

DEFINE THEORY_SATISFACTION_PIPELINE :=
    Theory
    -> EnumerateSentences
    -> ForEachSentence
       -> EvaluateInStructure
    -> IF every_sentence_satisfied
       THEN ModelOfTheory
       ELSE NonModelOfTheory

DEFINE SEMANTIC_REASONING_PIPELINE :=
    InputFormulaOrTheory
    -> ResolveSignature
    -> ResolveStructure
    -> ResolveAssignmentIfNeeded
    -> EvaluateSatisfaction
    -> DetermineSatisfiability
    -> DetermineValidityWhenRequested
    -> DetermineSemanticConsequenceWhenRequested
    -> ReturnSemanticRelations

DEFINE SATISFACTION_GRAPH := {
    nodes: {
        StructureNode,
        AssignmentNode,
        FormulaNode,
        SentenceNode,
        TheoryNode,
        TruthStatusNode
    },
    edges: {
        ASSIGNS,
        SATISFIES,
        DOES_NOT_SATISFY,
        IS_MODEL_OF,
        ENTAILS
    },
    recursive_formula_evaluation: TRUE
}

DEFINE ONTOLOGY_RELATIONS := {
    Satisfaction IS_COMPONENT_OF ModelTheory,
    Satisfaction RELATES Structure TO Formula,
    Satisfaction MAY_DEPEND_ON VariableAssignment,
    SentenceSatisfaction DOES_NOT_DEPEND_ON VariableAssignment,
    Model IS_STRUCTURE_THAT SATISFIES Theory,
    Satisfiability DEPENDS_ON ExistenceOfSatisfyingStructure,
    Validity DEPENDS_ON SatisfactionInAllStructures,
    SemanticConsequence DEPENDS_ON SatisfactionAcrossModelClass,
    FormulaEvaluation DEPENDS_ON Interpretation,
    FormulaEvaluation DEPENDS_ON VariableAssignment WHEN free_variables_exist=TRUE
}

DEFINE SEMANTIC_EQUIVALENCE := {
    "satisfaction" <=> Satisfaction,
    "satisfies" <=> SATISFIES,
    "is satisfied by" <=> SATISFIES,
    "true in a structure" <=> SentenceSatisfaction WHEN sentence_context=TRUE,
    "model of" <=> IS_MODEL_OF,
    "satisfiable" <=> Satisfiability,
    "semantically entails" <=> SemanticConsequence
}

DEFINE AI_CONSUMPTION := {
    purpose: "machine-readable recursive representation of satisfaction semantics in model theory",
    preserve_structure_identity: TRUE,
    preserve_assignment_identity: TRUE,
    preserve_formula_identity: TRUE,
    preserve_interpretation_identity: TRUE,
    recursively_evaluate_formula_structure: TRUE,
    distinguish_formula_from_sentence: TRUE,
    distinguish_satisfaction_from_satisfiability: TRUE,
    distinguish_satisfaction_from_validity: TRUE,
    distinguish_semantic_satisfaction_from_syntactic_derivability: TRUE,
    support_quantifier_assignment_updates: TRUE,
    support_theory_satisfaction: TRUE,
    support_semantic_consequence: TRUE,
    reasoning_mode: "symbolic + recursive + semantic + model-theoretic"
}

DEFINE CONFIDENCE := {
    ontology_identity: 1.00,
    atomic_satisfaction: 0.99,
    connective_semantics: 0.99,
    quantifier_semantics: 0.99,
    sentence_assignment_independence: 0.99,
    theory_satisfaction: 0.99,
    semantic_consequence: 0.99,
    complex_formula_evaluation: structure_and_formula_dependent
}

DEFINE UPDATE_MODEL := {
    version: "1.0",
    update_policy: "append-compatible",
    immutable_core: {
        structure_assignment_formula_relation,
        atomic_satisfaction,
        recursive_connective_semantics,
        quantifier_semantics,
        sentence_assignment_independence,
        theory_satisfaction,
        semantic_consequence
    },
    extensible_layers: {
        many_sorted_satisfaction,
        modal_satisfaction,
        temporal_satisfaction,
        intuitionistic_Kripke_satisfaction,
        probabilistic_semantics,
        finite_model_checkers,
        automated_semantic_evaluation
    }
}

DEFINE FLOW_HASH_INPUT :=
    CanonicalURL
    + DOMAIN
    + ENTITY_TYPES
    + RELATION_TYPES
    + RULES
    + SATISFACTION_SCHEMA
    + SENTENCE_SATISFACTION_SCHEMA
    + THEORY_SATISFACTION_SCHEMA
    + RECURSIVE_SEMANTICS
    + CRITICAL_DISTINCTIONS
    + TERM_EVALUATION_PIPELINE
    + FORMULA_SATISFACTION_PIPELINE
    + THEORY_SATISFACTION_PIPELINE
    + SEMANTIC_REASONING_PIPELINE
    + SATISFACTION_GRAPH
    + ONTOLOGY_RELATIONS
    + AI_CONSUMPTION
    + UPDATE_MODEL

FLOW_HASH := HASH(FLOW_HASH_INPUT)

RETURN {
    ontology: SatisfactionOntology,
    canonical_url: "https://kirethresearch.org/booksai-core/ontologies/mathematical-ontologies/mathematical-logic-ontologies/model-theory/satisfaction-ontology.html",
    parent_domain: ModelTheory,
    semantic_domain: MathematicalLogic,
    primary_entity: Satisfaction,
    recursive_semantics_enabled: TRUE,
    assignment_reasoning_enabled: TRUE,
    theory_satisfaction_enabled: TRUE,
    semantic_consequence_enabled: TRUE,
    machine_consumable: TRUE,
    recursive_reasoning_enabled: TRUE,
    database_safe_unicode: TRUE,
    flow_complete: TRUE
}

END_FLOW