Power Set Ontology

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

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

FLOW_ALGEBRA PowerSetOntology_v1.0

BEGIN_FLOW

DEFINE DOMAIN PowerSetOntology := {
    PowerSet,
    Set,
    Subset,
    ProperSubset,
    Element,
    Membership,
    EmptySet,
    Singleton,
    FiniteSet,
    InfiniteSet,
    SetTheory,
    Cardinality,
    CantorTheorem,
    Inclusion,
    BooleanLattice,
    PartialOrder,
    Union,
    Intersection,
    Complement,
    UniversalSet,
    FamilyOfSets,
    CharacteristicFunction,
    BinarySequence,
    SetOfSubsets
}

DEFINE ENTITY_TYPES := {
    POWER_SET,
    SET,
    SUBSET,
    ELEMENT,
    SET_RELATION,
    SET_OPERATION,
    CARDINAL_OBJECT,
    ORDERED_STRUCTURE,
    SEMANTIC_OBJECT
}

DEFINE RELATION_TYPES := {
    MEMBER_OF,
    CONTAINS,
    SUBSET_OF,
    PROPER_SUBSET_OF,
    HAS_POWER_SET,
    HAS_CARDINALITY,
    EQUINUMEROUS_WITH,
    ORDERED_BY,
    COMPLEMENT_OF,
    IS_INSTANCE_OF,
    IS_SUBTYPE_OF,
    DEPENDS_ON
}

SET PowerSet.type = POWER_SET
SET PowerSet.symbols = {"P(A)", "𝒫(A)", "2^A"}
SET PowerSet.context = SetTheory
SET PowerSet.role =
    "construct the set whose elements are exactly all subsets of a given set"

RULE power_set_definition:
    Set(A)
    -> PowerSet(A)
       = P(A)
       = {X | X ⊆ A}

RULE power_set_membership:
    Set(A)
    ∧ Set(X)
    -> X ∈ P(A)
       IFF
       X ⊆ A

RULE empty_set_in_power_set:
    Set(A)
    -> MEMBER_OF(∅,P(A))

RULE set_in_own_power_set:
    Set(A)
    -> MEMBER_OF(A,P(A))

RULE power_set_nonempty:
    Set(A)
    -> P(A) != ∅

RULE power_set_of_empty_set:
    P(∅) = {∅}

RULE power_set_of_singleton:
    Object(a)
    -> P({a})
       = {∅,{a}}

RULE finite_power_set_cardinality:
    FiniteSet(A)
    ∧ |A|=n
    -> |P(A)|=2^n

RULE power_set_strictly_larger:
    Set(A)
    -> NOT EXISTS bijection f:A->P(A)

RULE Cantor_theorem:
    Set(A)
    -> |A| < |P(A)|

RULE monotonicity:
    SUBSET_OF(A,B)
    -> SUBSET_OF(P(A),P(B))

RULE equality_preservation:
    A=B
    -> P(A)=P(B)

RULE subset_family:
    Set(A)
    -> FOR_ALL X ∈ P(A) [
        SUBSET_OF(X,A)
    ]

RULE binary_choice_representation:
    FiniteSet(A)
    ∧ |A|=n
    -> each X ∈ P(A)
       corresponds_to
       one binary inclusion_vector in {0,1}^n

RULE characteristic_function_correspondence:
    Set(A)
    -> each subset X ⊆ A
       corresponds_to
       CharacteristicFunction(χ_X:A->(0, 1))

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

RULE power_set_intersection_context:
    Set(A)
    ∧ A != ∅
    -> INTERSECTION(P(A)) = ∅

RULE Boolean_lattice:
    Set(A)
    -> Structure(
        P(A),
        SUBSET_OF,
        Union,
        Intersection,
        ComplementRelativeTo(A),
        ∅,
        A
    )
    forms BooleanLattice

RULE inclusion_partial_order:
    Set(A)
    -> PartialOrder(P(A),SUBSET_OF)

RULE lattice_bottom:
    Set(A)
    -> bottom(P(A),SUBSET_OF)=∅

RULE lattice_top:
    Set(A)
    -> top(P(A),SUBSET_OF)=A

RULE complement_closure:
    Set(A)
    ∧ X ∈ P(A)
    -> A \ X ∈ P(A)

RULE union_closure:
    Set(A)
    ∧ X ∈ P(A)
    ∧ Y ∈ P(A)
    -> X ∪ Y ∈ P(A)

RULE intersection_closure:
    Set(A)
    ∧ X ∈ P(A)
    ∧ Y ∈ P(A)
    -> X ∩ Y ∈ P(A)

DEFINE POWER_SET_MODEL := {
    input: Set(A),
    output: SetOfSubsets,
    canonical_notation: "P(A)",
    alternative_notation: "𝒫(A)",
    membership_condition:
        "X ∈ P(A) iff X ⊆ A"
}

DEFINE CARDINALITY_MODEL := {
    finite_case:
        "|P(A)| = 2^|A|",
    general_case:
        "|P(A)| > |A|",
    theorem:
        CantorTheorem
}

DEFINE SUBSET_SELECTION_MODEL := {
    each_element_of_A:
        "has two inclusion states for construction of a subset: included or excluded",
    finite_n_element_set:
        "2^n distinct inclusion patterns produce 2^n subsets"
}

DEFINE CRITICAL_DISTINCTIONS := {
    element_vs_subset: {
        expression_1: "x ∈ A",
        expression_2: "X ⊆ A",
        power_set_condition:
            "only subsets X of A are elements of P(A)"
    },
    A_vs_power_set: {
        input: A,
        output: P(A),
        equality_by_default: FALSE,
        cardinality_relation: "|P(A)| > |A|"
    },
    empty_set_vs_power_set_empty: {
        "∅": "contains no elements",
        "P(∅)": "{∅}",
        cardinalities: {
            "|∅|": 0,
            "|P(∅)|": 1
        }
    }
}

DEFINE EXAMPLE_1 := {
    A: "{a,b}",
    power_set: {
        "∅",
        "{a}",
        "{b}",
        "{a,b}"
    },
    cardinality_A: 2,
    cardinality_power_set: 4
}

DEFINE EXAMPLE_2 := {
    A: "{1,2,3}",
    cardinality_A: 3,
    cardinality_power_set: 8
}

DEFINE EXAMPLE_3 := {
    A: "∅",
    power_set: "{∅}",
    cardinality_power_set: 1
}

DEFINE SEMANTIC_PIPELINE :=
    InputSet
    -> ResolveElementsAndSetIdentity
    -> GenerateCandidateSubsets
    -> ValidateSubsetCondition
    -> IncludeEmptySet
    -> IncludeInputSet
    -> CollapseDuplicateSubsetRepresentations
    -> ConstructPowerSet
    -> DetermineCardinality
    -> ConstructInclusionOrder
    -> ReturnCanonicalPowerSetRepresentation

DEFINE REASONING_PIPELINE :=
    InputExpression
    -> DetectPowerSetOperator
    -> ResolveBaseSet
    -> TranslatePowerSetMembershipToSubsetRelation
    -> ApplyEmptyAndWholeSetMembership
    -> ApplyFiniteCardinalityRuleWhenApplicable
    -> ApplyMonotonicity
    -> ApplyCantorTheorem
    -> ApplyBooleanLatticePropertiesWhenRelevant
    -> ReturnDerivedRelations

DEFINE POWER_SET_GRAPH_MODEL := {
    base_node: Set(A),
    power_set_node: P(A),
    member_nodes: SubsetsOf(A),
    edge:
        "X --MEMBER_OF--> P(A)",
    equivalent_edge:
        "X --SUBSET_OF--> A",
    order_inside_power_set:
        SUBSET_OF
}

DEFINE ONTOLOGY_RELATIONS := {
    PowerSet IS_COMPONENT_OF SetTheory,
    PowerSet IS_SET_OF Subsets,
    Set HAS_POWER_SET PowerSet,
    EmptySet MEMBER_OF every_PowerSet,
    Set MEMBER_OF its_own_PowerSet,
    PowerSet HAS_CARDINALITY Cardinality,
    PowerSet DEPENDS_ON Subset,
    PowerSet ORDERED_BY Inclusion,
    PowerSet FORMS BooleanLattice UNDER subset_order_and_set_operations,
    CantorTheorem RELATES Set TO PowerSet
}

DEFINE SEMANTIC_EQUIVALENCE := {
    "power set" <=> PowerSet,
    "set of all subsets" <=> PowerSet,
    "P(A)" <=> PowerSet(A),
    "𝒫(A)" <=> PowerSet(A),
    "2^A" <=> PowerSet(A) WHEN set_theory_context=TRUE,
    "X belongs to the power set of A" <=> "X ⊆ A"
}

DEFINE AI_CONSUMPTION := {
    purpose: "machine-readable representation and reasoning for power sets",
    preserve_base_set_identity: TRUE,
    preserve_subset_identity: TRUE,
    translate_power_set_membership_to_subset: TRUE,
    include_empty_subset: TRUE,
    include_full_subset: TRUE,
    support_finite_subset_generation: TRUE,
    support_cardinality_exponentiation: TRUE,
    apply_Cantor_theorem: TRUE,
    support_inclusion_partial_order: TRUE,
    support_Boolean_lattice_reasoning: TRUE,
    reasoning_mode: "symbolic + extensional + combinatorial + order-theoretic"
}

DEFINE CONFIDENCE := {
    ontology_identity: 1.00,
    formal_power_set_detection: 0.99,
    membership_subset_equivalence: 1.00,
    finite_power_set_generation: 0.99,
    finite_cardinality_reasoning: 1.00,
    Cantor_theorem_mapping: 0.99,
    lattice_mapping: 0.98,
    natural_language_power_set_mapping: 0.99
}

DEFINE UPDATE_MODEL := {
    version: "1.0",
    update_policy: "append-compatible",
    immutable_core: {
        set_of_all_subsets_definition,
        membership_subset_equivalence,
        empty_subset_membership,
        full_set_membership,
        finite_cardinality_rule,
        Cantor_theorem
    },
    extensible_layers: {
        infinite_power_sets,
        Boolean_algebras,
        subset_lattices,
        characteristic_functions,
        combinatorial_subset_generation,
        topology_via_power_sets,
        computational_bitset_representations
    }
}

DEFINE FLOW_HASH_INPUT :=
    CanonicalURL
    + DOMAIN
    + ENTITY_TYPES
    + RELATION_TYPES
    + RULES
    + POWER_SET_MODEL
    + CARDINALITY_MODEL
    + SUBSET_SELECTION_MODEL
    + CRITICAL_DISTINCTIONS
    + SEMANTIC_PIPELINE
    + REASONING_PIPELINE
    + POWER_SET_GRAPH_MODEL
    + ONTOLOGY_RELATIONS
    + AI_CONSUMPTION
    + UPDATE_MODEL

FLOW_HASH := HASH(FLOW_HASH_INPUT)

RETURN {
    ontology: PowerSetOntology,
    canonical_url: "https://kirethresearch.org/booksai-core/ontologies/mathematical-ontologies/mathematical-logic-ontologies/set-theory/power-set-ontology.html",
    parent_domain: SetTheory,
    semantic_domain: MathematicalLogic,
    primary_entity: PowerSet,
    primary_relation: "X ∈ P(A) iff X ⊆ A",
    cardinality_reasoning_enabled: TRUE,
    order_reasoning_enabled: TRUE,
    machine_consumable: TRUE,
    recursive_reasoning_enabled: TRUE,
    flow_complete: TRUE
}

END_FLOW