Heap Ontology

AI SEARCH

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

FLOW HEAP_ONTOLOGY {

  META {
    DOMAIN = "Computing Ontologies"
    SUBDOMAIN = "Data Structures"
    ONTOLOGY = "Heap Ontology"
    PURPOSE = "Formalise heap data structures, heap ordering, nodes, parent-child relations, array representations, insertion, extraction, heapification, priority operations, invariants and complexity."
    LOCALE = "en-GB"
  }

  ENTITY_TYPES {
    HEAP
    BINARY_HEAP
    MIN_HEAP
    MAX_HEAP
    D_ARY_HEAP
    BINOMIAL_HEAP
    FIBONACCI_HEAP
    PAIRING_HEAP
    MUTABLE_HEAP
    IMMUTABLE_HEAP
    PERSISTENT_HEAP
    PRIORITY_QUEUE
    NODE
    ROOT_NODE
    PARENT_NODE
    CHILD_NODE
    LEFT_CHILD
    RIGHT_CHILD
    ELEMENT
    KEY
    VALUE
    PRIORITY
    ARRAY_REPRESENTATION
    TREE_REPRESENTATION
    INDEX
    SIZE
    CAPACITY
    HEIGHT
    OPERATION
    CREATE
    INSERT
    PEEK_ROOT
    FIND_MIN
    FIND_MAX
    EXTRACT_MIN
    EXTRACT_MAX
    DELETE
    UPDATE_KEY
    DECREASE_KEY
    INCREASE_KEY
    MERGE
    MELD
    HEAPIFY
    BUILD_HEAP
    SIFT_UP
    SIFT_DOWN
    BUBBLE_UP
    BUBBLE_DOWN
    SWAP
    RESIZE
    HEAP_ORDER
    MIN_HEAP_ORDER
    MAX_HEAP_ORDER
    COMPLETE_TREE_INVARIANT
    HEAP_ORDER_INVARIANT
    ARRAY_INDEX_INVARIANT
    STRUCTURAL_INVARIANT
    TIME_COMPLEXITY
    SPACE_COMPLEXITY
    MEMORY
    POINTER
    REFERENCE
    IMPLEMENTATION
    LANGUAGE_CONTEXT
    RUNTIME_CONTEXT
    CONFIGURATION
    ERROR
    EVIDENCE
    CONFIDENCE_SCORE
    PROVENANCE_RECORD
  }

  RELATIONSHIPS {
    IS_A
    INSTANCE_OF
    IMPLEMENTS
    PART_OF
    CONTAINS
    HAS_NODE
    HAS_ROOT
    HAS_ELEMENT
    HAS_KEY
    HAS_VALUE
    HAS_PRIORITY
    PARENT_OF
    CHILD_OF
    LEFT_CHILD_OF
    RIGHT_CHILD_OF
    PRECEDES
    FOLLOWS
    HAS_INDEX
    HAS_SIZE
    HAS_CAPACITY
    HAS_HEIGHT
    STORED_IN
    MAPS_TO
    INSERTS
    PEEKS
    EXTRACTS
    DELETES
    UPDATES
    DECREASES_KEY
    INCREASES_KEY
    MERGES
    MELDS
    HEAPIFIES
    BUILDS
    SIFTS_UP
    SIFTS_DOWN
    SWAPS
    RESIZES
    HAS_HEAP_ORDER
    HAS_INVARIANT
    HAS_TIME_COMPLEXITY
    HAS_SPACE_COMPLEXITY
    HAS_IMPLEMENTATION
    HAS_CONFIGURATION
    POINTS_TO
    REFERENCES
    DEPENDS_ON
    DERIVED_FROM
    INFERRED_FROM
    HAS_EVIDENCE
    HAS_CONFIDENCE
    HAS_PROVENANCE
    SEMANTICALLY_EQUIVALENT_TO
  }

  INPUTS {
    HEAP_SPECIFICATIONS
    HEAP_IMPLEMENTATIONS
    SOURCE_CODE
    NODE_AND_ELEMENT_DATA
    KEY_VALUE_AND_PRIORITY_DATA
    PARENT_CHILD_DATA
    ARRAY_INDEX_DATA
    SIZE_AND_CAPACITY_DATA
    INSERTION_TRACES
    EXTRACTION_TRACES
    KEY_UPDATE_TRACES
    HEAPIFY_TRACES
    MERGE_TRACES
    INVARIANT_DEFINITIONS
    COMPLEXITY_ANALYSES
    MEMORY_DATA
    LANGUAGE_CONTEXT
    RUNTIME_CONTEXT
    CONFIGURATION_DATA
    ONTOLOGY_TERMS
  }

  NORMALISE {
    STANDARDISE_HEAP_IDENTIFIERS
    NORMALISE_HEAP_TYPES
    NORMALISE_NODE_AND_ELEMENT_IDENTIFIERS
    NORMALISE_KEY_VALUE_AND_PRIORITY_TYPES
    NORMALISE_PARENT_CHILD_RELATIONS
    NORMALISE_ARRAY_INDICES
    NORMALISE_SIZE_AND_CAPACITY
    NORMALISE_OPERATION_NAMES
    NORMALISE_HEAP_ORDER_TERMS
    NORMALISE_COMPLEXITY_NOTATION
    NORMALISE_LANGUAGE_AND_RUNTIME_CONTEXT
    RESOLVE_HEAP_NODE_AND_ELEMENT_IDENTITIES
    ALIGN_ONTOLOGY_TERMS
    REMOVE_DUPLICATES
    VALIDATE_METADATA
    PRESERVE_PROVENANCE
  }

  PROCESS HEAP_REASONING_PIPELINE {
    HEAP_REFERENCE
      -> HEAP_IDENTIFICATION
      -> HEAP_TYPE_RESOLUTION
      -> REPRESENTATION_MAPPING
      -> NODE_KEY_AND_PRIORITY_MAPPING
      -> HEAP_ORDER_ANALYSIS
      -> OPERATION_MAPPING
      -> INVARIANT_ANALYSIS
      -> COMPLEXITY_ANALYSIS
      -> VALIDATION
      -> OUTPUT
  }

  PROCESS BINARY_HEAP_STRUCTURE {
    BINARY_HEAP
      -> COMPLETE_BINARY_TREE_STRUCTURE

    ARRAY_REPRESENTATION
      -> NODE_INDEX_MAPPING

    ZERO_BASED_INDEX(I)
      -> LEFT_CHILD_INDEX = 2*I + 1
      -> RIGHT_CHILD_INDEX = 2*I + 2
      -> PARENT_INDEX = FLOOR((I-1)/2)

    INDEX_MAPPING
      -> PARENT_CHILD_RELATIONS
  }

  PROCESS HEAP_ORDER_REASONING {
    MIN_HEAP
      -> FOR_EACH_PARENT_CHILD
      -> PARENT_KEY <= CHILD_KEY

    MAX_HEAP
      -> FOR_EACH_PARENT_CHILD
      -> PARENT_KEY >= CHILD_KEY

    ALL_PARENT_CHILD_RELATIONS_VALID
      -> HEAP_ORDER_INVARIANT_SATISFIED
  }

  PROCESS INSERTION_REASONING {
    INSERT(ELEMENT)
      -> ADD_AT_NEXT_STRUCTURAL_POSITION

    ADD_AT_NEXT_STRUCTURAL_POSITION
      -> SIZE_INCREMENT

    NEW_NODE
      -> COMPARE_WITH_PARENT

    HEAP_ORDER_VIOLATION
      -> SWAP_WITH_PARENT
      -> REPEAT_SIFT_UP

    VALID_ORDER
      -> INSERTION_COMPLETE
  }

  PROCESS EXTRACTION_REASONING {
    MIN_HEAP
      -> EXTRACT_MIN = ROOT

    MAX_HEAP
      -> EXTRACT_MAX = ROOT

    ROOT_REMOVAL
      -> MOVE_LAST_ELEMENT_TO_ROOT

    MOVE_LAST_ELEMENT_TO_ROOT
      -> SIZE_DECREMENT

    ROOT
      -> COMPARE_WITH_PRIORITY_CHILD

    HEAP_ORDER_VIOLATION
      -> SWAP_WITH_SELECTED_CHILD
      -> REPEAT_SIFT_DOWN

    VALID_ORDER
      -> EXTRACTION_COMPLETE
  }

  PROCESS KEY_UPDATE_REASONING {
    NODE + NEW_KEY
      -> COMPARE_OLD_AND_NEW_KEY

    MIN_HEAP_DECREASE_KEY
      -> SIFT_UP_IF_REQUIRED

    MIN_HEAP_INCREASE_KEY
      -> SIFT_DOWN_IF_REQUIRED

    MAX_HEAP_INCREASE_KEY
      -> SIFT_UP_IF_REQUIRED

    MAX_HEAP_DECREASE_KEY
      -> SIFT_DOWN_IF_REQUIRED

    RESULT
      -> HEAP_ORDER_CHECK
  }

  PROCESS HEAPIFY_REASONING {
    ARBITRARY_ARRAY_OR_SUBTREE
      -> TARGET_NODE

    TARGET_NODE
      -> COMPARE_WITH_CHILDREN

    ORDER_VIOLATION
      -> SWAP_WITH_PRIORITY_CHILD

    SWAPPED_CHILD_POSITION
      -> RECURSIVE_OR_ITERATIVE_HEAPIFY

    RESULT
      -> LOCAL_HEAP_ORDER_RESTORED
  }

  PROCESS BUILD_HEAP_REASONING {
    UNSORTED_ELEMENT_SEQUENCE
      -> ARRAY_REPRESENTATION

    LAST_INTERNAL_NODE
      -> BOTTOM_UP_HEAPIFY

    EACH_INTERNAL_NODE_REVERSE_LEVEL_ORDER
      -> HEAPIFY

    RESULT
      -> VALID_HEAP
  }

  PROCESS PRIORITY_QUEUE_REASONING {
    PRIORITY_QUEUE
      -> HEAP_IMPLEMENTATION

    INSERT_WITH_PRIORITY
      -> HEAP_INSERT

    PEEK_HIGHEST_OR_LOWEST_PRIORITY
      -> ROOT_ACCESS

    REMOVE_HIGHEST_OR_LOWEST_PRIORITY
      -> ROOT_EXTRACTION
  }

  PROCESS INVARIANT_REASONING {
    HEAP_STATE
      -> STRUCTURAL_INVARIANT

    BINARY_HEAP
      -> COMPLETE_TREE_INVARIANT

    HEAP_STATE
      -> HEAP_ORDER_INVARIANT

    ARRAY_HEAP
      -> ARRAY_INDEX_INVARIANT

    POST_OPERATION_STATE
      -> ALL_REQUIRED_INVARIANTS_CHECK
  }

  PROCESS COMPLEXITY_REASONING {
    HEAP + HEAP_TYPE + OPERATION
      -> SIZE_HEIGHT_AND_IMPLEMENTATION

    BINARY_HEAP_INSERT
      -> SIFT_UP_PATH_LENGTH

    BINARY_HEAP_EXTRACT
      -> SIFT_DOWN_PATH_LENGTH

    ROOT_PEEK
      -> ROOT_ACCESS_COST

    BUILD_HEAP
      -> HEAPIFY_AGGREGATE_COST

    MEMORY_USAGE
      -> ELEMENT_STORAGE + IMPLEMENTATION_OVERHEAD

    COSTS
      -> TIME_AND_SPACE_COMPLEXITY
  }

  PROCESS PERSISTENCE_REASONING {
    PERSISTENT_HEAP_STATE(T1)
      + UPDATE
      -> NEW_HEAP_STATE(T2)

    T1
      -> PRESERVED

    T1 + T2
      -> STRUCTURAL_SHARING_IF_IMPLEMENTED
  }

  RULES {
    IF MIN_HEAP_IS_ASSERTED
    THEN REQUIRE PARENT_KEY <= CHILD_KEY_FOR_ALL_PARENT_CHILD_RELATIONS

    IF MAX_HEAP_IS_ASSERTED
    THEN REQUIRE PARENT_KEY >= CHILD_KEY_FOR_ALL_PARENT_CHILD_RELATIONS

    IF BINARY_HEAP_IS_ASSERTED
    THEN REQUIRE COMPLETE_BINARY_TREE_STRUCTURE

    IF ROOT_IS_EXTRACTED
    THEN RESTORE_STRUCTURE_AND_HEAP_ORDER_BEFORE_ASSERTING_VALID_HEAP

    IF KEY_IS_UPDATED
    THEN SELECT_REPAIR_DIRECTION_USING_HEAP_TYPE_AND_KEY_CHANGE

    IF HEAP_IS_USED_AS_PRIORITY_QUEUE
    THEN DISTINGUISH PRIORITY_ORDER_FROM_FULL_SORT_ORDER

    IF PERSISTENT_HEAP_IS_UPDATED
    THEN PRESERVE_PRIOR_HEAP_STATE

    IF SEMANTIC_IDENTIFIERS_DIFFER
    AND HEAP_REFERENT_IS_SAME
    THEN APPLY SEMANTIC_EQUIVALENCE
  }

  CONFIDENCE {
    CONFIDENCE_SCORE =
      WEIGHT(
        HEAP_IDENTITY_CERTAINTY,
        HEAP_TYPE_CERTAINTY,
        NODE_AND_ELEMENT_COMPLETENESS,
        PARENT_CHILD_COMPLETENESS,
        KEY_AND_PRIORITY_CERTAINTY,
        OPERATION_TRACE_COMPLETENESS,
        INVARIANT_EVIDENCE_QUALITY,
        PROVENANCE_COMPLETENESS
      )

    LEVELS {
      HIGH
      MODERATE
      LOW
      INSUFFICIENT
    }

    IF HEAP_TYPE_IS_UNKNOWN
    THEN REDUCE_ORDER_AND_OPERATION_CONFIDENCE

    IF PARENT_CHILD_OR_INDEX_DATA_IS_PARTIAL
    THEN REDUCE_STRUCTURE_CONFIDENCE

    IF COMPLETE_STATE_AND_OPERATION_TRACE_CONFIRM_INVARIANTS
    THEN INCREASE_CONFIDENCE_SCORE
  }

  SEMANTIC_EQUIVALENCE {
    EQUIVALENCE_KEY =
      NORMALISE(
        ENTITY_TYPE,
        HEAP_IDENTIFIER,
        HEAP_TYPE,
        KEY_OR_PRIORITY_TYPE,
        IMPLEMENTATION,
        SIZE,
        LANGUAGE_RUNTIME_CONTEXT
      )

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

    ELSE PRESERVE_DISTINCT_ENTITIES
  }

  REASONING_CONSTRAINTS {
    HEAP != MEMORY_HEAP
    HEAP != FULLY_SORTED_SEQUENCE
    HEAP != BINARY_SEARCH_TREE
    MIN_HEAP != MAX_HEAP
    ROOT_PRIORITY != GLOBAL_TOTAL_ORDER_OF_ALL_NONROOT_ELEMENTS
    HEAP_ORDER != BINARY_SEARCH_TREE_ORDER
    PRIORITY_QUEUE != HEAP_AS_IDENTICAL_ABSTRACT_CONCEPT
    HEAPIFY != FULL_SORT
    BUILD_HEAP != REPEATED_SORTING
    ARRAY_INDEX != NODE_IDENTITY
    KEY != PRIORITY_IN_ALL_IMPLEMENTATIONS
    COMPLETE_BINARY_TREE != PERFECT_BINARY_TREE
    PERSISTENT_HEAP != MUTABLE_HEAP
    COMPLEXITY_DEPENDS_ON_HEAP_TYPE_OPERATION_AND_IMPLEMENTATION
    LANGUAGE_RUNTIME_AND_CONFIGURATION_AFFECT_MEMORY_BEHAVIOUR
    PROVENANCE_MUST_BE_PRESERVED
    UNCERTAINTY_MUST_NOT_BE_DISCARDED
  }

  VALIDATION {
    CHECK_ENTITY_TYPES
    CHECK_RELATION_DOMAINS_AND_RANGES
    CHECK_HEAP_IDENTIFIER
    CHECK_HEAP_TYPE
    CHECK_NODE_AND_ELEMENT_IDENTITIES
    CHECK_KEY_VALUE_AND_PRIORITY
    CHECK_ROOT
    CHECK_PARENT_CHILD_RELATIONS
    CHECK_COMPLETE_TREE_STRUCTURE_IF_BINARY
    CHECK_ARRAY_INDEX_MAPPING_IF_APPLICABLE
    CHECK_HEAP_ORDER
    CHECK_INSERTION
    CHECK_EXTRACTION
    CHECK_KEY_UPDATES
    CHECK_HEAPIFY
    CHECK_BUILD_HEAP
    CHECK_PRIORITY_QUEUE_RELATIONS
    CHECK_INVARIANTS
    CHECK_COMPLEXITY_CONTEXT
    CHECK_PERSISTENCE
    CHECK_LANGUAGE_RUNTIME_AND_CONFIGURATION
    CHECK_PROVENANCE
    CHECK_CONFIDENCE
    CHECK_SEMANTIC_CONSISTENCY
  }

  OUTPUTS {
    NORMALISED_HEAP_ENTITIES
    HEAP_TYPE_RELATIONS
    NODE_ELEMENT_KEY_AND_PRIORITY_RELATIONS
    ROOT_RELATIONS
    PARENT_CHILD_RELATIONS
    ARRAY_INDEX_RELATIONS
    HEAP_ORDER_RELATIONS
    INSERTION_RELATIONS
    EXTRACTION_RELATIONS
    KEY_UPDATE_RELATIONS
    HEAPIFY_RELATIONS
    BUILD_HEAP_RELATIONS
    PRIORITY_QUEUE_RELATIONS
    HEAP_STATE_TRANSITIONS
    INVARIANT_RELATIONS
    TIME_COMPLEXITY_RELATIONS
    SPACE_COMPLEXITY_RELATIONS
    PERSISTENCE_AND_STRUCTURAL_SHARING_RELATIONS
    CONFIDENCE_SCORES
    EVIDENCE_LINKS
    PROVENANCE_RECORDS
    EXPLANATION_PATHS
  }

  UPDATE_MODEL {
    ON HEAP_OPERATION {
      NORMALISE
      RESOLVE_HEAP_NODE_AND_ELEMENT_IDENTITIES
      UPDATE_ELEMENT_SET
      UPDATE_ROOT_AND_PARENT_CHILD_RELATIONS
      UPDATE_ARRAY_INDICES_IF_APPLICABLE
      UPDATE_SIZE
      RESTORE_OR_CHECK_HEAP_ORDER
      RECHECK_INVARIANTS
      UPDATE_CONFIDENCE
    }

    ON IMPLEMENTATION_CONFIGURATION_OR_RUNTIME_CHANGE {
      UPDATE_IMPLEMENTATION_CONTEXT
      REASSESS_COMPLEXITY
      RECHECK_HEAP_TYPE_AND_INVARIANTS
      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_HEAP
      BY_HEAP_TYPE
      BY_NODE
      BY_ELEMENT
      BY_KEY
      BY_PRIORITY
      BY_ROOT
      BY_OPERATION
      BY_INSERTION
      BY_EXTRACTION
      BY_HEAPIFY
      BY_PRIORITY_QUEUE
      BY_INVARIANT
      BY_COMPLEXITY
      BY_CONFIDENCE
    }

    REASON {
      APPLY_RELATIONSHIPS
      APPLY_RULES
      ANALYSE_BINARY_HEAP_STRUCTURE
      ANALYSE_HEAP_ORDER
      TRACE_INSERTIONS
      TRACE_EXTRACTIONS
      ANALYSE_KEY_UPDATES
      TRACE_HEAPIFY
      ANALYSE_BUILD_HEAP
      ANALYSE_PRIORITY_QUEUE_RELATIONS
      CHECK_INVARIANTS
      ANALYSE_COMPLEXITY
      ANALYSE_PERSISTENCE
      CHECK_SEMANTIC_EQUIVALENCE
      PRESERVE_UNCERTAINTY
      TRACE_EVIDENCE
      TRACE_PROVENANCE
      GENERATE_EXPLANATION_PATH
    }

    RESPONSE_POLICY {
      DISTINGUISH_DATA_STRUCTURE_HEAP_FROM_MEMORY_HEAP
      DISTINGUISH_MIN_HEAP_FROM_MAX_HEAP
      DISTINGUISH_HEAP_ORDER_FROM_TOTAL_SORT_ORDER
      PRESERVE_HEAP_TYPE_KEY_PRIORITY_STRUCTURE_IMPLEMENTATION_LANGUAGE_AND_RUNTIME_CONTEXT
      DISTINGUISH_PRIORITY_QUEUE_ABSTRACTION_FROM_HEAP_IMPLEMENTATION
      PRESERVE_HEAP_INVARIANTS_AND_VERSIONED_STATES
      RETURN_CONFIDENCE_WHEN_AVAILABLE
      RETURN_PROVENANCE_WHEN_AVAILABLE
      AVOID_UNSUPPORTED_HEAP_INFERENCE
    }
  }

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

END FLOW