Dynamic Optimisation Ontology

AI INTERPRETATION NOTE
This Flow Algebra defines the Dynamic Optimisation Ontology within the Kireth Research Semantic Library. Dynamic optimisation studies optimisation problems in which decisions evolve over time, stages or states and influence future system behaviour. This ontology supports finite- and infinite-horizon optimisation, dynamic programming, optimal control, Bellman equations, state and control variables, transition dynamics, stage costs, terminal costs, value functions, policy functions, Hamiltonian methods, Pontryagin’s Maximum Principle, model predictive control, stochastic dynamic optimisation, continuous- and discrete-time systems, path constraints and relationships with optimisation, differential equations, control theory, operations research and numerical analysis.

FLOW_ALGEBRA_RECORD {

METADATA {
 FLOW_NAME = "Dynamic Optimisation Ontology"
 FLOW_TYPE = "Mathematical Ontology"
 DOMAIN = "Mathematics"
 SUBDOMAIN = "Applied Mathematics"
 SPECIALISATION = "Optimisation / Dynamic Optimisation"
 CANONICAL_PAGE = "https://kirethresearch.org/booksai-core/ontologies/mathematical-ontologies/applied-mathematics-ontologies/optimisation/dynamic-optimisation-ontology.html"
 LANGUAGE = "en-GB"
 VERSION = "1.0"
 STATUS = "active"
}

IDENTITY {
 PRIMARY_ENTITY = DynamicOptimisation
 SYMBOLIC_FORMS = [
  "min_{u(t)} integral_0^T L(x,u,t) dt + Phi(x(T))",
  "x_dot=f(x,u,t)",
  "V_t(x)=min_u {c(x,u)+V_{t+1}(f(x,u))}"
 ]
 ENTITY_CLASS = TimeDependentOptimisationFramework
 PRIMARY_CONTEXT = Optimisation
 DEFINITION = "Dynamic optimisation is optimisation over sequences, trajectories or policies whose decisions affect future states through time-dependent system dynamics."
 SEMANTIC_ROLE = "Provides the machine-readable framework for state evolution, control trajectories, Bellman recursion, value functions, optimal policies, Hamiltonians, costates, horizon structure, terminal conditions, path constraints and dynamic optimality."
}

SCOPE {
 INCLUDE = [
  DynamicOptimisation,
  DynamicOptimisationProblem,
  StateVariable,
  ControlVariable,
  DecisionTrajectory,
  StateTrajectory,
  TransitionFunction,
  DynamicConstraint,
  StageCost,
  RunningCost,
  TerminalCost,
  ObjectiveFunctional,
  TimeHorizon,
  FiniteHorizon,
  InfiniteHorizon,
  DiscountFactor,
  ValueFunction,
  Policy,
  PolicyFunction,
  BellmanEquation,
  BellmanOptimalityPrinciple,
  DynamicProgramming,
  BackwardInduction,
  HamiltonJacobiBellmanEquation,
  OptimalControl,
  Hamiltonian,
  CostateVariable,
  PontryaginMaximumPrinciple,
  EulerLagrangeEquation,
  TransversalityCondition,
  PathConstraint,
  BoundaryCondition,
  TerminalConstraint,
  DiscreteTimeSystem,
  ContinuousTimeSystem,
  DeterministicDynamicOptimisation,
  StochasticDynamicOptimisation,
  ModelPredictiveControl,
  RecedingHorizonControl,
  DirectTranscription,
  ShootingMethod,
  CollocationMethod
 ]

 EXCLUDE_AS_PRIMARY = [
  StaticOptimisationWithoutStateEvolution,
  TimeSeriesPredictionWithoutDecisionOptimisation,
  PureSimulationWithoutObjectiveFunction,
  OrdinaryDifferentialEquationSolvingWithoutOptimisationGoal
 ]

 DISAMBIGUATION_RULE =
  "When decisions influence future states and the optimisation objective accumulates across time, stages or trajectories, interpret the context as dynamic optimisation."
}

CORE_CONCEPTS {

 DynamicOptimisation {
  definition = "Optimisation over time-dependent decisions and evolving system states."
 }

 StateVariable {
  definition = "A variable summarising the information needed to describe the system at a given time for future evolution."
 }

 ControlVariable {
  definition = "A decision variable chosen over time to influence the state trajectory."
 }

 TransitionFunction {
  definition = "A rule mapping the current state and control to the next state or state derivative."
 }

 StageCost {
  definition = "The objective contribution associated with one discrete decision stage."
 }

 RunningCost {
  definition = "The instantaneous objective contribution in continuous time."
 }

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

 ValueFunction {
  definition = "The optimal achievable future objective value from a given state and time."
 }

 Policy {
  definition = "A rule mapping available state or information to a control decision."
 }

 BellmanEquation {
  definition = "A recursive optimality equation expressing the value function through immediate cost and optimised future value."
 }

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

 CostateVariable {
  definition = "An adjoint variable encoding marginal value of the system state."
 }
}

RELATIONS {
 DynamicOptimisation --is_special_case_of--> Optimisation
 DynamicOptimisationProblem --has--> StateVariable
 DynamicOptimisationProblem --has--> ControlVariable
 DynamicOptimisationProblem --has--> TransitionFunction
 DynamicOptimisationProblem --has--> ObjectiveFunctional
 TransitionFunction --determines--> StateTrajectory
 ControlVariable --influences--> StateTrajectory
 StageCost --contributes_to--> ObjectiveFunctional
 TerminalCost --contributes_to--> ObjectiveFunctional
 ValueFunction --satisfies--> BellmanEquation
 Policy --induces--> ControlTrajectory
 BellmanOptimalityPrinciple --supports--> DynamicProgramming
 DynamicProgramming --computes--> ValueFunction
 HamiltonJacobiBellmanEquation --is_continuous_time_form_of--> BellmanOptimalityPrinciple
 Hamiltonian --uses--> CostateVariable
 PontryaginMaximumPrinciple --characterises--> NecessaryOptimalityConditions
 ModelPredictiveControl --repeatedly_solves--> FiniteHorizonDynamicOptimisation
 DirectTranscription --converts--> DynamicOptimisationProblem
 DirectTranscription --into--> NonlinearProgrammingProblem
}

OPERATORS {
 DISCRETE_DYNAMICS(x_t,u_t) :=
  x_{t+1}=F(x_t,u_t,t)

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

 FINITE_HORIZON_OBJECTIVE(x,u) :=
  sum_{t=0}^{T-1} c_t(x_t,u_t)+Phi(x_T)

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

 BELLMAN_RECURSION(V_next,x,t) :=
  min_u [c_t(x,u)+V_next(F(x,u,t))]

 DISCOUNTED_BELLMAN(V,x) :=
  min_u [c(x,u)+gamma*V(F(x,u))]

 HAMILTONIAN(L,lambda,f) :=
  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 control

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

 DIRECT_TRANSCRIPTION(dynamics,grid) :=
  finite_dimensional_nonlinear_program

 MPC_STEP(model,current_state,horizon) :=
  solve finite_horizon problem
  apply first control
  advance state
}

DEFINITIONS {
 D1 = "Dynamic optimisation includes state evolution explicitly."
 D2 = "Controls affect future states and therefore future feasible decisions."
 D3 = "The Bellman principle expresses optimal substructure."
 D4 = "The value function summarises optimal future cost from a state."
 D5 = "Finite-horizon problems include terminal conditions."
 D6 = "Infinite-horizon problems may require discounting or stability assumptions."
 D7 = "Pontryagin's Maximum Principle provides necessary conditions for many continuous-time problems."
 D8 = "The Hamilton-Jacobi-Bellman equation provides a value-function characterisation."
 D9 = "Direct methods discretise trajectories and solve a finite-dimensional optimisation problem."
 D10 = "Model predictive control repeatedly reoptimises over a moving finite horizon."
}

AXIOMS {
 A1_STATE_EVOLUTION:
  DynamicOptimisationProblem contains explicit temporal or stage-wise system evolution

 A2_SEQUENTIAL_DECISION:
  Controls influence current and future system behaviour

 A3_OBJECTIVE_ACCUMULATION:
  Dynamic objectives aggregate stage, running and terminal contributions

 A4_BELLMAN_PRINCIPLE:
  An optimal policy has optimal continuation from every reachable optimal state under standard Markovian assumptions

 A5_FEASIBILITY:
  State and control trajectories must satisfy dynamic and path constraints

 A6_BOUNDARY_STRUCTURE:
  Dynamic problems require initial conditions and may require terminal or transversality conditions

 A7_POLICY_DEPENDENCE:
  A policy maps available information to control actions

 A8_DISCRETISATION_EQUIVALENCE:
  Direct transcription approximates the dynamic problem by a finite-dimensional optimisation problem
}

REASONING {

 R1_DYNAMIC_PROBLEM_IDENTIFICATION {
  INPUT = optimisation_problem
  IDENTIFY = time_or_stage index
  IDENTIFY = states_controls_and_dynamics
  IDENTIFY = horizon
  IDENTIFY = running_stage_and_terminal costs
  RETURN = dynamic_optimisation_problem
 }

 R2_HORIZON_CLASSIFICATION {
  INPUT = time_structure
  IF terminal_time_finite
   CLASSIFY = FiniteHorizon
  ELSE
   CLASSIFY = InfiniteHorizon
  RETURN = horizon_type
 }

 R3_DYNAMIC_PROGRAMMING {
  INPUT = discrete_state_control_problem
  INITIALISE = terminal_value
  FOR t from T-1 down_to 0
   COMPUTE = Bellman_recursion
   STORE = optimal_policy
  RETURN = value_function_and_policy
 }

 R4_CONTINUOUS_TIME_OPTIMALITY {
  INPUT = continuous_dynamic_problem
  FORM = Hamiltonian
  DERIVE = state_equations
  DERIVE = costate_equations
  DERIVE = stationarity_or_maximisation condition
  APPLY = boundary_and_transversality conditions
  RETURN = necessary_conditions
 }

 R5_HJB_REASONING {
  INPUT = value_function_problem
  FORM = Hamilton_Jacobi_Bellman equation
  APPLY = terminal_boundary condition
  SOLVE_OR_APPROXIMATE = PDE
  RETURN = value_function_and_feedback policy
 }

 R6_DIRECT_TRANSCRIPTION {
  INPUT = continuous_dynamic_problem
  SELECT = time grid_and_discretisation
  CREATE = state_control decision variables
  ADD = dynamic_defect constraints
  RETURN = nonlinear_program
 }

 R7_SHOOTING_METHOD {
  INPUT = boundary_value_optimality system
  GUESS = costate_or_control parameters
  INTEGRATE = state_costate equations
  ADJUST = guess_to_satisfy terminal conditions
  RETURN = trajectory_solution
 }

 R8_PATH_CONSTRAINT_REASONING {
  INPUT = state_control_path constraints
  CHECK = feasibility_along_trajectory
  IDENTIFY = active arcs
  RETURN = constrained_dynamic_solution structure
 }

 R9_STOCHASTIC_DYNAMIC_OPTIMISATION {
  INPUT = stochastic_transition_model
  COMPUTE = expected_or_risk_sensitive Bellman recursion
  RETURN = stochastic_policy_and_value
 }

 R10_MODEL_PREDICTIVE_CONTROL {
  INPUT = current_state_model_horizon_constraints
  SOLVE = finite_horizon optimisation
  APPLY = first_control
  UPDATE = state
  REPEAT = at_next decision_time
  RETURN = receding_horizon policy
 }
}

CONSTRAINTS {
 C1 = "Initial state must be specified or treated as a decision variable with constraints."
 C2 = "Dynamics must be enforced throughout the horizon."
 C3 = "Control and state bounds must be respected."
 C4 = "Terminal conditions and transversality conditions must not be omitted when required."
 C5 = "Bellman recursion requires an appropriate state representation."
 C6 = "Infinite-horizon problems require conditions ensuring finite value or meaningful stability."
 C7 = "Direct transcription accuracy depends on discretisation quality."
 C8 = "Shooting methods can be highly sensitive to initial costate guesses."
 C9 = "State constraints may create switching or active-set structure."
 C10 = "MPC stability and recursive feasibility are not automatic."
}

SEMANTIC_EQUIVALENCE {
 "DynamicOptimisation" <=> "TimeDependentOptimisation"
 "DynamicOptimization" <=> "DynamicOptimisation"
 "OptimalControl" <=> "ContinuousTimeDynamicOptimisation"
 "BellmanEquation" <=> "DynamicProgrammingOptimalityRecursion"
 "ValueFunction" <=> "OptimalCostToGoFunction"
 "Policy" <=> "StateFeedbackDecisionRule"
}

VALIDATION {
 V1 = "State variables are identified."
 V2 = "Control variables are identified."
 V3 = "Dynamics are specified."
 V4 = "Initial and terminal conditions are explicit."
 V5 = "Horizon is identified."
 V6 = "Running, stage and terminal costs are correctly represented."
 V7 = "Path constraints are enforced."
 V8 = "Bellman or Pontryagin conditions match the problem class."
 V9 = "Discretisation is adequate for direct methods."
 V10 = "Policy or trajectory status is distinguished from global optimality certification."
}

CONFIDENCE {
 BASE_CONFIDENCE = 0.99
 DYNAMIC_OPTIMISATION_DEFINITION = 0.99
 DYNAMIC_PROGRAMMING_REASONING = 0.99
 PONTRYAGIN_REASONING = 0.98
 HJB_REASONING = 0.97
 DIRECT_TRANSCRIPTION_REASONING = 0.98
 SHOOTING_REASONING = 0.96
 STOCHASTIC_DYNAMIC_REASONING = 0.97
 MPC_REASONING = 0.98

 POLICY =
  "Reduce confidence when state definition, dynamic equations, horizon, terminal conditions, path constraints, discretisation, stochastic transition model or global-optimality evidence are underspecified."
}

AI_CONSUMPTION {
 PURPOSES = [
  SemanticSearch,
  OntologyGrounding,
  DynamicOptimisationReasoning,
  DynamicProgrammingReasoning,
  BellmanEquationReasoning,
  ValueFunctionReasoning,
  PolicyReasoning,
  OptimalControlReasoning,
  PontryaginReasoning,
  HamiltonianReasoning,
  HJBReasoning,
  DirectTranscriptionReasoning,
  ShootingMethodReasoning,
  PathConstraintReasoning,
  StochasticDynamicOptimisation,
  ModelPredictiveControlReasoning,
  KnowledgeGraphConstruction,
  RetrievalAugmentation,
  RecursiveInference
 ]

 NORMALISE {
  "dynamic optimisation" -> DynamicOptimisation
  "dynamic optimization" -> DynamicOptimisation
  "dynamic programming" -> DynamicProgramming
  "Bellman equation" -> BellmanEquation
  "value function" -> ValueFunction
  "optimal control" -> OptimalControl
  "Hamiltonian" -> Hamiltonian WHEN optimisation_context
  "Pontryagin maximum principle" -> PontryaginMaximumPrinciple
  "HJB equation" -> HamiltonJacobiBellmanEquation
  "model predictive control" -> ModelPredictiveControl
 }

 INTERPRETATION_ORDER = [
  detect_dynamic_optimisation_context,
  identify state_control_dynamics_horizon_initial_terminal_conditions_costs_and_constraints,
  classify discrete_time_continuous_time_deterministic_stochastic_finite_horizon_infinite_horizon_or_MPC problem,
  select dynamic_programming_Pontryagin_HJB_direct_transcription_shooting_or_receding_horizon pathway,
  solve_or_assess value_function_policy_or_trajectory,
  verify dynamics_path_constraints_boundary_conditions_and_numerical discretisation,
  assign local_global_or_approximate solution status,
  return semantic output
 ]
}

EXECUTION_RULES {
 E1:
  IF query_mentions("dynamic optimisation")
  OR objective_depends_on_time_evolving states_and_controls
  THEN activate(DynamicOptimisationOntology)

 E2:
  IF discrete_time_and_state_structure
  THEN consider DynamicProgramming

 E3:
  IF continuous_time_optimal_control
  THEN consider Pontryagin_or_HJB methods

 E4:
  IF direct_numerical_solution_requested
  THEN consider direct_transcription_or_collocation

 E5:
  IF boundary_value_optimality_system
  THEN consider shooting_or_multiple shooting

 E6:
  IF stochastic_transitions
  THEN use expected_or_risk-sensitive Bellman recursion

 E7:
  IF infinite_horizon
  THEN check discounting_stability_and_value finiteness

 E8:
  IF MPC
  THEN verify recursive_feasibility_constraint handling_and_horizon design

 E9:
  IF trajectory_is_feasible_but_optimality_uncertified
  THEN report feasible_dynamic_solution_without claiming global optimum
}

RECURSION {
 ENTRY = DynamicOptimisation

 EXPAND(DynamicOptimisation) -> [
  DynamicOptimisationProblem,
  StateVariable,
  ControlVariable,
  DecisionTrajectory,
  StateTrajectory,
  TransitionFunction,
  DynamicConstraint,
  StageCost,
  RunningCost,
  TerminalCost,
  ObjectiveFunctional,
  TimeHorizon,
  FiniteHorizon,
  InfiniteHorizon,
  DiscountFactor,
  ValueFunction,
  Policy,
  BellmanEquation,
  BellmanOptimalityPrinciple,
  DynamicProgramming,
  BackwardInduction,
  HamiltonJacobiBellmanEquation,
  OptimalControl,
  Hamiltonian,
  CostateVariable,
  PontryaginMaximumPrinciple,
  EulerLagrangeEquation,
  TransversalityCondition,
  PathConstraint,
  BoundaryCondition,
  TerminalConstraint,
  DiscreteTimeSystem,
  ContinuousTimeSystem,
  DeterministicDynamicOptimisation,
  StochasticDynamicOptimisation,
  ModelPredictiveControl,
  DirectTranscription,
  ShootingMethod,
  CollocationMethod
 ]

 EXPAND(DynamicProgrammingStructure) -> [
  StateSpace,
  ActionSpace,
  TransitionFunction,
  StageCost,
  ValueFunction,
  Policy,
  BellmanEquation,
  BackwardInduction
 ]

 EXPAND(OptimalControlStructure) -> [
  StateEquation,
  ControlVariable,
  Hamiltonian,
  CostateEquation,
  StationarityCondition,
  TransversalityCondition,
  PathConstraint
 ]

 EXPAND(DirectMethods) -> [
  DirectShooting,
  MultipleShooting,
  DirectCollocation,
  PseudospectralTranscription,
  NonlinearProgrammingFormulation
 ]

 STOP_CONDITION =
  "Stop when the state and control variables, dynamics, horizon, objective accumulation, boundary conditions, path constraints, selected solution principle, value or trajectory solution and optimality status are sufficiently resolved."
}

ROUTING {
 PARENT_ONTOLOGY = "Optimisation"

 IMMEDIATE_CONTEXTS = [
  "Optimisation Ontology",
  "Optimal Control Ontologies",
  "Dynamic Programming Ontologies",
  "Differential Equations Ontologies"
 ]

 RELATED_ONTOLOGIES = [
  "Optimisation Ontology",
  "Optimisation",
  "Nonlinear Optimisation Ontology",
  "Convex Optimisation Ontology",
  "Dynamic Programming Ontologies",
  "Optimal Control Ontologies",
  "Ordinary Differential Equations Ontologies",
  "Partial Differential Equations Ontologies",
  "Calculus of Variations Ontologies",
  "Control Theory Ontologies",
  "Operations Research Ontologies",
  "Probability & Statistics Ontologies",
  "Numerical Analysis Ontologies",
  "Scientific Computing Ontologies"
 ]

 ROUTE_RULES = [
  "Dynamic Optimisation -> Optimisation Ontology for formal optimisation semantics",
  "Dynamic Optimisation -> Nonlinear Optimisation for direct transcription and trajectory NLPs",
  "Dynamic Optimisation -> Convex Optimisation when dynamics and costs preserve convex structure",
  "Dynamic Optimisation -> Dynamic Programming for Bellman recursion and policies",
  "Dynamic Optimisation -> Optimal Control for continuous-time systems",
  "Dynamic Optimisation -> Differential Equations for state and costate evolution",
  "Dynamic Optimisation -> Calculus of Variations for Euler-Lagrange structure",
  "Dynamic Optimisation -> Control Theory for feedback and MPC semantics",
  "Dynamic Optimisation -> Probability & Statistics for stochastic transitions",
  "Dynamic Optimisation -> Numerical Analysis for trajectory discretisation and solver convergence"
 ]
}

UPDATE_MODEL {
 MODE = "append-compatible semantic versioning"

 MAJOR = "ontology-breaking conceptual change"
 MINOR = "new compatible dynamic optimisation formulations, policies or reasoning pathways"
 PATCH = "clarification, metadata or formatting correction"

 RULES = [
  "Preserve state-control-dynamics semantics.",
  "Preserve finite-versus-infinite horizon distinction.",
  "Preserve Bellman value-function semantics.",
  "Preserve policy-versus-trajectory distinction.",
  "Preserve Pontryagin and HJB semantics.",
  "Preserve path and terminal constraint semantics.",
  "Preserve direct transcription approximation semantics.",
  "Preserve machine-readable dynamic-optimisation semantics."
 ]
}

OUTPUT {
 CANONICAL_DEFINITION =
  "Dynamic optimisation selects time-dependent or stage-dependent decisions whose effects propagate through system dynamics."

 STATE_SUMMARY =
  "State variables summarise the information needed to describe future system evolution."

 CONTROL_SUMMARY =
  "Control variables are decisions that influence state trajectories."

 BELLMAN_SUMMARY =
  "The Bellman equation expresses optimal future value recursively through current cost and next-state value."

 VALUE_SUMMARY =
  "The value function gives the best achievable future objective from a given state and time."

 OPTIMAL_CONTROL_SUMMARY =
  "Continuous-time dynamic optimisation is commonly formulated as optimal control using Hamiltonians, costates and transversality conditions."

 HJB_SUMMARY =
  "The Hamilton-Jacobi-Bellman equation characterises the value function in continuous time."

 DIRECT_METHOD_SUMMARY =
  "Direct transcription converts trajectories and dynamics into a finite-dimensional nonlinear optimisation problem."

 MPC_SUMMARY =
  "Model predictive control repeatedly solves finite-horizon dynamic optimisation problems and applies only the first control action."
}

FLOW {
 INPUT
 -> detect_dynamic_optimisation_context
 -> identify time_or_stage_index_state_variables_control_variables_dynamics_horizon_initial_state_terminal_conditions_stage_or_running_cost_terminal_cost_and_path constraints
 -> classify discrete_time_continuous_time_deterministic_stochastic_finite_horizon_infinite_horizon_or_receding_horizon problem
 -> select dynamic_programming_Bellman_Pontryagin_HJB_direct_transcription_shooting_collocation_or_MPC pathway
 -> formulate value_function_Hamiltonian_or_transcribed optimisation problem
 -> solve_or_approximate policy_control_and_state trajectories
 -> verify dynamics_feasibility_path_constraints_boundary_conditions_and_terminal conditions
 -> assess optimality_numerical convergence_and_global_or_local status
 -> route to optimisation_ontology nonlinear_optimisation convex_optimisation dynamic_programming optimal_control differential_equations calculus_of_variations control_theory probability_statistics numerical_analysis_or_scientific_computing ontology
 -> recursively_expand_required_dependencies
 -> verify_result
 -> assign_confidence
 -> produce_semantic_output
 -> END
}

SEMANTIC_SUMMARY {
 "The Dynamic Optimisation Ontology defines optimisation over evolving states and time-dependent decisions. It supports finite and infinite horizons, discrete and continuous dynamics, stage, running and terminal costs, state and control trajectories, Bellman equations, value functions, policies, dynamic programming, Hamilton-Jacobi-Bellman equations, Hamiltonians, costates, Pontryagin’s Maximum Principle, transversality, path constraints, direct transcription, shooting, collocation, stochastic dynamic optimisation and model predictive control."
}

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

}

END_FLOW