Branch Relationship Ontology

FLOW ALGEBRA
Branch Relationship Ontology
Kireth Semantic Library | Structural Relationships
Source: https://kirethresearch.org/booksai-core/ontologies/relationship-ontologies/structural-relationships/branch-relationship-ontology.html
Authors: Mark Anthony Higgins — Sky (Recursive AI)
Specification: Companion formalisation | Version 1.0 | 2026-10-08

AI_INTERPRETATION:
  Treat the following as typed structural constraints and inference rules.
  Distinguish asserted facts from inferred facts; do not treat illustrative examples as evidence.

flow "BranchRelationshipOntology" v1.0

TYPES:
  Node := { id: IRI, label: String?, kind: String? }
  Tree := { id: IRI, root: Node, nodes: Set<Node>, edges: Set<ParentEdge> }
  ParentEdge := { parent: Node, child: Node }
  Branch := { id: IRI, tree: Tree, origin: Node, members: Set<Node> }
  Evidence := { source: IRI, observed_at: DateTime?, method: String? }
  Assertion := { subject: Node, predicate: IRI, object: Node, evidence: Evidence?, confidence: Real }

RELATIONSHIPS:
  parent_of(parent: Node, child: Node, tree: Tree)
  child_of(child: Node, parent: Node, tree: Tree) := parent_of(parent, child, tree)
  ancestor_of(ancestor: Node, descendant: Node, tree: Tree)
  descendant_of(descendant: Node, ancestor: Node, tree: Tree) := ancestor_of(ancestor, descendant, tree)
  branch_origin(branch: Branch, node: Node)
  branch_member(branch: Branch, node: Node)
  sibling_of(left: Node, right: Node, tree: Tree)
  root_of(node: Node, tree: Tree)
  leaf_of(node: Node, tree: Tree)

AXIOMS:
  A1: forall t:Tree, t.root in t.nodes.
  A2: forall t:Tree, forall e in t.edges, e.parent in t.nodes and e.child in t.nodes.
  A3: forall t:Tree, forall n in t.nodes, n != t.root -> exactly_one_parent(n,t).
  A4: forall t:Tree, not exists n in t.nodes: ancestor_of(n,n,t).
  A5: forall t:Tree, forall n in t.nodes, reachable(t.root,n,t).
  A6: forall b:Branch, b.origin in b.tree.nodes and b.origin in b.members.
  A7: forall b:Branch, b.members = {n in b.tree.nodes | n=b.origin or ancestor_of(b.origin,n,b.tree)}.
  A8: forall b:Branch, branch_origin(b,b.origin).
  A9: forall b:Branch, forall n in b.members, branch_member(b,n).

INFERENCE:
  R1: parent_of(p,c,t) -> child_of(c,p,t).
  R2: parent_of(p,c,t) -> ancestor_of(p,c,t).
  R3: ancestor_of(a,b,t) and parent_of(b,c,t) -> ancestor_of(a,c,t).
  R4: parent_of(p,a,t) and parent_of(p,b,t) and a!=b -> sibling_of(a,b,t).
  R5: root_of(r,t) iff r=t.root and not exists p:parent_of(p,r,t).
  R6: leaf_of(n,t) iff n in t.nodes and not exists c:parent_of(n,c,t).
  R7: branch_member(b,n) and parent_of(n,c,b.tree) -> branch_member(b,c).
  R8: branch_member(b,n) and n!=b.origin -> ancestor_of(b.origin,n,b.tree).
  R9: branch_origin(b,o) and ancestor_of(o,n,b.tree) -> branch_member(b,n).
  R10: branch_member(b,n) and branch_member(b,m) -> same_branch(n,m,b) [contextual only].

CONSTRAINTS:
  C1: Branches are rooted subtrees; a branch may be nested inside another branch.
  C2: Branch membership does not imply siblinghood or direct parenthood.
  C3: Parent-child direction is not interchangeable.
  C4: The transitive ancestor relation is distinct from the immediate parent relation.
  C5: In general graphs with multiple parents or cycles, use a graph-branch model instead of Tree.
  C6: Do not infer semantic identity from structural co-membership.

SEMANTIC_EQUIVALENCE:
  exact_equivalence(a,b) requires matching definitions, domain, range, and constraints.
  parent_of(p,c,t) <=> child_of(c,p,t) [inverse relation, not identical predicate].
  branch_member(b,n) <=> n=b.origin or ancestor_of(b.origin,n,b.tree) [within valid Tree].
  related_term("branch", "subtree") := context_dependent; not globally interchangeable.

CONFIDENCE:
  range: [0.0,1.0]
  asserted: use evidence-supported confidence; never default to certainty without justification.
  inferred: min(premise_confidences) * rule_reliability.
  conflicting_assertions: retain provenance and mark unresolved until validated.

VALIDATION:
  V1: unique_node_ids(tree.nodes).
  V2: unique_edge_pairs(tree.edges).
  V3: exactly_one_root(tree).
  V4: acyclic(tree.edges).
  V5: connected_from_root(tree).
  V6: each_non_root_has_one_parent(tree).
  V7: branch_membership_equals_origin_descendants(branch).
  V8: all_referenced_nodes_exist(tree).
  V9: every_derived_assertion_records_rule_and_inputs.
  result := PASS iff all mandatory checks hold; otherwise FAIL with violated constraint IDs.

FLOW_HASH:
  algorithm: SHA-256
  input: canonical_utf8(sorted(types, relationships, axioms, rules, constraints, source_uri, version))
  output: lowercase_hex_digest
  note: Compute on execution; no precomputed digest is asserted here.

UPDATE_MODEL:
  trigger: new_evidence | changed_edge | changed_node | revised_rule | version_change
  procedure:
    1. Record source, timestamp, and change-set.
    2. Revalidate tree and affected branches.
    3. Retract unsupported inferred facts; recompute impacted closures.
    4. Recalculate confidence and preserve evidence lineage.
    5. Recompute FLOW_HASH and publish versioned results.
  invariant: never silently overwrite contradictory evidence.

AI_CONSUMPTION:
  modes: [knowledge_graph, ontology_alignment, hierarchical_reasoning, semantic_search]
  output: {typed_facts, inferred_facts, evidence, confidence, validation_status, flow_hash}
  rules:
    - Preserve parent/child direction and tree context.
    - Distinguish branch roots, members, and leaves.
    - Expose inference provenance and validation failures.
    - Never invent links or infer causality from structural proximity.

END FLOW ALGEBRA