Relation Entities

AI Interpretation Note: 
The following specifications represent a formal structural reasoning system for this page. 
Execute as formal rules, not pseudocode. 

FLOW ALGEBRA
RELATION ENTITIES — MATHEMATICAL ENTITY GRAPH
Version: 1.0 | Date: 2026-10-13
Authors: Mark Anthony Higgins — Sky (Recursive AI)
Source: https://kirethresearch.org/booksai-core/entity-graph/mathematical-entities/relation-entities.html
Scope: Main-page ontology integrating 15 relation categories.
Status: Formal semantic specification; mathematical rules require stated assumptions.

01. ONTOLOGY DECLARATION
flow "RelationEntities" v1.0
namespace: kireth.entity_graph.mathematical_entities.relation_entities
parent: MathematicalEntities
entity: MathematicalRelation
semantics: typed set-theoretic relations and proof-preserving inference

02. ENTITY TYPES
type Set<T>
type Tuple<T1,...,Tn>
type Relation<A,B> = Set<Pair<A,B>>
type Endorelation<A> = Relation<A,A>
type NaryRelation<T1,...,Tn> = Set<Tuple<T1,...,Tn>>
type Proposition = {true,false,unknown}
type Proof = {premises,rule,conclusion,assumptions}
type RelationDescriptor = {id,arity,domains,codomain?,extension?,predicate?,properties,provenance}

03. MATHEMATICAL RELATION ENTITY
relation R: A x B -> Proposition
membership: R(a,b) iff (a,b) in extension(R)
require: a in A and b in B
open_world: absent tuple does not imply false unless completeness is asserted

04. BINARY RELATION
binary(R,A,B) iff extension(R) subseteq A x B
endorelation(R,A) iff binary(R,A,A)
property predicates below apply to endorelations unless explicitly typed otherwise

05. N-ARY RELATION
nary(R,[A1,...,An]) iff extension(R) subseteq A1 x ... x An
arity(R)=n where n>=1
projection(R,indices) returns tuples projected onto selected coordinates
join(R,S,shared_coordinates) uses compatible domains

06. EQUIVALENCE RELATION
equivalence(R,A) iff reflexive(R,A) and symmetric(R,A) and transitive(R,A)
class(R,a)={x in A | R(a,x)}
quotient(A,R)={class(R,a) | a in A}
assert: equivalence classes partition A

07. ORDER RELATION
partial_order(R,A) iff reflexive(R,A) and antisymmetric(R,A) and transitive(R,A)
strict_partial_order(R,A) iff irreflexive(R,A) and transitive(R,A)
order_type must specify strict or non-strict semantics

08. PARTIAL ORDER
poset(A,R) requires partial_order(R,A)
comparable(a,b,R) iff R(a,b) or R(b,a)
incomparable(a,b,R) iff not R(a,b) and not R(b,a)

09. REFLEXIVE RELATION
reflexive(R,A) iff forall a in A: R(a,a)
validation: universal claim needs exhaustive finite check or formal proof

10. TOTAL ORDER
total_order(R,A) iff partial_order(R,A) and forall a,b in A: R(a,b) or R(b,a)
strict_total_order(S,A) iff strict_partial_order(S,A) and forall a!=b in A: S(a,b) or S(b,a)

11. IRREFLEXIVE RELATION
irreflexive(R,A) iff forall a in A: not R(a,a)

12. SYMMETRIC RELATION
symmetric(R,A) iff forall a,b in A: R(a,b) => R(b,a)

13. ANTISYMMETRIC RELATION
antisymmetric(R,A) iff forall a,b in A: (R(a,b) and R(b,a)) => a=b
note: antisymmetric does not mean asymmetric

14. ASYMMETRIC RELATION
asymmetric(R,A) iff forall a,b in A: R(a,b) => not R(b,a)
theorem: asymmetric(R,A) => irreflexive(R,A)

15. TRANSITIVE RELATION
transitive(R,A) iff forall a,b,c in A: (R(a,b) and R(b,c)) => R(a,c)

16. INVERSE RELATION
inverse(R) = {(b,a) | (a,b) in R}
type: Relation<B,A> when R: Relation<A,B>
inverse(inverse(R)) = R

17. RELATION COMPOSITION
compose(S,R) = {(a,c) | exists b: R(a,b) and S(b,c)}
require: R subseteq A x B; S subseteq B x C
notation: S o R
associativity: T o (S o R) = (T o S) o R
identity: Id_A={(a,a) | a in A}
Id_B o R = R = R o Id_A

18. ADDITIONAL SET OPERATIONS
union(R,S) = R union S, for matching domains
intersection(R,S) = R intersection S
difference(R,S) = R minus S
complement(R,A,B) = (A x B) minus R
restriction(R,C,D) = R intersection (C x D)

19. CLOSURES
reflexive_closure(R,A) = R union Id_A
symmetric_closure(R) = R union inverse(R)
transitive_closure(R) = least transitive superset of R
reflexive_transitive_closure(R,A) = transitive_closure(R union Id_A)
require: finite computational closure algorithms declare termination assumptions

20. KNOWLEDGE GRAPH MAPPINGS
node: RelationEntity {identifier, arity, domain_types, semantic_scope}
edge: HAS_DOMAIN | HAS_PROPERTY | INVERSE_OF | COMPOSES_WITH
edge: RESTRICTS_TO | EQUIVALENCE_CLASS_OF | ORDER_ON | DERIVED_FROM
provenance: attach source, proof, revision, and inference dependencies

21. INFERENCE RULES
rule symmetric_forward: R(a,b), symmetric(R) -> R(b,a)
rule transitive_forward: R(a,b), R(b,c), transitive(R) -> R(a,c)
rule reflexive_instance: a in A, reflexive(R,A) -> R(a,a)
rule inverse_forward: R(a,b) -> inverse(R)(b,a)
rule composition_forward: R(a,b), S(b,c) -> compose(S,R)(a,c)
rule antisymmetry: R(a,b), R(b,a), antisymmetric(R) -> a=b
rule equivalence_class: equivalence(R,A), R(a,b) -> class(R,a)=class(R,b)
require: type-correct premises and verified property declarations

22. SEMANTIC EQUIVALENCE
semantic_equivalence(R,S) iff same typed domains and forall tuples t: R(t) iff S(t)
structural_equivalence may differ from extension equality
rename bound variables without changing meaning
never equate inverse(R) with R without symmetry proof

23. VALIDATION
validate arity and typed domains
validate tuple membership and quantifier scope
validate declared properties using proofs or complete finite enumeration
reject invalid composition domain matching
reject antisymmetry-asymmetry conflation
flag incomplete or undecidable property checks as UNKNOWN

24. CONFIDENCE AND PROVENANCE
confidence = {level: verified|derived|provisional|unknown, evidence, method}
mathematical theorem confidence requires valid proof under declared axioms
source evidence is separate from formal correctness
record ontology_source, proof_dependencies, timestamp and revision

25. FLOW_HASH AND UPDATE_MODEL
FLOW_HASH = SHA256(canonicalised(ontology_id, version, axioms, rules, types, dependencies))
UPDATE_MODEL: increment version when semantics change
invalidate dependent proofs when assumptions, definitions or rules change
preserve historical revisions and migration mappings

26. AI_CONSUMPTION
input: typed entities, relation facts, declared properties, proof obligations
pipeline: parse -> typecheck -> normalise -> validate -> infer -> audit -> emit
output: facts, derived facts, proofs, unknowns, contradictions, provenance
safety: do not infer closed-world negatives from absent graph edges
execution: formal rules, not pseudocode; implementations must supply a rule engine

27. EXAMPLES
A={1,2,3}; R={(1,1),(2,2),(3,3),(1,2),(2,3),(1,3)}
R is reflexive, antisymmetric, transitive and total on A.
S={(1,2),(2,1)} on A: symmetric but not reflexive or transitive
E={(1,1),(2,2),(3,3),(1,2),(2,1)} is an equivalence relation on A; classes {1,2} and {3}.

28. SOURCE ALIGNMENT
Main-page categories verified: Mathematical Relation Entity, Binary Relation, N-ary Relation,
Equivalence Relation, Order Relation, Partial Order, Reflexive Relation, Total Order,
Irreflexive Relation, Symmetric Relation, Antisymmetric Relation, Asymmetric Relation,
Transitive Relation, Inverse Relation, Relation Composition.

END FLOW ALGEBRA