_optimize_hook dispatch on AbstractReformulationMethod

Author: dnguyen227

README.md

@@ -184,13 +184,12 @@ The following reformulation methods are currently supported:
 
     All variables must be included in exactly one partition. For manual partitioning, ensure each variable appears in exactly one group. For automatic partitioning, variables are divided as evenly as possible among the specified number of partitions.
 
-6. [Cutting Planes](https://pubsonline.informs.org/doi/10.1287/ijoc.2015.0669): This method iteratively generates cutting planes using a separation problem and a relaxed Big-M formulation, then applies a final reformulation method. The `CuttingPlanes` struct is created with the following arguments:
+6. [Cutting Planes](https://pubsonline.informs.org/doi/10.1287/ijoc.2015.0669): This method iteratively generates cutting planes using a separation problem and a relaxed Big-M formulation. The `CuttingPlanes` struct is created with the following arguments:
 
     - `optimizer`: Optimizer to use when solving the separation and relaxed Big-M subproblems. This is a required value.
     - `max_iter`: Maximum number of cutting plane iterations. Default: `3`.
     - `seperation_tolerance`: Convergence tolerance for the separation problem objective. Default: `1e-6`.
-    - `final_reform_method`: Reformulation method to apply after cutting plane iterations. Default: `BigM()`.
-    - `M_value`: Big-M value to use in the relaxed Big-M reformulation during iterations. Default: `1e9`.
+    - `M_value`: Big-M value to use in the relaxed Big-M reformulation. Default: `1e9`.
 
 ## Infinite-Dimensional GDP
 To model disjunctions, logical variables, and logical constraints with infinite-dimensional optimization problems (e.g., dynamic and stochastic optimization), DisjunctiveProgramming is also compatible with [InfiniteOpt.jl](https://github.com/infiniteopt/InfiniteOpt.jl). For this, the syntax is largely the same, users simply need to import `InfiniteOpt` and use `InfiniteGDPModel`. They also can use `InfiniteLogical` to declare infinite logical variables as shown below:

docs/src/index.md

@@ -171,7 +171,7 @@ The following reformulation methods are currently supported:
 
 5. [Indicator](https://jump.dev/JuMP.jl/stable/manual/constraints/#Indicator-constraints): This method reformulates each disjunct constraint into an indicator constraint with the Boolean reformulation counterpart of the Logical variable used to define the disjunct constraint. This is invoked with [`Indicator`](@ref).
 
-6. Logic-based Outer Approximation (LOA): An iterative solution method for nonlinear GDPs, rather than a single-shot reformulation. It alternates between a primal NLP (the model reformulated by an inner method — `BigM`, `MBM`, or `Hull` — with the disjunct binaries fixed at the current selection) and a master MILP that accumulates outer-approximation and no-good cuts until the bound meets the incumbent. This is invoked with the [`LOA`](@ref) struct, e.g. `optimize!(m, gdp_method = LOA(Ipopt.Optimizer))`.
+6. Logic-based Outer Approximation (LOA): An iterative solution method for nonlinear GDPs, rather than a single-shot reformulation. It alternates between a primal NLP (the model reformulated by an inner method — `BigM`, `MBM`, or `Hull` — with the disjunct binaries fixed at the current selection) and a master MILP that accumulates outer-approximation and no-good cuts until the bound meets the incumbent. This is invoked with the [`LOA`](@ref) struct, e.g. `optimize!(m, gdp_method = LOA(Ipopt.Optimizer))`. Unlike the reformulation methods above, `LOA` runs the full algorithm on every `optimize!` call and cannot be passed to `reformulate_model`.
 
 ## Release Notes
 

ext/InfiniteDisjunctiveProgramming.jl

@@ -412,15 +412,10 @@ end
 # variable under an infinite indicator keys its single disaggregated
 # copy by each per-support binary reference, mirroring the per-support
 # disjunct cuts that look it up.
-_transcribed_disaggregation_map(::InfiniteOpt.InfiniteModel, ::Nothing) =
-    nothing
-function _transcribed_disaggregation_map(
-    model::InfiniteOpt.InfiniteModel,
-    disaggregation_map
-    )
+function _transcribed_disaggregation_map(model::InfiniteOpt.InfiniteModel)
     result = Dict{Tuple{JuMP.VariableRef,
         Union{JuMP.VariableRef, JuMP.AffExpr}}, JuMP.VariableRef}()
-    for ((variable, indicator), disaggregated) in disaggregation_map
+    for ((variable, indicator), disaggregated) in DP._disaggregation_map(model)
         binary_refs = _transcribed_binary_refs(model, indicator)
         variables = _transcribed_refs(
             InfiniteOpt.transformation_variable(variable))
@@ -437,8 +432,7 @@ end
 
 function DP.build_loa_problem(
     model::InfiniteOpt.InfiniteModel,
-    method::DP.LOA,
-    disaggregation_map = nothing
+    method::DP.LOA
     )
     InfiniteOpt.build_transformation_backend!(model)
     nlp = InfiniteOpt.transformation_model(model)
@@ -493,7 +487,7 @@ function DP.build_loa_problem(
 
     return DP._LOAProblem(nlp, binaries,
         disjunct_constraints, global_constraints,
-        _transcribed_disaggregation_map(model, disaggregation_map))
+        _transcribed_disaggregation_map(model))
 end
 
 end

src/datatypes.jl

@@ -417,11 +417,8 @@ constraints.
 """
 struct Hull{T} <: AbstractReformulationMethod
     value::T
-    # Internal: LOA installs a Dict here to collect the disaggregation
-    # map during reformulation; `nothing` for every other use.
-    disaggregation_map::Union{Nothing, AbstractDict}
-    function Hull(ϵ::T = 1e-6; disaggregation_map = nothing) where {T}
-        new{T}(ϵ, disaggregation_map)
+    function Hull(ϵ::T = 1e-6) where {T}
+        new{T}(ϵ)
     end
 end
 
@@ -430,13 +427,11 @@ mutable struct _Hull{V <: JuMP.AbstractVariableRef, T} <: AbstractReformulationM
     value::T
     disjunction_variables::Dict{V, Vector{V}}
     disjunct_variables::Dict{Tuple{V, Union{V, JuMP.GenericAffExpr{T, V}}}, V}
-    disaggregation_map::Union{Nothing, AbstractDict}
     function _Hull(method::Hull{T}, vrefs::Set{V}) where {T, V <: JuMP.AbstractVariableRef}
         new{V, T}(
             method.value,
             Dict{V, Vector{V}}(vref => V[] for vref in vrefs),
-            Dict{Tuple{V, Union{V, JuMP.GenericAffExpr{T, V}}}, V}(),
-            method.disaggregation_map
+            Dict{Tuple{V, Union{V, JuMP.GenericAffExpr{T, V}}}, V}()
         )
     end
 end
@@ -450,24 +445,20 @@ A type for using the cutting planes approach for disjunctive constraints.
 - `optimizer::O`: Optimizer to use when solving mini-models (required).
 - `max_iter::Int`: Number of iterations (default = `3`).
 - `seperation_tolerance::T`: Tolerance for the separation problem (default = `1e-6`).
-- `final_reform_method::AbstractReformulationMethod`: Final reformulation 
-method to use after cutting planes (default = `BigM()`).
 - `M_value::T`: Big-M value to use in the final reformulation (default = `1e9`).
 """
 struct CuttingPlanes{O, T} <: AbstractReformulationMethod
     optimizer::O;
     max_iter::Int
     seperation_tolerance::T
-    final_reform_method::AbstractReformulationMethod
     M_value::T
     function CuttingPlanes(
         optimizer::O;
         max_iter::Int = 3,
         seperation_tolerance::T = 1e-6,
-        final_reform_method = BigM(),
         M_value::T = 1e9
     ) where {O, T}
-        new{O, T}(optimizer, max_iter, seperation_tolerance, final_reform_method, M_value)
+        new{O, T}(optimizer, max_iter, seperation_tolerance, M_value)
     end
 end
 
@@ -575,13 +566,18 @@ struct Indicator <: AbstractReformulationMethod end
 #                              LOA
 ################################################################################
 """
-    LOA{O, P, R, T} <: AbstractReformulationMethod
+    LOA{O, P, R, T} <: AbstractSolutionMethod
 
 Logic-based Outer Approximation solver for GDP models. Iterates a primary
 NLP (original model reformulated by `inner_method`, binaries fixed per
 iteration) and a master MILP accumulating OA and no-good cuts.
 `inner_method` is `BigM` (default), `MBM`, or `Hull`.
 
+LOA is a solution algorithm, not a reformulation: it is invoked with
+`optimize!(model, gdp_method = LOA(...))`, always re-runs on `optimize!`,
+and is not accepted by [`reformulate_model`](@ref). After the run the
+incumbent is loaded into `model`, so JuMP solution queries work directly.
+
 ## Fields
 - `nlp_optimizer::O`: solver for the primary NLP.
 - `mip_optimizer::P`: solver for the master MILP (default `nlp_optimizer`).
@@ -599,10 +595,10 @@ iteration) and a master MILP accumulating OA and no-good cuts.
 - `slack_tol::Float64`: max total slack for which the bound still counts
   as converged (positive slack = nonconvex crossing, keep iterating).
 - `iteration_time_limit::Float64`: budget (s) for the iteration loop.
-- `time_limit::Float64`: overall budget (s) incl. the final solve
-  (default 3600; `Inf` disables).
+- `time_limit::Float64`: overall budget (s) for the algorithm; the
+  final loading solve is not capped (default 3600; `Inf` disables).
 """
-struct LOA{O, P, R, T} <: AbstractReformulationMethod
+struct LOA{O, P, R, T} <: AbstractSolutionMethod
     nlp_optimizer::O
     mip_optimizer::P
     inner_method::R
@@ -647,7 +643,7 @@ end
 # is the binary or its `1 - y` complement expression), the nonlinear
 # global `(function, set)` pairs, and the `(variable, binary_ref) ->
 # disaggregated variable` map from an inner Hull reformulation
-# (`nothing` for Big-M / MBM). Built by `build_loa_problem`. The
+# (empty for Big-M / MBM). Built by `build_loa_problem`. The
 # set-covering seed generates its combinations on the fly from the
 # master, so none are stored here.
 struct _LOAProblem{M <: JuMP.AbstractModel, V <: JuMP.AbstractVariableRef, T}
@@ -657,8 +653,7 @@ struct _LOAProblem{M <: JuMP.AbstractModel, V <: JuMP.AbstractVariableRef, T}
         JuMP.AbstractJuMPScalar, _MOI.AbstractScalarSet}}
     global_constraints::Vector{Tuple{JuMP.AbstractJuMPScalar,
         _MOI.AbstractScalarSet}}
-    disaggregation_map::Union{Nothing,
-        Dict{Tuple{V, Union{V, JuMP.GenericAffExpr{T, V}}}, V}}
+    disaggregation_map::Dict{Tuple{V, Union{V, JuMP.GenericAffExpr{T, V}}}, V}
 
     # Inner constructor deriving the value type `T` from the NLP model.
     # `T` only appears inside `Union` field types, so the default
@@ -715,6 +710,10 @@ mutable struct GDPData{M <: JuMP.AbstractModel, V <: JuMP.AbstractVariableRef, C
     # Helpful metadata for most reformulations (not just one of them)
     variable_bounds::Dict{V, Tuple{T, T}}
 
+    # Hull disaggregations recorded during reformulation, consumed by
+    # solution algorithms (LOA): (variable, indicator) => disaggregated
+    disaggregation_map::Dict{Tuple{V, LogicalVariableRef{M}}, V}
+
     # Reformulation variables and constraints
     reformulation_variables::Vector{V}
     reformulation_constraints::Vector{C}
@@ -735,6 +734,7 @@ mutable struct GDPData{M <: JuMP.AbstractModel, V <: JuMP.AbstractVariableRef, C
             Dict{LogicalVariableRef{M}, Vector{Union{DisjunctConstraintRef{M}, DisjunctionRef{M}}}}(),
             Dict{Union{DisjunctConstraintRef{M}, DisjunctionRef{M}}, LogicalVariableRef{M}}(),
             Dict{V, Tuple{T, T}}(),
+            Dict{Tuple{V, LogicalVariableRef{M}}, V}(),
             Vector{V}(),
             Vector{C}(),
             nothing,

src/hull.jl

@@ -42,9 +42,8 @@ function _disaggregate_variable(
     #temp storage
     push!(method.disjunction_variables[vref], dvref)
     method.disjunct_variables[vref, bvref] = dvref
-    #record into the LOA disaggregation map when installed (LOA-Hull only)
-    method.disaggregation_map === nothing ||
-        (method.disaggregation_map[(vref, lvref)] = dvref)
+    #record the disaggregation for solution algorithms (LOA)
+    _disaggregation_map(model)[(vref, lvref)] = dvref
     #create bounding constraints
     dvname = JuMP.name(dvref)
     lbname = isempty(dvname) ? "" : "$(dvname)_lower_bound"
@@ -257,9 +256,7 @@ function reformulate_disjunction(model::JuMP.AbstractModel, disj::Disjunction, m
     return ref_cons
 end
 function reformulate_disjunction(model::JuMP.AbstractModel, disj::Disjunction, method::_Hull)
-    return reformulate_disjunction(model, disj,
-        Hull(method.value;
-            disaggregation_map = method.disaggregation_map))
+    return reformulate_disjunction(model, disj, Hull(method.value))
 end
 
 function reformulate_disjunct_constraint(