Parent Relationship Ontology

FLOW ALGEBRA
ONTOLOGY: Parent Relationship Ontology
SOURCE: https://kirethresearch.org/booksai-core/ontologies/relationship-ontologies/structural-relationships/parent-relationship-ontology.html
VERSION: 1.0
AUTHORS: Mark Anthony Higgins — Sky (Recursive AI)

PURPOSE
Formalise direct parent-to-child structural relationships within taxonomies, trees, ontologies, document hierarchies and knowledge graphs. This specification is a companion model, not a verbatim transcription of the source page.

TYPES
Entity := {id: IRI, type: Class, label: String, metadata: Map}
ParentEdge := {parent: Entity, child: Entity, context: IRI, provenance: Evidence, confidence: Real[0,1]}
Hierarchy := {nodes: Set[Entity], edges: Set[ParentEdge], root: Entity?}
Evidence := {source: IRI?, method: String, observed_at: DateTime?}

RELATIONSHIPS
PARENT_OF(p,c) := direct structural parent of c is p
CHILD_OF(c,p) := inverse(PARENT_OF(p,c))
ANCESTOR_OF(p,c) := transitive_closure(PARENT_OF)(p,c)
DESCENDANT_OF(c,p) := inverse(ANCESTOR_OF(p,c))
SIBLING_OF(a,b) := exists p: PARENT_OF(p,a) and PARENT_OF(p,b) and a != b
ROOT_OF(r,h) := r in h.nodes and not exists p: PARENT_OF(p,r) within h

TYPE_CONSTRAINTS
forall p,c: PARENT_OF(p,c) => Entity(p) and Entity(c)
forall p,c: PARENT_OF(p,c) => p != c
forall p,c: PARENT_OF(p,c) => CHILD_OF(c,p)
forall p,c: PARENT_OF(p,c) => ANCESTOR_OF(p,c)
forall p,c: PARENT_OF(p,c) => not ANCESTOR_OF(c,p)  # acyclic hierarchical profile

CARDINALITY
TREE_PROFILE: each non-root child has exactly one direct parent per hierarchy context.
DAG_PROFILE: each child may have multiple direct parents; cycles remain forbidden.
GENERAL_GRAPH_PROFILE: cycles may be permitted only with explicit alternative semantics; do not infer a tree.

INFERENCE
PARENT_OF(a,b) and PARENT_OF(b,c) => ANCESTOR_OF(a,c)
PARENT_OF(a,b) and PARENT_OF(a,c) and b != c => SIBLING_OF(b,c)
PARENT_OF(a,b) does not imply PARENT_OF(b,a)
ANCESTOR_OF(a,c) does not imply PARENT_OF(a,c)
PARENT_OF(a,b) does not automatically imply subclass, ownership, causation or biological parentage.

SEMANTIC_EQUIVALENCE
PARENT_OF(p,c) <=> CHILD_OF(c,p) [inverse relation, same context]
PARENT_OF != ANCESTOR_OF [direct versus transitive]
PARENT_OF != PART_OF [hierarchy versus mereology]
PARENT_OF != SUBCLASS_OF [structural versus taxonomic entailment unless explicitly mapped]

CONFIDENCE
confidence(edge) in [0,1]
confidence(inferred_relation) <= min(confidence(premises))
confidence is evidence strength, not a substitute for logical validity.

VALIDATION
CHECK identifiers are unique and resolvable where required.
CHECK endpoints exist in the declared hierarchy.
CHECK no self-parent edge.
CHECK no directed cycles in TREE_PROFILE or DAG_PROFILE.
CHECK parent cardinality in TREE_PROFILE.
CHECK root reachability where a connected rooted tree is asserted.
CHECK context and provenance are retained across inference.
CHECK inferred edges are distinguished from asserted edges.

FLOW_HASH
canonical_payload := canonical_sort(nodes, edges, context, rules, version)
flow_hash := SHA256(UTF8(canonical_payload))
# Recompute on semantic updates; exclude volatile runtime timestamps unless intentionally versioned.

UPDATE_MODEL
on ADD_EDGE(p,c): validate_types; validate_profile; recompute_closure; recompute_flow_hash
on REMOVE_EDGE(p,c): retract_unsupported_inferences; validate_reachability; recompute_flow_hash
on CHANGE_CONTEXT: isolate_contextual_edges; rerun_validation; recompute_flow_hash
on EVIDENCE_UPDATE: refresh_confidence; record_provenance; recompute_flow_hash

AI_CONSUMPTION
input: hierarchy entities, asserted parent edges, contexts, evidence
process: normalise -> type_check -> validate -> infer -> score -> hash
output: direct_parent_links, ancestor_paths, sibling_sets, validation_report, provenance, flow_hash
policy: preserve directionality, distinguish asserted from inferred, do not invent missing parents.

END FLOW ALGEBRA