Intersection Ontology

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

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

FLOW_ALGEBRA IntersectionOntology_v1.0

BEGIN_FLOW

DEFINE DOMAIN IntersectionOntology := {
    Intersection,
    Set,
    Element,
    Membership,
    SetTheory,
    BinaryIntersection,
    GeneralIntersection,
    IndexedIntersection,
    FamilyOfSets,
    IndexedFamily,
    EmptySet,
    UniversalSet,
    Subset,
    Superset,
    Union,
    Difference,
    SymmetricDifference,
    Complement,
    DisjointSet,
    Cardinality,
    FiniteSet,
    Associativity,
    Commutativity,
    Idempotence,
    IdentityElement,
    Absorption,
    Distributivity,
    DeMorganLaw
}

DEFINE ENTITY_TYPES := {
    SET_OPERATION,
    SET,
    ELEMENT,
    SET_RELATION,
    SET_FAMILY,
    ALGEBRAIC_PROPERTY,
    CARDINAL_OBJECT,
    SEMANTIC_OBJECT
}

DEFINE RELATION_TYPES := {
    MEMBER_OF,
    CONTAINS,
    SUBSET_OF,
    SUPERSET_OF,
    INTERSECTS,
    INTERSECTION_OF,
    INDEXED_BY,
    DISJOINT_WITH,
    EQUAL_TO,
    HAS_CARDINALITY,
    IS_INSTANCE_OF,
    IS_SUBTYPE_OF,
    DEPENDS_ON
}

SET Intersection.type = SET_OPERATION
SET Intersection.symbol = "∩"
SET Intersection.context = SetTheory
SET Intersection.role =
    "construct a set containing exactly those elements that belong to every relevant input set"

RULE binary_intersection:
    Set(A)
    ∧ Set(B)
    -> Intersection(A,B) = A ∩ B
    = {x | x ∈ A AND x ∈ B}

RULE binary_intersection_membership:
    Set(A)
    ∧ Set(B)
    -> x ∈ A ∩ B
       IFF
       (x ∈ A AND x ∈ B)

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

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

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

RULE commutativity:
    Set(A)
    ∧ Set(B)
    -> A ∩ B = B ∩ A

RULE associativity:
    Set(A)
    ∧ Set(B)
    ∧ Set(C)
    -> (A ∩ B) ∩ C
       = A ∩ (B ∩ C)

RULE idempotence:
    Set(A)
    -> A ∩ A = A

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

RULE universal_identity:
    UniversalSet(U)
    ∧ SUBSET_OF(A,U)
    -> A ∩ U = A
    ∧ U ∩ A = A

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

RULE union_intersection_absorption:
    Set(A)
    ∧ Set(B)
    -> A ∩ (A ∪ B) = A

RULE distributive_over_union:
    Set(A)
    ∧ Set(B)
    ∧ Set(C)
    -> A ∩ (B ∪ C)
       = (A ∩ B) ∪ (A ∩ C)

RULE union_distributive_over_intersection:
    Set(A)
    ∧ Set(B)
    ∧ Set(C)
    -> A ∪ (B ∩ C)
       = (A ∪ B) ∩ (A ∪ C)

RULE disjointness:
    Set(A)
    ∧ Set(B)
    ∧ A ∩ B = ∅
    -> DISJOINT_WITH(A,B)

RULE nonempty_intersection:
    Set(A)
    ∧ Set(B)
    ∧ EXISTS x [
        x ∈ A AND x ∈ B
    ]
    -> A ∩ B != ∅

RULE intersection_complement:
    UniversalSet(U)
    ∧ SUBSET_OF(A,U)
    -> A ∩ Complement_U(A) = ∅

RULE DeMorgan_intersection:
    UniversalSet(U)
    ∧ SUBSET_OF(A,U)
    ∧ SUBSET_OF(B,U)
    -> Complement_U(A ∩ B)
       = Complement_U(A) ∪ Complement_U(B)

RULE general_intersection:
    FamilyOfSets(F)
    ∧ F != ∅
    -> INTERSECTION(F)
       = {x | FOR_ALL A ∈ F [x ∈ A]}

RULE general_intersection_membership:
    FamilyOfSets(F)
    ∧ F != ∅
    -> x ∈ INTERSECTION(F)
       IFF
       FOR_ALL A ∈ F [
           x ∈ A
       ]

RULE indexed_intersection:
    IndexedFamily({A_i | i ∈ I})
    ∧ I != ∅
    -> INTERSECTION_i∈I A_i
       = {x | FOR_ALL i ∈ I [x ∈ A_i]}

RULE intersection_singleton_family:
    Set(A)
    -> INTERSECTION({A})=A

RULE empty_index_intersection_context:
    IndexedFamily({A_i | i ∈ I})
    ∧ I = ∅
    -> result REQUIRES ambient_universe_or_type_context

RULE finite_intersection_cardinality:
    FiniteSet(A)
    ∧ FiniteSet(B)
    -> |A ∩ B|
       = |A| + |B| - |A ∪ B|

DEFINE BINARY_INTERSECTION_MODEL := {
    notation: "A ∩ B",
    membership_condition:
        "x ∈ A ∩ B iff x ∈ A and x ∈ B",
    output_type: Set,
    semantic_operator: conjunction
}

DEFINE GENERAL_INTERSECTION_MODEL := {
    notation: "⋂F",
    input: FamilyOfSets,
    ordinary_condition: "F is nonempty unless an ambient universe convention is explicitly supplied",
    membership_condition:
        "x ∈ ⋂F iff x belongs to every member set of F"
}

DEFINE INDEXED_INTERSECTION_MODEL := {
    notation: "⋂_{i∈I} A_i",
    index_set: I,
    family: "{A_i | i ∈ I}",
    membership_condition:
        "x belongs to the indexed intersection iff for every i ∈ I, x ∈ A_i"
}

DEFINE ALGEBRAIC_PROPERTIES := {
    commutative: "A ∩ B = B ∩ A",
    associative: "(A ∩ B) ∩ C = A ∩ (B ∩ C)",
    idempotent: "A ∩ A = A",
    empty_annihilator: "A ∩ ∅ = ∅",
    universal_identity: "A ∩ U = A",
    absorption: "A ∩ (A ∪ B) = A"
}

DEFINE EXAMPLE_1 := {
    A: "{1,2,3}",
    B: "{2,3,4}",
    intersection: "{2,3}"
}

DEFINE EXAMPLE_2 := {
    A: "{a,b}",
    B: "{c,d}",
    intersection: "∅",
    relation: DisjointSet
}

DEFINE EXAMPLE_3 := {
    family: "{{1,2,3}, {2,3,4}, {2,5,3}}",
    general_intersection: "{2,3}"
}

DEFINE EXAMPLE_4 := {
    universe: "U = {1,2,3,4}",
    A: "{1,2}",
    complement_A: "{3,4}",
    intersection: "A ∩ Aᶜ = ∅"
}

DEFINE SEMANTIC_PIPELINE :=
    IntersectionExpression
    -> IdentifyInputSets
    -> ResolveMembershipOfEachInput
    -> RetainElementsPresentInEveryInput
    -> ConstructResultSet
    -> InferResultSubsetOfEachOperand
    -> DetectDisjointnessIfResultEmpty
    -> ApplyAlgebraicSimplifications
    -> ComputeCardinalityWhenApplicable
    -> ReturnCanonicalIntersection

DEFINE REASONING_PIPELINE :=
    InputSetExpression
    -> DetectIntersectionOperator
    -> ParseBinaryGeneralOrIndexedIntersection
    -> ResolveSetOperands
    -> ApplyMembershipConjunction
    -> ApplyIdentityIdempotenceCommutativityAssociativity
    -> ApplySubsetSimplifications
    -> ApplyDistributiveOrDeMorganRulesWhenRelevant
    -> DetectEmptyIntersection
    -> ReturnDerivedRelations

DEFINE INTERSECTION_GRAPH_MODEL := {
    input_nodes: Sets,
    operation_node: Intersection,
    output_node: Set,
    membership_rule:
        "an element receives membership in the output only when membership is established in every operand",
    subset_edges:
        "output --SUBSET_OF--> each operand"
}

DEFINE ONTOLOGY_RELATIONS := {
    Intersection IS_COMPONENT_OF SetTheory,
    Intersection IS_SUBTYPE_OF SetOperation,
    Intersection OPERATES_ON Set,
    Intersection RETURNS Set,
    IntersectionResult SUBSET_OF each_InputSet,
    EmptySet IS_ABSORBING_ELEMENT_FOR Intersection,
    UniversalSet IS_IDENTITY_FOR Intersection WHEN context_defined=TRUE,
    Intersection DEPENDS_ON Membership,
    Intersection INTERACTS_WITH Union THROUGH Distributivity,
    Intersection INTERACTS_WITH Complement THROUGH DeMorganLaw,
    Disjointness DEPENDS_ON EmptyIntersection
}

DEFINE SEMANTIC_EQUIVALENCE := {
    "intersection" <=> Intersection,
    "set intersection" <=> Intersection,
    "common elements" <=> Intersection WHEN set_context=TRUE,
    "A and B" <=> "A ∩ B" WHEN element_membership_context=TRUE,
    "∩" <=> Intersection,
    "big intersection" <=> GeneralIntersection WHEN family_of_sets_context=TRUE,
    "indexed intersection" <=> IndexedIntersection
}

DEFINE AI_CONSUMPTION := {
    purpose: "machine-readable representation and evaluation of set intersection",
    preserve_operand_identity: TRUE,
    preserve_element_identity: TRUE,
    use_membership_conjunction: TRUE,
    infer_result_subset_relations: TRUE,
    detect_disjointness: TRUE,
    apply_intersection_algebraic_laws: TRUE,
    support_binary_intersection: TRUE,
    support_general_intersection: TRUE,
    support_indexed_intersection: TRUE,
    require_context_for_empty_index_intersection: TRUE,
    support_cardinality_reasoning: TRUE,
    reasoning_mode: "symbolic + extensional + algebraic"
}

DEFINE CONFIDENCE := {
    ontology_identity: 1.00,
    formal_intersection_detection: 1.00,
    binary_intersection_evaluation: 0.99,
    general_intersection_evaluation: 0.99,
    algebraic_simplification: 0.99,
    subset_inference: 0.99,
    disjointness_detection: 0.99,
    finite_cardinality_reasoning: 0.99,
    natural_language_intersection_mapping: context_dependent
}

DEFINE UPDATE_MODEL := {
    version: "1.0",
    update_policy: "append-compatible",
    immutable_core: {
        membership_conjunction,
        extensional_result,
        commutativity,
        associativity,
        idempotence,
        empty_annihilator,
        result_subset_property
    },
    extensible_layers: {
        infinite_intersections,
        indexed_intersections,
        Boolean_algebra_intersection,
        topology_closed_set_intersections,
        measure_theoretic_intersections,
        computational_set_intersection
    }
}

DEFINE FLOW_HASH_INPUT :=
    CanonicalURL
    + DOMAIN
    + ENTITY_TYPES
    + RELATION_TYPES
    + RULES
    + BINARY_INTERSECTION_MODEL
    + GENERAL_INTERSECTION_MODEL
    + INDEXED_INTERSECTION_MODEL
    + ALGEBRAIC_PROPERTIES
    + SEMANTIC_PIPELINE
    + REASONING_PIPELINE
    + INTERSECTION_GRAPH_MODEL
    + ONTOLOGY_RELATIONS
    + AI_CONSUMPTION
    + UPDATE_MODEL

FLOW_HASH := HASH(FLOW_HASH_INPUT)

RETURN {
    ontology: IntersectionOntology,
    canonical_url: "https://kirethresearch.org/booksai-core/ontologies/mathematical-ontologies/mathematical-logic-ontologies/set-theory/intersection-ontology.html",
    parent_domain: SetTheory,
    semantic_domain: MathematicalLogic,
    primary_entity: Intersection,
    canonical_symbol: "∩",
    extensional_reasoning_enabled: TRUE,
    algebraic_reasoning_enabled: TRUE,
    disjointness_detection_enabled: TRUE,
    machine_consumable: TRUE,
    recursive_reasoning_enabled: TRUE,
    flow_complete: TRUE
}

END_FLOW