Resource Relationship Ontology

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

flow "ResourceRelationshipOntology" v1.0 {
  ontology:
    id: "resource-relationship-ontology"
    parent: "system-relationships"
    purpose: "Represent evidence-backed allocation, consumption, production, ownership and dependency relationships between resources and systems."

  types:
    Resource: {id: string, kind: enum[material, energy, information, equipment, compute, storage, personnel, financial, other], capacity: number?, unit: string?, availability: string?}
    System: {id: string, name: string, boundary: string?}
    Process: {id: string, system_id: string, state: string?}
    Allocation: {id: string, resource_id: string, consumer_id: string, quantity: number?, unit: string?, valid_from: datetime?, valid_to: datetime?, evidence: string[]}
    Measurement: {id: string, quantity: number, unit: string, timestamp: datetime?, uncertainty: number?, provenance: string}
    Relationship: {id: string, subject: string, predicate: string, object: string, context: string?, confidence: number, evidence: string[]}

  predicates:
    requires(process: Process, resource: Resource)
    allocated_to(resource: Resource, system: System)
    consumed_by(resource: Resource, process: Process)
    produced_by(resource: Resource, process: Process)
    shared_between(resource: Resource, a: System, b: System)
    constrained_by(resource: Resource, measurement: Measurement)
    depends_on(a: Resource, b: Resource)
    managed_by(resource: Resource, system: System)

  constraints:
    - "Every relationship endpoint must resolve to an appropriately typed entity."
    - "Confidence must lie within [0,1]."
    - "Quantities and capacities must specify compatible units."
    - "Allocations must respect capacity limits within the same time interval and accounting scope."
    - "Allocation, access, custody, management and legal ownership are distinct predicates."
    - "Consumption does not imply destruction; distinguish consumable and reusable resources."
    - "Resource dependency is not automatically transitive without an explicit dependency model."
    - "Temporal validity must be preserved for changing allocations and availability."

  inference:
    rule resource_requirement:
      if requires(p,r) and belongs_to(p,s)
      then resource_requirement_of(r,s)
      confidence: "inherit evidence; distinguish requirement from actual allocation"
    rule allocation_usage:
      if allocated_to(r,s) and executes(s,p) and requires(p,r)
      then potentially_available_to(r,p)
      confidence: "availability and permissions must be checked"
    rule capacity_conflict:
      if overlapping_allocations(r) and total_allocated(r) > capacity(r)
      then flag_capacity_conflict(r)
      confidence: "requires harmonised units and temporal scope"

  SEMANTIC_EQUIVALENCE:
    - "Resolve resource aliases against versioned identifiers and classifications."
    - "Do not conflate resources with equal labels but different units, scopes or ownership."
    - "Preserve distinctions between requires, uses, allocates, produces and consumes."

  CONFIDENCE:
    range: [0,1]
    factors: [source_reliability, measurement_uncertainty, temporal_validity, allocation_records, independent_verification]
    policy: "Do not manufacture certainty or increase confidence solely by chaining relationships."

  VALIDATION:
    - "Verify entity identity, relationship types, quantity units and temporal intervals."
    - "Check capacity and allocation conflicts where adequate data exists."
    - "Retain provenance and flag unsupported claims of ownership or consumption."
    - "Preserve unknown or contested resource availability as unresolved."

  FLOW_HASH:
    algorithm: "SHA-256"
    input: "canonicalised ontology version, typed assertions, constraints, 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, reconcile, detect_conflicts, recompute_inferences, publish]
    rollback: true

  AI_CONSUMPTION:
    representation: "typed resource-dependency knowledge graph with temporal evidence"
    outputs: [resource_links, allocation_edges, requirement_edges, capacity_warnings, confidence_annotations, provenance_records]
    safeguards: [no_unverified_ownership, preserve_units, preserve_temporal_scope, distinguish_requirements_from_actual_usage]
}

END FLOW ALGEBRA