Domain of Discourse Ontology

KIRETH RESEARCH — SEMANTIC LIBRARY
AI CORE → ONTOLOGIES → MATHEMATICAL ONTOLOGIES → MATHEMATICAL LOGIC ONTOLOGIES
PREDICATE LOGIC → DOMAIN OF DISCOURSE ONTOLOGY

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

FLOW_ALGEBRA DomainOfDiscourseOntology_v1.0

BEGIN_FLOW

DEFINE DOMAIN DomainOfDiscourseOntology := {
    DomainOfDiscourse,
    UniverseOfDiscourse,
    Domain,
    PredicateLogic,
    Individual,
    Object,
    Element,
    Entity,
    Variable,
    Constant,
    Term,
    Predicate,
    Relation,
    FunctionSymbol,
    Quantifier,
    UniversalQuantifier,
    ExistentialQuantifier,
    Formula,
    Interpretation,
    Structure,
    Model,
    Assignment,
    Denotation,
    Extension,
    TruthValue,
    Satisfaction,
    Subdomain,
    EmptyDomain,
    NonEmptyDomain,
    SortedDomain,
    ManySortedDomain
}

DEFINE ENTITY_TYPES := {
    DOMAIN,
    ELEMENT,
    INDIVIDUAL,
    VARIABLE,
    TERM,
    SYMBOL,
    PREDICATE,
    QUANTIFIER,
    FORMULA,
    INTERPRETATION,
    MODEL,
    ASSIGNMENT,
    SEMANTIC_OBJECT
}

DEFINE RELATION_TYPES := {
    CONTAINS,
    MEMBER_OF,
    RANGES_OVER,
    QUANTIFIES_OVER,
    ASSIGNS_FROM,
    DENOTES_IN,
    INTERPRETS_OVER,
    HAS_DOMAIN,
    HAS_CODOMAIN,
    RESTRICTS,
    IS_SUBDOMAIN_OF,
    SATISFIES,
    EVALUATES_IN,
    DEPENDS_ON,
    IS_INSTANCE_OF,
    IS_SUBTYPE_OF
}

SET DomainOfDiscourse.type = DOMAIN
SET DomainOfDiscourse.alias = UniverseOfDiscourse
SET DomainOfDiscourse.context = PredicateLogic
SET DomainOfDiscourse.role =
    "specify the collection of objects over which variables range and quantifiers operate during interpretation"

RULE domain_membership:
    DomainOfDiscourse(D)
    ∧ Object(a)
    ∧ a ∈ D
    -> MEMBER_OF(a,D)
    ∧ CONTAINS(D,a)

RULE variable_range:
    Variable(x)
    ∧ DomainOfDiscourse(D)
    -> RANGES_OVER(x,D)

RULE universal_domain:
    Formula(∀x phi)
    ∧ DomainOfDiscourse(D)
    -> QUANTIFIES_OVER(∀x,D)
    ∧ FOR_ALL d IN D [Evaluate(phi,x:=d)]

RULE existential_domain:
    Formula(∃x phi)
    ∧ DomainOfDiscourse(D)
    -> QUANTIFIES_OVER(∃x,D)
    ∧ EXISTS d IN D [Evaluate(phi,x:=d)]

RULE assignment_from_domain:
    Assignment(g)
    ∧ Variable(x)
    ∧ DomainOfDiscourse(D)
    -> g(x) ∈ D
    ∧ ASSIGNS_FROM(g,x,D)

RULE constant_denotation:
    Interpretation(I)
    ∧ Constant(c)
    ∧ DomainOfDiscourse(D)
    -> Denotation_I(c) ∈ D
    ∧ DENOTES_IN(c,D)

RULE predicate_interpretation:
    Interpretation(I)
    ∧ Predicate(P)
    ∧ Arity(P)=n
    ∧ DomainOfDiscourse(D)
    -> Extension_I(P) subset_of D^n

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

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

RULE model_definition:
    Structure(M)
    ∧ FormulaSet(Gamma)
    ∧ SATISFIES(M,Gamma)
    -> Model(M,Gamma)

RULE truth_domain_dependence:
    Formula(phi)
    ∧ Interpretation(I)
    ∧ DomainOfDiscourse(D1)
    ∧ DomainOfDiscourse(D2)
    ∧ D1 != D2
    -> TruthValue(phi,I,D1)
       MAY_DIFFER_FROM
       TruthValue(phi,I,D2)

RULE subdomain:
    Domain(D1)
    ∧ Domain(D2)
    ∧ D1 subset_of D2
    -> IS_SUBDOMAIN_OF(D1,D2)

RULE restricted_domain_reasoning:
    DomainOfDiscourse(D)
    ∧ RestrictionCondition(R)
    -> Subdomain(D_R) = {x ∈ D | R(x)}

RULE standard_first_order_nonempty_domain:
    StandardFirstOrderSemantics
    -> Cardinality(DomainOfDiscourse) >= 1

DEFINE DOMAIN_CONSTRAINTS := {
    standard_first_order_logic: {
        nonempty: TRUE,
        variables_range_over: "elements of D",
        constants_denote: "elements of D",
        n_ary_predicates_denote: "subsets of D^n",
        n_ary_functions_denote: "functions D^n -> D"
    },
    alternative_logical_systems: {
        empty_domain_possible: system_dependent
    }
}

DEFINE QUANTIFIER_DEPENDENCE := {
    universal: {
        expression: "∀x φ(x)",
        domain_role: "test φ for every x ∈ D"
    },
    existential: {
        expression: "∃x φ(x)",
        domain_role: "test whether at least one x ∈ D satisfies φ"
    }
}

DEFINE INTERPRETATION_STRUCTURE := {
    structure: "M = <D,I>",
    D: DomainOfDiscourse,
    I: Interpretation,
    requirement:
        "I assigns semantic values to non-logical symbols relative to D"
}

DEFINE EXAMPLE_1 := {
    formula: "∀x Mortal(x)",
    domain_A: "all humans",
    domain_B: "all living organisms",
    observation:
        "the domain determines which objects must satisfy Mortal(x)"
}

DEFINE EXAMPLE_2 := {
    formula: "∃x Prime(x)",
    domain: "natural numbers",
    evaluation:
        "true when at least one member of the natural-number domain belongs to the extension of Prime"
}

DEFINE EXAMPLE_3 := {
    language: "people in a particular classroom",
    domain: "the people under discussion",
    role:
        "variables and quantifiers are interpreted only over those domain members"
}

DEFINE SEMANTIC_PIPELINE :=
    LogicalLanguage
    -> IdentifyIntendedUniverse
    -> ConstructDomainOfDiscourse
    -> ValidateDomainConstraints
    -> MapConstantsToDomainElements
    -> MapFunctionsOverDomain
    -> MapPredicatesToRelationsOverDomain
    -> RangeVariablesOverDomain
    -> ApplyVariableAssignments
    -> EvaluateQuantifiedFormulas
    -> DetermineSatisfactionAndTruth

DEFINE REASONING_PIPELINE :=
    InputFormulaOrStatement
    -> IdentifyEntityTypesUnderDiscussion
    -> ResolveDomainOfDiscourse
    -> CheckDomainRestrictions
    -> ResolveVariableRange
    -> ResolveSymbolDenotations
    -> ApplyQuantifierSemantics
    -> EvaluateFormula
    -> CompareAlternativeDomainsWhenRelevant

DEFINE DOMAIN_SELECTION_PIPELINE :=
    Context
    -> CandidateEntities
    -> InclusionCriteria
    -> ExclusionCriteria
    -> DomainBoundary
    -> DomainOfDiscourse
    -> SemanticInterpretation

DEFINE ONTOLOGY_RELATIONS := {
    DomainOfDiscourse IS_COMPONENT_OF PredicateLogicSemantics,
    DomainOfDiscourse CONTAINS Element,
    Element MEMBER_OF DomainOfDiscourse,
    Variable RANGES_OVER DomainOfDiscourse,
    UniversalQuantifier QUANTIFIES_OVER DomainOfDiscourse,
    ExistentialQuantifier QUANTIFIES_OVER DomainOfDiscourse,
    Assignment ASSIGNS_FROM DomainOfDiscourse,
    Constant DENOTES_IN DomainOfDiscourse,
    Interpretation INTERPRETS_OVER DomainOfDiscourse,
    Predicate HAS_EXTENSION RelationOverDomain,
    FunctionSymbol HAS_DOMAIN DomainOfDiscourse,
    Subdomain IS_SUBDOMAIN_OF DomainOfDiscourse,
    FormulaEvaluation DEPENDS_ON DomainOfDiscourse
}

DEFINE SEMANTIC_EQUIVALENCE := {
    "domain of discourse" <=> DomainOfDiscourse,
    "universe of discourse" <=> DomainOfDiscourse,
    "universe" <=> DomainOfDiscourse WHEN formal_logic_context=TRUE,
    "domain" <=> DomainOfDiscourse WHEN interpretation_context=TRUE,
    "range of quantification" <=> DomainOfDiscourse WHEN quantifier_context=TRUE
}

DEFINE AI_CONSUMPTION := {
    purpose: "machine-readable representation of the universe over which predicate-logic expressions are interpreted",
    preserve_domain_identity: TRUE,
    preserve_domain_membership: TRUE,
    preserve_domain_restrictions: TRUE,
    bind_variable_ranges_to_domain: TRUE,
    bind_quantifier_ranges_to_domain: TRUE,
    constrain_constant_denotations_to_domain: TRUE,
    constrain_predicate_extensions_to_domain_products: TRUE,
    constrain_function_interpretations_to_domain: TRUE,
    detect_domain_sensitive_truth: TRUE,
    distinguish_domain_from_predicate_extension: TRUE,
    reasoning_mode: "symbolic + model-theoretic + domain-aware"
}

DEFINE CONFIDENCE := {
    ontology_identity: 1.00,
    domain_membership_mapping: 0.99,
    variable_range_mapping: 0.99,
    quantifier_domain_mapping: 0.99,
    interpretation_mapping: 0.99,
    formal_domain_resolution: 0.99,
    natural_language_domain_resolution: context_dependent
}

DEFINE UPDATE_MODEL := {
    version: "1.0",
    update_policy: "append-compatible",
    immutable_core: {
        domain_membership,
        variable_ranging,
        quantifier_ranging,
        constant_denotation,
        predicate_extension_domain,
        function_domain_mapping
    },
    extensible_layers: {
        sorted_domains,
        many_sorted_domains,
        varying_domains,
        possible_world_domains,
        temporal_domains,
        computational_domains,
        empty_domain_semantics
    }
}

DEFINE FLOW_HASH_INPUT :=
    CanonicalURL
    + DOMAIN
    + ENTITY_TYPES
    + RELATION_TYPES
    + RULES
    + DOMAIN_CONSTRAINTS
    + QUANTIFIER_DEPENDENCE
    + INTERPRETATION_STRUCTURE
    + SEMANTIC_PIPELINE
    + REASONING_PIPELINE
    + DOMAIN_SELECTION_PIPELINE
    + ONTOLOGY_RELATIONS
    + AI_CONSUMPTION
    + UPDATE_MODEL

FLOW_HASH := HASH(FLOW_HASH_INPUT)

RETURN {
    ontology: DomainOfDiscourseOntology,
    canonical_url: "https://kirethresearch.org/booksai-core/ontologies/mathematical-ontologies/mathematical-logic-ontologies/predicate-logic/domain-of-discourse-ontology.html",
    parent_domain: PredicateLogic,
    semantic_domain: MathematicalLogic,
    primary_entity: DomainOfDiscourse,
    alias: UniverseOfDiscourse,
    machine_consumable: TRUE,
    recursive_reasoning_enabled: TRUE,
    domain_sensitive: TRUE,
    model_theoretic: TRUE,
    flow_complete: TRUE
}

END_FLOW