Recursive Dependency Ontology

FLOW ALGEBRA
TITLE: Recursive Dependency Ontology
DOMAIN: Relationship Ontologies / Recursive Relationships
SOURCE: https://kirethresearch.org/booksai-core/ontologies/relationship-ontologies/recursive-relationships/recursive-dependency-ontology.html
VERSION: 1.0
AUTHORS: Mark Anthony Higgins — Sky (Recursive AI)
STATUS: Companion formalisation; source-page specification not independently verified.

flow "RecursiveDependencyOntology" v1.0 {
  ontology:
    id: "recursive-dependency-ontology"
    parent: "recursive-relationships"
    purpose: "Represent recursive dependency structures, their evaluation semantics, cycle handling, termination and provenance."

  types:
    Entity: {id: string, kind: string, version: string?}
    Dependency: {id: string, dependent: string, prerequisite: string, kind: enum[hard, soft, conditional, recursive], condition: string?, confidence: number, evidence: string[]}
    DependencyGraph: {id: string, nodes: string[], edges: string[], directed: bool}
    Evaluation: {id: string, graph: string, strategy: enum[acyclic_order, least_fixed_point, bounded_iteration, guarded_recursion], status: enum[pending, converged, terminated, unresolved, failed], iterations: int, provenance: string[]}
    BaseCase: {entity: string, predicate: string, evidence: string[]}

  predicates:
    depends_on(dependent: Entity, prerequisite: Entity)
    recursively_depends_on(a: Entity, b: Entity)
    has_base_case(entity: Entity, base: BaseCase)
    belongs_to_graph(entity: Entity, graph: DependencyGraph)
    evaluated_by(graph: DependencyGraph, evaluation: Evaluation)
    blocks(prerequisite: Entity, dependent: Entity)

  constraints:
    - "Dependency endpoints must resolve to typed entities."
    - "Dependency direction is dependent -> prerequisite and must remain consistent."
    - "Confidence lies within [0,1]; each asserted edge retains evidence and provenance."
    - "Cycles are permitted only when a declared evaluation strategy handles them."
    - "Recursive evaluation requires a base case, a proven termination argument, or a bounded/fixed-point strategy."
    - "A dependency path does not imply that every edge is a hard blocking dependency."
    - "Do not infer causality, temporal order or semantic identity from dependency alone."

  inference:
    rule dependency_reachability:
      if depends_on(a,b) and depends_on(b,c)
      then indirectly_depends_on(a,c)
      condition: "preserve edge kinds and conditions; do not promote to direct dependency"
    rule recursive_cycle:
      if reachable(a,a) and path_length(a,a) > 0
      then recursive_dependency_detected(a)
      condition: "report strongly connected component and participating edges"
    rule blocking_dependency:
      if depends_on(a,b) and edge_kind(a,b) == hard and unavailable(b)
      then blocked(a)
      condition: "only where the hard dependency is active"
    rule fixed_point:
      if monotone_operator(graph) and complete_lattice(domain(graph))
      then least_fixed_point_exists(graph)
      condition: "existence does not guarantee finite convergence"

  SEMANTIC_EQUIVALENCE:
    - "Normalise dependency predicates using a versioned vocabulary."
    - "Distinguish direct, indirect, conditional and recursive dependencies."
    - "Never collapse dependency equivalence into entity identity."

  CONFIDENCE:
    range: [0,1]
    factors: [evidence_quality, edge_validity, condition_satisfaction, model_assumptions, source_reliability]
    policy: "Preserve uncertainty along paths; do not inflate confidence by repeated recursion."

  VALIDATION:
    - "Check endpoint resolution, edge direction, predicate type and evidence."
    - "Detect strongly connected components and classify supported versus unsupported recursion."
    - "Verify base cases, guards, convergence criteria, iteration bounds and stopping rules."
    - "Reject unsupported claims of termination or finite convergence."
    - "Retain counterexamples and contradictory dependency assertions."

  FLOW_HASH:
    algorithm: "SHA-256"
    input: "canonicalised ontology version, typed graph, rules and provenance"
    note: "Compute at execution; no hash value is claimed here."

  UPDATE_MODEL:
    strategy: "versioned, provenance-preserving incremental update"
    steps: [ingest, normalise, validate, identify_affected_components, re_evaluate_cycles, recompute_fixed_points, publish]
    rollback: true

  AI_CONSUMPTION:
    representation: "typed directed dependency graph with recursive evaluation metadata"
    outputs: [dependency_edges, recursive_components, blocking_paths, evaluation_status, confidence_annotations, provenance_records]
    safeguards: [cycle_awareness, bounded_evaluation, no_unsupported_transitivity, no_unjustified_termination_claims]
}

END FLOW ALGEBRA