Peripheral Device Ontology

AI SEARCH

FLOW ALGEBRA — PERIPHERAL DEVICE ONTOLOGY
Semantic Library
Version: 4.0
Canonical Page:
https://kirethresearch.org/booksai-core/ontologies/computing-ontologies/computer-hardware/peripheral-device-ontology.html

FLOW PERIPHERAL_DEVICE_ONTOLOGY {

  META {
    DOMAIN = "Computing Ontologies"
    SUBDOMAIN = "Computer Hardware"
    ONTOLOGY = "Peripheral Device Ontology"
    PURPOSE = "Formalise peripheral hardware devices, their functional classes, interfaces, controllers, drivers, data transfers, operational states, compatibility and failure relationships."
    LOCALE = "en-GB"
  }

  ENTITY_TYPES {
    PERIPHERAL_DEVICE
    INPUT_DEVICE
    OUTPUT_DEVICE
    INPUT_OUTPUT_DEVICE
    STORAGE_PERIPHERAL
    COMMUNICATION_PERIPHERAL
    HUMAN_INTERFACE_DEVICE
    KEYBOARD
    MOUSE
    TOUCHPAD
    GAME_CONTROLLER
    SCANNER
    CAMERA
    WEBCAM
    MICROPHONE
    DISPLAY
    MONITOR
    PROJECTOR
    PRINTER
    SPEAKER
    HEADPHONE
    EXTERNAL_STORAGE_DEVICE
    USB_FLASH_DRIVE
    EXTERNAL_HARD_DRIVE
    EXTERNAL_SSD
    CARD_READER
    NETWORK_ADAPTER
    MODEM
    DOCKING_STATION
    HUB
    CONTROLLER
    DEVICE_CONTROLLER
    HOST_CONTROLLER
    INTERFACE
    PORT
    CONNECTOR
    USB
    THUNDERBOLT
    PCIE
    BLUETOOTH
    WIFI
    ETHERNET
    HDMI
    DISPLAYPORT
    AUDIO_INTERFACE
    SERIAL_INTERFACE
    DEVICE_DRIVER
    FIRMWARE
    DEVICE_CLASS
    DEVICE_IDENTIFIER
    SIGNAL
    DATA
    INPUT_DATA
    OUTPUT_DATA
    COMMAND
    REQUEST
    RESPONSE
    TRANSFER
    BANDWIDTH
    LATENCY
    DATA_RATE
    POWER
    VOLTAGE
    CURRENT
    TEMPERATURE
    STATE
    DEVICE_STATE
    EVENT
    CONNECTION_EVENT
    DISCONNECTION_EVENT
    ERROR
    FAILURE
    CONFIGURATION
    HARDWARE_REVISION
    FIRMWARE_VERSION
    DRIVER_VERSION
    EVIDENCE
    CONFIDENCE_SCORE
    PROVENANCE_RECORD
  }

  RELATIONSHIPS {
    IS_A
    INSTANCE_OF
    PART_OF
    CONTAINS
    HAS_CONTROLLER
    HAS_INTERFACE
    HAS_PORT
    HAS_CONNECTOR
    HAS_DRIVER
    HAS_FIRMWARE
    CONNECTED_TO
    INTERFACES_WITH
    ATTACHED_TO
    COMMUNICATES_WITH
    SENDS
    RECEIVES
    READS
    WRITES
    TRANSFERS
    CAPTURES
    OUTPUTS
    STORES
    RETRIEVES
    CONTROLS
    ENUMERATES
    IDENTIFIES
    CONFIGURES
    POWERS
    HAS_DEVICE_CLASS
    HAS_IDENTIFIER
    HAS_BANDWIDTH
    HAS_LATENCY
    HAS_DATA_RATE
    HAS_POWER
    HAS_VOLTAGE
    HAS_CURRENT
    HAS_TEMPERATURE
    HAS_STATE
    TRANSITIONS_TO
    HAS_CONFIGURATION
    HAS_HARDWARE_REVISION
    HAS_FIRMWARE_VERSION
    HAS_DRIVER_VERSION
    FAILS_WITH
    DEPENDS_ON
    PRECEDES
    FOLLOWS
    DERIVED_FROM
    INFERRED_FROM
    HAS_EVIDENCE
    HAS_CONFIDENCE
    HAS_PROVENANCE
    MAPS_TO
    SEMANTICALLY_EQUIVALENT_TO
  }

  INPUTS {
    DEVICE_SPECIFICATIONS
    MANUFACTURER_DATA
    MODEL_DATA
    DEVICE_CLASS_DATA
    DEVICE_IDENTIFIER_DATA
    INTERFACE_DATA
    PORT_AND_CONNECTOR_DATA
    CONTROLLER_DATA
    TRANSFER_TRACES
    BANDWIDTH_DATA
    LATENCY_DATA
    POWER_DATA
    TEMPERATURE_DATA
    DRIVER_DATA
    FIRMWARE_DATA
    CONFIGURATION_DATA
    HARDWARE_REVISION_DATA
    CONNECTION_EVENTS
    ERROR_LOGS
    FAILURE_RECORDS
    ONTOLOGY_TERMS
  }

  NORMALISE {
    STANDARDISE_DEVICE_IDENTIFIERS
    NORMALISE_MANUFACTURER_NAMES
    NORMALISE_MODEL_NAMES
    NORMALISE_DEVICE_CLASSES
    NORMALISE_INTERFACE_NAMES
    NORMALISE_PORT_NAMES
    NORMALISE_CONNECTOR_NAMES
    NORMALISE_PROTOCOL_NAMES
    NORMALISE_BANDWIDTH_UNITS
    NORMALISE_LATENCY_UNITS
    NORMALISE_POWER_UNITS
    NORMALISE_VOLTAGE_UNITS
    NORMALISE_TEMPERATURE_UNITS
    NORMALISE_DRIVER_VERSIONS
    NORMALISE_FIRMWARE_VERSIONS
    NORMALISE_HARDWARE_REVISIONS
    RESOLVE_DEVICE_IDENTITIES
    ALIGN_ONTOLOGY_TERMS
    REMOVE_DUPLICATES
    VALIDATE_METADATA
    PRESERVE_PROVENANCE
  }

  PROCESS PERIPHERAL_REASONING_PIPELINE {
    DEVICE_CONNECTION
      -> PHYSICAL_INTERFACE_DETECTION
      -> ELECTRICAL_OR_LINK_INITIALISATION
      -> DEVICE_ENUMERATION
      -> DEVICE_IDENTIFICATION
      -> DRIVER_BINDING
      -> DEVICE_CONFIGURATION
      -> DATA_OR_COMMAND_TRANSFER
      -> OPERATIONAL_STATE
  }

  PROCESS DEVICE_ENUMERATION {
    CONNECTION_EVENT
      -> HOST_CONTROLLER_DETECTION

    HOST_CONTROLLER_DETECTION
      -> DEVICE_DESCRIPTOR_OR_IDENTIFIER_REQUEST

    DEVICE_RESPONSE
      -> DEVICE_CLASS_RESOLUTION

    DEVICE_CLASS_RESOLUTION
      -> DRIVER_SELECTION

    DRIVER_SELECTION
      -> DEVICE_INITIALISATION
  }

  PROCESS INTERFACE_REASONING {
    PERIPHERAL_DEVICE + HOST_SYSTEM
      -> CONNECTOR_COMPATIBILITY_CHECK

    CONNECTOR_COMPATIBILITY_CHECK
      -> ELECTRICAL_COMPATIBILITY_CHECK

    ELECTRICAL_COMPATIBILITY_CHECK
      -> PROTOCOL_COMPATIBILITY_CHECK

    PROTOCOL_COMPATIBILITY_CHECK
      -> DRIVER_SUPPORT_CHECK

    DRIVER_SUPPORT_CHECK
      -> FUNCTIONAL_COMPATIBILITY_RESULT
  }

  PROCESS DATA_TRANSFER_REASONING {
    SOURCE
      -> TRANSFER_REQUEST

    TRANSFER_REQUEST
      -> INTERFACE_PROTOCOL

    INTERFACE_PROTOCOL
      -> DATA_TRANSFER

    DATA_TRANSFER
      -> DESTINATION

    DESTINATION
      -> ACKNOWLEDGEMENT_OR_RESPONSE
  }

  PROCESS HOT_PLUG_REASONING {
    CONNECTION_EVENT
      -> DEVICE_DETECTION
      -> ENUMERATION
      -> DRIVER_BINDING
      -> AVAILABLE_STATE

    DISCONNECTION_EVENT
      -> TRANSFER_TERMINATION
      -> RESOURCE_RELEASE
      -> DEVICE_REMOVAL_STATE
  }

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

    HOST_OR_EXTERNAL_POWER_SOURCE
      -> AVAILABLE_POWER

    AVAILABLE_POWER + DEVICE_REQUIREMENT
      -> POWER_FEASIBILITY
  }

  PROCESS PERFORMANCE_REASONING {
    PERIPHERAL_DEVICE + INTERFACE + WORKLOAD
      -> TRANSFER_PROFILE

    TRANSFER_PROFILE
      -> LATENCY
      -> DATA_RATE
      -> EFFECTIVE_BANDWIDTH
      -> QUEUEING_OR_PROTOCOL_OVERHEAD

    TRANSFER_PROFILE
      -> BOTTLENECK_HYPOTHESIS
  }

  PROCESS FAILURE_REASONING {
    EXPECTED_DEVICE_BEHAVIOUR + OBSERVED_STATE
      -> DIFFERENCE_ANALYSIS

    DIFFERENCE_ANALYSIS
      -> CONNECTION_CANDIDATE
      -> POWER_CANDIDATE
      -> DRIVER_CANDIDATE
      -> FIRMWARE_CANDIDATE
      -> HARDWARE_CANDIDATE

    EVIDENCE
      -> ROOT_CAUSE_HYPOTHESIS
      -> CONFIDENCE_SCORE
  }

  RULES {
    IF PERIPHERAL_IS_CONNECTED
    THEN DO_NOT_AUTOMATICALLY_ASSERT_FUNCTIONAL_OPERATION

    IF CONNECTOR_TYPES_MATCH
    THEN REQUIRE ELECTRICAL_PROTOCOL_DRIVER_AND_CONFIGURATION_CHECKS

    IF DEVICE_IS_ENUMERATED
    THEN DO_NOT_AUTOMATICALLY_ASSERT_ALL_DEVICE_FUNCTIONS_ARE_AVAILABLE

    IF DRIVER_IS_BOUND
    THEN PRESERVE DRIVER_VERSION_AND_CONFIGURATION_CONTEXT

    IF BUS_POWERED_DEVICE_IS_USED
    THEN REQUIRE HOST_POWER_BUDGET_COMPATIBILITY

    IF INTERFACE_HAS_HIGHER_THEORETICAL_BANDWIDTH
    THEN DO_NOT_AUTOMATICALLY_INFER_HIGHER_DEVICE_PERFORMANCE

    IF FAILURE_IS_OBSERVED
    THEN DO_NOT_ASSERT_DEVICE_HARDWARE_ROOT_CAUSE_WITHOUT_INTERFACE_POWER_DRIVER_AND_FIRMWARE_CHECKS

    IF SEMANTIC_IDENTIFIERS_DIFFER
    AND PERIPHERAL_REFERENT_IS_SAME
    THEN APPLY SEMANTIC_EQUIVALENCE
  }

  CONFIDENCE {
    CONFIDENCE_SCORE =
      WEIGHT(
        DEVICE_SPECIFICATION_COMPLETENESS,
        DEVICE_IDENTIFICATION_CERTAINTY,
        INTERFACE_CERTAINTY,
        DRIVER_AND_FIRMWARE_CERTAINTY,
        CONFIGURATION_CERTAINTY,
        TRANSFER_TRACE_COMPLETENESS,
        FAILURE_EVIDENCE_QUALITY,
        PROVENANCE_COMPLETENESS
      )

    LEVELS {
      HIGH
      MODERATE
      LOW
      INSUFFICIENT
    }

    IF DEVICE_IDENTIFIER_IS_AMBIGUOUS
    THEN REDUCE_DEVICE_RESOLUTION_CONFIDENCE

    IF DRIVER_OR_FIRMWARE_CONTEXT_IS_UNKNOWN
    THEN REDUCE_FUNCTIONAL_COMPATIBILITY_CONFIDENCE

    IF REPRODUCIBLE_DEVICE_TESTS_CONFIRM_OPERATION
    THEN INCREASE CONFIDENCE_SCORE
  }

  SEMANTIC_EQUIVALENCE {
    EQUIVALENCE_KEY =
      NORMALISE(
        ENTITY_TYPE,
        MANUFACTURER,
        MODEL,
        DEVICE_IDENTIFIER,
        HARDWARE_REVISION,
        INTERFACE,
        FIRMWARE_VERSION
      )

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

    ELSE PRESERVE_DISTINCT_ENTITIES
  }

  REASONING_CONSTRAINTS {
    PERIPHERAL_DEVICE != DEVICE_DRIVER
    CONNECTION != FUNCTIONAL_OPERATION
    CONNECTOR_MATCH != PROTOCOL_COMPATIBILITY
    ENUMERATION != FULL_FUNCTIONAL_SUPPORT
    DEVICE_CLASS != SPECIFIC_DEVICE_MODEL
    THEORETICAL_INTERFACE_BANDWIDTH != OBSERVED_DEVICE_THROUGHPUT
    LATENCY != BANDWIDTH
    BUS_POWER_AVAILABILITY != GUARANTEED_SUFFICIENT_POWER
    DRIVER_VERSION_AFFECTS_DEVICE_BEHAVIOUR
    FIRMWARE_VERSION_AFFECTS_DEVICE_BEHAVIOUR
    CONFIGURATION_AFFECTS_DEVICE_BEHAVIOUR
    HOT_PLUG_SUPPORT_IS_INTERFACE_AND_DEVICE_DEPENDENT
    FAILURE_SYMPTOM != ROOT_CAUSE
    PROVENANCE_MUST_BE_PRESERVED
    UNCERTAINTY_MUST_NOT_BE_DISCARDED
  }

  VALIDATION {
    CHECK_ENTITY_TYPES
    CHECK_RELATION_DOMAINS_AND_RANGES
    CHECK_DEVICE_IDENTIFIER
    CHECK_DEVICE_CLASS
    CHECK_INTERFACE
    CHECK_PORT_AND_CONNECTOR
    CHECK_PROTOCOL
    CHECK_DRIVER_SUPPORT
    CHECK_FIRMWARE_VERSION
    CHECK_POWER_REQUIREMENTS
    CHECK_CONNECTION_STATE
    CHECK_TRANSFER_RELATIONS
    CHECK_PERFORMANCE_CONTEXT
    CHECK_CONFIGURATION
    CHECK_HARDWARE_REVISION
    CHECK_FAILURE_RELATIONS
    CHECK_PROVENANCE
    CHECK_CONFIDENCE
    CHECK_SEMANTIC_CONSISTENCY
  }

  OUTPUTS {
    NORMALISED_PERIPHERAL_ENTITIES
    DEVICE_CLASS_RELATIONS
    INTERFACE_RELATIONS
    PORT_AND_CONNECTOR_RELATIONS
    ENUMERATION_RELATIONS
    DRIVER_BINDING_RELATIONS
    FIRMWARE_RELATIONS
    FUNCTIONAL_COMPATIBILITY_RELATIONS
    DATA_TRANSFER_RELATIONS
    POWER_RELATIONS
    DEVICE_STATE_TRANSITIONS
    PERFORMANCE_PROFILES
    FAILURE_HYPOTHESES
    BOTTLENECK_HYPOTHESES
    CONFIDENCE_SCORES
    EVIDENCE_LINKS
    PROVENANCE_RECORDS
    EXPLANATION_PATHS
  }

  UPDATE_MODEL {
    ON DEVICE_DRIVER_FIRMWARE_OR_CONFIGURATION_CHANGE {
      NORMALISE
      ENTITY_RESOLUTION
      UPDATE_INTERFACE_CONTEXT
      UPDATE_DEVICE_CLASS
      UPDATE_DRIVER_BINDING
      UPDATE_FIRMWARE_CONTEXT
      UPDATE_POWER_CONTEXT
      RECOMPUTE_AFFECTED_RELATIONS
      UPDATE_CONFIDENCE
      PRESERVE_VERSION_HISTORY
    }

    ON NEW_CONNECTION_TRANSFER_OR_FAILURE_DATA {
      LINK_EVIDENCE
      UPDATE_DEVICE_STATE
      UPDATE_TRANSFER_PROFILE
      UPDATE_CONNECTION_RELATIONS
      REASSESS_FUNCTIONAL_COMPATIBILITY
      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_PERIPHERAL
      BY_DEVICE_CLASS
      BY_DEVICE_IDENTIFIER
      BY_INTERFACE
      BY_PORT
      BY_CONNECTOR
      BY_DRIVER
      BY_FIRMWARE
      BY_CONNECTION_STATE
      BY_TRANSFER
      BY_POWER
      BY_FAILURE
      BY_CONFIDENCE
    }

    REASON {
      APPLY_RELATIONSHIPS
      APPLY_RULES
      TRACE_DEVICE_ENUMERATION
      ANALYSE_INTERFACE_COMPATIBILITY
      TRACE_DATA_TRANSFERS
      ANALYSE_HOT_PLUG_EVENTS
      ANALYSE_POWER_REQUIREMENTS
      ANALYSE_PERFORMANCE
      ANALYSE_FAILURES
      CHECK_SEMANTIC_EQUIVALENCE
      PRESERVE_UNCERTAINTY
      TRACE_EVIDENCE
      TRACE_PROVENANCE
      GENERATE_EXPLANATION_PATH
    }

    RESPONSE_POLICY {
      DISTINGUISH_CONNECTION_FROM_FUNCTIONAL_OPERATION
      DISTINGUISH_DEVICE_FROM_DRIVER
      PRESERVE_INTERFACE_DRIVER_FIRMWARE_AND_CONFIGURATION_CONTEXT
      DISTINGUISH_ENUMERATION_FROM_FULL_FUNCTIONAL_SUPPORT
      DISTINGUISH_THEORETICAL_FROM_OBSERVED_PERFORMANCE
      DISTINGUISH_FAILURE_SYMPTOM_FROM_ROOT_CAUSE
      RETURN_CONFIDENCE_WHEN_AVAILABLE
      RETURN_PROVENANCE_WHEN_AVAILABLE
      AVOID_UNSUPPORTED_PERIPHERAL_INFERENCE
    }
  }

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

END FLOW