InfiniteOpt.jl

InfiniteOpt.jl is a JuMP extension designed for modeling and solving infinite-dimensional optimization problems, such as dynamic, stochastic, and PDE-constrained optimization.

It decouples infinite-dimensional formulations from the solution techniques used to solve them. By default, it uses direct transcription (discretization) transformations that are compatible with all JuMP-supported solvers. For high-performance GPU computing, it is compatible with InfiniteExaModels.jl.

Key modeling capabilities include:

• Infinite parameters: Time, space, uncertainty, etc.
• Infinite variables: e.g., y(t, x)
• Derivatives: Ordinary and partial derivative operators of any order.
• Measures: Univariate/multivariate integrals and expectations.
• Constraints: Linear, quadratic, nonlinear, conic, semi-definite, and indicator constraints.
• Advanced Integrations: Machine learning surrogate models (via MathOptAI) and generalized disjunctive programming (via DisjunctiveProgramming.jl).

A TranscriptionBackend is a specialized JuMPBackend used to map a transcribed finite model back to its original infinite model (mapping variables, constraints, etc.).

To use it, you can either create an empty backend or generate one from an existing InfiniteModel using build_transformation_backend! or transformation_backend.

Important for efficiency: To support incremental updates of parameter functions (allowing for faster resolves), set update_parameter_functions = true when defining the backend. This maps parameter functions to JuMP parameters instead of just numerical values.

# Option 1: Create an empty backend with incremental updates enabled
backend = TranscriptionBackend(Ipopt.Optimizer, update_parameter_functions = true)
model = InfiniteModel(backend)

# Option 2: Generate a backend from an existing InfiniteModel
build_transformation_backend!(inf_model)
backend = transformation_backend(inf_model)

Infinite domains in InfiniteOpt describe the behavior of infinite parameters. They are categorized into two main groups based on whether they describe a single independent parameter or a multi-dimensional group of dependent parameters:

1. InfiniteScalarDomain: Describes a single independent infinite parameter (univariate).

   • IntervalDomain: A continuous interval [lb, ub]. Supports (semi-)infinite bounds like -Inf or Inf.
   • UniDistributionDomain: Corresponds to a univariate distribution from Distributions.jl.

2. InfiniteArrayDomain: Describes a group of dependent multi-dimensional infinite parameters (multivariate).

   • MultiDistributionDomain: Corresponds to a multivariate or matrix-variate distribution from Distributions.jl. The distribution's dimensions must match the parameter array's shape.
   • CollectionDomain: A collection of InfiniteScalarDomains treated dependently, allowing for non-combinatorial support grids.

# Example of different domain types
# Univariate
domain_int = IntervalDomain(-2, 2)
domain_dist = UniDistributionDomain(Beta(2,2))

# Multivariate
domain_multi = MultiDistributionDomain(MvNormal([0., 0.], [1. 0.; 0. 2.]))
domain_coll = CollectionDomain([IntervalDomain(-2, 2), IntervalDomain(-1, 4)])

InfiniteOpt extends JuMP with specialized variable types. You specify these by passing a subtype of InfOptVariableType to the @variable macro.

• Infinite(params...): Represents a variable over a continuous range or distribution.
• SemiInfinite(infinite_var, fixed_val, params...): Represents a variable that is infinite over some parameters but fixed at a specific value for others.
• Point(infinite_var, fixed_val, params...): Represents a variable fixed at specific points.
• Finite: Standard JuMP finite variables.

Note: SemiInfinite and Point variables inherit the integrality of their respective Infinite variables and this cannot be overwritten.

# Explicit types
@variable(model, y, Infinite(t, x...))
@variable(model, ys, SemiInfinite(y, 0, x...))
@variable(model, yp, Point(y, 0, [1, 1, 1]...))

# Anonymous types
y = @variable(model, variable_type = Infinite(t, x...))

Generative supports are automatically generated supports (like collocation nodes or quadrature points) based on existing finite elements. These are used by measures and derivative evaluation schemes.

• Concept: An IndependentParameter can be associated with one AbstractGenerativeInfo object (default is NoGenerativeSupports).
• UniformGenerativeInfo: A concrete subtype that applies generative supports uniformly to each finite element. It requires a list of relative positions (e.g., [0.5] for the midpoint) and an InternalLabel.
• API for Extension Writers:
  • generative_support_info(param_ref): Check current generative information.
  • has_generative_supports(param_ref): Check if supports have been created.
  • add_generative_supports(model): Triggers the generation of supports.

Note: End-users should generally not modify generative supports directly.

struct MyGenLabel <: InfiniteOpt.InternalLabel end;

# Create info to add a support at the midpoint (0.5) of each element
info = UniformGenerativeInfo([0.5], MyGenLabel)