Equivalence Class Ontology

FLOW ALGEBRA
EQUIVALENCE CLASS ONTOLOGY
Kireth Semantic Library | Entity Graph > Mathematical Entities > Set Entities
Source: https://kirethresearch.org/booksai-core/entity-graph/mathematical-entities/set-entities/equivalence-class-ontology.html
Authors: Mark Higgins — Sky (Recursive AI)
Version: 1.0 | Date: 2026-10-13
Status: Mathematical specification based on established set theory; source page not independently verified.

01. PURPOSE
flow "EquivalenceClassOntology" v1.0
  intent: model equivalence classes, quotient sets and their logical consequences
  foundation: classical set theory and equivalence relations
  output: typed semantic entities, rules, proof obligations and provenance

02. ENTITY TYPES
  Set[S] : collection of elements
  Relation[R] : subset of S × S
  EquivalenceRelation[R] : Relation[R] satisfying reflexive, symmetric, transitive
  Element[a] : member of S
  EquivalenceClass[C_a] : subset of S associated with a under R
  QuotientSet[S/R] : set of distinct equivalence classes
  Representative[a] : element chosen from its class
  CanonicalRepresentative[c] : selected representative under an explicit selection rule
  Partition[P] : pairwise-disjoint nonempty blocks whose union is S

03. CORE DEFINITION
  given: a ∈ S; R ⊆ S × S
  require: equivalence_relation(R,S)
  define: [a]_R = {x ∈ S | R(x,a)}
  define: S/R = {[a]_R | a ∈ S}
  assert: a ∈ [a]_R
  assert: [a]_R ⊆ S
  assert: [a]_R ≠ ∅

04. EQUIVALENCE RELATION AXIOMS
  reflexive: ∀x∈S, R(x,x)
  symmetric: ∀x,y∈S, R(x,y) ⇒ R(y,x)
  transitive: ∀x,y,z∈S, (R(x,y) ∧ R(y,z)) ⇒ R(x,z)
  reject: classification_as_equivalence_relation if any axiom fails

05. CLASS IDENTITIES
  theorem: R(a,b) ⇔ [a]_R = [b]_R
  theorem: ¬R(a,b) ⇔ [a]_R ∩ [b]_R = ∅
  theorem: [a]_R ∩ [b]_R ≠ ∅ ⇒ [a]_R = [b]_R
  theorem: ∪(S/R) = S
  theorem: distinct classes partition S
  note: each element belongs to exactly one class of S/R

06. QUOTIENT CONSTRUCTION
  quotient(S,R):
    precondition: equivalence_relation(R,S)
    result: {[a]_R | a∈S}
    deduplicate: by extensional set equality, not representative name
    postcondition: partition(quotient(S,R),S)
  quotient_map q:S→S/R:
    q(a)=[a]_R
    surjective: true
    kernel_equivalence: q(a)=q(b) ⇔ R(a,b)

07. PARTITION CORRESPONDENCE
  partition_to_relation(P,S): R_P(a,b) ⇔ ∃B∈P: a∈B ∧ b∈B
  relation_to_partition(R,S): P_R = S/R
  theorem: these constructions are inverse for valid partitions and equivalence relations

08. FINITE CARDINALITY
  when: S finite
  assert: 1 ≤ |S/R| ≤ |S| if S nonempty
  assert: |S/R| = 0 if S empty
  assert: Σ(C∈S/R) |C| = |S|
  note: equal-sized classes imply |S| = |S/R| × class_size
  reject: assuming equal-sized classes without evidence

09. INFINITE SETS
  allow: infinite S and infinite classes
  cardinality: quotient size may be finite or infinite
  caution: choice of representatives for arbitrary families may require the axiom of choice
  caution: no global canonical representative exists without a specified rule

10. EXAMPLES
  parity:
    S: integers Z
    R(a,b): (a-b) divisible by 2
    classes: even integers; odd integers
    quotient_cardinality: 2
  congruence_mod_n:
    S: Z
    require: n positive integer
    R(a,b): n divides (a-b)
    classes: residues modulo n
    quotient_cardinality: n
  rational_construction:
    S: {(a,b)∈Z×Z | b≠0}
    R((a,b),(c,d)): a*d=b*c
    quotient: rational numbers Q
    caution: equivalence is on integer pairs, not numerical equality of pairs

11. OPERATIONS AND TYPING
  class_of(a,R): EquivalenceClass
    require: a∈S and equivalence_relation(R,S)
  same_class(a,b,R): Boolean = R(a,b)
  class_members(C): Set
  quotient_set(S,R): Set[EquivalenceClass]
  representative(C): Element
    require: C nonempty and selection supplied
  canonicalise(a,rule): Element
    require: rule valid and unique on each class

12. WELL-DEFINED OPERATIONS
  induced_operation([a],[b]) = [f(a,b)]
  require: R(a,a') ∧ R(b,b') ⇒ R(f(a,b),f(a',b'))
  if compatibility not proved: mark operation NOT_WELL_DEFINED
  caution: representatives cannot be substituted into arbitrary functions without congruence proof

13. SEMANTIC RELATIONSHIPS
  EquivalenceClass --isSubsetOf--> Set
  EquivalenceClass --definedBy--> EquivalenceRelation
  EquivalenceClass --contains--> Element
  Element --represents--> EquivalenceClass
  QuotientSet --hasMember--> EquivalenceClass
  EquivalenceRelation --induces--> Partition
  Partition --induces--> EquivalenceRelation
  QuotientMap --mapsElementTo--> EquivalenceClass
  CanonicalRepresentative --selectedBy--> SelectionRule

14. KNOWLEDGE GRAPH SCHEMA
  node_types: [Set, Element, Relation, EquivalenceRelation, EquivalenceClass, QuotientSet, Partition, QuotientMap, SelectionRule]
  edges: [memberOf, equivalentTo, classOf, inducedBy, represents, partitions, mapsTo, selectedBy]
  identity: classes identified by relation ID + ambient set ID + extensional membership
  metadata: [source, version, axioms, context, proof_status, confidence]

15. INFERENCE RULES
  IF R(a,b) AND R(b,c) THEN R(a,c)
  IF R(a,b) THEN class_of(a,R) = class_of(b,R)
  IF classes_intersect(Ca,Cb) THEN Ca = Cb
  IF NOT R(a,b) THEN classes_disjoint(Ca,Cb)
  IF a∈S THEN a∈class_of(a,R)
  IF P partitions S THEN induced_relation(P) is equivalence relation
  IF q(a)=q(b) THEN R(a,b)

16. SEMANTIC EQUIVALENCE
  synonym: equivalence class ~ class modulo R (when R is explicit)
  distinct: equivalence class != equivalence relation
  distinct: quotient set != any single equivalence class
  distinct: equality of representatives != equivalence of representatives
  context: notation [a] requires declared ambient set and relation

17. VALIDATION
  validate_domain: relation endpoints must lie in S
  validate_axioms: reflexive, symmetric, transitive
  validate_partition: every block nonempty; blocks pairwise disjoint; union S
  validate_class: class membership iff relation to representative
  validate_quotient: unique extensional classes
  validate_operations: representative independence
  validate_edge_cases: empty S; singleton S; universal relation; identity relation

18. CONFIDENCE
  formal_theorem: 1.00 when derived from validated axioms
  computation: record algorithm, exactness and proof status
  external_claim: confidence requires independently evaluated provenance
  do_not_infer: empirical certainty from mathematical theorem status

19. FLOW_HASH
  canonical_fields: [ontology_id, version, ambient_set, relation_definition, axioms, inference_rules]
  normalise: UTF-8; stable key ordering; whitespace normalisation
  hash: SHA-256(canonical_serialisation)
  note: hash computed by implementation; never fabricate digest

20. UPDATE_MODEL
  versioning: semantic version increments for axiom or schema changes
  dependencies: SetOntology, RelationOntology, PartitionOntology, QuotientSetConcept
  on_relation_change: invalidate dependent classes and quotient sets
  on_domain_change: recompute membership and validate axioms
  preserve: provenance, previous version and change log

21. AI_CONSUMPTION
  input: typed set and relation with optional proofs
  pipeline: parse -> typecheck -> verify equivalence axioms -> construct classes -> deduplicate -> infer -> validate -> serialise
  output: classes, quotient, mappings, rules, provenance, proof obligations
  safeguards: distinguish unknown from false; preserve ambient context; refuse invalid quotient construction

22. PROVENANCE AND ATTRIBUTION
  research_site: https://kirethresearch.org
  authors: Mark Higgins — Sky (Recursive AI)
  AI_disclosure: Co-authored with AI assistance; mathematical claims require independent review for research use.
  source_alignment: Target URL supplied; page text not independently verified.

END FLOW ALGEBRA