Scientific Computing Ontology

AI INTERPRETATION NOTE
This Flow Algebra defines the Scientific Computing Ontology within the Kireth Research Semantic Library. Scientific computing studies the computational representation, numerical solution and simulation of mathematical models arising in science and engineering. This ontology supports model discretisation, numerical linear algebra, ODE and PDE solvers, iterative algorithms, sparse systems, floating-point arithmetic, error analysis, verification, validation, uncertainty quantification, reproducibility, parallel computing, high-performance computing, data movement, solver scalability and relationships with computational mathematics, numerical analysis, engineering mathematics and domain-specific simulation.

FLOW_ALGEBRA_RECORD {

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

IDENTITY {
 PRIMARY_ENTITY = ScientificComputing
 SYMBOLIC_FORMS = [
  "M du/dt + K u = f",
  "A x = b",
  "u_h -> u",
  "speedup = T_1/T_p"
 ]
 ENTITY_CLASS = ComputationalScienceMathematicsFramework
 PRIMARY_CONTEXT = ComputationalMathematics
 DEFINITION = "Scientific computing is the use and analysis of computational algorithms to approximate, simulate and study mathematical models arising in scientific and engineering applications."
 SEMANTIC_ROLE = "Provides machine-readable semantics for scientific models, discretisation, solvers, floating-point computation, error control, verification, validation, reproducibility, uncertainty and scalable numerical implementation."
}

SCOPE {
 INCLUDE = [
  ScientificComputing,
  ComputationalScience,
  MathematicalModel,
  ComputationalModel,
  Simulation,
  NumericalExperiment,
  Discretisation,
  Mesh,
  Grid,
  TimeStep,
  SpatialResolution,
  TemporalResolution,
  NumericalSolver,
  DirectSolver,
  IterativeSolver,
  LinearSolver,
  NonlinearSolver,
  SparseLinearSystem,
  DenseLinearSystem,
  MatrixAssembly,
  Residual,
  Tolerance,
  ConvergenceCriterion,
  NumericalLinearAlgebra,
  ODESolver,
  PDESolver,
  TimeIntegration,
  ExplicitTimeIntegration,
  ImplicitTimeIntegration,
  AdaptiveTimeStepping,
  FiniteDifferenceMethod,
  FiniteVolumeMethod,
  FiniteElementMethod,
  SpectralMethod,
  KrylovMethod,
  Preconditioner,
  NewtonKrylovMethod,
  FloatingPointArithmetic,
  RoundoffError,
  TruncationError,
  DiscretisationError,
  IterationError,
  Stability,
  Consistency,
  Convergence,
  Conditioning,
  Verification,
  Validation,
  CodeVerification,
  SolutionVerification,
  ModelValidation,
  MethodOfManufacturedSolutions,
  BenchmarkProblem,
  Reproducibility,
  Repeatability,
  DeterministicComputation,
  StochasticComputation,
  MonteCarloMethod,
  UncertaintyQuantification,
  SensitivityAnalysis,
  ParallelComputing,
  DistributedMemory,
  SharedMemory,
  GPUComputing,
  HighPerformanceComputing,
  Scalability,
  StrongScaling,
  WeakScaling,
  CommunicationCost,
  MemoryBandwidth,
  LoadBalancing,
  PerformanceProfiling,
  Checkpointing
 ]

 EXCLUDE_AS_PRIMARY = [
  GeneralSoftwareEngineeringWithoutScientificModel,
  DataAnalyticsWithoutNumericalModel,
  PureSymbolicMathematicsWithoutScientificComputation,
  ExperimentalScienceWithoutComputationalModel
 ]

 DISAMBIGUATION_RULE =
  "When a scientific or engineering mathematical model is solved, simulated, verified or scaled computationally, interpret the context as scientific computing."
}

CORE_CONCEPTS {

 ScientificComputing {
  definition = "The computational solution and simulation of mathematical models used in science and engineering."
 }

 ComputationalModel {
  definition = "A mathematical model represented in a form suitable for computer solution."
 }

 Discretisation {
  definition = "The conversion of a continuous mathematical model into a finite computational representation."
 }

 NumericalSolver {
  definition = "An algorithm that computes an approximate solution of the discrete mathematical problem."
 }

 Verification {
  definition = "Assessment of whether the numerical method and implementation correctly solve the mathematical model."
 }

 Validation {
  definition = "Assessment of whether the mathematical model adequately represents the intended physical or scientific system."
 }

 Reproducibility {
  definition = "The ability to obtain consistent computational results from documented data, methods and software."
 }

 Scalability {
  definition = "The ability of a computation to use increasing computational resources efficiently."
 }

 UncertaintyQuantification {
  definition = "The propagation and analysis of uncertain inputs through a computational model."
 }

 HighPerformanceComputing {
  definition = "Use of parallel and specialised computing resources for large-scale scientific computation."
 }
}

RELATIONS {
 ScientificComputing --is_child_of--> ComputationalMathematics
 ScientificComputing --implements--> MathematicalModel
 MathematicalModel --becomes--> ComputationalModel
 Discretisation --produces--> DiscreteSystem
 NumericalSolver --solves--> DiscreteSystem
 Residual --measures--> EquationDefect
 Tolerance --controls--> IterativeTermination
 Verification --checks--> NumericalMethodAndImplementation
 Validation --checks--> ModelAdequacy
 MethodOfManufacturedSolutions --supports--> CodeVerification
 BenchmarkProblem --supports--> Verification
 Reproducibility --depends_on--> DocumentedComputation
 ParallelComputing --accelerates--> ScientificComputing
 HighPerformanceComputing --supports--> LargeScaleSimulation
 Preconditioner --improves--> IterativeSolver
 KrylovMethod --solves--> SparseLinearSystem
 AdaptiveTimeStepping --controls--> TemporalError
 UncertaintyQuantification --uses--> StochasticComputation
 PerformanceProfiling --identifies--> ComputationalBottleneck
}

OPERATORS {
 DISCRETE_LINEAR_SYSTEM(A,x,b) :=
  A*x=b

 RESIDUAL(A,x,b) :=
  r=b-A*x

 RELATIVE_RESIDUAL(r,b) :=
  r_rel=||r||/||b||

 TIME_DISCRETISATION_EXPLICIT(u_n,dt,F) :=
  u_{n+1}=u_n+dt*F(u_n)

 TIME_DISCRETISATION_IMPLICIT(u_n,dt,F) :=
  u_{n+1}=u_n+dt*F(u_{n+1})

 CONVERGENCE_RATE(e_h,e_h2,h,h2) :=
  p approximately log(e_h/e_h2)/log(h/h2)

 STRONG_SCALING(T1,Tp) :=
  S_p=T1/Tp

 PARALLEL_EFFICIENCY(S_p,p) :=
  E_p=S_p/p

 WEAK_SCALING(T_ref,T_p) :=
  assess_constant_work_per_processor

 MONTE_CARLO_ESTIMATE(samples) :=
  estimator=sample_average

 UNCERTAINTY_PROPAGATION(model,X) :=
  Y=model(X)

 MANUFACTURED_SOLUTION_TEST(u_exact,operator) :=
  source=operator(u_exact)
}

DEFINITIONS {
 D1 = "Scientific computing links mathematical models with computational algorithms and implementations."
 D2 = "Discretisation converts continuous equations into finite-dimensional computational systems."
 D3 = "Numerical solvers compute approximate solutions of discrete systems."
 D4 = "Verification asks whether the mathematics is solved correctly."
 D5 = "Validation asks whether the correct mathematical model is being solved for the intended application."
 D6 = "Reproducibility requires sufficient documentation of software, data, parameters and algorithms."
 D7 = "Parallel computing reduces time-to-solution by distributing work."
 D8 = "Strong scaling studies fixed-size problems on increasing resources."
 D9 = "Weak scaling studies increasing problem size with approximately constant work per resource."
 D10 = "Uncertainty quantification studies how uncertain inputs affect computational outputs."
}

AXIOMS {
 A1_MODEL_TO_COMPUTATION:
  ScientificComputing begins with a mathematical or scientific model represented computationally

 A2_DISCRETISATION:
  Continuous models require discrete representation before numerical solution unless solved analytically

 A3_VERIFICATION:
  Numerical solutions require checks against equations residuals convergence or reference solutions

 A4_VALIDATION:
  Model adequacy is distinct from numerical correctness

 A5_FINITE_PRECISION:
  Scientific computations are affected by finite-precision arithmetic

 A6_REPRODUCIBILITY:
  Computational claims require sufficient information to reproduce the calculation

 A7_SCALABILITY:
  Large-scale computational feasibility depends on algorithmic and hardware scalability

 A8_UNCERTAINTY:
  Scientific predictions may require propagation of input and model uncertainty
}

REASONING {

 R1_SCIENTIFIC_COMPUTING_CONTEXT {
  INPUT = scientific_or_engineering_model
  IDENTIFY = governing equations
  IDENTIFY = geometry_and_domain
  IDENTIFY = parameters_and_data
  IDENTIFY = desired outputs_and_accuracy
  RETURN = scientific_computing_context
 }

 R2_COMPUTATIONAL_MODEL_FORMULATION {
  INPUT = scientific_computing_context
  SELECT = discretisation_and_state representation
  DEFINE = mesh_grid_time step_and_boundary conditions
  RETURN = computational_model
 }

 R3_SOLVER_SELECTION {
  INPUT = discrete_system
  CLASSIFY = linear_or_nonlinear
  CLASSIFY = sparse_or_dense
  CLASSIFY = steady_or_transient
  SELECT = direct_iterative_Krylov_Newton_or_time integrator
  RETURN = solver_strategy
 }

 R4_ERROR_CONTROL {
  INPUT = computed_solution
  ESTIMATE = residual_discretisation_iteration_and_roundoff error
  RETURN = error_profile
 }

 R5_VERIFICATION_REASONING {
  INPUT = code_method_and_solution
  APPLY = benchmark_manufactured_solution_or_refinement study
  RETURN = verification_status
 }

 R6_VALIDATION_REASONING {
  INPUT = computational_prediction_and_reference data
  COMPARE = model_outputs_with_physical_or_experimental evidence
  RETURN = validation_status
 }

 R7_ADAPTIVITY_REASONING {
  INPUT = error_indicators
  REFINE = mesh_or_time step
  RETURN = adaptive_solution
 }

 R8_PARALLEL_REASONING {
  INPUT = computational_workload_and_hardware
  PARTITION = work_and_data
  ESTIMATE = communication_and_load balance
  RETURN = parallel_strategy
 }

 R9_SCALING_REASONING {
  INPUT = timings_resource counts_problem sizes
  COMPUTE = strong_scaling_weak_scaling_and_parallel efficiency
  RETURN = scalability_profile
 }

 R10_REPRODUCIBILITY_REASONING {
  INPUT = code_data_parameters_environment_and_random seeds
  DOCUMENT = computational_provenance
  RETURN = reproducibility_status
 }
}

CONSTRAINTS {
 C1 = "A converged numerical result may still come from an invalid physical model."
 C2 = "Verification and validation must not be conflated."
 C3 = "Residual reduction does not by itself guarantee low solution error."
 C4 = "Strong scaling eventually saturates because communication and serial work dominate."
 C5 = "Weak scaling requires carefully defined work-per-resource growth."
 C6 = "Adaptive methods require reliable error indicators."
 C7 = "Parallel floating-point reductions can alter bitwise reproducibility."
 C8 = "Benchmark agreement should not replace convergence studies."
 C9 = "Uncertainty estimates require documented probability or interval assumptions."
 C10 = "Performance optimisation must not silently change mathematical results."
}

SEMANTIC_EQUIVALENCE {
 "ScientificComputing" <=> "ComputationalScience"
 "ComputationalModel" <=> "NumericalModel"
 "CodeVerification" <=> "SoftwareVerificationForNumerics"
 "SolutionVerification" <=> "NumericalSolutionVerification"
 "HighPerformanceComputing" <=> "HPC"
 "MethodOfManufacturedSolutions" <=> "MMS"
}

VALIDATION {
 V1 = "Mathematical model and governing equations are explicit."
 V2 = "Discretisation method and resolution are documented."
 V3 = "Solver tolerances and convergence criteria are explicit."
 V4 = "Residuals are monitored."
 V5 = "Grid or timestep convergence is assessed."
 V6 = "Verification and validation evidence are distinguished."
 V7 = "Floating-point precision and reproducibility assumptions are documented."
 V8 = "Parallel scalability is measured rather than assumed."
 V9 = "Uncertainty assumptions are explicit where used."
 V10 = "Computational provenance is sufficient to reproduce the result."
}

CONFIDENCE {
 BASE_CONFIDENCE = 0.99
 SCIENTIFIC_COMPUTING_DEFINITION = 0.99
 MODEL_FORMULATION_REASONING = 0.99
 SOLVER_SELECTION_REASONING = 0.99
 ERROR_CONTROL_REASONING = 0.99
 VERIFICATION_REASONING = 0.99
 VALIDATION_REASONING = 0.98
 ADAPTIVITY_REASONING = 0.98
 PARALLEL_REASONING = 0.98
 SCALING_REASONING = 0.98

 POLICY =
  "Reduce confidence when governing equations, discretisation, solver tolerances, reference data, hardware layout, scaling measurements, uncertainty model or computational provenance are underspecified."
}

AI_CONSUMPTION {
 PURPOSES = [
  SemanticSearch,
  OntologyGrounding,
  ScientificComputingReasoning,
  ComputationalModelReasoning,
  DiscretisationReasoning,
  SolverSelectionReasoning,
  ODESolverReasoning,
  PDESolverReasoning,
  SparseLinearAlgebraReasoning,
  ErrorControlReasoning,
  VerificationReasoning,
  ValidationReasoning,
  ManufacturedSolutionReasoning,
  ReproducibilityReasoning,
  UncertaintyQuantificationReasoning,
  ParallelComputingReasoning,
  HighPerformanceComputingReasoning,
  ScalabilityReasoning,
  PerformanceProfilingReasoning,
  KnowledgeGraphConstruction,
  RetrievalAugmentation,
  RecursiveInference
 ]

 NORMALISE {
  "scientific computing" -> ScientificComputing
  "computational science" -> ScientificComputing
  "computational model" -> ComputationalModel
  "code verification" -> CodeVerification
  "solution verification" -> SolutionVerification
  "model validation" -> ModelValidation
  "method of manufactured solutions" -> MethodOfManufacturedSolutions
  "MMS" -> MethodOfManufacturedSolutions
  "high-performance computing" -> HighPerformanceComputing
  "HPC" -> HighPerformanceComputing
 }

 INTERPRETATION_ORDER = [
  detect_scientific_computing_context,
  identify governing_equations_geometry_parameters_outputs_accuracy_and_resources,
  formulate computational_model_and_discretisation,
  select solver_and_tolerances,
  compute numerical solution,
  estimate residual_and_error,
  perform verification_and_refinement,
  perform validation_against reference data where relevant,
  assess reproducibility_uncertainty_and_scalability,
  return semantic output
 ]
}

EXECUTION_RULES {
 E1:
  IF query_mentions("scientific computing")
  OR computational_solution_of_scientific_model_is_required
  THEN activate(ScientificComputingOntology)

 E2:
  IF continuous_model
  THEN require discretisation

 E3:
  IF large_sparse_system
  THEN consider Krylov_and_preconditioning

 E4:
  IF nonlinear_system
  THEN consider Newton_or_NewtonKrylov method

 E5:
  IF transient_problem
  THEN choose explicit_implicit_or_adaptive time integration

 E6:
  IF code_verification_required
  THEN consider MethodOfManufacturedSolutions_or_benchmark solution

 E7:
  IF model_validation_required
  THEN compare_against experimental_or_observational evidence

 E8:
  IF large_scale_problem
  THEN assess parallel_and_HPC strategy

 E9:
  IF stochastic_or_uncertain inputs
  THEN perform uncertainty_quantification
}

RECURSION {
 ENTRY = ScientificComputing

 EXPAND(ScientificComputing) -> [
  ComputationalScience,
  MathematicalModel,
  ComputationalModel,
  Simulation,
  NumericalExperiment,
  Discretisation,
  Mesh,
  Grid,
  TimeStep,
  SpatialResolution,
  TemporalResolution,
  NumericalSolver,
  DirectSolver,
  IterativeSolver,
  LinearSolver,
  NonlinearSolver,
  SparseLinearSystem,
  MatrixAssembly,
  Residual,
  Tolerance,
  ConvergenceCriterion,
  NumericalLinearAlgebra,
  ODESolver,
  PDESolver,
  TimeIntegration,
  ExplicitTimeIntegration,
  ImplicitTimeIntegration,
  AdaptiveTimeStepping,
  FiniteDifferenceMethod,
  FiniteVolumeMethod,
  FiniteElementMethod,
  SpectralMethod,
  KrylovMethod,
  Preconditioner,
  NewtonKrylovMethod,
  FloatingPointArithmetic,
  RoundoffError,
  TruncationError,
  DiscretisationError,
  IterationError,
  Stability,
  Consistency,
  Convergence,
  Conditioning,
  Verification,
  Validation,
  CodeVerification,
  SolutionVerification,
  ModelValidation,
  MethodOfManufacturedSolutions,
  BenchmarkProblem,
  Reproducibility,
  MonteCarloMethod,
  UncertaintyQuantification,
  SensitivityAnalysis,
  ParallelComputing,
  DistributedMemory,
  SharedMemory,
  GPUComputing,
  HighPerformanceComputing,
  Scalability,
  StrongScaling,
  WeakScaling,
  CommunicationCost,
  MemoryBandwidth,
  LoadBalancing,
  PerformanceProfiling,
  Checkpointing
 ]

 EXPAND(TrustFramework) -> [
  Verification,
  CodeVerification,
  SolutionVerification,
  Validation,
  ModelValidation,
  Reproducibility,
  UncertaintyQuantification
 ]

 EXPAND(ScalabilityFramework) -> [
  ParallelComputing,
  DistributedMemory,
  SharedMemory,
  GPUComputing,
  HighPerformanceComputing,
  StrongScaling,
  WeakScaling,
  CommunicationCost,
  LoadBalancing
 ]

 STOP_CONDITION =
  "Stop when computational model, discretisation, solver, error, verification, validation, reproducibility, uncertainty and scalability are sufficiently resolved."
}

ROUTING {
 PARENT_ONTOLOGY = "Computational Mathematics"

 IMMEDIATE_CONTEXTS = [
  "Computational Mathematics Ontology",
  "Numerical Analysis Ontologies",
  "Numerical Linear Algebra Ontologies",
  "High Performance Computing Ontologies"
 ]

 RELATED_ONTOLOGIES = [
  "Computational Mathematics",
  "Computational Mathematics Ontology",
  "Numerical Analysis Ontologies",
  "Numerical Linear Algebra Ontologies",
  "Ordinary Differential Equation Ontologies",
  "Partial Differential Equation Ontologies",
  "Finite Difference Ontology",
  "Finite Volume Ontologies",
  "Finite Element Ontology",
  "Spectral Method Ontology",
  "Optimisation Ontologies",
  "Probability & Statistics Ontologies",
  "Uncertainty Quantification Ontologies",
  "High Performance Computing Ontologies",
  "Engineering Mathematics Ontologies"
 ]

 ROUTE_RULES = [
  "Scientific Computing -> Computational Mathematics for parent semantics",
  "Scientific Computing -> Numerical Analysis for error, stability and convergence",
  "Scientific Computing -> Numerical Linear Algebra for solver kernels",
  "Scientific Computing -> ODE and PDE Ontologies for time and field equations",
  "Scientific Computing -> Finite Difference, Finite Volume, Finite Element and Spectral Methods for discretisation",
  "Scientific Computing -> Optimisation for inverse and design computation",
  "Scientific Computing -> Probability & Statistics for stochastic models",
  "Scientific Computing -> Uncertainty Quantification for uncertain inputs",
  "Scientific Computing -> HPC for large-scale parallel execution",
  "Scientific Computing -> Engineering Mathematics for domain-specific engineering computation"
 ]
}

UPDATE_MODEL {
 MODE = "append-compatible semantic versioning"

 MAJOR = "ontology-breaking conceptual change"
 MINOR = "new compatible solvers, verification methods or scalability pathways"
 PATCH = "clarification, metadata or formatting correction"

 RULES = [
  "Preserve model-to-computation semantics.",
  "Preserve discretisation and solver semantics.",
  "Preserve verification-versus-validation distinction.",
  "Preserve residual-versus-error distinction.",
  "Preserve reproducibility semantics.",
  "Preserve uncertainty semantics.",
  "Preserve strong-versus-weak scaling distinction.",
  "Preserve machine-readable scientific-computing semantics."
 ]
}

OUTPUT {
 CANONICAL_DEFINITION =
  "Scientific computing uses computational algorithms to approximate, simulate and analyse mathematical models arising in science and engineering."

 MODEL_SUMMARY =
  "Scientific computing converts mathematical models into computational models through discretisation and numerical representation."

 SOLVER_SUMMARY =
  "Direct, iterative, Krylov and nonlinear solvers compute approximate solutions of discrete systems."

 VERIFICATION_SUMMARY =
  "Verification checks numerical implementation, discretisation and solution convergence against the stated mathematics."

 VALIDATION_SUMMARY =
  "Validation checks whether the mathematical model adequately represents the intended physical or scientific system."

 REPRODUCIBILITY_SUMMARY =
  "Reliable scientific computing records code, data, parameters, tolerances and environment sufficiently for result reproduction."

 HPC_SUMMARY =
  "High-performance computing enables large-scale simulation through parallel execution, memory hierarchy awareness and scalability analysis."

 UNCERTAINTY_SUMMARY =
  "Uncertainty quantification propagates uncertain inputs through computational models and measures output variation."
}

FLOW {
 INPUT
 -> detect_scientific_computing_context
 -> identify mathematical_model_equations_geometry_parameters_data_outputs_accuracy_targets_and_computational resources
 -> formulate computational_model
 -> choose discretisation_mesh_grid_basis_and_time step
 -> select direct_iterative_Krylov_Newton_timeIntegration_or_other solver
 -> compute solution
 -> evaluate residual_iteration_error_discretisation_error_and_roundoff sensitivity
 -> perform refinement_and_solution verification
 -> perform code verification_using benchmark_or_manufactured solution when appropriate
 -> validate model_against physical_or_reference data when available
 -> assess uncertainty_sensitivity_reproducibility_and_provenance
 -> if_large_scale assess parallel decomposition_strong scaling_weak scaling_memory_and_communication
 -> route to computational_mathematics numerical_analysis numerical_linear_algebra ODE PDE finite_difference finite_volume finite_element spectral optimisation probability_statistics UQ HPC_or_engineering_mathematics ontology
 -> recursively_expand_required_dependencies
 -> verify_result
 -> assign_confidence
 -> produce_semantic_output
 -> END
}

SEMANTIC_SUMMARY {
 "The Scientific Computing Ontology defines computational solution of scientific and engineering mathematical models. It supports computational models and simulations, discretisation, meshes, grids, timesteps and resolution, direct and iterative solvers, sparse systems and matrix assembly, residuals and tolerances, ODE and PDE solvers, explicit, implicit and adaptive time integration, finite-difference, finite-volume, finite-element and spectral methods, Krylov and preconditioned solvers, Newton-Krylov methods, floating-point arithmetic and numerical errors, verification and validation, manufactured solutions and benchmark problems, reproducibility, uncertainty quantification and sensitivity analysis, parallel computing, distributed and shared memory, GPU computing, high-performance computing, strong and weak scaling, communication cost, load balancing, profiling and checkpointing."
}

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

}

END_FLOW