Programming Ontology

AI SEARCH

FLOW ALGEBRA — PROGRAMMING ONTOLOGY
Semantic Library
Version: 4.0
Canonical Page:
https://kirethresearch.org/booksai-core/ontologies/computing-ontologies/programming/programming-ontology-2.html

FLOW PROGRAMMING_ONTOLOGY {

  META {
    DOMAIN = "Computing Ontologies"
    SUBDOMAIN = "Programming"
    ONTOLOGY = "Programming Ontology"
    PURPOSE = "Formalise programming languages, source-code structures, symbols, types, expressions, control flow, functions, objects, compilation, execution, testing and program-state relationships."
    LOCALE = "en-GB"
  }

  ENTITY_TYPES {
    PROGRAMMING_LANGUAGE
    PROGRAM
    SOFTWARE
    SOURCE_CODE
    SOURCE_FILE
    MODULE
    PACKAGE
    LIBRARY
    FRAMEWORK
    SYNTAX
    SEMANTICS
    GRAMMAR
    TOKEN
    LEXEME
    IDENTIFIER
    KEYWORD
    OPERATOR
    EXPRESSION
    STATEMENT
    DECLARATION
    DEFINITION
    VARIABLE
    CONSTANT
    LITERAL
    VALUE
    DATA
    DATA_TYPE
    PRIMITIVE_TYPE
    COMPOSITE_TYPE
    USER_DEFINED_TYPE
    ARRAY
    LIST
    MAP
    SET
    OBJECT
    CLASS
    INTERFACE
    ENUMERATION
    FUNCTION
    PROCEDURE
    METHOD
    PARAMETER
    ARGUMENT
    RETURN_VALUE
    SCOPE
    NAMESPACE
    BINDING
    SYMBOL
    SYMBOL_TABLE
    CONTROL_FLOW
    SEQUENCE
    CONDITIONAL
    LOOP
    BRANCH
    EXCEPTION
    ERROR
    SYNTAX_ERROR
    TYPE_ERROR
    RUNTIME_ERROR
    LOGIC_ERROR
    INPUT
    OUTPUT
    PROGRAM_STATE
    MEMORY
    STACK
    HEAP
    POINTER
    REFERENCE
    RESOURCE
    COMPILER
    INTERPRETER
    ASSEMBLER
    LINKER
    LOADER
    ABSTRACT_SYNTAX_TREE
    INTERMEDIATE_REPRESENTATION
    BYTECODE
    MACHINE_CODE
    EXECUTABLE
    RUNTIME
    VIRTUAL_MACHINE
    BUILD
    DEPENDENCY
    TEST
    TEST_CASE
    UNIT_TEST
    INTEGRATION_TEST
    DEBUGGER
    TRACE
    VERSION
    CONFIGURATION
    EVIDENCE
    CONFIDENCE_SCORE
    PROVENANCE_RECORD
  }

  RELATIONSHIPS {
    IS_A
    INSTANCE_OF
    PART_OF
    CONTAINS
    WRITTEN_IN
    DEFINES
    DECLARES
    REFERENCES
    RESOLVES_TO
    BINDS_TO
    HAS_TYPE
    HAS_VALUE
    ASSIGNS
    EVALUATES_TO
    CALLS
    INVOKES
    HAS_PARAMETER
    HAS_ARGUMENT
    RETURNS
    IMPORTS
    EXPORTS
    DEPENDS_ON
    IMPLEMENTS
    EXTENDS
    INHERITS_FROM
    OVERRIDES
    INSTANTIATES
    READS
    WRITES
    ALLOCATES
    DEALLOCATES
    POINTS_TO
    REFERENCES_OBJECT
    PRECEDES
    FOLLOWS
    BRANCHES_TO
    LOOPS_TO
    THROWS
    CATCHES
    HANDLES
    COMPILES_TO
    INTERPRETS
    LINKS_TO
    LOADS
    EXECUTES
    TESTS
    DEBUGS
    HAS_STATE
    TRANSITIONS_TO
    HAS_CONFIGURATION
    HAS_VERSION
    DERIVED_FROM
    INFERRED_FROM
    HAS_EVIDENCE
    HAS_CONFIDENCE
    HAS_PROVENANCE
    MAPS_TO
    SEMANTICALLY_EQUIVALENT_TO
  }

  INPUTS {
    SOURCE_CODE
    SOURCE_FILES
    LANGUAGE_SPECIFICATIONS
    LANGUAGE_VERSION_DATA
    GRAMMARS
    TYPE_DEFINITIONS
    SYMBOL_TABLES
    ABSTRACT_SYNTAX_TREES
    CONTROL_FLOW_GRAPHS
    CALL_GRAPHS
    DEPENDENCY_GRAPHS
    BUILD_CONFIGURATIONS
    COMPILER_OUTPUT
    INTERPRETER_TRACES
    RUNTIME_TRACES
    TEST_RESULTS
    DEBUG_TRACES
    ERROR_LOGS
    VERSION_DATA
    CONFIGURATION_DATA
    ONTOLOGY_TERMS
  }

  NORMALISE {
    STANDARDISE_PROGRAM_IDENTIFIERS
    NORMALISE_LANGUAGE_NAMES
    NORMALISE_LANGUAGE_VERSIONS
    NORMALISE_SOURCE_PATHS
    NORMALISE_IDENTIFIERS
    NORMALISE_TYPE_NAMES
    NORMALISE_FUNCTION_SIGNATURES
    NORMALISE_CLASS_AND_INTERFACE_NAMES
    NORMALISE_MODULE_AND_PACKAGE_NAMES
    NORMALISE_DEPENDENCY_IDENTIFIERS
    NORMALISE_ERROR_TYPES
    NORMALISE_VERSION_IDENTIFIERS
    RESOLVE_SYMBOL_IDENTITIES
    ALIGN_ONTOLOGY_TERMS
    REMOVE_DUPLICATES
    VALIDATE_METADATA
    PRESERVE_PROVENANCE
  }

  PROCESS PROGRAMMING_ONTOLOGY_PIPELINE {
    SOURCE_CODE
      -> LANGUAGE_IDENTIFICATION
      -> LEXICAL_ANALYSIS
      -> SYNTACTIC_ANALYSIS
      -> SYMBOL_RESOLUTION
      -> TYPE_RESOLUTION
      -> CONTROL_FLOW_MAPPING
      -> CALL_AND_DEPENDENCY_MAPPING
      -> EXECUTION_SEMANTICS_MAPPING
      -> VALIDATION
      -> OUTPUT
  }

  PROCESS LEXICAL_AND_SYNTACTIC_REASONING {
    SOURCE_TEXT
      -> TOKENISATION

    TOKENISATION
      -> TOKEN_STREAM

    TOKEN_STREAM
      -> PARSING

    PARSING
      -> ABSTRACT_SYNTAX_TREE

    ABSTRACT_SYNTAX_TREE
      -> SYNTAX_VALIDATION
  }

  PROCESS SYMBOL_REASONING {
    IDENTIFIER_REFERENCE
      -> CURRENT_SCOPE

    CURRENT_SCOPE
      -> ENCLOSING_SCOPE_SEARCH_IF_REQUIRED

    SCOPE_SEARCH
      -> NAMESPACE_OR_MODULE_SEARCH

    MATCHED_DECLARATION
      -> SYMBOL_BINDING

    SYMBOL_BINDING
      -> REFERENCED_ENTITY
  }

  PROCESS TYPE_REASONING {
    EXPRESSION_OR_VALUE
      -> TYPE_INFORMATION

    TYPE_INFORMATION
      -> LANGUAGE_TYPE_RULES

    LANGUAGE_TYPE_RULES
      -> TYPE_COMPATIBILITY_CHECK

    COMPATIBLE
      -> TYPED_EXPRESSION

    INCOMPATIBLE
      -> TYPE_ERROR
  }

  PROCESS CONTROL_FLOW_REASONING {
    ENTRY_POINT
      -> STATEMENT_SEQUENCE

    STATEMENT_SEQUENCE
      -> CONDITIONAL_EDGES
      -> LOOP_EDGES
      -> FUNCTION_CALL_EDGES
      -> EXCEPTION_EDGES

    CONTROL_EDGES
      -> CONTROL_FLOW_GRAPH

    CONTROL_FLOW_GRAPH
      -> REACHABILITY_AND_PATH_ANALYSIS
  }

  PROCESS FUNCTION_REASONING {
    FUNCTION_CALL
      -> CALLEE_RESOLUTION

    CALLEE_RESOLUTION
      -> ARGUMENT_EVALUATION

    ARGUMENT_EVALUATION
      -> PARAMETER_BINDING

    PARAMETER_BINDING
      -> FUNCTION_BODY_EXECUTION

    FUNCTION_BODY_EXECUTION
      -> RETURN_VALUE_OR_EXCEPTION

    RETURN_VALUE
      -> CALLER_CONTINUATION
  }

  PROCESS OBJECT_REASONING {
    CLASS_DEFINITION
      -> MEMBER_DEFINITIONS

    OBJECT_CREATION
      -> CLASS_RESOLUTION

    CLASS_RESOLUTION
      -> OBJECT_INITIALISATION

    METHOD_CALL
      -> RECEIVER_RESOLUTION
      -> METHOD_DISPATCH

    METHOD_DISPATCH
      -> METHOD_IMPLEMENTATION
  }

  PROCESS MEMORY_REASONING {
    VALUE_OR_OBJECT_CREATION
      -> STORAGE_REQUIREMENT

    STORAGE_REQUIREMENT
      -> STACK_OR_HEAP_OR_STATIC_STORAGE

    POINTER_OR_REFERENCE
      -> TARGET_RESOLUTION

    LIFETIME_END
      -> AUTOMATIC_MANAGED_OR_MANUAL_DEALLOCATION
  }

  PROCESS COMPILATION_REASONING {
    SOURCE_CODE
      -> FRONT_END_ANALYSIS

    FRONT_END_ANALYSIS
      -> INTERMEDIATE_REPRESENTATION

    INTERMEDIATE_REPRESENTATION
      -> OPTIMISATION

    OPTIMISATION
      -> CODE_GENERATION

    CODE_GENERATION
      -> OBJECT_OR_MACHINE_CODE

    OBJECT_CODE
      -> LINKING

    LINKING
      -> EXECUTABLE_OR_LIBRARY
  }

  PROCESS EXECUTION_REASONING {
    EXECUTABLE_SOURCE_OR_BYTECODE
      -> RUNTIME_OR_INTERPRETER_OR_VM

    RUNTIME
      -> INSTRUCTION_OR_EXPRESSION_EVALUATION

    EVALUATION
      -> PROGRAM_STATE_TRANSITION

    PROGRAM_STATE_TRANSITION
      -> NEXT_OPERATION_OR_TERMINATION
  }

  PROCESS TEST_AND_ERROR_REASONING {
    TEST_CASE
      -> TEST_INPUT

    TEST_INPUT
      -> PROGRAM_EXECUTION

    PROGRAM_EXECUTION
      -> OBSERVED_RESULT

    OBSERVED_RESULT + EXPECTED_RESULT
      -> PASS_OR_FAIL

    FAILURE_OR_RUNTIME_ERROR
      -> TRACE_AND_CONTEXT_ANALYSIS
      -> ROOT_CAUSE_HYPOTHESIS
      -> CONFIDENCE_SCORE
  }

  RULES {
    IF IDENTIFIER_IS_REFERENCED
    THEN REQUIRE SCOPE_NAMESPACE_AND_BINDING_CONTEXT

    IF VALUE_IS_INTERPRETED
    THEN PRESERVE TYPE_LANGUAGE_AND_VERSION_CONTEXT

    IF FUNCTION_IS_CALLED
    THEN LINK CALLER_CALLEE_ARGUMENTS_PARAMETERS_AND_RETURN_OR_EXCEPTION

    IF OBJECT_IS_INSTANTIATED
    THEN PRESERVE CLASS_AND_CONSTRUCTION_CONTEXT

    IF SOURCE_CODE_COMPILES
    THEN DO_NOT_AUTOMATICALLY_ASSERT CORRECT_RUNTIME_BEHAVIOUR

    IF TEST_PASSES
    THEN DO_NOT_ASSERT ABSENCE_OF_ALL_DEFECTS

    IF RUNTIME_ERROR_OCCURS
    THEN PRESERVE PROGRAM_STATE_CALL_STACK_AND_INPUT_CONTEXT

    IF SEMANTIC_IDENTIFIERS_DIFFER
    AND PROGRAMMING_REFERENT_IS_SAME
    THEN APPLY SEMANTIC_EQUIVALENCE
  }

  CONFIDENCE {
    CONFIDENCE_SCORE =
      WEIGHT(
        LANGUAGE_VERSION_CERTAINTY,
        PARSE_COMPLETENESS,
        SYMBOL_RESOLUTION_COMPLETENESS,
        TYPE_INFORMATION_COMPLETENESS,
        CONTROL_FLOW_COMPLETENESS,
        RUNTIME_TRACE_QUALITY,
        TEST_EVIDENCE_QUALITY,
        PROVENANCE_COMPLETENESS
      )

    LEVELS {
      HIGH
      MODERATE
      LOW
      INSUFFICIENT
    }

    IF LANGUAGE_OR_VERSION_IS_UNKNOWN
    THEN REDUCE_SEMANTIC_INFERENCE_CONFIDENCE

    IF DYNAMIC_DISPATCH_OR_RUNTIME_STATE_IS_UNOBSERVED
    THEN REDUCE_RUNTIME_INFERENCE_CONFIDENCE

    IF REPRODUCIBLE_TESTS_AND_TRACES_CONFIRM_BEHAVIOUR
    THEN INCREASE CONFIDENCE_SCORE
  }

  SEMANTIC_EQUIVALENCE {
    EQUIVALENCE_KEY =
      NORMALISE(
        ENTITY_TYPE,
        CANONICAL_IDENTIFIER,
        PROGRAMMING_LANGUAGE,
        LANGUAGE_VERSION,
        SIGNATURE_OR_TYPE,
        MODULE_AND_SCOPE_CONTEXT
      )

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

    ELSE PRESERVE_DISTINCT_ENTITIES
  }

  REASONING_CONSTRAINTS {
    SOURCE_CODE != EXECUTING_PROGRAM
    SYNTAX != SEMANTICS
    IDENTIFIER != REFERENCED_ENTITY_WITHOUT_BINDING
    VARIABLE != VALUE
    TYPE != VALUE
    PARAMETER != ARGUMENT
    FUNCTION_DEFINITION != FUNCTION_CALL
    CLASS != OBJECT
    INTERFACE != IMPLEMENTATION
    POINTER != POINTED_TO_OBJECT
    COMPILATION_SUCCESS != PROGRAM_CORRECTNESS
    TEST_PASS != PROOF_OF_CORRECTNESS
    RUNTIME_ERROR != ROOT_CAUSE
    STATIC_CALL_GRAPH_MAY_DIFFER_FROM_RUNTIME_DISPATCH
    LANGUAGE_VERSION_AFFECTS_SEMANTICS
    CONFIGURATION_AND_DEPENDENCIES_AFFECT_PROGRAM_BEHAVIOUR
    DYNAMIC_EXECUTION_MAY_NOT_BE_FULLY_INFERABLE_FROM_STATIC_CODE
    PROVENANCE_MUST_BE_PRESERVED
    UNCERTAINTY_MUST_NOT_BE_DISCARDED
  }

  VALIDATION {
    CHECK_ENTITY_TYPES
    CHECK_RELATION_DOMAINS_AND_RANGES
    CHECK_LANGUAGE_AND_VERSION
    CHECK_PARSE_STRUCTURE
    CHECK_SYMBOL_BINDINGS
    CHECK_SCOPE_AND_NAMESPACE
    CHECK_TYPE_RELATIONS
    CHECK_CONTROL_FLOW
    CHECK_CALL_GRAPH
    CHECK_OBJECT_AND_CLASS_RELATIONS
    CHECK_MEMORY_RELATIONS
    CHECK_DEPENDENCIES
    CHECK_COMPILATION_RELATIONS
    CHECK_RUNTIME_TRACES
    CHECK_TEST_RESULTS
    CHECK_ERROR_RELATIONS
    CHECK_CONFIGURATION
    CHECK_PROVENANCE
    CHECK_CONFIDENCE
    CHECK_SEMANTIC_CONSISTENCY
  }

  OUTPUTS {
    NORMALISED_PROGRAMMING_ENTITIES
    LANGUAGE_RELATIONS
    SYNTAX_AND_SEMANTIC_RELATIONS
    ABSTRACT_SYNTAX_RELATIONS
    SYMBOL_BINDINGS
    TYPE_RELATIONS
    CONTROL_FLOW_GRAPHS
    CALL_GRAPHS
    CLASS_AND_OBJECT_RELATIONS
    DEPENDENCY_GRAPHS
    MEMORY_RELATIONS
    COMPILATION_RELATIONS
    EXECUTION_TRACES
    TEST_RELATIONS
    ERROR_AND_EXCEPTION_RELATIONS
    ROOT_CAUSE_HYPOTHESES
    CONFIDENCE_SCORES
    EVIDENCE_LINKS
    PROVENANCE_RECORDS
    EXPLANATION_PATHS
  }

  UPDATE_MODEL {
    ON SOURCE_OR_CONFIGURATION_CHANGE {
      NORMALISE
      REPARSE_AFFECTED_SOURCE
      RESOLVE_SYMBOLS
      RECHECK_TYPES
      UPDATE_CONTROL_FLOW
      UPDATE_CALL_AND_OBJECT_RELATIONS
      UPDATE_DEPENDENCY_GRAPHS
      RECOMPUTE_AFFECTED_RELATIONS
      UPDATE_CONFIDENCE
      PRESERVE_VERSION_HISTORY
    }

    ON NEW_TEST_RUNTIME_OR_ERROR_DATA {
      LINK_EVIDENCE
      UPDATE_EXECUTION_TRACE
      UPDATE_DYNAMIC_DISPATCH_RELATIONS
      UPDATE_TEST_RELATIONS
      REASSESS_ERROR_AND_ROOT_CAUSE_HYPOTHESES
      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_PROGRAM
      BY_LANGUAGE
      BY_MODULE
      BY_IDENTIFIER
      BY_SYMBOL
      BY_TYPE
      BY_FUNCTION
      BY_CLASS
      BY_OBJECT
      BY_CONTROL_FLOW
      BY_DEPENDENCY
      BY_COMPILATION
      BY_RUNTIME
      BY_TEST
      BY_ERROR
      BY_CONFIDENCE
    }

    REASON {
      APPLY_RELATIONSHIPS
      APPLY_RULES
      PARSE_SOURCE
      RESOLVE_SYMBOLS
      ANALYSE_TYPES
      TRACE_CONTROL_FLOW
      TRACE_FUNCTION_CALLS
      ANALYSE_OBJECTS_AND_DISPATCH
      ANALYSE_MEMORY
      TRACE_COMPILATION_AND_EXECUTION
      ANALYSE_TESTS
      ANALYSE_ERRORS
      CHECK_SEMANTIC_EQUIVALENCE
      PRESERVE_UNCERTAINTY
      TRACE_EVIDENCE
      TRACE_PROVENANCE
      GENERATE_EXPLANATION_PATH
    }

    RESPONSE_POLICY {
      DISTINGUISH_SYNTAX_FROM_SEMANTICS
      DISTINGUISH_IDENTIFIER_FROM_BOUND_ENTITY
      PRESERVE_LANGUAGE_VERSION_TYPE_SCOPE_NAMESPACE_AND_MODULE_CONTEXT
      DISTINGUISH_CLASS_FROM_OBJECT
      DISTINGUISH_STATIC_STRUCTURE_FROM_RUNTIME_BEHAVIOUR
      DISTINGUISH_TEST_SUCCESS_FROM_PROOF_OF_CORRECTNESS
      RETURN_CONFIDENCE_WHEN_AVAILABLE
      RETURN_PROVENANCE_WHEN_AVAILABLE
      AVOID_UNSUPPORTED_PROGRAMMING_INFERENCE
    }
  }

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

END FLOW