Computational Systems Ontology

AI SEARCH

FLOW ALGEBRA — COMPUTATIONAL SYSTEMS ONTOLOGY
Semantic Library
Version: 4.0
Canonical Page:
https://kirethresearch.org/booksai-core/ontologies/computing-ontologies/foundations-of-computing/computational-systems-ontology.html

FLOW COMPUTATIONAL_SYSTEMS_ONTOLOGY {

  META {
    DOMAIN = "Computing Ontologies"
    SUBDOMAIN = "Foundations of Computing"
    ONTOLOGY = "Computational Systems Ontology"
    PURPOSE = "Formalise entities, structures, interactions, states and reasoning processes used to represent computational systems and their behaviour."
    LOCALE = "en-GB"
  }

  ENTITY_TYPES {
    COMPUTATIONAL_SYSTEM
    COMPUTING_DEVICE
    COMPUTER
    HARDWARE
    SOFTWARE
    FIRMWARE
    PROCESSOR
    MEMORY
    STORAGE
    NETWORK
    NODE
    COMPONENT
    MODULE
    SERVICE
    PROCESS
    THREAD
    TASK
    PROGRAM
    ALGORITHM
    INSTRUCTION
    OPERATING_SYSTEM
    RUNTIME_ENVIRONMENT
    INTERFACE
    API
    PROTOCOL
    INPUT
    OUTPUT
    DATA
    RESOURCE
    STATE
    EVENT
    TRANSITION
    CONFIGURATION
    VERSION
    DEPENDENCY
    COMMUNICATION_CHANNEL
    MESSAGE
    REQUEST
    RESPONSE
    ERROR
    FAILURE
    LOG
    METRIC
    PERFORMANCE_MEASURE
    SECURITY_CONTROL
    USER
    AGENT
    EXTERNAL_SYSTEM
    MODEL
    EVIDENCE
    CONFIDENCE_SCORE
    PROVENANCE_RECORD
  }

  RELATIONSHIPS {
    IS_A
    INSTANCE_OF
    PART_OF
    CONTAINS
    HAS_COMPONENT
    CONNECTED_TO
    COMMUNICATES_WITH
    DEPENDS_ON
    RUNS_ON
    EXECUTES
    HOSTS
    INVOKES
    CALLS
    RETURNS
    SENDS
    RECEIVES
    READS
    WRITES
    STORES
    RETRIEVES
    PROCESSES
    TRANSFORMS
    PRODUCES
    CONSUMES
    HAS_INPUT
    HAS_OUTPUT
    HAS_STATE
    TRANSITIONS_TO
    TRIGGERS
    PRECEDES
    FOLLOWS
    ALLOCATES
    USES_RESOURCE
    HAS_CONFIGURATION
    HAS_VERSION
    HAS_DEPENDENCY
    EXPOSES
    IMPLEMENTS
    MONITORS
    FAILS_WITH
    RECOVERS_FROM
    HAS_EVIDENCE
    HAS_CONFIDENCE
    HAS_PROVENANCE
    DERIVED_FROM
    INFERRED_FROM
    MAPS_TO
    SEMANTICALLY_EQUIVALENT_TO
  }

  INPUTS {
    SYSTEM_ARCHITECTURES
    COMPONENT_DEFINITIONS
    HARDWARE_SPECIFICATIONS
    SOFTWARE_SPECIFICATIONS
    CONFIGURATION_DATA
    VERSION_DATA
    DEPENDENCY_DATA
    EXECUTION_TRACES
    SYSTEM_LOGS
    NETWORK_TRACES
    RESOURCE_METRICS
    PERFORMANCE_METRICS
    ERROR_RECORDS
    SECURITY_EVENTS
    INTERFACE_DEFINITIONS
    PROTOCOL_DEFINITIONS
    ONTOLOGY_TERMS
  }

  NORMALISE {
    STANDARDISE_SYSTEM_IDENTIFIERS
    NORMALISE_COMPONENT_NAMES
    NORMALISE_VERSION_IDENTIFIERS
    NORMALISE_CONFIGURATION
    NORMALISE_RESOURCE_UNITS
    NORMALISE_EVENT_TYPES
    NORMALISE_ERROR_TYPES
    RESOLVE_DEPENDENCIES
    RESOLVE_COMPONENT_IDENTITIES
    ALIGN_ONTOLOGY_TERMS
    REMOVE_DUPLICATES
    VALIDATE_METADATA
    PRESERVE_PROVENANCE
  }

  PROCESS SYSTEM_REASONING_PIPELINE {
    INPUT
      -> SYSTEM_IDENTIFICATION
      -> COMPONENT_RESOLUTION
      -> RELATION_MAPPING
      -> STATE_RECONSTRUCTION
      -> DEPENDENCY_ANALYSIS
      -> BEHAVIOUR_ANALYSIS
      -> VALIDATION
      -> CONFIDENCE_ESTIMATION
      -> OUTPUT
  }

  PROCESS SYSTEM_COMPOSITION {
    COMPONENT_SET
      -> INTERFACE_COMPATIBILITY_CHECK

    INTERFACE_COMPATIBILITY_CHECK
      -> DEPENDENCY_RESOLUTION

    DEPENDENCY_RESOLUTION
      -> RESOURCE_COMPATIBILITY_CHECK

    RESOURCE_COMPATIBILITY_CHECK
      -> COMPOSED_SYSTEM

    COMPOSED_SYSTEM
      -> SYSTEM_VALIDATION
  }

  PROCESS EXECUTION_REASONING {
    PROGRAM + INPUT + RUNTIME_ENVIRONMENT
      -> EXECUTION_INSTANCE

    EXECUTION_INSTANCE
      -> INSTRUCTION_SEQUENCE
      -> STATE_TRANSITIONS

    STATE_TRANSITIONS
      -> OUTPUT_OR_ERROR

    OUTPUT_OR_ERROR
      -> EXECUTION_TRACE
  }

  PROCESS STATE_REASONING {
    SYSTEM_STATE(T1)
      + EVENT
      -> TRANSITION

    TRANSITION
      -> SYSTEM_STATE(T2)

    STATE_SEQUENCE
      -> BEHAVIOURAL_TRACE

    BEHAVIOURAL_TRACE
      -> SYSTEM_BEHAVIOUR_MODEL
  }

  PROCESS DEPENDENCY_REASONING {
    COMPONENT_A DEPENDS_ON COMPONENT_B
      -> DEPENDENCY_EDGE

    DEPENDENCY_EDGE
      -> VERSION_COMPATIBILITY_CHECK
      -> CONFIGURATION_COMPATIBILITY_CHECK
      -> AVAILABILITY_CHECK

    FAILURE(COMPONENT_B)
      -> IMPACT_ANALYSIS(COMPONENT_A)

    DEPENDENCY_PATH
      -> PROPAGATION_ANALYSIS
  }

  PROCESS RESOURCE_REASONING {
    TASK
      -> RESOURCE_REQUIREMENTS

    RESOURCE_REQUIREMENTS
      -> PROCESSOR_REQUIREMENT
      -> MEMORY_REQUIREMENT
      -> STORAGE_REQUIREMENT
      -> NETWORK_REQUIREMENT

    AVAILABLE_RESOURCES + RESOURCE_REQUIREMENTS
      -> ALLOCATION_DECISION

    ALLOCATION_DECISION
      -> EXECUTION_FEASIBILITY
  }

  PROCESS COMMUNICATION_REASONING {
    COMPONENT_A + MESSAGE + PROTOCOL + COMPONENT_B
      -> COMMUNICATION_EVENT

    COMMUNICATION_EVENT
      -> SEND
      -> TRANSPORT
      -> RECEIVE
      -> VALIDATE

    VALIDATE
      -> RESPONSE_OR_ERROR
  }

  PROCESS FAILURE_REASONING {
    ERROR_OR_FAILURE
      -> FAILURE_CONTEXT

    FAILURE_CONTEXT
      -> ROOT_CAUSE_CANDIDATES

    ROOT_CAUSE_CANDIDATES
      -> DEPENDENCY_TRACE
      -> STATE_TRACE
      -> EVIDENCE_CHECK

    EVIDENCE_CHECK
      -> ROOT_CAUSE_HYPOTHESIS
      -> CONFIDENCE_SCORE
  }

  PROCESS PERFORMANCE_REASONING {
    SYSTEM + WORKLOAD + RESOURCE_METRICS
      -> PERFORMANCE_PROFILE

    PERFORMANCE_PROFILE
      -> BOTTLENECK_ANALYSIS
      -> LATENCY_ANALYSIS
      -> THROUGHPUT_ANALYSIS
      -> RESOURCE_UTILISATION_ANALYSIS

    PERFORMANCE_PROFILE
      -> OPTIMISATION_HYPOTHESES
  }

  RULES {
    IF COMPUTATIONAL_SYSTEM EXISTS
    THEN REQUIRE {
      SYSTEM_BOUNDARY
      COMPONENT_SET
      INTERFACES
      EXECUTION_CONTEXT
    }

    IF COMPONENT_A DEPENDS_ON COMPONENT_B
    AND COMPONENT_B DEPENDS_ON COMPONENT_C
    THEN INFER DEPENDENCY_PATH(A, C)

    IF SYSTEM_STATE_CHANGES
    THEN LINK {
      PRIOR_STATE
      EVENT
      TRANSITION
      RESULTING_STATE
    }

    IF FAILURE_OCCURS
    THEN PRESERVE {
      FAILURE_TYPE
      SYSTEM_STATE
      COMPONENT_CONTEXT
      VERSION_CONTEXT
      CONFIGURATION_CONTEXT
      PROVENANCE
    }

    IF PERFORMANCE_RESULT_IS_RECORDED
    THEN REQUIRE {
      WORKLOAD_CONTEXT
      HARDWARE_CONTEXT
      SOFTWARE_VERSION
      CONFIGURATION
    }

    IF TWO_SYSTEMS_HAVE_SAME_COMPONENT_NAMES
    THEN DO_NOT_ASSUME_IDENTICAL_CONFIGURATION_OR_BEHAVIOUR

    IF SEMANTIC_IDENTIFIERS_DIFFER
    AND COMPUTATIONAL_SYSTEM_REFERENT_IS_SAME
    THEN APPLY SEMANTIC_EQUIVALENCE
  }

  CONFIDENCE {
    CONFIDENCE_SCORE =
      WEIGHT(
        SYSTEM_OBSERVABILITY,
        COMPONENT_RESOLUTION,
        VERSION_CERTAINTY,
        CONFIGURATION_CERTAINTY,
        DEPENDENCY_RESOLUTION,
        TRACE_COMPLETENESS,
        REPRODUCIBILITY,
        PROVENANCE_COMPLETENESS
      )

    LEVELS {
      HIGH
      MODERATE
      LOW
      INSUFFICIENT
    }

    IF TRACE_IS_INCOMPLETE
    THEN REDUCE CONFIDENCE_SCORE

    IF VERSION_OR_CONFIGURATION_IS_UNKNOWN
    THEN REDUCE CONFIDENCE_SCORE

    IF REPRODUCIBLE_SYSTEM_BEHAVIOUR_CONFIRMS_RESULT
    THEN INCREASE CONFIDENCE_SCORE
  }

  SEMANTIC_EQUIVALENCE {
    EQUIVALENCE_KEY =
      NORMALISE(
        ENTITY_TYPE,
        CANONICAL_IDENTIFIER,
        VERSION,
        CONFIGURATION,
        SYSTEM_BOUNDARY,
        EXECUTION_CONTEXT
      )

    IF EQUIVALENCE_KEY(A) == EQUIVALENCE_KEY(B)
    THEN A SEMANTICALLY_EQUIVALENT_TO B

    ELSE PRESERVE_DISTINCT_ENTITIES
  }

  REASONING_CONSTRAINTS {
    SYSTEM != COMPONENT
    PROGRAM != PROCESS
    CONFIGURATION != VERSION
    DEPENDENCY != EXECUTION
    CONNECTIVITY != SUCCESSFUL_COMMUNICATION
    ERROR != ROOT_CAUSE
    CORRELATION != CAUSATION
    PERFORMANCE_IS_WORKLOAD_DEPENDENT
    BEHAVIOUR_IS_CONFIGURATION_DEPENDENT
    EXECUTION_ENVIRONMENT_AFFECTS_RESULTS
    DISTRIBUTED_STATE_MAY_BE_PARTIAL
    OBSERVED_STATE != INFERRED_STATE
    PROVENANCE_MUST_BE_PRESERVED
    UNCERTAINTY_MUST_NOT_BE_DISCARDED
  }

  VALIDATION {
    CHECK_ENTITY_TYPES
    CHECK_SYSTEM_BOUNDARIES
    CHECK_COMPONENT_IDENTIFIERS
    CHECK_RELATION_DOMAINS_AND_RANGES
    CHECK_INTERFACES
    CHECK_DEPENDENCIES
    CHECK_VERSION_CONTEXT
    CHECK_CONFIGURATION_CONTEXT
    CHECK_STATE_TRANSITIONS
    CHECK_EXECUTION_TRACES
    CHECK_RESOURCE_RELATIONS
    CHECK_FAILURE_RELATIONS
    CHECK_PERFORMANCE_CONTEXT
    CHECK_PROVENANCE
    CHECK_CONFIDENCE
    CHECK_SEMANTIC_CONSISTENCY
  }

  OUTPUTS {
    NORMALISED_COMPUTATIONAL_SYSTEMS
    SYSTEM_COMPONENT_GRAPHS
    DEPENDENCY_GRAPHS
    INTERFACE_RELATIONS
    EXECUTION_TRACES
    STATE_TRANSITION_GRAPHS
    RESOURCE_RELATIONS
    COMMUNICATION_RELATIONS
    FAILURE_HYPOTHESES
    PERFORMANCE_PROFILES
    INFERRED_DEPENDENCIES
    CONFIDENCE_SCORES
    EVIDENCE_LINKS
    PROVENANCE_RECORDS
    EXPLANATION_PATHS
  }

  UPDATE_MODEL {
    ON SYSTEM_CHANGE {
      NORMALISE
      ENTITY_RESOLUTION
      UPDATE_COMPONENT_GRAPH
      UPDATE_INTERFACES
      UPDATE_DEPENDENCIES
      UPDATE_CONFIGURATION
      RECOMPUTE_AFFECTED_INFERENCES
      UPDATE_CONFIDENCE
      PRESERVE_VERSION_HISTORY
    }

    ON NEW_EXECUTION_OR_MONITORING_DATA {
      LINK_TRACE
      UPDATE_SYSTEM_STATE
      UPDATE_PERFORMANCE_PROFILE
      REASSESS_FAILURE_HYPOTHESES
      UPDATE_CONFIDENCE
      RECORD_PROVENANCE
    }

    ON ONTOLOGY_REVISION {
      REMAP_TERMS
      CHECK_SEMANTIC_EQUIVALENCE
      IDENTIFY_DEPRECATED_TERMS
      MIGRATE_RELATIONSHIPS
      PRESERVE_PRIOR_VERSION_REFERENCES
    }
  }

  FLOW_HASH {
    HASH_INPUT =
      CANONICALISE(
        ENTITY_TYPES,
        RELATIONSHIPS,
        RULES,
        CONFIDENCE,
        SEMANTIC_EQUIVALENCE,
        REASONING_CONSTRAINTS,
        UPDATE_MODEL
      )

    FLOW_HASH = SHA256(HASH_INPUT)
  }

  AI_CONSUMPTION {
    INDEX {
      ONTOLOGY
      ENTITY_TYPES
      RELATIONSHIPS
      RULES
      OUTPUTS
    }

    RETRIEVE {
      BY_SYSTEM
      BY_COMPONENT
      BY_PROCESS
      BY_DEPENDENCY
      BY_INTERFACE
      BY_RESOURCE
      BY_STATE
      BY_EVENT
      BY_FAILURE
      BY_PERFORMANCE
      BY_VERSION
      BY_CONFIGURATION
      BY_CONFIDENCE
    }

    REASON {
      APPLY_RELATIONSHIPS
      APPLY_RULES
      TRACE_DEPENDENCIES
      TRACE_EXECUTION
      TRACE_STATE_TRANSITIONS
      TRACE_COMMUNICATION
      ANALYSE_FAILURE_PROPAGATION
      ANALYSE_RESOURCE_USAGE
      ANALYSE_PERFORMANCE
      PRESERVE_UNCERTAINTY
      TRACE_EVIDENCE
      TRACE_PROVENANCE
      GENERATE_EXPLANATION_PATH
    }

    RESPONSE_POLICY {
      DISTINGUISH_SYSTEM_FROM_COMPONENT
      DISTINGUISH_ERROR_FROM_ROOT_CAUSE
      DISTINGUISH_OBSERVED_FROM_INFERRED_STATE
      PRESERVE_VERSION_CONTEXT
      PRESERVE_CONFIGURATION_CONTEXT
      PRESERVE_WORKLOAD_CONTEXT
      RETURN_CONFIDENCE_WHEN_AVAILABLE
      RETURN_PROVENANCE_WHEN_AVAILABLE
      AVOID_UNSUPPORTED_SYSTEM_INFERENCE
    }
  }

  TERMINAL {
    RESULT =
      VALIDATED(
        SEMANTICALLY_NORMALISED(
          EVIDENCE_LINKED(
            CONFIDENCE_AWARE(
              COMPUTATIONAL_SYSTEMS_KNOWLEDGE
            )
          )
        )
      )
  }
}

END FLOW