Computing Ontology

AI SEARCH

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

FLOW COMPUTING_ONTOLOGY {

  META {
    DOMAIN = "Computing Ontologies"
    SUBDOMAIN = "Foundations of Computing"
    ONTOLOGY = "Computing Ontology"
    PURPOSE = "Formalise core entities, relationships, processes and reasoning structures that define computation and computing systems."
    LOCALE = "en-GB"
  }

  ENTITY_TYPES {
    COMPUTING_ENTITY
    COMPUTATION
    COMPUTATIONAL_SYSTEM
    COMPUTER
    HARDWARE
    SOFTWARE
    FIRMWARE
    PROCESSOR
    MEMORY
    STORAGE
    DEVICE
    PROGRAM
    ALGORITHM
    PROCEDURE
    FUNCTION
    OPERATION
    INSTRUCTION
    PROCESS
    THREAD
    TASK
    COMPONENT
    MODULE
    INTERFACE
    INPUT
    OUTPUT
    DATA
    INFORMATION
    BIT
    BYTE
    VALUE
    VARIABLE
    CONSTANT
    DATA_TYPE
    DATA_STRUCTURE
    FILE
    DATABASE
    NETWORK
    NODE
    PROTOCOL
    RESOURCE
    STATE
    EVENT
    TRANSITION
    USER
    AGENT
    OPERATING_SYSTEM
    APPLICATION
    SERVICE
    API
    CONFIGURATION
    VERSION
    DEPENDENCY
    ERROR
    LOG
    MODEL
    REPRESENTATION
    EVIDENCE
    CONFIDENCE_SCORE
    PROVENANCE_RECORD
  }

  RELATIONSHIPS {
    IS_A
    INSTANCE_OF
    PART_OF
    CONTAINS
    CONNECTED_TO
    DEPENDS_ON
    IMPLEMENTS
    EXECUTES
    RUNS_ON
    INVOKES
    CALLS
    RETURNS
    READS
    WRITES
    STORES
    RETRIEVES
    PROCESSES
    TRANSFORMS
    RECEIVES
    SENDS
    PRODUCES
    CONSUMES
    HAS_INPUT
    HAS_OUTPUT
    HAS_STATE
    TRANSITIONS_TO
    HAS_COMPONENT
    HAS_RESOURCE
    HAS_CONFIGURATION
    HAS_VERSION
    HAS_DEPENDENCY
    HAS_ERROR
    REPRESENTS
    ENCODES
    DECODES
    PRECEDES
    FOLLOWS
    DERIVED_FROM
    INFERRED_FROM
    HAS_EVIDENCE
    HAS_CONFIDENCE
    HAS_PROVENANCE
    MAPS_TO
    SEMANTICALLY_EQUIVALENT_TO
  }

  INPUTS {
    DATA
    PROGRAMS
    ALGORITHMS
    INSTRUCTIONS
    CONFIGURATION_DATA
    HARDWARE_SPECIFICATIONS
    SOFTWARE_SPECIFICATIONS
    SYSTEM_STATE
    USER_INPUT
    NETWORK_INPUT
    DATABASE_INPUT
    EXECUTION_TRACES
    LOGS
    DEPENDENCY_DATA
    ONTOLOGY_TERMS
  }

  NORMALISE {
    STANDARDISE_IDENTIFIERS
    NORMALISE_DATA_TYPES
    NORMALISE_COMPONENT_NAMES
    NORMALISE_VERSION_IDENTIFIERS
    NORMALISE_CONFIGURATION
    RESOLVE_DEPENDENCIES
    RESOLVE_COMPONENT_IDENTITIES
    ALIGN_ONTOLOGY_TERMS
    REMOVE_DUPLICATES
    VALIDATE_METADATA
    PRESERVE_PROVENANCE
  }

  PROCESS COMPUTING_PIPELINE {
    INPUT
      -> REPRESENTATION
      -> VALIDATION
      -> PROCESSING
      -> STATE_TRANSITION
      -> OUTPUT
      -> VERIFICATION
      -> PROVENANCE_RECORD
  }

  PROCESS PROGRAM_EXECUTION {
    PROGRAM + INPUT + EXECUTION_ENVIRONMENT
      -> LOAD

    LOAD
      -> INITIALISE

    INITIALISE
      -> EXECUTE_INSTRUCTIONS

    EXECUTE_INSTRUCTIONS
      -> STATE_TRANSITIONS

    STATE_TRANSITIONS
      -> OUTPUT_OR_ERROR

    OUTPUT_OR_ERROR
      -> EXECUTION_RECORD
  }

  PROCESS DATA_TRANSFORMATION {
    INPUT_DATA
      -> PARSE
      -> VALIDATE
      -> TRANSFORM
      -> OUTPUT_DATA

    OUTPUT_DATA
      -> QUALITY_CHECK
      -> STORAGE_OR_TRANSMISSION
  }

  PROCESS RESOURCE_REASONING {
    COMPUTATIONAL_TASK
      -> RESOURCE_REQUIREMENTS

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

    AVAILABLE_RESOURCES + RESOURCE_REQUIREMENTS
      -> FEASIBILITY_CHECK
  }

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

    TRANSITION
      -> SYSTEM_STATE(T2)

    STATE_SEQUENCE
      -> EXECUTION_TRACE
      -> BEHAVIOUR_INTERPRETATION
  }

  PROCESS DEPENDENCY_REASONING {
    COMPONENT_A DEPENDS_ON COMPONENT_B
      -> DEPENDENCY_EDGE

    DEPENDENCY_EDGE
      -> VERSION_CHECK
      -> CONFIGURATION_CHECK
      -> AVAILABILITY_CHECK

    FAILURE(COMPONENT_B)
      -> IMPACT_ANALYSIS(COMPONENT_A)
  }

  PROCESS SYSTEM_COMPOSITION {
    COMPONENTS
      -> INTERFACE_COMPATIBILITY_CHECK

    INTERFACE_COMPATIBILITY_CHECK
      -> DEPENDENCY_RESOLUTION

    DEPENDENCY_RESOLUTION
      -> COMPOSED_SYSTEM

    COMPOSED_SYSTEM
      -> SYSTEM_VALIDATION
  }

  RULES {
    IF PROGRAM EXECUTES
    THEN REQUIRE {
      EXECUTION_ENVIRONMENT
      INPUT_OR_TRIGGER
      DEPENDENCIES
      VERSION_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 REQUIRE {
      PRIOR_STATE
      EVENT_OR_OPERATION
      RESULTING_STATE
    }

    IF OUTPUT_IS_PRODUCED
    THEN LINK {
      INPUT
      PROCESS
      OUTPUT
      EXECUTION_CONTEXT
      PROVENANCE_RECORD
    }

    IF ERROR_OCCURS
    THEN PRESERVE {
      ERROR_TYPE
      SYSTEM_STATE
      EXECUTION_CONTEXT
      VERSION
      PROVENANCE
    }

    IF SOFTWARE_VERSION_DIFFERS
    THEN DO_NOT_ASSUME_IDENTICAL_BEHAVIOUR

    IF SEMANTIC_IDENTIFIERS_DIFFER
    AND COMPUTING_REFERENT_IS_SAME
    THEN APPLY SEMANTIC_EQUIVALENCE
  }

  CONFIDENCE {
    CONFIDENCE_SCORE =
      WEIGHT(
        INPUT_QUALITY,
        SYSTEM_OBSERVABILITY,
        VERSION_CERTAINTY,
        CONFIGURATION_CERTAINTY,
        DEPENDENCY_RESOLUTION,
        EXECUTION_REPRODUCIBILITY,
        VALIDATION_RESULTS,
        PROVENANCE_COMPLETENESS
      )

    LEVELS {
      HIGH
      MODERATE
      LOW
      INSUFFICIENT
    }

    IF VERSION_IS_UNKNOWN
    THEN REDUCE CONFIDENCE_SCORE

    IF CONFIGURATION_IS_UNKNOWN
    THEN REDUCE CONFIDENCE_SCORE

    IF REPRODUCIBLE_EXECUTION_CONFIRMS_RESULT
    THEN INCREASE CONFIDENCE_SCORE
  }

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

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

    ELSE PRESERVE_DISTINCT_ENTITIES
  }

  REASONING_CONSTRAINTS {
    PROGRAM != PROCESS
    ALGORITHM != PROGRAM
    SOFTWARE != HARDWARE
    DATA != INFORMATION
    INPUT != OUTPUT
    DEPENDENCY != EXECUTION
    CONNECTIVITY != INTEROPERABILITY
    VERSION_CONTEXT_AFFECTS_BEHAVIOUR
    CONFIGURATION_AFFECTS_BEHAVIOUR
    EXECUTION_ENVIRONMENT_AFFECTS_BEHAVIOUR
    OBSERVED_STATE != PREDICTED_STATE
    PROVENANCE_MUST_BE_PRESERVED
    UNCERTAINTY_MUST_NOT_BE_DISCARDED
  }

  VALIDATION {
    CHECK_ENTITY_TYPES
    CHECK_RELATION_DOMAINS_AND_RANGES
    CHECK_IDENTIFIERS
    CHECK_VERSION_CONTEXT
    CHECK_CONFIGURATION
    CHECK_DEPENDENCIES
    CHECK_INPUT_OUTPUT_RELATIONS
    CHECK_STATE_TRANSITIONS
    CHECK_EXECUTION_CONTEXT
    CHECK_PROVENANCE
    CHECK_CONFIDENCE
    CHECK_SEMANTIC_CONSISTENCY
    CHECK_DUPLICATE_ENTITIES
  }

  OUTPUTS {
    NORMALISED_COMPUTING_ENTITIES
    COMPONENT_RELATIONSHIPS
    DEPENDENCY_GRAPH
    PROGRAM_EXECUTION_RELATIONS
    DATA_FLOW_RELATIONS
    RESOURCE_RELATIONS
    STATE_TRANSITIONS
    EXECUTION_TRACES
    ERROR_RELATIONS
    INFERRED_DEPENDENCIES
    CONFIDENCE_SCORES
    EVIDENCE_LINKS
    PROVENANCE_RECORDS
    EXPLANATION_PATHS
  }

  UPDATE_MODEL {
    ON SYSTEM_CHANGE {
      NORMALISE
      ENTITY_RESOLUTION
      UPDATE_COMPONENTS
      UPDATE_DEPENDENCIES
      RECOMPUTE_AFFECTED_RELATIONS
      UPDATE_CONFIDENCE
      PRESERVE_VERSION_HISTORY
    }

    ON NEW_EXECUTION_DATA {
      LINK_EXECUTION_TRACE
      UPDATE_SYSTEM_STATE
      REASSESS_BEHAVIOURAL_RELATIONS
      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_COMPUTATION
      BY_SYSTEM
      BY_HARDWARE
      BY_SOFTWARE
      BY_PROGRAM
      BY_ALGORITHM
      BY_DATA
      BY_PROCESS
      BY_COMPONENT
      BY_DEPENDENCY
      BY_VERSION
      BY_STATE
      BY_CONFIDENCE
    }

    REASON {
      APPLY_RELATIONSHIPS
      APPLY_RULES
      TRACE_DEPENDENCIES
      TRACE_DATA_FLOW
      TRACE_EXECUTION
      ANALYSE_STATE_TRANSITIONS
      PRESERVE_UNCERTAINTY
      TRACE_EVIDENCE
      TRACE_PROVENANCE
      GENERATE_EXPLANATION_PATH
    }

    RESPONSE_POLICY {
      DISTINGUISH_PROGRAM_FROM_PROCESS
      DISTINGUISH_ALGORITHM_FROM_IMPLEMENTATION
      PRESERVE_VERSION_CONTEXT
      PRESERVE_CONFIGURATION_CONTEXT
      RETURN_CONFIDENCE_WHEN_AVAILABLE
      RETURN_PROVENANCE_WHEN_AVAILABLE
      AVOID_UNSUPPORTED_COMPUTATIONAL_INFERENCE
    }
  }

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

END FLOW