Set Family Ontology

FLOW ALGEBRA
SET FAMILY ONTOLOGY
Kireth Semantic Library | Mathematical Entities | Set Entities
Source: https://kirethresearch.org/booksai-core/entity-graph/mathematical-entities/set-entities/set-family-ontology.html
Authors: Mark Higgins — Sky (Recursive AI)
Version: 1.0 | Date: 2026-10-13 | Locale: en-GB
Status: Formal mathematical synthesis; source webpage not independently verified.

01. PURPOSE
flow "SetFamilyOntology" v1.0
  domain: set_theory
  entity: SetFamily
  meaning: A collection whose members are sets, optionally indexed by a domain.
  distinguish: A family of sets is not necessarily a partition or a pairwise-disjoint collection.

02. TYPES
  Set := collection of objects under an explicit foundational theory
  IndexSet := Set
  Family := Set[Set] | IndexedFamily[IndexSet, Set]
  MemberSet := Set
  Universe := optional contextual set U
  Cardinal := cardinal number
  Predicate := Boolean-valued expression

03. CORE ENTITY SCHEMA
  SetFamily:
    id: URI
    label: string
    representation: enumerated | indexed | predicate_defined
    members: collection[Set]
    index_domain: IndexSet?
    member_map: (i in IndexSet) -> Set?
    universe: Set?
    properties: list[string]
    provenance: URI?

04. FORMAL DEFINITIONS
  unindexed_family(F) := forall A in F: is_set(A)
  indexed_family((A_i)_(i in I)) := function A: I -> Set
  range(A) := {A_i | i in I}
  note: distinct indices may identify equal member sets.
  empty_family := {} ; indexed family with I={} has empty range.

05. MEMBERSHIP AND CONTAINMENT
  family_member(A,F) <=> A in F
  element_of_member(x,A,F) <=> A in F and x in A
  subfamily(G,F) <=> G subseteq F
  indexed_subfamily(A,J,I) requires J subseteq I
  note: x in union(F) does not imply x in every member.

06. UNION AND INTERSECTION
  union(F) := {x | exists A in F: x in A}
  indexed_union(A,I) := {x | exists i in I: x in A_i}
  intersection(F) := {x | forall A in F: x in A}
  indexed_intersection(A,I) := {x | forall i in I: x in A_i}
  empty_union := {}
  empty_intersection: requires specified universe U; equals U relative to U.

07. FAMILY PROPERTIES
  pairwise_disjoint(A,I) <=> forall i,j in I: i != j -> intersection(A_i,A_j)={}
  covering(F,U) <=> union(F)=U
  partition(F,U) <=> covering(F,U) and {} notin F and
                     forall A,B in F: A!=B -> intersection(A,B)={}
  nested_by_inclusion(F) <=> forall A,B in F: A subseteq B or B subseteq A
  directed_by_inclusion(F) <=> F!={} and
    forall A,B in F: exists C in F: A subseteq C and B subseteq C
  finite_family(F) <=> cardinality(F) is finite
  locally_finite(F,U,topology) := each x in U has a neighbourhood
    meeting only finitely many members of F

08. SPECIALISED FAMILIES
  cover := family whose union contains the target set
  open_cover := cover whose members are open in a specified topology
  sigma_algebra := nonempty family of subsets of U closed under
    complements relative to U and countable unions
  filter_base := nonempty family of nonempty subsets satisfying
    downward-refinement conditions
  partition := nonempty blocks that are pairwise disjoint and cover U
  chain := family linearly ordered by inclusion

09. OPERATIONS
  add_member(F,A) := F union {A}
  remove_member(F,A) := F difference {A}
  select(F,P) := {A in F | P(A)}
  image_family(F,f) := {f[A] | A in F}
  restrict_indices(A,I,J) := (A_j)_(j in J), requires J subseteq I
  family_product(A,I) := {f: I -> union(range(A)) |
                          forall i in I: f(i) in A_i}

10. CARDINALITY AND INDEXING
  cardinality(range(A)) <= cardinality(I)
  finite_union_bound: |union(F)| <= sum(A in F, |A|) for finite F
  indexed_repetition: A_i=A_j is permitted for i!=j
  indexing_is_structure: indexed families preserve labels and multiplicity

11. SET-THEORETIC IDENTITIES
  union(F union G) = union(F) union union(G)
  if F,G nonempty: intersection(F union G) = intersection(F) intersection intersection(G)
  if F subseteq G: union(F) subseteq union(G)
  if F subseteq G and F,G nonempty: intersection(G) subseteq intersection(F)
  DeMorgan_relative_to_U:
    U difference union(F) = intersection({U difference A | A in F})
    U difference intersection(F) = union({U difference A | A in F})
    requires F nonempty for unrestricted intersection convention

12. KNOWLEDGE GRAPH ENTITIES
  nodes: SetFamily, Set, IndexSet, Universe, Element, Partition,
         Cover, SigmaAlgebra, FilterBase, Topology, Predicate
  edges:
    SetFamily --hasMemberSet--> Set
    SetFamily --indexedBy--> IndexSet
    SetFamily --hasUniverse--> Universe
    SetFamily --hasUnion--> Set
    SetFamily --hasIntersection--> Set
    SetFamily --isSubfamilyOf--> SetFamily
    Partition --specialises--> SetFamily
    Cover --specialises--> SetFamily

13. SEMANTIC RELATIONSHIPS
  related_to: Set Ontology, Element Ontology, Subset Ontology,
    Set Partition Ontology, Power Set Ontology, Cartesian Product Ontology
  equivalent_labels: [family of sets, set collection]
  semantic_difference:
    family_vs_partition: partition requires nonempty disjoint blocks and coverage
    family_vs_power_set: power set contains all subsets of a given set
    family_vs_indexed_family: indexing preserves index identity

14. INFERENCE RULES
  R1: A in F and x in A => x in union(F)
  R2: x in intersection(F) and A in F => x in A
  R3: G subseteq F => union(G) subseteq union(F)
  R4: partition(F,U) => covering(F,U)
  R5: partition(F,U) => pairwise_disjoint_distinct_members(F)
  R6: indexed_family(A,I) => range(A) is a family of sets
  R7: F subseteq power_set(U) => union(F) subseteq U

15. VALIDATION
  V1: every member is a set in the chosen foundational universe
  V2: indexed mapping is total on its declared index domain
  V3: every member lies within U when F is declared a family over U
  V4: partition blocks are nonempty, disjoint and cover U
  V5: avoid undefined empty intersections without ambient U
  V6: distinguish indexed family from its range when duplicates exist
  V7: check topology-dependent properties only when topology supplied

16. EXAMPLES
  E1: F={{1,2},{2,3}}; union(F)={1,2,3}; intersection(F)={2}
  E2: A_1={a}, A_2={a}; indexed family has two indices, one distinct member set
  E3: F={{1},{2,3}} partitions U={1,2,3}
  E4: F={} has union {}; intersection requires ambient U

17. CONFIDENCE
  mathematical_axioms: 1.00 within stated foundations
  derived_rules: 1.00 when preconditions hold
  contextual_classification: depends on supplied universe/topology
  source_alignment: unverified; do not infer page-specific claims

18. SEMANTIC_EQUIVALENCE
  canonicalise: normalise set-membership and inclusion notation
  preserve: index labels, ambient universe, domain assumptions
  compare_unindexed: extensional equality of member sets
  compare_indexed: equality requires compatible indices and pointwise members
  prohibit: collapsing an indexed family into its range without annotation

19. FLOW_HASH
  canonical_payload: ontology_id + version + axioms + typed_rules + constraints
  algorithm: SHA-256
  hash_value: compute upon publication; never fabricate

20. UPDATE_MODEL
  update_trigger: corrected theorem, notation, taxonomy, or source alignment
  procedure: validate -> increment version -> recalculate hash -> publish changelog
  maintain: backwards-compatible entity identifiers where feasible

21. AI_CONSUMPTION
  input: set-family entities, member sets, optional indices and universe
  processing: typecheck -> normalise -> infer -> validate -> cite provenance
  output: typed facts, derived relations, assumptions, confidence, trace
  safeguards: preserve set-theoretic context and avoid unsupported inferences

22. AUTHORSHIP AND PROVENANCE
  authors: Mark Higgins — Sky (Recursive AI)
  publication: https://kirethresearch.org
  provenance: Kireth Semantic Library; formal synthesis of standard set theory
  notice: Formal specification is not an executable implementation by itself.

END FLOW ALGEBRA