Universal Quantifier Ontology

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

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

FLOW_ALGEBRA UniversalQuantifierOntology_v1.0

BEGIN_FLOW

DEFINE DOMAIN UniversalQuantifierOntology := {
    UniversalQuantifier,
    Quantifier,
    PredicateLogic,
    Variable,
    BoundVariable,
    FreeVariable,
    Formula,
    OpenFormula,
    ClosedFormula,
    Predicate,
    Term,
    Scope,
    Binding,
    DomainOfDiscourse,
    Interpretation,
    Model,
    Assignment,
    TruthValue,
    Satisfaction,
    Counterexample,
    UniversalStatement,
    RestrictedUniversalStatement,
    QuantifierScope,
    QuantifierOrder,
    NestedQuantification
}

DEFINE ENTITY_TYPES := {
    UNIVERSAL_QUANTIFIER,
    QUANTIFIER,
    VARIABLE,
    FORMULA,
    PREDICATE,
    TERM,
    SCOPE,
    DOMAIN,
    INTERPRETATION,
    MODEL,
    ASSIGNMENT,
    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,
    FALSIFIED_BY,
    PRECEDES,
    NESTS_WITHIN,
    IS_INSTANCE_OF,
    IS_SUBTYPE_OF,
    DEPENDS_ON,
    EQUIVALENT_TO
}

SET UniversalQuantifier.type = UNIVERSAL_QUANTIFIER
SET UniversalQuantifier.parent = Quantifier
SET UniversalQuantifier.symbol = "∀"
SET UniversalQuantifier.reading = "for all / for every"
SET UniversalQuantifier.role =
    "assert that a scoped formula holds for every admissible value of a bound variable in the domain of discourse"

RULE universal_formula_construction:
    Variable(x)
    ∧ Formula(phi)
    -> Formula(∀x phi)
    ∧ BINDS(UniversalQuantifier,x)
    ∧ HAS_SCOPE(UniversalQuantifier,phi)

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

RULE universal_semantics:
    Model(M)
    ∧ Assignment(g)
    ∧ DomainOfDiscourse(D)
    -> TRUE_M_g(∀x phi)
       IFF
       FOR_ALL d IN D [
           TRUE_M_g[x:=d](phi)
       ]

RULE universal_falsehood:
    Model(M)
    ∧ DomainOfDiscourse(D)
    -> FALSE_M(∀x phi)
       IFF
       EXISTS d IN D [
           FALSE_M_g[x:=d](phi)
       ]

RULE counterexample:
    Formula(∀x phi)
    ∧ Element(a,Domain)
    ∧ FALSE(phi[x:=a])
    -> Counterexample(a,∀x phi)
    ∧ FALSIFIED_BY(∀x phi,a)

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

RULE restricted_universal:
    Predicate(A)
    ∧ Predicate(B)
    -> "All A are B"
       FORMALISES_AS
       ∀x(A(x) → B(x))

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

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

RULE vacuous_universal_quantification:
    Formula(∀x phi)
    ∧ NOT OCCURS_IN(x,phi)
    -> VacuousQuantification(∀,x,phi)

RULE nested_universal:
    Formula(∀x∀y phi)
    -> NestedQuantification(∀x,∀y)

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

RULE universal_instantiation:
    Formula(∀x phi(x))
    ∧ Term(t)
    ∧ FreeFor(t,x,phi)
    -> phi(t)

RULE universal_generalisation:
    Derivable(phi(x))
    ∧ x arbitrary
    ∧ x not dependent on undischarged special assumptions
    -> Derivable(∀x phi(x))

DEFINE SYMBOL_MODEL := {
    symbol: "∀",
    unicode_name: "FOR ALL",
    logical_role: UniversalQuantifier,
    binding_form: "∀x φ",
    variable: x,
    scope: φ
}

DEFINE CORE_SEMANTICS := {
    expression: "∀x φ(x)",
    truth_condition:
        "φ(x) is true for every value assigned to x from the domain of discourse",
    falsity_condition:
        "at least one domain element makes φ(x) false",
    falsification_witness: Counterexample
}

DEFINE RESTRICTED_FORM := {
    natural_language: "Every 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 which objects belong to the selected domain"
}

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

DEFINE EXAMPLE_1 := {
    natural_language: "Every human is mortal.",
    formalisation: "∀x(Human(x) → Mortal(x))",
    quantifier: UniversalQuantifier,
    bound_variable: x,
    restriction: Human(x),
    predicate_condition: Mortal(x)
}

DEFINE EXAMPLE_2 := {
    natural_language: "Everything is self-identical.",
    formalisation: "∀x(x=x)",
    quantifier: UniversalQuantifier,
    bound_variable: x
}

DEFINE EXAMPLE_3 := {
    statement: "∀x Bird(x)",
    counterexample_condition:
        "one object in the domain for which Bird(x) is false is sufficient to falsify the statement"
}

DEFINE SEMANTIC_PIPELINE :=
    UniversalExpression
    -> DetectUniversalForce
    -> IdentifyBoundVariable
    -> IdentifyRestriction
    -> IdentifyScope
    -> ConstructUniversalFormula
    -> ResolveDomainOfDiscourse
    -> GenerateAssignmentsForEveryDomainElement
    -> EvaluateScopedFormulaForEachAssignment
    -> AggregateTruthConditions
    -> TRUE_IF_ALL
    -> FALSE_IF_COUNTEREXAMPLE_EXISTS

DEFINE REASONING_PIPELINE :=
    InputStatement
    -> DetectExpressions({"all","every","each","any"})
    -> ResolveLogicalUniversalMeaning
    -> ExtractPredicates
    -> BindVariable
    -> ResolveScope
    -> PreserveQuantifierOrder
    -> FormaliseAsUniversalFormula
    -> EvaluateOrInfer
    -> SearchForCounterexampleWhenTestingTruth

DEFINE ONTOLOGY_RELATIONS := {
    UniversalQuantifier IS_SUBTYPE_OF Quantifier,
    UniversalQuantifier IS_COMPONENT_OF PredicateLogic,
    UniversalQuantifier BINDS Variable,
    UniversalQuantifier HAS_SCOPE Formula,
    UniversalQuantifier RANGES_OVER DomainOfDiscourse,
    BoundVariable IS_BOUND_IN Formula,
    UniversalStatement DEPENDS_ON DomainOfDiscourse,
    UniversalStatement FALSIFIED_BY Counterexample,
    UniversalQuantifier DEPENDS_ON QuantifierScope,
    UniversalQuantifier DEPENDS_ON VariableBinding
}

DEFINE SEMANTIC_EQUIVALENCE := {
    "for all" <=> UniversalQuantifier,
    "for every" <=> UniversalQuantifier,
    "every" <=> UniversalQuantifier WHEN quantificational_context=TRUE,
    "each" <=> UniversalQuantifier WHEN quantificational_context=TRUE,
    "all" <=> UniversalQuantifier WHEN logical_context=TRUE,
    "∀" <=> UniversalQuantifier
}

DEFINE AI_CONSUMPTION := {
    purpose: "machine-readable semantic representation of universal quantification",
    preserve_quantifier_symbol: TRUE,
    preserve_bound_variable: TRUE,
    preserve_scope: TRUE,
    preserve_domain: TRUE,
    preserve_quantifier_order: TRUE,
    detect_restricted_universal_forms: TRUE,
    detect_counterexamples: TRUE,
    support_universal_instantiation: TRUE,
    distinguish_universal_from_existential: TRUE,
    reasoning_mode: "symbolic + model-theoretic + scoped"
}

DEFINE CONFIDENCE := {
    ontology_identity: 1.00,
    universal_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: {
        universal_symbol,
        universal_truth_condition,
        variable_binding,
        quantifier_scope,
        domain_ranging,
        counterexample_falsification
    },
    extensible_layers: {
        restricted_universal_quantification,
        many_sorted_universal_quantification,
        higher_order_universal_quantification,
        modal_universal_quantification,
        temporal_universal_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: UniversalQuantifierOntology,
    canonical_url: "https://kirethresearch.org/booksai-core/ontologies/mathematical-ontologies/mathematical-logic-ontologies/predicate-logic/universal-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,
    flow_complete: TRUE
}

END_FLOW