Stack Ontology

AI SEARCH

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

FLOW STACK_ONTOLOGY {

  META {
    DOMAIN = "Computing Ontologies"
    SUBDOMAIN = "Data Structures"
    ONTOLOGY = "Stack Ontology"
    PURPOSE = "Formalise stack data structures, elements, top position, LIFO ordering, push, pop, peek, capacity, underflow, overflow, implementations, complexity and stack-state relationships."
    LOCALE = "en-GB"
  }

  ENTITY_TYPES {
    STACK
    ABSTRACT_STACK
    ARRAY_STACK
    LINKED_STACK
    BOUNDED_STACK
    UNBOUNDED_STACK
    MUTABLE_STACK
    IMMUTABLE_STACK
    PERSISTENT_STACK
    ELEMENT
    VALUE
    TOP_ELEMENT
    TOP_POSITION
    BOTTOM_ELEMENT
    SIZE
    CAPACITY
    EMPTY_STACK
    FULL_STACK
    OPERATION
    CREATE
    INITIALISE
    PUSH
    POP
    PEEK
    TOP
    IS_EMPTY
    IS_FULL
    CLEAR
    TRAVERSE
    ITERATE
    COPY
    STACK_STATE
    PREVIOUS_STATE
    NEXT_STATE
    LIFO_ORDERING
    UNDERFLOW
    OVERFLOW
    STACK_ERROR
    NODE
    NEXT_REFERENCE
    ARRAY
    INDEX
    MEMORY
    MEMORY_LOCATION
    ALLOCATION
    DEALLOCATION
    INVARIANT
    SIZE_INVARIANT
    TOP_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_TOP
    HAS_BOTTOM
    HAS_SIZE
    HAS_CAPACITY
    HAS_STATE
    TRANSITIONS_TO
    PRECEDES
    FOLLOWS
    PUSHES
    POPS
    PEEKS
    READS
    ADDS
    REMOVES
    CLEARS
    TRAVERSES
    ITERATES
    STORED_IN
    HAS_NODE
    HAS_NEXT
    HAS_INDEX
    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 {
    STACK_SPECIFICATIONS
    ABSTRACT_DATA_TYPE_SPECIFICATIONS
    STACK_IMPLEMENTATIONS
    SOURCE_CODE
    ELEMENT_AND_VALUE_DATA
    TOP_POSITION_DATA
    SIZE_AND_CAPACITY_DATA
    OPERATION_TRACES
    PUSH_TRACES
    POP_TRACES
    ERROR_TRACES
    MEMORY_DATA
    INVARIANT_DEFINITIONS
    COMPLEXITY_ANALYSES
    LANGUAGE_CONTEXT
    RUNTIME_CONTEXT
    CONFIGURATION_DATA
    ONTOLOGY_TERMS
  }

  NORMALISE {
    STANDARDISE_STACK_IDENTIFIERS
    NORMALISE_STACK_TYPES
    NORMALISE_ELEMENT_TYPES
    NORMALISE_TOP_POSITION
    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_STACK_AND_ELEMENT_IDENTITIES
    ALIGN_ONTOLOGY_TERMS
    REMOVE_DUPLICATES
    VALIDATE_METADATA
    PRESERVE_PROVENANCE
  }

  PROCESS STACK_REASONING_PIPELINE {
    STACK_REFERENCE
      -> STACK_IDENTIFICATION
      -> IMPLEMENTATION_RESOLUTION
      -> ELEMENT_AND_TOP_MAPPING
      -> OPERATION_MAPPING
      -> LIFO_ORDERING_ANALYSIS
      -> ERROR_AND_INVARIANT_ANALYSIS
      -> COMPLEXITY_ANALYSIS
      -> VALIDATION
      -> OUTPUT
  }

  PROCESS PUSH_REASONING {
    STACK_STATE(T1)
      + PUSH(VALUE)
      -> CAPACITY_CHECK

    SPACE_AVAILABLE_OR_UNBOUNDED
      -> ADD_NEW_TOP_ELEMENT

    ADD_NEW_TOP_ELEMENT
      -> PREVIOUS_TOP_BECOMES_NEXT_ELEMENT

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

    FULL_BOUNDED_STACK
      -> OVERFLOW_OR_DEFINED_IMPLEMENTATION_BEHAVIOUR
  }

  PROCESS POP_REASONING {
    STACK_STATE(T1)
      + POP
      -> EMPTY_CHECK

    NONEMPTY_STACK
      -> READ_TOP_ELEMENT
      -> REMOVE_TOP_ELEMENT

    REMOVE_TOP_ELEMENT
      -> NEXT_ELEMENT_BECOMES_TOP

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

    EMPTY_STACK
      -> UNDERFLOW_OR_DEFINED_IMPLEMENTATION_BEHAVIOUR
  }

  PROCESS PEEK_REASONING {
    STACK
      -> EMPTY_CHECK

    NONEMPTY_STACK
      -> TOP_ELEMENT
      -> RETURN_VALUE_WITHOUT_REMOVAL

    EMPTY_STACK
      -> UNDERFLOW_OR_DEFINED_IMPLEMENTATION_BEHAVIOUR
  }

  PROCESS ARRAY_STACK_REASONING {
    ARRAY_STACK
      -> BACKING_ARRAY

    TOP_POSITION
      -> ARRAY_INDEX

    PUSH
      -> INCREMENT_OR_SELECT_TOP_INDEX
      -> WRITE_ELEMENT

    POP
      -> READ_TOP_INDEX
      -> CLEAR_OR_IGNORE_SLOT
      -> DECREMENT_TOP_INDEX

    CAPACITY_EXCEEDED
      -> RESIZE_IF_DYNAMIC_IMPLEMENTATION
      OR -> OVERFLOW_IF_FIXED
  }

  PROCESS LINKED_STACK_REASONING {
    LINKED_STACK
      -> TOP_NODE

    PUSH
      -> ALLOCATE_NEW_NODE
      -> NEW_NODE.NEXT = OLD_TOP
      -> TOP = NEW_NODE

    POP
      -> OLD_TOP = TOP
      -> TOP = OLD_TOP.NEXT
      -> DEALLOCATE_OR_RELEASE_OLD_TOP_IF_REQUIRED

    EMPTY_STACK
      -> TOP = NULL_OR_SENTINEL
  }

  PROCESS LIFO_REASONING {
    PUSH(A)
      -> PUSH(B)

    IF NO_INTERVENING_POP_REMOVES_B
    THEN POP_RESULT = B BEFORE A

    STACK_HISTORY
      -> REVERSE_ORDER_OF_UNPOPPED_PUSHES
  }

  PROCESS INVARIANT_REASONING {
    STACK_STATE
      -> SIZE_CHECK

    SIZE
      -> REQUIRE SIZE >= 0

    BOUNDED_STACK
      -> REQUIRE SIZE <= CAPACITY

    EMPTY_STACK
      -> REQUIRE SIZE = 0

    NONEMPTY_STACK
      -> REQUIRE TOP_ELEMENT_EXISTS

    POST_OPERATION_STATE
      -> LIFO_AND_STRUCTURE_INVARIANT_CHECK
  }

  PROCESS COMPLEXITY_REASONING {
    STACK + IMPLEMENTATION + OPERATION
      -> INPUT_AND_CAPACITY_CONTEXT

    PUSH
      -> NORMAL_OPERATION_COST
      -> RESIZE_COST_IF_APPLICABLE

    POP
      -> REMOVAL_COST

    PEEK
      -> TOP_ACCESS_COST

    MEMORY_USAGE
      -> ELEMENT_STORAGE + IMPLEMENTATION_OVERHEAD

    COSTS
      -> TIME_AND_SPACE_COMPLEXITY
  }

  PROCESS PERSISTENT_STACK_REASONING {
    PERSISTENT_STACK_STATE(T1)
      + PUSH_OR_POP
      -> NEW_STACK_STATE(T2)

    T1
      -> PRESERVED

    T1 + T2
      -> STRUCTURAL_SHARING_IF_IMPLEMENTED

    NEW_TOP_PATH
      -> VERSIONED_STACK_STATE
  }

  RULES {
    IF PUSH_OCCURS
    THEN NEW_ELEMENT_BECOMES_TOP_UNLESS_OPERATION_FAILS

    IF POP_OCCURS_ON_NONEMPTY_STACK
    THEN REMOVE_AND_RETURN_CURRENT_TOP_ELEMENT

    IF PEEK_OCCURS
    THEN DO_NOT MODIFY_STACK_STATE

    IF STACK_IS_EMPTY
    THEN POP_OR_PEEK_MUST_FOLLOW_DEFINED_UNDERFLOW_BEHAVIOUR

    IF BOUNDED_STACK_IS_FULL
    THEN PUSH_MUST_FOLLOW_DEFINED_OVERFLOW_OR_RESIZE_BEHAVIOUR

    IF LIFO_ORDERING_IS_ASSERTED
    THEN PRESERVE OPERATION_HISTORY

    IF PERSISTENT_STACK_IS_UPDATED
    THEN PRESERVE PRIOR_STACK_STATE

    IF SEMANTIC_IDENTIFIERS_DIFFER
    AND STACK_REFERENT_IS_SAME
    THEN APPLY SEMANTIC_EQUIVALENCE
  }

  CONFIDENCE {
    CONFIDENCE_SCORE =
      WEIGHT(
        STACK_IDENTITY_CERTAINTY,
        IMPLEMENTATION_CERTAINTY,
        ELEMENT_SEQUENCE_COMPLETENESS,
        TOP_POSITION_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_LIFO_SEQUENCE_CONFIDENCE

    IF IMPLEMENTATION_OR_CAPACITY_POLICY_IS_UNKNOWN
    THEN REDUCE_OVERFLOW_AND_COMPLEXITY_CONFIDENCE

    IF COMPLETE_OPERATION_TRACE_CONFIRMS_STACK_STATE
    THEN INCREASE_CONFIDENCE_SCORE
  }

  SEMANTIC_EQUIVALENCE {
    EQUIVALENCE_KEY =
      NORMALISE(
        ENTITY_TYPE,
        STACK_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 {
    STACK != QUEUE
    STACK != ELEMENT
    TOP_ELEMENT != TOP_POSITION
    PUSH != INSERT_AT_ARBITRARY_POSITION
    POP != DELETE_ARBITRARY_ELEMENT
    PEEK != POP
    LIFO != FIFO
    EMPTY_STACK != NULL_STACK_REFERENCE
    SIZE != CAPACITY
    UNDERFLOW != OVERFLOW
    ARRAY_STACK != LINKED_STACK
    BOUNDED_STACK != UNBOUNDED_STACK
    PERSISTENT_STACK != MUTABLE_STACK
    POPPED_VALUE != CURRENT_TOP_AFTER_SUCCESSFUL_POP
    TIME_COMPLEXITY_DEPENDS_ON_IMPLEMENTATION_AND_RESIZE_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_STACK_IDENTIFIER
    CHECK_STACK_TYPE
    CHECK_ELEMENT_TYPE
    CHECK_ELEMENT_SEQUENCE
    CHECK_TOP_ELEMENT_AND_POSITION
    CHECK_SIZE
    CHECK_CAPACITY
    CHECK_PUSH_RELATIONS
    CHECK_POP_RELATIONS
    CHECK_PEEK_RELATIONS
    CHECK_LIFO_ORDERING
    CHECK_UNDERFLOW_AND_OVERFLOW
    CHECK_ARRAY_IMPLEMENTATION_IF_APPLICABLE
    CHECK_LINKED_IMPLEMENTATION_IF_APPLICABLE
    CHECK_INVARIANTS
    CHECK_COMPLEXITY_CONTEXT
    CHECK_PERSISTENCE
    CHECK_LANGUAGE_RUNTIME_AND_CONFIGURATION
    CHECK_PROVENANCE
    CHECK_CONFIDENCE
    CHECK_SEMANTIC_CONSISTENCY
  }

  OUTPUTS {
    NORMALISED_STACK_ENTITIES
    STACK_TYPE_RELATIONS
    ELEMENT_SEQUENCE_RELATIONS
    TOP_AND_BOTTOM_RELATIONS
    SIZE_AND_CAPACITY_RELATIONS
    PUSH_RELATIONS
    POP_RELATIONS
    PEEK_RELATIONS
    LIFO_ORDERING_RELATIONS
    STACK_STATE_TRANSITIONS
    UNDERFLOW_AND_OVERFLOW_RELATIONS
    ARRAY_STACK_RELATIONS
    LINKED_STACK_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 STACK_OPERATION {
      NORMALISE
      RESOLVE_STACK_AND_ELEMENT_IDENTITIES
      UPDATE_ELEMENT_SEQUENCE
      UPDATE_TOP
      UPDATE_SIZE_AND_CAPACITY
      UPDATE_STACK_STATE
      RECHECK_LIFO_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_STACK
      BY_STACK_TYPE
      BY_ELEMENT
      BY_TOP
      BY_OPERATION
      BY_PUSH
      BY_POP
      BY_PEEK
      BY_SIZE
      BY_CAPACITY
      BY_ERROR
      BY_INVARIANT
      BY_COMPLEXITY
      BY_CONFIDENCE
    }

    REASON {
      APPLY_RELATIONSHIPS
      APPLY_RULES
      TRACE_PUSH_OPERATIONS
      TRACE_POP_OPERATIONS
      TRACE_PEEK_OPERATIONS
      ANALYSE_ARRAY_STACKS
      ANALYSE_LINKED_STACKS
      ANALYSE_LIFO_ORDERING
      CHECK_STACK_INVARIANTS
      ANALYSE_COMPLEXITY
      ANALYSE_PERSISTENCE
      CHECK_SEMANTIC_EQUIVALENCE
      PRESERVE_UNCERTAINTY
      TRACE_EVIDENCE
      TRACE_PROVENANCE
      GENERATE_EXPLANATION_PATH
    }

    RESPONSE_POLICY {
      DISTINGUISH_STACK_FROM_QUEUE
      DISTINGUISH_TOP_ELEMENT_FROM_TOP_POSITION
      DISTINGUISH_PUSH_POP_AND_PEEK
      PRESERVE_ELEMENT_SEQUENCE_IMPLEMENTATION_CAPACITY_LANGUAGE_AND_RUNTIME_CONTEXT
      PRESERVE_LIFO_ORDERING_AND_STACK_STATE
      RETURN_CONFIDENCE_WHEN_AVAILABLE
      RETURN_PROVENANCE_WHEN_AVAILABLE
      AVOID_UNSUPPORTED_STACK_INFERENCE
    }
  }

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

END FLOW