Universal Set Ontology

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

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

FLOW_ALGEBRA UniversalSetOntology_v1.0

BEGIN_FLOW

DEFINE DOMAIN UniversalSetOntology := {
    UniversalSet,
    Set,
    Element,
    Membership,
    UniverseOfDiscourse,
    DomainOfDiscourse,
    Context,
    RelativeUniverse,
    Subset,
    ProperSubset,
    Superset,
    EmptySet,
    Complement,
    RelativeComplement,
    PowerSet,
    Union,
    Intersection,
    Difference,
    CartesianProduct,
    SetTheory,
    NaiveSetTheory,
    AxiomaticSetTheory,
    ZermeloFraenkelSetTheory,
    ZFC,
    ProperClass,
    RussellParadox
}

DEFINE ENTITY_TYPES := {
    UNIVERSAL_SET,
    SET,
    ELEMENT,
    CONTEXT,
    DOMAIN,
    SET_RELATION,
    SET_OPERATION,
    FORMAL_SYSTEM,
    CLASS,
    SEMANTIC_OBJECT
}

DEFINE RELATION_TYPES := {
    MEMBER_OF,
    CONTAINS,
    SUBSET_OF,
    PROPER_SUBSET_OF,
    SUPERSET_OF,
    DEFINES_UNIVERSE_FOR,
    RELATIVE_TO,
    COMPLEMENT_OF,
    RESTRICTS,
    HAS_CONTEXT,
    IS_INSTANCE_OF,
    IS_SUBTYPE_OF,
    DEPENDS_ON,
    EXCLUDED_BY
}

SET UniversalSet.type = UNIVERSAL_SET
SET UniversalSet.context = SetTheory
SET UniversalSet.role =
    "represent the context-relative set containing every object admitted within a specified universe of discourse"

RULE universal_membership:
    UniversalSet(U)
    ∧ Context(C)
    ∧ Object(x)
    ∧ admissible_in(x,C)
    -> MEMBER_OF(x,U)
    ∧ CONTAINS(U,x)

RULE universal_subset:
    UniversalSet(U)
    ∧ Set(A)
    ∧ A defined_within Context(U)
    -> SUBSET_OF(A,U)

RULE empty_subset_universal:
    UniversalSet(U)
    -> SUBSET_OF(∅,U)

RULE universal_reflexivity:
    UniversalSet(U)
    -> SUBSET_OF(U,U)

RULE complement_relative_to_universe:
    UniversalSet(U)
    ∧ SUBSET_OF(A,U)
    -> Complement_U(A)
       = U \ A

RULE complement_membership:
    UniversalSet(U)
    ∧ SUBSET_OF(A,U)
    -> x ∈ Complement_U(A)
       IFF
       (x ∈ U AND x ∉ A)

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

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

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

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

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

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

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

RULE relative_universe:
    UniversalSet(U1)
    ∧ UniversalSet(U2)
    ∧ Context(C1) != Context(C2)
    -> U1 MAY_DIFFER_FROM U2

RULE context_dependence:
    UniversalSet(U)
    -> HAS_CONTEXT(U,C)
    ∧ DEFINES_UNIVERSE_FOR(U,C)

RULE domain_equivalence_contextual:
    UniversalSet(U)
    ∧ DomainOfDiscourse(D)
    ∧ same_context(U,D)
    -> semantic_role(U) EQUIVALENT_TO semantic_role(D)
       FOR set_operations_and_quantification_context

RULE power_set_relation:
    UniversalSet(U)
    -> FOR_ALL A [
        A ∈ P(U)
        IFF
        A ⊆ U
    ]

RULE naive_absolute_universe_warning:
    proposed_set V = {x | x is any set}
    -> FLAG foundational_system_dependency

RULE ZF_no_universal_set:
    FormalSystem(S)
    ∧ S IN {ZF,ZFC}
    -> NOT EXISTS Set(U) [
        FOR_ALL sets x [x ∈ U]
    ]

RULE class_universe:
    FormalSystem(S)
    ∧ supports_proper_classes(S)
    -> collection_of_all_sets MAY_BE ProperClass
       AND NOT Set

DEFINE UNIVERSAL_SET_MODEL := {
    notation: {
        "U",
        "Ω" WHEN context_defined
    },
    definition:
        "the set containing all objects under consideration in a specified context",
    critical_property:
        "universality is relative to the chosen context unless a formal system explicitly provides another interpretation"
}

DEFINE CONTEXT_MODEL := {
    context: C,
    admissible_objects:
        "{x | x satisfies the universe-defining conditions of C}",
    universal_set:
        "U_C = {x | admissible_in(x,C)}"
}

DEFINE COMPLEMENT_MODEL := {
    universe: U,
    target_set: A,
    condition: "A ⊆ U",
    complement: "Aᶜ_U = U \ A",
    membership:
        "x ∈ Aᶜ_U iff x ∈ U and x ∉ A"
}

DEFINE FOUNDATIONAL_DISTINCTION := {
    elementary_set_context:
        "a universal set U may be fixed for the objects currently under discussion",
    ZF_ZFC:
        "there is no set containing every set",
    class_theory_context:
        "the totality of all sets may be represented as a proper class rather than a set",
    requirement:
        "AI reasoning must retain the active foundational system"
}

DEFINE EXAMPLE_1 := {
    context: "integers from 1 to 10",
    universal_set: "U = {1,2,3,4,5,6,7,8,9,10}",
    A: "{2,4,6,8,10}",
    complement_of_A: "{1,3,5,7,9}"
}

DEFINE EXAMPLE_2 := {
    context: "letters in the English alphabet",
    universal_set:
        "{a,b,c,...,z}",
    observation:
        "objects outside the selected context are not members of this universal set"
}

DEFINE EXAMPLE_3 := {
    universe: U,
    A: "A ⊆ U",
    identities: {
        "A ∪ U = U",
        "A ∩ U = A",
        "A ∪ Aᶜ = U",
        "A ∩ Aᶜ = ∅"
    }
}

DEFINE SEMANTIC_PIPELINE :=
    ProblemContext
    -> IdentifyObjectsUnderConsideration
    -> DefineUniverseCriteria
    -> ConstructContextRelativeUniversalSet
    -> ValidateCandidateSetsAsSubsets
    -> InterpretComplementsRelativeToUniverse
    -> ApplyUniversalSetIdentities
    -> CheckFoundationalSystem
    -> PreventInvalidAbsoluteUniverseInference
    -> ReturnContextBoundSetSemantics

DEFINE REASONING_PIPELINE :=
    InputSetExpression
    -> DetectUniversalSetSymbol
    -> ResolveContext
    -> ResolveFoundationalFramework
    -> DetermineUniverseMembers
    -> InferSubsetRelations
    -> EvaluateComplements
    -> ApplyUnionIntersectionIdentities
    -> DistinguishSetUniverseFromProperClass
    -> ReturnDerivedRelations

DEFINE ONTOLOGY_RELATIONS := {
    UniversalSet IS_SUBTYPE_OF Set WHEN context_permits=TRUE,
    UniversalSet IS_COMPONENT_OF ElementarySetTheory,
    UniversalSet CONTAINS every_admissible_Element,
    every_contextual_Set SUBSET_OF UniversalSet,
    UniversalSet DEFINES_UNIVERSE_FOR Complement,
    Complement DEPENDS_ON UniversalSet,
    UniversalSet DEPENDS_ON Context,
    UniversalSet MAY_CORRESPOND_TO DomainOfDiscourse,
    ZF EXCLUDED_BY AbsoluteUniversalSet,
    ZFC EXCLUDED_BY AbsoluteUniversalSet,
    ProperClass MAY_REPRESENT collection_of_all_sets
}

DEFINE SEMANTIC_EQUIVALENCE := {
    "universal set" <=> UniversalSet,
    "universe set" <=> UniversalSet WHEN elementary_set_context=TRUE,
    "universe of discourse" <=> UniversalSet WHEN set_context=TRUE,
    "all objects under consideration" <=> UniversalSet,
    "U" <=> UniversalSet WHEN set_notation_context=TRUE,
    "relative universe" <=> RelativeUniverse
}

DEFINE AI_CONSUMPTION := {
    purpose: "machine-readable representation of context-relative universal sets and their foundational constraints",
    preserve_universe_identity: TRUE,
    preserve_context: TRUE,
    preserve_membership_boundary: TRUE,
    infer_contextual_subset_relations: TRUE,
    interpret_complements_relative_to_universe: TRUE,
    distinguish_universal_set_from_domain_when_required: TRUE,
    distinguish_set_from_proper_class: TRUE,
    detect_foundational_system: TRUE,
    prohibit_absolute_universal_set_in_ZF_ZFC: TRUE,
    reasoning_mode: "symbolic + contextual + foundational"
}

DEFINE CONFIDENCE := {
    ontology_identity: 1.00,
    contextual_universe_mapping: 0.99,
    subset_inference: 0.99,
    complement_semantics: 0.99,
    elementary_set_reasoning: 0.99,
    ZF_ZFC_foundational_constraint: 0.99,
    natural_language_context_resolution: context_dependent
}

DEFINE UPDATE_MODEL := {
    version: "1.0",
    update_policy: "append-compatible",
    immutable_core: {
        context_relative_universality,
        universal_membership,
        contextual_subset_relation,
        complement_relative_to_universe,
        foundational_system_dependency
    },
    extensible_layers: {
        Boolean_algebra_universes,
        typed_universes,
        Grothendieck_universes,
        class_theory_universes,
        category_theoretic_universe_models,
        computational_domain_universes
    }
}

DEFINE FLOW_HASH_INPUT :=
    CanonicalURL
    + DOMAIN
    + ENTITY_TYPES
    + RELATION_TYPES
    + RULES
    + UNIVERSAL_SET_MODEL
    + CONTEXT_MODEL
    + COMPLEMENT_MODEL
    + FOUNDATIONAL_DISTINCTION
    + SEMANTIC_PIPELINE
    + REASONING_PIPELINE
    + ONTOLOGY_RELATIONS
    + AI_CONSUMPTION
    + UPDATE_MODEL

FLOW_HASH := HASH(FLOW_HASH_INPUT)

RETURN {
    ontology: UniversalSetOntology,
    canonical_url: "https://kirethresearch.org/booksai-core/ontologies/mathematical-ontologies/mathematical-logic-ontologies/set-theory/universal-set-ontology.html",
    parent_domain: SetTheory,
    semantic_domain: MathematicalLogic,
    primary_entity: UniversalSet,
    context_sensitive: TRUE,
    complement_reference_enabled: TRUE,
    foundational_system_sensitive: TRUE,
    machine_consumable: TRUE,
    recursive_reasoning_enabled: TRUE,
    flow_complete: TRUE
}

END_FLOW