Foundations of Computing

AI SEARCH

FLOW ALGEBRA — FOUNDATIONS OF COMPUTING
Semantic Library
Version: 4.0
Canonical Page:
https://kirethresearch.org/booksai-core/ontologies/computing-ontologies/foundations-of-computing.html

FLOW FOUNDATIONS_OF_COMPUTING {

  META {
    DOMAIN = "Computing Ontologies"
    SUBDOMAIN = "Foundations of Computing"
    ONTOLOGY = "Foundations of Computing"
    PURPOSE = "Formalise the foundational entities, relationships, abstractions and reasoning structures underlying computation, algorithms, information, programs and computational systems."
    LOCALE = "en-GB"
  }

  ENTITY_TYPES {
    COMPUTATION
    COMPUTATIONAL_SYSTEM
    ABSTRACT_MACHINE
    FORMAL_SYSTEM
    ALGORITHM
    PROGRAM
    PROCEDURE
    FUNCTION
    OPERATION
    INSTRUCTION
    EXPRESSION
    STATEMENT
    SYMBOL
    ALPHABET
    STRING
    LANGUAGE
    FORMAL_LANGUAGE
    GRAMMAR
    SYNTAX
    SEMANTICS
    TYPE
    VALUE
    VARIABLE
    CONSTANT
    DATA
    INFORMATION
    BIT
    BYTE
    BINARY_VALUE
    DATA_STRUCTURE
    STATE
    STATE_SPACE
    TRANSITION
    INPUT
    OUTPUT
    PROCESS
    EVENT
    RESOURCE
    MEMORY
    TIME
    COMPLEXITY
    PROBLEM
    PROBLEM_INSTANCE
    SOLUTION
    DECISION_PROBLEM
    COMPUTABLE_FUNCTION
    TURING_MACHINE
    AUTOMATON
    LOGIC
    PROPOSITION
    PREDICATE
    PROOF
    THEOREM
    SET
    RELATION
    GRAPH
    NODE
    EDGE
    MODEL
    REPRESENTATION
    ENCODING
    DECODING
    EVIDENCE
    CONFIDENCE_SCORE
    PROVENANCE_RECORD
  }

  RELATIONSHIPS {
    IS_A
    INSTANCE_OF
    PART_OF
    CONTAINS
    REPRESENTS
    ENCODES
    DECODES
    COMPUTES
    EXECUTES
    TRANSFORMS
    MAPS_TO
    ACCEPTS
    REJECTS
    READS
    WRITES
    PRODUCES
    CONSUMES
    HAS_INPUT
    HAS_OUTPUT
    HAS_STATE
    TRANSITIONS_TO
    PRECEDES
    FOLLOWS
    DEPENDS_ON
    IMPLEMENTS
    SATISFIES
    PROVES
    DERIVES
    DEFINES
    REFERENCES
    EQUIVALENT_TO
    REDUCES_TO
    DECIDES
    RECOGNISES
    TERMINATES_ON
    HAS_COMPLEXITY
    HAS_RESOURCE_REQUIREMENT
    DERIVED_FROM
    INFERRED_FROM
    HAS_EVIDENCE
    HAS_CONFIDENCE
    HAS_PROVENANCE
    SEMANTICALLY_EQUIVALENT_TO
  }

  FOUNDATIONAL_DOMAINS {
    THEORY_OF_COMPUTATION
    ALGORITHMS
    DATA_STRUCTURES
    FORMAL_LANGUAGES
    AUTOMATA_THEORY
    COMPUTABILITY_THEORY
    COMPLEXITY_THEORY
    INFORMATION_THEORY
    LOGIC
    DISCRETE_MATHEMATICS
    PROGRAMMING_LANGUAGE_FOUNDATIONS
    TYPE_THEORY
    FORMAL_SEMANTICS
    COMPUTER_ARCHITECTURE_FOUNDATIONS
  }

  INPUTS {
    SYMBOLS
    DATA
    FORMAL_EXPRESSIONS
    ALGORITHMS
    PROGRAMS
    PROBLEM_DEFINITIONS
    FORMAL_LANGUAGES
    GRAMMARS
    MACHINE_DEFINITIONS
    LOGICAL_AXIOMS
    TYPE_RULES
    STATE_DEFINITIONS
    TRANSITION_RULES
    RESOURCE_BOUNDS
    PROOFS
    ONTOLOGY_TERMS
  }

  NORMALISE {
    STANDARDISE_SYMBOLS
    NORMALISE_IDENTIFIERS
    NORMALISE_FORMAL_NOTATION
    NORMALISE_DATA_TYPES
    NORMALISE_STATE_REPRESENTATIONS
    NORMALISE_MACHINE_DEFINITIONS
    NORMALISE_COMPLEXITY_NOTATION
    RESOLVE_EQUIVALENT_EXPRESSIONS
    ALIGN_ONTOLOGY_TERMS
    REMOVE_DUPLICATES
    VALIDATE_DEFINITIONS
    PRESERVE_PROVENANCE
  }

  PROCESS COMPUTATION {
    INPUT
      -> ENCODING
      -> INITIAL_STATE
      -> COMPUTATIONAL_STEPS
      -> STATE_TRANSITIONS
      -> HALT_OR_CONTINUE
      -> OUTPUT
      -> VALIDATION
  }

  PROCESS ALGORITHM_EXECUTION {
    PROBLEM_INSTANCE
      -> INPUT_REPRESENTATION

    INPUT_REPRESENTATION + ALGORITHM
      -> INITIALISE

    INITIALISE
      -> EXECUTE_OPERATIONS

    EXECUTE_OPERATIONS
      -> INTERMEDIATE_STATES

    INTERMEDIATE_STATES
      -> TERMINATION_CHECK

    TERMINATION_CHECK
      -> SOLUTION_OR_CONTINUATION
  }

  PROCESS FORMAL_LANGUAGE_REASONING {
    ALPHABET
      -> SYMBOL_SET

    SYMBOL_SET
      -> STRINGS

    GRAMMAR + STRING
      -> DERIVATION_ANALYSIS

    DERIVATION_ANALYSIS
      -> ACCEPT_OR_REJECT

    ACCEPTED_STRINGS
      -> LANGUAGE
  }

  PROCESS AUTOMATON_REASONING {
    INPUT_STRING + INITIAL_STATE + TRANSITION_FUNCTION
      -> STATE_SEQUENCE

    STATE_SEQUENCE
      -> FINAL_STATE

    FINAL_STATE
      -> ACCEPTANCE_CHECK

    ACCEPTANCE_CHECK
      -> ACCEPT_OR_REJECT
  }

  PROCESS COMPUTABILITY_REASONING {
    PROBLEM
      -> FORMALISE_AS_FUNCTION_OR_LANGUAGE

    FORMALISED_PROBLEM
      -> MACHINE_MODEL

    MACHINE_MODEL
      -> TERMINATION_ANALYSIS
      -> DECIDABILITY_ANALYSIS

    DECIDABILITY_ANALYSIS
      -> DECIDABLE_OR_UNDECIDABLE_OR_UNKNOWN
  }

  PROCESS COMPLEXITY_REASONING {
    ALGORITHM + INPUT_SIZE
      -> RESOURCE_ANALYSIS

    RESOURCE_ANALYSIS
      -> TIME_REQUIREMENT
      -> SPACE_REQUIREMENT

    TIME_REQUIREMENT + SPACE_REQUIREMENT
      -> ASYMPTOTIC_CLASSIFICATION

    ASYMPTOTIC_CLASSIFICATION
      -> COMPLEXITY_RELATION
  }

  PROCESS PROGRAM_SEMANTICS {
    PROGRAM + INPUT_STATE
      -> SEMANTIC_INTERPRETATION

    SEMANTIC_INTERPRETATION
      -> STATE_TRANSITIONS

    STATE_TRANSITIONS
      -> OUTPUT_STATE

    OUTPUT_STATE
      -> SPECIFICATION_CHECK
  }

  PROCESS INFORMATION_REPRESENTATION {
    INFORMATION
      -> ENCODING_SCHEME
      -> DATA_REPRESENTATION

    DATA_REPRESENTATION
      -> STORAGE_OR_TRANSMISSION

    STORAGE_OR_TRANSMISSION
      -> DECODING

    DECODING
      -> RECONSTRUCTED_INFORMATION
  }

  RULES {
    IF ALGORITHM CLAIMS_TO_SOLVE PROBLEM
    THEN REQUIRE {
      INPUT_DOMAIN
      OUTPUT_DOMAIN
      TERMINATION_CONDITION
      CORRECTNESS_CONDITION
    }

    IF PROGRAM_EXECUTION_TERMINATES
    THEN LINK {
      INITIAL_STATE
      EXECUTION_TRACE
      FINAL_STATE
      OUTPUT
    }

    IF A REDUCES_TO B
    AND B IS_DECIDABLE
    THEN DO_NOT_AUTOMATICALLY_INFER A IS_DECIDABLE_WITHOUT_REDUCTION_DIRECTION_CHECK

    IF TWO_PROGRAMS_PRODUCE_SAME_OUTPUT_FOR_TESTED_INPUTS
    THEN DO_NOT_ASSERT_GENERAL_SEMANTIC_EQUIVALENCE

    IF COMPLEXITY_IS_STATED
    THEN REQUIRE {
      RESOURCE_TYPE
      INPUT_SIZE_DEFINITION
      COMPUTATIONAL_MODEL
      BOUND_TYPE
    }

    IF FORMAL_PROOF_EXISTS
    THEN PRESERVE {
      AXIOMS
      INFERENCE_RULES
      DERIVATION
      CONCLUSION
    }

    IF SEMANTIC_IDENTIFIERS_DIFFER
    AND FORMAL_REFERENT_IS_SAME
    THEN APPLY SEMANTIC_EQUIVALENCE
  }

  CONFIDENCE {
    CONFIDENCE_SCORE =
      WEIGHT(
        FORMAL_DEFINITION_COMPLETENESS,
        PROOF_VALIDITY,
        MODEL_SPECIFICATION,
        EXECUTION_REPRODUCIBILITY,
        TEST_COVERAGE,
        REPRESENTATION_ACCURACY,
        CONSISTENCY,
        PROVENANCE_COMPLETENESS
      )

    LEVELS {
      HIGH
      MODERATE
      LOW
      INSUFFICIENT
    }

    IF FORMAL_PROOF_VALIDATES_CLAIM
    THEN INCREASE CONFIDENCE_SCORE

    IF RESULT_IS_ONLY_EMPIRICALLY_TESTED
    THEN PRESERVE_LIMITED_GENERALISATION

    IF COMPUTATIONAL_MODEL_IS_UNSPECIFIED
    THEN REDUCE CONFIDENCE_SCORE
  }

  SEMANTIC_EQUIVALENCE {
    EQUIVALENCE_KEY =
      NORMALISE(
        ENTITY_TYPE,
        FORMAL_DEFINITION,
        INPUT_DOMAIN,
        OUTPUT_DOMAIN,
        COMPUTATIONAL_CONTEXT
      )

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

    ELSE PRESERVE_DISTINCT_ENTITIES
  }

  REASONING_CONSTRAINTS {
    PROGRAM != EXECUTING_PROCESS
    ALGORITHM != IMPLEMENTATION
    SYNTAX != SEMANTICS
    DATA != INFORMATION
    EMPIRICAL_TESTING != FORMAL_PROOF
    TERMINATION != CORRECTNESS
    CORRECTNESS != EFFICIENCY
    COMPUTABILITY != TRACTABILITY
    EQUIVALENT_OUTPUT_ON_SAMPLES != GENERAL_EQUIVALENCE
    COMPLEXITY_DEPENDS_ON_COMPUTATIONAL_MODEL
    REPRESENTATION_AFFECTS_COMPUTATION
    PROVENANCE_MUST_BE_PRESERVED
    UNCERTAINTY_MUST_NOT_BE_DISCARDED
  }

  VALIDATION {
    CHECK_ENTITY_TYPES
    CHECK_RELATION_DOMAINS_AND_RANGES
    CHECK_FORMAL_DEFINITIONS
    CHECK_INPUT_OUTPUT_DOMAINS
    CHECK_STATE_TRANSITIONS
    CHECK_TERMINATION_CONDITIONS
    CHECK_PROOF_STRUCTURE
    CHECK_COMPLEXITY_CONTEXT
    CHECK_COMPUTATIONAL_MODEL
    CHECK_SEMANTIC_EQUIVALENCE
    CHECK_PROVENANCE
    CHECK_CONFIDENCE
    CHECK_DUPLICATE_ENTITIES
  }

  OUTPUTS {
    NORMALISED_FOUNDATIONAL_ENTITIES
    FORMAL_RELATIONSHIPS
    COMPUTATIONAL_MODELS
    ALGORITHM_REPRESENTATIONS
    EXECUTION_TRACES
    STATE_TRANSITION_GRAPHS
    LANGUAGE_RECOGNITION_RESULTS
    COMPUTABILITY_RESULTS
    COMPLEXITY_RELATIONS
    SEMANTIC_RELATIONS
    PROOF_RELATIONS
    CONFIDENCE_SCORES
    EVIDENCE_LINKS
    PROVENANCE_RECORDS
    EXPLANATION_PATHS
  }

  UPDATE_MODEL {
    ON NEW_FORMAL_DEFINITION {
      NORMALISE
      ENTITY_RESOLUTION
      UPDATE_RELATIONSHIPS
      RECOMPUTE_DEPENDENT_INFERENCES
      UPDATE_CONFIDENCE
      PRESERVE_VERSION_HISTORY
    }

    ON NEW_PROOF_OR_COUNTEREXAMPLE {
      LINK_EVIDENCE
      REASSESS_CLAIMS
      REASSESS_EQUIVALENCE
      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,
        FOUNDATIONAL_DOMAINS,
        RULES,
        CONFIDENCE,
        SEMANTIC_EQUIVALENCE,
        REASONING_CONSTRAINTS,
        UPDATE_MODEL
      )

    FLOW_HASH = SHA256(HASH_INPUT)
  }

  AI_CONSUMPTION {
    INDEX {
      ONTOLOGY
      ENTITY_TYPES
      RELATIONSHIPS
      FOUNDATIONAL_DOMAINS
      RULES
      OUTPUTS
    }

    RETRIEVE {
      BY_COMPUTATION
      BY_ALGORITHM
      BY_PROGRAM
      BY_MACHINE
      BY_LANGUAGE
      BY_PROBLEM
      BY_COMPLEXITY
      BY_STATE
      BY_RELATION
      BY_PROOF
      BY_CONFIDENCE
    }

    REASON {
      APPLY_FORMAL_RULES
      TRACE_STATE_TRANSITIONS
      TRACE_REDUCTIONS
      ANALYSE_TERMINATION
      ANALYSE_COMPUTABILITY
      ANALYSE_COMPLEXITY
      CHECK_SEMANTIC_EQUIVALENCE
      PRESERVE_UNCERTAINTY
      TRACE_EVIDENCE
      TRACE_PROVENANCE
      GENERATE_EXPLANATION_PATH
    }

    RESPONSE_POLICY {
      DISTINGUISH_ALGORITHM_FROM_IMPLEMENTATION
      DISTINGUISH_SYNTAX_FROM_SEMANTICS
      DISTINGUISH_TESTING_FROM_PROOF
      PRESERVE_COMPUTATIONAL_MODEL_CONTEXT
      RETURN_CONFIDENCE_WHEN_AVAILABLE
      RETURN_PROVENANCE_WHEN_AVAILABLE
      AVOID_UNSUPPORTED_FORMAL_INFERENCE
    }
  }

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

END FLOW