Irreflexive Relation Ontology

FLOW ALGEBRA
IRREFLEXIVE RELATION ONTOLOGY
Kireth Semantic Library | Entity Graph > Mathematical Entities > Relation Entities
Source: https://kirethresearch.org/booksai-core/entity-graph/mathematical-entities/relation-entities/irreflexive-relation-ontology.html
Authors: Mark Higgins — Sky (Recursive AI)
Version: 1.0 | Date: 2026-10-13 | Locale: en-GB
Status: Formal mathematical specification based on standard relation theory; source-page content not independently verified.

01. PURPOSE
flow "IrreflexiveRelationOntology" v1.0
  objective: represent, validate and reason over binary relations with no self-related elements.
  domain: set_theory / relation_theory / knowledge_representation
  distinction: irreflexivity is stronger than merely not being reflexive.

02. TYPES
  type Set[T]
  type Element[T]
  type Pair[T] = (T,T)
  type Relation[T] = Set[Pair[T]]
  type TruthValue = {true,false,unknown}
  type Evidence = {proof,counterexample,assertion,observation}
  type DomainPolicy = {closed_world,open_world}

03. ENTITY SCHEMA
  entity RelationEntity[T]:
    id: URI
    carrier: Set[T]
    ordered_pairs: Relation[T]
    arity: 2
    irreflexive_status: TruthValue
    domain_policy: DomainPolicy
    evidence: Evidence?
    provenance: URI?
    version: string
  invariant: ordered_pairs subset_of carrier x carrier

04. FORMAL DEFINITION
  is_irreflexive(R,A) := forall x in A: (x,x) not_in R
  equivalent: R intersection Delta(A) = empty_set
  where Delta(A) := {(x,x) | x in A}
  equivalent: forall x in A: not R(x,x)
  note: carrier A must be explicit; missing pair data alone is not proof under open-world semantics.

05. CLASSIFICATION
  irreflexive: no diagonal pair belongs to R
  reflexive: every diagonal pair belongs to R
  non_reflexive: at least one diagonal pair is absent
  non_irreflexive: at least one diagonal pair is present
  empty_carrier: empty relation is both reflexive and irreflexive vacuously
  nonempty_carrier: no relation can be both reflexive and irreflexive

06. CANONICAL EXAMPLES
  less_than on real_numbers: irreflexive
  proper_subset on sets: irreflexive
  strict_precedence on events: irreflexive
  not_equal on any carrier: irreflexive
  less_than_or_equal on nonempty ordered sets: not irreflexive
  identity_relation on nonempty sets: not irreflexive
  empty_relation on any set: irreflexive

07. FINITE VALIDATION
  validate(R,A):
    require all (u,v) in R satisfy u in A and v in A
    for x in A:
      if (x,x) in R: return {status:false,witness:x}
    return {status:true,certificate:"all diagonal pairs absent"}
  complexity: O(|A| + |R|) expected with hash-set membership
  caution: enumerating an infinite carrier requires symbolic proof, not finite iteration.

08. OPEN-WORLD REASONING
  if exists x with proven R(x,x): status=false
  else if all diagonal pairs proven absent: status=true
  else: status=unknown
  missing_triples_do_not_imply_false: true
  closed_world_assumption: may justify absence only when explicitly declared and complete

09. CORE INFERENCE RULES
  IR1: irreflexive(R,A) => forall x in A: not R(x,x)
  IR2: R(x,x) => not irreflexive(R,A) when x in A
  IR3: R subset_of S and irreflexive(S,A) => irreflexive(R,A)
  IR4: irreflexive(R,A) => irreflexive(inverse(R),A)
  IR5: irreflexive(R,A) => irreflexive(R intersection S,A)
  IR6: irreflexive(R,A) and irreflexive(S,A) => irreflexive(R union S,A)
  IR7: asymmetric(R,A) => irreflexive(R,A)
  IR8: transitive(R,A) and irreflexive(R,A) => asymmetric(R,A)
  IR9: irreflexive(R,A) does_not_imply asymmetric(R,A)
  IR10: irreflexive(R,A) does_not_imply transitive(R,A)

10. RELATION ALGEBRA
  diagonal Delta(A) = {(x,x) | x in A}
  irreflexive_part(R) = R minus Delta(A)
  inverse(R) = {(y,x) | (x,y) in R}
  complement(R) = (A x A) minus R
  complement_of_irreflexive_relation_is_reflexive: true
  composition_may_break_irreflexivity: true
  example: R={(a,b),(b,a)}; (a,a) in R compose R
  transitive_closure_may_break_irreflexivity: true
  example: directed cycle creates a diagonal pair in transitive closure

11. GRAPH INTERPRETATION
  carrier_elements -> graph_vertices
  ordered_pairs -> directed_edges
  irreflexive <=> no self-loops
  bidirectional_edges_allowed: true
  cycles_of_length_greater_than_one_allowed: true
  simple_digraph_no_loops: compatible

12. MATRIX INTERPRETATION
  finite_carrier A={a1,...,an}
  adjacency_matrix M[i,j] := 1 iff (ai,aj) in R
  irreflexive <=> forall i: M[i,i]=0
  trace(M)=0 is equivalent for Boolean adjacency matrices

13. KNOWLEDGE GRAPH
  node: IrreflexiveRelation
  is_a: BinaryRelationProperty
  applies_to: BinaryRelation
  has_carrier: Set
  excludes_pair: DiagonalPair
  implies: NoSelfLoop
  implied_by: AsymmetricRelation
  related_to: StrictOrder, DirectedGraph, ReflexiveRelation, RelationComplement
  contrast_with: ReflexiveRelation, NonReflexiveRelation
  evidence_link: ProofOrCounterexample

14. SEMANTIC EQUIVALENCE
  "irreflexive relation" == "anti-reflexive relation" in standard relation-theory usage
  "no element relates to itself" == forall x in A: not R(x,x)
  "not reflexive" != "irreflexive" in general
  "asymmetric" != "irreflexive" in general
  normalise: carrier, predicate, direction, domain_policy, quantifier_scope

15. TYPE AND DOMAIN CONSTRAINTS
  require relation_arity == 2
  require pair_coordinates belong_to carrier
  require carrier_scope stable throughout proof
  forbid infer_irreflexive_from_missing_edges when domain_policy=open_world
  reject untyped cross-domain comparisons without an explicit coercion

16. COUNTEREXAMPLES
  R={(a,a)} on A={a,b}: not_irreflexive; witness=a
  R={(a,b),(b,a)} on A={a,b}: irreflexive but not asymmetric
  R={(a,b),(b,c)} on A={a,b,c}: irreflexive but not transitive
  R={(a,b),(b,a)}: transitive_closure not irreflexive

17. PROOF OBLIGATIONS
  PO1: carrier and pair-set well-formed
  PO2: diagonal exclusion established for all carrier elements
  PO3: quantified domain not silently narrowed
  PO4: open-world incompleteness handled as unknown
  PO5: transformation rules preserve stated assumptions

18. VALIDATION CASES
  case empty_relation_nonempty_carrier: expect true
  case empty_relation_empty_carrier: expect true
  case strict_less_than_integers: expect true
  case identity_nonempty_carrier: expect false
  case bidirectional_nonloop_edges: expect true
  case open_world_missing_self_edge_without_completeness: expect unknown

19. CONFIDENCE
  confidence.status: proven | refuted | unknown
  confidence.method: deductive_proof | exhaustive_finite_check | counterexample | asserted
  confidence.score: optional calibrated estimate; never substitute for proof
  confidence.evidence: required for status=proven or refuted

20. FLOW HASH
  canonical_payload: normalised(type,carrier,ordered_pairs,domain_policy,version)
  FLOW_HASH: SHA-256(canonical_payload)
  note: hash is computed by implementation; no fabricated hash value.

21. UPDATE MODEL
  on_add_pair(x,x): invalidate proven_irreflexive; set false
  on_remove_pair(x,x): recompute; do not assume true under open-world semantics
  on_carrier_change: revalidate all constraints
  on_relation_revision: increment version; retain provenance
  on_proof_change: refresh confidence and dependent inferences

22. AI CONSUMPTION
  output_schema:
    ontology: IrreflexiveRelationOntology
    carrier_id: URI
    relation_id: URI
    status: true | false | unknown
    witness: Element? 
    proof: string?
    assumptions: list[string]
    provenance: URI?
    flow_hash: string?
  reasoning_priority: formal proofs > complete finite checks > unverified assertions
  hallucination_guard: never assert universal absence from incomplete samples

23. CROSS-ONTOLOGY LINKS
  BinaryRelationOntology: parent_relation_type
  ReflexiveRelationOntology: contrast
  AsymmetricRelationOntology: stronger_property
  TransitiveRelationOntology: combination_yields_asymmetry
  PartialOrderOntology: non-strict order contrast
  TotalOrderOntology: strict-order connection
  SetOntology: carrier and membership semantics
  MathematicalStatementOntology: universal negation

24. EXECUTION SUMMARY
  INPUT: carrier A, binary relation R, completeness metadata
  CHECK: pair typing and diagonal membership
  INFER: true / false / unknown with evidence
  EMIT: graph facts, validated statements, version and flow hash
  GUARANTEE: no unsupported inference of irreflexivity from missing data

END FLOW ALGEBRA