Programming

AI SEARCH

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

FLOW PROGRAMMING {

  META {
    DOMAIN = "Computing Ontologies"
    SUBDOMAIN = "Programming"
    ONTOLOGY = "Programming"
    PURPOSE = "Formalise programming concepts, languages, source code, data, control flow, functions, types, compilation, execution, testing, errors and software-development relationships."
    LOCALE = "en-GB"
  }

  ENTITY_TYPES {
    PROGRAMMING
    PROGRAM
    SOFTWARE
    SOURCE_CODE
    SOURCE_FILE
    MODULE
    PACKAGE
    LIBRARY
    FRAMEWORK
    PROGRAMMING_LANGUAGE
    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
    CONTROL_FLOW
    SEQUENCE
    CONDITIONAL
    LOOP
    BRANCH
    EXCEPTION
    ERROR
    RUNTIME_ERROR
    SYNTAX_ERROR
    TYPE_ERROR
    LOGIC_ERROR
    INPUT
    OUTPUT
    STATE
    MEMORY
    STACK
    HEAP
    POINTER
    REFERENCE
    RESOURCE
    COMPILER
    INTERPRETER
    ASSEMBLER
    LINKER
    LOADER
    BYTECODE
    MACHINE_CODE
    EXECUTABLE
    RUNTIME
    VIRTUAL_MACHINE
    BUILD
    DEPENDENCY
    TEST
    UNIT_TEST
    INTEGRATION_TEST
    DEBUGGER
    TRACE
    VERSION
    CONFIGURATION
    EVIDENCE
    CONFIDENCE_SCORE
    PROVENANCE_RECORD
  }

  PROGRAMMING_DOMAINS {
    LANGUAGE_FOUNDATIONS
    SYNTAX_AND_SEMANTICS
    DATA_AND_TYPES
    VARIABLES_AND_BINDINGS
    EXPRESSIONS_AND_OPERATORS
    CONTROL_FLOW
    FUNCTIONS_AND_PROCEDURES
    OBJECT_ORIENTED_PROGRAMMING
    FUNCTIONAL_PROGRAMMING
    LOGIC_PROGRAMMING
    CONCURRENT_PROGRAMMING
    MEMORY_MANAGEMENT
    ERROR_AND_EXCEPTION_HANDLING
    COMPILATION_AND_INTERPRETATION
    BUILD_AND_DEPENDENCY_MANAGEMENT
    TESTING_AND_DEBUGGING
    PROGRAM_EXECUTION
  }

  RELATIONSHIPS {
    IS_A
    INSTANCE_OF
    PART_OF
    CONTAINS
    WRITTEN_IN
    DEFINES
    DECLARES
    REFERENCES
    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
    LANGUAGE_SPECIFICATIONS
    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_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_REASONING_PIPELINE {
    SOURCE_CODE
      -> LANGUAGE_IDENTIFICATION
      -> LEXICAL_STRUCTURE
      -> SYNTACTIC_STRUCTURE
      -> SYMBOL_RESOLUTION
      -> TYPE_RESOLUTION
      -> CONTROL_FLOW_MAPPING
      -> CALL_AND_DEPENDENCY_MAPPING
      -> EXECUTION_SEMANTICS
      -> VALIDATION
      -> OUTPUT
  }

  PROCESS PARSING_REASONING {
    SOURCE_TEXT
      -> LEXICAL_ANALYSIS

    LEXICAL_ANALYSIS
      -> TOKEN_STREAM

    TOKEN_STREAM
      -> PARSING

    PARSING
      -> ABSTRACT_SYNTAX_TREE

    ABSTRACT_SYNTAX_TREE
      -> SYNTAX_VALIDATION
  }

  PROCESS SYMBOL_RESOLUTION {
    IDENTIFIER_REFERENCE
      -> SCOPE_LOOKUP

    SCOPE_LOOKUP
      -> NAMESPACE_LOOKUP

    NAMESPACE_LOOKUP
      -> DECLARATION_OR_DEFINITION

    RESOLVED_SYMBOL
      -> BINDING
  }

  PROCESS TYPE_REASONING {
    EXPRESSION_OR_VALUE
      -> TYPE_INFORMATION

    TYPE_INFORMATION
      -> STATIC_OR_DYNAMIC_TYPE_RULES

    TYPE_RULES
      -> COMPATIBLE_TYPE
      OR -> TYPE_ERROR

    COMPATIBLE_TYPE
      -> TYPED_EXPRESSION
  }

  PROCESS CONTROL_FLOW_REASONING {
    ENTRY_POINT
      -> STATEMENT_SEQUENCE

    STATEMENT_SEQUENCE
      -> CONDITIONAL_BRANCHES
      -> LOOPS
      -> FUNCTION_CALLS
      -> EXCEPTION_PATHS

    CONTROL_EDGES
      -> CONTROL_FLOW_GRAPH

    CONTROL_FLOW_GRAPH
      -> REACHABILITY_AND_PATH_ANALYSIS
  }

  PROCESS FUNCTION_REASONING {
    FUNCTION_CALL
      -> FUNCTION_RESOLUTION

    FUNCTION_RESOLUTION
      -> ARGUMENT_BINDING

    ARGUMENT_BINDING
      -> FUNCTION_BODY_EXECUTION

    FUNCTION_BODY_EXECUTION
      -> RETURN_VALUE_OR_EXCEPTION

    RETURN_VALUE
      -> CALLER_CONTINUATION
  }

  PROCESS MEMORY_REASONING {
    VALUE_OR_OBJECT_CREATION
      -> STORAGE_REQUIREMENT

    STORAGE_REQUIREMENT
      -> STACK_OR_HEAP_OR_STATIC_STORAGE

    REFERENCE_OR_POINTER
      -> TARGET_RESOLUTION

    LIFETIME_END
      -> AUTOMATIC_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 INTERPRETATION_REASONING {
    SOURCE_OR_BYTECODE
      -> INTERPRETER_OR_VM

    INTERPRETER_OR_VM
      -> INSTRUCTION_EVALUATION

    INSTRUCTION_EVALUATION
      -> PROGRAM_STATE_UPDATE

    PROGRAM_STATE_UPDATE
      -> NEXT_INSTRUCTION_OR_TERMINATION
  }

  PROCESS TESTING_REASONING {
    TEST_CASE
      -> TEST_INPUT

    TEST_INPUT
      -> PROGRAM_EXECUTION

    PROGRAM_EXECUTION
      -> OBSERVED_OUTPUT_OR_STATE

    OBSERVED_OUTPUT_OR_STATE + EXPECTED_RESULT
      -> PASS_OR_FAIL

    FAILURE
      -> DIAGNOSTIC_EVIDENCE
  }

  PROCESS ERROR_REASONING {
    SOURCE_OR_EXECUTION_EVENT
      -> ERROR_DETECTION

    ERROR_DETECTION
      -> SYNTAX_ERROR
      OR -> TYPE_ERROR
      OR -> RUNTIME_ERROR
      OR -> LOGIC_ERROR_CANDIDATE

    ERROR_CONTEXT
      -> CAUSAL_TRACE

    CAUSAL_TRACE
      -> ROOT_CAUSE_HYPOTHESIS
      -> CONFIDENCE_SCORE
  }

  RULES {
    IF IDENTIFIER_IS_REFERENCED
    THEN REQUIRE SCOPE_AND_BINDING_CONTEXT

    IF VALUE_IS_INTERPRETED
    THEN PRESERVE TYPE_AND_LANGUAGE_CONTEXT

    IF FUNCTION_IS_CALLED
    THEN LINK CALLER_CALLEE_ARGUMENTS_AND_RETURN_OR_EXCEPTION

    IF SOURCE_CODE_COMPILES
    THEN DO_NOT_AUTOMATICALLY_ASSERT_CORRECT_PROGRAM_BEHAVIOUR

    IF TEST_PASSES
    THEN DO_NOT_ASSERT ABSENCE_OF_ALL_DEFECTS

    IF RUNTIME_ERROR_OCCURS
    THEN PRESERVE EXECUTION_STATE_AND_CALL_CONTEXT

    IF SAME_SYNTAX_EXISTS_IN_DIFFERENT_LANGUAGES
    THEN DO_NOT_ASSUME_IDENTICAL_SEMANTICS

    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_BEHAVIOUR_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_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
    POINTER != POINTED_TO_OBJECT
    COMPILATION_SUCCESS != PROGRAM_CORRECTNESS
    TEST_PASS != PROOF_OF_CORRECTNESS
    RUNTIME_ERROR != ROOT_CAUSE
    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_PROGRAMMING_DOMAINS
    CHECK_RELATION_DOMAINS_AND_RANGES
    CHECK_LANGUAGE_AND_VERSION
    CHECK_PARSE_STRUCTURE
    CHECK_SYMBOL_BINDINGS
    CHECK_TYPE_RELATIONS
    CHECK_CONTROL_FLOW
    CHECK_CALL_GRAPH
    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
    SYMBOL_BINDINGS
    TYPE_RELATIONS
    CONTROL_FLOW_GRAPHS
    CALL_GRAPHS
    DEPENDENCY_GRAPHS
    MEMORY_RELATIONS
    COMPILATION_RELATIONS
    INTERPRETATION_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_DEPENDENCY_GRAPHS
      RECOMPUTE_AFFECTED_RELATIONS
      UPDATE_CONFIDENCE
      PRESERVE_VERSION_HISTORY
    }

    ON NEW_TEST_RUNTIME_OR_ERROR_DATA {
      LINK_EVIDENCE
      UPDATE_EXECUTION_TRACE
      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,
        PROGRAMMING_DOMAINS,
        RELATIONSHIPS,
        RULES,
        CONFIDENCE,
        SEMANTIC_EQUIVALENCE,
        REASONING_CONSTRAINTS,
        UPDATE_MODEL
      )

    FLOW_HASH = SHA256(HASH_INPUT)
  }

  AI_CONSUMPTION {
    INDEX {
      ONTOLOGY
      ENTITY_TYPES
      PROGRAMMING_DOMAINS
      RELATIONSHIPS
      RULES
      OUTPUTS
    }

    RETRIEVE {
      BY_PROGRAM
      BY_LANGUAGE
      BY_MODULE
      BY_IDENTIFIER
      BY_TYPE
      BY_FUNCTION
      BY_CLASS
      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_MEMORY
      TRACE_COMPILATION_OR_INTERPRETATION
      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_AND_MODULE_CONTEXT
      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_KNOWLEDGE
            )
          )
        )
      )
  }
}

END FLOW