Digital Computing Ontology

AI SEARCH

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

FLOW DIGITAL_COMPUTING_ONTOLOGY {

  META {
    DOMAIN = "Computing Ontologies"
    SUBDOMAIN = "Foundations of Computing"
    ONTOLOGY = "Digital Computing Ontology"
    PURPOSE = "Formalise the entities, binary representations, logical operations, architectures and computational processes underlying digital computing systems."
    LOCALE = "en-GB"
  }

  ENTITY_TYPES {
    DIGITAL_COMPUTING_SYSTEM
    DIGITAL_COMPUTER
    DIGITAL_DEVICE
    HARDWARE
    SOFTWARE
    FIRMWARE
    PROCESSOR
    CPU
    MEMORY
    REGISTER
    CACHE
    STORAGE
    BUS
    CLOCK
    CIRCUIT
    DIGITAL_CIRCUIT
    LOGIC_GATE
    TRANSISTOR
    BINARY_DIGIT
    BIT
    BYTE
    WORD
    BINARY_VALUE
    BOOLEAN_VALUE
    NUMBER_REPRESENTATION
    CHARACTER_REPRESENTATION
    INSTRUCTION
    OPCODE
    OPERAND
    MACHINE_CODE
    ASSEMBLY_CODE
    PROGRAM
    ALGORITHM
    PROCESS
    THREAD
    INPUT
    OUTPUT
    DATA
    ADDRESS
    MEMORY_LOCATION
    STATE
    EVENT
    STATE_TRANSITION
    INTERRUPT
    SIGNAL
    CLOCK_CYCLE
    INSTRUCTION_SET
    ARCHITECTURE
    OPERATING_SYSTEM
    INTERFACE
    PERIPHERAL
    NETWORK_INTERFACE
    ERROR
    CONFIGURATION
    VERSION
    EVIDENCE
    CONFIDENCE_SCORE
    PROVENANCE_RECORD
  }

  RELATIONSHIPS {
    IS_A
    INSTANCE_OF
    PART_OF
    CONTAINS
    CONNECTED_TO
    IMPLEMENTS
    EXECUTES
    RUNS_ON
    ENCODES
    DECODES
    REPRESENTS
    STORES
    READS
    WRITES
    LOADS
    FETCHES
    DECODES_INSTRUCTION
    COMPUTES
    TRANSFORMS
    SENDS
    RECEIVES
    CLOCKS
    TRIGGERS
    INTERRUPTS
    ADDRESSES
    HAS_ADDRESS
    HAS_VALUE
    HAS_INPUT
    HAS_OUTPUT
    HAS_STATE
    TRANSITIONS_TO
    HAS_INSTRUCTION_SET
    HAS_ARCHITECTURE
    HAS_CONFIGURATION
    HAS_VERSION
    DEPENDS_ON
    PRECEDES
    FOLLOWS
    DERIVED_FROM
    INFERRED_FROM
    HAS_EVIDENCE
    HAS_CONFIDENCE
    HAS_PROVENANCE
    MAPS_TO
    SEMANTICALLY_EQUIVALENT_TO
  }

  INPUTS {
    BINARY_DATA
    DIGITAL_SIGNALS
    MACHINE_INSTRUCTIONS
    PROGRAMS
    MEMORY_CONTENT
    REGISTER_VALUES
    HARDWARE_SPECIFICATIONS
    INSTRUCTION_SET_DEFINITIONS
    ARCHITECTURE_DEFINITIONS
    CLOCK_SIGNALS
    DEVICE_INPUT
    CONFIGURATION_DATA
    EXECUTION_TRACES
    ERROR_RECORDS
    ONTOLOGY_TERMS
  }

  NORMALISE {
    STANDARDISE_IDENTIFIERS
    NORMALISE_BINARY_REPRESENTATIONS
    NORMALISE_NUMBER_FORMATS
    NORMALISE_CHARACTER_ENCODINGS
    NORMALISE_ADDRESS_FORMATS
    NORMALISE_INSTRUCTION_NAMES
    NORMALISE_ARCHITECTURE_NAMES
    NORMALISE_VERSION_IDENTIFIERS
    RESOLVE_COMPONENT_IDENTITIES
    ALIGN_ONTOLOGY_TERMS
    REMOVE_DUPLICATES
    VALIDATE_METADATA
    PRESERVE_PROVENANCE
  }

  PROCESS DIGITAL_COMPUTATION_PIPELINE {
    INPUT
      -> DIGITAL_ENCODING
      -> STORAGE_OR_REGISTER_LOAD
      -> INSTRUCTION_PROCESSING
      -> LOGICAL_OR_ARITHMETIC_OPERATION
      -> STATE_TRANSITION
      -> OUTPUT_ENCODING
      -> OUTPUT
  }

  PROCESS BINARY_REPRESENTATION {
    INFORMATION_OR_VALUE
      -> ENCODING_SCHEME

    ENCODING_SCHEME
      -> BINARY_REPRESENTATION

    BINARY_REPRESENTATION
      -> BIT_SEQUENCE

    BIT_SEQUENCE
      -> STORAGE_OR_TRANSMISSION
  }

  PROCESS LOGIC_OPERATION {
    BINARY_INPUTS
      -> LOGIC_GATE_OR_BOOLEAN_OPERATION

    LOGIC_GATE_OR_BOOLEAN_OPERATION
      -> BOOLEAN_EVALUATION

    BOOLEAN_EVALUATION
      -> BINARY_OUTPUT
  }

  PROCESS INSTRUCTION_CYCLE {
    PROGRAM_COUNTER
      -> FETCH_INSTRUCTION

    FETCH_INSTRUCTION
      -> DECODE_INSTRUCTION

    DECODE_INSTRUCTION
      -> FETCH_OPERANDS

    FETCH_OPERANDS
      -> EXECUTE_OPERATION

    EXECUTE_OPERATION
      -> WRITE_RESULT

    WRITE_RESULT
      -> UPDATE_PROCESSOR_STATE

    UPDATE_PROCESSOR_STATE
      -> NEXT_INSTRUCTION_OR_INTERRUPT
  }

  PROCESS MEMORY_REASONING {
    ADDRESS + WRITE_OPERATION + VALUE
      -> MEMORY_STATE_UPDATE

    ADDRESS + READ_OPERATION
      -> MEMORY_LOOKUP

    MEMORY_LOOKUP
      -> STORED_VALUE

    STORED_VALUE
      -> REGISTER_OR_OUTPUT
  }

  PROCESS PROCESSOR_STATE_REASONING {
    PROCESSOR_STATE(T1)
      + INSTRUCTION
      -> EXECUTION_STEP

    EXECUTION_STEP
      -> PROCESSOR_STATE(T2)

    PROCESSOR_STATE_SEQUENCE
      -> EXECUTION_TRACE
  }

  PROCESS INTERRUPT_REASONING {
    INTERRUPT_EVENT
      -> SAVE_CURRENT_STATE

    SAVE_CURRENT_STATE
      -> INTERRUPT_HANDLER

    INTERRUPT_HANDLER
      -> SERVICE_EVENT

    SERVICE_EVENT
      -> RESTORE_STATE

    RESTORE_STATE
      -> RESUME_EXECUTION
  }

  PROCESS DIGITAL_ERROR_REASONING {
    EXPECTED_BINARY_STATE + OBSERVED_BINARY_STATE
      -> DIFFERENCE_DETECTION

    DIFFERENCE_DETECTION
      -> ERROR_CLASSIFICATION

    ERROR_CLASSIFICATION
      -> CORRECTION_OR_FAILURE

    CORRECTION_OR_FAILURE
      -> UPDATED_STATE
  }

  RULES {
    IF BINARY_VALUE_EXISTS
    THEN REQUIRE {
      BIT_WIDTH_OR_ENCODING_CONTEXT
      REPRESENTATION_SCHEME
    }

    IF MACHINE_INSTRUCTION_EXECUTES
    THEN LINK {
      INSTRUCTION
      OPERANDS
      PROCESSOR_STATE_BEFORE
      PROCESSOR_STATE_AFTER
      EXECUTION_CONTEXT
    }

    IF MEMORY_VALUE_IS_READ
    THEN REQUIRE {
      ADDRESS
      MEMORY_CONTEXT
      READ_TIME_OR_EXECUTION_STATE
    }

    IF SAME_BIT_PATTERN_USES_DIFFERENT_ENCODING
    THEN DO_NOT_ASSUME_SAME_SEMANTIC_VALUE

    IF INTEGER_REPRESENTATION_HAS_FIXED_WIDTH
    THEN PRESERVE {
      SIGNEDNESS
      BIT_WIDTH
      OVERFLOW_CONTEXT
    }

    IF HARDWARE_ARCHITECTURES_DIFFER
    THEN DO_NOT_ASSUME_MACHINE_CODE_COMPATIBILITY

    IF SEMANTIC_IDENTIFIERS_DIFFER
    AND DIGITAL_COMPUTING_REFERENT_IS_SAME
    THEN APPLY SEMANTIC_EQUIVALENCE
  }

  CONFIDENCE {
    CONFIDENCE_SCORE =
      WEIGHT(
        SIGNAL_INTEGRITY,
        STATE_OBSERVABILITY,
        ARCHITECTURE_CERTAINTY,
        INSTRUCTION_DECODE_CERTAINTY,
        MEMORY_STATE_CERTAINTY,
        EXECUTION_TRACE_COMPLETENESS,
        REPRODUCIBILITY,
        PROVENANCE_COMPLETENESS
      )

    LEVELS {
      HIGH
      MODERATE
      LOW
      INSUFFICIENT
    }

    IF EXECUTION_TRACE_IS_INCOMPLETE
    THEN REDUCE CONFIDENCE_SCORE

    IF ARCHITECTURE_OR_ENCODING_IS_UNKNOWN
    THEN REDUCE CONFIDENCE_SCORE

    IF REPRODUCIBLE_EXECUTION_CONFIRMS_STATE
    THEN INCREASE CONFIDENCE_SCORE
  }

  SEMANTIC_EQUIVALENCE {
    EQUIVALENCE_KEY =
      NORMALISE(
        ENTITY_TYPE,
        BINARY_REPRESENTATION,
        ENCODING,
        BIT_WIDTH,
        ARCHITECTURE,
        EXECUTION_CONTEXT
      )

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

    ELSE PRESERVE_DISTINCT_ENTITIES
  }

  REASONING_CONSTRAINTS {
    BIT_PATTERN != SEMANTIC_VALUE_WITHOUT_ENCODING
    MACHINE_CODE != SOURCE_CODE
    INSTRUCTION != EXECUTION
    ADDRESS != STORED_VALUE
    MEMORY_LOCATION != REGISTER
    DIGITAL_STATE != PHYSICAL_SIGNAL
    LOGICAL_MODEL != PHYSICAL_IMPLEMENTATION
    SAME_OPCODE_MAY_DIFFER_ACROSS_ARCHITECTURES
    OVERFLOW_DEPENDS_ON_REPRESENTATION
    ENDIANNESS_AFFECTS_MULTI_BYTE_INTERPRETATION
    EXECUTION_CONTEXT_AFFECTS_STATE
    PROVENANCE_MUST_BE_PRESERVED
    UNCERTAINTY_MUST_NOT_BE_DISCARDED
  }

  VALIDATION {
    CHECK_ENTITY_TYPES
    CHECK_RELATION_DOMAINS_AND_RANGES
    CHECK_BINARY_REPRESENTATIONS
    CHECK_BIT_WIDTH
    CHECK_ENCODING_CONTEXT
    CHECK_ARCHITECTURE_CONTEXT
    CHECK_INSTRUCTION_SET
    CHECK_MEMORY_ADDRESSES
    CHECK_PROCESSOR_STATE
    CHECK_STATE_TRANSITIONS
    CHECK_EXECUTION_TRACE
    CHECK_ERROR_RELATIONS
    CHECK_PROVENANCE
    CHECK_CONFIDENCE
    CHECK_SEMANTIC_CONSISTENCY
  }

  OUTPUTS {
    NORMALISED_DIGITAL_COMPUTING_ENTITIES
    BINARY_REPRESENTATIONS
    LOGIC_RELATIONS
    INSTRUCTION_RELATIONS
    MEMORY_RELATIONS
    PROCESSOR_STATE_TRANSITIONS
    EXECUTION_TRACES
    INTERRUPT_RELATIONS
    ARCHITECTURE_RELATIONS
    DIGITAL_ERROR_RELATIONS
    CONFIDENCE_SCORES
    EVIDENCE_LINKS
    PROVENANCE_RECORDS
    EXPLANATION_PATHS
  }

  UPDATE_MODEL {
    ON NEW_HARDWARE_OR_EXECUTION_DATA {
      NORMALISE
      ENTITY_RESOLUTION
      UPDATE_ARCHITECTURE_CONTEXT
      UPDATE_PROCESSOR_STATE
      UPDATE_MEMORY_STATE
      RECOMPUTE_AFFECTED_RELATIONS
      UPDATE_CONFIDENCE
      PRESERVE_VERSION_HISTORY
    }

    ON NEW_EXECUTION_EVIDENCE {
      LINK_EXECUTION_TRACE
      REASSESS_STATE_TRANSITIONS
      REASSESS_ERROR_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_SYSTEM
      BY_PROCESSOR
      BY_MEMORY
      BY_BINARY_VALUE
      BY_INSTRUCTION
      BY_ARCHITECTURE
      BY_ADDRESS
      BY_STATE
      BY_EVENT
      BY_EXECUTION_TRACE
      BY_ERROR
      BY_CONFIDENCE
    }

    REASON {
      APPLY_RELATIONSHIPS
      APPLY_RULES
      TRACE_INSTRUCTION_CYCLE
      TRACE_MEMORY_ACCESS
      TRACE_PROCESSOR_STATE
      ANALYSE_BINARY_REPRESENTATION
      ANALYSE_LOGIC_OPERATIONS
      ANALYSE_INTERRUPTS
      CHECK_SEMANTIC_EQUIVALENCE
      PRESERVE_UNCERTAINTY
      TRACE_EVIDENCE
      TRACE_PROVENANCE
      GENERATE_EXPLANATION_PATH
    }

    RESPONSE_POLICY {
      DISTINGUISH_BITS_FROM_MEANING
      DISTINGUISH_INSTRUCTION_FROM_EXECUTION
      PRESERVE_ENCODING_CONTEXT
      PRESERVE_ARCHITECTURE_CONTEXT
      PRESERVE_BIT_WIDTH_AND_SIGNEDNESS
      RETURN_CONFIDENCE_WHEN_AVAILABLE
      RETURN_PROVENANCE_WHEN_AVAILABLE
      AVOID_UNSUPPORTED_DIGITAL_COMPUTING_INFERENCE
    }
  }

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

END FLOW