ROM Ontology

AI SEARCH

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

FLOW ROM_ONTOLOGY {

  META {
    DOMAIN = "Computing Ontologies"
    SUBDOMAIN = "Computer Hardware"
    ONTOLOGY = "ROM Ontology"
    PURPOSE = "Formalise read-only and non-volatile memory technologies, stored firmware, addressing, programming, erasure, read operations, persistence and reliability relationships."
    LOCALE = "en-GB"
  }

  ENTITY_TYPES {
    ROM
    READ_ONLY_MEMORY
    NON_VOLATILE_MEMORY
    MASK_ROM
    PROM
    EPROM
    EEPROM
    FLASH_MEMORY
    NOR_FLASH
    NAND_FLASH
    MEMORY_CHIP
    MEMORY_CELL
    MEMORY_ARRAY
    MEMORY_BLOCK
    MEMORY_PAGE
    WORD
    BYTE
    BIT
    ADDRESS
    MEMORY_LOCATION
    DATA
    STORED_VALUE
    FIRMWARE
    BOOT_FIRMWARE
    BIOS
    UEFI
    MICROCODE
    READ_OPERATION
    PROGRAM_OPERATION
    WRITE_OPERATION
    ERASE_OPERATION
    VERIFY_OPERATION
    PROGRAMMER
    MEMORY_CONTROLLER
    ADDRESS_BUS
    DATA_BUS
    CONTROL_BUS
    CHIP_SELECT
    READ_ENABLE
    WRITE_ENABLE
    ERASE_ENABLE
    CAPACITY
    ACCESS_TIME
    LATENCY
    DATA_RATE
    VOLTAGE
    PROGRAMMING_VOLTAGE
    POWER
    TEMPERATURE
    RETENTION_TIME
    ENDURANCE
    PROGRAM_ERASE_CYCLE
    BIT_ERROR
    ERROR_CORRECTION
    ECC
    STATE
    EVENT
    LOCK_STATE
    WRITE_PROTECTION
    CONFIGURATION
    HARDWARE_REVISION
    VERSION
    EVIDENCE
    CONFIDENCE_SCORE
    PROVENANCE_RECORD
  }

  RELATIONSHIPS {
    IS_A
    INSTANCE_OF
    PART_OF
    CONTAINS
    HAS_CELL
    HAS_ARRAY
    HAS_BLOCK
    HAS_PAGE
    HAS_ADDRESS
    STORES
    HOLDS
    READS
    PROGRAMS
    WRITES
    ERASES
    VERIFIES
    ADDRESSES
    SELECTS
    ENABLES
    PROTECTS
    LOCKS
    UNLOCKS
    PERSISTS_WITHOUT
    CONTAINS_FIRMWARE
    HAS_CAPACITY
    HAS_ACCESS_TIME
    HAS_LATENCY
    HAS_DATA_RATE
    HAS_VOLTAGE
    HAS_PROGRAMMING_VOLTAGE
    HAS_POWER
    HAS_TEMPERATURE
    HAS_RETENTION_TIME
    HAS_ENDURANCE
    HAS_ECC
    DETECTS_ERROR
    CORRECTS_ERROR
    HAS_STATE
    TRANSITIONS_TO
    HAS_CONFIGURATION
    HAS_HARDWARE_REVISION
    HAS_VERSION
    DEPENDS_ON
    PRECEDES
    FOLLOWS
    DERIVED_FROM
    INFERRED_FROM
    HAS_EVIDENCE
    HAS_CONFIDENCE
    HAS_PROVENANCE
    MAPS_TO
    SEMANTICALLY_EQUIVALENT_TO
  }

  INPUTS {
    ROM_SPECIFICATIONS
    MEMORY_TECHNOLOGY_DATA
    CHIP_DATA
    CAPACITY_DATA
    ADDRESS_MAPS
    FIRMWARE_IMAGES
    FIRMWARE_VERSION_DATA
    READ_TRACES
    PROGRAMMING_DATA
    ERASE_DATA
    ACCESS_TIME_DATA
    VOLTAGE_DATA
    POWER_DATA
    TEMPERATURE_DATA
    RETENTION_DATA
    ENDURANCE_DATA
    ECC_DATA
    ERROR_LOGS
    WRITE_PROTECTION_DATA
    CONFIGURATION_DATA
    HARDWARE_REVISION_DATA
    VERSION_DATA
    ONTOLOGY_TERMS
  }

  NORMALISE {
    STANDARDISE_ROM_IDENTIFIERS
    NORMALISE_MEMORY_TECHNOLOGY_NAMES
    NORMALISE_CAPACITY_UNITS
    NORMALISE_ADDRESS_FORMATS
    NORMALISE_ACCESS_TIME_UNITS
    NORMALISE_VOLTAGE_UNITS
    NORMALISE_POWER_UNITS
    NORMALISE_TEMPERATURE_UNITS
    NORMALISE_RETENTION_UNITS
    NORMALISE_ENDURANCE_MEASURES
    NORMALISE_FIRMWARE_VERSIONS
    NORMALISE_ERROR_TYPES
    NORMALISE_HARDWARE_REVISIONS
    NORMALISE_VERSION_IDENTIFIERS
    RESOLVE_MEMORY_IDENTITIES
    ALIGN_ONTOLOGY_TERMS
    REMOVE_DUPLICATES
    VALIDATE_METADATA
    PRESERVE_PROVENANCE
  }

  PROCESS ROM_READ_PIPELINE {
    READ_REQUEST
      -> ADDRESS_SELECTION
      -> MEMORY_LOCATION_RESOLUTION
      -> CHIP_OR_ARRAY_SELECTION
      -> STORED_STATE_SENSE
      -> DATA_DECODE
      -> DATA_RETURN
  }

  PROCESS PROGRAMMING_REASONING {
    PROGRAM_DATA + TARGET_ADDRESS
      -> TECHNOLOGY_PROGRAMMABILITY_CHECK

    PROGRAMMABLE_MEMORY
      -> WRITE_PROTECTION_CHECK

    WRITE_ALLOWED
      -> PROGRAM_OPERATION

    PROGRAM_OPERATION
      -> VERIFY_OPERATION

    VERIFY_OPERATION
      -> PROGRAM_SUCCESS_OR_FAILURE
  }

  PROCESS ERASE_REASONING {
    ERASE_REQUEST
      -> MEMORY_TECHNOLOGY_CHECK

    ERASABLE_MEMORY
      -> ERASE_GRANULARITY_SELECTION

    ERASE_GRANULARITY_SELECTION
      -> CHIP_OR_BLOCK_OR_PAGE_ERASE

    ERASE_OPERATION
      -> ERASED_STATE

    ERASED_STATE
      -> VERIFY_OPERATION
  }

  PROCESS FIRMWARE_REASONING {
    ROM_OR_NON_VOLATILE_MEMORY
      -> STORED_FIRMWARE

    STORED_FIRMWARE
      -> FIRMWARE_VERSION

    SYSTEM_START_OR_DEVICE_INITIALISATION
      -> FIRMWARE_READ

    FIRMWARE_READ
      -> EXECUTION_OR_CONFIGURATION_HANDOFF
  }

  PROCESS RETENTION_REASONING {
    STORED_STATE + TIME + TEMPERATURE_CONTEXT
      -> RETENTION_ASSESSMENT

    RETENTION_ASSESSMENT
      -> STABLE_STATE
      OR -> DEGRADATION_RISK

    DEGRADATION_RISK
      -> ERROR_PROBABILITY_INCREASE
  }

  PROCESS ENDURANCE_REASONING {
    PROGRAM_ERASE_CYCLES
      -> ENDURANCE_USAGE

    ENDURANCE_USAGE + TECHNOLOGY_LIMIT
      -> REMAINING_ENDURANCE_ESTIMATE

    EXCESSIVE_CYCLING
      -> WEAR_RISK
  }

  PROCESS ERROR_REASONING {
    STORED_DATA
      -> READ_AND_INTEGRITY_CHECK

    INTEGRITY_CHECK
      -> NO_ERROR
      OR -> CORRECTABLE_ERROR
      OR -> UNCORRECTABLE_ERROR

    CORRECTABLE_ERROR
      -> ECC_CORRECTION
      -> CORRECTED_DATA

    UNCORRECTABLE_ERROR
      -> ERROR_REPORT
  }

  RULES {
    IF ENTITY == MASK_ROM
    THEN DO_NOT_ASSERT_FIELD_REPROGRAMMABILITY

    IF ENTITY == PROM
    THEN PRESERVE ONE_TIME_PROGRAMMABLE_CONTEXT

    IF ENTITY == EPROM
    THEN PRESERVE ERASE_METHOD_AND_REPROGRAMMING_CONTEXT

    IF ENTITY == EEPROM_OR_FLASH_MEMORY
    THEN PRESERVE PROGRAM_ERASE_GRANULARITY_AND_ENDURANCE_CONTEXT

    IF READ_OPERATION_OCCURS
    THEN DO_NOT_INFER_MEMORY_STATE_CHANGE_FROM_READ_ALONE

    IF FIRMWARE_VERSION_DIFFERS
    THEN DO_NOT_ASSUME_IDENTICAL_DEVICE_BEHAVIOUR

    IF WRITE_PROTECTION_IS_ACTIVE
    THEN BLOCK_OR_FLAG_PROGRAM_OPERATION

    IF SEMANTIC_IDENTIFIERS_DIFFER
    AND ROM_REFERENT_IS_SAME
    THEN APPLY SEMANTIC_EQUIVALENCE
  }

  CONFIDENCE {
    CONFIDENCE_SCORE =
      WEIGHT(
        ROM_SPECIFICATION_COMPLETENESS,
        TECHNOLOGY_CERTAINTY,
        ADDRESS_MAPPING_CERTAINTY,
        FIRMWARE_VERSION_CERTAINTY,
        PROGRAM_ERASE_HISTORY_QUALITY,
        RETENTION_CONTEXT_QUALITY,
        ERROR_LOG_QUALITY,
        PROVENANCE_COMPLETENESS
      )

    LEVELS {
      HIGH
      MODERATE
      LOW
      INSUFFICIENT
    }

    IF MEMORY_TECHNOLOGY_IS_UNKNOWN
    THEN REDUCE_PROGRAMMABILITY_AND_ENDURANCE_CONFIDENCE

    IF FIRMWARE_VERSION_IS_UNKNOWN
    THEN REDUCE_FIRMWARE_BEHAVIOUR_CONFIDENCE

    IF VERIFIED_READBACK_CONFIRMS_PROGRAMMED_DATA
    THEN INCREASE CONFIDENCE_SCORE
  }

  SEMANTIC_EQUIVALENCE {
    EQUIVALENCE_KEY =
      NORMALISE(
        ENTITY_TYPE,
        CANONICAL_IDENTIFIER,
        MEMORY_TECHNOLOGY,
        CAPACITY,
        FIRMWARE_VERSION,
        HARDWARE_REVISION,
        CONFIGURATION
      )

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

    ELSE PRESERVE_DISTINCT_ENTITIES
  }

  REASONING_CONSTRAINTS {
    ROM != RAM
    READ_ONLY != NECESSARILY_FACTORY_IMMUTABLE_FOR_ALL_ROM_FAMILIES
    NON_VOLATILE != INFINITE_RETENTION
    READ_OPERATION != PROGRAM_OPERATION
    PROGRAM_OPERATION != ERASE_OPERATION
    PROM != EEPROM
    EPROM != EEPROM
    FLASH_MEMORY != MASK_ROM
    FIRMWARE != MEMORY_DEVICE
    CAPACITY != PERFORMANCE
    RETENTION_DEPENDS_ON_TECHNOLOGY_AND_CONDITIONS
    ENDURANCE_DEPENDS_ON_PROGRAM_ERASE_HISTORY
    ECC_DETECTION != ALWAYS_CORRECTION
    FIRMWARE_VERSION_AFFECTS_SYSTEM_BEHAVIOUR
    PROVENANCE_MUST_BE_PRESERVED
    UNCERTAINTY_MUST_NOT_BE_DISCARDED
  }

  VALIDATION {
    CHECK_ENTITY_TYPES
    CHECK_RELATION_DOMAINS_AND_RANGES
    CHECK_ROM_IDENTIFIER
    CHECK_MEMORY_TECHNOLOGY
    CHECK_CAPACITY
    CHECK_ADDRESS_MAPPING
    CHECK_READ_RELATIONS
    CHECK_PROGRAMMABILITY
    CHECK_ERASE_METHOD
    CHECK_WRITE_PROTECTION
    CHECK_FIRMWARE_VERSION
    CHECK_RETENTION_CONTEXT
    CHECK_ENDURANCE_CONTEXT
    CHECK_ECC_AND_ERROR_RELATIONS
    CHECK_VOLTAGE_AND_TEMPERATURE_CONTEXT
    CHECK_HARDWARE_REVISION
    CHECK_VERSION_CONTEXT
    CHECK_PROVENANCE
    CHECK_CONFIDENCE
    CHECK_SEMANTIC_CONSISTENCY
  }

  OUTPUTS {
    NORMALISED_ROM_ENTITIES
    MEMORY_TECHNOLOGY_RELATIONS
    ADDRESS_MAPPING_RELATIONS
    READ_RELATIONS
    PROGRAMMING_RELATIONS
    ERASE_RELATIONS
    WRITE_PROTECTION_RELATIONS
    FIRMWARE_RELATIONS
    RETENTION_RELATIONS
    ENDURANCE_RELATIONS
    ECC_AND_ERROR_RELATIONS
    MEMORY_STATE_TRANSITIONS
    CONFIDENCE_SCORES
    EVIDENCE_LINKS
    PROVENANCE_RECORDS
    EXPLANATION_PATHS
  }

  UPDATE_MODEL {
    ON ROM_FIRMWARE_OR_CONFIGURATION_CHANGE {
      NORMALISE
      ENTITY_RESOLUTION
      UPDATE_ADDRESS_MAPPING
      UPDATE_FIRMWARE_CONTEXT
      UPDATE_WRITE_PROTECTION_STATE
      UPDATE_ENDURANCE_STATE
      RECOMPUTE_AFFECTED_RELATIONS
      UPDATE_CONFIDENCE
      PRESERVE_VERSION_HISTORY
    }

    ON NEW_READ_PROGRAM_ERASE_OR_ERROR_DATA {
      LINK_EVIDENCE
      UPDATE_MEMORY_STATE
      UPDATE_PROGRAM_ERASE_HISTORY
      UPDATE_ERROR_PROFILE
      REASSESS_RETENTION_AND_ENDURANCE
      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_ROM
      BY_MEMORY_TECHNOLOGY
      BY_CHIP
      BY_ADDRESS
      BY_FIRMWARE
      BY_PROGRAM_OPERATION
      BY_ERASE_OPERATION
      BY_RETENTION
      BY_ENDURANCE
      BY_WRITE_PROTECTION
      BY_ERROR
      BY_CONFIDENCE
    }

    REASON {
      APPLY_RELATIONSHIPS
      APPLY_RULES
      TRACE_ROM_READS
      TRACE_PROGRAMMING
      TRACE_ERASURE
      ANALYSE_FIRMWARE
      ANALYSE_RETENTION
      ANALYSE_ENDURANCE
      ANALYSE_ERRORS_AND_ECC
      CHECK_SEMANTIC_EQUIVALENCE
      PRESERVE_UNCERTAINTY
      TRACE_EVIDENCE
      TRACE_PROVENANCE
      GENERATE_EXPLANATION_PATH
    }

    RESPONSE_POLICY {
      DISTINGUISH_ROM_TECHNOLOGIES
      DISTINGUISH_READ_FROM_PROGRAM_AND_ERASE
      PRESERVE_FIRMWARE_VERSION_CONTEXT
      PRESERVE_RETENTION_AND_ENDURANCE_CONTEXT
      PRESERVE_WRITE_PROTECTION_CONTEXT
      RETURN_CONFIDENCE_WHEN_AVAILABLE
      RETURN_PROVENANCE_WHEN_AVAILABLE
      AVOID_UNSUPPORTED_ROM_INFERENCE
    }
  }

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

END FLOW