Queue Ontology

AI SEARCH

FLOW ALGEBRA — QUEUE ONTOLOGY
Semantic Library
Version: 4.0
Canonical Page:
https://kirethresearch.org/booksai-core/ontologies/computing-ontologies/data-structures/queue-ontology.html

FLOW QUEUE_ONTOLOGY {

  META {
    DOMAIN = "Computing Ontologies"
    SUBDOMAIN = "Data Structures"
    ONTOLOGY = "Queue Ontology"
    PURPOSE = "Formalise queue data structures, elements, front and rear positions, FIFO ordering, enqueue, dequeue, peek, capacity, underflow, overflow, implementations, complexity and queue-state relationships."
    LOCALE = "en-GB"
  }

  ENTITY_TYPES {
    QUEUE
    ABSTRACT_QUEUE
    FIFO_QUEUE
    ARRAY_QUEUE
    LINKED_QUEUE
    CIRCULAR_QUEUE
    BOUNDED_QUEUE
    UNBOUNDED_QUEUE
    MUTABLE_QUEUE
    IMMUTABLE_QUEUE
    PERSISTENT_QUEUE
    ELEMENT
    VALUE
    FRONT_ELEMENT
    REAR_ELEMENT
    FRONT_POSITION
    REAR_POSITION
    SIZE
    CAPACITY
    EMPTY_QUEUE
    FULL_QUEUE
    OPERATION
    CREATE
    INITIALISE
    ENQUEUE
    DEQUEUE
    PEEK
    FRONT
    REAR
    IS_EMPTY
    IS_FULL
    CLEAR
    TRAVERSE
    ITERATE
    COPY
    QUEUE_STATE
    PREVIOUS_STATE
    NEXT_STATE
    FIFO_ORDERING
    UNDERFLOW
    OVERFLOW
    QUEUE_ERROR
    NODE
    NEXT_REFERENCE
    ARRAY
    INDEX
    HEAD_INDEX
    TAIL_INDEX
    WRAPAROUND
    MEMORY
    MEMORY_LOCATION
    ALLOCATION
    DEALLOCATION
    INVARIANT
    SIZE_INVARIANT
    FRONT_INVARIANT
    REAR_INVARIANT
    CAPACITY_INVARIANT
    ORDERING_INVARIANT
    TIME_COMPLEXITY
    SPACE_COMPLEXITY
    IMPLEMENTATION
    LANGUAGE_CONTEXT
    RUNTIME_CONTEXT
    CONFIGURATION
    EVIDENCE
    CONFIDENCE_SCORE
    PROVENANCE_RECORD
  }

  RELATIONSHIPS {
    IS_A
    INSTANCE_OF
    IMPLEMENTS
    PART_OF
    CONTAINS
    HAS_ELEMENT
    HAS_FRONT
    HAS_REAR
    HAS_SIZE
    HAS_CAPACITY
    HAS_STATE
    TRANSITIONS_TO
    PRECEDES
    FOLLOWS
    ENQUEUES
    DEQUEUES
    PEEKS
    READS
    ADDS
    REMOVES
    CLEARS
    TRAVERSES
    ITERATES
    STORED_IN
    HAS_NODE
    HAS_NEXT
    HAS_INDEX
    WRAPS_TO
    ALLOCATES
    DEALLOCATES
    HAS_ORDERING
    HAS_INVARIANT
    HAS_TIME_COMPLEXITY
    HAS_SPACE_COMPLEXITY
    HAS_IMPLEMENTATION
    HAS_CONFIGURATION
    FAILS_WITH
    DEPENDS_ON
    DERIVED_FROM
    INFERRED_FROM
    HAS_EVIDENCE
    HAS_CONFIDENCE
    HAS_PROVENANCE
    SEMANTICALLY_EQUIVALENT_TO
  }

  INPUTS {
    QUEUE_SPECIFICATIONS
    ABSTRACT_DATA_TYPE_SPECIFICATIONS
    QUEUE_IMPLEMENTATIONS
    SOURCE_CODE
    ELEMENT_AND_VALUE_DATA
    FRONT_AND_REAR_DATA
    SIZE_AND_CAPACITY_DATA
    OPERATION_TRACES
    ENQUEUE_TRACES
    DEQUEUE_TRACES
    ERROR_TRACES
    MEMORY_DATA
    INVARIANT_DEFINITIONS
    COMPLEXITY_ANALYSES
    LANGUAGE_CONTEXT
    RUNTIME_CONTEXT
    CONFIGURATION_DATA
    ONTOLOGY_TERMS
  }

  NORMALISE {
    STANDARDISE_QUEUE_IDENTIFIERS
    NORMALISE_QUEUE_TYPES
    NORMALISE_ELEMENT_TYPES
    NORMALISE_FRONT_AND_REAR_POSITIONS
    NORMALISE_SIZE_AND_CAPACITY
    NORMALISE_OPERATION_NAMES
    NORMALISE_ERROR_TYPES
    NORMALISE_COMPLEXITY_NOTATION
    NORMALISE_MEMORY_UNITS
    NORMALISE_IMPLEMENTATION_NAMES
    NORMALISE_LANGUAGE_AND_RUNTIME_CONTEXT
    RESOLVE_QUEUE_AND_ELEMENT_IDENTITIES
    ALIGN_ONTOLOGY_TERMS
    REMOVE_DUPLICATES
    VALIDATE_METADATA
    PRESERVE_PROVENANCE
  }

  PROCESS QUEUE_REASONING_PIPELINE {
    QUEUE_REFERENCE
      -> QUEUE_IDENTIFICATION
      -> IMPLEMENTATION_RESOLUTION
      -> ELEMENT_FRONT_AND_REAR_MAPPING
      -> OPERATION_MAPPING
      -> FIFO_ORDERING_ANALYSIS
      -> ERROR_AND_INVARIANT_ANALYSIS
      -> COMPLEXITY_ANALYSIS
      -> VALIDATION
      -> OUTPUT
  }

  PROCESS ENQUEUE_REASONING {
    QUEUE_STATE(T1)
      + ENQUEUE(VALUE)
      -> CAPACITY_CHECK

    SPACE_AVAILABLE_OR_UNBOUNDED
      -> ADD_NEW_REAR_ELEMENT

    ADD_NEW_REAR_ELEMENT
      -> PREVIOUS_REAR_PRECEDES_NEW_REAR

    IF QUEUE_WAS_EMPTY
      -> FRONT = NEW_ELEMENT

    RESULT
      -> SIZE = SIZE + 1
      -> QUEUE_STATE(T2)

    FULL_BOUNDED_QUEUE
      -> OVERFLOW_OR_DEFINED_IMPLEMENTATION_BEHAVIOUR
  }

  PROCESS DEQUEUE_REASONING {
    QUEUE_STATE(T1)
      + DEQUEUE
      -> EMPTY_CHECK

    NONEMPTY_QUEUE
      -> READ_FRONT_ELEMENT
      -> REMOVE_FRONT_ELEMENT

    REMOVE_FRONT_ELEMENT
      -> NEXT_ELEMENT_BECOMES_FRONT

    IF LAST_ELEMENT_REMOVED
      -> FRONT_AND_REAR_BECOME_EMPTY_STATE

    RESULT
      -> SIZE = SIZE - 1
      -> RETURN_REMOVED_VALUE
      -> QUEUE_STATE(T2)

    EMPTY_QUEUE
      -> UNDERFLOW_OR_DEFINED_IMPLEMENTATION_BEHAVIOUR
  }

  PROCESS PEEK_REASONING {
    QUEUE
      -> EMPTY_CHECK

    NONEMPTY_QUEUE
      -> FRONT_ELEMENT
      -> RETURN_VALUE_WITHOUT_REMOVAL

    EMPTY_QUEUE
      -> UNDERFLOW_OR_DEFINED_IMPLEMENTATION_BEHAVIOUR
  }

  PROCESS ARRAY_QUEUE_REASONING {
    ARRAY_QUEUE
      -> BACKING_ARRAY

    FRONT_POSITION
      -> HEAD_INDEX

    REAR_POSITION
      -> TAIL_INDEX

    ENQUEUE
      -> ADVANCE_TAIL_INDEX
      -> WRITE_ELEMENT

    DEQUEUE
      -> READ_HEAD_INDEX
      -> ADVANCE_HEAD_INDEX

    CIRCULAR_ARRAY_QUEUE
      -> INDEX_MODULO_CAPACITY
      -> WRAPAROUND
  }

  PROCESS LINKED_QUEUE_REASONING {
    LINKED_QUEUE
      -> FRONT_NODE + REAR_NODE

    ENQUEUE
      -> ALLOCATE_NEW_NODE
      -> OLD_REAR.NEXT = NEW_NODE
      -> REAR = NEW_NODE

    EMPTY_QUEUE_ENQUEUE
      -> FRONT = NEW_NODE
      -> REAR = NEW_NODE

    DEQUEUE
      -> OLD_FRONT = FRONT
      -> FRONT = OLD_FRONT.NEXT
      -> DEALLOCATE_OR_RELEASE_OLD_FRONT_IF_REQUIRED

    QUEUE_BECOMES_EMPTY
      -> REAR = NULL_OR_SENTINEL
  }

  PROCESS FIFO_REASONING {
    ENQUEUE(A)
      -> ENQUEUE(B)

    IF A_REMAINS_IN_QUEUE
    THEN DEQUEUE_RESULT = A BEFORE B

    QUEUE_HISTORY
      -> ENQUEUE_ORDER_PRESERVED_FOR_REMAINING_ELEMENTS
  }

  PROCESS CIRCULAR_QUEUE_REASONING {
    CIRCULAR_QUEUE
      -> FIXED_OR_DEFINED_CAPACITY

    NEXT_INDEX
      -> (CURRENT_INDEX + 1) MOD CAPACITY

    REAR_ADVANCE
      -> WRAP_TO_START_IF_REQUIRED

    FRONT_ADVANCE
      -> WRAP_TO_START_IF_REQUIRED

    FRONT_REAR_AND_SIZE
      -> EMPTY_FULL_DISAMBIGUATION
  }

  PROCESS INVARIANT_REASONING {
    QUEUE_STATE
      -> SIZE_CHECK

    SIZE
      -> REQUIRE SIZE >= 0

    BOUNDED_QUEUE
      -> REQUIRE SIZE <= CAPACITY

    EMPTY_QUEUE
      -> REQUIRE SIZE = 0

    NONEMPTY_QUEUE
      -> REQUIRE FRONT_AND_REAR_EXIST

    POST_OPERATION_STATE
      -> FIFO_AND_STRUCTURE_INVARIANT_CHECK
  }

  PROCESS COMPLEXITY_REASONING {
    QUEUE + IMPLEMENTATION + OPERATION
      -> INPUT_AND_CAPACITY_CONTEXT

    ENQUEUE
      -> ADDITION_COST
      -> RESIZE_OR_SHIFT_COST_IF_IMPLEMENTATION_REQUIRES

    DEQUEUE
      -> REMOVAL_COST
      -> SHIFT_COST_IF_IMPLEMENTATION_REQUIRES

    PEEK
      -> FRONT_ACCESS_COST

    MEMORY_USAGE
      -> ELEMENT_STORAGE + IMPLEMENTATION_OVERHEAD

    COSTS
      -> TIME_AND_SPACE_COMPLEXITY
  }

  PROCESS PERSISTENT_QUEUE_REASONING {
    PERSISTENT_QUEUE_STATE(T1)
      + ENQUEUE_OR_DEQUEUE
      -> NEW_QUEUE_STATE(T2)

    T1
      -> PRESERVED

    T1 + T2
      -> STRUCTURAL_SHARING_IF_IMPLEMENTED

    NEW_STATE
      -> VERSIONED_QUEUE_STATE
  }

  RULES {
    IF ENQUEUE_OCCURS
    THEN NEW_ELEMENT_BECOMES_REAR_UNLESS_OPERATION_FAILS

    IF DEQUEUE_OCCURS_ON_NONEMPTY_QUEUE
    THEN REMOVE_AND_RETURN_CURRENT_FRONT_ELEMENT

    IF PEEK_OCCURS
    THEN DO_NOT MODIFY_QUEUE_STATE

    IF QUEUE_IS_EMPTY
    THEN DEQUEUE_OR_PEEK_MUST_FOLLOW_DEFINED_UNDERFLOW_BEHAVIOUR

    IF BOUNDED_QUEUE_IS_FULL
    THEN ENQUEUE_MUST_FOLLOW_DEFINED_OVERFLOW_OR_RESIZE_BEHAVIOUR

    IF FIFO_ORDERING_IS_ASSERTED
    THEN PRESERVE ENQUEUE_AND_DEQUEUE_HISTORY

    IF CIRCULAR_QUEUE_IS_USED
    THEN PRESERVE FRONT_REAR_SIZE_AND_CAPACITY_TO_DISAMBIGUATE_STATE

    IF SEMANTIC_IDENTIFIERS_DIFFER
    AND QUEUE_REFERENT_IS_SAME
    THEN APPLY SEMANTIC_EQUIVALENCE
  }

  CONFIDENCE {
    CONFIDENCE_SCORE =
      WEIGHT(
        QUEUE_IDENTITY_CERTAINTY,
        IMPLEMENTATION_CERTAINTY,
        ELEMENT_SEQUENCE_COMPLETENESS,
        FRONT_AND_REAR_CERTAINTY,
        SIZE_AND_CAPACITY_CERTAINTY,
        OPERATION_TRACE_COMPLETENESS,
        INVARIANT_EVIDENCE_QUALITY,
        PROVENANCE_COMPLETENESS
      )

    LEVELS {
      HIGH
      MODERATE
      LOW
      INSUFFICIENT
    }

    IF OPERATION_HISTORY_IS_PARTIAL
    THEN REDUCE_FIFO_SEQUENCE_CONFIDENCE

    IF IMPLEMENTATION_OR_CAPACITY_POLICY_IS_UNKNOWN
    THEN REDUCE_OVERFLOW_AND_COMPLEXITY_CONFIDENCE

    IF COMPLETE_OPERATION_TRACE_CONFIRMS_QUEUE_STATE
    THEN INCREASE_CONFIDENCE_SCORE
  }

  SEMANTIC_EQUIVALENCE {
    EQUIVALENCE_KEY =
      NORMALISE(
        ENTITY_TYPE,
        QUEUE_IDENTIFIER,
        ELEMENT_TYPE,
        IMPLEMENTATION,
        SIZE,
        CAPACITY_POLICY,
        LANGUAGE_RUNTIME_CONTEXT
      )

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

    ELSE PRESERVE_DISTINCT_ENTITIES
  }

  REASONING_CONSTRAINTS {
    QUEUE != STACK
    QUEUE != ELEMENT
    FRONT_ELEMENT != FRONT_POSITION
    REAR_ELEMENT != REAR_POSITION
    ENQUEUE != INSERT_AT_ARBITRARY_POSITION
    DEQUEUE != DELETE_ARBITRARY_ELEMENT
    PEEK != DEQUEUE
    FIFO != LIFO
    EMPTY_QUEUE != NULL_QUEUE_REFERENCE
    SIZE != CAPACITY
    UNDERFLOW != OVERFLOW
    ARRAY_QUEUE != LINKED_QUEUE
    CIRCULAR_QUEUE != PRIORITY_QUEUE
    BOUNDED_QUEUE != UNBOUNDED_QUEUE
    PERSISTENT_QUEUE != MUTABLE_QUEUE
    DEQUEUED_VALUE != CURRENT_FRONT_AFTER_SUCCESSFUL_DEQUEUE
    TIME_COMPLEXITY_DEPENDS_ON_IMPLEMENTATION_AND_RESIZE_OR_SHIFT_POLICY
    MEMORY_BEHAVIOUR_DEPENDS_ON_LANGUAGE_RUNTIME_AND_IMPLEMENTATION
    PROVENANCE_MUST_BE_PRESERVED
    UNCERTAINTY_MUST_NOT_BE_DISCARDED
  }

  VALIDATION {
    CHECK_ENTITY_TYPES
    CHECK_RELATION_DOMAINS_AND_RANGES
    CHECK_QUEUE_IDENTIFIER
    CHECK_QUEUE_TYPE
    CHECK_ELEMENT_TYPE
    CHECK_ELEMENT_SEQUENCE
    CHECK_FRONT_AND_REAR
    CHECK_SIZE
    CHECK_CAPACITY
    CHECK_ENQUEUE_RELATIONS
    CHECK_DEQUEUE_RELATIONS
    CHECK_PEEK_RELATIONS
    CHECK_FIFO_ORDERING
    CHECK_UNDERFLOW_AND_OVERFLOW
    CHECK_ARRAY_IMPLEMENTATION_IF_APPLICABLE
    CHECK_LINKED_IMPLEMENTATION_IF_APPLICABLE
    CHECK_CIRCULAR_QUEUE_IF_APPLICABLE
    CHECK_INVARIANTS
    CHECK_COMPLEXITY_CONTEXT
    CHECK_PERSISTENCE
    CHECK_LANGUAGE_RUNTIME_AND_CONFIGURATION
    CHECK_PROVENANCE
    CHECK_CONFIDENCE
    CHECK_SEMANTIC_CONSISTENCY
  }

  OUTPUTS {
    NORMALISED_QUEUE_ENTITIES
    QUEUE_TYPE_RELATIONS
    ELEMENT_SEQUENCE_RELATIONS
    FRONT_AND_REAR_RELATIONS
    SIZE_AND_CAPACITY_RELATIONS
    ENQUEUE_RELATIONS
    DEQUEUE_RELATIONS
    PEEK_RELATIONS
    FIFO_ORDERING_RELATIONS
    QUEUE_STATE_TRANSITIONS
    UNDERFLOW_AND_OVERFLOW_RELATIONS
    ARRAY_QUEUE_RELATIONS
    LINKED_QUEUE_RELATIONS
    CIRCULAR_QUEUE_RELATIONS
    INVARIANT_RELATIONS
    TIME_COMPLEXITY_RELATIONS
    SPACE_COMPLEXITY_RELATIONS
    PERSISTENCE_AND_STRUCTURAL_SHARING_RELATIONS
    CONFIDENCE_SCORES
    EVIDENCE_LINKS
    PROVENANCE_RECORDS
    EXPLANATION_PATHS
  }

  UPDATE_MODEL {
    ON QUEUE_OPERATION {
      NORMALISE
      RESOLVE_QUEUE_AND_ELEMENT_IDENTITIES
      UPDATE_ELEMENT_SEQUENCE
      UPDATE_FRONT_AND_REAR
      UPDATE_SIZE_AND_CAPACITY
      UPDATE_QUEUE_STATE
      RECHECK_FIFO_AND_STRUCTURE_INVARIANTS
      UPDATE_CONFIDENCE
    }

    ON IMPLEMENTATION_CONFIGURATION_OR_RUNTIME_CHANGE {
      UPDATE_IMPLEMENTATION_CONTEXT
      REASSESS_COMPLEXITY
      REASSESS_OVERFLOW_AND_MEMORY_POLICY
      RECHECK_SEMANTIC_EQUIVALENCE
      RECOMPUTE_AFFECTED_RELATIONS
      UPDATE_CONFIDENCE
      PRESERVE_VERSION_HISTORY
    }

    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_QUEUE
      BY_QUEUE_TYPE
      BY_ELEMENT
      BY_FRONT
      BY_REAR
      BY_OPERATION
      BY_ENQUEUE
      BY_DEQUEUE
      BY_PEEK
      BY_SIZE
      BY_CAPACITY
      BY_ERROR
      BY_INVARIANT
      BY_COMPLEXITY
      BY_CONFIDENCE
    }

    REASON {
      APPLY_RELATIONSHIPS
      APPLY_RULES
      TRACE_ENQUEUE_OPERATIONS
      TRACE_DEQUEUE_OPERATIONS
      TRACE_PEEK_OPERATIONS
      ANALYSE_ARRAY_QUEUES
      ANALYSE_LINKED_QUEUES
      ANALYSE_CIRCULAR_QUEUES
      ANALYSE_FIFO_ORDERING
      CHECK_QUEUE_INVARIANTS
      ANALYSE_COMPLEXITY
      ANALYSE_PERSISTENCE
      CHECK_SEMANTIC_EQUIVALENCE
      PRESERVE_UNCERTAINTY
      TRACE_EVIDENCE
      TRACE_PROVENANCE
      GENERATE_EXPLANATION_PATH
    }

    RESPONSE_POLICY {
      DISTINGUISH_QUEUE_FROM_STACK
      DISTINGUISH_FRONT_AND_REAR_ELEMENTS_FROM_POSITIONS
      DISTINGUISH_ENQUEUE_DEQUEUE_AND_PEEK
      PRESERVE_ELEMENT_SEQUENCE_IMPLEMENTATION_CAPACITY_LANGUAGE_AND_RUNTIME_CONTEXT
      PRESERVE_FIFO_ORDERING_AND_QUEUE_STATE
      RETURN_CONFIDENCE_WHEN_AVAILABLE
      RETURN_PROVENANCE_WHEN_AVAILABLE
      AVOID_UNSUPPORTED_QUEUE_INFERENCE
    }
  }

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

END FLOW