Computer Science Ontology

AI SEARCH

FLOW ALGEBRA — COMPUTER SCIENCE ONTOLOGY
Semantic Library
Version: 4.0
Canonical Page:
https://kirethresearch.org/booksai-core/ontologies/computing-ontologies/foundations-of-computing/computer-science-ontology.html

FLOW COMPUTER_SCIENCE_ONTOLOGY {

  META {
    DOMAIN = "Computing Ontologies"
    SUBDOMAIN = "Foundations of Computing"
    ONTOLOGY = "Computer Science Ontology"
    PURPOSE = "Formalise the principal entities, disciplines, relationships, computational processes and reasoning structures that constitute computer science."
    LOCALE = "en-GB"
  }

  ENTITY_TYPES {
    COMPUTER_SCIENCE
    COMPUTATION
    COMPUTATIONAL_PROBLEM
    COMPUTATIONAL_SYSTEM
    FORMAL_SYSTEM
    ABSTRACT_MACHINE
    COMPUTER
    HARDWARE
    SOFTWARE
    PROGRAM
    ALGORITHM
    PROCEDURE
    FUNCTION
    INSTRUCTION
    PROCESS
    THREAD
    DATA
    INFORMATION
    DATA_TYPE
    DATA_STRUCTURE
    DATABASE
    FILE
    NETWORK
    PROTOCOL
    PROGRAMMING_LANGUAGE
    FORMAL_LANGUAGE
    GRAMMAR
    SYNTAX
    SEMANTICS
    COMPILER
    INTERPRETER
    OPERATING_SYSTEM
    DISTRIBUTED_SYSTEM
    PARALLEL_SYSTEM
    SECURITY_SYSTEM
    AI_SYSTEM
    MACHINE_LEARNING_MODEL
    ROBOT
    USER_INTERFACE
    GRAPHIC
    IMAGE
    TEXT
    KNOWLEDGE_BASE
    KNOWLEDGE_GRAPH
    STATE
    EVENT
    TRANSITION
    INPUT
    OUTPUT
    RESOURCE
    COMPLEXITY
    PROOF
    SPECIFICATION
    MODEL
    EVIDENCE
    CONFIDENCE_SCORE
    PROVENANCE_RECORD
  }

  DISCIPLINES {
    THEORY_OF_COMPUTATION
    ALGORITHMS_AND_DATA_STRUCTURES
    PROGRAMMING_LANGUAGES
    SOFTWARE_ENGINEERING
    COMPUTER_ARCHITECTURE
    OPERATING_SYSTEMS
    DATABASE_SYSTEMS
    COMPUTER_NETWORKS
    DISTRIBUTED_COMPUTING
    PARALLEL_COMPUTING
    CYBERSECURITY
    CRYPTOGRAPHY
    ARTIFICIAL_INTELLIGENCE
    MACHINE_LEARNING
    NATURAL_LANGUAGE_PROCESSING
    COMPUTER_VISION
    ROBOTICS
    COMPUTER_GRAPHICS
    HUMAN_COMPUTER_INTERACTION
    INFORMATION_RETRIEVAL
    DATA_SCIENCE
    SCIENTIFIC_COMPUTING
    FORMAL_METHODS
  }

  RELATIONSHIPS {
    IS_A
    INSTANCE_OF
    PART_OF
    CONTAINS
    STUDIES
    MODELS
    REPRESENTS
    DEFINES
    IMPLEMENTS
    COMPUTES
    EXECUTES
    RUNS_ON
    PROCESSES
    TRANSFORMS
    STORES
    RETRIEVES
    READS
    WRITES
    SENDS
    RECEIVES
    COMMUNICATES_WITH
    CONNECTED_TO
    DEPENDS_ON
    INVOKES
    CALLS
    RETURNS
    COMPILES_TO
    INTERPRETS
    HAS_INPUT
    HAS_OUTPUT
    HAS_STATE
    TRANSITIONS_TO
    HAS_COMPLEXITY
    SATISFIES
    VERIFIES
    PROVES
    PREDICTS
    CLASSIFIES
    OPTIMISES
    DERIVED_FROM
    INFERRED_FROM
    HAS_EVIDENCE
    HAS_CONFIDENCE
    HAS_PROVENANCE
    MAPS_TO
    SEMANTICALLY_EQUIVALENT_TO
  }

  INPUTS {
    FORMAL_DEFINITIONS
    ALGORITHMS
    SOURCE_CODE
    PROGRAMS
    DATASETS
    DATA_STRUCTURES
    SYSTEM_SPECIFICATIONS
    HARDWARE_SPECIFICATIONS
    NETWORK_DEFINITIONS
    DATABASE_SCHEMAS
    LANGUAGE_GRAMMARS
    LOGICAL_AXIOMS
    EXECUTION_TRACES
    PERFORMANCE_DATA
    SECURITY_DATA
    PROOFS
    ONTOLOGY_TERMS
  }

  NORMALISE {
    STANDARDISE_IDENTIFIERS
    NORMALISE_FORMAL_NOTATION
    NORMALISE_PROGRAMMING_LANGUAGE_NAMES
    NORMALISE_DATA_TYPES
    NORMALISE_ALGORITHM_NAMES
    NORMALISE_SYSTEM_COMPONENTS
    NORMALISE_COMPLEXITY_NOTATION
    RESOLVE_EQUIVALENT_CONCEPTS
    ALIGN_ONTOLOGY_TERMS
    REMOVE_DUPLICATES
    VALIDATE_METADATA
    PRESERVE_PROVENANCE
  }

  PROCESS COMPUTER_SCIENCE_REASONING {
    INPUT
      -> CONCEPT_IDENTIFICATION
      -> DOMAIN_CLASSIFICATION
      -> ENTITY_RESOLUTION
      -> RELATION_MAPPING
      -> COMPUTATIONAL_ANALYSIS
      -> VALIDATION
      -> INFERENCE
      -> CONFIDENCE_ESTIMATION
      -> OUTPUT
  }

  PROCESS ALGORITHM_REASONING {
    COMPUTATIONAL_PROBLEM
      -> FORMAL_PROBLEM_DEFINITION

    FORMAL_PROBLEM_DEFINITION
      -> ALGORITHM

    ALGORITHM
      -> CORRECTNESS_ANALYSIS
      -> TERMINATION_ANALYSIS
      -> COMPLEXITY_ANALYSIS

    CORRECTNESS_ANALYSIS
    + TERMINATION_ANALYSIS
    + COMPLEXITY_ANALYSIS
      -> ALGORITHM_CHARACTERISATION
  }

  PROCESS PROGRAMMING_LANGUAGE_REASONING {
    SOURCE_CODE + PROGRAMMING_LANGUAGE
      -> PARSE

    PARSE
      -> SYNTAX_TREE

    SYNTAX_TREE
      -> SEMANTIC_ANALYSIS

    SEMANTIC_ANALYSIS
      -> COMPILE_OR_INTERPRET

    COMPILE_OR_INTERPRET
      -> EXECUTION_BEHAVIOUR
  }

  PROCESS SOFTWARE_SYSTEM_REASONING {
    SOFTWARE_COMPONENTS
      -> DEPENDENCY_GRAPH

    DEPENDENCY_GRAPH
      -> INTERFACE_ANALYSIS
      -> CONFIGURATION_ANALYSIS

    INTERFACE_ANALYSIS + CONFIGURATION_ANALYSIS
      -> SYSTEM_COMPOSITION

    SYSTEM_COMPOSITION
      -> EXECUTION
      -> OBSERVED_BEHAVIOUR
  }

  PROCESS DATA_REASONING {
    DATA
      -> REPRESENTATION

    REPRESENTATION
      -> DATA_STRUCTURE_OR_SCHEMA

    DATA_STRUCTURE_OR_SCHEMA
      -> STORAGE
      -> RETRIEVAL
      -> TRANSFORMATION

    TRANSFORMATION
      -> OUTPUT_DATA
  }

  PROCESS NETWORK_REASONING {
    NODE_A + PROTOCOL + NODE_B
      -> COMMUNICATION_PATH

    COMMUNICATION_PATH
      -> ENCODING
      -> TRANSMISSION
      -> ROUTING
      -> RECEPTION
      -> DECODING
  }

  PROCESS FORMAL_VERIFICATION {
    PROGRAM_OR_SYSTEM + SPECIFICATION
      -> FORMAL_MODEL

    FORMAL_MODEL
      -> PROPERTY_CHECK

    PROPERTY_CHECK
      -> PROOF_OR_COUNTEREXAMPLE

    PROOF_OR_COUNTEREXAMPLE
      -> VERIFICATION_RESULT
  }

  PROCESS AI_REASONING {
    DATASET + AI_MODEL
      -> TRAINING_OR_INFERENCE

    TRAINING_OR_INFERENCE
      -> MODEL_OUTPUT

    MODEL_OUTPUT
      -> VALIDATION
      -> CONFIDENCE_ESTIMATION
      -> EXPLANATION
  }

  RULES {
    IF ALGORITHM CLAIMS_TO_SOLVE COMPUTATIONAL_PROBLEM
    THEN REQUIRE {
      INPUT_DOMAIN
      OUTPUT_DOMAIN
      TERMINATION_CONDITION
      CORRECTNESS_CRITERIA
    }

    IF PROGRAM IMPLEMENTS ALGORITHM
    THEN PRESERVE_DISTINCTION(PROGRAM, ALGORITHM)

    IF SOFTWARE EXECUTES
    THEN REQUIRE {
      EXECUTION_ENVIRONMENT
      DEPENDENCIES
      VERSION_CONTEXT
      INPUT_OR_TRIGGER
    }

    IF FORMAL_PROOF_EXISTS
    THEN LINK {
      PREMISES
      INFERENCE_RULES
      DERIVATION
      CONCLUSION
    }

    IF MODEL_OUTPUT == PREDICTION
    THEN DO_NOT_ASSERT_AS_OBSERVED_FACT

    IF TWO_IMPLEMENTATIONS_SHARE_ALGORITHM
    THEN DO_NOT_ASSUME_IDENTICAL_PERFORMANCE

    IF SEMANTIC_IDENTIFIERS_DIFFER
    AND COMPUTER_SCIENCE_REFERENT_IS_SAME
    THEN APPLY SEMANTIC_EQUIVALENCE
  }

  CONFIDENCE {
    CONFIDENCE_SCORE =
      WEIGHT(
        DEFINITION_COMPLETENESS,
        FORMAL_VALIDITY,
        IMPLEMENTATION_CONTEXT,
        EXECUTION_REPRODUCIBILITY,
        TEST_COVERAGE,
        PROOF_SUPPORT,
        EMPIRICAL_SUPPORT,
        PROVENANCE_COMPLETENESS
      )

    LEVELS {
      HIGH
      MODERATE
      LOW
      INSUFFICIENT
    }

    IF FORMAL_PROOF_SUPPORTS_CLAIM
    THEN INCREASE CONFIDENCE_SCORE

    IF RESULT_IS_ONLY_EMPIRICALLY_TESTED
    THEN PRESERVE_GENERALISATION_LIMIT

    IF EXECUTION_CONTEXT_IS_UNKNOWN
    THEN REDUCE CONFIDENCE_SCORE
  }

  SEMANTIC_EQUIVALENCE {
    EQUIVALENCE_KEY =
      NORMALISE(
        ENTITY_TYPE,
        CANONICAL_IDENTIFIER,
        FORMAL_DEFINITION,
        VERSION_OR_MODEL,
        COMPUTATIONAL_CONTEXT
      )

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

    ELSE PRESERVE_DISTINCT_ENTITIES
  }

  REASONING_CONSTRAINTS {
    ALGORITHM != PROGRAM
    PROGRAM != PROCESS
    SOURCE_CODE != EXECUTION
    SYNTAX != SEMANTICS
    DATA != INFORMATION
    TESTING != FORMAL_PROOF
    TERMINATION != CORRECTNESS
    CORRECTNESS != EFFICIENCY
    COMPUTABILITY != TRACTABILITY
    PREDICTION != OBSERVATION
    PERFORMANCE_DEPENDS_ON_IMPLEMENTATION_AND_ENVIRONMENT
    PROVENANCE_MUST_BE_PRESERVED
    UNCERTAINTY_MUST_NOT_BE_DISCARDED
  }

  VALIDATION {
    CHECK_ENTITY_TYPES
    CHECK_DISCIPLINE_CLASSIFICATION
    CHECK_RELATION_DOMAINS_AND_RANGES
    CHECK_FORMAL_DEFINITIONS
    CHECK_ALGORITHM_CONTEXT
    CHECK_PROGRAM_CONTEXT
    CHECK_EXECUTION_CONTEXT
    CHECK_COMPLEXITY_CONTEXT
    CHECK_PROOF_STRUCTURE
    CHECK_DATA_RELATIONS
    CHECK_NETWORK_RELATIONS
    CHECK_PROVENANCE
    CHECK_CONFIDENCE
    CHECK_SEMANTIC_CONSISTENCY
    CHECK_DUPLICATE_ENTITIES
  }

  OUTPUTS {
    NORMALISED_COMPUTER_SCIENCE_ENTITIES
    DISCIPLINE_RELATIONSHIPS
    ALGORITHM_RELATIONS
    PROGRAM_RELATIONS
    DATA_RELATIONS
    SYSTEM_RELATIONS
    NETWORK_RELATIONS
    FORMAL_LANGUAGE_RELATIONS
    COMPLEXITY_RELATIONS
    VERIFICATION_RESULTS
    AI_MODEL_RELATIONS
    CONFIDENCE_SCORES
    EVIDENCE_LINKS
    PROVENANCE_RECORDS
    EXPLANATION_PATHS
  }

  UPDATE_MODEL {
    ON NEW_COMPUTING_KNOWLEDGE {
      NORMALISE
      ENTITY_RESOLUTION
      UPDATE_DISCIPLINE_MAPPING
      UPDATE_RELATIONSHIPS
      RECOMPUTE_DEPENDENT_INFERENCES
      UPDATE_CONFIDENCE
      PRESERVE_VERSION_HISTORY
    }

    ON NEW_PROOF_OR_EXECUTION_EVIDENCE {
      LINK_EVIDENCE
      REASSESS_CLAIMS
      REASSESS_RELATIONSHIPS
      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,
        DISCIPLINES,
        RELATIONSHIPS,
        RULES,
        CONFIDENCE,
        SEMANTIC_EQUIVALENCE,
        REASONING_CONSTRAINTS,
        UPDATE_MODEL
      )

    FLOW_HASH = SHA256(HASH_INPUT)
  }

  AI_CONSUMPTION {
    INDEX {
      ONTOLOGY
      ENTITY_TYPES
      DISCIPLINES
      RELATIONSHIPS
      RULES
      OUTPUTS
    }

    RETRIEVE {
      BY_DISCIPLINE
      BY_COMPUTATION
      BY_ALGORITHM
      BY_PROGRAM
      BY_LANGUAGE
      BY_DATA
      BY_SYSTEM
      BY_NETWORK
      BY_COMPLEXITY
      BY_PROOF
      BY_AI_MODEL
      BY_CONFIDENCE
    }

    REASON {
      APPLY_RELATIONSHIPS
      APPLY_RULES
      TRACE_ALGORITHM_TO_IMPLEMENTATION
      TRACE_DATA_FLOW
      TRACE_EXECUTION
      ANALYSE_COMPLEXITY
      ANALYSE_FORMAL_PROPERTIES
      CHECK_SEMANTIC_EQUIVALENCE
      PRESERVE_UNCERTAINTY
      TRACE_EVIDENCE
      TRACE_PROVENANCE
      GENERATE_EXPLANATION_PATH
    }

    RESPONSE_POLICY {
      DISTINGUISH_ALGORITHM_FROM_PROGRAM
      DISTINGUISH_SOURCE_FROM_EXECUTION
      DISTINGUISH_TESTING_FROM_PROOF
      DISTINGUISH_PREDICTION_FROM_OBSERVATION
      PRESERVE_COMPUTATIONAL_CONTEXT
      RETURN_CONFIDENCE_WHEN_AVAILABLE
      RETURN_PROVENANCE_WHEN_AVAILABLE
      AVOID_UNSUPPORTED_COMPUTER_SCIENCE_INFERENCE
    }
  }

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

END FLOW