Transformation Relationship Ontology

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

flow "TransformationRelationshipOntology" v1.0 {
  ontology:
    id: "transformation-relationship-ontology"
    parent: "process-relationships"
    purpose: "Describe evidence-backed transformations between typed input and output states, including agents, methods, constraints and provenance."

  types:
    Entity: {id: string, kind: string, schema: string?}
    State: {id: string, entity_id: string, timestamp: datetime?, properties: map, version: string?}
    Transformation: {id: string, kind: enum[physical, chemical, biological, informational, computational, organisational, other], method: string, reversible: boolean?, deterministic: boolean?}
    Execution: {id: string, transformation_id: string, started_at: datetime?, completed_at: datetime?, status: enum[planned, running, succeeded, failed, cancelled]}
    Agent: {id: string, role: string}
    Resource: {id: string, kind: string}
    Evidence: {id: string, source: string, timestamp: datetime?, reliability: number?}
    Relationship: {id: string, subject: string, predicate: string, object: string, context: string?, confidence: number, evidence: string[]}

  predicates:
    transforms(t: Transformation, input: State, output: State)
    consumes(e: Execution, input: State)
    produces(e: Execution, output: State)
    performed_by(e: Execution, agent: Agent)
    uses_resource(e: Execution, resource: Resource)
    precedes(a: Execution, b: Execution)
    derived_from(output: State, input: State)
    supported_by(relation: Relationship, evidence: Evidence)

  constraints:
    - "Every transformation must identify at least one typed input and one typed output."
    - "State references and execution references must resolve to existing entities."
    - "An output state must not be treated as produced by a failed or merely planned execution."
    - "Confidence and evidence reliability must lie within [0, 1]."
    - "Transformation does not imply reversibility, equivalence or preservation of identity."
    - "Preserve units, timestamps, schema versions and transformation parameters where applicable."
    - "A transformation chain must not silently cross incompatible state schemas."
    - "Causal attribution requires evidence beyond temporal sequence."

  inference:
    rule derivation_from_success:
      if consumes(e, s_in) and produces(e, s_out) and status(e) == succeeded
      then derived_from(s_out, s_in)
      confidence: "bounded by execution evidence and input provenance"
    rule chained_derivation:
      if derived_from(c,b) and derived_from(b,a) and compatible_lineage(a,b,c)
      then derived_from(c,a)
      confidence: "preserve full chain; do not inflate confidence"
    rule execution_order:
      if precedes(a,b) and precedes(b,c) and same_ordering_context(a,b,c)
      then precedes(a,c)
      confidence: "retain temporal provenance"

  SEMANTIC_EQUIVALENCE:
    - "Align transformation labels only when input/output semantics and method constraints are compatible."
    - "Distinguish exact equivalence from similar effects and alternative procedures."
    - "Do not equate a transformed state with its original state by default."

  CONFIDENCE:
    range: [0,1]
    factors: [source_reliability, execution_verification, measurement_uncertainty, schema_compatibility, reproducibility]
    policy: "Preserve uncertainty and never manufacture certainty through chained derivations."

  VALIDATION:
    - "Verify referential integrity and typed input/output compatibility."
    - "Check execution status, timestamps, parameter completeness and evidence links."
    - "Flag cycles, missing lineage, conflicting outcomes and unsupported reversibility claims."
    - "Distinguish transformation lineage from logical implication or causal proof."

  FLOW_HASH:
    algorithm: "SHA-256"
    input: "canonicalised ontology version, typed transformations, constraints, evidence 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, recompute_lineage, publish]
    rollback: true

  AI_CONSUMPTION:
    representation: "typed transformation graph with execution and evidence annotations"
    outputs: [transformation_edges, input_output_states, execution_traces, derived_lineage, uncertainty_annotations, provenance_records]
    safeguards: [no_unsupported_causation, no_unverified_success, preserve_identity_distinctions, preserve_versions_and_units]
}

END FLOW ALGEBRA