Recursive Metadata Ontology

FLOW ALGEBRA

Ontology: Recursive Metadata Ontology
Domain: Metadata Ontologies > AI Semantic Library Metadata
Canonical URL: https://kirethresearch.org/booksai-core/ontologies/metadata-ontologies/ai-semantic-library-metadata/recursive-metadata-ontology.html
Authors: Mark Anthony Higgins — Sky (Recursive AI)

flow "RecursiveMetadataOntology" v1.0

# ---------- DOMAIN ----------
domain:
  class: MetadataOntology
  category: AISemanticLibraryMetadata
  subject: RecursiveMetadata
  purpose:
    - represent recursive semantic processes, traversal state, depth, cycles, stopping conditions, and provenance
    - support recursive AI reasoning, ontology traversal, graph exploration, recursive Flow Algebra, and semantic discovery
    - preserve recursion identity, entry state, visited state, parent-child recursion, confidence, termination, and provenance
    - distinguish recursion from repetition, iteration, hierarchy, graph cycles, and uncontrolled looping

# ---------- CORE ----------
entity RecursiveMetadata:
  type: SemanticLibraryMetadata
  describes: RecursiveSemanticProcess
  may_include:
    - recursion_identifier
    - starting_resource
    - current_resource
    - parent_state
    - child_states
    - recursion_depth
    - maximum_depth
    - visited_state
    - traversal_path
    - recursive_relationship
    - stopping_condition
    - cycle_policy
    - termination_state
    - confidence
    - validity
    - provenance

entity RecursiveSemanticProcess:
  type: AIReasoningProcess

entity RecursionIdentifier:
  type: PersistentIdentifier
  identifies: RecursiveSemanticProcess

relationships:
  RecursiveMetadata -> DESCRIBES -> RecursiveSemanticProcess
  RecursiveSemanticProcess -> IDENTIFIED_BY -> RecursionIdentifier
  RecursiveSemanticProcess -> STARTS_AT -> SemanticResource
  RecursiveSemanticProcess -> MAY_TRAVERSE -> SemanticRelationship
  RecursiveSemanticProcess -> MAY_VISIT -> SemanticResource
  RecursiveSemanticProcess -> MAY_CREATE -> RecursiveState
  RecursiveState -> MAY_HAVE_PARENT -> RecursiveState
  RecursiveState -> MAY_HAVE_CHILD -> RecursiveState
  RecursiveSemanticProcess -> GOVERNED_BY -> RecursionPolicy
  RecursiveSemanticProcess -> TERMINATES_BY -> StoppingCondition
  RecursiveMetadata -> MAY_HAVE_PROVENANCE -> RecursiveProvenance

# ---------- STATE / DEPTH ----------
entity RecursiveState:
  type: StateMetadata
  may_include:
    - state_identifier
    - resource
    - depth
    - parent_state
    - child_states
    - incoming_relationship
    - context
    - confidence
    - status

rule state:
  recursive state SHOULD preserve depth and parent context

rule child_depth:
  child depth = parent depth + 1
  unless traversal model defines another depth function

rule maximum_depth:
  IF maximum depth is reached
  THEN expansion MUST stop for that branch

# ---------- VISITED STATE / PATH ----------
entity VisitedState:
  type: TraversalMetadata
  may_include:
    - visited_resources
    - visited_relationships
    - visited_states
    - visit_count

rule visited:
  preserve visited state where cycles or repeated expansion are possible

rule revisit:
  revisiting resource != necessarily cycle
  when context or traversal state differs

entity RecursiveTraversalPath:
  type: PathMetadata
  may_include:
    - ordered_resources
    - ordered_relationships
    - path_length
    - branch_identifier

rule path:
  traversal path SHOULD preserve resource and relationship order

rule path_identity:
  same endpoint != same traversal path

# ---------- RECURSIVE RELATIONSHIP ----------
entity RecursiveRelationship:
  type: SemanticRelationship
  may_include:
    - source
    - predicate
    - target
    - direction
    - recursive_state
    - confidence

rule relationship:
  recursive traversal MUST preserve relationship direction

rule inverse:
  recursive traversal MUST NOT reverse relationship
  unless inverse semantics explicitly permit

# ---------- RECURSION TYPES ----------
recursion_types:
  - direct_recursion
  - indirect_recursion
  - mutual_recursion
  - hierarchical_recursion
  - graph_recursion
  - semantic_recursion
  - query_recursion
  - flow_recursion
  - metadata_recursion

rule hierarchy:
  hierarchy traversal != recursion automatically
  unless repeated application of traversal rule occurs

rule graph:
  graph cycle != uncontrolled recursion
  when visited-state and cycle policy are enforced

rule semantic:
  recursive semantic inference SHOULD preserve distinction
  between asserted and inferred knowledge

rule flow_recursion:
  recursive Flow Algebra MUST define cycle or termination behaviour

# ---------- POLICY / STOPPING ----------
entity RecursionPolicy:
  type: PolicyMetadata
  may_include:
    - allowed_relationships
    - maximum_depth
    - maximum_visits
    - maximum_branches
    - timeout
    - stopping_conditions
    - cycle_policy
    - pruning_policy

entity StoppingCondition:
  type: ConstraintMetadata
  may_include:
    - maximum_depth
    - target_found
    - no_new_resources
    - confidence_threshold
    - time_limit
    - visit_limit
    - branch_limit
    - explicit_stop
    - error_state

rule stopping:
  recursive process MUST have finite stopping behaviour
  where uncontrolled recursion is possible

# ---------- CYCLES ----------
entity RecursiveCycle:
  type: TraversalMetadata
  may_include:
    - repeated_resource
    - repeated_state
    - cycle_path
    - detection_time
    - cycle_type

cycle_types:
  - resource_cycle
  - relationship_cycle
  - state_cycle
  - dependency_cycle
  - semantic_cycle

rule cycle:
  cycle detection SHOULD preserve repeated state and path

rule cycle_loop:
  detected cycle != infinite loop
  when cycle policy terminates or prunes traversal

entity CyclePolicy:
  type: PolicyMetadata
  may_be:
    - stop_branch
    - skip_repeated_state
    - allow_limited_revisit
    - collapse_cycle
    - report_cycle

# ---------- PRUNING / BRANCHING ----------
entity RecursivePruning:
  type: ReasoningMetadata
  may_include:
    - branch
    - pruning_reason
    - threshold
    - policy
    - prune_time

rule pruning:
  pruned branch != disproven branch

entity RecursiveBranch:
  type: TraversalMetadata
  may_include:
    - branch_identifier
    - parent_state
    - child_states
    - branch_depth
    - branch_status

rule branch:
  recursive process MAY produce multiple valid branches

# ---------- CONTEXT / CONFIDENCE ----------
entity RecursiveContextPropagation:
  type: ContextMetadata
  may_include:
    - inherited_context
    - local_context
    - overridden_context
    - derived_context

rule context:
  child state MAY inherit parent context
  but local context MAY constrain or override it

entity RecursiveConfidence:
  type: EpistemicMetadata
  range: [0.0, 1.0]
  may_include:
    - parent_confidence
    - relationship_confidence
    - local_confidence
    - derived_confidence

rule confidence_bounds:
  REQUIRE 0.0 <= confidence <= 1.0

rule confidence_growth:
  recursion depth MUST NOT automatically increase confidence

# ---------- PROVENANCE / VALIDITY ----------
entity RecursiveProvenance:
  type: ProvenanceMetadata
  may_include:
    - recursion_identifier
    - starting_resource
    - visited_resources
    - traversed_relationships
    - traversal_path
    - derived_states
    - inference_events
    - pruning_events
    - termination_event

rule provenance:
  recursive reasoning SHOULD preserve traversal
  and derivation history

entity RecursiveValidity:
  type: ValidityMetadata
  may_include:
    - valid_from
    - valid_until
    - dependency_state
    - policy_version
    - traversal_state

# ---------- VALIDATION ----------
validation:
  require:
    - identifiable_recursive_process
    - starting_state
    - stopping_or_cycle_control

  reject:
    - hierarchy_presented_as recursion_without repeated_rule
    - repeated_resource_presented_as cycle_without state_context
    - cycle_presented_as infinite_loop_without execution_evidence
    - child_state_presented_as parent_state
    - traversal_relationship_direction_reversed_without inverse_semantics
    - recursion_depth_presented_as confidence
    - pruned_branch_presented_as disproven_branch
    - recursive_inference_presented_as explicit_assertion
    - recursion_without stopping_or_cycle_control_where unbounded

# ---------- SEMANTIC EQUIVALENCE ----------
SEMANTIC_EQUIVALENCE:
  "recursive metadata" ~= "metadata describing recursive semantic processes and traversal state"
  "semantic recursion" ~= "recursive application of semantic reasoning or traversal rules"
  "recursive traversal" ~= "repeated traversal of related semantic resources according to a recursion rule"
  "recursion depth" ~= "level of recursive expansions from an entry state"
  "cycle detection" ~= "identification of repeated resource or semantic state within recursive traversal"
  "recursive provenance" ~= "provenance describing recursive traversal and derivation history"

  PRESERVE distinctions:
    recursion != repetition
    recursion != simple_iteration
    hierarchy != recursion
    graph_cycle != infinite_loop
    repeated_resource != repeated_state
    parent_state != child_state
    recursion_depth != confidence
    traversal_path != endpoint
    pruning != disproof
    asserted_knowledge != recursive_inference
    cycle_detection != cycle_failure
    stopping_condition != error_condition

# ---------- CONFIDENCE MODEL ----------
CONFIDENCE:
  explicit_recursive_metadata:
    score: 1.00
  explicit_traversal_path:
    score: 1.00
  validated_cycle_detection:
    score: 0.99
  deterministic_recursive_execution:
    score: 0.99
  inferred_recursive_relationship:
    score: <= 0.90
  context_dependent_revisit:
    score: <= 0.85
  low_evidence_recursive_inference:
    score: <= 0.65
  incomplete_visited_state:
    score: <= 0.60
  incomplete_recursive_provenance:
    score: <= 0.55
    action: preserve uncertainty

# ---------- UPDATE MODEL ----------
UPDATE_MODEL:
  on_recursion_start:
    - assign RecursionIdentifier
    - preserve starting resource and context
    - initialise depth
    - initialise visited state
    - load RecursionPolicy
    - initialise provenance

  on_recursive_expansion:
    - validate traversal relationship
    - calculate child depth
    - propagate applicable context
    - check visited state
    - check cycle policy
    - create child RecursiveState
    - update traversal path and provenance

  on_cycle_detection:
    - identify repeated resource or state
    - preserve cycle path
    - apply CyclePolicy
    - prune, stop, collapse, or permit limited revisit
    - update provenance

  on_termination:
    - identify termination reason
    - preserve final state and depth
    - record completed and pruned branches
    - finalise provenance
    - return confidence

# ---------- FLOW HASH ----------
FLOW_HASH:
  inputs:
    - ontology
    - recursive_entities
    - relationships
    - recursion_types
    - depth_rules
    - visited_state_rules
    - stopping_conditions
    - cycle_policy
    - pruning_rules
    - confidence_model
    - validation
    - semantic_equivalence
    - update_model

  canonicalisation:
    - preserve_recursion_identifier
    - preserve_starting_state
    - preserve_relationship_direction
    - preserve_depth
    - preserve_visited_state_semantics
    - preserve_stopping_conditions
    - preserve_cycle_policy
    - preserve_pruning_policy
    - preserve_confidence_lineage
    - preserve_provenance
    - preserve_rule_order

  output:
    deterministic_semantic_hash

# ---------- AI CONSUMPTION ----------
AI_CONSUMPTION:
  interpret_as:
    - AI Semantic Library metadata ontology
    - recursive semantic-process and traversal-state model
    - cycle-safe ontology, graph, query, metadata, and Flow Algebra recursion structure
    - confidence-aware and provenance-aware recursive reasoning model

  operations:
    - identify recursive processes
    - resolve recursion entry and current state
    - calculate recursion depth
    - preserve parent-child state relationships
    - traverse semantic relationships directionally
    - maintain visited state
    - detect and classify cycles
    - apply stopping and cycle policies
    - prune branches safely
    - propagate semantic context
    - propagate confidence without artificial inflation
    - trace recursive provenance
    - preserve uncertainty

  constraints:
    - do_not_equate_recursion_with simple_repetition
    - do_not_equate_hierarchy_with recursion
    - do_not_equate_graph_cycle_with infinite_loop
    - do_not_equate_repeated_resource_with repeated_state
    - do_not_reverse_relationships_without inverse_semantics
    - do_not_equate_depth_with confidence
    - do_not_equate_pruning_with disproof
    - do_not_equate_recursive_inference_with explicit_assertion
    - require_stopping_or_cycle_control_for potentially_unbounded_recursion

# ---------- QUERY MODEL ----------
query:
  input:
    - recursion_identifier
    - starting_resource
    - current_resource
    - recursion_type
    - recursion_depth
    - maximum_depth
    - relationship
    - termination_state

  resolve:
    1. identify RecursiveSemanticProcess
    2. resolve entry and current state
    3. inspect depth and maximum depth
    4. inspect visited resources and traversal path
    5. resolve recursive relationships and direction
    6. detect repeated resources or states
    7. apply cycle, pruning, and stopping policies
    8. inspect context and confidence propagation
    9. trace provenance and validity
    10. return recursive state

  output:
    - recursive_process
    - recursion_identifier
    - starting_state
    - current_state
    - depth
    - visited_state
    - traversal_path
    - cycle_state
    - stopping_condition
    - termination_state
    - confidence
    - provenance

# ---------- INFERENCE ----------
inference:
  IF unvisited valid target exists
  AND stopping condition is false
  THEN create child RecursiveState

  IF repeated semantic state is detected
  THEN apply CyclePolicy
  AND do_not continue uncontrolled recursion

  IF maximum depth is reached
  THEN terminate or prune current branch

  IF recursive inference lacks sufficient evidence
  THEN preserve uncertainty
  AND reduce confidence

# ---------- OUTPUT CONTRACT ----------
output:
  ontology_entity: RecursiveMetadata
  recursion_identity: machine_interpretable
  entry_and_current_state: explicit
  parent_child_state: preserved
  depth: explicit
  visited_state: maintained
  traversal_path: ordered
  relationship_direction: preserved
  cycles: detectable
  stopping_conditions: enforceable
  pruning: non_disproof
  confidence: lineage_aware
  provenance: preserved
  recursion: cycle_safe
  uncertainty: explicit
  AI_reasoning: enabled

end flow