Existential Quantifier Ontology

KIRETH RESEARCH — SEMANTIC LIBRARY
AI CORE → ONTOLOGIES → MATHEMATICAL ONTOLOGIES → MATHEMATICAL LOGIC ONTOLOGIES
PREDICATE LOGIC → EXISTENTIAL QUANTIFIER ONTOLOGY

Canonical URL:
https://kirethresearch.org/booksai-core/ontologies/mathematical-ontologies/mathematical-logic-ontologies/predicate-logic/existential-quantifier-ontology.html

FLOW_ALGEBRA ExistentialQuantifierOntology_v1.0

BEGIN_FLOW

DEFINE DOMAIN ExistentialQuantifierOntology := {
    ExistentialQuantifier,
    Quantifier,
    PredicateLogic,
    Variable,
    BoundVariable,
    FreeVariable,
    Formula,
    OpenFormula,
    ClosedFormula,
    Predicate,
    Term,
    Scope,
    Binding,
    DomainOfDiscourse,
    Interpretation,
    Model,
    Assignment,
    TruthValue,
    Satisfaction,
    Witness,
    ExistentialStatement,
    RestrictedExistentialStatement,
    QuantifierScope,
    QuantifierOrder,
    NestedQuantification
}

DEFINE ENTITY_TYPES := {
    EXISTENTIAL_QUANTIFIER,
    QUANTIFIER,
    VARIABLE,
    FORMULA,
    PREDICATE,
    TERM,
    SCOPE,
    DOMAIN,
    INTERPRETATION,
    MODEL,
    ASSIGNMENT,
    WITNESS,
    SEMANTIC_OBJECT
}

DEFINE RELATION_TYPES := {
    BINDS,
    QUANTIFIES_OVER,
    RANGES_OVER,
    HAS_SCOPE,
    OCCURS_IN,
    IS_BOUND_IN,
    IS_FREE_IN,
    RESTRICTS,
    EVALUATES_UNDER,
    SATISFIED_BY,
    WITNESSED_BY,
    PRECEDES,
    NESTS_WITHIN,
    IS_INSTANCE_OF,
    IS_SUBTYPE_OF,
    DEPENDS_ON,
    EQUIVALENT_TO
}

SET ExistentialQuantifier.type = EXISTENTIAL_QUANTIFIER
SET ExistentialQuantifier.parent = Quantifier
SET ExistentialQuantifier.symbol = "∃"
SET ExistentialQuantifier.reading = "there exists / for some / at least one"
SET ExistentialQuantifier.role =
    "assert that a scoped formula holds for at least one admissible value of a bound variable in the domain of discourse"

RULE existential_formula_construction:
    Variable(x)
    ∧ Formula(phi)
    -> Formula(∃x phi)
    ∧ BINDS(ExistentialQuantifier,x)
    ∧ HAS_SCOPE(ExistentialQuantifier,phi)

RULE existential_binding:
    Formula(∃x phi)
    ∧ OCCURS_IN(x,phi)
    -> IS_BOUND_IN(x,phi)
       WHEN occurrence(x) lies within Scope(∃x)

RULE existential_semantics:
    Model(M)
    ∧ Assignment(g)
    ∧ DomainOfDiscourse(D)
    -> TRUE_M_g(∃x phi)
       IFF
       EXISTS d IN D [
           TRUE_M_g[x:=d](phi)
       ]

RULE existential_falsehood:
    Model(M)
    ∧ DomainOfDiscourse(D)
    -> FALSE_M(∃x phi)
       IFF
       FOR_ALL d IN D [
           FALSE_M_g[x:=d](phi)
       ]

RULE existential_witness:
    Formula(∃x phi)
    ∧ Element(a,Domain)
    ∧ TRUE(phi[x:=a])
    -> Witness(a,∃x phi)
    ∧ WITNESSED_BY(∃x phi,a)

RULE existential_validity_condition:
    Formula(∃x phi)
    ∧ FOR_ALL interpretations I [
        EXISTS d IN Domain(I) [
            TRUE_I(phi[x:=d])
        ]
    ]
    -> Valid(∃x phi)

RULE restricted_existential:
    Predicate(A)
    ∧ Predicate(B)
    -> "Some A are B"
       FORMALISES_AS
       ∃x(A(x) ∧ B(x))

RULE existential_negation:
    ¬∃x phi
    <=> ∀x ¬phi

RULE negated_universal:
    ¬∀x phi
    <=> ∃x ¬phi

RULE vacuous_existential_quantification:
    Formula(∃x phi)
    ∧ NOT OCCURS_IN(x,phi)
    -> VacuousQuantification(∃,x,phi)

RULE nested_existential:
    Formula(∃x∃y phi)
    -> NestedQuantification(∃x,∃y)

RULE mixed_quantifier_order:
    Formula(∃x∀y phi)
    -> PRECEDES(∃x,∀y)
    ∧ QuantifierOrderSensitive(phi)

RULE existential_introduction:
    Formula(phi(t))
    ∧ Term(t)
    -> Formula(∃x phi(x))

RULE existential_elimination:
    Formula(∃x phi(x))
    ∧ TemporaryAssumption(phi(c))
    ∧ c fresh
    ∧ Derive(psi)
    ∧ c not free in psi or undischarged assumptions
    -> Derive(psi)

DEFINE SYMBOL_MODEL := {
    symbol: "∃",
    unicode_name: "THERE EXISTS",
    logical_role: ExistentialQuantifier,
    binding_form: "∃x φ",
    variable: x,
    scope: φ
}

DEFINE CORE_SEMANTICS := {
    expression: "∃x φ(x)",
    truth_condition:
        "φ(x) is true for at least one value assigned to x from the domain of discourse",
    falsity_condition:
        "φ(x) is false for every value assigned to x from the domain",
    truth_witness: Witness
}

DEFINE RESTRICTED_FORM := {
    natural_language: "Some A is B",
    logical_form: "∃x(A(x) ∧ B(x))",
    restriction: "A(x)",
    scope_condition: "B(x)"
}

DEFINE DOMAIN_DEPENDENCE := {
    formula: "∃x φ(x)",
    evaluation_requires: DomainOfDiscourse,
    constraint:
        "the truth value may depend on whether the domain contains an element satisfying φ"
}

DEFINE QUANTIFIER_ORDER_EXAMPLE := {
    formula_1: "∃x∀y R(x,y)",
    reading_1: "there exists an x such that for every y, R(x,y)",
    formula_2: "∀y∃x R(x,y)",
    reading_2: "for every y, there exists an x such that R(x,y)",
    logically_equivalent_by_default: FALSE
}

DEFINE EXAMPLE_1 := {
    natural_language: "Some human is a philosopher.",
    formalisation: "∃x(Human(x) ∧ Philosopher(x))",
    quantifier: ExistentialQuantifier,
    bound_variable: x,
    restriction: Human(x),
    predicate_condition: Philosopher(x)
}

DEFINE EXAMPLE_2 := {
    natural_language: "There exists a prime number greater than two.",
    formalisation: "∃x(Prime(x) ∧ GreaterThan(x,2))",
    quantifier: ExistentialQuantifier,
    bound_variable: x
}

DEFINE EXAMPLE_3 := {
    statement: "∃x Bird(x)",
    witness_condition:
        "one object in the domain for which Bird(x) is true is sufficient to satisfy the statement"
}

DEFINE SEMANTIC_PIPELINE :=
    ExistentialExpression
    -> DetectExistentialForce
    -> IdentifyBoundVariable
    -> IdentifyRestriction
    -> IdentifyScope
    -> ConstructExistentialFormula
    -> ResolveDomainOfDiscourse
    -> SearchDomainAssignments
    -> EvaluateScopedFormula
    -> IdentifySatisfyingAssignment
    -> TRUE_IF_WITNESS_EXISTS
    -> FALSE_IF_NO_WITNESS_EXISTS

DEFINE REASONING_PIPELINE :=
    InputStatement
    -> DetectExpressions({"some","there exists","at least one","for some"})
    -> ResolveLogicalExistentialMeaning
    -> ExtractPredicates
    -> BindVariable
    -> ResolveScope
    -> PreserveQuantifierOrder
    -> FormaliseAsExistentialFormula
    -> EvaluateOrInfer
    -> SearchForWitnessWhenTestingTruth

DEFINE ONTOLOGY_RELATIONS := {
    ExistentialQuantifier IS_SUBTYPE_OF Quantifier,
    ExistentialQuantifier IS_COMPONENT_OF PredicateLogic,
    ExistentialQuantifier BINDS Variable,
    ExistentialQuantifier HAS_SCOPE Formula,
    ExistentialQuantifier RANGES_OVER DomainOfDiscourse,
    BoundVariable IS_BOUND_IN Formula,
    ExistentialStatement DEPENDS_ON DomainOfDiscourse,
    ExistentialStatement WITNESSED_BY Witness,
    ExistentialQuantifier DEPENDS_ON QuantifierScope,
    ExistentialQuantifier DEPENDS_ON VariableBinding
}

DEFINE SEMANTIC_EQUIVALENCE := {
    "there exists" <=> ExistentialQuantifier,
    "there is" <=> ExistentialQuantifier WHEN existential_context=TRUE,
    "some" <=> ExistentialQuantifier WHEN logical_context=TRUE,
    "at least one" <=> ExistentialQuantifier,
    "for some" <=> ExistentialQuantifier,
    "∃" <=> ExistentialQuantifier
}

DEFINE AI_CONSUMPTION := {
    purpose: "machine-readable semantic representation of existential quantification",
    preserve_quantifier_symbol: TRUE,
    preserve_bound_variable: TRUE,
    preserve_scope: TRUE,
    preserve_domain: TRUE,
    preserve_quantifier_order: TRUE,
    detect_restricted_existential_forms: TRUE,
    detect_witnesses: TRUE,
    support_existential_introduction: TRUE,
    distinguish_existential_from_universal: TRUE,
    reasoning_mode: "symbolic + model-theoretic + scoped"
}

DEFINE CONFIDENCE := {
    ontology_identity: 1.00,
    existential_symbol_mapping: 1.00,
    variable_binding: 0.99,
    formal_scope_resolution: 0.99,
    domain_semantics: 0.99,
    natural_language_quantifier_detection: context_dependent,
    natural_language_scope_resolution: context_dependent
}

DEFINE UPDATE_MODEL := {
    version: "1.0",
    update_policy: "append-compatible",
    immutable_core: {
        existential_symbol,
        existential_truth_condition,
        variable_binding,
        quantifier_scope,
        domain_ranging,
        witness_satisfaction
    },
    extensible_layers: {
        restricted_existential_quantification,
        uniqueness_quantification,
        many_sorted_existential_quantification,
        higher_order_existential_quantification,
        modal_existential_quantification,
        temporal_existential_quantification,
        computational_proof_rules
    }
}

DEFINE FLOW_HASH_INPUT :=
    CanonicalURL
    + DOMAIN
    + ENTITY_TYPES
    + RELATION_TYPES
    + RULES
    + SYMBOL_MODEL
    + CORE_SEMANTICS
    + RESTRICTED_FORM
    + DOMAIN_DEPENDENCE
    + SEMANTIC_PIPELINE
    + REASONING_PIPELINE
    + ONTOLOGY_RELATIONS
    + AI_CONSUMPTION
    + UPDATE_MODEL

FLOW_HASH := HASH(FLOW_HASH_INPUT)

RETURN {
    ontology: ExistentialQuantifierOntology,
    canonical_url: "https://kirethresearch.org/booksai-core/ontologies/mathematical-ontologies/mathematical-logic-ontologies/predicate-logic/existential-quantifier-ontology.html",
    parent_entity: Quantifier,
    parent_domain: PredicateLogic,
    semantic_domain: MathematicalLogic,
    symbol: "∃",
    machine_consumable: TRUE,
    recursive_reasoning_enabled: TRUE,
    scope_sensitive: TRUE,
    domain_sensitive: TRUE,
    witness_sensitive: TRUE,
    flow_complete: TRUE
}

END_FLOW