Optimal Control Ontology

AI INTERPRETATION NOTE
This Flow Algebra defines the Optimal Control Ontology within the Kireth Research Semantic Library. Optimal control studies how to choose time-varying control inputs for dynamical systems so that a performance objective is minimised or maximised subject to system dynamics, boundary conditions and constraints. This ontology supports continuous- and discrete-time optimal control, cost functionals, terminal cost, running cost, Hamiltonians, costates, Pontryagin’s Maximum Principle, Hamilton-Jacobi-Bellman equations, dynamic programming, linear quadratic regulation, Riccati equations, constrained optimal control, direct transcription, shooting methods, model predictive control and relationships with control theory, dynamic optimisation, calculus of variations, nonlinear optimisation and numerical analysis.

FLOW_ALGEBRA_RECORD {

METADATA {
 FLOW_NAME = "Optimal Control Ontology"
 FLOW_TYPE = "Mathematical Ontology"
 DOMAIN = "Mathematics"
 SUBDOMAIN = "Applied Mathematics"
 SPECIALISATION = "Control Theory / Optimal Control"
 CANONICAL_PAGE = "https://kirethresearch.org/booksai-core/ontologies/mathematical-ontologies/applied-mathematics-ontologies/control-theory/optimal-control-ontology.html"
 LANGUAGE = "en-GB"
 VERSION = "1.0"
 STATUS = "active"
}

IDENTITY {
 PRIMARY_ENTITY = OptimalControl
 SYMBOLIC_FORMS = [
  "min_u J = Phi(x(T)) + integral_0^T L(x,u,t) dt",
  "x_dot=f(x,u,t)",
  "H(x,u,lambda,t)=L+lambda^T f"
 ]
 ENTITY_CLASS = DynamicalOptimisationControlFramework
 PRIMARY_CONTEXT = ControlTheory
 DEFINITION = "Optimal control is the optimisation of control trajectories for dynamical systems subject to system dynamics, constraints and a performance criterion."
 SEMANTIC_ROLE = "Provides the machine-readable framework for control trajectories, state trajectories, cost functionals, Hamiltonians, costates, Bellman equations, Riccati equations, constrained trajectory optimisation and numerical solution methods."
}

SCOPE {
 INCLUDE = [
  OptimalControl,
  OptimalControlProblem,
  StateVariable,
  ControlVariable,
  StateTrajectory,
  ControlTrajectory,
  DynamicConstraint,
  InitialCondition,
  TerminalCondition,
  BoundaryCondition,
  PathConstraint,
  StateConstraint,
  ControlConstraint,
  RunningCost,
  StageCost,
  TerminalCost,
  CostFunctional,
  PerformanceIndex,
  Hamiltonian,
  CostateVariable,
  AdjointVariable,
  PontryaginMaximumPrinciple,
  MinimumPrinciple,
  StationarityCondition,
  TransversalityCondition,
  HamiltonJacobiBellmanEquation,
  HJBEquation,
  DynamicProgramming,
  ValueFunction,
  FeedbackPolicy,
  OpenLoopOptimalControl,
  ClosedLoopOptimalControl,
  LinearQuadraticRegulator,
  LQR,
  RiccatiEquation,
  AlgebraicRiccatiEquation,
  DifferentialRiccatiEquation,
  LinearQuadraticGaussianControl,
  LQG,
  BangBangControl,
  SingularControl,
  ConstrainedOptimalControl,
  DirectTranscription,
  DirectCollocation,
  MultipleShooting,
  SingleShooting,
  PseudospectralMethod,
  ModelPredictiveControl,
  RecedingHorizonControl,
  StochasticOptimalControl,
  InfiniteHorizonControl,
  FiniteHorizonControl
 ]

 EXCLUDE_AS_PRIMARY = [
  StaticOptimisationWithoutSystemDynamics,
  FeedbackControlWithoutPerformanceOptimisation,
  PureDynamicSimulationWithoutControlObjective,
  GenericCalculusOfVariationsWithoutControlInputSemantics
 ]

 DISAMBIGUATION_RULE =
  "When a time-dependent control input must be chosen to optimise a performance index subject to dynamical equations, interpret the context as optimal control."
}

CORE_CONCEPTS {

 OptimalControl {
  definition = "Control design obtained by optimising a performance criterion over admissible state and control trajectories."
 }

 OptimalControlProblem {
  definition = "A dynamical optimisation problem defined by dynamics, admissible controls, constraints and a performance index."
 }

 CostFunctional {
  definition = "A scalar objective depending on the entire control-state trajectory."
 }

 RunningCost {
  definition = "The instantaneous contribution to the performance index during the trajectory."
 }

 TerminalCost {
  definition = "The objective contribution associated with the final state or terminal time."
 }

 Hamiltonian {
  definition = "A function combining running cost with system dynamics weighted by costate variables."
 }

 CostateVariable {
  definition = "An adjoint variable representing sensitivity of optimal future cost to the state."
 }

 PontryaginMaximumPrinciple {
  definition = "A set of necessary conditions for optimality involving state, costate, control and Hamiltonian equations."
 }

 ValueFunction {
  definition = "The minimum or maximum achievable future cost from a given state and time."
 }

 HamiltonJacobiBellmanEquation {
  definition = "A partial differential equation satisfied by the value function under dynamic programming."
 }

 LinearQuadraticRegulator {
  definition = "An optimal state-feedback problem for linear dynamics and quadratic costs."
 }
}

RELATIONS {
 OptimalControl --is_child_of--> ControlTheory
 OptimalControl --is_special_case_of--> DynamicOptimisation
 OptimalControlProblem --has--> StateVariable
 OptimalControlProblem --has--> ControlVariable
 OptimalControlProblem --has--> CostFunctional
 OptimalControlProblem --has--> DynamicConstraint
 CostFunctional --contains--> RunningCost
 CostFunctional --may_contain--> TerminalCost
 Hamiltonian --combines--> RunningCost
 Hamiltonian --combines--> CostateVariable
 PontryaginMaximumPrinciple --uses--> Hamiltonian
 CostateVariable --satisfies--> AdjointEquation
 ValueFunction --satisfies--> HamiltonJacobiBellmanEquation
 DynamicProgramming --computes--> ValueFunction
 LinearQuadraticRegulator --uses--> RiccatiEquation
 ModelPredictiveControl --repeatedly_solves--> FiniteHorizonOptimalControl
 DirectTranscription --converts--> OptimalControlProblem
 DirectTranscription --into--> NonlinearProgrammingProblem
}

OPERATORS {
 CONTINUOUS_DYNAMICS(x,u,t) :=
  x_dot=f(x,u,t)

 DISCRETE_DYNAMICS(x_k,u_k,k) :=
  x_{k+1}=F(x_k,u_k,k)

 COST_FUNCTIONAL_CONTINUOUS(x,u,T) :=
  Phi(x(T),T)+integral_0^T L(x(t),u(t),t) dt

 COST_FUNCTIONAL_DISCRETE(x,u,N) :=
  Phi(x_N)+sum_{k=0}^{N-1} l(x_k,u_k,k)

 HAMILTONIAN(L,lambda,f) :=
  H=L(x,u,t)+lambda^T*f(x,u,t)

 COSTATE_EQUATION(H,x) :=
  lambda_dot=-partial H/partial x

 STATIONARITY_CONDITION(H,u) :=
  partial H/partial u=0
  for unconstrained interior optimum

 TRANSVERSALITY(lambda_T,Phi,x_T) :=
  lambda(T)=partial Phi/partial x_T
  under compatible terminal conditions

 HJB(V,x,t) :=
  -partial V/partial t =
  min_u [L(x,u,t)+grad_x(V)^T*f(x,u,t)]

 LQR_CONTROL(K,x) :=
  u=-K*x

 CONTINUOUS_ARE(A,B,Q,R,P) :=
  A^T*P+P*A-P*B*R^-1*B^T*P+Q=0

 LQR_GAIN(R,B,P) :=
  K=R^-1*B^T*P

 MPC_STEP(current_state,horizon,model) :=
  solve finite_horizon optimal_control
  apply first control
  shift horizon
}

DEFINITIONS {
 D1 = "Optimal control optimises a trajectory-dependent performance criterion."
 D2 = "State dynamics constrain admissible trajectories."
 D3 = "Hamiltonians combine instantaneous cost with dynamical evolution."
 D4 = "Costates encode sensitivity of future optimal cost to the current state."
 D5 = "Pontryagin’s principle gives necessary optimality conditions."
 D6 = "Dynamic programming gives a value-function formulation."
 D7 = "The HJB equation characterises continuous-time optimal value functions."
 D8 = "LQR provides optimal linear state feedback for quadratic costs."
 D9 = "Direct methods discretise the trajectory and solve a finite-dimensional optimisation problem."
 D10 = "MPC repeatedly solves finite-horizon optimal control online."
}

AXIOMS {
 A1_DYNAMIC_CONSTRAINT:
  OptimalControlProblem includes explicit system dynamics

 A2_CONTROL_DECISION:
  ControlVariable is optimised over time or stages

 A3_OBJECTIVE:
  Optimality is defined through a declared cost or performance functional

 A4_FEASIBILITY:
  State and control trajectories must satisfy all path and boundary constraints

 A5_PMP:
  Under standard regularity conditions, local optima satisfy Pontryagin-type necessary conditions

 A6_HJB:
  The value function satisfies a Bellman optimality relation where sufficiently regular

 A7_LQR:
  Standard LQR assumes linear dynamics, quadratic cost and appropriate stabilisability conditions

 A8_CONSTRAINT_AWARENESS:
  Control and state constraints materially affect the optimal solution structure
}

REASONING {

 R1_OPTIMAL_CONTROL_EXTRACTION {
  INPUT = control_problem
  IDENTIFY = states
  IDENTIFY = controls
  IDENTIFY = dynamics
  IDENTIFY = initial_and_terminal conditions
  IDENTIFY = running_and_terminal costs
  IDENTIFY = path_constraints
  RETURN = structured_optimal_control_problem
 }

 R2_PROBLEM_CLASSIFICATION {
  INPUT = structured_problem
  CLASSIFY = continuous_or_discrete
  CLASSIFY = finite_or_infinite horizon
  CLASSIFY = deterministic_or_stochastic
  CLASSIFY = linear_quadratic_or_nonlinear
  RETURN = optimal_control_class
 }

 R3_PONTRYAGIN_REASONING {
  INPUT = continuous_optimal_control_problem
  FORM = Hamiltonian
  DERIVE = state_equations
  DERIVE = costate_equations
  DERIVE = stationarity_or_minimum condition
  APPLY = transversality conditions
  RETURN = necessary_conditions
 }

 R4_HJB_REASONING {
  INPUT = value_function formulation
  FORM = HJB equation
  APPLY = terminal_boundary condition
  SOLVE_OR_APPROXIMATE = value_function
  RETURN = optimal_feedback policy
 }

 R5_LQR_REASONING {
  INPUT = A_B_Q_R
  CHECK = stabilizability_and_weight properties
  SOLVE = Riccati equation
  COMPUTE = K
  RETURN = optimal_state_feedback
 }

 R6_DIRECT_TRANSCRIPTION {
  INPUT = continuous_optimal_control_problem
  SELECT = time_grid
  DISCRETISE = dynamics_and_cost
  CREATE = finite-dimensional decision variables
  RETURN = nonlinear_program
 }

 R7_SHOOTING_REASONING {
  INPUT = boundary_value optimality system
  GUESS = costates_or_unknown initial parameters
  INTEGRATE = state_and_costate equations
  ADJUST = guess_until terminal conditions satisfied
  RETURN = shooting_solution
 }

 R8_CONSTRAINED_CONTROL {
  INPUT = state_and_control constraints
  IDENTIFY = active path constraints
  APPLY = direct optimisation_or constrained necessary conditions
  RETURN = constrained_optimal trajectory
 }

 R9_MPC_REASONING {
  INPUT = current_state_model_constraints_horizon
  SOLVE = finite_horizon optimal control
  APPLY = first control move
  UPDATE = state_and_horizon
  RETURN = receding_horizon policy
 }

 R10_OPTIMAL_CONTROL_VALIDATION {
  INPUT = candidate trajectory
  CHECK = dynamics
  CHECK = boundary conditions
  CHECK = path_constraints
  CHECK = optimality conditions_or_numerical convergence
  RETURN = optimal_control_status
 }
}

CONSTRAINTS {
 C1 = "Initial conditions must be explicit."
 C2 = "Terminal conditions must match the chosen transversality conditions."
 C3 = "State and control path constraints must be enforced over the full trajectory."
 C4 = "PMP conditions are generally necessary, not automatically sufficient."
 C5 = "HJB methods suffer from dimensionality growth in large state spaces."
 C6 = "Direct transcription accuracy depends on grid and discretisation quality."
 C7 = "Shooting methods can be sensitive to initial guesses."
 C8 = "LQR weighting matrices must satisfy compatible definiteness conditions."
 C9 = "MPC stability and recursive feasibility require explicit design checks."
 C10 = "Numerical convergence does not automatically prove global optimality."
}

SEMANTIC_EQUIVALENCE {
 "OptimalControl" <=> "TrajectoryOptimisationControl"
 "OptimalControlProblem" <=> "DynamicControlOptimisationProblem"
 "PontryaginMaximumPrinciple" <=> "PontryaginMinimumPrinciple"
 "HamiltonJacobiBellmanEquation" <=> "HJBEquation"
 "LinearQuadraticRegulator" <=> "LQR"
 "RecedingHorizonControl" <=> "ModelPredictiveControl"
}

VALIDATION {
 V1 = "States and controls are identified."
 V2 = "Dynamics are explicit."
 V3 = "Initial and terminal conditions are specified."
 V4 = "Cost functional is explicit."
 V5 = "Path constraints are represented."
 V6 = "Selected optimality principle matches the problem class."
 V7 = "Numerical discretisation is documented."
 V8 = "LQR assumptions are checked where used."
 V9 = "MPC horizon and constraints are explicit."
 V10 = "Necessary, sufficient, local and global optimality statuses are distinguished."
}

CONFIDENCE {
 BASE_CONFIDENCE = 0.99
 OPTIMAL_CONTROL_DEFINITION = 0.99
 PROBLEM_CLASSIFICATION_REASONING = 0.99
 PMP_REASONING = 0.99
 HJB_REASONING = 0.98
 LQR_REASONING = 0.99
 DIRECT_TRANSCRIPTION_REASONING = 0.98
 SHOOTING_REASONING = 0.97
 MPC_REASONING = 0.98
 VALIDATION_REASONING = 0.99

 POLICY =
  "Reduce confidence when dynamics, boundary conditions, path constraints, cost functional, horizon, Riccati assumptions, discretisation, or global-optimality evidence are underspecified."
}

AI_CONSUMPTION {
 PURPOSES = [
  SemanticSearch,
  OntologyGrounding,
  OptimalControlReasoning,
  PontryaginReasoning,
  HamiltonianReasoning,
  CostateReasoning,
  HJBReasoning,
  DynamicProgrammingReasoning,
  LQRReasoning,
  RiccatiReasoning,
  ConstrainedOptimalControlReasoning,
  DirectTranscriptionReasoning,
  ShootingMethodReasoning,
  MPCReasoning,
  StochasticOptimalControlReasoning,
  KnowledgeGraphConstruction,
  RetrievalAugmentation,
  RecursiveInference
 ]

 NORMALISE {
  "optimal control" -> OptimalControl
  "optimal control problem" -> OptimalControlProblem
  "Pontryagin maximum principle" -> PontryaginMaximumPrinciple
  "Pontryagin minimum principle" -> PontryaginMaximumPrinciple
  "HJB equation" -> HamiltonJacobiBellmanEquation
  "linear quadratic regulator" -> LinearQuadraticRegulator
  "LQR" -> LinearQuadraticRegulator
  "Riccati equation" -> RiccatiEquation
  "model predictive control" -> ModelPredictiveControl
  "receding horizon control" -> ModelPredictiveControl
 }

 INTERPRETATION_ORDER = [
  detect_optimal_control_context,
  identify states_controls_dynamics_horizon_initial_terminal_conditions_costs_and_path constraints,
  classify continuous_discrete_finite_infinite_deterministic_stochastic_linearQuadratic_or_nonlinear problem,
  select PMP_HJB_dynamicProgramming_LQR_directTranscription_shooting_or_MPC pathway,
  compute_or_approximate control_and_state trajectory,
  verify dynamics_boundary conditions_and_constraints,
  assess necessary_sufficient_local_or_global optimality evidence,
  return semantic output
 ]
}

EXECUTION_RULES {
 E1:
  IF query_mentions("optimal control")
  OR time_varying_control_is_optimised_subject_to dynamics
  THEN activate(OptimalControlOntology)

 E2:
  IF continuous_time_with_smooth dynamics
  THEN consider PontryaginMaximumPrinciple

 E3:
  IF value_function_or_feedback_optimality requested
  THEN consider HJB_or_dynamic programming

 E4:
  IF linear_dynamics_and_quadratic cost
  THEN consider LQR

 E5:
  IF state_or_control_constraints are important
  THEN consider direct_transcription_or_MPC

 E6:
  IF boundary_value necessary conditions are manageable
  THEN consider shooting methods

 E7:
  IF finite_horizon_problem_is_resolved_repeatedly_online
  THEN classify ModelPredictiveControl

 E8:
  IF numerical_solution_only
  THEN report numerical_optimality status_without claiming globality unless supported

 E9:
  IF path_constraints_become_active
  THEN include active-arc or constrained optimisation reasoning
}

RECURSION {
 ENTRY = OptimalControl

 EXPAND(OptimalControl) -> [
  OptimalControlProblem,
  StateVariable,
  ControlVariable,
  StateTrajectory,
  ControlTrajectory,
  DynamicConstraint,
  InitialCondition,
  TerminalCondition,
  BoundaryCondition,
  PathConstraint,
  StateConstraint,
  ControlConstraint,
  RunningCost,
  StageCost,
  TerminalCost,
  CostFunctional,
  PerformanceIndex,
  Hamiltonian,
  CostateVariable,
  AdjointVariable,
  PontryaginMaximumPrinciple,
  MinimumPrinciple,
  StationarityCondition,
  TransversalityCondition,
  HamiltonJacobiBellmanEquation,
  HJBEquation,
  DynamicProgramming,
  ValueFunction,
  FeedbackPolicy,
  OpenLoopOptimalControl,
  ClosedLoopOptimalControl,
  LinearQuadraticRegulator,
  LQR,
  RiccatiEquation,
  AlgebraicRiccatiEquation,
  DifferentialRiccatiEquation,
  LinearQuadraticGaussianControl,
  LQG,
  BangBangControl,
  SingularControl,
  ConstrainedOptimalControl,
  DirectTranscription,
  DirectCollocation,
  MultipleShooting,
  SingleShooting,
  PseudospectralMethod,
  ModelPredictiveControl,
  RecedingHorizonControl,
  StochasticOptimalControl,
  InfiniteHorizonControl,
  FiniteHorizonControl
 ]

 EXPAND(PMPStructure) -> [
  Hamiltonian,
  StateEquation,
  CostateEquation,
  StationarityCondition,
  MinimumCondition,
  TransversalityCondition
 ]

 EXPAND(DynamicProgrammingStructure) -> [
  ValueFunction,
  BellmanPrinciple,
  HamiltonJacobiBellmanEquation,
  FeedbackPolicy
 ]

 EXPAND(NumericalMethods) -> [
  DirectTranscription,
  DirectCollocation,
  SingleShooting,
  MultipleShooting,
  PseudospectralMethod
 ]

 STOP_CONDITION =
  "Stop when the dynamics, objective, horizon, constraints, optimality principle, numerical method, state-control trajectory and optimality status are sufficiently resolved."
}

ROUTING {
 PARENT_ONTOLOGY = "Control Theory"

 IMMEDIATE_CONTEXTS = [
  "Control Theory Ontology",
  "State-Space Control Ontology",
  "Dynamic Optimisation Ontology",
  "Model Predictive Control Ontologies"
 ]

 RELATED_ONTOLOGIES = [
  "Control Theory Ontology",
  "Control Theory",
  "State-Space Control Ontology",
  "Feedback Control Ontology",
  "Dynamic Optimisation Ontology",
  "Nonlinear Optimisation Ontology",
  "Convex Optimisation Ontology",
  "Calculus of Variations Ontologies",
  "Differential Equations Ontologies",
  "Dynamic Programming Ontologies",
  "Model Predictive Control Ontologies",
  "Stochastic Control Ontologies",
  "Numerical Analysis Ontologies",
  "Scientific Computing Ontologies"
 ]

 ROUTE_RULES = [
  "Optimal Control -> Control Theory Ontology for core control semantics",
  "Optimal Control -> State-Space Control for state and matrix representations",
  "Optimal Control -> Dynamic Optimisation for trajectory optimisation semantics",
  "Optimal Control -> Nonlinear Optimisation for direct transcription",
  "Optimal Control -> Convex Optimisation where convex structure holds",
  "Optimal Control -> Calculus of Variations for variational optimality",
  "Optimal Control -> Differential Equations for state and costate dynamics",
  "Optimal Control -> Dynamic Programming for Bellman and HJB reasoning",
  "Optimal Control -> Model Predictive Control for receding-horizon implementation",
  "Optimal Control -> Numerical Analysis for transcription, shooting and collocation"
 ]
}

UPDATE_MODEL {
 MODE = "append-compatible semantic versioning"

 MAJOR = "ontology-breaking conceptual change"
 MINOR = "new compatible optimal-control methods, constraints or reasoning pathways"
 PATCH = "clarification, metadata or formatting correction"

 RULES = [
  "Preserve state-control-dynamics semantics.",
  "Preserve running-versus-terminal cost distinction.",
  "Preserve Hamiltonian and costate semantics.",
  "Preserve PMP and HJB distinction.",
  "Preserve open-loop versus feedback optimal control distinction.",
  "Preserve finite-versus-infinite horizon distinction.",
  "Preserve constrained numerical solution semantics.",
  "Preserve machine-readable optimal-control semantics."
 ]
}

OUTPUT {
 CANONICAL_DEFINITION =
  "Optimal control chooses state-dependent or time-dependent control trajectories that optimise a performance criterion subject to system dynamics and constraints."

 HAMILTONIAN_SUMMARY =
  "The Hamiltonian combines instantaneous cost with system dynamics weighted by costates."

 PMP_SUMMARY =
  "Pontryagin’s principle gives necessary optimality conditions through state, costate and control equations."

 HJB_SUMMARY =
  "The HJB equation characterises the optimal value function and feedback policy."

 LQR_SUMMARY =
  "LQR computes optimal linear state feedback for quadratic cost using a Riccati equation."

 CONSTRAINT_SUMMARY =
  "State, control and path constraints can fundamentally alter optimal trajectory structure."

 NUMERICAL_SUMMARY =
  "Direct transcription, collocation and shooting methods convert or solve optimal-control problems numerically."

 MPC_SUMMARY =
  "MPC repeatedly solves a constrained finite-horizon optimal-control problem in closed loop."

 STATUS_SUMMARY =
  "Optimal-control results should distinguish necessary conditions, numerical local optima, sufficient conditions and certified global optimality."
}

FLOW {
 INPUT
 -> detect_optimal_control_context
 -> identify state_variables_control_variables_dynamics_initial_state_terminal_conditions_horizon_running_cost_terminal_cost_and_path constraints
 -> classify continuous_discrete_finiteHorizon_infiniteHorizon_deterministic_stochastic_linearQuadratic_or_nonlinear problem
 -> choose Pontryagin_HJB_dynamicProgramming_LQR_directTranscription_collocation_shooting_pseudospectral_or_MPC method
 -> formulate Hamiltonian_value_function_Riccati_equation_or_transcribed nonlinear program
 -> compute_or_approximate control trajectory_and_state trajectory
 -> verify dynamics_initial_terminal_and_path constraints
 -> evaluate cost_functional_and_optimality conditions
 -> classify necessary_sufficient_local_global_or_numerical solution status
 -> route to control_theory_ontology state_space feedback_control dynamic_optimisation nonlinear_optimisation convex_optimisation calculus_of_variations differential_equations dynamic_programming MPC stochastic_control numerical_analysis_or_scientific_computing ontology
 -> recursively_expand_required_dependencies
 -> verify_result
 -> assign_confidence
 -> produce_semantic_output
 -> END
}

SEMANTIC_SUMMARY {
 "The Optimal Control Ontology defines optimisation of control trajectories for dynamical systems. It supports state and control variables, running and terminal costs, Hamiltonians, costates, Pontryagin’s Maximum Principle, transversality, value functions, Hamilton-Jacobi-Bellman equations, dynamic programming, open- and closed-loop optimal control, LQR and Riccati equations, LQG, bang-bang and singular control, state and control constraints, direct transcription, collocation, shooting, pseudospectral methods, stochastic optimal control and model predictive control."
}

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

}

END_FLOW