Computing Domain Ontology

FLOW ALGEBRA
TITLE: Computing Domain Ontology
DOMAIN: Domain Ontologies / Computing Domains
SOURCE: https://kirethresearch.org/booksai-core/ontologies/domain-ontologies/computing-domains/computing-domain-ontology.html
VERSION: 1.0
AUTHORS: Mark Anthony Higgins — Sky (Recursive AI)
STATUS: Companion formalisation; source-page specification not independently verified.

flow "ComputingDomainOntology" v1.0 {
  ontology:
    id: "computing-domain-ontology"
    parent: "computing-domains"
    purpose: "Represent computing entities, computational processes, system dependencies and verifiable relationships across hardware, software, data and networks."

  types:
    ComputingSystem: {id: string, kind: enum[desktop, server, embedded, mobile, distributed, cloud, other], version: string?}
    HardwareComponent: {id: string, kind: enum[processor, memory, storage, network_interface, accelerator, peripheral, other], specification: string?}
    SoftwareComponent: {id: string, kind: enum[operating_system, application, service, library, firmware, driver, other], version: string?}
    Algorithm: {id: string, inputs: string[], outputs: string[], complexity: string?, specification: string?}
    DataStructure: {id: string, kind: string, schema: string?, constraints: string[]}
    Dataset: {id: string, schema: string?, format: string?, provenance: string, classification: string?}
    Network: {id: string, protocol: string?, topology: string?}
    Process: {id: string, state: enum[created, ready, running, blocked, completed, failed], started_at: datetime?}
    Interface: {id: string, protocol: string?, contract: string?, version: string?}
    Observation: {id: string, timestamp: datetime, metric: string, value: number, unit: string, provenance: string}
    Relationship: {id: string, subject: string, predicate: string, object: string, context: string?, confidence: number, evidence: string[]}

  predicates:
    contains(system: ComputingSystem, component: string)
    executes(system: ComputingSystem, process: Process)
    implements(component: SoftwareComponent, algorithm: Algorithm)
    depends_on(component: string, prerequisite: string)
    communicates_via(component: string, interface: Interface)
    connected_to(a: string, b: string, network: Network)
    consumes(process: Process, resource: string)
    produces(process: Process, dataset: Dataset)
    stores(system: ComputingSystem, dataset: Dataset)
    measured_by(entity: string, observation: Observation)
    compatible_with(a: string, b: string, context: string)

  constraints:
    - "All relationship endpoints must resolve to typed entities or declared external references."
    - "Confidence must lie within [0, 1]."
    - "Software, interfaces and protocols must retain relevant version information."
    - "Measurements must include units, timestamps and provenance."
    - "Dependency does not imply execution, causation, compatibility or ownership."
    - "Connectivity is not automatically transitive; a multi-hop path requires explicit path inference."
    - "Compatibility is contextual and must not be inferred from shared names alone."
    - "Security permissions and authorisation must not be inferred from network reachability."
    - "Do not infer that all dependencies are acyclic; report cycles according to their semantics."

  inference:
    rule indirect_dependency:
      if depends_on(a,b) and depends_on(b,c) and compatible_dependency_context(a,b,c)
      then indirectly_depends_on(a,c)
      confidence: "retain original evidence; report dependency path"
    rule interface_communication:
      if communicates_via(a,i) and communicates_via(b,i) and validated_contract(i,a,b)
      then potentially_interoperable(a,b,i)
      confidence: "conditional on protocol and contract validation"
    rule algorithm_execution:
      if implements(s,a) and executes(h,p) and invokes(p,s)
      then execution_uses_algorithm(p,a)
      confidence: "requires invocation evidence"
    rule network_path:
      if connected_to(a,b,n) and connected_to(b,c,n) and routing_permitted(a,b,c,n)
      then reachable_via(a,c,b,n)
      confidence: "time- and policy-dependent; no access authorisation implied"

  SEMANTIC_EQUIVALENCE:
    - "Normalise computing terminology using versioned, domain-appropriate vocabularies."
    - "Distinguish equivalent implementations from identical software artefacts."
    - "Preserve platform, protocol, architecture and version context."
    - "Do not equate dependency, compatibility, connectivity and interoperability."

  CONFIDENCE:
    range: [0,1]
    factors: [source_reliability, test_coverage, runtime_observation, version_match, reproducibility, configuration_context]
    policy: "Do not increase confidence merely by chaining inferred relationships; preserve uncertainty and evidence lineage."

  VALIDATION:
    - "Check entity types, relationship endpoints, required attributes and cardinality."
    - "Validate software and interface versions against declared contracts."
    - "Check dependency cycles, unavailable components and incompatible protocols."
    - "Validate measurement units, timestamps, execution states and provenance."
    - "Flag contradictory assertions without silently discarding evidence."
    - "Require explicit tests before asserting operational or security guarantees."

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

  UPDATE_MODEL:
    strategy: "versioned, provenance-preserving incremental update"
    steps: [ingest, normalise, validate, compare_versions, reconcile, recompute_dependencies, recompute_inferences, publish]
    rollback: true

  AI_CONSUMPTION:
    representation: "typed computing knowledge graph with evidence-backed relationships"
    outputs: [entity_links, system_component_graphs, dependency_paths, compatibility_assessments, inferred_edges, provenance_records, uncertainty_annotations]
    safeguards: [no_unverified_compatibility, no_assumed_authorisation, preserve_versions, preserve_runtime_context, no_unsupported_causal_claims]
}

END FLOW ALGEBRA