Union Ontology

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

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

FLOW_ALGEBRA UnionOntology_v1.0

BEGIN_FLOW

DEFINE DOMAIN UnionOntology := {
    Union,
    Set,
    Element,
    Membership,
    SetTheory,
    BinaryUnion,
    GeneralUnion,
    IndexedUnion,
    FamilyOfSets,
    IndexedFamily,
    EmptySet,
    UniversalSet,
    Subset,
    Superset,
    Intersection,
    Difference,
    SymmetricDifference,
    Complement,
    Cardinality,
    FiniteSet,
    DisjointSet,
    Associativity,
    Commutativity,
    Idempotence,
    IdentityElement,
    Absorption,
    Distributivity
}

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,
    UNION_WITH,
    UNION_OF,
    INDEXED_BY,
    DISJOINT_WITH,
    EQUAL_TO,
    HAS_CARDINALITY,
    IS_INSTANCE_OF,
    IS_SUBTYPE_OF,
    DEPENDS_ON
}

SET Union.type = SET_OPERATION
SET Union.symbol = "∪"
SET Union.context = SetTheory
SET Union.role =
    "construct a set containing exactly those elements that belong to at least one of the input sets"

RULE binary_union:
    Set(A)
    ∧ Set(B)
    -> Union(A,B) = A ∪ B
    = {x | x ∈ A OR x ∈ B}

RULE binary_union_membership:
    Set(A)
    ∧ Set(B)
    -> x ∈ A ∪ B
       IFF
       (x ∈ A OR x ∈ B)

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

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

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

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_identity:
    Set(A)
    -> A ∪ ∅ = A
    ∧ ∅ ∪ A = A

RULE universal_absorption:
    UniversalSet(U)
    ∧ SUBSET_OF(A,U)
    -> A ∪ U = U

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

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

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

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

RULE union_complement:
    UniversalSet(U)
    ∧ SUBSET_OF(A,U)
    -> A ∪ Complement_U(A) = U

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

RULE general_union:
    FamilyOfSets(F)
    -> UNION(F)
       = {x | EXISTS A ∈ F [x ∈ A]}

RULE general_union_membership:
    FamilyOfSets(F)
    -> x ∈ UNION(F)
       IFF
       EXISTS A ∈ F [
           x ∈ A
       ]

RULE indexed_union:
    IndexedFamily({A_i | i ∈ I})
    -> UNION_i∈I A_i
       = {x | EXISTS i ∈ I [x ∈ A_i]}

RULE union_empty_family:
    FamilyOfSets(F)
    ∧ F = ∅
    -> UNION(F) = ∅

RULE union_singleton_family:
    Set(A)
    -> UNION({A})=A

RULE union_power_set:
    Set(A)
    -> UNION(P(A))=A

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

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

DEFINE BINARY_UNION_MODEL := {
    notation: "A ∪ B",
    membership_condition:
        "x ∈ A ∪ B iff x ∈ A or x ∈ B",
    output_type: Set,
    duplicate_handling:
        "an element belonging to both input sets occurs only once as a member of the resulting set"
}

DEFINE GENERAL_UNION_MODEL := {
    notation: "⋃F",
    input: FamilyOfSets,
    membership_condition:
        "x ∈ ⋃F iff x belongs to at least one member set of F",
    output_type: Set
}

DEFINE INDEXED_UNION_MODEL := {
    notation: "⋃_{i∈I} A_i",
    index_set: I,
    family: "{A_i | i ∈ I}",
    membership_condition:
        "x belongs to the indexed union iff there exists i ∈ I such that x ∈ A_i"
}

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

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

DEFINE EXAMPLE_2 := {
    A: "{a,b}",
    B: "{b,c}",
    observation:
        "b belongs to both A and B but remains a single member of A ∪ B"
}

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

DEFINE EXAMPLE_4 := {
    A: "{1,2}",
    B: "{3,4}",
    disjoint: TRUE,
    cardinality_relation:
        "|A ∪ B| = |A| + |B| = 4"
}

DEFINE SEMANTIC_PIPELINE :=
    UnionExpression
    -> IdentifyInputSets
    -> ResolveMembershipOfEachInput
    -> CollectElementsPresentInAtLeastOneInput
    -> CollapseDuplicateMembership
    -> ConstructResultSet
    -> InferInputSubsetRelations
    -> ApplyAlgebraicSimplifications
    -> ComputeCardinalityWhenApplicable
    -> ReturnCanonicalUnion

DEFINE REASONING_PIPELINE :=
    InputSetExpression
    -> DetectUnionOperator
    -> ParseBinaryGeneralOrIndexedUnion
    -> ResolveSetOperands
    -> ApplyMembershipDisjunction
    -> ApplyIdentityIdempotenceCommutativityAssociativity
    -> ApplySubsetSimplifications
    -> ApplyDistributiveOrDeMorganRulesWhenRelevant
    -> EvaluateResult
    -> ReturnDerivedRelations

DEFINE UNION_GRAPH_MODEL := {
    input_nodes: Sets,
    operation_node: Union,
    output_node: Set,
    membership_rule:
        "incoming membership from any operand creates membership in the output",
    duplicate_edges:
        "multiple membership paths to the same element collapse to one extensional membership fact"
}

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

DEFINE SEMANTIC_EQUIVALENCE := {
    "union" <=> Union,
    "set union" <=> Union,
    "A or B" <=> "A ∪ B" WHEN element_membership_context=TRUE,
    "combined set" <=> Union WHEN mathematical_set_context=TRUE,
    "∪" <=> Union,
    "big union" <=> GeneralUnion WHEN family_of_sets_context=TRUE,
    "indexed union" <=> IndexedUnion
}

DEFINE AI_CONSUMPTION := {
    purpose: "machine-readable representation and evaluation of set union",
    preserve_operand_identity: TRUE,
    preserve_element_identity: TRUE,
    use_membership_disjunction: TRUE,
    collapse_duplicate_membership: TRUE,
    infer_operand_subsets_of_result: TRUE,
    apply_union_algebraic_laws: TRUE,
    support_binary_union: TRUE,
    support_general_union: TRUE,
    support_indexed_union: TRUE,
    support_cardinality_reasoning: TRUE,
    reasoning_mode: "symbolic + extensional + algebraic"
}

DEFINE CONFIDENCE := {
    ontology_identity: 1.00,
    formal_union_detection: 1.00,
    binary_union_evaluation: 0.99,
    general_union_evaluation: 0.99,
    algebraic_simplification: 0.99,
    subset_inference: 0.99,
    finite_cardinality_reasoning: 0.99,
    natural_language_union_mapping: context_dependent
}

DEFINE UPDATE_MODEL := {
    version: "1.0",
    update_policy: "append-compatible",
    immutable_core: {
        membership_disjunction,
        extensional_result,
        commutativity,
        associativity,
        idempotence,
        empty_identity,
        input_subset_property
    },
    extensible_layers: {
        infinite_unions,
        indexed_unions,
        Boolean_algebra_union,
        topology_open_set_unions,
        measure_theoretic_unions,
        computational_set_union
    }
}

DEFINE FLOW_HASH_INPUT :=
    CanonicalURL
    + DOMAIN
    + ENTITY_TYPES
    + RELATION_TYPES
    + RULES
    + BINARY_UNION_MODEL
    + GENERAL_UNION_MODEL
    + INDEXED_UNION_MODEL
    + ALGEBRAIC_PROPERTIES
    + SEMANTIC_PIPELINE
    + REASONING_PIPELINE
    + UNION_GRAPH_MODEL
    + ONTOLOGY_RELATIONS
    + AI_CONSUMPTION
    + UPDATE_MODEL

FLOW_HASH := HASH(FLOW_HASH_INPUT)

RETURN {
    ontology: UnionOntology,
    canonical_url: "https://kirethresearch.org/booksai-core/ontologies/mathematical-ontologies/mathematical-logic-ontologies/set-theory/union-ontology.html",
    parent_domain: SetTheory,
    semantic_domain: MathematicalLogic,
    primary_entity: Union,
    canonical_symbol: "∪",
    extensional_reasoning_enabled: TRUE,
    algebraic_reasoning_enabled: TRUE,
    machine_consumable: TRUE,
    recursive_reasoning_enabled: TRUE,
    flow_complete: TRUE
}

END_FLOW