Wrapper for the Mixed Integer Linear Minimization Oracle

src/Boscia.jl

@@ -12,6 +12,7 @@ using Dates
 const MOI = MathOptInterface
 const MOIU = MOI.Utilities
 
+import Base: convert
 import MathOptSetDistances as MOD
 
 include("time_tracking_lmo.jl")
@@ -23,7 +24,6 @@ include("node.jl")
 include("custom_bonobo.jl")
 include("callbacks.jl")
 include("problem.jl")
-include("infeasible_pairwise.jl")
 include("heuristics.jl")
 include("strong_branching.jl")
 include("utilities.jl")

src/MOI_bounded_oracle.jl

@@ -17,13 +17,46 @@ function MathOptBLMO(lmo::FrankWolfe.MathOptLMO)
     return MathOptBLMO(lmo.o, lmo.use_modfify)
 end
 
+"""
+Convert object of Type MathOptLMO into MathOptBLMO and viceversa.
+"""
+function convert(::Type{MathOptBLMO}, lmo::FrankWolfe.MathOptLMO)
+    return MathOptBLMO(lmo.o, lmo.use_modify)
+end
+function convert(::Type{FrankWolfe.MathOptLMO}, nlmo::MathOptBLMO) 
+    return FrankWolfe.MathOptLMO(blmo.o, blmo.use_modfify)
+end
+
+
 ################## Necessary to implement ####################
 """
     compute_extreme_point
 
 Is implemented in the FrankWolfe package in file "moi_oracle.jl".
 """
 
+"""
+Get list of variables indices. 
+If the problem has n variables, they are expected to contiguous and ordered from 1 to n.
+"""
+function get_list_of_variables(blmo::MathOptBLMO) 
+    v_indices = MOI.get(blmo.o, MOI.ListOfVariableIndices())
+    if v_indices != MOI.VariableIndex.(1:n)
+        error("Variables are expected to be contiguous and ordered from 1 to N")
+    end
+    return v_indices
+end
+
+"""
+Get list of binary and integer variables, respectively.
+"""
+function get_binary_variables(blmo::MathOptBLMO) 
+    return MOI.get(blmo.o, MOI.ListOfConstraintIndices{MOI.VariableIndex,MOI.ZeroOne}())
+end
+function get_integer_variables(blmo::MathOptBLMO) 
+    return MOI.get(blmo.o, MOI.ListOfConstraintIndices{MOI.VariableIndex,MOI.Integer}())
+end 
+
 """
 Get the index of the integer variable the bound is working on.
 """
@@ -120,6 +153,104 @@ function is_integer_constraint(blmo::MathOptBLMO, idx::Int)
     return false, -1
 end
 
+"""
+Is a given point v linear feasible for the model?
+"""
+function is_linear_feasible(blmo::MathOptBLMO, v::AbstractVector)
+    return is_linear_feasible(blmo.o, v)
+end
+function is_linear_feasible(o::MOI.ModelLike, v::AbstractVector)
+    valvar(f) = v[f.value]
+    for (F, S) in MOI.get(o, MOI.ListOfConstraintTypesPresent())
+        isfeasible = is_linear_feasible_subroutine(o, F, S, valvar)
+        if !isfeasible
+            return false
+        end
+    end
+    # satisfies all constraints
+    return true
+end
+# function barrier for performance
+function is_linear_feasible_subroutine(o::MOI.ModelLike, ::Type{F}, ::Type{S}, valvar) where {F,S}
+    if S == MOI.ZeroOne || S <: MOI.Indicator || S == MOI.Integer
+        return true
+    end
+    cons_list = MOI.get(o, MOI.ListOfConstraintIndices{F,S}())
+    for c_idx in cons_list
+        func = MOI.get(o, MOI.ConstraintFunction(), c_idx)
+        val = MOIU.eval_variables(valvar, func)
+        set = MOI.get(o, MOI.ConstraintSet(), c_idx)
+       # @debug("Constraint: $(F)-$(S) $(func) = $(val) in $(set)")
+        dist = MOD.distance_to_set(MOD.DefaultDistance(), val, set)
+        scip_tol = 1e-6
+        if o isa SCIP.Optimizer
+            scip_tol = MOI.get(o, MOI.RawOptimizerAttribute("numerics/feastol"))
+        end
+        if dist > 5000.0 * scip_tol
+            @debug("Constraint: $(F)-$(S) $(func) = $(val) in $(set)")
+            @debug("Distance to set: $(dist)")
+            return false
+        end
+    end
+    return true
+end
+
+"""
+Define a copy function for strong branching
+"""
+function Base.copy(blmo::MathOptBLMO)
+    return MathOptBLMO(blmo.o, blmo.use_modify)
+end
+
+"""
+Read global bounds from the problem
+"""
+function build_global_bounds(blmo::MathOptBLMO)
+    global_bounds = Boscia.IntegerBounds()
+    for idx in integer_variables
+        for ST in (MOI.LessThan{Float64}, MOI.GreaterThan{Float64})
+            cidx = MOI.ConstraintIndex{MOI.VariableIndex,ST}(idx)
+            # Variable constraints to not have to be explicitly given, see Buchheim example
+            if MOI.is_valid(blmo.o, cidx)
+                s = MOI.get(blmo.o, MOI.ConstraintSet(), cidx)
+                push!(global_bounds, (idx, s))
+            end
+        end
+        cidx = MOI.ConstraintIndex{MOI.VariableIndex,MOI.Interval{Float64}}(idx)
+        if MOI.is_valid(blmo.o, cidx)
+            x = MOI.VariableIndex(idx)
+            s = MOI.get(blmo.o, MOI.ConstraintSet(), cidx)
+            MOI.delete(blmo.o, cidx)
+            MOI.add_constraint(blmo.o, x, MOI.GreaterThan(s.lower))
+            MOI.add_constraint(blmo.o, x, MOI.LessThan(s.upper))
+            push!(global_bounds, (idx, MOI.GreaterThan(s.lower)))
+            push!(global_bounds, (idx, MOI.LessThan(s.upper)))
+        end
+        @assert !MOI.is_valid(lmo.o, cidx)
+    end 
+    return global_bounds
+end
+
+"""
+Add explicit bounds for binary variables.
+"""
+function explicit_bounds_binary_var(blmo::MathOptBLMO, global_bounds::IntegerBounds, binary_variables)
+    # adding binary bounds explicitly
+    for idx in binary_variables
+        cidx = MOI.ConstraintIndex{MOI.VariableIndex,MOI.LessThan{Float64}}(idx)
+        if !MOI.is_valid(blmo.o, cidx)
+            MOI.add_constraint(blmo.o, MOI.VariableIndex(idx), MOI.LessThan(1.0))
+        end
+        @assert MOI.is_valid(blmo.o, cidx)
+        cidx = MOI.ConstraintIndex{MOI.VariableIndex,MOI.GreaterThan{Float64}}(idx)
+        if !MOI.is_valid(blmo.o, cidx)
+            MOI.add_constraint(blmo.o, MOI.VariableIndex(idx), MOI.GreaterThan(0.0))
+        end
+        global_bounds[idx, :greaterthan] = MOI.GreaterThan(0.0)
+        global_bounds[idx, :lessthan] = MOI.LessThan(1.0)
+    end 
+end
+
 
 ##################### Optional to implement ################
 
@@ -211,48 +342,6 @@ function get_BLMO_solve_data(blmo::MathOptBLMO)
     return opt_times, numberofnodes, simplex_iterations
 end
 
-"""
-Is a given point v linear feasible for the model?
-"""
-function is_linear_feasible(blmo::MathOptBLMO)
-    return is_linear_feasible(blmo.o)
-end
-function is_linear_feasible(o::MOI.ModelLike, v::AbstractVector)
-    valvar(f) = v[f.value]
-    for (F, S) in MOI.get(o, MOI.ListOfConstraintTypesPresent())
-        isfeasible = is_linear_feasible_subroutine(o, F, S, valvar)
-        if !isfeasible
-            return false
-        end
-    end
-    # satisfies all constraints
-    return true
-end
-# function barrier for performance
-function is_linear_feasible_subroutine(o::MOI.ModelLike, ::Type{F}, ::Type{S}, valvar) where {F,S}
-    if S == MOI.ZeroOne || S <: MOI.Indicator || S == MOI.Integer
-        return true
-    end
-    cons_list = MOI.get(o, MOI.ListOfConstraintIndices{F,S}())
-    for c_idx in cons_list
-        func = MOI.get(o, MOI.ConstraintFunction(), c_idx)
-        val = MOIU.eval_variables(valvar, func)
-        set = MOI.get(o, MOI.ConstraintSet(), c_idx)
-       # @debug("Constraint: $(F)-$(S) $(func) = $(val) in $(set)")
-        dist = MOD.distance_to_set(MOD.DefaultDistance(), val, set)
-        scip_tol = 1e-6
-        if o isa SCIP.Optimizer
-            scip_tol = MOI.get(o, MOI.RawOptimizerAttribute("numerics/feastol"))
-        end
-        if dist > 5000.0 * scip_tol
-            @debug("Constraint: $(F)-$(S) $(func) = $(val) in $(set)")
-            @debug("Distance to set: $(dist)")
-            return false
-        end
-    end
-    return true
-end
-
 """
 Is a given point v indicator feasible, i.e. meets the indicator constraints? If applicable.
 """
@@ -305,3 +394,177 @@ end
 function get_tol(o::MOI.AbstractOptimizer)
     return 1e-06
 end
+
+"""
+Find best solution from the solving process.
+"""
+function find_best_solution(f::Function, blmo::MathOptBLMO, vars, domain_oracle)
+    return  find_best_solution(f, blmo.o, vars, domain_oracle)
+end
+
+"""
+List of all variable pointers. Depends on how you save your variables internally.
+
+Is used in `find_best_solution`.
+"""
+function get_variables_pointers(blmo::BoundedLinearMinimizationOracle, tree)
+    return [MOI.VariableIndex(var) for var in 1:tree.root.problem.nvars]
+end
+
+"""
+Deal with infeasible vertex if necessary, e.g. check what caused it etc.
+"""
+function check_infeasible_vertex(blmo::MathOptBLMO, tree)
+    node = tree.nodes[tree.root.current_node_id[]]
+    node_bounds = node.local_bounds
+    for list in (node_bounds.lower_bounds, node_bounds.upper_bounds)
+        for (idx, set) in list
+            c_idx =  MOI.ConstraintIndex{MOI.VariableIndex, typeof(set)}(idx)
+            @assert MOI.is_valid(state.tlmo.blmo.o, c_idx)
+            set2 = MOI.get(state.tlmo.blmo.o, MOI.ConstraintSet(), c_idx)
+            if !(set == set2)
+                MOI.set(tlmo.blmo.o, MOI.ConstraintSet(), c_idx, set)
+                set3 = MOI.get(tlmo.blmo.o, MOI.ConstraintSet(), c_idx)
+                @assert (set3 == set) "$((idx, set3, set))"
+            end
+        end
+    end
+end
+
+"""
+Behavior for strong branching.
+"""
+function Bonobo.get_branching_variable(
+    tree::Bonobo.BnBTree,
+    branching::PartialStrongBranching{MathOptBLMO},
+    node::Bonobo.AbstractNode,
+)
+    xrel = Bonobo.get_relaxed_values(tree, node)
+    max_lowerbound = -Inf
+    max_idx = -1
+    # copy problem and remove integer constraints
+    filtered_src = MOI.Utilities.ModelFilter(tree.root.problem.lmo.lmo.o) do item
+        if item isa Tuple
+            (_, S) = item
+            if S <: Union{MOI.Indicator,MOI.Integer,MOI.ZeroOne}
+                return false
+            end
+        end
+        return !(item isa MOI.ConstraintIndex{<:Any,<:Union{MOI.ZeroOne,MOI.Integer,MOI.Indicator}})
+    end
+    index_map = MOI.copy_to(branching.optimizer, filtered_src)
+    # sanity check, otherwise the functions need permuted indices
+    for (v1, v2) in index_map
+        if v1 isa MOI.VariableIndex
+            @assert v1 == v2
+        end
+    end
+    relaxed_lmo = FrankWolfe.MathOptLMO(branching.optimizer)
+    @assert !isempty(node.active_set)
+    active_set = copy(node.active_set)
+    empty!(active_set)
+    num_frac = 0
+    for idx in Bonobo.get_branching_indices(tree.root)
+        if !isapprox(xrel[idx], round(xrel[idx]), atol=tree.options.atol, rtol=tree.options.rtol)
+            # left node: x_i <=  floor(̂x_i)
+            fxi = floor(xrel[idx])
+            # create LMO
+            boundsLeft = copy(node.local_bounds)
+            if haskey(boundsLeft.upper_bounds, idx)
+                delete!(boundsLeft.upper_bounds, idx)
+            end
+            push!(boundsLeft.upper_bounds, (idx => MOI.LessThan(fxi)))
+            build_LMO(
+                relaxed_lmo,
+                tree.root.problem.integer_variable_bounds,
+                boundsLeft,
+                Bonobo.get_branching_indices(tree.root),
+            )
+            MOI.optimize!(relaxed_lmo.o)
+            #MOI.set(relaxed_lmo.o, MOI.Silent(), false)
+            if MOI.get(relaxed_lmo.o, MOI.TerminationStatus()) == MOI.OPTIMAL
+                empty!(active_set)
+                for (λ, v) in node.active_set
+                    if v[idx] <= xrel[idx]
+                        push!(active_set, ((λ, v)))
+                    end
+                end
+                @assert !isempty(active_set)
+                FrankWolfe.active_set_renormalize!(active_set)
+                _, _, primal_relaxed, dual_gap_relaxed, _ =
+                    FrankWolfe.blended_pairwise_conditional_gradient(
+                        tree.root.problem.f,
+                        tree.root.problem.g,
+                        relaxed_lmo,
+                        active_set,
+                        verbose=false,
+                        epsilon=branching.solving_epsilon,
+                        max_iteration=branching.max_iteration,
+                    )
+                left_relaxed = primal_relaxed - dual_gap_relaxed
+            else
+                @debug "Left non-optimal status $(MOI.get(relaxed_lmo.o, MOI.TerminationStatus()))"
+                left_relaxed = Inf
+            end
+            #right node: x_i >=  floor(̂x_i)
+            cxi = ceil(xrel[idx])
+            boundsRight = copy(node.local_bounds)
+            if haskey(boundsRight.lower_bounds, idx)
+                delete!(boundsRight.lower_bounds, idx)
+            end
+            push!(boundsRight.lower_bounds, (idx => MOI.GreaterThan(cxi)))
+            build_LMO(
+                relaxed_lmo,
+                tree.root.problem.integer_variable_bounds,
+                boundsRight,
+                Bonobo.get_branching_indices(tree.root),
+            )
+            MOI.optimize!(relaxed_lmo.o)
+            if MOI.get(relaxed_lmo.o, MOI.TerminationStatus()) == MOI.OPTIMAL
+                empty!(active_set)
+                for (λ, v) in node.active_set
+                    if v[idx] >= xrel[idx]
+                        push!(active_set, (λ, v))
+                    end
+                end
+                if isempty(active_set)
+                    @show xrel[idx]
+                    @show length(active_set)
+                    @info [active_set.atoms[idx] for idx in eachindex(active_set)]
+                    error("Empty active set, unreachable")
+                end
+                FrankWolfe.active_set_renormalize!(active_set)
+                _, _, primal_relaxed, dual_gap_relaxed, _ =
+                    FrankWolfe.blended_pairwise_conditional_gradient(
+                        tree.root.problem.f,
+                        tree.root.problem.g,
+                        relaxed_lmo,
+                        active_set,
+                        verbose=false,
+                        epsilon=branching.solving_epsilon,
+                        max_iteration=branching.max_iteration,
+                    )
+                right_relaxed = primal_relaxed - dual_gap_relaxed
+            else
+                @debug "Right non-optimal status $(MOI.get(relaxed_lmo.o, MOI.TerminationStatus()))"
+                right_relaxed = Inf
+            end
+            # lowest lower bound on the two branches
+            lowerbound_increase = min(left_relaxed, right_relaxed)
+            if lowerbound_increase > max_lowerbound
+                max_lowerbound = lowerbound_increase
+                max_idx = idx
+            end
+            num_frac += 1
+        end
+    end
+    @debug "strong branching: index $max_idx, lower bound $max_lowerbound"
+    if max_idx <= 0 && num_frac != 0
+        error("Infeasible node! Please check constraints! node lb: $(node.lb)")
+        max_idx = -1
+    end
+    if max_idx <= 0
+        max_idx = -1
+    end
+    return max_idx
+end