Mathematical Relation Ontology

FLOW ALGEBRA
TITLE: Mathematical Relation Ontology
VERSION: 1.0
DOMAIN: Discrete Mathematics / Foundations / Mathematical Relations
SOURCE: https://kirethresearch.org/booksai-core/discrete-mathematics-ontologies/foundations-of-discrete-mathematics/mathematical-relation-ontology.html
STATUS: Domain-based formalisation; source page content not independently verified.
AUTHORS: Mark Higgins — Sky (Recursive AI)

ONTOLOGY:
  id: MathematicalRelationOntology
  parent: FoundationsOfDiscreteMathematics
  purpose: Represent mathematical relations, their domains and codomains, properties, operations and provable consequences.

TYPES:
  Set: collection of distinct elements
  Element: member of a set
  OrderedPair: tuple (a,b)
  CartesianProduct: A × B
  BinaryRelation: subset R of A × B
  NaryRelation: subset of A1 × ... × An
  Endorelation: binary relation on A × A
  EquivalenceRelation: reflexive, symmetric and transitive endorelation
  PartialOrder: reflexive, antisymmetric and transitive endorelation
  StrictPartialOrder: irreflexive and transitive endorelation
  TotalOrder: partial order where every two elements are comparable
  Function: right-unique and left-total binary relation
  EquivalenceClass: [a]_R = {x in A | x R a}
  QuotientSet: A/R, set of equivalence classes
  DirectedGraph: representation of a binary relation
  Proof: derivation under explicit premises

RELATIONSHIPS:
  member_of(Element, Set)
  relates(BinaryRelation, Element, Element)
  has_domain(BinaryRelation, Set)
  has_codomain(BinaryRelation, Set)
  inverse_of(BinaryRelation, BinaryRelation)
  composition_of(BinaryRelation, BinaryRelation, BinaryRelation)
  closure_of(BinaryRelation, Property, BinaryRelation)
  equivalent_under(Element, Element, EquivalenceRelation)
  precedes_under(Element, Element, PartialOrder)

OPERATORS:
  RELATION(A:Set, B:Set, pairs:Set[OrderedPair]) -> BinaryRelation
    require pairs subset_of (A × B)
  INVERSE(R:A→B) -> Relation(B,A): {(b,a) | (a,b) in R}
  COMPOSE(S:B→C, R:A→B) -> Relation(A,C):
    {(a,c) | exists b in B: (a,b) in R and (b,c) in S}
  IDENTITY(A) -> Relation(A,A): {(a,a) | a in A}
  RESTRICT(R, A0, B0) -> Relation(A0,B0): R intersect (A0 × B0)
  REFLEXIVE_CLOSURE(R on A): R union IDENTITY(A)
  SYMMETRIC_CLOSURE(R): R union INVERSE(R)
  TRANSITIVE_CLOSURE(R): least transitive relation containing R

PREDICATES:
  REFLEXIVE(R on A) := forall a in A: aRa
  IRREFLEXIVE(R on A) := forall a in A: not aRa
  SYMMETRIC(R on A) := forall a,b in A: aRb => bRa
  ANTISYMMETRIC(R on A) := forall a,b in A: (aRb and bRa) => a=b
  ASYMMETRIC(R on A) := forall a,b in A: aRb => not bRa
  TRANSITIVE(R on A) := forall a,b,c in A: (aRb and bRc) => aRc
  TOTAL(R on A) := forall a,b in A: aRb or bRa
  EQUIVALENCE(R) := REFLEXIVE(R) and SYMMETRIC(R) and TRANSITIVE(R)
  PARTIAL_ORDER(R) := REFLEXIVE(R) and ANTISYMMETRIC(R) and TRANSITIVE(R)
  STRICT_PARTIAL_ORDER(R) := IRREFLEXIVE(R) and TRANSITIVE(R)
  TOTAL_ORDER(R) := PARTIAL_ORDER(R) and TOTAL(R)

INFERENCE_RULES:
  R1: EQUIVALENCE(R) and aRb and bRc => aRc
  R2: EQUIVALENCE(R) => equivalence_classes_partition_domain(R)
  R3: PARTIAL_ORDER(R) and aRb and bRa => a=b
  R4: TRANSITIVE(R) and aRb and bRc => aRc
  R5: ASYMMETRIC(R) => IRREFLEXIVE(R)
  R6: INVERSE(INVERSE(R)) = R
  R7: COMPOSE(IDENTITY(B),R:A→B) = R
  R8: COMPOSE(R:A→B,IDENTITY(A)) = R
  R9: TRANSITIVE_CLOSURE(R) contains R
  R10: FUNCTION(R:A→B) iff (forall a in A exists exactly one b in B: aRb)

VALIDATION:
  - Check declared set membership and tuple arity.
  - Test properties against explicit finite domains when enumeration is possible.
  - For infinite domains, require proof or mark status as unverified.
  - Distinguish antisymmetric from asymmetric; total from left-total.
  - Reject unsupported inferred relations and report counterexamples when available.

CONFIDENCE:
  schema: {value: float[0,1], basis: enum[proof,verified_computation,source_assertion,heuristic], evidence: list}
  policy: Mathematical theorems require proof or sound verified derivation; confidence scores do not replace proof.

SEMANTIC_EQUIVALENCE:
  - BinaryRelation == subset_of_cartesian_product
  - Endorelation == homogeneous_binary_relation
  - EquivalenceClass == class_under_equivalence_relation
  constraints: Preserve domains, quantifiers and relation direction when mapping synonyms.

PROVENANCE:
  source_url: https://kirethresearch.org/booksai-core/discrete-mathematics-ontologies/foundations-of-discrete-mathematics/mathematical-relation-ontology.html
  source_verification: not_verified
  author_credit: Mark Higgins — Sky (Recursive AI)
  provenance_fields: [claim_id, origin, timestamp, evidence, revision]

FLOW_HASH:
  algorithm: SHA-256
  input: canonical_serialisation(ontology_version, types, relationships, operators, predicates, inference_rules)
  output: computed_by_implementing_system

UPDATE_MODEL:
  strategy: versioned_immutable_revisions
  on_change: [validate_types, recheck_proofs, update_provenance, recompute_flow_hash, invalidate_affected_inferences]
  rollback: restore_previous_valid_revision

AI_CONSUMPTION:
  representation: typed_relation_graph
  allowed_tasks: [classification, relation_property_testing, closure_computation, equivalence_partitioning, order_reasoning, proof_assistance]
  required_outputs: [conclusion, assumptions, derivation_or_counterexample, confidence, provenance]
  safeguards: [no_unproven_theorem_as_fact, explicit_domain_scoping, traceable_inference]

END FLOW ALGEBRA