Empty Set Ontology

KIRETH RESEARCH — SEMANTIC LIBRARY
AI CORE → ONTOLOGIES → MATHEMATICAL ONTOLOGIES → MATHEMATICAL LOGIC ONTOLOGIES
SET THEORY → EMPTY SET ONTOLOGY

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

FLOW_ALGEBRA EmptySetOntology_v1.0

BEGIN_FLOW

DEFINE DOMAIN EmptySetOntology := {
    EmptySet,
    NullSet,
    Set,
    Element,
    Membership,
    NonMembership,
    Subset,
    ProperSubset,
    PowerSet,
    UniversalSet,
    Union,
    Intersection,
    Difference,
    SymmetricDifference,
    Complement,
    CartesianProduct,
    Cardinality,
    FiniteSet,
    Singleton,
    Extensionality,
    SetTheory,
    ZermeloFraenkelSetTheory,
    ZFC,
    EmptyRelation,
    EmptyFunction
}

DEFINE ENTITY_TYPES := {
    EMPTY_SET,
    SET,
    ELEMENT,
    SET_RELATION,
    SET_OPERATION,
    CARDINAL_OBJECT,
    FORMAL_SYSTEM,
    SEMANTIC_OBJECT
}

DEFINE RELATION_TYPES := {
    MEMBER_OF,
    NOT_MEMBER_OF,
    SUBSET_OF,
    PROPER_SUBSET_OF,
    EQUAL_TO,
    HAS_CARDINALITY,
    UNION_WITH,
    INTERSECTS,
    DIFFERENCE_WITH,
    COMPLEMENT_OF,
    IS_INSTANCE_OF,
    IS_SUBTYPE_OF,
    DEPENDS_ON
}

SET EmptySet.type = EMPTY_SET
SET EmptySet.parent = Set
SET EmptySet.symbols = {"∅", "{}"}
SET EmptySet.aliases = {"empty set", "null set"}
SET EmptySet.context = SetTheory
SET EmptySet.role =
    "represent the unique set containing no elements"

RULE empty_set_definition:
    Set(E)
    ∧ NOT EXISTS x [
        x ∈ E
    ]
    -> EmptySet(E)

RULE empty_set_membership:
    EmptySet(E)
    -> FOR_ALL x [
        x ∉ E
    ]

RULE empty_set_uniqueness:
    EmptySet(A)
    ∧ EmptySet(B)
    -> A = B

RULE uniqueness_via_extensionality:
    Set(A)
    ∧ Set(B)
    ∧ FOR_ALL x [
        x ∉ A AND x ∉ B
    ]
    -> A = B = ∅

RULE empty_set_cardinality:
    EmptySet(E)
    -> Cardinality(E)=0
    ∧ HAS_CARDINALITY(E,0)

RULE empty_set_finite:
    EmptySet(E)
    -> FiniteSet(E)

RULE empty_set_subset:
    Set(A)
    -> SUBSET_OF(∅,A)

RULE proper_empty_subset:
    Set(A)
    ∧ A != ∅
    -> PROPER_SUBSET_OF(∅,A)

RULE empty_self_subset:
    SUBSET_OF(∅,∅)

RULE union_identity:
    Set(A)
    -> A ∪ ∅ = A
    ∧ ∅ ∪ A = A

RULE intersection_annihilator:
    Set(A)
    -> A ∩ ∅ = ∅
    ∧ ∅ ∩ A = ∅

RULE difference_empty_right:
    Set(A)
    -> A \ ∅ = A

RULE difference_empty_left:
    Set(A)
    -> ∅ \ A = ∅

RULE symmetric_difference_empty:
    Set(A)
    -> A △ ∅ = A

RULE cartesian_product_empty_left:
    Set(A)
    -> ∅ × A = ∅

RULE cartesian_product_empty_right:
    Set(A)
    -> A × ∅ = ∅

RULE power_set_empty:
    P(∅) = {∅}

RULE power_set_empty_cardinality:
    Cardinality(P(∅)) = 1

RULE empty_set_element_of_its_power_set:
    MEMBER_OF(∅,P(∅))

RULE complement_empty:
    UniversalSet(U)
    -> Complement_U(∅)=U

RULE complement_universe:
    UniversalSet(U)
    -> Complement_U(U)=∅

RULE disjoint_with_every_set:
    Set(A)
    -> A ∩ ∅ = ∅
    -> DISJOINT(A,∅)

RULE empty_relation:
    Set(A)
    ∧ Set(B)
    -> ∅ ⊆ A × B
    -> Relation(∅,A,B)

RULE empty_function:
    Set(B)
    -> Function(∅:∅->B)

DEFINE EMPTY_SET_MODEL := {
    canonical_symbol: "∅",
    alternative_notation: "{}",
    cardinality: 0,
    members: none,
    uniqueness: TRUE,
    finite: TRUE
}

DEFINE MEMBERSHIP_MODEL := {
    statement: "x ∈ ∅",
    truth_value: FALSE,
    equivalent_statement: "x ∉ ∅",
    truth_value_equivalent: TRUE
}

DEFINE SUBSET_MODEL := {
    statement: "∅ ⊆ A",
    truth_value: TRUE,
    reason:
        "there is no element of ∅ that can violate the subset condition"
}

DEFINE OPERATION_IDENTITIES := {
    "A ∪ ∅" : "A",
    "A ∩ ∅" : "∅",
    "A \ ∅" : "A",
    "∅ \ A" : "∅",
    "A △ ∅" : "A",
    "A × ∅" : "∅",
    "∅ × A" : "∅",
    "P(∅)" : "{∅}"
}

DEFINE CRITICAL_DISTINCTIONS := {
    EmptySet_vs_SetContainingEmptySet: {
        empty_set: "∅",
        singleton_containing_empty_set: "{∅}",
        cardinality_empty_set: 0,
        cardinality_singleton: 1,
        equality: FALSE
    },
    EmptySet_vs_NullValue: {
        mathematical_empty_set: "a defined set with zero elements",
        null_value: "a computational or semantic absence marker",
        equivalence: FALSE_BY_DEFAULT
    },
    EmptySet_vs_Zero: {
        empty_set: "∅",
        numeric_zero: "0",
        note:
            "in von Neumann ordinal construction 0 is represented by ∅, but this representation must not erase the conceptual distinction between number and set outside that construction"
    }
}

DEFINE AXIOMATIC_MODEL := {
    ZF_ZFC:
        "the empty set exists and is unique by extensionality once existence is established",
    common_form:
        "∃E ∀x (x ∉ E)"
}

DEFINE EXAMPLE_1 := {
    set: "A = {1,2,3}",
    union: "A ∪ ∅ = A",
    intersection: "A ∩ ∅ = ∅"
}

DEFINE EXAMPLE_2 := {
    empty_set: "∅",
    singleton: "{∅}",
    comparison: {
        "|∅| = 0",
        "|{∅}| = 1"
    }
}

DEFINE EXAMPLE_3 := {
    power_set: "P(∅) = {∅}",
    cardinality: 1
}

DEFINE EXAMPLE_4 := {
    A: "{a,b}",
    cartesian_products: {
        "A × ∅ = ∅",
        "∅ × A = ∅"
    }
}

DEFINE SEMANTIC_PIPELINE :=
    SetExpression
    -> DetectEmptySetNotation
    -> CanonicaliseToEmptySet
    -> AssertZeroMembership
    -> AssertCardinalityZero
    -> ApplyUniversalSubsetProperty
    -> ApplyOperationIdentities
    -> DistinguishFromSingletonContainingEmptySet
    -> PreserveFoundationalContext
    -> ReturnCanonicalEmptySetRepresentation

DEFINE REASONING_PIPELINE :=
    InputExpression
    -> IdentifyOccurrencesOf∅OrEmptyBraces
    -> ResolveSetContext
    -> ApplyUniqueness
    -> ApplySubsetVacuity
    -> SimplifyUnionIntersectionDifference
    -> SimplifyCartesianProducts
    -> ResolvePowerSet
    -> ValidateCardinality
    -> ReturnDerivedSetRelations

DEFINE ONTOLOGY_RELATIONS := {
    EmptySet IS_SUBTYPE_OF Set,
    EmptySet IS_COMPONENT_OF SetTheory,
    EmptySet HAS_CARDINALITY 0,
    EmptySet SUBSET_OF every_Set,
    EmptySet PROPER_SUBSET_OF every_nonempty_Set,
    EmptySet IS_IDENTITY_FOR Union,
    EmptySet IS_ANNIHILATOR_FOR Intersection,
    EmptySet IS_ANNIHILATOR_FOR CartesianProduct,
    PowerSetOfEmptySet EQUAL_TO SingletonContainingEmptySet,
    EmptySet DEPENDS_ON Extensionality FOR uniqueness
}

DEFINE SEMANTIC_EQUIVALENCE := {
    "empty set" <=> EmptySet,
    "null set" <=> EmptySet WHEN mathematical_set_context=TRUE,
    "∅" <=> EmptySet,
    "{}" <=> EmptySet WHEN set_notation_context=TRUE,
    "set with no elements" <=> EmptySet,
    "zero-element set" <=> EmptySet
}

DEFINE AI_CONSUMPTION := {
    purpose: "machine-readable representation of the unique set with no elements",
    canonicalise_empty_notation: TRUE,
    preserve_zero_cardinality: TRUE,
    prohibit_member_inference: TRUE,
    infer_subset_of_every_set: TRUE,
    apply_empty_set_operation_identities: TRUE,
    distinguish_empty_set_from_singleton_empty_set: TRUE,
    distinguish_empty_set_from_null_marker: TRUE,
    preserve_foundational_context: TRUE,
    reasoning_mode: "symbolic + extensional + identity-aware"
}

DEFINE CONFIDENCE := {
    ontology_identity: 1.00,
    empty_set_detection: 1.00,
    zero_membership: 1.00,
    subset_reasoning: 1.00,
    operation_simplification: 0.99,
    power_set_reasoning: 0.99,
    empty_singleton_distinction: 1.00,
    natural_language_empty_set_mapping: 0.99
}

DEFINE UPDATE_MODEL := {
    version: "1.0",
    update_policy: "append-compatible",
    immutable_core: {
        no_elements,
        uniqueness,
        cardinality_zero,
        subset_of_every_set,
        union_identity,
        intersection_annihilator,
        cartesian_product_annihilator,
        power_set_of_empty_set
    },
    extensible_layers: {
        von_Neumann_zero,
        ordinal_constructions,
        empty_relations,
        empty_functions,
        categorical_initial_objects,
        computational_empty_collections
    }
}

DEFINE FLOW_HASH_INPUT :=
    CanonicalURL
    + DOMAIN
    + ENTITY_TYPES
    + RELATION_TYPES
    + RULES
    + EMPTY_SET_MODEL
    + MEMBERSHIP_MODEL
    + SUBSET_MODEL
    + OPERATION_IDENTITIES
    + CRITICAL_DISTINCTIONS
    + AXIOMATIC_MODEL
    + SEMANTIC_PIPELINE
    + REASONING_PIPELINE
    + ONTOLOGY_RELATIONS
    + AI_CONSUMPTION
    + UPDATE_MODEL

FLOW_HASH := HASH(FLOW_HASH_INPUT)

RETURN {
    ontology: EmptySetOntology,
    canonical_url: "https://kirethresearch.org/booksai-core/ontologies/mathematical-ontologies/mathematical-logic-ontologies/set-theory/empty-set-ontology.html",
    parent_domain: SetTheory,
    semantic_domain: MathematicalLogic,
    primary_entity: EmptySet,
    canonical_symbol: "∅",
    cardinality: 0,
    unique: TRUE,
    machine_consumable: TRUE,
    recursive_reasoning_enabled: TRUE,
    flow_complete: TRUE
}

END_FLOW