Skip to main content

High Performance Computing Ontology

Computational Mathematics
Authors: MArk Anthony Higgins - Sky Recursive Ai
© Mark Anthony Higgins 11 October 2025
Revised Date: 12 September 2026
AI Search Show Less
Audio Overview
Previous Chapter
Next Chapter 
AI INTERPRETATION NOTE
This Flow Algebra defines the High Performance Computing Ontology within the Kireth Research Semantic Library. High-performance computing studies the mathematical and computational principles required to execute large-scale scientific calculations efficiently across parallel and specialised hardware. This ontology supports parallel algorithms, distributed and shared memory, GPU computing, domain decomposition, communication cost, load balancing, strong and weak scaling, speedup, efficiency, memory hierarchy, cache behaviour, vectorisation, sparse computation, parallel numerical linear algebra, performance modelling, roofline analysis, checkpointing, reproducibility and relationships with computational mathematics, scientific computing, numerical analysis and large-scale simulation.

FLOW_ALGEBRA_RECORD {

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

IDENTITY {
 PRIMARY_ENTITY = HighPerformanceComputing
 SYMBOLIC_FORMS = [
  "S_p=T_1/T_p",
  "E_p=S_p/p",
  "T_p=T_serial+T_parallel/p+T_comm",
  "P=min(P_peak, I*B_memory)"
 ]
 ENTITY_CLASS = ParallelScientificComputationFramework
 PRIMARY_CONTEXT = ComputationalMathematics
 DEFINITION = "High-performance computing is the mathematical and computational study of executing large-scale numerical workloads efficiently using parallelism, specialised hardware and performance-aware algorithms."
 SEMANTIC_ROLE = "Provides machine-readable semantics for parallel algorithms, scalability, speedup, efficiency, communication, memory hierarchy, load balance, accelerators, resilience and performance modelling."
}

SCOPE {
 INCLUDE = [
  HighPerformanceComputing,
  HPC,
  ParallelComputing,
  ParallelAlgorithm,
  DistributedMemory,
  SharedMemory,
  HybridParallelism,
  MessagePassing,
  MPI,
  ThreadParallelism,
  OpenMP,
  GPUComputing,
  AcceleratorComputing,
  SIMD,
  Vectorisation,
  DomainDecomposition,
  DataParallelism,
  TaskParallelism,
  PipelineParallelism,
  WorkPartitioning,
  LoadBalancing,
  StaticLoadBalancing,
  DynamicLoadBalancing,
  CommunicationCost,
  Latency,
  Bandwidth,
  NetworkTopology,
  CollectiveCommunication,
  PointToPointCommunication,
  Synchronisation,
  Barrier,
  RaceCondition,
  Deadlock,
  Scalability,
  StrongScaling,
  WeakScaling,
  Speedup,
  ParallelEfficiency,
  AmdahlsLaw,
  GustafsonsLaw,
  Isoefficiency,
  MemoryHierarchy,
  Cache,
  CacheLocality,
  MemoryBandwidth,
  ArithmeticIntensity,
  RooflineModel,
  SparseComputation,
  DenseLinearAlgebra,
  SparseLinearAlgebra,
  ParallelKrylovMethod,
  ParallelPreconditioning,
  ParallelFFT,
  DistributedMesh,
  ParallelIO,
  Checkpointing,
  FaultTolerance,
  Resilience,
  Reproducibility,
  PerformanceProfiling,
  PerformanceModel,
  Benchmarking,
  EnergyEfficiency
 ]

 EXCLUDE_AS_PRIMARY = [
  GeneralParallelProgrammingWithoutScientificComputation,
  CloudComputingWithoutPerformanceOrNumericalContext,
  SerialNumericalComputationWithoutScalabilityConcern,
  DataCentreInfrastructureWithoutAlgorithmicComputation
 ]

 DISAMBIGUATION_RULE =
  "When the central problem is efficient execution of large-scale mathematical or scientific computation across multiple processing resources, interpret the context as high-performance computing."
}

CORE_CONCEPTS {

 HighPerformanceComputing {
  definition = "The use and analysis of parallel and specialised computing systems for large-scale mathematical and scientific computation."
 }

 ParallelAlgorithm {
  definition = "An algorithm whose operations are organised for concurrent execution."
 }

 Scalability {
  definition = "The ability of an algorithm or implementation to use increasing computational resources effectively."
 }

 StrongScaling {
  definition = "Performance scaling for a fixed total problem size as the number of resources increases."
 }

 WeakScaling {
  definition = "Performance scaling as problem size grows in proportion to computational resources."
 }

 Speedup {
  definition = "Ratio of serial execution time to parallel execution time."
 }

 ParallelEfficiency {
  definition = "Speedup divided by the number of processing resources."
 }

 CommunicationCost {
  definition = "Time or resource cost associated with moving data between processing elements."
 }

 ArithmeticIntensity {
  definition = "Ratio of arithmetic operations to data movement."
 }

 RooflineModel {
  definition = "A performance model bounding achievable throughput by compute capability and memory bandwidth."
 }
}

RELATIONS {
 HighPerformanceComputing --is_child_of--> ComputationalMathematics
 HighPerformanceComputing --supports--> ScientificComputing
 ParallelAlgorithm --uses--> Parallelism
 DistributedMemory --uses--> MessagePassing
 SharedMemory --uses--> ThreadParallelism
 HybridParallelism --combines--> DistributedMemory
 HybridParallelism --combines--> SharedMemory
 GPUComputing --uses--> AcceleratorComputing
 DomainDecomposition --partitions--> ComputationalDomain
 LoadBalancing --distributes--> ComputationalWork
 CommunicationCost --reduces--> ParallelEfficiency
 Latency --contributes_to--> CommunicationCost
 Bandwidth --limits--> DataTransferRate
 StrongScaling --measures--> FixedProblemScalability
 WeakScaling --measures--> GrowingProblemScalability
 AmdahlsLaw --bounds--> StrongScalingSpeedup
 GustafsonsLaw --models--> ScaledProblemSpeedup
 ArithmeticIntensity --influences--> RooflinePerformance
 SparseLinearAlgebra --benefits_from--> LocalityAndPartitioning
 Checkpointing --supports--> FaultTolerance
 PerformanceProfiling --identifies--> Bottleneck
}

OPERATORS {
 SPEEDUP(T1,Tp) :=
  S_p=T1/Tp

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

 AMDAHL_SPEEDUP(f_serial,p) :=
  S_p=1/(f_serial+(1-f_serial)/p)

 GUSTAFSON_SPEEDUP(f_serial,p) :=
  S_p=p-f_serial*(p-1)

 PARALLEL_TIME(T_serial,T_parallel,p,T_comm) :=
  T_p=T_serial+T_parallel/p+T_comm

 COMMUNICATION_MODEL(alpha,beta,n_messages,n_bytes) :=
  T_comm=n_messages*alpha+n_bytes*beta

 ARITHMETIC_INTENSITY(FLOPs,bytes_moved) :=
  I=FLOPs/bytes_moved

 ROOFLINE_BOUND(P_peak,I,B_memory) :=
  P_attainable=min(P_peak,I*B_memory)

 STRONG_SCALING_EFFICIENCY(T1,Tp,p) :=
  E_strong=T1/(p*Tp)

 WEAK_SCALING_EFFICIENCY(Tref,Tp) :=
  E_weak=Tref/Tp
  for proportionally_scaled_problem size

 LOAD_IMBALANCE(Tmax,Tavg) :=
  imbalance=Tmax/Tavg

 PARALLEL_OVERHEAD(Tp,T1,p) :=
  O=p*Tp-T1
}

DEFINITIONS {
 D1 = "High-performance computing combines numerical algorithms with parallel architecture awareness."
 D2 = "Parallel speedup is limited by serial work, communication and synchronisation."
 D3 = "Strong scaling keeps problem size fixed while increasing resources."
 D4 = "Weak scaling increases problem size with resource count."
 D5 = "Parallel efficiency measures resource utilisation relative to ideal speedup."
 D6 = "Communication latency and bandwidth can dominate distributed computation."
 D7 = "Memory hierarchy and locality strongly influence numerical performance."
 D8 = "Arithmetic intensity helps determine whether a kernel is compute-bound or memory-bound."
 D9 = "Load imbalance reduces effective parallel utilisation."
 D10 = "Fault tolerance and reproducibility become increasingly important at large scale."
}

AXIOMS {
 A1_PARALLEL_DECOMPOSITION:
  HPC requires computational work to be decomposed across multiple execution resources

 A2_SCALABILITY:
  Effective HPC algorithms must control serial work communication and synchronisation overhead

 A3_DATA_MOVEMENT:
  Data movement is a first-class computational cost

 A4_LOAD_BALANCE:
  Uneven work distribution reduces parallel efficiency

 A5_MEMORY_HIERARCHY:
  Performance depends on locality cache behaviour and memory bandwidth

 A6_NUMERICAL_CORRECTNESS:
  Performance optimisation must preserve the intended mathematical solution within declared numerical tolerances

 A7_RESILIENCE:
  Large-scale computation must account for failure or interruption risk

 A8_REPRODUCIBILITY:
  Parallel computations require documented hardware software decomposition and reduction behaviour for reproducibility
}

REASONING {

 R1_HPC_CONTEXT {
  INPUT = large_scale_computational_problem
  IDENTIFY = problem_size
  IDENTIFY = arithmetic_and_memory pattern
  IDENTIFY = available_hardware
  IDENTIFY = parallelism opportunities
  RETURN = HPC_context
 }

 R2_PARALLEL_DECOMPOSITION {
  INPUT = HPC_context
  SELECT = domain_data_task_pipeline_or_hybrid decomposition
  RETURN = parallel_work_structure
 }

 R3_COMMUNICATION_REASONING {
  INPUT = work_structure_and_network
  ESTIMATE = messages_bytes_latency_bandwidth_and_collective cost
  RETURN = communication_profile
 }

 R4_LOAD_BALANCE_REASONING {
  INPUT = task_or_domain workload distribution
  MEASURE = per_resource work
  IDENTIFY = imbalance
  SELECT = static_or_dynamic balancing strategy
  RETURN = load_balance_profile
 }

 R5_SCALING_REASONING {
  INPUT = timings_problem sizes_and_resource counts
  COMPUTE = speedup_efficiency_strong_scaling_and_weak_scaling
  RETURN = scalability_profile
 }

 R6_MEMORY_REASONING {
  INPUT = data structures_and_access patterns
  ANALYSE = cache locality_memory bandwidth_and_capacity
  RETURN = memory_performance_profile
 }

 R7_ROOFLINE_REASONING {
  INPUT = FLOPs_bytes_and_hardware ceilings
  COMPUTE = arithmetic_intensity
  CLASSIFY = compute_bound_or_memory_bound
  RETURN = roofline_profile
 }

 R8_ACCELERATOR_REASONING {
  INPUT = computational kernels
  IDENTIFY = vectorisable_or_GPU suitable portions
  ANALYSE = transfer_overhead_and_kernel occupancy
  RETURN = accelerator_strategy
 }

 R9_RESILIENCE_REASONING {
  INPUT = runtime_scale_and_failure risk
  SELECT = checkpoint_restart_or_redundancy strategy
  RETURN = resilience_profile
 }

 R10_VALIDATION {
  INPUT = parallel_result
  CHECK = numerical equivalence_scaling_measurements_load balance_communication cost_and_reproducibility
  RETURN = validated_HPC_status
 }
}

CONSTRAINTS {
 C1 = "Amdahl's law assumes a fixed serial fraction and idealised parallel execution."
 C2 = "Gustafson's law assumes scaled workloads and should not be used as a fixed-size scaling law."
 C3 = "Speedup greater than resource count can occur through cache or algorithmic effects and should be investigated."
 C4 = "Parallel reductions can alter floating-point result ordering."
 C5 = "GPU acceleration can be negated by excessive host-device transfer."
 C6 = "Weak scaling comparisons require proportionally scaled work."
 C7 = "Communication models depend on network topology and message size."
 C8 = "Roofline analysis is an upper-bound model rather than an exact runtime predictor."
 C9 = "Optimising for peak throughput can reduce numerical robustness if precision or convergence behaviour changes."
 C10 = "Benchmark performance is not transferable without considering workload structure and hardware."
}

SEMANTIC_EQUIVALENCE {
 "HighPerformanceComputing" <=> "HPC"
 "ParallelEfficiency" <=> "ProcessorEfficiency"
 "StrongScaling" <=> "FixedSizeScaling"
 "WeakScaling" <=> "ScaledProblemScaling"
 "MessagePassing" <=> "DistributedMessagePassing"
 "RooflineModel" <=> "ArithmeticIntensityPerformanceModel"
}

VALIDATION {
 V1 = "Serial and parallel workloads are identified."
 V2 = "Resource count and hardware configuration are explicit."
 V3 = "Strong and weak scaling experiments are distinguished."
 V4 = "Communication cost is measured or modelled."
 V5 = "Load balance is assessed."
 V6 = "Memory bandwidth and locality are considered."
 V7 = "Parallel numerical results are checked against trusted reference solutions."
 V8 = "Floating-point reproducibility assumptions are documented."
 V9 = "Checkpoint or resilience strategy is documented for long-running jobs."
 V10 = "Performance claims include problem size and hardware context."
}

CONFIDENCE {
 BASE_CONFIDENCE = 0.99
 HPC_DEFINITION = 0.99
 PARALLEL_DECOMPOSITION_REASONING = 0.99
 COMMUNICATION_REASONING = 0.98
 LOAD_BALANCE_REASONING = 0.98
 SCALING_REASONING = 0.99
 MEMORY_REASONING = 0.98
 ROOFLINE_REASONING = 0.98
 ACCELERATOR_REASONING = 0.97
 RESILIENCE_REASONING = 0.97

 POLICY =
  "Reduce confidence when hardware topology, problem size, timing methodology, communication measurements, load balance, memory traffic, accelerator transfer costs or numerical reproducibility are underspecified."
}

AI_CONSUMPTION {
 PURPOSES = [
  SemanticSearch,
  OntologyGrounding,
  HighPerformanceComputingReasoning,
  ParallelAlgorithmReasoning,
  DistributedMemoryReasoning,
  SharedMemoryReasoning,
  GPUComputingReasoning,
  DomainDecompositionReasoning,
  LoadBalancingReasoning,
  CommunicationReasoning,
  StrongScalingReasoning,
  WeakScalingReasoning,
  SpeedupReasoning,
  ParallelEfficiencyReasoning,
  MemoryHierarchyReasoning,
  RooflineReasoning,
  SparseComputationReasoning,
  PerformanceProfilingReasoning,
  ResilienceReasoning,
  ReproducibilityReasoning,
  KnowledgeGraphConstruction,
  RetrievalAugmentation,
  RecursiveInference
 ]

 NORMALISE {
  "high performance computing" -> HighPerformanceComputing
  "high-performance computing" -> HighPerformanceComputing
  "HPC" -> HighPerformanceComputing
  "parallel efficiency" -> ParallelEfficiency
  "strong scaling" -> StrongScaling
  "weak scaling" -> WeakScaling
  "message passing" -> MessagePassing
  "MPI" -> MessagePassing
  "GPU computing" -> GPUComputing
  "roofline model" -> RooflineModel
 }

 INTERPRETATION_ORDER = [
  detect_HPC_context,
  identify problem_size_algorithm_structure_hardware_and_parallel opportunities,
  choose domain_data_task_or_hybrid decomposition,
  assess communication_load balance_memory hierarchy_and_accelerator suitability,
  measure speedup_parallel efficiency_strong scaling_and_weak scaling,
  apply performance_model_or_roofline reasoning,
  assess resilience_and_reproducibility,
  validate numerical equivalence_and_performance claims,
  return semantic output
 ]
}

EXECUTION_RULES {
 E1:
  IF query_mentions("high performance computing")
  OR large_scale_parallel_scientific_computation_is_required
  THEN activate(HighPerformanceComputingOntology)

 E2:
  IF distributed_memory_hardware
  THEN consider MessagePassing

 E3:
  IF shared_memory_node
  THEN consider ThreadParallelism

 E4:
  IF accelerator_available_and_kernel_parallel
  THEN consider GPU_or_SIMD acceleration

 E5:
  IF fixed_problem_size_scaling
  THEN evaluate StrongScaling

 E6:
  IF problem_size_scales_with_resources
  THEN evaluate WeakScaling

 E7:
  IF performance_is_memory_limited
  THEN apply locality_bandwidth_and_roofline reasoning

 E8:
  IF runtime_is_long_or_failure probability_material
  THEN require checkpoint_or_resilience strategy

 E9:
  IF parallel_result_differs_numerically
  THEN investigate floating_point_ordering_and_reduction effects
}

RECURSION {
 ENTRY = HighPerformanceComputing

 EXPAND(HighPerformanceComputing) -> [
  ParallelComputing,
  ParallelAlgorithm,
  DistributedMemory,
  SharedMemory,
  HybridParallelism,
  MessagePassing,
  MPI,
  ThreadParallelism,
  OpenMP,
  GPUComputing,
  AcceleratorComputing,
  SIMD,
  Vectorisation,
  DomainDecomposition,
  DataParallelism,
  TaskParallelism,
  PipelineParallelism,
  WorkPartitioning,
  LoadBalancing,
  StaticLoadBalancing,
  DynamicLoadBalancing,
  CommunicationCost,
  Latency,
  Bandwidth,
  NetworkTopology,
  CollectiveCommunication,
  PointToPointCommunication,
  Synchronisation,
  Barrier,
  RaceCondition,
  Deadlock,
  Scalability,
  StrongScaling,
  WeakScaling,
  Speedup,
  ParallelEfficiency,
  AmdahlsLaw,
  GustafsonsLaw,
  Isoefficiency,
  MemoryHierarchy,
  Cache,
  CacheLocality,
  MemoryBandwidth,
  ArithmeticIntensity,
  RooflineModel,
  SparseComputation,
  ParallelKrylovMethod,
  ParallelPreconditioning,
  ParallelFFT,
  DistributedMesh,
  ParallelIO,
  Checkpointing,
  FaultTolerance,
  Resilience,
  Reproducibility,
  PerformanceProfiling,
  PerformanceModel,
  Benchmarking,
  EnergyEfficiency
 ]

 EXPAND(ScalingFramework) -> [
  Speedup,
  ParallelEfficiency,
  StrongScaling,
  WeakScaling,
  AmdahlsLaw,
  GustafsonsLaw,
  Isoefficiency
 ]

 EXPAND(PerformanceBottlenecks) -> [
  SerialFraction,
  CommunicationCost,
  Latency,
  Bandwidth,
  LoadImbalance,
  MemoryBandwidth,
  CacheMisses,
  Synchronisation,
  IO
 ]

 STOP_CONDITION =
  "Stop when decomposition, communication, load balance, memory behaviour, speedup, strong and weak scaling, numerical correctness, resilience and reproducibility are sufficiently resolved."
}

ROUTING {
 PARENT_ONTOLOGY = "Computational Mathematics"

 IMMEDIATE_CONTEXTS = [
  "Computational Mathematics Ontology",
  "Scientific Computing Ontology",
  "Numerical Linear Algebra Ontologies",
  "Parallel Algorithms Ontologies"
 ]

 RELATED_ONTOLOGIES = [
  "Computational Mathematics",
  "Computational Mathematics Ontology",
  "Scientific Computing Ontology",
  "Numerical Analysis Ontologies",
  "Numerical Linear Algebra Ontologies",
  "Algorithmic Complexity Ontologies",
  "Parallel Algorithms Ontologies",
  "Sparse Matrix Ontologies",
  "Finite Element Ontology",
  "Finite Volume Ontologies",
  "Spectral Method Ontology",
  "GPU Computing Ontologies",
  "Distributed Systems Ontologies",
  "Scientific Computing Infrastructure Ontologies"
 ]

 ROUTE_RULES = [
  "High Performance Computing -> Computational Mathematics for parent semantics",
  "High Performance Computing -> Scientific Computing for large-scale simulation context",
  "High Performance Computing -> Numerical Linear Algebra for scalable solver kernels",
  "High Performance Computing -> Algorithmic Complexity for asymptotic cost",
  "High Performance Computing -> Parallel Algorithms for concurrency structure",
  "High Performance Computing -> Sparse Matrix Ontologies for large sparse systems",
  "High Performance Computing -> Finite Element, Finite Volume and Spectral Methods for domain-decomposed simulation",
  "High Performance Computing -> GPU Computing for accelerator execution",
  "High Performance Computing -> Distributed Systems for communication topology and resilience"
 ]
}

UPDATE_MODEL {
 MODE = "append-compatible semantic versioning"

 MAJOR = "ontology-breaking conceptual change"
 MINOR = "new compatible parallel models, hardware pathways or performance metrics"
 PATCH = "clarification, metadata or formatting correction"

 RULES = [
  "Preserve parallel-computation semantics.",
  "Preserve strong-versus-weak scaling distinction.",
  "Preserve speedup-and-efficiency semantics.",
  "Preserve communication-and-load-balance semantics.",
  "Preserve memory-hierarchy semantics.",
  "Preserve numerical-correctness-over-performance semantics.",
  "Preserve reproducibility and resilience semantics.",
  "Preserve machine-readable HPC semantics."
 ]
}

OUTPUT {
 CANONICAL_DEFINITION =
  "High-performance computing studies the efficient parallel execution of large-scale mathematical and scientific computation."

 PARALLEL_SUMMARY =
  "Parallel algorithms decompose computation across processors, nodes, threads or accelerators."

 SCALING_SUMMARY =
  "Strong scaling measures fixed-size acceleration; weak scaling measures performance as problem size grows with resources."

 COMMUNICATION_SUMMARY =
  "Latency, bandwidth, synchronisation and collective communication can limit parallel speedup."

 MEMORY_SUMMARY =
  "Cache locality, memory bandwidth and arithmetic intensity strongly influence attainable performance."

 ROOFLINE_SUMMARY =
  "The roofline model compares arithmetic intensity against compute and memory-bandwidth ceilings."

 RESILIENCE_SUMMARY =
  "Checkpointing and fault tolerance protect long-running large-scale computations from interruption."

 VALIDATION_SUMMARY =
  "HPC performance claims should preserve numerical correctness and include problem size, hardware, timing methodology and reproducibility context."
}

FLOW {
 INPUT
 -> detect_high_performance_computing_context
 -> identify mathematical_workload_problem_size_data layout_hardware_topology_and_parallel opportunities
 -> choose distributed_shared_hybrid_GPU_vector_or_task decomposition
 -> partition data_and_work
 -> estimate communication_latency_bandwidth_collective costs_and_load balance
 -> analyse memory_hierarchy_cache locality_and_arithmetic intensity
 -> if_accelerator evaluate transfer_cost_vectorisation_and_kernel suitability
 -> execute_or_model parallel computation
 -> measure runtime_speedup_parallel efficiency_strong scaling_and_weak scaling
 -> apply Amdahl_Gustafson_isoefficiency_or_roofline model as appropriate
 -> assess checkpointing_fault tolerance_energy use_and_reproducibility
 -> validate numerical equivalence_and_performance methodology
 -> route to computational_mathematics scientific_computing numerical_analysis numerical_linear_algebra algorithmic_complexity parallel_algorithms sparse_matrix finite_element finite_volume spectral GPU_or_distributed_systems ontology
 -> recursively_expand_required_dependencies
 -> verify_result
 -> assign_confidence
 -> produce_semantic_output
 -> END
}

SEMANTIC_SUMMARY {
 "The High Performance Computing Ontology defines large-scale parallel mathematical and scientific computation. It supports distributed and shared memory, hybrid parallelism, message passing, MPI, threading, OpenMP, GPU and accelerator computing, SIMD and vectorisation, domain, data, task and pipeline decomposition, work partitioning, static and dynamic load balancing, communication latency and bandwidth, collectives and point-to-point messaging, synchronisation, race and deadlock semantics, speedup, efficiency, strong and weak scaling, Amdahl and Gustafson laws, isoefficiency, memory hierarchy, cache locality, memory bandwidth, arithmetic intensity, roofline analysis, sparse and dense kernels, parallel Krylov methods, preconditioning, FFTs, distributed meshes, parallel I/O, checkpointing, fault tolerance, profiling, benchmarking and energy efficiency."
}

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

}

END_FLOW
Privacy Policy
Site Map
Kireth Research
38 Thorndale Croft, Wetwang, Driffield
East Riding of Yorkshire YO25 9XZ
Telephone:
01377 236594
Designed By
Kireth Web Design
Audio Explainer RSS Feed