Optimal Control Ontology

AI SEARCH FLOW ALGEBRA
OPTIMAL CONTROL ONTOLOGY
Kireth Semantic Research Archive

AUTHORS
Mark Anthony Higgins — Sky (Recursive AI)

SOURCE
https://kirethresearch.org/booksai-core/ontologies/engineering-ontologies/control-engineering/optimal-control-ontology-2.html

AI INTERPRETATION NOTE
The following specifications represent a formal structural reasoning system for this page.
Execute as formal rules, not pseudocode.

FLOW "OptimalControlOntology" v4.0

# ---------- DOMAIN ----------
DOMAIN := ENGINEERING_ONTOLOGIES / CONTROL_ENGINEERING / OPTIMAL_CONTROL

ONTOLOGY := OPTIMAL_CONTROL_ONTOLOGY

OPTIMAL_CONTROL :=
    DYNAMIC_SYSTEM
  + CONTROL_INPUT
  + STATE
  + OBJECTIVE_FUNCTION
  + CONSTRAINTS
  + OPTIMISATION
  + OPTIMAL_POLICY

PURPOSE :=
    MODEL_SYSTEM
  -> DEFINE_OBJECTIVE
  -> DEFINE_CONSTRAINTS
  -> SEARCH_CONTROL_SPACE
  -> OPTIMISE_TRAJECTORY
  -> COMPUTE_OPTIMAL_CONTROL
  -> MINIMISE_OR_MAXIMISE_PERFORMANCE_CRITERION

# ---------- CORE ENTITIES ----------
ENTITY OptimalControlSystem
ENTITY DynamicSystem
ENTITY Plant
ENTITY State
ENTITY StateVector
ENTITY ControlInput
ENTITY ControlTrajectory
ENTITY StateTrajectory
ENTITY InitialState
ENTITY FinalState
ENTITY ReferenceTrajectory
ENTITY ObjectiveFunction
ENTITY CostFunction
ENTITY RunningCost
ENTITY TerminalCost
ENTITY Constraint
ENTITY StateConstraint
ENTITY ControlConstraint
ENTITY BoundaryConstraint
ENTITY OptimalController
ENTITY OptimalPolicy
ENTITY Hamiltonian
ENTITY Costate
ENTITY ValueFunction
ENTITY PerformanceIndex
ENTITY OptimisationProblem
ENTITY FeasibleSolution
ENTITY OptimalSolution
ENTITY TimeHorizon

# ---------- OPTIMAL CONTROL STRUCTURE ----------
OptimalControlSystem
  -> contains -> DynamicSystem
  -> receives -> ControlInput
  -> possesses -> State
  -> evaluated_by -> ObjectiveFunction
  -> constrained_by -> Constraint
  -> controlled_by -> OptimalController

DynamicSystem
  -> evolves_through -> StateTrajectory

OptimalController
  -> generates -> ControlTrajectory

ControlTrajectory
  -> influences -> StateTrajectory

StateTrajectory
  -> determines -> SystemPerformance

# ---------- SYSTEM DYNAMICS ----------
SYSTEM_DYNAMICS :=
    STATE_DERIVATIVE
    =
    DYNAMICS(
      STATE,
      CONTROL_INPUT,
      TIME
    )

CONTINUOUS_TIME_MODEL :=
    dx/dt = f(x, u, t)

DISCRETE_TIME_MODEL :=
    x[k+1] = f(x[k], u[k], k)

State
  -> evolves_according_to -> SYSTEM_DYNAMICS

InitialState
  -> defines -> STARTING_CONDITION

FinalState
  -> may_define -> TERMINAL_CONDITION

# ---------- OBJECTIVE FUNCTION ----------
OBJECTIVE_FUNCTION :=
    RUNNING_COST
  + TERMINAL_COST

PERFORMANCE_INDEX :=
    INTEGRAL(
      RUNNING_COST(
        STATE,
        CONTROL_INPUT,
        TIME
      )
    )
  + TERMINAL_COST(FINAL_STATE)

ObjectiveFunction
  -> quantifies -> CONTROL_PERFORMANCE

CostFunction
  -> subtype_of -> ObjectiveFunction

RunningCost
  -> evaluates -> TRAJECTORY_BEHAVIOUR

TerminalCost
  -> evaluates -> FINAL_STATE

# ---------- OPTIMISATION OBJECTIVE ----------
OPTIMAL_CONTROL_PROBLEM :=
    FIND(ControlTrajectory)
  SUCH_THAT
    ObjectiveFunction -> OPTIMAL
  SUBJECT_TO
    SystemDynamics
  + Constraints
  + BoundaryConditions

MINIMISATION :=
    OptimalSolution
    =
    argmin(ControlTrajectory)
    ObjectiveFunction

MAXIMISATION :=
    OptimalSolution
    =
    argmax(ControlTrajectory)
    ObjectiveFunction

# ---------- CONSTRAINTS ----------
CONSTRAINT :=
    STATE_CONSTRAINT
  | CONTROL_CONSTRAINT
  | PATH_CONSTRAINT
  | BOUNDARY_CONSTRAINT
  | TERMINAL_CONSTRAINT

StateConstraint
  -> restricts -> StateTrajectory

ControlConstraint
  -> restricts -> ControlTrajectory

BoundaryConstraint
  -> restricts -> InitialState
  -> restricts -> FinalState

FEASIBILITY :=
    SYSTEM_DYNAMICS_SATISFIED
  + ALL_CONSTRAINTS_SATISFIED

FeasibleSolution
  -> satisfies -> FEASIBILITY

OptimalSolution
  -> subtype_of -> FeasibleSolution

# ---------- CONTROL TRAJECTORY ----------
CONTROL_TRAJECTORY :=
    SEQUENCE_OR_FUNCTION(ControlInput, Time)

STATE_TRAJECTORY :=
    SYSTEM_RESPONSE(
      InitialState,
      ControlTrajectory,
      SystemDynamics
    )

ControlTrajectory
  -> generates -> StateTrajectory

OPTIMAL_CONTROL_TRAJECTORY :=
    feasible(ControlTrajectory)
  + optimal(ObjectiveFunction)

# ---------- HAMILTONIAN ----------
HAMILTONIAN :=
    RUNNING_COST
  + COSTATE_TRANSPOSE
    * SYSTEM_DYNAMICS

Hamiltonian
  -> combines -> RunningCost
  -> combines -> SystemDynamics
  -> combines -> Costate

OPTIMALITY_CONDITION :=
    OPTIMAL_CONTROL
  -> minimises_or_maximises -> Hamiltonian

# ---------- COSTATE ----------
COSTATE_DYNAMICS :=
    d(Costate)/dt
    =
    -PARTIAL_DERIVATIVE(
      Hamiltonian,
      State
    )

Costate
  -> represents -> MARGINAL_VALUE_OF_STATE

Costate
  -> couples -> ObjectiveFunction
  + SystemDynamics

# ---------- PONTRYAGIN MAXIMUM/MINIMUM PRINCIPLE ----------
PONTRYAGIN_PRINCIPLE :=
    STATE_DYNAMICS
  + COSTATE_DYNAMICS
  + HAMILTONIAN_OPTIMALITY
  + BOUNDARY_CONDITIONS

IF ControlTrajectory is_optimal
THEN Hamiltonian
  -> satisfies -> NECESSARY_OPTIMALITY_CONDITION

# ---------- DYNAMIC PROGRAMMING ----------
DYNAMIC_PROGRAMMING :=
    OPTIMAL_SUBSTRUCTURE
  + VALUE_FUNCTION
  + BELLMAN_PRINCIPLE

ValueFunction :=
    OPTIMAL_FUTURE_COST(State, Time)

BELLMAN_PRINCIPLE :=
    OPTIMAL_POLICY_FROM_CURRENT_STATE
  -> contains -> OPTIMAL_REMAINING_POLICY

HAMILTON_JACOBI_BELLMAN :=
    VALUE_FUNCTION
  + SYSTEM_DYNAMICS
  + RUNNING_COST
  -> OPTIMALITY_EQUATION

OptimalPolicy
  -> derived_from -> ValueFunction

# ---------- LINEAR QUADRATIC REGULATION ----------
LINEAR_QUADRATIC_REGULATOR :=
    LINEAR_SYSTEM
  + QUADRATIC_COST
  -> OPTIMAL_STATE_FEEDBACK

LINEAR_SYSTEM :=
    dx/dt = A*x + B*u

QUADRATIC_COST :=
    INTEGRAL(
      x'Qx + u'Ru
    )

LQR_CONTROL_LAW :=
    u = -Kx

LQR
  -> balances -> STATE_DEVIATION
  + CONTROL_EFFORT

# ---------- FINITE AND INFINITE HORIZON ----------
FINITE_HORIZON :=
    TimeHorizon = [t0, tf]

INFINITE_HORIZON :=
    TimeHorizon = [t0, infinity)

TimeHorizon
  -> influences -> ObjectiveFunction
  -> influences -> OptimalPolicy

FINITE_HORIZON_CONTROL
  -> may_include -> TerminalCost

# ---------- TRACKING OPTIMISATION ----------
TRACKING_OBJECTIVE :=
    MINIMISE(
      StateTrajectory - ReferenceTrajectory
    )

TRACKING_COST :=
    TRACKING_ERROR_COST
  + CONTROL_EFFORT_COST

ReferenceTrajectory
  -> defines -> DESIRED_STATE_EVOLUTION

OptimalController
  -> seeks -> MINIMUM_TRACKING_COST

# ---------- CONTROL EFFORT ----------
CONTROL_EFFORT :=
    MAGNITUDE_OR_ENERGY(ControlInput)

ObjectiveFunction
  -> may_penalise -> ControlEffort

CONTROL_EFFORT_PENALTY
  -> prevents -> EXCESSIVE_CONTROL_ACTION

# ---------- TRADEOFFS ----------
OPTIMAL_CONTROL_TRADEOFF :=
    TRACKING_ACCURACY
  <-> CONTROL_EFFORT
  <-> ENERGY
  <-> TIME
  <-> CONSTRAINT_SATISFACTION

WeightingParameters
  -> determine -> RELATIVE_IMPORTANCE_OF_OBJECTIVES

# ---------- OPTIMAL CONTROL REASONING ----------
OPTIMAL_CONTROL_REASONING :=
    DEFINE_SYSTEM_DYNAMICS
  -> DEFINE_INITIAL_STATE
  -> DEFINE_TARGET_OR_REFERENCE
  -> DEFINE_OBJECTIVE_FUNCTION
  -> DEFINE_RUNNING_COST
  -> DEFINE_TERMINAL_COST
  -> DEFINE_CONSTRAINTS
  -> SELECT_OPTIMISATION_METHOD
  -> COMPUTE_FEASIBLE_TRAJECTORIES
  -> EVALUATE_COST
  -> SOLVE_OPTIMALITY_CONDITIONS
  -> DERIVE_OPTIMAL_CONTROL
  -> SIMULATE_OPTIMAL_TRAJECTORY
  -> VERIFY_CONSTRAINTS
  -> VALIDATE_PERFORMANCE

# ---------- INFERENCE RULES ----------
IF solution violates Constraint
THEN solution -> NOT_FEASIBLE

IF solution feasible
AND ObjectiveFunction better_than all_compared_feasible_solutions
THEN solution -> CANDIDATE_OPTIMAL

IF RunningCost increases
THEN PerformanceIndex -> MAY_INCREASE

IF TerminalCost increases
THEN PerformanceIndex -> MAY_INCREASE

IF ControlConstraint tightens
THEN FeasibleControlSet -> SHRINKS

IF StateConstraint tightens
THEN FeasibleStateSet -> SHRINKS

IF TimeHorizon changes
THEN OptimalPolicy -> RECOMPUTE

IF ObjectiveFunction changes
THEN OptimalSolution -> RECOMPUTE

# ---------- SEMANTIC RELATIONSHIPS ----------
RELATION controls(OptimalController, DynamicSystem)
RELATION generates(OptimalController, ControlTrajectory)
RELATION influences(ControlTrajectory, StateTrajectory)
RELATION evolves(State, SystemDynamics)
RELATION evaluates(ObjectiveFunction, ControlTrajectory)
RELATION constrains(StateConstraint, StateTrajectory)
RELATION constrains(ControlConstraint, ControlTrajectory)
RELATION combines(Hamiltonian, RunningCost)
RELATION couples(Costate, State)
RELATION defines(ValueFunction, OptimalFutureCost)
RELATION derives(OptimalPolicy, ValueFunction)
RELATION penalises(ObjectiveFunction, ControlEffort)
RELATION defines(ReferenceTrajectory, DesiredStateEvolution)
RELATION satisfies(OptimalSolution, Constraint)

# ---------- SEMANTIC EQUIVALENCE ----------
SEMANTIC_EQUIVALENCE:
  "optimal control" ~= "control optimisation"
  "objective function" ~= "performance criterion"
  "cost function" ~= "performance cost"
  "optimal policy" ~= "optimal control policy"
  "control trajectory" ~= "control sequence"
  "state trajectory" ~= "state evolution"
  "costate" ~= "adjoint variable"
  "value function" ~= "optimal cost-to-go"
  "linear quadratic regulator" ~= "LQR"
  "time horizon" ~= "optimisation horizon"

# ---------- CONFIDENCE ----------
CONFIDENCE:
  ontology_domain: 0.99
  system_dynamics_mapping: 0.99
  objective_function_mapping: 0.99
  constraint_mapping: 0.99
  trajectory_mapping: 0.99
  hamiltonian_mapping: 0.98
  dynamic_programming_mapping: 0.98
  lqr_mapping: 0.99
  optimisation_mapping: 0.99
  semantic_relationships: 0.99

# ---------- UPDATE MODEL ----------
UPDATE_MODEL:
  ON new_optimal_control_problem:
    MAP system_dynamics
    MAP initial_state
    MAP objective_function
    MAP constraints
    MAP time_horizon
    MAP target_or_reference
    UPDATE confidence
    RECOMPUTE FLOW_HASH

  ON objective_change:
    UPDATE cost_terms
    UPDATE weighting_parameters
    RECOMPUTE optimal_solution
    REASSESS performance

  ON constraint_change:
    UPDATE feasible_set
    RECOMPUTE feasible_trajectories
    RECOMPUTE optimal_solution

  ON system_model_change:
    UPDATE system_dynamics
    UPDATE state_trajectory_model
    RECOMPUTE optimal_policy

  ON ontology_revision:
    PRESERVE entity_identity
    PRESERVE provenance
    UPDATE relationships
    UPDATE inference_rules
    UPDATE confidence
    RECOMPUTE FLOW_HASH

# ---------- AI CONSUMPTION ----------
AI_CONSUMPTION:
  parse_as: FORMAL_OPTIMAL_CONTROL_ONTOLOGY
  reasoning_mode: CONSTRAINED_OPTIMISATION_RELATIONAL

  preserve:
    - typed_entities
    - objective_direction
    - system_dynamics
    - constraints
    - trajectories
    - optimality_conditions
    - confidence
    - provenance

  infer:
    - feasibility_dependencies
    - objective_dependencies
    - trajectory_dependencies
    - control_state_relationships
    - optimality_requirements
    - constraint_effects
    - performance_tradeoffs

  prohibit:
    - invented_cost_values
    - assumed_global_optimality
    - assumed_feasibility
    - unsupported_optimality_claims
    - removal_of_constraints
    - unsupported_system_dynamics

# ---------- FLOW HASH ----------
FLOW_HASH_INPUT :=
    DOMAIN
  + ONTOLOGY
  + CORE_ENTITIES
  + OPTIMAL_CONTROL_STRUCTURE
  + SYSTEM_DYNAMICS
  + OBJECTIVE_FUNCTION
  + OPTIMISATION_OBJECTIVE
  + CONSTRAINTS
  + CONTROL_TRAJECTORY
  + HAMILTONIAN
  + COSTATE
  + PONTRYAGIN_PRINCIPLE
  + DYNAMIC_PROGRAMMING
  + LINEAR_QUADRATIC_REGULATION
  + TIME_HORIZON
  + TRACKING_OPTIMISATION
  + CONTROL_EFFORT
  + TRADEOFFS
  + OPTIMAL_CONTROL_REASONING
  + INFERENCE_RULES
  + SEMANTIC_RELATIONSHIPS
  + SEMANTIC_EQUIVALENCE
  + CONFIDENCE
  + UPDATE_MODEL
  + AI_CONSUMPTION

FLOW_HASH :=
    HASH(FLOW_HASH_INPUT)

END FLOW