Computer Hardware

AI SEARCH

FLOW ALGEBRA — COMPUTER HARDWARE
Semantic Library
Version: 4.0
Canonical Page:
https://kirethresearch.org/booksai-core/ontologies/computing-ontologies/computer-hardware.html

FLOW COMPUTER_HARDWARE {

  META {
    DOMAIN = "Computing Ontologies"
    SUBDOMAIN = "Computer Hardware"
    ONTOLOGY = "Computer Hardware"
    PURPOSE = "Formalise physical computing components, devices, interfaces, electrical resources, data pathways and operational relationships that constitute computer hardware."
    LOCALE = "en-GB"
  }

  ENTITY_TYPES {
    COMPUTER_HARDWARE
    COMPUTER_SYSTEM
    DEVICE
    COMPONENT
    PROCESSOR
    CPU
    GPU
    CORE
    MOTHERBOARD
    CHIPSET
    SYSTEM_ON_CHIP
    MEMORY
    RAM
    ROM
    CACHE
    STORAGE
    HARD_DISK_DRIVE
    SOLID_STATE_DRIVE
    FLASH_STORAGE
    POWER_SUPPLY
    COOLING_SYSTEM
    HEAT_SINK
    FAN
    SENSOR
    CONTROLLER
    BUS
    INTERCONNECT
    PORT
    CONNECTOR
    INTERFACE
    NETWORK_INTERFACE
    INPUT_DEVICE
    OUTPUT_DEVICE
    PERIPHERAL
    DISPLAY
    KEYBOARD
    MOUSE
    PRINTER
    CAMERA
    MICROPHONE
    SPEAKER
    CIRCUIT
    PCB
    TRANSISTOR
    LOGIC_GATE
    CLOCK
    SIGNAL
    DATA
    ADDRESS
    INSTRUCTION
    FIRMWARE
    DEVICE_DRIVER
    RESOURCE
    POWER
    VOLTAGE
    CURRENT
    TEMPERATURE
    FREQUENCY
    BANDWIDTH
    LATENCY
    STATE
    EVENT
    FAILURE
    ERROR
    CONFIGURATION
    VERSION
    SPECIFICATION
    PERFORMANCE_METRIC
    EVIDENCE
    CONFIDENCE_SCORE
    PROVENANCE_RECORD
  }

  HARDWARE_DOMAINS {
    PROCESSING_HARDWARE
    MEMORY_HARDWARE
    STORAGE_HARDWARE
    MOTHERBOARD_AND_CHIPSET
    INPUT_HARDWARE
    OUTPUT_HARDWARE
    NETWORK_HARDWARE
    POWER_HARDWARE
    COOLING_HARDWARE
    EMBEDDED_HARDWARE
    PERIPHERAL_HARDWARE
    INTERCONNECT_HARDWARE
    ELECTRONIC_COMPONENTS
  }

  RELATIONSHIPS {
    IS_A
    INSTANCE_OF
    PART_OF
    CONTAINS
    HAS_COMPONENT
    CONNECTED_TO
    INTERFACES_WITH
    INSTALLED_IN
    MOUNTED_ON
    POWERED_BY
    COOLED_BY
    CONTROLLED_BY
    COMMUNICATES_WITH
    SENDS
    RECEIVES
    READS
    WRITES
    STORES
    PROCESSES
    EXECUTES
    ADDRESSES
    TRANSFERS
    CLOCKS
    SENSES
    DRIVES
    HAS_PORT
    HAS_INTERFACE
    HAS_POWER_REQUIREMENT
    HAS_VOLTAGE
    HAS_CURRENT
    HAS_TEMPERATURE
    HAS_FREQUENCY
    HAS_BANDWIDTH
    HAS_LATENCY
    HAS_STATE
    TRANSITIONS_TO
    HAS_CONFIGURATION
    HAS_VERSION
    FAILS_WITH
    DEPENDS_ON
    PRECEDES
    FOLLOWS
    DERIVED_FROM
    INFERRED_FROM
    HAS_EVIDENCE
    HAS_CONFIDENCE
    HAS_PROVENANCE
    MAPS_TO
    SEMANTICALLY_EQUIVALENT_TO
  }

  INPUTS {
    HARDWARE_SPECIFICATIONS
    COMPONENT_LISTS
    DEVICE_IDENTIFIERS
    PROCESSOR_SPECIFICATIONS
    MEMORY_SPECIFICATIONS
    STORAGE_SPECIFICATIONS
    MOTHERBOARD_SPECIFICATIONS
    INTERFACE_SPECIFICATIONS
    POWER_SPECIFICATIONS
    THERMAL_SPECIFICATIONS
    SENSOR_DATA
    FIRMWARE_DATA
    DEVICE_CONFIGURATION
    PERFORMANCE_METRICS
    FAILURE_RECORDS
    VERSION_DATA
    ONTOLOGY_TERMS
  }

  NORMALISE {
    STANDARDISE_HARDWARE_IDENTIFIERS
    NORMALISE_MANUFACTURER_AND_MODEL_NAMES
    NORMALISE_COMPONENT_TYPES
    NORMALISE_CAPACITY_UNITS
    NORMALISE_FREQUENCY_UNITS
    NORMALISE_VOLTAGE_UNITS
    NORMALISE_CURRENT_UNITS
    NORMALISE_POWER_UNITS
    NORMALISE_TEMPERATURE_UNITS
    NORMALISE_BANDWIDTH_UNITS
    NORMALISE_INTERFACE_NAMES
    NORMALISE_VERSION_IDENTIFIERS
    RESOLVE_COMPONENT_IDENTITIES
    ALIGN_ONTOLOGY_TERMS
    REMOVE_DUPLICATES
    VALIDATE_METADATA
    PRESERVE_PROVENANCE
  }

  PROCESS HARDWARE_REASONING_PIPELINE {
    INPUT
      -> DEVICE_IDENTIFICATION
      -> COMPONENT_RESOLUTION
      -> PHYSICAL_TOPOLOGY_MAPPING
      -> INTERFACE_MAPPING
      -> RESOURCE_MAPPING
      -> POWER_AND_THERMAL_MAPPING
      -> OPERATIONAL_STATE_MAPPING
      -> VALIDATION
      -> OUTPUT
  }

  PROCESS COMPONENT_COMPOSITION {
    COMPUTER_SYSTEM
      -> COMPONENT_SET

    COMPONENT_SET
      -> INTERFACE_COMPATIBILITY_CHECK

    INTERFACE_COMPATIBILITY_CHECK
      -> POWER_COMPATIBILITY_CHECK

    POWER_COMPATIBILITY_CHECK
      -> PHYSICAL_COMPATIBILITY_CHECK

    PHYSICAL_COMPATIBILITY_CHECK
      -> COMPOSED_HARDWARE_SYSTEM
  }

  PROCESS DATA_PATH_REASONING {
    SOURCE_COMPONENT + DATA + DESTINATION_COMPONENT
      -> INTERFACE_SELECTION

    INTERFACE_SELECTION
      -> TRANSFER_PATH

    TRANSFER_PATH
      -> DATA_TRANSFER

    DATA_TRANSFER
      -> DESTINATION_RECEIPT
  }

  PROCESS POWER_REASONING {
    COMPONENT
      -> VOLTAGE_REQUIREMENT
      -> CURRENT_REQUIREMENT
      -> POWER_REQUIREMENT

    COMPONENT_REQUIREMENTS
      -> SYSTEM_POWER_DEMAND

    POWER_SUPPLY_CAPABILITY + SYSTEM_POWER_DEMAND
      -> POWER_FEASIBILITY
  }

  PROCESS THERMAL_REASONING {
    COMPONENT_OPERATION
      -> HEAT_GENERATION

    HEAT_GENERATION
      -> COOLING_REQUIREMENT

    COOLING_SYSTEM
      -> HEAT_REMOVAL

    HEAT_REMOVAL + AMBIENT_CONDITIONS
      -> COMPONENT_TEMPERATURE

    COMPONENT_TEMPERATURE
      -> THERMAL_STATE
  }

  PROCESS DEVICE_IO_REASONING {
    INPUT_DEVICE
      -> INPUT_SIGNAL

    INPUT_SIGNAL
      -> CONTROLLER_OR_INTERFACE

    CONTROLLER_OR_INTERFACE
      -> COMPUTER_SYSTEM

    COMPUTER_SYSTEM
      -> OUTPUT_DATA

    OUTPUT_DATA
      -> OUTPUT_INTERFACE
      -> OUTPUT_DEVICE
  }

  PROCESS FAILURE_REASONING {
    HARDWARE_EVENT + OBSERVED_STATE
      -> FAILURE_DETECTION

    FAILURE_DETECTION
      -> AFFECTED_COMPONENT

    AFFECTED_COMPONENT
      -> DEPENDENCY_AND_IMPACT_ANALYSIS

    DEPENDENCY_AND_IMPACT_ANALYSIS
      -> ROOT_CAUSE_HYPOTHESES
      -> CONFIDENCE_SCORE
  }

  PROCESS PERFORMANCE_REASONING {
    HARDWARE_CONFIGURATION + WORKLOAD
      -> HARDWARE_PROFILE

    HARDWARE_PROFILE
      -> PROCESSING_PERFORMANCE
      -> MEMORY_PERFORMANCE
      -> STORAGE_PERFORMANCE
      -> IO_PERFORMANCE
      -> NETWORK_PERFORMANCE
      -> POWER_PROFILE
      -> THERMAL_PROFILE

    HARDWARE_PROFILE
      -> BOTTLENECK_HYPOTHESIS
  }

  RULES {
    IF HARDWARE_COMPONENT_IS_INSTALLED
    THEN REQUIRE {
      PHYSICAL_INTERFACE
      ELECTRICAL_OR_LOGICAL_INTERFACE
      CONFIGURATION_CONTEXT
    }

    IF COMPONENT_IS_POWERED
    THEN REQUIRE COMPATIBLE_VOLTAGE_CURRENT_AND_POWER_CONTEXT

    IF COMPONENT_TEMPERATURE_EXCEEDS_SPECIFIED_LIMIT
    THEN FLAG THERMAL_RISK

    IF DEVICE_IS_CONNECTED
    THEN DO_NOT_AUTOMATICALLY_ASSERT_DRIVER_OR_PROTOCOL_COMPATIBILITY

    IF TWO_COMPONENTS_SHARE_CONNECTOR_TYPE
    THEN DO_NOT_ASSUME_FULL_FUNCTIONAL_COMPATIBILITY

    IF PERFORMANCE_IS_COMPARED
    THEN REQUIRE WORKLOAD_CONFIGURATION_AND_MEASUREMENT_CONTEXT

    IF FAILURE_IS_OBSERVED
    THEN DO_NOT_ASSERT_ROOT_CAUSE_WITHOUT_EVIDENCE_CHAIN

    IF SEMANTIC_IDENTIFIERS_DIFFER
    AND HARDWARE_REFERENT_IS_SAME
    THEN APPLY SEMANTIC_EQUIVALENCE
  }

  CONFIDENCE {
    CONFIDENCE_SCORE =
      WEIGHT(
        SPECIFICATION_COMPLETENESS,
        COMPONENT_IDENTIFICATION_CERTAINTY,
        INTERFACE_CERTAINTY,
        CONFIGURATION_CERTAINTY,
        SENSOR_DATA_QUALITY,
        MEASUREMENT_REPRODUCIBILITY,
        FAILURE_EVIDENCE_QUALITY,
        PROVENANCE_COMPLETENESS
      )

    LEVELS {
      HIGH
      MODERATE
      LOW
      INSUFFICIENT
    }

    IF MODEL_OR_VERSION_IS_UNKNOWN
    THEN REDUCE_COMPATIBILITY_CONFIDENCE

    IF SENSOR_OR_MEASUREMENT_DATA_IS_UNRELIABLE
    THEN REDUCE_OPERATIONAL_STATE_CONFIDENCE

    IF REPRODUCIBLE_TESTING_CONFIRMS_BEHAVIOUR
    THEN INCREASE CONFIDENCE_SCORE
  }

  SEMANTIC_EQUIVALENCE {
    EQUIVALENCE_KEY =
      NORMALISE(
        ENTITY_TYPE,
        MANUFACTURER,
        MODEL,
        HARDWARE_REVISION,
        INTERFACE_CONTEXT,
        CONFIGURATION
      )

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

    ELSE PRESERVE_DISTINCT_ENTITIES
  }

  REASONING_CONSTRAINTS {
    HARDWARE != SOFTWARE
    DEVICE != DRIVER
    CONNECTOR_COMPATIBILITY != PROTOCOL_COMPATIBILITY
    PHYSICAL_CONNECTION != FUNCTIONAL_OPERATION
    CAPACITY != PERFORMANCE
    CLOCK_RATE != OVERALL_SYSTEM_PERFORMANCE
    THEORETICAL_BANDWIDTH != OBSERVED_BANDWIDTH
    POWER_RATING != ACTUAL_POWER_CONSUMPTION
    TEMPERATURE != HEAT_GENERATION
    FAILURE_SYMPTOM != ROOT_CAUSE
    PERFORMANCE_IS_WORKLOAD_DEPENDENT
    CONFIGURATION_AFFECTS_HARDWARE_BEHAVIOUR
    FIRMWARE_AFFECTS_DEVICE_BEHAVIOUR
    PROVENANCE_MUST_BE_PRESERVED
    UNCERTAINTY_MUST_NOT_BE_DISCARDED
  }

  VALIDATION {
    CHECK_ENTITY_TYPES
    CHECK_HARDWARE_DOMAINS
    CHECK_RELATION_DOMAINS_AND_RANGES
    CHECK_HARDWARE_IDENTIFIERS
    CHECK_COMPONENT_TOPOLOGY
    CHECK_INTERFACES
    CHECK_POWER_REQUIREMENTS
    CHECK_THERMAL_LIMITS
    CHECK_FIRMWARE_CONTEXT
    CHECK_DEVICE_CONFIGURATION
    CHECK_PERFORMANCE_CONTEXT
    CHECK_FAILURE_RELATIONS
    CHECK_VERSION_CONTEXT
    CHECK_PROVENANCE
    CHECK_CONFIDENCE
    CHECK_SEMANTIC_CONSISTENCY
  }

  OUTPUTS {
    NORMALISED_HARDWARE_ENTITIES
    HARDWARE_DOMAIN_RELATIONS
    COMPONENT_TOPOLOGY
    INTERFACE_RELATIONS
    DATA_PATH_RELATIONS
    POWER_RELATIONS
    THERMAL_RELATIONS
    DEVICE_IO_RELATIONS
    OPERATIONAL_STATE_RELATIONS
    FAILURE_HYPOTHESES
    PERFORMANCE_PROFILES
    BOTTLENECK_HYPOTHESES
    CONFIDENCE_SCORES
    EVIDENCE_LINKS
    PROVENANCE_RECORDS
    EXPLANATION_PATHS
  }

  UPDATE_MODEL {
    ON HARDWARE_OR_CONFIGURATION_CHANGE {
      NORMALISE
      ENTITY_RESOLUTION
      UPDATE_COMPONENT_TOPOLOGY
      UPDATE_INTERFACES
      UPDATE_POWER_MODEL
      UPDATE_THERMAL_MODEL
      UPDATE_CONFIGURATION
      RECOMPUTE_AFFECTED_RELATIONS
      UPDATE_CONFIDENCE
      PRESERVE_VERSION_HISTORY
    }

    ON NEW_SENSOR_PERFORMANCE_OR_FAILURE_DATA {
      LINK_EVIDENCE
      UPDATE_OPERATIONAL_STATE
      UPDATE_POWER_AND_THERMAL_PROFILE
      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,
        HARDWARE_DOMAINS,
        RELATIONSHIPS,
        RULES,
        CONFIDENCE,
        SEMANTIC_EQUIVALENCE,
        REASONING_CONSTRAINTS,
        UPDATE_MODEL
      )

    FLOW_HASH = SHA256(HASH_INPUT)
  }

  AI_CONSUMPTION {
    INDEX {
      ONTOLOGY
      ENTITY_TYPES
      HARDWARE_DOMAINS
      RELATIONSHIPS
      RULES
      OUTPUTS
    }

    RETRIEVE {
      BY_HARDWARE
      BY_COMPONENT
      BY_DEVICE
      BY_PROCESSOR
      BY_MEMORY
      BY_STORAGE
      BY_INTERFACE
      BY_POWER
      BY_TEMPERATURE
      BY_FAILURE
      BY_PERFORMANCE
      BY_CONFIGURATION
      BY_CONFIDENCE
    }

    REASON {
      APPLY_RELATIONSHIPS
      APPLY_RULES
      TRACE_COMPONENT_TOPOLOGY
      TRACE_DATA_PATHS
      ANALYSE_INTERFACE_COMPATIBILITY
      ANALYSE_POWER_REQUIREMENTS
      ANALYSE_THERMAL_STATE
      ANALYSE_DEVICE_IO
      ANALYSE_FAILURES
      ANALYSE_PERFORMANCE
      CHECK_SEMANTIC_EQUIVALENCE
      PRESERVE_UNCERTAINTY
      TRACE_EVIDENCE
      TRACE_PROVENANCE
      GENERATE_EXPLANATION_PATH
    }

    RESPONSE_POLICY {
      DISTINGUISH_HARDWARE_FROM_SOFTWARE
      DISTINGUISH_CONNECTION_FROM_COMPATIBILITY
      PRESERVE_MODEL_VERSION_AND_CONFIGURATION_CONTEXT
      PRESERVE_POWER_AND_THERMAL_CONTEXT
      DISTINGUISH_FAILURE_SYMPTOM_FROM_ROOT_CAUSE
      RETURN_CONFIDENCE_WHEN_AVAILABLE
      RETURN_PROVENANCE_WHEN_AVAILABLE
      AVOID_UNSUPPORTED_HARDWARE_INFERENCE
    }
  }

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

END FLOW