Cloud Computing Domain Ontology

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

flow "CloudComputingDomainOntology" v1.0 {
  ontology:
    id: "cloud-computing-domain-ontology"
    parent: "computing-domains"
    purpose: "Represent cloud infrastructure, service delivery, resource allocation, security boundaries, and operational evidence using typed, traceable relationships."

  types:
    CloudProvider: {id: string, name: string}
    CloudAccount: {id: string, provider_id: string, tenant_id: string?}
    Region: {id: string, provider_id: string, jurisdiction: string?}
    AvailabilityZone: {id: string, region_id: string}
    CloudService: {id: string, category: enum[compute, storage, database, network, identity, observability, messaging, other], service_model: enum[IaaS, PaaS, SaaS, FaaS, other]}
    Resource: {id: string, service_id: string, account_id: string, region_id: string?, lifecycle: enum[planned, provisioning, active, suspended, retired]}
    Workload: {id: string, name: string, criticality: string?, owner: string?}
    Deployment: {id: string, workload_id: string, version: string, timestamp: datetime, provenance: string}
    Policy: {id: string, kind: enum[access, network, retention, encryption, compliance, other], version: string}
    Observation: {id: string, metric: string, value: number, unit: string, timestamp: datetime, provenance: string}
    Relationship: {id: string, subject: string, predicate: string, object: string, context: string?, confidence: number, evidence: string[]}

  predicates:
    provides(provider: CloudProvider, service: CloudService)
    hosts(resource: Resource, workload: Workload)
    deployed_in(resource: Resource, region: Region)
    belongs_to(resource: Resource, account: CloudAccount)
    depends_on(a: Resource, b: Resource)
    communicates_with(a: Resource, b: Resource)
    governed_by(resource: Resource, policy: Policy)
    measured_by(resource: Resource, observation: Observation)
    deploys(deployment: Deployment, workload: Workload)
    located_in(zone: AvailabilityZone, region: Region)

  constraints:
    - "Every relationship endpoint must resolve to a typed entity."
    - "Confidence values must be within [0, 1]."
    - "Resource identifiers are scoped by provider and account; do not merge across scopes based on names."
    - "Regions, zones and jurisdiction are distinct; physical location must not be assumed from marketing labels."
    - "A dependency does not automatically imply network reachability, data access or causation."
    - "Service model and shared-responsibility boundaries must be explicit."
    - "Measurements require units, timestamps and provenance."
    - "Security compliance cannot be inferred solely from the existence of a policy."

  inference:
    rule account_provider:
      if belongs_to(resource,account) and account.provider_id == provider.id
      then provider_context(resource,provider)
      confidence: "preserve source provenance"
    rule dependency_path:
      if depends_on(a,b) and depends_on(b,c) and compatible_scope(a,b,c)
      then indirect_dependency(a,c)
      confidence: "derived; do not claim direct dependency"
    rule regional_context:
      if deployed_in(resource,region) and located_in(zone,region)
      then region_association(resource,region)
      confidence: "do not infer deployment into the particular zone"

  SEMANTIC_EQUIVALENCE:
    - "Normalise provider-specific service labels to versioned generic cloud concepts."
    - "Distinguish exact identity, service-category equivalence and functional similarity."
    - "Preserve provider, region, account, deployment version and time context."

  CONFIDENCE:
    range: [0,1]
    factors: [source_reliability, configuration_freshness, measurement_quality, independent_confirmation, inference_depth]
    policy: "Do not increase confidence solely through multi-hop chaining."

  VALIDATION:
    - "Check entity types, resource scope, referenced identifiers and service-model compatibility."
    - "Check timestamps, units, resource lifecycle and policy versions."
    - "Flag stale configurations, missing provenance, cycles and contradictory deployment claims."
    - "Treat observed runtime state separately from desired configuration."

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

  AI_CONSUMPTION:
    representation: "typed cloud knowledge graph with evidence-backed edges"
    outputs: [resource_inventory, dependency_graph, deployment_lineage, policy_links, observations, uncertainty_annotations]
    safeguards: [no_unverified_compliance_claims, no_unsupported_identity_merges, preserve_tenant_boundaries, preserve_temporal_context]
}

END FLOW ALGEBRA