Recursive Reasoning Relationship Ontology

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

flow "RecursiveReasoningRelationshipOntology" v1.0 {
  ontology:
    id: "recursive-reasoning-relationship-ontology"
    parent: "ai-reasoning-relationships"
    purpose: "Represent recursive inference, self-referential reasoning dependencies, iterative refinement and their evidence-backed termination conditions."

  types:
    Proposition: {id: string, statement: string, context: string?, provenance: string}
    ReasoningStep: {id: string, rule_id: string, premises: string[], conclusion: string, iteration: integer, evidence: string[], confidence: number}
    ReasoningGraph: {id: string, nodes: string[], edges: string[], version: string}
    RecursiveRule: {id: string, base_case: string, recursive_case: string, termination_test: string, monotonic: boolean}
    EvaluationState: {id: string, iteration: integer, known_facts: string[], pending: string[], status: enum[pending, running, converged, terminated, failed]}
    Evidence: {id: string, source: string, reliability: number, timestamp: datetime?}
    Relationship: {id: string, subject: string, predicate: string, object: string, confidence: number, provenance: string[]}

  predicates:
    depends_on(step: ReasoningStep, premise: Proposition)
    derives(step: ReasoningStep, conclusion: Proposition)
    recursively_invokes(rule: RecursiveRule, rule: RecursiveRule)
    refines(step: ReasoningStep, earlier_step: ReasoningStep)
    supported_by(proposition: Proposition, evidence: Evidence)
    revisits(step: ReasoningStep, proposition: Proposition)
    terminates_at(rule: RecursiveRule, state: EvaluationState)

  constraints:
    - "Every inference step must cite a rule and resolvable premises."
    - "Confidence values must lie within [0,1]."
    - "A recursive rule must specify a base case or explicit fixed-point semantics."
    - "Recursive cycles are permitted only under defined evaluation and termination policies."
    - "A cycle is not independent corroboration of its own conclusion."
    - "Set iteration, depth, memory and time limits to prevent unbounded execution."
    - "Distinguish deductive entailment from heuristic refinement and hypothesis generation."
    - "Non-monotonic updates require retraction or recomputation of affected conclusions."

  inference:
    rule base_case:
      if satisfied(rule.base_case, state)
      then mark_derived(base_conclusion(rule), state)
      confidence: "grounded in base-case evidence"
    rule recursive_expansion:
      if applicable(rule.recursive_case, state) and within_limits(state)
      then apply_rule_once(rule, state)
      confidence: "propagate calibrated uncertainty without circular amplification"
    rule fixed_point:
      if canonical_facts(state_next) == canonical_facts(state_current)
      then mark_converged(state_next)
      confidence: "convergence does not establish truth independently"
    rule dependency_trace:
      if derives(step, proposition) and depends_on(step, premise)
      then record_dependency(proposition, premise, step)
      confidence: "retain step-level evidence"

  SEMANTIC_EQUIVALENCE:
    - "Normalise proposition identifiers only within compatible scopes and contexts."
    - "Distinguish repeated assertions, equivalent propositions and independently supported claims."
    - "Preserve rule versions, variable bindings and inference context."

  CONFIDENCE:
    range: [0,1]
    factors: [premise_quality, rule_validity, evidence_independence, recursion_depth, model_uncertainty, contradiction_status]
    policy: "Do not inflate confidence through repeated recursive traversal of the same evidence."

  VALIDATION:
    - "Check graph references, rule typing, premise availability and provenance."
    - "Detect unproductive cycles, unsupported base cases and non-terminating paths."
    - "Verify convergence or record bounded termination without convergence."
    - "Re-evaluate dependent conclusions when source facts or rules change."
    - "Flag contradictions and retain competing hypotheses where unresolved."

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

  UPDATE_MODEL:
    strategy: "versioned incremental truth maintenance"
    steps: [ingest, normalise, validate, identify_dependencies, invalidate_affected_inferences, recompute_to_fixed_point, audit, publish]
    rollback: true

  AI_CONSUMPTION:
    representation: "typed reasoning dependency graph with bounded recursive evaluation"
    outputs: [inference_traces, derived_assertions, dependency_paths, confidence_annotations, convergence_status, provenance_records]
    safeguards: [bounded_recursion, no_circular_evidence_inflation, contradiction_checks, versioned_rules, transparent_uncertainty]
}

END FLOW ALGEBRA