Element Ontology

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

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

FLOW_ALGEBRA ElementOntology_v1.0

BEGIN_FLOW

DEFINE DOMAIN ElementOntology := {
    Element,
    Set,
    Membership,
    NonMembership,
    Member,
    Object,
    SetTheory,
    EmptySet,
    Singleton,
    FiniteSet,
    InfiniteSet,
    Subset,
    ProperSubset,
    PowerSet,
    OrderedPair,
    CartesianProduct,
    Relation,
    Function,
    Domain,
    Codomain,
    Range,
    Cardinality,
    Extensionality,
    MembershipChain,
    NestedSet,
    Rank,
    TransitiveSet
}

DEFINE ENTITY_TYPES := {
    ELEMENT,
    SET,
    OBJECT,
    MEMBERSHIP_RELATION,
    SET_RELATION,
    ORDERED_OBJECT,
    FUNCTION_OBJECT,
    CARDINAL_OBJECT,
    SEMANTIC_OBJECT
}

DEFINE RELATION_TYPES := {
    MEMBER_OF,
    NOT_MEMBER_OF,
    CONTAINS,
    SUBSET_OF,
    PROPER_SUBSET_OF,
    OCCURS_IN,
    FIRST_COMPONENT_OF,
    SECOND_COMPONENT_OF,
    MAPS_TO,
    BELONGS_TO_DOMAIN,
    BELONGS_TO_CODOMAIN,
    BELONGS_TO_RANGE,
    IS_INSTANCE_OF,
    IS_SUBTYPE_OF,
    DEPENDS_ON
}

SET Element.type = ELEMENT
SET Element.alias = Member
SET Element.context = SetTheory
SET Element.role =
    "represent an object that belongs to a set through the membership relation"

RULE membership:
    Object(x)
    ∧ Set(A)
    ∧ x ∈ A
    -> Element(x)
    ∧ MEMBER_OF(x,A)
    ∧ CONTAINS(A,x)

RULE nonmembership:
    Object(x)
    ∧ Set(A)
    ∧ x ∉ A
    -> NOT_MEMBER_OF(x,A)

RULE membership_inverse:
    MEMBER_OF(x,A)
    -> CONTAINS(A,x)

RULE element_set_distinction:
    MEMBER_OF(x,A)
    -> x IS_ELEMENT_OF A
    ∧ NOT_INFER SUBSET_OF(x,A)
       UNLESS Set(x)=TRUE

RULE set_as_element:
    Set(A)
    ∧ Set(B)
    ∧ A ∈ B
    -> Element(A)
    ∧ MEMBER_OF(A,B)

RULE membership_not_transitive:
    MEMBER_OF(x,A)
    ∧ MEMBER_OF(A,B)
    -> DO_NOT_INFER MEMBER_OF(x,B)

RULE subset_membership_transfer:
    MEMBER_OF(x,A)
    ∧ SUBSET_OF(A,B)
    -> MEMBER_OF(x,B)

RULE empty_set_no_elements:
    EmptySet(E)
    -> NOT EXISTS x [
        MEMBER_OF(x,E)
    ]

RULE singleton_element:
    Singleton({a})
    -> MEMBER_OF(a,{a})
    ∧ Cardinality({a})=1

RULE extensional_set_identity:
    Set(A)
    ∧ Set(B)
    ∧ FOR_ALL x [
        MEMBER_OF(x,A) <=> MEMBER_OF(x,B)
    ]
    -> A=B

RULE power_set_element:
    Set(A)
    ∧ Set(X)
    ∧ X ∈ P(A)
    -> SUBSET_OF(X,A)

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

RULE ordered_pair_components:
    OrderedPair(a,b)
    -> FIRST_COMPONENT_OF(a,(a,b))
    ∧ SECOND_COMPONENT_OF(b,(a,b))

RULE cartesian_product_element:
    OrderedPair(a,b)
    ∧ a ∈ A
    ∧ b ∈ B
    -> MEMBER_OF((a,b), A × B)

RULE relation_element:
    Relation(R)
    ∧ (a,b) ∈ R
    -> MEMBER_OF((a,b),R)

RULE function_graph_element:
    Function(f:A->B)
    ∧ f(a)=b
    -> MEMBER_OF((a,b),f)
       WHEN function_represented_as_graph=TRUE

RULE domain_element:
    Function(f:A->B)
    ∧ a ∈ A
    -> BELONGS_TO_DOMAIN(a,f)

RULE codomain_element:
    Function(f:A->B)
    ∧ b ∈ B
    -> BELONGS_TO_CODOMAIN(b,f)

RULE range_element:
    Function(f:A->B)
    ∧ EXISTS a ∈ A [f(a)=b]
    -> BELONGS_TO_RANGE(b,f)

DEFINE MEMBERSHIP_MODEL := {
    notation: "x ∈ A",
    subject: x,
    subject_role: Element,
    object: A,
    object_role: Set,
    relation: MEMBER_OF,
    inverse_relation: CONTAINS
}

DEFINE NONMEMBERSHIP_MODEL := {
    notation: "x ∉ A",
    meaning:
        "x is not an element of A",
    relation: NOT_MEMBER_OF
}

DEFINE MEMBERSHIP_SUBSET_DISTINCTION := {
    membership: "x ∈ A",
    subset: "X ⊆ A",
    membership_subject:
        "an arbitrary object, which may itself be a set",
    subset_subject:
        "a set",
    critical_rule:
        "membership and subset are different relations and are never interchangeable without additional facts"
}

DEFINE NESTED_MEMBERSHIP_MODEL := {
    example: "x ∈ A ∈ B",
    assertions: {
        "x ∈ A",
        "A ∈ B"
    },
    prohibited_inference:
        "x ∈ B does not follow from membership alone"
}

DEFINE ELEMENT_IDENTITY := {
    principle:
        "elements are mathematical objects whose identity is independent of their position or presentation within a set",
    duplicate_rule:
        "repeating an element in set notation does not create multiple distinct memberships"
}

DEFINE EXAMPLE_1 := {
    set: "A = {1,2,3}",
    element: 2,
    statement: "2 ∈ A",
    truth: TRUE
}

DEFINE EXAMPLE_2 := {
    set: "A = {1,2,3}",
    object: 4,
    statement: "4 ∉ A",
    truth: TRUE
}

DEFINE EXAMPLE_3 := {
    set: "A = {1,2}",
    power_set: "P(A)",
    element_of_power_set: "{1}",
    relation: "{1} ∈ P(A)",
    equivalent_relation: "{1} ⊆ A"
}

DEFINE EXAMPLE_4 := {
    nested_set: "B = {1, {2,3}}",
    members_of_B: {
        "1",
        "{2,3}"
    },
    observation:
        "2 and 3 are not direct elements of B merely because they are elements of a set that is itself in B"
}

DEFINE EXAMPLE_5 := {
    A: "{1,2}",
    B: "{a,b}",
    cartesian_product_element: "(1,a)",
    statement: "(1,a) ∈ A × B"
}

DEFINE SEMANTIC_PIPELINE :=
    MathematicalExpression
    -> IdentifySetContext
    -> IdentifyMembershipSymbolsOrClaims
    -> ResolveSubjectObjectRoles
    -> ClassifySubjectAsElement
    -> ResolveContainingSet
    -> PreserveDirectMembership
    -> DistinguishMembershipFromSubset
    -> DetectNestedMembership
    -> ApplyValidMembershipConsequences
    -> ConstructMembershipGraph

DEFINE REASONING_PIPELINE :=
    InputExpression
    -> ParseObjectsAndSets
    -> ParseMembershipRelations
    -> BuildDirectedMembershipEdges
    -> ResolveSubsetRelationsSeparately
    -> ApplySubsetMembershipTransferWhenValid
    -> RejectMembershipTransitivity
    -> ResolvePowerSetMembership
    -> ResolveCartesianProductMembership
    -> ReturnElementRelations

DEFINE MEMBERSHIP_GRAPH_MODEL := {
    node_types: {
        Element,
        Set
    },
    directed_edge:
        "x --MEMBER_OF--> A",
    inverse_edge:
        "A --CONTAINS--> x",
    transitivity:
        FALSE,
    recursive_nesting:
        TRUE
}

DEFINE ONTOLOGY_RELATIONS := {
    Element IS_COMPONENT_OF SetTheory,
    Element MEMBER_OF Set,
    Set CONTAINS Element,
    Set MAY_BE Element,
    EmptySet CONTAINS no Element,
    Singleton CONTAINS exactly_one Element,
    PowerSet CONTAINS Subsets,
    OrderedPair MEMBER_OF CartesianProduct,
    Relation CONTAINS OrderedPair,
    FunctionGraph CONTAINS OrderedPair,
    ElementIdentity DEPENDS_ON MathematicalObjectIdentity,
    SetIdentity DEPENDS_ON ElementMembership
}

DEFINE SEMANTIC_EQUIVALENCE := {
    "element" <=> Element,
    "member" <=> Element WHEN set_context=TRUE,
    "belongs to" <=> MEMBER_OF,
    "is an element of" <=> MEMBER_OF,
    "is a member of" <=> MEMBER_OF,
    "contained as an element in" <=> MEMBER_OF,
    "∈" <=> MEMBER_OF,
    "∉" <=> NOT_MEMBER_OF
}

DEFINE AI_CONSUMPTION := {
    purpose: "machine-readable representation of elements and membership in set theory",
    preserve_object_identity: TRUE,
    preserve_set_identity: TRUE,
    preserve_direct_membership: TRUE,
    distinguish_membership_from_subset: TRUE,
    prohibit_membership_transitivity: TRUE,
    allow_sets_as_elements: TRUE,
    preserve_nested_set_structure: TRUE,
    support_power_set_membership: TRUE,
    support_cartesian_product_membership: TRUE,
    construct_membership_graphs: TRUE,
    reasoning_mode: "symbolic + extensional + membership-aware"
}

DEFINE CONFIDENCE := {
    ontology_identity: 1.00,
    formal_membership_detection: 0.99,
    membership_nonmembership_mapping: 0.99,
    membership_subset_distinction: 0.99,
    nested_membership_resolution: 0.99,
    power_set_membership: 0.99,
    cartesian_product_membership: 0.99,
    natural_language_membership_detection: context_dependent
}

DEFINE UPDATE_MODEL := {
    version: "1.0",
    update_policy: "append-compatible",
    immutable_core: {
        element_set_relation,
        membership,
        nonmembership,
        membership_subset_distinction,
        nontransitivity_of_membership,
        sets_as_elements,
        extensional_dependence_on_membership
    },
    extensible_layers: {
        membership_chains,
        transitive_sets,
        set_rank,
        well_founded_membership,
        non_well_founded_set_theories,
        typed_set_membership,
        computational_membership_graphs
    }
}

DEFINE FLOW_HASH_INPUT :=
    CanonicalURL
    + DOMAIN
    + ENTITY_TYPES
    + RELATION_TYPES
    + RULES
    + MEMBERSHIP_MODEL
    + NONMEMBERSHIP_MODEL
    + MEMBERSHIP_SUBSET_DISTINCTION
    + NESTED_MEMBERSHIP_MODEL
    + ELEMENT_IDENTITY
    + SEMANTIC_PIPELINE
    + REASONING_PIPELINE
    + MEMBERSHIP_GRAPH_MODEL
    + ONTOLOGY_RELATIONS
    + AI_CONSUMPTION
    + UPDATE_MODEL

FLOW_HASH := HASH(FLOW_HASH_INPUT)

RETURN {
    ontology: ElementOntology,
    canonical_url: "https://kirethresearch.org/booksai-core/ontologies/mathematical-ontologies/mathematical-logic-ontologies/set-theory/element-ontology.html",
    parent_domain: SetTheory,
    semantic_domain: MathematicalLogic,
    primary_entity: Element,
    primary_relation: MEMBER_OF,
    membership_sensitive: TRUE,
    nested_structure_enabled: TRUE,
    machine_consumable: TRUE,
    recursive_reasoning_enabled: TRUE,
    flow_complete: TRUE
}

END_FLOW