Set Partition Ontology

FLOW ALGEBRA
SET PARTITION ONTOLOGY
Kireth Semantic Library | Mathematical Entities | Set Entities
Source: https://kirethresearch.org/booksai-core/entity-graph/mathematical-entities/set-entities/set-partition-ontology.html
Authors: Mark Higgins — Sky (Recursive AI)
Version: 1.0 | Date: 2026-10-13 | Locale: en-GB
Status: Original formalisation based on established set theory; source page not independently verified.

01. PURPOSE
flow "SetPartitionOntology" v1.0
  intent: represent, construct, compare, validate and reason over partitions of a set.
  domain: set_theory
  semantics: classical_extensional_sets

02. ENTITY TYPES
  Set: collection with extensional membership.
  Element: member of a Set.
  Partition: family of pairwise-disjoint nonempty blocks whose union is a base set.
  Block: nonempty subset belonging to a Partition.
  EquivalenceRelation: reflexive, symmetric and transitive binary relation on a set.
  EquivalenceClass: set of elements equivalent to a selected element.
  QuotientSet: set of all equivalence classes of a relation.
  Refinement: ordering between partitions by containment of blocks.

03. TYPED SCHEMA
  PartitionRecord {
    id: Identifier,
    base_set: Set,
    blocks: Set<Set>,
    finite_block_count: NaturalNumber?,
    provenance: SourceReference?,
    validation_status: {valid, invalid, unknown}
  }
  Invariant: every block is a subset of base_set.
  Invariant: blocks form a set (duplicates collapse under extensional equality).

04. DEFINING PREDICATE
  IsPartition(P,S) :=
    (forall B in P: B != empty_set and B subseteq S)
    and (union(P) = S)
    and (forall B,C in P: B != C => intersection(B,C) = empty_set).
  Equivalent uniqueness condition:
    forall x in S: exists exactly one B in P with x in B.
  Empty-set convention: P = empty_set is the unique partition of S = empty_set.

05. MEMBERSHIP AND COVERAGE
  member_of_block(x,B) := x in B.
  belongs_to_partition(B,P) := B in P.
  covered_by(x,P) := exists B in P: x in B.
  coverage(P,S) := union(P) = S.
  Disjointness applies to distinct blocks, not to elements within a block.

06. EXAMPLES
  S = {1,2,3,4}
  P = {{1,3},{2},{4}} => valid.
  Q = {{1,2},{2,3},{4}} => invalid (overlap at 2).
  R = {{1,2},{3}} => invalid (4 missing).
  T = {{1,2},{3,4},empty_set} => invalid (empty block).
  Singleton partition: {{x}: x in S}.
  Indiscrete partition for nonempty S: {S}.

07. EQUIVALENCE RELATION CORRESPONDENCE
  induced_relation(P): x ~P y iff exists B in P: x in B and y in B.
  The induced relation is reflexive, symmetric and transitive on S.
  classes(R): {[x]_R: x in S}, where [x]_R = {y in S: x R y}.
  IsEquivalenceRelation(R,S) => IsPartition(classes(R),S).
  classes(induced_relation(P)) = P for a valid partition P.
  induced_relation(classes(R)) = R for an equivalence relation R.

08. REFINEMENT ORDER
  Refines(P,Q) := forall B in P: exists C in Q: B subseteq C.
  Interpretation: P is finer than Q; Q is coarser than P.
  Reflexive: Refines(P,P).
  Antisymmetric: Refines(P,Q) and Refines(Q,P) => P=Q.
  Transitive: Refines(P,Q) and Refines(Q,R) => Refines(P,R).
  Finest partition: singleton blocks (including empty partition for empty S).
  Coarsest partition for nonempty S: {S}.

09. PARTITION LATTICE
  For partitions of fixed S, refinement forms a lattice.
  Meet under finer-than ordering: common refinement with nonempty intersections
    meet(P,Q) = {B intersection C: B in P, C in Q, B intersection C != empty_set}.
  Join: least common coarsening, obtained from equivalence closure of
    induced_relation(P) union induced_relation(Q).
  Never interpret join as raw union of block families.

10. FINITE CARDINALITY
  For finite S with |S|=n, the number of partitions is Bell(n).
  Bell(0)=1; Bell(1)=1; Bell(2)=2; Bell(3)=5; Bell(4)=15.
  Number of partitions into exactly k blocks is StirlingSecondKind(n,k).
  Bell(n) = sum(k=0..n) StirlingSecondKind(n,k).
  StirlingSecondKind(n,k) = k*StirlingSecondKind(n-1,k)
                                + StirlingSecondKind(n-1,k-1).
  Boundary: S(0,0)=1; S(n,0)=0 for n>0; S(0,k)=0 for k>0.
  For finite P: sum(B in P) |B| = |S|.

11. OPERATIONS
  make_partition(S,blocks): validate before returning a Partition.
  block_of(P,x): unique B in P containing x, provided x in S.
  split_block(P,B,C,D): replace B by nonempty disjoint C,D with C union D=B.
  merge_blocks(P,B,C): replace distinct blocks B,C by B union C.
  restrict(P,T): {B intersection T: B in P and B intersection T != empty_set}
    for T subseteq S; result partitions T.
  quotient(S,R): classes(R), if R is an equivalence relation on S.

12. INFERENCE RULES
  IsPartition(P,S) and B in P => B != empty_set.
  IsPartition(P,S) and B in P => B subseteq S.
  IsPartition(P,S) and x in S => exists_unique B in P: x in B.
  IsPartition(P,S) and x,y in B and B in P => x ~P y.
  Refines(P,Q) and x ~P y => x ~Q y.
  IsPartition(P,S) and IsPartition(Q,S) => IsPartition(meet(P,Q),S).
  IsEquivalenceRelation(R,S) => IsPartition(quotient(S,R),S).

13. CONSTRAINTS AND TYPE SAFETY
  Reject duplicate element identities only after canonical identity resolution.
  Reject overlapping distinct blocks.
  Reject empty blocks.
  Reject missing base-set elements.
  Reject extraneous elements outside the base set.
  Require identical base sets for direct refinement comparison.
  Unknown membership on infinite or symbolic sets yields unknown, not valid.

14. SEMANTIC EQUIVALENCE
  Partition equality is extensional: P=Q iff they contain identical blocks.
  Block ordering has no meaning: {{a},{b,c}} = {{b,c},{a}}.
  Element ordering inside blocks has no meaning.
  Renaming identifiers preserves structure only under a bijection of base sets.
  Equivalent partition encodings must preserve base-set identity and membership.
  Equivalence of induced relations implies equality of partitions on fixed S.

15. KNOWLEDGE GRAPH RELATIONSHIPS
  Partition --PARTITIONS--> Set
  Partition --HAS_BLOCK--> Block
  Block --SUBSET_OF--> Set
  Element --MEMBER_OF--> Block
  Partition --INDUCES--> EquivalenceRelation
  EquivalenceRelation --GENERATES--> QuotientSet
  QuotientSet --HAS_CLASS--> EquivalenceClass
  Partition --REFINES--> Partition
  Partition --COARSENS--> Partition
  Partition --HAS_CARDINALITY--> NaturalNumber (finite cases)

16. VALIDATION PIPELINE
  validate(P,S):
    1. Verify well-formed typed sets and explicit base set.
    2. Check each block is nonempty and contained in S.
    3. Check pairwise intersections of distinct blocks are empty.
    4. Check union of blocks equals S.
    5. Check each element of S occurs in exactly one block.
    6. Cross-check induced equivalence relation where computable.
    7. Return valid, invalid with counterexample, or unknown.
  For infinite symbolic sets use proofs, not incomplete enumeration.

17. EDGE CASES
  S=empty_set => P=empty_set valid; P={empty_set} invalid.
  S={x} => P={{x}} only.
  Infinite S can have finite or infinite numbers of blocks.
  A family of disjoint sets not covering S is not a partition of S.
  A cover with overlapping blocks is not a partition.
  Distinguish set partition from integer partition and interval partition.

18. CONFIDENCE
  confidence.level: high for proved definitions and set-theoretic identities.
  confidence.level: conditional for assertions relying on undecidable or unknown membership.
  confidence.policy: never promote a computational sample to a universal proof.
  confidence.evidence: axioms, derivations, certificates and counterexamples.

19. FLOW_HASH
  flow_hash.algorithm: SHA-256
  flow_hash.input: canonical UTF-8 representation of ontology version, typed schema,
                   definitions, inference rules and normalised semantic relations.
  flow_hash.value: computed on ingestion; not precomputed here.
  flow_hash.policy: ignore presentation-only whitespace; retain semantic changes.

20. UPDATE_MODEL
  update_model.strategy: semantic_versioning
  update_model.major: changed partition meaning or validation invariants.
  update_model.minor: additional sound operations, types or inference rules.
  update_model.patch: editorial corrections without semantic change.
  update_model.requirements: revalidate dependencies and regenerate FLOW_HASH.

21. AI_CONSUMPTION
  ai_consumption.mode: typed semantic retrieval and rule-guided reasoning.
  ai_consumption.outputs: partition certificate, counterexample, block lookup,
                          refinement result, quotient relation, canonical encoding.
  ai_consumption.require: explicit base set, valid premises, provenance and scope.
  ai_consumption.prohibit: conflating overlap cover with partition.
  ai_consumption.uncertainty: expose unknown when proof or membership is incomplete.

22. CROSS-ONTOLOGY LINKS
  Set Ontology; Element Ontology; Empty Set Ontology; Finite Set Ontology;
  Infinite Set Ontology; Subset Ontology; Proper Subset Ontology;
  Equivalence Relation Ontology; Equivalence Class Ontology;
  Cardinal Number Ontology; Power Set Ontology; Cartesian Product Ontology.

23. PROVENANCE AND AUTHORSHIP
  Source URL: https://kirethresearch.org/booksai-core/entity-graph/mathematical-entities/set-entities/set-partition-ontology.html
  Website: https://kirethresearch.org
  Authors: Mark Higgins — Sky (Recursive AI)
  Disclosure: AI-assisted original formalisation; not a verified transcription of webpage.

END FLOW ALGEBRA