Subset Ontology

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

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

FLOW_ALGEBRA SubsetOntology_v1.0

BEGIN_FLOW

DEFINE DOMAIN SubsetOntology := {
    Subset,
    Set,
    Element,
    Membership,
    ProperSubset,
    ImproperSubset,
    Superset,
    ProperSuperset,
    SetEquality,
    EmptySet,
    UniversalSet,
    PowerSet,
    Inclusion,
    SetContainment,
    Reflexivity,
    Antisymmetry,
    Transitivity,
    PartialOrder,
    Poset,
    InclusionMap,
    FamilyOfSets,
    Chain,
    Antichain,
    Intersection,
    Union,
    Difference,
    Cardinality
}

DEFINE ENTITY_TYPES := {
    SET,
    ELEMENT,
    SET_RELATION,
    ORDER_RELATION,
    SET_OPERATION,
    SET_FAMILY,
    ORDERED_STRUCTURE,
    SEMANTIC_OBJECT
}

DEFINE RELATION_TYPES := {
    MEMBER_OF,
    SUBSET_OF,
    PROPER_SUBSET_OF,
    SUPERSET_OF,
    PROPER_SUPERSET_OF,
    EQUAL_TO,
    CONTAINS,
    INCLUDED_IN,
    COMPARABLE_WITH,
    INCOMPARABLE_WITH,
    IS_INSTANCE_OF,
    IS_SUBTYPE_OF,
    DEPENDS_ON
}

SET Subset.type = SET_RELATION
SET Subset.symbol = "⊆"
SET Subset.context = SetTheory
SET Subset.role =
    "express that every element of one set is also an element of another set"

RULE subset_definition:
    Set(A)
    ∧ Set(B)
    ∧ FOR_ALL x [
        x ∈ A -> x ∈ B
    ]
    -> SUBSET_OF(A,B)

RULE subset_expansion:
    SUBSET_OF(A,B)
    -> FOR_ALL x [
        MEMBER_OF(x,A) -> MEMBER_OF(x,B)
    ]

RULE reflexivity:
    Set(A)
    -> SUBSET_OF(A,A)

RULE transitivity:
    SUBSET_OF(A,B)
    ∧ SUBSET_OF(B,C)
    -> SUBSET_OF(A,C)

RULE antisymmetry:
    SUBSET_OF(A,B)
    ∧ SUBSET_OF(B,A)
    -> EQUAL_TO(A,B)

RULE equality_characterisation:
    Set(A)
    ∧ Set(B)
    -> EQUAL_TO(A,B)
       IFF
       SUBSET_OF(A,B) ∧ SUBSET_OF(B,A)

RULE proper_subset:
    SUBSET_OF(A,B)
    ∧ A != B
    -> PROPER_SUBSET_OF(A,B)

RULE improper_subset:
    Set(A)
    -> ImproperSubset(A,A)

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

RULE universal_containment:
    UniversalSet(U)
    ∧ Set(A)
    ∧ A within_context U
    -> SUBSET_OF(A,U)

RULE subset_superset_inverse:
    SUBSET_OF(A,B)
    -> SUPERSET_OF(B,A)

RULE proper_inverse:
    PROPER_SUBSET_OF(A,B)
    -> PROPER_SUPERSET_OF(B,A)

RULE power_set_membership:
    Set(A)
    ∧ Set(X)
    -> MEMBER_OF(X,P(A))
       IFF
       SUBSET_OF(X,A)

RULE subset_cardinality_finite:
    FiniteSet(A)
    ∧ FiniteSet(B)
    ∧ SUBSET_OF(A,B)
    -> |A| <= |B|

RULE proper_subset_cardinality_finite:
    FiniteSet(A)
    ∧ FiniteSet(B)
    ∧ PROPER_SUBSET_OF(A,B)
    -> |A| < |B|

RULE intersection_subset:
    Set(A)
    ∧ Set(B)
    -> SUBSET_OF(A ∩ B,A)
    ∧ SUBSET_OF(A ∩ B,B)

RULE union_superset:
    Set(A)
    ∧ Set(B)
    -> SUBSET_OF(A,A ∪ B)
    ∧ SUBSET_OF(B,A ∪ B)

RULE difference_subset:
    Set(A)
    ∧ Set(B)
    -> SUBSET_OF(A \ B,A)

RULE subset_preserves_intersection:
    SUBSET_OF(A,B)
    -> A ∩ B = A

RULE subset_preserves_union:
    SUBSET_OF(A,B)
    -> A ∪ B = B

RULE subset_difference_empty:
    SUBSET_OF(A,B)
    -> A \ B = ∅

RULE inclusion_partial_order:
    FamilyOfSets(F)
    ∧ relation = SUBSET_OF
    ∧ Reflexive(relation)
    ∧ Antisymmetric(relation)
    ∧ Transitive(relation)
    -> PartialOrder(F,SUBSET_OF)

RULE comparability:
    Set(A)
    ∧ Set(B)
    ∧ (SUBSET_OF(A,B) OR SUBSET_OF(B,A))
    -> COMPARABLE_WITH(A,B)

RULE incomparability:
    Set(A)
    ∧ Set(B)
    ∧ NOT SUBSET_OF(A,B)
    ∧ NOT SUBSET_OF(B,A)
    -> INCOMPARABLE_WITH(A,B)

DEFINE SUBSET_MODEL := {
    notation: "A ⊆ B",
    definition:
        "every element of A is an element of B",
    logical_form:
        "∀x(x ∈ A → x ∈ B)",
    inverse:
        "B ⊇ A"
}

DEFINE PROPER_SUBSET_MODEL := {
    notation: "A ⊂ B",
    definition:
        "A is a subset of B and A is not equal to B",
    logical_form:
        "(A ⊆ B) ∧ (A ≠ B)",
    note:
        "notation conventions for ⊂ vary between texts; explicit semantic definition should be retained"
}

DEFINE MEMBERSHIP_SUBSET_DISTINCTION := {
    membership: "x ∈ A",
    subset: "A ⊆ B",
    membership_relation:
        "object-to-set",
    subset_relation:
        "set-to-set",
    critical_constraint:
        "do not infer membership from subset notation or subset from membership notation without additional premises"
}

DEFINE ORDER_PROPERTIES := {
    reflexive: "A ⊆ A",
    antisymmetric: "(A ⊆ B ∧ B ⊆ A) -> A = B",
    transitive: "(A ⊆ B ∧ B ⊆ C) -> A ⊆ C",
    classification: PartialOrder
}

DEFINE EXAMPLE_1 := {
    A: "{1,2}",
    B: "{1,2,3}",
    relation: "A ⊆ B",
    proper_relation: "A ⊂ B"
}

DEFINE EXAMPLE_2 := {
    A: "{a,b}",
    relation: "A ⊆ A",
    property: Reflexivity
}

DEFINE EXAMPLE_3 := {
    A: "∅",
    B: "{1,2,3}",
    relation: "∅ ⊆ B",
    truth: TRUE
}

DEFINE EXAMPLE_4 := {
    A: "{1}",
    B: "{1,2}",
    C: "{1,2,3}",
    premises: {
        "A ⊆ B",
        "B ⊆ C"
    },
    conclusion: "A ⊆ C",
    property: Transitivity
}

DEFINE EXAMPLE_5 := {
    A: "{1,2}",
    power_set_of_A: {
        "∅",
        "{1}",
        "{2}",
        "{1,2}"
    },
    equivalence:
        "X ∈ P(A) iff X ⊆ A"
}

DEFINE SEMANTIC_PIPELINE :=
    SetPair(A,B)
    -> ResolveSetIdentity
    -> EnumerateOrCharacteriseElementsOfA
    -> TestMembershipInBForEachElementOfA
    -> IF all_members_transfer
       THEN SUBSET_OF(A,B)
       ELSE NOT_SUBSET_OF(A,B)
    -> TestEquality
    -> ClassifyProperOrImproperSubset
    -> DeriveInverseSupersetRelation

DEFINE REASONING_PIPELINE :=
    InputSetRelations
    -> ParseSets
    -> ParseMembershipFacts
    -> BuildSubsetGraph
    -> ApplyReflexivity
    -> ApplyTransitivity
    -> ApplyAntisymmetry
    -> ResolveProperSubsetRelations
    -> ConnectSubsetsToPowerSetMembership
    -> ApplySetOperationConsequences
    -> ReturnDerivedInclusionRelations

DEFINE SUBSET_GRAPH_MODEL := {
    nodes: Sets,
    directed_edge: "A --SUBSET_OF--> B",
    reflexive: TRUE,
    transitive: TRUE,
    antisymmetric: TRUE,
    cycle_condition:
        "A ⊆ B and B ⊆ A collapse to set equality"
}

DEFINE ONTOLOGY_RELATIONS := {
    Subset IS_COMPONENT_OF SetTheory,
    Subset RELATES Set TO Set,
    ProperSubset IS_SUBTYPE_OF Subset,
    Superset IS_INVERSE_OF Subset,
    ProperSuperset IS_INVERSE_OF ProperSubset,
    SetEquality DEPENDS_ON MutualSubset,
    EmptySet SUBSET_OF every_Set,
    Set SUBSET_OF UniversalSet WHEN context_defined=TRUE,
    PowerSet CONTAINS every_Subset,
    Inclusion IS_PARTIAL_ORDER_ON FamilyOfSets,
    Subset DEPENDS_ON ElementMembership
}

DEFINE SEMANTIC_EQUIVALENCE := {
    "subset" <=> Subset,
    "is a subset of" <=> SUBSET_OF,
    "included in" <=> SUBSET_OF WHEN set_context=TRUE,
    "set inclusion" <=> Subset,
    "proper subset" <=> ProperSubset,
    "superset" <=> Superset,
    "⊆" <=> SUBSET_OF,
    "⊇" <=> SUPERSET_OF
}

DEFINE AI_CONSUMPTION := {
    purpose: "machine-readable representation and reasoning for subset relations in set theory",
    preserve_set_identity: TRUE,
    distinguish_membership_from_subset: TRUE,
    preserve_subset_direction: TRUE,
    apply_reflexivity: TRUE,
    apply_transitivity: TRUE,
    apply_antisymmetry: TRUE,
    detect_proper_subsets: TRUE,
    derive_inverse_superset_relations: TRUE,
    connect_subset_to_power_set_membership: TRUE,
    support_subset_graph_reasoning: TRUE,
    reasoning_mode: "symbolic + extensional + order-theoretic"
}

DEFINE CONFIDENCE := {
    ontology_identity: 1.00,
    formal_subset_detection: 0.99,
    membership_subset_distinction: 0.99,
    reflexive_reasoning: 1.00,
    transitive_reasoning: 0.99,
    antisymmetric_reasoning: 0.99,
    proper_subset_detection: 0.99,
    natural_language_inclusion_mapping: context_dependent
}

DEFINE UPDATE_MODEL := {
    version: "1.0",
    update_policy: "append-compatible",
    immutable_core: {
        subset_definition,
        membership_transfer,
        reflexivity,
        transitivity,
        antisymmetry,
        proper_subset_distinction,
        membership_subset_distinction,
        power_set_equivalence
    },
    extensible_layers: {
        subset_lattices,
        Boolean_algebras,
        chains_and_antichains,
        transfinite_subset_structures,
        computational_subset_reasoning,
        fuzzy_subset_relations
    }
}

DEFINE FLOW_HASH_INPUT :=
    CanonicalURL
    + DOMAIN
    + ENTITY_TYPES
    + RELATION_TYPES
    + RULES
    + SUBSET_MODEL
    + PROPER_SUBSET_MODEL
    + MEMBERSHIP_SUBSET_DISTINCTION
    + ORDER_PROPERTIES
    + SEMANTIC_PIPELINE
    + REASONING_PIPELINE
    + SUBSET_GRAPH_MODEL
    + ONTOLOGY_RELATIONS
    + AI_CONSUMPTION
    + UPDATE_MODEL

FLOW_HASH := HASH(FLOW_HASH_INPUT)

RETURN {
    ontology: SubsetOntology,
    canonical_url: "https://kirethresearch.org/booksai-core/ontologies/mathematical-ontologies/mathematical-logic-ontologies/set-theory/subset-ontology.html",
    parent_domain: SetTheory,
    semantic_domain: MathematicalLogic,
    primary_entity: Subset,
    primary_relation: SUBSET_OF,
    membership_sensitive: TRUE,
    partial_order_reasoning_enabled: TRUE,
    machine_consumable: TRUE,
    recursive_reasoning_enabled: TRUE,
    flow_complete: TRUE
}

END_FLOW