Optim

Optimizer{T} <: MOI.AbstractOptimizer

A high-level abstraction-based solver that automatically orchestrates system abstraction and control synthesis. This wrapper follows the classical abstraction pipeline (e.g., as in SCOTS), where the state and input spaces are discretized into hyper-rectangular cells, independent of the specific control task.

It delegates responsibility to modular sub-solvers: one for abstraction and one for control, depending on the type of problem to be solved.

Structure and Sub-solvers

The optimizer internally manages two sub-solvers:

• abstraction_solver: OptimizerEmptyProblem: Used to compute the symbolic abstraction of the system from its dynamics and domain.

• control_solver: One of the following control-specific optimizers, depending on the problem type:

  • OptimizerOptimalControlProblem: for reachability/optimal control problems.
  • OptimizerSafetyProblem: for safety problems.

Behavior

• The user sets the control task via: MOI.set(optimizer, MOI.RawOptimizerAttribute("concrete_problem"), my_problem) where my_problem is a subtype of ProblemType.

• The optimizer automatically dispatches to the appropriate control solver based on the problem type.

• If the abstraction has not yet been computed, it is automatically built before solving the control problem.

• Once computed, the abstraction is cached — switching the control problem (e.g., from safety to reachability) does not recompute it.

• The field solve_time_sec tracks the runtime of the last call to MOI.optimize!.

• The resulting controller and value function are stored and can be queried from the wrapper.

User-settable and access to subsolver fields

Via MOI.set(...), the user may configure abstraction_solver and control_solver parameters. Any field accessible in the sub-solvers (abstraction or control) can be transparently accessed via:

MOI.set(optimizer, MOI.RawOptimizerAttribute("state_grid"), grid)
MOI.get(optimizer, MOI.RawOptimizerAttribute("abstract_value_function"))

Example

using Dionysos, JuMP
optimizer = MOI.instantiate(Dionysos.Optim.UniformGridAbstraction.Optimizer)

MOI.set(optimizer, MOI.RawOptimizerAttribute("concrete_problem"), my_problem)
MOI.set(optimizer, MOI.RawOptimizerAttribute("state_grid"), state_grid)
MOI.set(optimizer, MOI.RawOptimizerAttribute("input_grid"), input_grid)
MOI.set(optimizer, MOI.RawOptimizerAttribute("time_step"), 0.1)
MOI.set(optimizer, MOI.RawOptimizerAttribute("print_level"), 2)

MOI.optimize!(optimizer)

time = MOI.get(optimizer, MOI.RawOptimizerAttribute("solve_time_sec"))
value_fun = MOI.get(optimizer, MOI.RawOptimizerAttribute("abstract_value_function"))
controller = MOI.get(optimizer, MOI.RawOptimizerAttribute("concrete_controller"))

OptimizerEmptyProblem{T} <: MOI.AbstractOptimizer

A solver responsible for constructing an abstraction of the system dynamics, independently of the control specification.

This optimizer wraps everything needed to solve an EmptyProblem, which is used to generate a symbolic model (abstraction) of either a continuous- or discrete-time system.

Purpose

This optimizer builds a symbolic abstraction by simulating or approximating the behavior of the given system. The abstraction method is chosen via the approx_mode field, and determines which parameters and approximation logic are used.

Parameters

Mandatory fields set by the user

• empty_problem (required): An instance of EmptyProblem containing the system to abstract and the state region.

• state_grid (required): The discretization grid for the state space.

• input_grid (required): The discretization grid for the input space.

Optional user-tunable fields

• time_step (optional, required if the system is continuous): Time step used for discretizing or simulating continuous-time systems.

• nsystem (optional, default = 5): Number of substeps to use when simulating continuous-time systems (e.g., in Runge-Kutta integration).

• approx_mode (required): The abstraction technique to use. Supported modes:

  • USER_DEFINED: Use a custom overapproximation function. Set overapproximation_map::Function.

  • GROWTH: Use growth-bound based overapproximation. Set jacobian_bound, optionally growthbound_map, ngrowthbound.

  • LINEARIZED: Use linearization + Jacobian/Hessian. Set DF_sys, bound_DF, and bound_DDF.

  • CENTER_SIMULATION: Simulate the center of each cell only.

  • RANDOM_SIMULATION: Sample and simulate random points in each cell. Set n_samples.

• efficient (optional, default = true): Whether to use optimized internal routines based on approx_mode.

• print_level (optional, default = 1): Verbosity level:

  • 0: silent
  • 1: standard
  • 2: verbose/debug

Internally computed fields (after MOI.optimize!)

• abstract_system: The resulting symbolic abstraction, of type SymbolicModelList.

• discrete_time_system: Internally constructed discrete-time version of the system used during abstraction.

• abstraction_construction_time_sec: Time (in seconds) spent constructing the abstraction.

System approximation objects (derived from approx_mode)

• continuous_time_system_approximation: A ContinuousTimeSystemApproximation, automatically created if the original system is continuous.

• discrete_time_system_approximation: A DiscreteTimeSystemApproximation, created in all cases.

Example

using Dionysos, JuMP
optimizer = MOI.instantiate(Dionysos.Optim.OptimizerEmptyProblem.Optimizer)

MOI.set(optimizer, MOI.RawOptimizerAttribute("concrete_problem"), my_problem)
MOI.set(optimizer, MOI.RawOptimizerAttribute("state_grid"), state_grid)
MOI.set(optimizer, MOI.RawOptimizerAttribute("input_grid"), input_grid)
MOI.set(optimizer, MOI.RawOptimizerAttribute("time_step"), 0.1)
MOI.set(optimizer, MOI.RawOptimizerAttribute("print_level"), 2)
MOI.set(optimizer, MOI.RawOptimizerAttribute("approx_mode"), GROWTH)
MOI.set(optimizer, MOI.RawOptimizerAttribute("jacobian_bound"), my_jacobian_bound)

MOI.optimize!(optimizer)

time = MOI.get(optimizer, MOI.RawOptimizerAttribute("abstraction_construction_time_sec"))
abstract_system = MOI.get(optimizer, MOI.RawOptimizerAttribute("abstract_system"))
discrete_time_system = MOI.get(optimizer, MOI.RawOptimizerAttribute("discrete_time_system"))

OptimizerOptimalControlProblem{T} <: MOI.AbstractOptimizer

An optimizer that solves reachability or reach-avoid optimal control problems using symbolic abstractions of the system.

This solver takes as input a concrete problem (typically an instance of OptimalControlProblem) and a symbolic abstraction of the system (i.e., an abstract_system). It then solves the abstract version of the control problem.

Key Behavior

• Lifts the concrete problem to the symbolic abstraction space (abstract_system) and constructs the corresponding abstract_problem.
• Computes the controllable_set — the largest set of abstract states from which reachability can be guaranteed.
• Synthesizes an abstract_controller that brings the system to the target set under worst-case dynamics.
• Computes the abstract_value_function that maps each state (cell) to the worst-case number of steps needed to reach the target.
• The solver is successful if the field success is true after MOI.optimize!.

Parameters

Mandatory fields set by the user

• concrete_problem (required): An instance of OptimalControlProblem that defines the reach-avoid task (system, initial set, target, costs, horizon).

• abstract_system (required): The symbolic abstraction of the system, usually obtained from an abstraction optimizer such as OptimizerEmptyProblem.

Optional user-tunable parameters

• early_stop (optional, default = true): If true, the fixpoint algorithm stops early when the initial set is fully contained in the controllable set. If false, it computes the entire maximal controllable set.

• sparse_input (optional, default = false): If true, uses a sparse representation of the transition table, reducing memory usage when the number of inputs is large but only few are admissible per state (e.g., in determinized abstractions, with new_input = (input, target)).

• print_level (optional, default = 1): Controls verbosity:

  • 0: silent
  • 1: default
  • 2: detailed logging

Internally computed fields

These fields are generated automatically during MOI.optimize!.

• abstract_problem: The lifted version of the concrete problem over the abstract system.
• abstract_problem_time_sec: Time taken to solve the abstract problem.
• abstract_controller: A controller mapping abstract states to control inputs.
• controllable_set: Set of abstract states from which the target is reachable.
• uncontrollable_set: Complementary states with no admissible reachability strategy.
• value_fun_tab: Tabular value function over abstract states (e.g., cost-to-go or step count).
• abstract_value_function: Functional form of the abstract value function.
• concrete_value_function: Functional form of the value function mapped back to the original system.
• success: Boolean flag indicating whether the solver completed successfully.

Example

using Dionysos, JuMP
optimizer = MOI.instantiate(Dionysos.Optim.OptimizerOptimalControlProblem.Optimizer)

MOI.set(optimizer, MOI.RawOptimizerAttribute("concrete_problem"), my_problem)
MOI.set(optimizer, MOI.RawOptimizerAttribute("abstract_system"), abstract_system)
MOI.set(optimizer, MOI.RawOptimizerAttribute("print_level"), 2)

MOI.optimize!(optimizer)

time = MOI.get(optimizer, MOI.RawOptimizerAttribute("abstract_problem_time_sec"))
controllable_set = MOI.get(optimizer, MOI.RawOptimizerAttribute("controllable_set"))
abstract_value_function = MOI.get(optimizer, MOI.RawOptimizerAttribute("abstract_value_function"))
concrete_value_function = MOI.get(optimizer, MOI.RawOptimizerAttribute("concrete_value_function"))
abstract_controller = MOI.get(optimizer, MOI.RawOptimizerAttribute("concrete_controller"))

OptimizerSafetyProblem{T} <: MOI.AbstractOptimizer

An optimizer for solving safety control problems over symbolic system abstractions.

This solver takes as input a SafetyProblem and a symbolic abstraction of the system (e.g., a SymbolicModelList), and computes a controller that ensures the system remains within a safe set over a time horizon or indefinitely.

Key Behavior

• Lifts the concrete safety problem to the abstract domain and builds an abstract_problem.
• Computes the invariant set, i.e., the largest set of abstract states from which all trajectories can be safely controlled.
• Synthesizes an abstract_controller that guarantees safety under worst-case transitions.
• The optimization is successful if success == true after calling MOI.optimize!.

Parameters

Mandatory fields set by the user

• concrete_problem (required): An instance of SafetyProblem that specifies the system, initial set, safe set, and horizon.

• abstract_system (required): A symbolic abstraction of the system, e.g., obtained from OptimizerEmptyProblem.

Optional user-tunable parameters

• print_level (optional, default = 1): Controls verbosity:
  • 0: silent
  • 1: default (info)
  • 2: verbose debug output

Internally computed fields

These fields are automatically filled in by MOI.optimize!.

• abstract_problem: The lifted version of the safety problem in the symbolic domain.
• abstract_problem_time_sec: Time taken to solve the safety problem over the abstract system.
• abstract_controller: A controller mapping abstract states to admissible inputs that keep the system safe.
• invariant_set: The largest subset of abstract states from which safety can be maintained.
• invariant_set_complement: States from which safety cannot be guaranteed.
• success: Boolean flag indicating whether a valid invariant set and controller were found.

Example

using Dionysos, JuMP
optimizer = MOI.instantiate(Dionysos.Optim.OptimizerSafetyProblem.Optimizer)

MOI.set(optimizer, MOI.RawOptimizerAttribute("concrete_problem"), my_problem)
MOI.set(optimizer, MOI.RawOptimizerAttribute("abstract_system"), abstract_system)
MOI.set(optimizer, MOI.RawOptimizerAttribute("print_level"), 2)

MOI.optimize!(optimizer)

time = MOI.get(optimizer, MOI.RawOptimizerAttribute("abstract_problem_time_sec"))
invariant_set = MOI.get(optimizer, MOI.RawOptimizerAttribute("invariant_set"))
abstract_controller = MOI.get(optimizer, MOI.RawOptimizerAttribute("concrete_controller"))

Optimizer{T} <: MOI.AbstractOptimizer

Abstraction-based solver for which the domain is covered with ellipsoidal cells, independently of the control task.

Optimizer{T} <: MOI.AbstractOptimizer

Abstraction-based solver for which the domain is initially partioned into coarse hyper-rectangular cells, which are iteratively locally smartly refined with respect to the control task.

Optimizer{T} <: MOI.AbstractOptimizer

Abstraction-based solver for which the hyper-rectangular abstraction and the controller are co-designed to reduce the computation cost of the abstraction.

Optimizer{T} <: MOI.AbstractOptimizer

Abstraction-based solver using the lazy abstraction method with ellipsoidal cells.

Optimizer{T} <: MOI.AbstractOptimizer

Bemporad Morari solver: Optimal control of hybrid systems via a predictive control scheme using mixed integer quadratic programming (MIQP) online optimization procedures.

Optimizer{T} <: MOI.AbstractOptimizer

Branch and bound solver: Optimal control of hybrid systems via a predictive control scheme combining a branch and bound algorithm that can refine Q-functions using Lagrangian duality.