Numerical Workflow Ontology

AI INTERPRETATION NOTE
This Flow Algebra defines the Numerical Workflow Ontology within the Kireth Research Semantic Library. A numerical workflow is a structured computational process that connects numerical preprocessing, discretisation, solver execution, refinement, convergence assessment, error analysis, postprocessing and validation under explicit dependency, tolerance, precision, provenance and reproducibility semantics. This ontology supports numerical linear algebra, differential equation solving, optimisation, integration, differentiation, mesh generation, iterative methods, adaptive refinement, solver coupling, checkpoints, benchmark relationships, verification, validation and scientific workflow orchestration.

FLOW_ALGEBRA_RECORD {

METADATA {
 FLOW_NAME = "Numerical Workflow Ontology"
 FLOW_TYPE = "Mathematical Ontology"
 DOMAIN = "Mathematics"
 SUBDOMAIN = "Computational Mathematics"
 SPECIALISATION = "Computational Scientific Workflows / Numerical Workflow"
 CANONICAL_PAGE = "https://kirethframeworkold.co.uk/books/semantic-library/ai-core/ontologies/mathematical-ontologies/computational-mathematics-ontologies/computational-scientific-workflows/numerical-workflow-ontology.html"
 LANGUAGE = "en-GB"
 VERSION = "1.0"
 STATUS = "active"
}

IDENTITY {
 PRIMARY_ENTITY = NumericalWorkflow
 ENTITY_CLASS = NumericalComputationOrchestrationFramework
 PRIMARY_CONTEXT = ComputationalScientificWorkflow
 DEFINITION = "A numerical workflow is a structured scientific computation process that coordinates numerical problem setup, discretisation, solver execution, convergence control, error assessment and postprocessing."
 SYMBOLIC_FORMS = [
  "problem -> discretise -> solve -> estimate_error -> refine -> postprocess",
  "u_h = solve(A_h,b_h)",
  "while error > tolerance: refine_and_resolve",
  "result = execute(NW,inputs,method,solver,tolerances,precision)"
 ]
 SEMANTIC_ROLE = "Provides machine-readable semantics for numerical stages, solver dependencies, refinement loops, tolerances, precision, convergence, error analysis, verification and reproducibility."
}

SCOPE {
 INCLUDE = [
  NumericalWorkflow,
  ScientificWorkflow,
  ComputationalScientificWorkflow,
  ComputationalWorkflow,
  NumericalPipeline,
  SolverWorkflow,
  SimulationWorkflow,
  AnalysisWorkflow,
  Preprocessing,
  NumericalPreprocessing,
  ProblemDefinition,
  MathematicalModel,
  GoverningEquation,
  BoundaryCondition,
  InitialCondition,
  SourceTerm,
  Parameter,
  ParameterSet,
  Domain,
  ComputationalDomain,
  Geometry,
  Mesh,
  Grid,
  MeshGeneration,
  GridGeneration,
  MeshRefinement,
  GridRefinement,
  AdaptiveMeshRefinement,
  AMRrelationship,
  CoarseningRelationship,
  RemeshingRelationship,
  Discretisation,
  NumericalDiscretisation,
  SpatialDiscretisation,
  TemporalDiscretisation,
  FiniteDifferenceMethod,
  FiniteElementMethod,
  BoundaryElementMethod,
  SpectralMethod,
  FiniteVolumeRelationship,
  BasisFunctionRelationship,
  ShapeFunctionRelationship,
  QuadratureRuleRelationship,
  NumericalIntegration,
  NumericalDifferentiation,
  MatrixAssembly,
  VectorAssembly,
  SystemAssembly,
  SparseMatrix,
  DenseMatrix,
  ComputationalMatrix,
  VectorComputation,
  TensorComputation,
  LinearSystem,
  NonlinearSystem,
  AlgebraicSystem,
  ResidualEquation,
  Solver,
  NumericalSolver,
  LinearSolver,
  NonlinearSolver,
  DirectSolver,
  IterativeSolver,
  ODESolver,
  PDESolver,
  DifferentialEquationSolver,
  EigenvalueSolverRelationship,
  OptimisationSolver,
  RootFinderRelationship,
  TimeIntegrator,
  ExplicitIntegrator,
  ImplicitIntegrator,
  EulerMethod,
  RungeKutta,
  NewtonMethodRelationship,
  KrylovMethodRelationship,
  ConjugateGradientRelationship,
  GMRESRelationship,
  MultigridRelationship,
  Preconditioner,
  Preconditioning,
  InitialGuess,
  SolverConfiguration,
  SolverTolerance,
  AbsoluteTolerance,
  RelativeTolerance,
  ResidualTolerance,
  MaximumIterations,
  StoppingCriterion,
  ConvergenceCriterion,
  DivergenceCriterion,
  Iteration,
  IterationCount,
  Residual,
  ResidualNorm,
  RelativeResidual,
  Convergence,
  ConvergenceRate,
  Nonconvergence,
  Divergence,
  Stagnation,
  OscillationRelationship,
  AdaptiveStepSize,
  TimeStep,
  StepSize,
  CFLConditionRelationship,
  StabilityConditionRelationship,
  NumericalStability,
  Conditioning,
  ConditionNumber,
  Precision,
  FloatingPointPrecision,
  SinglePrecision,
  DoublePrecision,
  MixedPrecision,
  FloatingPointArithmetic,
  RoundOffError,
  TruncationError,
  DiscretisationError,
  IterationError,
  SolverError,
  ApproximationError,
  ErrorEstimate,
  APrioriErrorEstimate,
  APosterioriErrorEstimate,
  ErrorIndicator,
  ErrorNorm,
  AbsoluteError,
  RelativeError,
  ErrorBudget,
  RefinementCriterion,
  AdaptiveRefinement,
  GoalOrientedRefinementRelationship,
  ConvergenceStudy,
  GridConvergence,
  MeshConvergence,
  TimeStepConvergence,
  OrderOfAccuracy,
  ObservedOrderOfAccuracy,
  RichardsonExtrapolation,
  GridConvergenceIndex,
  GCI,
  NumericalVerification,
  Verification,
  ComputationalValidation,
  Validation,
  ErrorAnalysis,
  VerificationMetrics,
  ValidationMetrics,
  Benchmark,
  RegressionTesting,
  Reproducibility,
  ReferenceSolution,
  AnalyticalSolution,
  ManufacturedSolution,
  BenchmarkSolution,
  KnownAnswerTest,
  Postprocessing,
  NumericalPostprocessing,
  DerivedQuantity,
  QuantityOfInterest,
  QoIRelationship,
  FieldExtractionRelationship,
  IntegralQuantityRelationship,
  StatisticalSummary,
  Aggregation,
  Interpolation,
  Projection,
  DataReduction,
  Export,
  Reporting,
  VisualisationRelationship,
  ResultArtifact,
  IntermediateArtifact,
  Checkpoint,
  SolverCheckpoint,
  WorkflowCheckpoint,
  Restart,
  Resume,
  Recovery,
  Retry,
  FaultTolerance,
  Task,
  WorkflowTask,
  NumericalTask,
  SolverTask,
  AssemblyTask,
  RefinementTask,
  VerificationTask,
  PostprocessingTask,
  TaskDependency,
  DataDependency,
  ControlDependency,
  IterationLoop,
  RefinementLoop,
  SolverLoop,
  ParameterSweep,
  EnsembleRun,
  SensitivitySweep,
  ConvergenceSweep,
  BatchExecution,
  ParallelExecution,
  DistributedExecution,
  TaskParallelism,
  DataParallelism,
  DomainDecompositionRelationship,
  HighPerformanceComputing,
  ParallelComputing,
  DistributedComputing,
  GPUComputing,
  ClusterComputing,
  ResourceAllocation,
  CPU,
  GPU,
  Memory,
  Storage,
  Network,
  CommunicationCost,
  ComputationCost,
  Scalability,
  StrongScaling,
  WeakScaling,
  WorkflowScheduler,
  TaskScheduler,
  ResourceScheduler,
  Orchestration,
  WorkflowEngine,
  NumericalWorkflowEngineRelationship,
  WorkflowRun,
  RunIdentifier,
  ExecutionState,
  Pending,
  Running,
  Completed,
  Failed,
  Retried,
  Provenance,
  WorkflowProvenance,
  NumericalProvenance,
  DataProvenance,
  SolverProvenance,
  MeshProvenance,
  ModelProvenance,
  Lineage,
  AuditTrail,
  Traceability,
  EnvironmentCapture,
  WorkflowVersion,
  ModelVersion,
  MeshVersion,
  SolverVersion,
  MethodVersion,
  LibraryVersion,
  CompilerVersion,
  ImplementationVersion,
  RandomSeed,
  Configuration,
  PrecisionConfiguration,
  ToleranceConfiguration,
  ScientificSimulation,
  NumericalLinearAlgebra,
  ComputationalOptimisation,
  ComputationalStatistics,
  SymbolicComputation,
  AIComputationalMathematics,
  ComputationalDataStructures,
  GraphAlgorithms
 ]
 EXCLUDE_AS_PRIMARY = [
  PureSymbolicWorkflowWithoutNumericalApproximation,
  GeneralScientificWorkflowWithoutNumericalSolverSemantics,
  DataPipelineWithoutNumericalMethodExecution,
  SingleNumericalCalculationWithoutMultiStageWorkflowOrchestration
 ]
 DISAMBIGUATION_RULE = "When a scientific workflow coordinates discretisation, numerical solvers, convergence control, error assessment and refinement, interpret the context as a numerical workflow."
}

CORE_CONCEPTS {
 NumericalWorkflow = "Structured orchestration of numerical computation stages."
 Discretisation = "Conversion of a continuous mathematical problem into a finite computational representation."
 NumericalSolver = "Algorithm that computes an approximate solution to the discretised problem."
 SolverTolerance = "Declared numerical threshold controlling iterative or adaptive termination."
 ErrorEstimate = "Estimate of discrepancy between numerical solution and exact or limiting solution."
 AdaptiveRefinement = "Modification of discretisation based on error or solution indicators."
 ConvergenceStudy = "Systematic evaluation of numerical behaviour under refinement."
 NumericalProvenance = "Traceable record of methods, meshes, tolerances, precision and solver settings."
}

RELATIONS {
 NumericalWorkflow --is_child_of--> ComputationalScientificWorkflow
 NumericalWorkflow --contains--> NumericalTasks
 ProblemDefinition --precedes--> Discretisation
 Discretisation --produces--> AlgebraicSystem
 MatrixAssembly --builds--> LinearOrNonlinearSystem
 NumericalSolver --solves--> DiscretisedSystem
 SolverTolerance --controls--> SolverTermination
 ErrorEstimate --guides--> AdaptiveRefinement
 AdaptiveRefinement --changes--> MeshOrStepSize
 ConvergenceStudy --assesses--> NumericalAccuracy
 NumericalVerification --checks--> NumericalWorkflowCorrectness
 Postprocessing --derives--> QuantitiesOfInterest
 Provenance --records--> NumericalMethodAndExecutionHistory
}

OPERATORS {
 DISCRETISE(problem,method,resolution) := discrete_problem(problem,method,resolution)
 ASSEMBLE(discrete_problem) := algebraic_system(discrete_problem)
 SOLVE(system,solver,tolerances) := numerical_solution(system,solver,tolerances)
 RESIDUAL(system,u) := system(u)
 ESTIMATE_ERROR(u_h,reference_or_estimator) := numerical_error_estimate(u_h,reference_or_estimator)
 REFINE(mesh_or_step,indicator) := refined_discretisation(mesh_or_step,indicator)
 CONVERGED(metric,tolerance) := metric <= tolerance
 POSTPROCESS(u_h,qoi) := derive_quantity(u_h,qoi)
}

AXIOMS {
 A1 = "A numerical workflow transforms a mathematical problem through discretisation into numerical solution stages."
 A2 = "Solver convergence is distinct from discretisation convergence."
 A3 = "Numerical accuracy depends on discretisation, solver tolerance and floating-point behaviour."
 A4 = "Adaptive workflows require explicit refinement and termination criteria."
 A5 = "Postprocessing cannot recover information lost by inadequate discretisation."
 A6 = "Verification requires enough metadata to reproduce method, resolution, tolerance and precision."
 A7 = "Parallel execution can alter floating-point reduction order without changing intended mathematics."
 A8 = "Numerical-workflow results require explicit method, solver, tolerance, error, convergence, validation and provenance semantics."
}

REASONING {
 R1_CONTEXT = identify(mathematical_problem,domain,method,accuracy_goal,resources,reference_options_and_validation_needs)
 R2_SETUP = define_geometry_boundary_initial_conditions_parameters_and_quantities_of_interest)
 R3_DISCRETISE = choose_space_time_discretisation_mesh_basis_and_resolution)
 R4_ASSEMBLE = construct_matrices_vectors_operators_and_algebraic_systems)
 R5_SOLVER = choose_linear_nonlinear_ODE_PDE_optimisation_or_eigen_solver_and_tolerances)
 R6_EXECUTE = solve_and_monitor_residuals_iterations_stability_and_failure_state)
 R7_ERROR = estimate_discretisation_iteration_roundoff_and_total_numerical_error)
 R8_REFINE = if_error_above_target refine_mesh_step_or_solver_settings_and_repeat)
 R9_VERIFY = perform_convergence_reference_and_invariant_checks)
 R10_PROVENANCE = record_methods_meshes_tolerances_precision_versions_and_execution_history)
}

CONSTRAINTS {
 C1 = "A tightly converged iterative solver can still produce an inaccurate discretised solution."
 C2 = "Loose solver tolerances can contaminate mesh or time-step convergence studies."
 C3 = "Excessive refinement can expose round-off or conditioning limitations."
 C4 = "Adaptive refinement requires indicators that correlate with relevant solution error."
 C5 = "Different discretisations can converge to different discrete branches when the problem is nonlinear."
 C6 = "Solver failure can result from poor scaling, conditioning or initialisation rather than invalid equations."
 C7 = "Parallel reductions can create small non-bitwise differences."
 C8 = "Changing precision can alter convergence and stability behaviour."
 C9 = "A single resolution is insufficient evidence for numerical independence."
 C10 = "Successful workflow completion does not prove physical or model validity."
}

SEMANTIC_EQUIVALENCE {
 "GridConvergenceIndex" <=> "GCI"
 "QuantityOfInterest" <=> "QoI"
 "AdaptiveMeshRefinement" <=> "AMR"
 "OrdinaryDifferentialEquationSolver" <=> "ODESolver"
 "PartialDifferentialEquationSolver" <=> "PDESolver"
}

VALIDATION {
 V1 = "Mathematical problem, domain and conditions are documented."
 V2 = "Discretisation method and resolution are documented."
 V3 = "Solver type, tolerances and stopping criteria are documented."
 V4 = "Floating-point precision is documented."
 V5 = "Residual and convergence histories are retained where relevant."
 V6 = "Error estimation or refinement criteria are documented."
 V7 = "Convergence or resolution studies are performed where required."
 V8 = "Postprocessing definitions for quantities of interest are documented."
 V9 = "Workflow provenance links results to method, mesh, solver and configuration."
 V10 = "Results are reproducible under documented workflow, solver, method, precision and environment versions."
}

CONFIDENCE {
 BASE_CONFIDENCE = 0.99
 NUMERICAL_WORKFLOW_DEFINITION = 0.99
 DISCRETISATION_REASONING = 0.99
 SOLVER_REASONING = 0.99
 ERROR_ESTIMATION_REASONING = 0.98
 ADAPTIVE_REFINEMENT_REASONING = 0.98
 CONVERGENCE_REASONING = 0.99
 REPRODUCIBILITY_REASONING = 0.99
 POLICY = "Reduce confidence when discretisation, solver tolerances, refinement criteria, precision, conditioning, reference evidence or provenance are underspecified."
}

AI_CONSUMPTION {
 PURPOSES = [
  SemanticSearch,OntologyGrounding,NumericalWorkflowReasoning,
  DiscretisationReasoning,MeshReasoning,
  SolverSelectionReasoning,ResidualReasoning,
  ConvergenceReasoning,ErrorEstimationReasoning,
  AdaptiveRefinementReasoning,PrecisionReasoning,
  NumericalVerificationReasoning,PostprocessingReasoning,
  CheckpointingReasoning,ParallelNumericalWorkflowReasoning,
  ProvenanceReasoning,ReproducibilityReasoning,
  KnowledgeGraphConstruction,RetrievalAugmentation,RecursiveInference
 ]
 NORMALISE {
  "numerical workflow" -> NumericalWorkflow
  "AMR" -> AdaptiveMeshRefinement
  "GCI" -> GridConvergenceIndex
  "QoI" -> QuantityOfInterest
  "ODE solver" -> ODESolver
  "PDE solver" -> PDESolver
 }
}

EXECUTION_RULES {
 E1 = "If a workflow coordinates discretisation, numerical solving and convergence control, activate NumericalWorkflowOntology."
 E2 = "Define mathematical model, domain and boundary or initial conditions before discretisation."
 E3 = "Select discretisation and resolution according to the problem class and accuracy goal."
 E4 = "Select solver and tolerances separately from discretisation resolution."
 E5 = "Monitor residual, convergence and numerical stability during execution."
 E6 = "Use error estimates and refinement loops when target accuracy is not achieved."
 E7 = "Separate solver convergence from mesh or time-step convergence."
 E8 = "Apply verification and validation before accepting final results."
 E9 = "Record methods, solver settings, precision, meshes, versions and provenance for reproducibility."
}

RECURSION {
 ENTRY = NumericalWorkflow
 EXPAND(NumericalWorkflow) -> [
  ScientificWorkflow,ComputationalScientificWorkflow,NumericalPipeline,
  ProblemDefinition,MathematicalModel,GoverningEquation,
  BoundaryCondition,InitialCondition,ComputationalDomain,
  Mesh,Grid,MeshGeneration,GridGeneration,MeshRefinement,
  AdaptiveMeshRefinement,AMRrelationship,Discretisation,
  SpatialDiscretisation,TemporalDiscretisation,
  FiniteDifferenceMethod,FiniteElementMethod,BoundaryElementMethod,
  SpectralMethod,NumericalIntegration,NumericalDifferentiation,
  MatrixAssembly,VectorAssembly,AlgebraicSystem,
  SparseMatrix,DenseMatrix,NumericalSolver,LinearSolver,
  NonlinearSolver,IterativeSolver,ODESolver,PDESolver,
  DifferentialEquationSolver,OptimisationSolver,
  TimeIntegrator,EulerMethod,RungeKutta,Preconditioner,
  SolverTolerance,StoppingCriterion,Residual,ResidualNorm,
  Convergence,Nonconvergence,NumericalStability,Conditioning,
  FloatingPointPrecision,RoundOffError,DiscretisationError,
  IterationError,ErrorEstimate,APrioriErrorEstimate,
  APosterioriErrorEstimate,ErrorIndicator,AdaptiveRefinement,
  ConvergenceStudy,GridConvergence,MeshConvergence,
  TimeStepConvergence,ObservedOrderOfAccuracy,
  RichardsonExtrapolation,GridConvergenceIndex,GCI,
  NumericalVerification,ComputationalValidation,ErrorAnalysis,
  VerificationMetrics,Postprocessing,QuantityOfInterest,
  Checkpoint,Restart,FaultTolerance,ParameterSweep,
  ParallelExecution,DistributedExecution,HighPerformanceComputing,
  WorkflowScheduler,Provenance,NumericalProvenance,
  Reproducibility,WorkflowVersion,SolverVersion,MethodVersion
 ]
 EXPAND(NumericalWorkflowFamilies) -> [
  NumericalProblemSetupAndPreprocessing,
  DiscretisationMeshAndGridGeneration,
  AssemblyAndNumericalSolverExecution,
  ConvergenceToleranceAndStabilityControl,
  ErrorEstimationAndAdaptiveRefinement,
  VerificationValidationAndBenchmarking,
  ParallelDistributedAndCheckpointedExecution,
  PostprocessingProvenanceAndReproducibility
 ]
 STOP_CONDITION = "Stop when model, discretisation, solver, tolerance, error, refinement, verification and provenance are sufficiently resolved."
}

ROUTING {
 PARENT_ONTOLOGY = "Computational Scientific Workflows"
 RELATED_ONTOLOGIES = [
  "Computational Scientific Workflows",
  "Scientific Workflow Ontology",
  "Data Pipeline Ontology",
  "Verification & Validation",
  "Numerical Verification Ontology",
  "Error Analysis Ontology",
  "Reproducibility Ontology",
  "Benchmark Ontology",
  "Numerical Methods Ontology 2",
  "Numerical Linear Algebra Ontology 2",
  "Differential Equation Solvers",
  "Finite Difference Method Ontology",
  "Finite Element Method Ontology",
  "Boundary Element Method Ontology",
  "Spectral Method Ontology 2",
  "Computational Optimisation Ontology",
  "Computational Statistics Ontology",
  "Scientific Simulation Ontology",
  "High Performance Computing Ontology 2",
  "Parallel Computing Ontology",
  "Distributed Computing Ontology",
  "GPU Computing Ontology"
 ]
 ROUTE_RULES = [
  "Numerical Workflow -> Computational Scientific Workflows for parent orchestration semantics",
  "Numerical Workflow -> Scientific Workflow for task, dependency and scheduling semantics",
  "Numerical Workflow -> Data Pipeline for numerical input and output data preparation",
  "Numerical Workflow -> Verification & Validation, Numerical Verification and Error Analysis for correctness and convergence assessment",
  "Numerical Workflow -> Reproducibility and Benchmark for repeatable numerical evidence",
  "Numerical Workflow -> Numerical Methods and Numerical Linear Algebra for discretisation and algebraic solve semantics",
  "Numerical Workflow -> Differential Equation Solvers and finite/spectral methods for PDE and ODE workflow stages",
  "Numerical Workflow -> Computational Optimisation and Computational Statistics for optimisation and statistical numerical stages",
  "Numerical Workflow -> Scientific Simulation for simulation-centric execution",
  "Numerical Workflow -> HPC, Parallel, Distributed and GPU Computing for scalable numerical workflows"
 ]
}

UPDATE_MODEL {
 MODE = "append-compatible semantic versioning"
 MAJOR = "ontology-breaking conceptual change"
 MINOR = "new compatible numerical stages, solver classes or reasoning pathways"
 PATCH = "clarification, metadata or formatting correction"
 RULES = [
  "Preserve mathematical-model-versus-discretised-system distinction.",
  "Preserve solver-convergence-versus-discretisation-convergence distinction.",
  "Preserve residual-versus-solution-error distinction.",
  "Preserve mesh-refinement-versus-solver-tolerance refinement distinction.",
  "Preserve preprocessing-versus-solver-versus-postprocessing stages.",
  "Preserve numerical-verification-versus-model-validation distinction.",
  "Preserve workflow-success-versus-numerical-accuracy distinction.",
  "Preserve machine-readable numerical-workflow semantics."
 ]
}

OUTPUT {
 CANONICAL_DEFINITION = "A numerical workflow is a structured scientific workflow that coordinates discretisation, numerical solving, error assessment, refinement and postprocessing."
 SETUP_SUMMARY = "Problem definition, geometry, conditions, parameters and quantities of interest establish the numerical problem."
 DISCRETISATION_SUMMARY = "Meshes, grids, basis functions and time steps convert the mathematical model into a finite computational system."
 SOLVER_SUMMARY = "Linear, nonlinear, ODE, PDE and optimisation solvers execute under explicit residual, tolerance and stopping semantics."
 ERROR_SUMMARY = "Discretisation, iteration and floating-point errors must be distinguished and controlled."
 REFINEMENT_SUMMARY = "Adaptive or systematic refinement loops improve resolution until declared accuracy or convergence criteria are satisfied."
 VALIDATION_SUMMARY = "Numerical workflows should retain convergence histories, error evidence, solver settings, provenance and reproducible computational conditions."
}

FLOW {
 INPUT
 -> detect_numerical_workflow_context
 -> identify_mathematical_problem_domain_method_accuracy_goal_resources_reference_options_and_validation_needs
 -> define_geometry_boundary_initial_conditions_parameters_and_quantities_of_interest
 -> choose_space_time_discretisation_mesh_grid_basis_and_resolution
 -> assemble_matrices_vectors_operators_and_algebraic_systems
 -> choose_numerical_solver_preconditioner_tolerances_precision_and_stopping_criteria
 -> execute_solver_and_monitor_residual_iterations_stability_and_failure_state
 -> estimate_discretisation_iteration_roundoff_and_total_numerical_error
 -> if_error_above_target_refine_mesh_grid_time_step_or_solver_settings_and_repeat
 -> perform_convergence_reference_invariant_and_numerical_verification_checks
 -> postprocess_solution_and_compute_quantities_of_interest
 -> record_methods_meshes_tolerances_precision_versions_environment_and_provenance
 -> package_workflow_artifacts_for_reproducible_rerun
 -> route_to_related_ontologies
 -> recursively_expand_required_dependencies
 -> verify_result
 -> assign_confidence
 -> produce_semantic_output
 -> END
}

FLOW_HASH {
 METHOD = "semantic-content-identity"
 ID = "KIRETH-MATH-COMPUTATIONAL-SCIENTIFIC-WORKFLOWS-NUMERICAL-WORKFLOW-ONTOLOGY-V1"
}

}

END_FLOW