Computational Model Ontology

AI INTERPRETATION NOTE
This Flow Algebra defines the Computational Model Ontology within the Kireth Research Semantic Library. A computational model is a mathematically defined representation implemented for execution on a computer in order to simulate, approximate, analyse, predict or optimise system behaviour. This ontology supports algorithms, discretisation, numerical schemes, state updates, solvers, convergence, stability, error control, simulation, computational experiments, surrogate computation, parallel execution, reproducibility, validation and relationships with mathematical modelling, numerical analysis, scientific computing and software systems.

FLOW_ALGEBRA_RECORD {

METADATA {
 FLOW_NAME = "Computational Model Ontology"
 FLOW_TYPE = "Mathematical Ontology"
 DOMAIN = "Mathematics"
 SUBDOMAIN = "Applied Mathematics"
 SPECIALISATION = "Mathematical Modelling / Computational Model"
 CANONICAL_PAGE = "https://kirethresearch.org/booksai-core/ontologies/mathematical-ontologies/applied-mathematics-ontologies/mathematical-modelling/computational-model-ontology.html"
 LANGUAGE = "en-GB"
 VERSION = "1.0"
 STATUS = "active"
}

IDENTITY {
 PRIMARY_ENTITY = ComputationalModel
 ENTITY_CLASS = ExecutableMathematicalModel
 PRIMARY_CONTEXT = MathematicalModelling
 DEFINITION = "A computational model is a mathematical model represented in an executable form so that its behaviour can be approximated, simulated, analysed or optimised by computational procedures."
 SEMANTIC_ROLE = "Provides the machine-readable framework for executable mathematical representations, numerical schemes, algorithms, state transitions, discretisation, solver configuration, error control, reproducibility and simulation."
}

SCOPE {
 INCLUDE = [
  ComputationalModel,
  ExecutableModel,
  MathematicalModel,
  Algorithm,
  NumericalMethod,
  Discretisation,
  Mesh,
  Grid,
  TimeStep,
  StateVector,
  StateUpdate,
  Solver,
  IterativeSolver,
  DirectSolver,
  Convergence,
  Stability,
  Consistency,
  Accuracy,
  ErrorEstimate,
  TruncationError,
  RoundoffError,
  Residual,
  Tolerance,
  Simulation,
  ComputationalExperiment,
  ParameterSweep,
  MonteCarloSimulation,
  DeterministicSimulation,
  StochasticSimulation,
  ParallelComputation,
  DistributedComputation,
  ReducedOrderModel,
  SurrogateModel,
  Verification,
  Validation,
  Reproducibility,
  Provenance,
  SoftwareImplementation
 ]

 EXCLUDE_AS_PRIMARY = [
  PureMathematicalModelWithoutExecutableRepresentation,
  GenericSoftwareWithoutMathematicalModel,
  DataProcessingPipelineWithoutModelDynamics,
  NumericalResultWithoutModelOrAlgorithmContext
 ]

 DISAMBIGUATION_RULE =
  "When a mathematical model is represented through algorithms, numerical schemes, discretisation, state updates, solvers or executable simulation code, interpret it as a computational model."
}

CORE_CONCEPTS {

 ComputationalModel {
  definition = "An executable mathematical representation of a system or mathematical process."
 }

 ExecutableModel {
  definition = "A model whose equations, rules or state transitions are represented in a form that can be evaluated computationally."
 }

 Algorithm {
  definition = "A finite or iterative computational procedure for carrying out model operations."
 }

 NumericalMethod {
  definition = "A computational procedure approximating a mathematical quantity or solution."
 }

 Discretisation {
  definition = "A transformation from a continuous or large-scale mathematical problem into a finite computational representation."
 }

 StateVector {
  definition = "A computational representation of the model state at a given step or time."
 }

 StateUpdate {
  definition = "A computational rule mapping the current state and inputs to a new state."
 }

 Solver {
  definition = "An algorithm used to compute an exact or approximate solution of model equations."
 }

 Convergence {
  definition = "The tendency of a numerical solution to approach the target mathematical solution as discretisation or iteration is refined."
 }

 Stability {
  definition = "The controlled response of a computational method to perturbations, roundoff, data variation or numerical error."
 }

 Consistency {
  definition = "The property that a discrete numerical scheme approximates the intended continuous equation as resolution increases."
 }

 Simulation {
  definition = "Execution of a computational model to generate trajectories, fields, states or outputs."
 }

 Reproducibility {
  definition = "The ability to reproduce computational results using sufficient information about code, inputs, parameters, environment and numerical settings."
 }
}

RELATIONS {
 ComputationalModel --is_special_case_of--> MathematicalModel
 ComputationalModel --is_implemented_by--> SoftwareImplementation
 ComputationalModel --uses--> Algorithm
 ComputationalModel --uses--> NumericalMethod
 ComputationalModel --may_require--> Discretisation
 Discretisation --produces--> Grid
 Discretisation --produces--> Mesh
 ComputationalModel --has_state--> StateVector
 StateUpdate --transforms--> StateVector
 Solver --solves--> GoverningEquation
 IterativeSolver --has_property--> Convergence
 NumericalMethod --has_property--> Stability
 NumericalMethod --has_property--> Consistency
 NumericalMethod --has_property--> Accuracy
 ErrorEstimate --quantifies--> NumericalError
 Simulation --executes--> ComputationalModel
 ComputationalExperiment --uses--> Simulation
 ParameterSweep --evaluates--> ParameterDependence
 Verification --evaluates--> ImplementationCorrectness
 Validation --evaluates--> FitnessForPurpose
 Reproducibility --depends_on--> Provenance
}

OPERATORS {
 DISCRETISE(model,spatial_scheme,time_scheme) :=
  finite_computational_representation

 INITIALISE_STATE(initial_conditions,parameters) :=
  computational_state_at_start

 UPDATE_STATE(state,inputs,dt,algorithm) :=
  next_state

 SOLVE(system,solver,tolerance) :=
  approximate_or_exact_solution

 COMPUTE_RESIDUAL(model,solution) :=
  discrepancy_between_discrete_equations_and_solution

 CHECK_CONVERGENCE(sequence,tolerance) :=
  stopping_condition_based_on_error_or_residual

 ESTIMATE_ERROR(reference,approximation) :=
  declared_norm_of_difference

 REFINE_DISCRETISATION(mesh_or_grid) :=
  higher_resolution_representation

 SIMULATE(model,inputs,parameters,conditions) :=
  sequence_or_field_of_computed_states

 PARAMETER_SWEEP(model,parameter_set) :=
  collection_of_simulation_outputs

 MONTE_CARLO(model,input_distribution,N) :=
  ensemble_of_N_stochastic_or_uncertain_runs

 VERIFY_COMPUTATIONAL_MODEL(model,reference_tests) :=
  implementation_and_numerical_correctness_assessment
}

DEFINITIONS {
 D1 = "A computational model is an executable representation of a mathematical model."
 D2 = "Discretisation converts continuous or large-scale structures into computational form."
 D3 = "Numerical error is distinct from model-form error."
 D4 = "Consistency, stability and convergence are distinct numerical properties."
 D5 = "Simulation is execution of a computational model, not the model itself."
 D6 = "Solver tolerances influence computational accuracy and cost."
 D7 = "Mesh or time-step refinement can reveal convergence behaviour."
 D8 = "Verification checks whether the computational implementation solves the intended mathematics."
 D9 = "Validation checks whether the model represents the intended system adequately."
 D10 = "Reproducibility requires preserving computational provenance."
}

AXIOMS {
 A1_EXECUTABILITY:
  ComputationalModel has an executable representation or algorithmic evaluation pathway

 A2_MODEL_LINK:
  ComputationalModel represents or approximates an underlying mathematical model

 A3_DISCRETISATION:
  Continuous models require a finite representation for standard digital computation

 A4_NUMERICAL_ERROR:
  Computational approximation introduces numerical error unless exact symbolic evaluation is used

 A5_VERIFICATION_VALIDATION_DISTINCTION:
  Correct computation does not imply model validity

 A6_REFINEMENT:
  Valid convergence analysis compares solutions under systematic refinement

 A7_REPRODUCIBILITY:
  Reproducing computational results requires sufficient provenance and configuration data

 A8_CONSTRAINT_PRESERVATION:
  Computational execution should preserve declared mathematical and physical constraints to the intended numerical tolerance
}

REASONING {

 R1_COMPUTATIONAL_MODEL_IDENTIFICATION {
  INPUT = model_description
  IDENTIFY = mathematical_structure
  IDENTIFY = executable_representation
  IDENTIFY = algorithms_and_solvers
  RETURN = ComputationalModel
 }

 R2_DISCRETISATION_REASONING {
  INPUT = continuous_or_large_scale_model
  IDENTIFY = spatial_temporal_state_or_parameter dimensions
  SELECT = discretisation_scheme
  PRODUCE = finite_system
  RETURN = computational_representation
 }

 R3_SOLVER_SELECTION {
  INPUT = discrete_problem
  CLASSIFY = linear_nonlinear_sparse_dense_stiff_or_stochastic
  SELECT = compatible_solver
  RETURN = solver_strategy
 }

 R4_CONVERGENCE_ANALYSIS {
  INPUT = solution_sequence_under_refinement
  COMPUTE = error_or_residual trend
  ESTIMATE = convergence_rate
  RETURN = convergence_profile
 }

 R5_STABILITY_ANALYSIS {
  INPUT = numerical_method_and_model
  PERTURB = input_state_or_roundoff
  ANALYSE = growth_or_decay
  RETURN = stability_profile
 }

 R6_ERROR_ANALYSIS {
  INPUT = model_discretisation_solver_and_solution
  IDENTIFY = truncation_roundoff_iteration_and_sampling errors
  ESTIMATE = total_numerical_error
  RETURN = error_profile
 }

 R7_SIMULATION_REASONING {
  INPUT = computational_model_initial_state_inputs_parameters
  INITIALISE = state
  ITERATE = update_rule_or_solver
  RECORD = outputs
  RETURN = simulation_result
 }

 R8_VERIFICATION_REASONING {
  INPUT = implementation_and_reference_cases
  TEST = analytical_solution_manufactured_solution_conservation_or_benchmark
  RETURN = verification_status
 }

 R9_REPRODUCIBILITY_REASONING {
  INPUT = computational_result
  EXTRACT = code_version_parameters_inputs_environment_random_seed_and_solver settings
  RETURN = reproducibility_record
 }

 R10_PERFORMANCE_REASONING {
  INPUT = computational_model_and_hardware_context
  IDENTIFY = time_memory_parallelism_and_scalability requirements
  RETURN = computational_cost_profile
 }
}

CONSTRAINTS {
 C1 = "Numerical approximation must not be confused with exact mathematical solution."
 C2 = "Solver tolerance must be interpreted relative to problem scaling."
 C3 = "Convergence claims require systematic refinement or iteration evidence."
 C4 = "Stability depends on the numerical method and problem."
 C5 = "Mesh independence and time-step independence are distinct checks."
 C6 = "Roundoff and truncation errors must be distinguished."
 C7 = "Parallel execution may change floating-point reduction order."
 C8 = "Randomised simulations require recorded random seeds or equivalent reproducibility controls."
 C9 = "Software bugs are distinct from mathematical model error."
 C10 = "Computational performance tradeoffs must not silently weaken accuracy requirements."
}

SEMANTIC_EQUIVALENCE {
 "ComputationalModel" <=> "ExecutableMathematicalModel"
 "NumericalMethod" <=> "ComputationalApproximationMethod"
 "Discretisation" <=> "FiniteComputationalRepresentation"
 "Simulation" <=> "ExecutionOfComputationalModel"
 "Convergence" <=> "ApproximationApproachesTargetUnderRefinement"
 "Verification" <=> "ComputationalImplementationCorrectnessAssessment"
}

VALIDATION {
 V1 = "Underlying mathematical model is identified."
 V2 = "Executable representation is defined."
 V3 = "Discretisation and solver are appropriate to the problem class."
 V4 = "Convergence evidence is available when approximation quality is claimed."
 V5 = "Stability is assessed where relevant."
 V6 = "Residual or error tolerances are explicit."
 V7 = "Initial and boundary conditions are represented correctly."
 V8 = "Verification evidence is distinct from validation evidence."
 V9 = "Random seeds and computational environment are recorded when required."
 V10 = "Numerical outputs preserve declared physical or mathematical constraints within tolerance."
}

CONFIDENCE {
 BASE_CONFIDENCE = 0.99
 COMPUTATIONAL_MODEL_DEFINITION = 0.99
 DISCRETISATION_REASONING = 0.98
 SOLVER_SELECTION_REASONING = 0.98
 CONVERGENCE_REASONING = 0.98
 STABILITY_REASONING = 0.97
 ERROR_ANALYSIS_REASONING = 0.98
 VERIFICATION_REASONING = 0.99
 REPRODUCIBILITY_REASONING = 0.99

 POLICY =
  "Reduce confidence when discretisation, solver, tolerances, refinement evidence, boundary conditions, numerical precision, implementation provenance or reproducibility metadata are underspecified."
}

AI_CONSUMPTION {
 PURPOSES = [
  SemanticSearch,
  OntologyGrounding,
  ComputationalModelReasoning,
  NumericalMethodReasoning,
  DiscretisationReasoning,
  SolverSelection,
  SimulationReasoning,
  ConvergenceAnalysis,
  StabilityAnalysis,
  ErrorAnalysis,
  VerificationReasoning,
  ReproducibilityReasoning,
  ParallelComputingReasoning,
  ScientificComputingReasoning,
  KnowledgeGraphConstruction,
  RetrievalAugmentation,
  RecursiveInference
 ]

 NORMALISE {
  "computational model" -> ComputationalModel
  "executable model" -> ExecutableModel
  "numerical model" -> ComputationalModel
  "numerical method" -> NumericalMethod
  "discretisation" -> Discretisation
  "discretization" -> Discretisation
  "solver" -> Solver
  "simulation" -> Simulation
  "convergence" -> Convergence
  "stability" -> Stability
  "verification" -> Verification
  "reproducibility" -> Reproducibility
 }

 INTERPRETATION_ORDER = [
  detect_computational_model_context,
  identify underlying_mathematical_model_discretisation_state_representation_solver_and_algorithm,
  identify simulation_solution_verification_convergence_stability_error_or_performance goal,
  execute or analyse computational pathway,
  verify numerical_accuracy_constraint_preservation_and_reproducibility assumptions,
  return semantic output
 ]
}

EXECUTION_RULES {
 E1:
  IF query_mentions("computational model")
  OR executable_numerical_model_context
  THEN activate(ComputationalModelOntology)

 E2:
  IF continuous_model
  THEN identify discretisation before numerical execution

 E3:
  IF iterative_solver
  THEN define stopping_tolerance_and_convergence criterion

 E4:
  IF convergence_claim
  THEN require refinement_or_iteration evidence

 E5:
  IF simulation_requested
  THEN identify initial_state_inputs_parameters_and_time_or_iteration horizon

 E6:
  IF stochastic_or_Monte_Carlo model
  THEN record random_seed_distribution_and_sample count

 E7:
  IF verification_requested
  THEN compare against reference analytical_manufactured_or_benchmark cases

 E8:
  IF parallel_execution
  THEN account for numerical_reduction_order_and_scalability

 E9:
  IF result_reproduction_requested
  THEN preserve code_version_environment_inputs_parameters_and_solver settings
}

RECURSION {
 ENTRY = ComputationalModel

 EXPAND(ComputationalModel) -> [
  MathematicalModel,
  ExecutableModel,
  Algorithm,
  NumericalMethod,
  Discretisation,
  Mesh,
  Grid,
  TimeStep,
  StateVector,
  StateUpdate,
  Solver,
  IterativeSolver,
  DirectSolver,
  Convergence,
  Stability,
  Consistency,
  Accuracy,
  ErrorEstimate,
  Residual,
  Tolerance,
  Simulation,
  ComputationalExperiment,
  ParameterSweep,
  MonteCarloSimulation,
  ParallelComputation,
  ReducedOrderModel,
  SurrogateModel,
  Verification,
  Validation,
  Reproducibility,
  Provenance,
  SoftwareImplementation
 ]

 EXPAND(NumericalQuality) -> [
  Consistency,
  Stability,
  Convergence,
  Accuracy,
  TruncationError,
  RoundoffError,
  IterationError,
  Residual
 ]

 EXPAND(Simulation) -> [
  InitialState,
  InputData,
  ParameterSet,
  TimeStep,
  StateUpdate,
  OutputSampling,
  Checkpoint
 ]

 EXPAND(Reproducibility) -> [
  CodeVersion,
  DependencyVersion,
  HardwareContext,
  RandomSeed,
  InputDataset,
  SolverConfiguration,
  NumericalPrecision
 ]

 STOP_CONDITION =
  "Stop when the computational representation, discretisation, solver, execution pathway, error, convergence, verification, reproducibility and output semantics are sufficiently resolved."
}

ROUTING {
 PARENT_ONTOLOGY = "Mathematical Modelling"

 IMMEDIATE_CONTEXTS = [
  "Mathematical Model Ontology",
  "Mathematical Modelling Ontology",
  "Numerical Analysis Ontologies",
  "Scientific Computing Ontologies"
 ]

 RELATED_ONTOLOGIES = [
  "Mathematical Model Ontology",
  "Mathematical Modelling Ontology",
  "Applied Mathematics Ontologies",
  "Numerical Analysis Ontologies",
  "Scientific Computing Ontologies",
  "Differential Equations Ontologies",
  "Linear Algebra Ontologies",
  "Optimisation Ontologies",
  "Probability & Statistics Ontologies",
  "Computational Mathematics Ontologies",
  "Software Engineering Ontologies",
  "High Performance Computing Ontologies"
 ]

 ROUTE_RULES = [
  "Computational Model -> Mathematical Model Ontology for formal model semantics",
  "Computational Model -> Mathematical Modelling Ontology for modelling-process semantics",
  "Computational Model -> Numerical Analysis for convergence, stability and error",
  "Computational Model -> Scientific Computing for simulation execution",
  "Computational Model -> Differential Equations for discretised dynamic or field models",
  "Computational Model -> Linear Algebra for matrix-based discrete systems",
  "Computational Model -> Optimisation for iterative numerical solution",
  "Computational Model -> Probability & Statistics for Monte Carlo and stochastic simulation",
  "Computational Model -> Software Engineering for implementation provenance",
  "Computational Model -> High Performance Computing for parallel and distributed execution"
 ]
}

UPDATE_MODEL {
 MODE = "append-compatible semantic versioning"

 MAJOR = "ontology-breaking conceptual change"
 MINOR = "new compatible numerical schemes, solver classes or computational reasoning pathways"
 PATCH = "clarification, metadata or formatting correction"

 RULES = [
  "Preserve executable-model semantics.",
  "Preserve link to underlying mathematical model.",
  "Preserve discretisation semantics.",
  "Preserve convergence-stability-consistency distinctions.",
  "Preserve verification-validation distinction.",
  "Preserve numerical-error decomposition.",
  "Preserve reproducibility and provenance.",
  "Preserve machine-readable computational-model semantics."
 ]
}

OUTPUT {
 CANONICAL_DEFINITION =
  "A computational model is an executable mathematical representation used to simulate, approximate, analyse or optimise system behaviour."

 EXECUTION_SUMMARY =
  "Computational models map mathematical structure into algorithms and numerical procedures."

 DISCRETISATION_SUMMARY =
  "Discretisation converts continuous or large-scale models into finite computational representations."

 SOLVER_SUMMARY =
  "Solvers compute exact or approximate solutions of discrete model equations."

 NUMERICAL_QUALITY_SUMMARY =
  "Consistency, stability, convergence and accuracy describe different aspects of numerical reliability."

 SIMULATION_SUMMARY =
  "Simulation executes the computational model to generate states, trajectories, fields or predictions."

 VERIFICATION_SUMMARY =
  "Verification checks that the computational implementation solves the intended mathematical problem correctly."

 REPRODUCIBILITY_SUMMARY =
  "Reproducibility requires preservation of code, data, parameters, environment, solver settings and random-state information."

 ERROR_SUMMARY =
  "Computational error may include discretisation, truncation, iteration, sampling and floating-point contributions."
}

FLOW {
 INPUT
 -> detect_computational_model_context
 -> identify underlying_model_state_representation_discretisation_algorithm_solver_parameters_conditions_and_environment
 -> classify deterministic_stochastic_static_dynamic_serial_parallel_or_reduced computational structure
 -> select execution_or_analysis pathway
 -> simulate_or_solve
 -> compute residual_error_convergence_stability_and_constraint checks
 -> verify implementation
 -> preserve provenance_and_reproducibility metadata
 -> route to mathematical_model mathematical_modelling numerical_analysis scientific_computing differential_equations linear_algebra optimisation probability_statistics software_engineering_or_high_performance_computing ontology
 -> recursively_expand_required_dependencies
 -> verify_result
 -> assign_confidence
 -> produce_semantic_output
 -> END
}

SEMANTIC_SUMMARY {
 "The Computational Model Ontology defines executable mathematical models through algorithms, discretisation, numerical methods, state representations, solvers, simulation, convergence, stability, error estimation, verification, reproducibility, provenance and computational performance. It preserves the distinction between the underlying mathematical model, its numerical approximation and the software implementation used to execute it."
}

FLOW_HASH {
 METHOD = "semantic-content-identity"
 ID = "KIRETH-MATH-APPLIED-MATHEMATICS-COMPUTATIONAL-MODEL-ONTOLOGY-V1"
}

}

END_FLOW