Commit ⋅ joaquimg/BilevelJuMP.jl

@@ -10,43 +10,37 @@

Loading

const LT = MOI.LessThan
const ET = MOI.EqualTo

const SCALAR_SETS = Union{
    MOI.GreaterThan{Float64},
    MOI.LessThan{Float64},
    MOI.EqualTo{Float64},
}
const SCALAR_SETS =
    Union{MOI.GreaterThan{Float64},MOI.LessThan{Float64},MOI.EqualTo{Float64}}

const VECTOR_SETS = Union{
    MOI.SecondOrderCone,
    MOI.RotatedSecondOrderCone,
}
const VECTOR_SETS = Union{MOI.SecondOrderCone,MOI.RotatedSecondOrderCone}

# dual variable info
mutable struct BilevelConstraintInfo{T<:Union{Float64, Vector{Float64}}}
mutable struct BilevelConstraintInfo{T<:Union{Float64,Vector{Float64}}}
    level::Level
    start::T
    upper::T
    lower::T
    function BilevelConstraintInfo{Float64}(level)
        new(level, NaN, NaN, NaN)
        return new(level, NaN, NaN, NaN)
    end
    function BilevelConstraintInfo{Vector{Float64}}(level, N::Integer)
        new(level, fill(NaN, N), fill(NaN, N), fill(NaN, N))
        return new(level, fill(NaN, N), fill(NaN, N), fill(NaN, N))
    end
end

mutable struct BilevelVariableInfo{T<:Union{Float64, Vector{Float64}}}
mutable struct BilevelVariableInfo{T<:Union{Float64,Vector{Float64}}}
    level::Level
    upper::T
    lower::T
    function BilevelVariableInfo(level)
        new{Float64}(level, NaN, NaN)
        return new{Float64}(level, NaN, NaN)
    end
    function BilevelVariableInfo(level, N::Integer)
        new{Vector{Float64}}(level, fill(NaN, N), fill(NaN, N))
        return new{Vector{Float64}}(level, fill(NaN, N), fill(NaN, N))
    end
end
function BilevelVariableInfo(_info::BilevelConstraintInfo{T}) where T
function BilevelVariableInfo(_info::BilevelConstraintInfo{T}) where {T}
    if isa(_info.upper, Number)
        info = BilevelVariableInfo(DUAL_OF_LOWER)
        info.lower = _info.lower

@@ -60,20 +54,19 @@

Loading

end

struct Complement#{M1 <: MOI.ModelLike, M2 <: MOI.ModelLike, F, S}
    is_vec
    is_vec::Any
    # primal::M1
    constraint
    func_w_cte#::F
    set_w_zero#::S
    constraint::Any
    func_w_cte::Any#::F
    set_w_zero::Any#::S
    # dual::M2
    variable#::VI
    variable::Any#::VI
    # var_set#::S2
end

abstract type AbstractBilevelSolverMode{T} end

mutable struct NoMode{T} <: AbstractBilevelSolverMode{T}
end
mutable struct NoMode{T} <: AbstractBilevelSolverMode{T} end

mutable struct SOS1Mode{T} <: AbstractBilevelSolverMode{T}
    function SOS1Mode()

@@ -83,7 +76,7 @@

Loading


mutable struct ComplementMode{T} <: AbstractBilevelSolverMode{T}
    with_slack::Bool
    function ComplementMode(;with_slack = false)
    function ComplementMode(; with_slack = false)
        return new{Float64}(with_slack)
    end
end

@@ -92,12 +85,12 @@

Loading

    epsilon::T
    with_slack::Bool
    aggregation_group::Int # only useful in mixed mode
    function_cache::Union{Nothing, MOI.AbstractScalarFunction}
    function_cache::Union{Nothing,MOI.AbstractScalarFunction}
    function ProductMode(
        eps::T=zero(Float64);
        eps::T = zero(Float64);
        with_slack::Bool = false,
        aggregation_group = nothing
    ) where T<:Float64 # Real
        aggregation_group = nothing,
    ) where {T<:Float64} # Real
        @assert aggregation_group === nothing || aggregation_group >= 1
        # nothing means individualized
        # positive integers point to their numbers

@@ -106,7 +99,7 @@

Loading

            with_slack,
            aggregation_group === nothing ? 0 : aggregation_group,
            nothing,
            )
        )
    end
end


@@ -121,17 +114,17 @@

Loading


struct ComplementBoundCache
    # internal usage
    upper::Dict{VI, BilevelVariableInfo}
    lower::Dict{VI, BilevelVariableInfo}
    ldual::Dict{CI, BilevelConstraintInfo}
    upper::Dict{VI,BilevelVariableInfo}
    lower::Dict{VI,BilevelVariableInfo}
    ldual::Dict{CI,BilevelConstraintInfo}
    # full map
    map::Dict{VI, BilevelVariableInfo}
    map::Dict{VI,BilevelVariableInfo}
    function ComplementBoundCache()
        return new(
            Dict{VI, BilevelVariableInfo}(),
            Dict{VI, BilevelVariableInfo}(),
            Dict{CI, BilevelConstraintInfo}(),
            Dict{VI, BilevelVariableInfo}(),
            Dict{VI,BilevelVariableInfo}(),
            Dict{VI,BilevelVariableInfo}(),
            Dict{CI,BilevelConstraintInfo}(),
            Dict{VI,BilevelVariableInfo}(),
        )
    end
end

@@ -141,30 +134,33 @@

Loading

    primal_big_M::Float64
    dual_big_M::Float64
    cache::ComplementBoundCache
    function FortunyAmatMcCarlMode(;with_slack = false,
        primal_big_M = Inf, dual_big_M = Inf)
    function FortunyAmatMcCarlMode(;
        with_slack = false,
        primal_big_M = Inf,
        dual_big_M = Inf,
    )
        return new{Float64}(
            with_slack,
            primal_big_M,
            dual_big_M,
            ComplementBoundCache()
            ComplementBoundCache(),
        )
    end
end

mutable struct MixedMode{T} <: AbstractBilevelSolverMode{T}
    default::AbstractBilevelSolverMode{T}
    constraint_mode_map_c::Dict{CI, AbstractBilevelSolverMode{T}}
    constraint_mode_map_v::Dict{VI, AbstractBilevelSolverMode{T}}
    constraint_mode_map_c::Dict{CI,AbstractBilevelSolverMode{T}}
    constraint_mode_map_v::Dict{VI,AbstractBilevelSolverMode{T}}
    cache::ComplementBoundCache
    function_cache::Dict{Int,MOI.AbstractScalarFunction}
    function MixedMode(;default = SOS1Mode())
    function MixedMode(; default = SOS1Mode())
        return new{Float64}(
            default,
            Dict{CI, AbstractBilevelSolverMode{Float64}}(),
            Dict{VI, AbstractBilevelSolverMode{Float64}}(),
            Dict{CI,AbstractBilevelSolverMode{Float64}}(),
            Dict{VI,AbstractBilevelSolverMode{Float64}}(),
            ComplementBoundCache(),
            Dict{Int,MOI.AbstractScalarFunction}()
            Dict{Int,MOI.AbstractScalarFunction}(),
        )
    end
end

@@ -201,32 +197,62 @@

Loading

    return nothing
end

function build_full_map!(mode,
    upper_idxmap, lower_idxmap, lower_dual_idxmap, lower_primal_dual_map)
function build_full_map!(
    mode,
    upper_idxmap,
    lower_idxmap,
    lower_dual_idxmap,
    lower_primal_dual_map,
)
    return nothing
end
function build_full_map!(mode::FortunyAmatMcCarlMode,
        upper_idxmap, lower_idxmap, lower_dual_idxmap, lower_primal_dual_map)
    _build_bound_map!(mode.cache,
        upper_idxmap, lower_idxmap, lower_dual_idxmap, lower_primal_dual_map)
function build_full_map!(
    mode::FortunyAmatMcCarlMode,
    upper_idxmap,
    lower_idxmap,
    lower_dual_idxmap,
    lower_primal_dual_map,
)
    _build_bound_map!(
        mode.cache,
        upper_idxmap,
        lower_idxmap,
        lower_dual_idxmap,
        lower_primal_dual_map,
    )
    return nothing
end
function build_full_map!(mode::MixedMode,
    upper_idxmap, lower_idxmap, lower_dual_idxmap, lower_primal_dual_map)
_build_bound_map!(mode.cache,
    upper_idxmap, lower_idxmap, lower_dual_idxmap, lower_primal_dual_map)
return nothing
function build_full_map!(
    mode::MixedMode,
    upper_idxmap,
    lower_idxmap,
    lower_dual_idxmap,
    lower_primal_dual_map,
)
    _build_bound_map!(
        mode.cache,
        upper_idxmap,
        lower_idxmap,
        lower_dual_idxmap,
        lower_primal_dual_map,
    )
    return nothing
end
function _build_bound_map!(mode::ComplementBoundCache,
    upper_idxmap, lower_idxmap, lower_dual_idxmap, lower_primal_dual_map)
function _build_bound_map!(
    mode::ComplementBoundCache,
    upper_idxmap,
    lower_idxmap,
    lower_dual_idxmap,
    lower_primal_dual_map,
)
    empty!(mode.map)
    for (k,v) in mode.upper
    for (k, v) in mode.upper
        mode.map[upper_idxmap[k]] = v
    end
    for (k,v) in mode.lower
    for (k, v) in mode.lower
        mode.map[lower_idxmap[k]] = v
    end
    for (k,v) in mode.ldual
    for (k, v) in mode.ldual
        vec = lower_primal_dual_map.primal_con_dual_var[k]#[1] # TODO check this scalar
        for var in vec
            mode.map[lower_dual_idxmap[var]] = BilevelVariableInfo(v)

@@ -238,22 +264,30 @@

Loading

mutable struct StrongDualityMode{T} <: AbstractBilevelSolverMode{T}
    inequality::Bool
    epsilon::T
    function StrongDualityMode(eps::T=zero(Float64); inequality = true) where T
    function StrongDualityMode(
        eps::T = zero(Float64);
        inequality = true,
    ) where {T}
        return new{T}(inequality, eps)
    end
end

ignore_dual_objective(::AbstractBilevelSolverMode{T}) where T = true
ignore_dual_objective(::StrongDualityMode{T}) where T = false
ignore_dual_objective(::AbstractBilevelSolverMode{T}) where {T} = true
ignore_dual_objective(::StrongDualityMode{T}) where {T} = false

function accept_vector_set(mode::AbstractBilevelSolverMode{T}, con::Complement) where T
function accept_vector_set(
    mode::AbstractBilevelSolverMode{T},
    con::Complement,
) where {T}
    if con.is_vec
        error("Set $(typeof(con.set_w_zero)) is not accepted when solution method is $(typeof(mode))")
        error(
            "Set $(typeof(con.set_w_zero)) is not accepted when solution method is $(typeof(mode))",
        )
    end
    return nothing
end
accept_vector_set(::ProductMode{T}, ::Complement) where T = nothing
accept_vector_set(::MixedMode{T}, ::Complement) where T = nothing
accept_vector_set(::ProductMode{T}, ::Complement) where {T} = nothing
accept_vector_set(::MixedMode{T}, ::Complement) where {T} = nothing

function get_canonical_complements(primal_model, primal_dual_map)
    map = primal_dual_map.primal_con_dual_var

@@ -264,8 +298,11 @@

Loading

    end
    return out
end
function get_canonical_complement(primal_model, map,
    ci::CI{F,S}) where {F, S<:VECTOR_SETS}
function get_canonical_complement(
    primal_model,
    map,
    ci::CI{F,S},
) where {F,S<:VECTOR_SETS}
    T = Float64
    func = MOI.copy(MOI.get(primal_model, MOI.ConstraintFunction(), ci))::F
    set = MOI.copy(MOI.get(primal_model, MOI.ConstraintSet(), ci))::S

@@ -279,12 +316,16 @@

Loading

    con = Complement(true, ci, func, set_with_zero(set), map[ci])
    return con
end
function get_canonical_complement(primal_model, map,
    ci::CI{F,S}) where {F, S<:SCALAR_SETS}
function get_canonical_complement(
    primal_model,
    map,
    ci::CI{F,S},
) where {F,S<:SCALAR_SETS}
    T = Float64
    func = MOI.copy(MOI.get(primal_model, MOI.ConstraintFunction(), ci))::F
    set = MOI.copy(MOI.get(primal_model, MOI.ConstraintSet(), ci))::S
    constant = Dualization.set_dot(1, set, T) *
    constant =
        Dualization.set_dot(1, set, T) *
        Dualization.get_scalar_term(primal_model, ci)[]
    if F == MOI.VariableIndex
        func = MOIU.operate(+, T, func, constant)

@@ -311,19 +352,23 @@

Loading

    mode,
    upper_var_to_lower_ctr::Dict{VI,CI} = Dict{VI,CI}();
    copy_names::Bool = false,
    pass_start::Bool = false
    )
    pass_start::Bool = false,
)

    # Start with an empty problem
    moi_mode = MOIU.AUTOMATIC
    m = MOIU.CachingOptimizer(MOIU.UniversalFallback(MOIU.Model{Float64}()), moi_mode)
    m = MOIU.CachingOptimizer(
        MOIU.UniversalFallback(MOIU.Model{Float64}()),
        moi_mode,
    )

    #=
        Create Lower DUAL level model
    =#
    # dualize the second level
    dual_problem = Dualization.dualize(lower,
        dual_names = DualNames("dual_","dual_"),
    dual_problem = Dualization.dualize(
        lower;
        dual_names = DualNames("dual_", "dual_"),
        variable_parameters = upper_variables,
        ignore_objective = ignore_dual_objective(mode),
        consider_constrained_variables = false,

@@ -354,7 +399,8 @@

Loading

        # get primal obj
        type_primal_obj = MOI.get(lower, MOI.ObjectiveFunctionType())
        @assert type_primal_obj !== nothing
        lower_primal_obj = MOI.get(lower, MOI.ObjectiveFunction{type_primal_obj}())
        lower_primal_obj =
            MOI.get(lower, MOI.ObjectiveFunction{type_primal_obj}())
        # deepcopy and delete dual obj
        # MOI.set(lower, MOI.ObjectiveFunction{MOI.ScalarAffineFunction{Float64}}(), MOI.ScalarAffineFunction(MOI.ScalarAffineTerm{Float64}[], 0.0))
    end

@@ -366,7 +412,7 @@

Loading

    end

    # append the second level primal
    append_to(m, lower, lower_idxmap, allow_single_bounds = true)
    append_to(m, lower, lower_idxmap; allow_single_bounds = true)
    if copy_names
        pass_names(m, lower, lower_idxmap)
    end

@@ -380,7 +426,8 @@

Loading

        # get dual obj
        tp_dual_obj = MOI.get(lower_dual, MOI.ObjectiveFunctionType())
        @assert tp_dual_obj !== nothing
        lower_dual_obj = MOI.get(lower_dual, MOI.ObjectiveFunction{tp_dual_obj}())
        lower_dual_obj =
            MOI.get(lower_dual, MOI.ObjectiveFunction{tp_dual_obj}())
        # delete dual obj
        # MOI.set(lower_dual, MOI.ObjectiveFunction{MOI.ScalarAffineFunction{Float64}}(), MOI.ScalarAffineFunction(MOI.ScalarAffineTerm{Float64}[], 0.0))
    end

@@ -389,12 +436,16 @@

Loading

    lower_dual_idxmap = MOIU.IndexMap()
    # 1) for QP's there are dual variable that are linked to:
    # 1.1) primal variables
    for (lower_primal_var_key, lower_dual_quad_slack_val) in lower_primal_dual_map.primal_var_dual_quad_slack
        lower_dual_idxmap[lower_dual_quad_slack_val] = lower_idxmap[lower_primal_var_key]
    for (lower_primal_var_key, lower_dual_quad_slack_val) in
        lower_primal_dual_map.primal_var_dual_quad_slack
        lower_dual_idxmap[lower_dual_quad_slack_val] =
            lower_idxmap[lower_primal_var_key]
    end
    # 1.2) and to upper level variable which are lower level parameters
    for (lower_primal_param_key, lower_dual_param_val) in lower_primal_dual_map.primal_parameter
        lower_dual_idxmap[lower_dual_param_val] = lower_idxmap[lower_primal_param_key]
    for (lower_primal_param_key, lower_dual_param_val) in
        lower_primal_dual_map.primal_parameter
        lower_dual_idxmap[lower_dual_param_val] =
            lower_idxmap[lower_primal_param_key]
    end
    # 2) Dual variables might appear in the upper level
    for (upper_var, lower_con) in upper_var_to_lower_ctr

@@ -413,8 +464,13 @@

Loading

    =#

    # build map bound map for FortunyAmatMcCarlMode
    build_full_map!(mode,
        upper_idxmap, lower_idxmap, lower_dual_idxmap, lower_primal_dual_map)
    build_full_map!(
        mode,
        upper_idxmap,
        lower_idxmap,
        lower_dual_idxmap,
        lower_primal_dual_map,
    )

    if ignore_dual_objective(mode)
        # complementary slackness

@@ -422,25 +478,48 @@

Loading

        for comp in comps
            if !is_equality(comp.set_w_zero)
                accept_vector_set(mode, comp)
                add_complement(mode, m, comp,
                    lower_idxmap, lower_dual_idxmap, copy_names, pass_start)
                add_complement(
                    mode,
                    m,
                    comp,
                    lower_idxmap,
                    lower_dual_idxmap,
                    copy_names,
                    pass_start,
                )
            else
                # feasible equality constraints always satisfy complementarity
            end
        end
    else # strong duality
        add_strong_duality(mode, m, lower_primal_obj, lower_dual_obj, lower_idxmap, lower_dual_idxmap)
        add_strong_duality(
            mode,
            m,
            lower_primal_obj,
            lower_dual_obj,
            lower_idxmap,
            lower_dual_idxmap,
        )
    end
    add_aggregate_constraints(m, mode, copy_names)

    return m, upper_idxmap, lower_idxmap, lower_primal_dual_map, lower_dual_idxmap
    return m,
    upper_idxmap,
    lower_idxmap,
    lower_primal_dual_map,
    lower_dual_idxmap
end

function add_strong_duality(mode::StrongDualityMode{T}, m, primal_obj, dual_obj,
    idxmap_primal, idxmap_dual) where T

function add_strong_duality(
    mode::StrongDualityMode{T},
    m,
    primal_obj,
    dual_obj,
    idxmap_primal,
    idxmap_dual,
) where {T}
    primal = MOIU.map_indices.(Ref(idxmap_primal), primal_obj)
    dual   = MOIU.map_indices.(Ref(idxmap_dual), dual_obj)
    dual = MOIU.map_indices.(Ref(idxmap_dual), dual_obj)

    func = MOIU.operate(-, T, primal, dual)


@@ -450,11 +529,16 @@

Loading

        return CI[c]
    else
        func_up = MOIU.operate(-, T, func, mode.epsilon)
        c_up = MOIU.normalize_and_add_constraint(m, func_up, MOI.LessThan(zero(T)))
        c_up =
            MOIU.normalize_and_add_constraint(m, func_up, MOI.LessThan(zero(T)))
        MOI.set(m, MOI.ConstraintName(), c_up, "lower_strong_duality_up")

        func_lo = MOIU.operate(+, T, func, mode.epsilon)
        c_lo = MOIU.normalize_and_add_constraint(m, func_lo, MOI.GreaterThan(zero(T)))
        c_lo = MOIU.normalize_and_add_constraint(
            m,
            func_lo,
            MOI.GreaterThan(zero(T)),
        )
        MOI.set(m, MOI.ConstraintName(), c_lo, "lower_strong_duality_lo")

        return CI[c_up, c_lo]

@@ -464,18 +548,22 @@

Loading

add_aggregate_constraints(m, mode, copy_names) = nothing

function _add_aggregate_constraints(
    m, func::F, eps, idx, copy_names
) where F<:MOI.ScalarQuadraticFunction{T} where T
    m,
    func::F,
    eps,
    idx,
    copy_names,
) where {F<:MOI.ScalarQuadraticFunction{T}} where {T}
    prod_f1 = MOIU.operate(-, T, func, eps)
    c1 = MOIU.normalize_and_add_constraint(m,
        prod_f1,
        MOI.LessThan{T}(0.0))
    c1 = MOIU.normalize_and_add_constraint(m, prod_f1, MOI.LessThan{T}(0.0))
    # appush!(out_ctr, c1)
    if true # comp.is_vec
        prod_f2 = MOIU.operate(+, T, func, eps)
        c2 = MOIU.normalize_and_add_constraint(m,
        c2 = MOIU.normalize_and_add_constraint(
            m,
            prod_f2,
            MOI.GreaterThan{T}(0.0))
            MOI.GreaterThan{T}(0.0),
        )
        # appush!(out_ctr, c2)
    end
    if copy_names

@@ -491,18 +579,23 @@

Loading

        return nothing
    end
    _add_aggregate_constraints(
        m, mode.function_cache, mode.epsilon, 0, copy_names)
        m,
        mode.function_cache,
        mode.epsilon,
        0,
        copy_names,
    )
    return nothing
end
function add_aggregate_constraints(m, mode::MixedMode{T}, copy_names) where T
function add_aggregate_constraints(m, mode::MixedMode{T}, copy_names) where {T}
    if isempty(mode.function_cache)
        return nothing
    end
    eps = Dict{Int, T}()
    eps = Dict{Int,T}()
    for list in (
        mode.constraint_mode_map_c,
        mode.constraint_mode_map_v,
        Dict(nothing=>mode.default)
        Dict(nothing => mode.default),
    )
        for md in values(list)
            val, idx = _get_eps_idx(md)

@@ -514,13 +607,12 @@

Loading

        end
    end
    for (idx, func) in mode.function_cache
        _add_aggregate_constraints(
            m, func, eps[idx], idx, copy_names)
        _add_aggregate_constraints(m, func, eps[idx], idx, copy_names)
    end
    return nothing
end

function _get_eps_idx(mode::ProductMode{T}) where T
function _get_eps_idx(mode::ProductMode{T}) where {T}
    idx = mode.aggregation_group
    eps = mode.epsilon
    return eps, idx

@@ -529,22 +621,43 @@

Loading

    return 0.0, 0
end

function add_complement(mode::MixedMode{T}, m, comp::Complement,
        idxmap_primal, idxmap_dual, copy_names::Bool, pass_start::Bool) where T
function add_complement(
    mode::MixedMode{T},
    m,
    comp::Complement,
    idxmap_primal,
    idxmap_dual,
    copy_names::Bool,
    pass_start::Bool,
) where {T}
    _mode = get_mode(mode, comp.constraint, idxmap_primal)
    accept_vector_set(_mode, comp)
    ret = add_complement(_mode, m, comp,
        idxmap_primal, idxmap_dual, copy_names, pass_start)
    ret = add_complement(
        _mode,
        m,
        comp,
        idxmap_primal,
        idxmap_dual,
        copy_names,
        pass_start,
    )
    add_function_to_cache(mode, _mode)
    return ret
end
add_function_to_cache(mode::MixedMode{T}, _mode) where T = nothing
function add_function_to_cache(mode::MixedMode{T}, _mode::ProductMode{T}) where T
add_function_to_cache(mode::MixedMode{T}, _mode) where {T} = nothing
function add_function_to_cache(
    mode::MixedMode{T},
    _mode::ProductMode{T},
) where {T}
    idx = _mode.aggregation_group
    if _mode.function_cache !== nothing && idx > 0
        if haskey(mode.function_cache, idx)
            mode.function_cache[idx] = MOIU.operate(+, T,
                mode.function_cache[idx], _mode.function_cache)
            mode.function_cache[idx] = MOIU.operate(
                +,
                T,
                mode.function_cache[idx],
                _mode.function_cache,
            )
        else
            mode.function_cache[idx] = _mode.function_cache
        end

@@ -553,10 +666,14 @@

Loading

    return nothing
end

function get_mode(mode::MixedMode{T}, ci::CI{F,S}, map) where {
function get_mode(
    mode::MixedMode{T},
    ci::CI{F,S},
    map,
) where {
    T,
    F<:MOI.VariableIndex,
    S<:Union{MOI.EqualTo{T}, MOI.LessThan{T}, MOI.GreaterThan{T}}
    S<:Union{MOI.EqualTo{T},MOI.LessThan{T},MOI.GreaterThan{T}},
}
    # key = map[VI(ci.value)]
    key = VI(ci.value)

@@ -575,8 +692,15 @@

Loading

    end
end

function add_complement(mode::ComplementMode{T}, m, comp::Complement,
    idxmap_primal, idxmap_dual, copy_names, pass_start::Bool) where T
function add_complement(
    mode::ComplementMode{T},
    m,
    comp::Complement,
    idxmap_primal,
    idxmap_dual,
    copy_names,
    pass_start::Bool,
) where {T}
    f = comp.func_w_cte
    s = comp.set_w_zero
    v = comp.variable

@@ -592,19 +716,24 @@

Loading

    if with_slack
        slack, slack_in_set = MOI.add_constrained_variable(m, s)
        new_f = MOIU.operate(-, T, f_dest, slack)
        equality = MOIU.normalize_and_add_constraint(m, new_f, MOI.EqualTo(zero(T)))
        equality =
            MOIU.normalize_and_add_constraint(m, new_f, MOI.EqualTo(zero(T)))

        if pass_start
            val = MOIU.eval_variables(
                x-> nothing_to_nan(MOI.get(m, MOI.VariablePrimalStart(), x)), f_dest)
                x -> nothing_to_nan(MOI.get(m, MOI.VariablePrimalStart(), x)),
                f_dest,
            )
            if !isnan(val)
                MOI.set(m, MOI.VariablePrimalStart(), slack, val)
            end
        end

        c = MOI.add_constraint(m, 
        c = MOI.add_constraint(
            m,
            MOI.VectorOfVariables([slack, dual]),
            MOI.Complements(1))
            MOI.Complements(1),
        )
        if copy_names
            nm = MOI.get(m, MOI.VariableName(), dual)
            MOI.set(m, MOI.VariableName(), slack, "slk_($(nm))")

@@ -620,9 +749,7 @@

Loading

    else
        new_f = MOIU.operate(vcat, T, f_dest, dual)

        c = MOI.add_constraint(m, 
            new_f,
            MOI.Complements(1))
        c = MOI.add_constraint(m, new_f, MOI.Complements(1))

        if copy_names
            nm = MOI.get(m, MOI.VariableName(), dual)

@@ -635,8 +762,15 @@

Loading

    return out_var, out_ctr
end

function add_complement(mode::SOS1Mode{T}, m, comp::Complement,
    idxmap_primal, idxmap_dual, copy_names::Bool, pass_start::Bool) where T
function add_complement(
    mode::SOS1Mode{T},
    m,
    comp::Complement,
    idxmap_primal,
    idxmap_dual,
    copy_names::Bool,
    pass_start::Bool,
) where {T}
    f = comp.func_w_cte
    s = comp.set_w_zero
    v = comp.variable

@@ -651,9 +785,11 @@

Loading

    equality = MOIU.normalize_and_add_constraint(m, new_f, MOI.EqualTo(zero(T)))

    dual = idxmap_dual[v]
    c1 = MOI.add_constraint(m, 
    c1 = MOI.add_constraint(
        m,
        MOI.VectorOfVariables([slack, dual]),
        MOI.SOS1([1.0, 2.0]))
        MOI.SOS1([1.0, 2.0]),
    )

    if copy_names
        nm = MOI.get(m, MOI.VariableName(), dual)

@@ -667,7 +803,7 @@

Loading

end

is_equality(set::S) where {S<:MOI.AbstractSet} = false
is_equality(set::MOI.EqualTo{T}) where T = true
is_equality(set::MOI.EqualTo{T}) where {T} = true
is_equality(set::MOI.Zeros) = true

only_variable_functions(v::MOI.VariableIndex) = v

@@ -684,8 +820,15 @@

Loading

    end
    return nothing
end
function add_complement(mode::ProductMode{T}, m, comp::Complement,
    idxmap_primal, idxmap_dual, copy_names::Bool, pass_start::Bool) where T
function add_complement(
    mode::ProductMode{T},
    m,
    comp::Complement,
    idxmap_primal,
    idxmap_dual,
    copy_names::Bool,
    pass_start::Bool,
) where {T}
    f = comp.func_w_cte
    s = comp.set_w_zero
    v = comp.variable

@@ -696,9 +839,9 @@

Loading

    eps = mode.epsilon
    with_slack = mode.with_slack

    f_dest = MOIU.map_indices(x->idxmap_primal[x], f)
    f_dest = MOIU.map_indices(x -> idxmap_primal[x], f)

    dual = comp.is_vec ? map(x->idxmap_dual[x], v) : idxmap_dual[v]
    dual = comp.is_vec ? map(x -> idxmap_dual[x], v) : idxmap_dual[v]

    if with_slack
        slack, slack_in_set = if comp.is_vec

@@ -708,12 +851,25 @@

Loading

        end
        new_f = MOIU.operate(-, T, f_dest, only_variable_functions(slack))
        if comp.is_vec
            equality = MOIU.normalize_and_add_constraint(m, new_f, MOI.Zeros(length(slack)))
            equality = MOIU.normalize_and_add_constraint(
                m,
                new_f,
                MOI.Zeros(length(slack)),
            )
        else
            equality = MOIU.normalize_and_add_constraint(m, new_f, MOI.EqualTo(zero(T)))
            equality = MOIU.normalize_and_add_constraint(
                m,
                new_f,
                MOI.EqualTo(zero(T)),
            )
        end

        prod_f = MOIU.operate(dot, T, only_variable_functions(slack), only_variable_functions(dual))
        prod_f = MOIU.operate(
            dot,
            T,
            only_variable_functions(slack),
            only_variable_functions(dual),
        )

        appush!(out_var, slack)
        appush!(out_ctr, slack_in_set)

@@ -721,15 +877,19 @@

Loading


        if mode.aggregation_group == 0
            prod_f1 = MOIU.operate(-, T, prod_f, eps)
            c1 = MOIU.normalize_and_add_constraint(m,
            c1 = MOIU.normalize_and_add_constraint(
                m,
                prod_f1,
                MOI.LessThan{Float64}(0.0))
                MOI.LessThan{Float64}(0.0),
            )
            appush!(out_ctr, c1)
            if comp.is_vec
                prod_f2 = MOIU.operate(+, T, prod_f, eps)
                c2 = MOIU.normalize_and_add_constraint(m,
                c2 = MOIU.normalize_and_add_constraint(
                    m,
                    prod_f2,
                    MOI.GreaterThan{Float64}(0.0))
                    MOI.GreaterThan{Float64}(0.0),
                )
                appush!(out_ctr, c2)
            end
        else

@@ -738,7 +898,9 @@

Loading


        if pass_start
            val = MOIU.eval_variables(
                x-> nothing_to_nan(MOI.get(m, MOI.VariablePrimalStart(), x)), f_dest)
                x -> nothing_to_nan(MOI.get(m, MOI.VariablePrimalStart(), x)),
                f_dest,
            )
            if comp.is_vec
                for i in eachindex(val)
                    if !isnan(val[i])

@@ -760,7 +922,12 @@

Loading

            if mode.aggregation_group == 0
                MOI.set(m, MOI.ConstraintName(), c1, "compl_prodWslk_($(nm))")
                if comp.is_vec
                    MOI.set(m, MOI.ConstraintName(), c2, "compl_prodWslk2_($(nm))")
                    MOI.set(
                        m,
                        MOI.ConstraintName(),
                        c2,
                        "compl_prodWslk2_($(nm))",
                    )
                end
            end
        end

@@ -768,15 +935,19 @@

Loading

        new_f = MOIU.operate(dot, T, f_dest, only_variable_functions(dual))
        if mode.aggregation_group == 0
            new_f1 = MOIU.operate(-, T, new_f, eps)
            c1 = MOIU.normalize_and_add_constraint(m, 
            c1 = MOIU.normalize_and_add_constraint(
                m,
                new_f1,
                MOI.LessThan{T}(0.0))
                MOI.LessThan{T}(0.0),
            )
            appush!(out_ctr, c1)
            if comp.is_vec # conic
                new_f2 = MOIU.operate(+, T, new_f, eps)
                c2 = MOIU.normalize_and_add_constraint(m, 
                c2 = MOIU.normalize_and_add_constraint(
                    m,
                    new_f2,
                    MOI.GreaterThan{T}(0.0))
                    MOI.GreaterThan{T}(0.0),
                )
                appush!(out_ctr, c2)
            end
            if copy_names

@@ -797,8 +968,15 @@

Loading

    return out_var, out_ctr
end

function add_complement(mode::IndicatorMode{T}, m, comp::Complement,
    idxmap_primal, idxmap_dual, copy_names::Bool, pass_start::Bool) where T
function add_complement(
    mode::IndicatorMode{T},
    m,
    comp::Complement,
    idxmap_primal,
    idxmap_dual,
    copy_names::Bool,
    pass_start::Bool,
) where {T}
    f = comp.func_w_cte
    s = comp.set_w_zero
    v = comp.variable

@@ -808,12 +986,14 @@

Loading

    is_tight = false
    has_start = false

    f_dest = MOIU.map_indices(x->idxmap_primal[x], f)
    f_dest = MOIU.map_indices(x -> idxmap_primal[x], f)

    dual = idxmap_dual[v]

    if comp.is_vec
        error("Vector constraint is (currently) not supported by indicator mode")
        error(
            "Vector constraint is (currently) not supported by indicator mode",
        )
    end

    if copy_names

@@ -854,7 +1034,9 @@

Loading


    if pass_start
        val = MOIU.eval_variables(
            x-> nothing_to_nan(MOI.get(m, MOI.VariablePrimalStart(), x)), f_dest)
            x -> nothing_to_nan(MOI.get(m, MOI.VariablePrimalStart(), x)),
            f_dest,
        )
        if !isnan(val)
            is_tight = abs(val) < 1e-8
            has_start = true

@@ -865,21 +1047,46 @@

Loading

        s1 = MOI.Indicator{MOI.ACTIVATE_ON_ONE}(pre_s1)
        s2 = MOI.Indicator{MOI.ACTIVATE_ON_ONE}(MOI.EqualTo(zero(T)))
        if pass_start && has_start
            MOI.set(m, MOI.VariablePrimalStart(), vb1, ifelse(is_tight, 1.0, 0.0))
            MOI.set(m, MOI.VariablePrimalStart(), vb2, ifelse(is_tight, 0.0, 1.0))
            MOI.set(
                m,
                MOI.VariablePrimalStart(),
                vb1,
                ifelse(is_tight, 1.0, 0.0),
            )
            MOI.set(
                m,
                MOI.VariablePrimalStart(),
                vb2,
                ifelse(is_tight, 0.0, 1.0),
            )
        end
    elseif method == ZERO_ZERO
        s1 = MOI.Indicator{MOI.ACTIVATE_ON_ZERO}(pre_s1)
        s2 = MOI.Indicator{MOI.ACTIVATE_ON_ZERO}(MOI.EqualTo(zero(T)))
        if pass_start && has_start
            MOI.set(m, MOI.VariablePrimalStart(), vb1, ifelse(is_tight, 0.0, 1.0))
            MOI.set(m, MOI.VariablePrimalStart(), vb2, ifelse(is_tight, 1.0, 0.0))
            MOI.set(
                m,
                MOI.VariablePrimalStart(),
                vb1,
                ifelse(is_tight, 0.0, 1.0),
            )
            MOI.set(
                m,
                MOI.VariablePrimalStart(),
                vb2,
                ifelse(is_tight, 1.0, 0.0),
            )
        end
    else
        s1 = MOI.Indicator{MOI.ACTIVATE_ON_ONE}(pre_s1)
        s2 = MOI.Indicator{MOI.ACTIVATE_ON_ZERO}(MOI.EqualTo(zero(T)))
        if pass_start && has_start
            MOI.set(m, MOI.VariablePrimalStart(), vb1, ifelse(is_tight, 1.0, 0.0))
            MOI.set(
                m,
                MOI.VariablePrimalStart(),
                vb1,
                ifelse(is_tight, 1.0, 0.0),
            )
        end
    end


@@ -894,10 +1101,10 @@

Loading

    return c1
end

function flip_set(set::MOI.LessThan{T}) where T
function flip_set(set::MOI.LessThan{T}) where {T}
    return MOI.GreaterThan{T}(0.0)
end
function flip_set(set::MOI.GreaterThan{T}) where T
function flip_set(set::MOI.GreaterThan{T}) where {T}
    return MOI.LessThan{T}(0.0)
end


@@ -915,16 +1122,22 @@

Loading

    end
end

function set_bound(inter::Interval, ::LT{T}) where T
function set_bound(inter::Interval, ::LT{T}) where {T}
    return inter.hi
end
function set_bound(inter::Interval, ::GT{T}) where T
function set_bound(inter::Interval, ::GT{T}) where {T}
    return inter.lo
end

function add_complement(mode::FortunyAmatMcCarlMode{T}, m, comp::Complement,
    idxmap_primal, idxmap_dual, copy_names::Bool, pass_start::Bool) where T

function add_complement(
    mode::FortunyAmatMcCarlMode{T},
    m,
    comp::Complement,
    idxmap_primal,
    idxmap_dual,
    copy_names::Bool,
    pass_start::Bool,
) where {T}
    f = comp.func_w_cte
    s = comp.set_w_zero
    v = comp.variable

@@ -937,11 +1150,16 @@

Loading

    end
    f_dest = MOIU.map_indices.(Ref(idxmap_primal), f)

    f_bounds = MOIU.eval_variables(vi -> get_bounds(vi, mode.cache.map, mode.primal_big_M), f_dest)
    f_bounds = MOIU.eval_variables(
        vi -> get_bounds(vi, mode.cache.map, mode.primal_big_M),
        f_dest,
    )

    if pass_start
        val = MOIU.eval_variables(
            x-> nothing_to_nan(MOI.get(m, MOI.VariablePrimalStart(), x)), f_dest)
            x -> nothing_to_nan(MOI.get(m, MOI.VariablePrimalStart(), x)),
            f_dest,
        )
        if !isnan(val)
            is_tight = abs(val) < 1e-8
            has_start = true

@@ -950,7 +1168,8 @@

Loading


    if mode.with_slack
        new_f = MOIU.operate(-, T, f_dest, slack)
        equality = MOIU.normalize_and_add_constraint(m, new_f, MOI.EqualTo(zero(T)))
        equality =
            MOIU.normalize_and_add_constraint(m, new_f, MOI.EqualTo(zero(T)))
        if pass_start && has_start
            MOI.set(m, MOI.VariablePrimalStart(), slack, val)
        end

@@ -974,17 +1193,17 @@

Loading

    Mv = set_bound(v_bounds, s2)

    if isnan(Ms) || abs(Ms) >= Inf || isnan(Mv) || abs(Mv) >= Inf
        error("It was not possible to automatically compute bounds"*
            " for a complementarity pair, please add the arguments"*
            " primal_big_M and dual_big_M to FortunyAmatMcCarlMode")
        error(
            "It was not possible to automatically compute bounds" *
            " for a complementarity pair, please add the arguments" *
            " primal_big_M and dual_big_M to FortunyAmatMcCarlMode",
        )
    end
    

    if mode.with_slack
        f1 = MOI.ScalarAffineFunction{T}(
            MOI.ScalarAffineTerm{T}.(
                [one(T), -Ms], [slack, bin]
            ),
            0.0
            MOI.ScalarAffineTerm{T}.([one(T), -Ms], [slack, bin]),
            0.0,
        )
    else
        push!(f_dest.terms, MOI.ScalarAffineTerm{T}(-Ms, bin))

@@ -992,10 +1211,8 @@

Loading

    end

    f2 = MOI.ScalarAffineFunction{T}(
        MOI.ScalarAffineTerm{T}.(
            [one(T), Mv], [dual, bin]
        ),
        -Mv
        MOI.ScalarAffineTerm{T}.([one(T), Mv], [dual, bin]),
        -Mv,
    )

    c1 = MOIU.normalize_and_add_constraint(m, f1, s2)

@@ -1022,7 +1239,7 @@

Loading

    return c1
end

function to_vector_affine(f::MOI.VectorAffineFunction{T}) where T
function to_vector_affine(f::MOI.VectorAffineFunction{T}) where {T}
    return f
end
function to_vector_affine(f::MOI.VectorOfVariables)

@@ -1032,9 +1249,13 @@

Loading

function handle_lower_objective_sense(lower::MOI.ModelLike)
    lower_objective_sense = MOI.get(lower, MOI.ObjectiveSense())
    if lower_objective_sense == MOI.FEASIBILITY_SENSE
        throw(ErrorException("Lower level models with objective_sense: " * 
                            lower_objective_sense * 
                            " are not supported."))
        throw(
            ErrorException(
                "Lower level models with objective_sense: " *
                lower_objective_sense *
                " are not supported.",
            ),
        )
    end
    return
end

@@ -8,7 +8,13 @@

Loading

    lower_only = Dict(
        JuMP.index(k) => JuMP.index(v) for (k, v) in model.lower_to_upper_link
    )
    return _build_single_model(upper, lower, lower_to_upper, lower_only, check_MIPMIP)
    return _build_single_model(
        upper,
        lower,
        lower_to_upper,
        lower_only,
        check_MIPMIP,
    )
end

function _build_single_model(

@@ -16,7 +22,7 @@

Loading

    lower::MOI.ModelLike,
    lower_to_upper_link::Dict{MOI.VariableIndex,MOI.VariableIndex},
    lower_only::Dict{MOI.VariableIndex,MOI.VariableIndex},
    check_MIPMIP::Bool = false
    check_MIPMIP::Bool = false,
)
    model = MOI.FileFormats.MPS.Model()
    upper_to_model_link = MOI.copy_to(model, upper)

@@ -43,29 +49,41 @@

Loading

        return upper_to_model_link[lower_to_upper_link[x]]
    end

    
    # Testing if the model is MIP-MIP or not. 
    if check_MIPMIP
        int_var = MOI.get(model, MOI.NumberOfConstraints{MOI.VariableIndex, MOI.Integer}())
        int_var = int_var + MOI.get(model, MOI.NumberOfConstraints{MOI.VariableIndex, MOI.ZeroOne}())
        int_var = MOI.get(
            model,
            MOI.NumberOfConstraints{MOI.VariableIndex,MOI.Integer}(),
        )
        int_var =
            int_var + MOI.get(
                model,
                MOI.NumberOfConstraints{MOI.VariableIndex,MOI.ZeroOne}(),
            )
        all_var = MOI.get(model, MOI.NumberOfVariables())
        if int_var != all_var
            throw("Currently MibS works on only MIP-MIP problems and the input model is not MIP-MIP!!")
            throw(
                "Currently MibS works on only MIP-MIP problems and the input model is not MIP-MIP!!",
            )
        end
    end

    lower_sense = MOI.get(lower, MOI.ObjectiveSense())

    return model, lower_variables, lower_objective, lower_constraints, lower_sense
    return model,
    lower_variables,
    lower_objective,
    lower_constraints,
    lower_sense
end

function _index_to_row_link(model::MOI.FileFormats.MPS.Model)
    i = 0
    dict = Dict{MOI.ConstraintIndex, Int}()
    dict = Dict{MOI.ConstraintIndex,Int}()
    for (S, _) in MOI.FileFormats.MPS.SET_TYPES
        for ci in MOI.get(
            model,
            MOI.ListOfConstraintIndices{MOI.ScalarAffineFunction{Float64}, S}(),
            MOI.ListOfConstraintIndices{MOI.ScalarAffineFunction{Float64},S}(),
        )
            dict[ci] = i
            i += 1

@@ -87,13 +105,12 @@

Loading

    lower_objective::MOI.ScalarAffineFunction,
    lower_constraints::Vector{MOI.ConstraintIndex},
    lower_sense::MOI.OptimizationSense,
    aux_filename::String
    aux_filename::String,
)
    rows = _index_to_row_link(new_model)
    cols = _index_to_column_link(new_model)
    obj_coefficients = Dict{MOI.VariableIndex,Float64}(
        x => 0.0 for x in lower_variables
    )
    obj_coefficients =
        Dict{MOI.VariableIndex,Float64}(x => 0.0 for x in lower_variables)
    for term in lower_objective.terms
        if haskey(obj_coefficients, term.variable)
            obj_coefficients[term.variable] += term.coefficient

@@ -111,7 +128,7 @@

Loading

        for x in lower_variables
            println(io, "LO $(obj_coefficients[x])")
        end
        println(io, "OS ", lower_sense == MOI.MAX_SENSE ? -1 : 1)
        return println(io, "OS ", lower_sense == MOI.MAX_SENSE ? -1 : 1)
    end
    return
end

@@ -125,12 +142,12 @@

Loading

    # write(io, "\n BilevelJuMP Calling MibS \n")
    io_err = "mibs_errors.txt"
    mibs_call() do exe
        run(
        return run(
            pipeline(
                `$(exe) -Alps_instance $(mps_filename) -MibS_auxiliaryInfoFile $(aux_filename)`,
                `$(exe) -Alps_instance $(mps_filename) -MibS_auxiliaryInfoFile $(aux_filename)`;
                stdout = io,
                stderr = io_err,
            )
            ),
        )
    end
    # seekstart(io_err)

@@ -141,8 +158,8 @@

Loading

function _parse_output(
    output::String,
    new_model::MOI.FileFormats.MPS.Model,
    lower_variables::Vector{MOI.VariableIndex}
    )
    lower_variables::Vector{MOI.VariableIndex},
)
    lines = split(output, '\n')
    found_status = false
    objective_value = NaN

@@ -150,7 +167,6 @@

Loading

    upper = Dict{Int,Float64}()
    lower = Dict{Int,Float64}()


    all_var = MOI.get(new_model, MOI.ListOfVariableIndices())

    CntU = 0

@@ -172,7 +188,7 @@

Loading

            Dict_Lower_IndexToModel[CntD] = y
            CntD = CntD + 1
        else
            Dict_Upper_Name[CntU] = nameofvar  
            Dict_Upper_Name[CntU] = nameofvar
            Dict_Upper_Value[nameofvar] = 0
            Dict_Upper_IndexToModel[CntU] = y
            CntU = CntU + 1

@@ -180,7 +196,6 @@

Loading

        Dict_All[y] = 0
    end


    for line in lines
        if !found_status
            if occursin("Optimal solution", line)

@@ -222,7 +237,7 @@

Loading

        nonzero_lower = lower,
        all_upper = Dict_Upper_Value,
        all_lower = Dict_Lower_Value,
        all_var = Dict_All
        all_var = Dict_All,
    )
end


@@ -262,7 +277,7 @@

Loading

    mktempdir() do path
        mps_filename = joinpath(path, "model.mps")
        aux_filename = joinpath(path, "model.aux")
        new_model, variables, objective, constraints, sense  =
        new_model, variables, objective, constraints, sense =
            _build_single_model(model, true)
        # This MPS file must be strictly compliant with the format
        MOI.write_to_file(new_model, mps_filename)

@@ -285,24 +300,28 @@

Loading

            mps_db = joinpath(orig_path, debug_file_prefix * "model.mps")
            aux_db = joinpath(orig_path, debug_file_prefix * "model.aux")
            try
                cp(mps_filename, mps_db, force = true)
                cp(mps_filename, mps_db; force = true)
            catch e
                println("BilevelJuMP failed to write debug file $mps_db: with $e")
                println(
                    "BilevelJuMP failed to write debug file $mps_db: with $e",
                )
            end
            try
                cp(aux_filename, aux_db, force = true)
                cp(aux_filename, aux_db; force = true)
            catch e
                println("BilevelJuMP failed to write debug file $aux_db: with $e")
                println(
                    "BilevelJuMP failed to write debug file $aux_db: with $e",
                )
            end
        end
        if length(err) > 0
            mibs_error =
            "MibS returned:\n\n" *
            "$err\n\n" *
            "MibS input files can be found at:\n" *
            "* $mps_db\n" *
            "* $aux_db\n\n" *
            "Please include these files if you open an issue.\n"
                "MibS returned:\n\n" *
                "$err\n\n" *
                "MibS input files can be found at:\n" *
                "* $mps_db\n" *
                "* $aux_db\n\n" *
                "Please include these files if you open an issue.\n"
            error(mibs_error)
        end
        if length(output) == 0

@@ -26,49 +26,49 @@

Loading

    lo::T
    hi::T
end
function Interval(lo::T, hi::T) where {T <: Real}
function Interval(lo::T, hi::T) where {T<:Real}
    # if hi < lo <= hi + eps(T)
    #     lo = hi
    # end
    @assert lo <= hi
    Interval{T}(lo, hi)
    return Interval{T}(lo, hi)
end

function Base.iszero(a::Interval)
    iszero(a.hi) && iszero(a.lo)
    return iszero(a.hi) && iszero(a.lo)
end

+(a::Interval) = a
-(a::Interval) = Interval(-a.hi, -a.lo)

function +(a::Interval{T}, b::T) where {T<:Real}
    Interval(a.lo + b, a.hi + b)
    return Interval(a.lo + b, a.hi + b)
end
+(b::T, a::Interval{T}) where {T<:Real} = a+b
+(b::T, a::Interval{T}) where {T<:Real} = a + b

function -(a::Interval{T}, b::T) where {T<:Real}
    Interval(a.lo - b, a.hi - b)
    return Interval(a.lo - b, a.hi - b)
end
function -(b::T, a::Interval{T}) where {T<:Real}
    Interval(b - a.hi, b - a.lo)
    return Interval(b - a.hi, b - a.lo)
end

function +(a::Interval{T}, b::Interval{T}) where T<:Real
    Interval(a.lo + b.lo, a.hi + b.hi)
function +(a::Interval{T}, b::Interval{T}) where {T<:Real}
    return Interval(a.lo + b.lo, a.hi + b.hi)
end

function -(a::Interval{T}, b::Interval{T}) where T<:Real
    Interval(a.lo - b.hi, a.hi - b.lo)
function -(a::Interval{T}, b::Interval{T}) where {T<:Real}
    return Interval(a.lo - b.hi, a.hi - b.lo)
end

## Multiplication
function *(x::T, a::Interval{T}) where {T<:Real}
    (iszero(a) || iszero(x)) && return Interval(zero(T), zero(T))
    if x ≥ 0.0
        return Interval(a.lo*x, a.hi*x)
        return Interval(a.lo * x, a.hi * x)
    else
        return Interval(a.hi*x, a.lo*x)
        return Interval(a.hi * x, a.lo * x)
    end
end

*(a::Interval{T}, x::T) where {T<:Real} = x*a
*(a::Interval{T}, x::T) where {T<:Real} = x * a

@@ -1,18 +1,33 @@

Loading

JuMP.num_variables(m::AbstractBilevelModel) = JuMP.num_variables(bilevel_model(m))
function JuMP.num_variables(m::AbstractBilevelModel)
    return JuMP.num_variables(bilevel_model(m))
end
_plural(n) = (isone(n) ? "" : "s")
function JuMP.show_constraints_summary(io::IO, model::BilevelModel)
    JuMP.show_constraints_summary(io, Upper(model))
    JuMP.show_constraints_summary(io, Lower(model), true)
    return JuMP.show_constraints_summary(io, Lower(model), true)
end
function JuMP.show_constraints_summary(io::IO, model::UpperModel)
    n = JuMP.num_constraints(model)
    println(io, "Upper Constraint", _plural(n), ": ", n)
    return println(io, "Upper Constraint", _plural(n), ": ", n)
end
function JuMP.show_constraints_summary(io::IO, model::LowerModel, line_break = false)
function JuMP.show_constraints_summary(
    io::IO,
    model::LowerModel,
    line_break = false,
)
    n = JuMP.num_constraints(model)
    print(io, "Lower Constraint", _plural(n), ": ", n, ifelse(line_break, "\n",""))
    return print(
        io,
        "Lower Constraint",
        _plural(n),
        ": ",
        n,
        ifelse(line_break, "\n", ""),
    )
end
function JuMP.show_backend_summary(io::IO, model::InnerBilevelModel)
    return JuMP.show_backend_summary(io, model.m)
end
JuMP.show_backend_summary(io::IO, model::InnerBilevelModel) = JuMP.show_backend_summary(io, model.m)
function JuMP.show_backend_summary(io::IO, model::BilevelModel)
    println(io, "Bilevel Model")
    println(io, "Solution method: ", model.mode)

@@ -36,15 +51,20 @@

Loading

end

function JuMP.show_objective_function_summary(io::IO, model::UpperModel)
    println(io, "Upper objective function type: \n",
            JuMP.objective_function_type(model))
    return println(
        io,
        "Upper objective function type: \n",
        JuMP.objective_function_type(model),
    )
end
function JuMP.show_objective_function_summary(io::IO, model::LowerModel)
    println(io, "Lower objective function type: \n",
            JuMP.objective_function_type(model))
    return println(
        io,
        "Lower objective function type: \n",
        JuMP.objective_function_type(model),
    )
end
function JuMP.show_objective_function_summary(io::IO, model::BilevelModel)
    JuMP.show_objective_function_summary(io, Upper(model))
    JuMP.show_objective_function_summary(io, Lower(model))
    return JuMP.show_objective_function_summary(io, Lower(model))
end


@@ -6,7 +6,7 @@

Loading

            MOI.set(dest, MOI.VariableName(), map[vi], name)
        end
    end
    for (F,S) in MOI.get(src, MOI.ListOfConstraintTypesPresent())
    for (F, S) in MOI.get(src, MOI.ListOfConstraintTypesPresent())
        if !(F <: MOI.VariableIndex)
            for con in MOI.get(src, MOI.ListOfConstraintIndices{F,S}())
                name = MOI.get(src, MOI.ConstraintName(), con)

@@ -18,8 +18,13 @@

Loading

    end
end

function append_to(dest::MOI.ModelLike, src::MOI.ModelLike, idxmap, 
    filter_constraints::Union{Nothing, Function}=nothing; allow_single_bounds::Bool = true)
function append_to(
    dest::MOI.ModelLike,
    src::MOI.ModelLike,
    idxmap,
    filter_constraints::Union{Nothing,Function} = nothing;
    allow_single_bounds::Bool = true,
)

    #=
        This function follows closely the function `default_copy_to` defined in

@@ -36,7 +41,7 @@

Loading

    vis_src = MOI.get(src, MOI.ListOfVariableIndices())
    # index_map_for_variable_indices only initializes the data structure
    # idxmap = index_map_for_variable_indices(vis_src)
    

    # The `NLPBlock` assumes that the order of variables does not change (#849)
    if MOI.NLPBlock() in MOI.get(src, MOI.ListOfModelAttributesSet())
        error("NLP models are not supported.")

@@ -91,144 +96,170 @@

Loading

end

# scalar
function MOIU.promote_operation(::typeof(LinearAlgebra.dot), ::Type{T},
    ::Type{<:Union{MOI.VariableIndex, MOI.ScalarAffineFunction{T}}},
    ::Type{T}
    ) where T
    MOI.ScalarAffineFunction{T}
function MOIU.promote_operation(
    ::typeof(LinearAlgebra.dot),
    ::Type{T},
    ::Type{<:Union{MOI.VariableIndex,MOI.ScalarAffineFunction{T}}},
    ::Type{T},
) where {T}
    return MOI.ScalarAffineFunction{T}
end
function MOIU.promote_operation(::typeof(LinearAlgebra.dot), ::Type{T},
function MOIU.promote_operation(
    ::typeof(LinearAlgebra.dot),
    ::Type{T},
    ::Type{<:Union{MOI.VariableIndex, MOI.ScalarAffineFunction{T}}}
    ) where T
    MOI.ScalarAffineFunction{T}
    ::Type{T},
    ::Type{<:Union{MOI.VariableIndex,MOI.ScalarAffineFunction{T}}},
) where {T}
    return MOI.ScalarAffineFunction{T}
end
function MOIU.promote_operation(::typeof(LinearAlgebra.dot), ::Type{T},
    ::Type{<:Union{MOI.VariableIndex, MOI.ScalarAffineFunction{T}}},
    ::Type{<:Union{MOI.VariableIndex, MOI.ScalarAffineFunction{T}}}
    ) where T
    MOI.ScalarQuadraticFunction{T}
function MOIU.promote_operation(
    ::typeof(LinearAlgebra.dot),
    ::Type{T},
    ::Type{<:Union{MOI.VariableIndex,MOI.ScalarAffineFunction{T}}},
    ::Type{<:Union{MOI.VariableIndex,MOI.ScalarAffineFunction{T}}},
) where {T}
    return MOI.ScalarQuadraticFunction{T}
end
function MOIU.promote_operation(::typeof(LinearAlgebra.dot), ::Type{T},
function MOIU.promote_operation(
    ::typeof(LinearAlgebra.dot),
    ::Type{T},
    ::Type{MOI.ScalarQuadraticFunction{T}},
    ::Type{T}
    ) where T
    MOI.ScalarQuadraticFunction{T}
    ::Type{T},
) where {T}
    return MOI.ScalarQuadraticFunction{T}
end
function MOIU.promote_operation(::typeof(LinearAlgebra.dot), ::Type{T},
function MOIU.promote_operation(
    ::typeof(LinearAlgebra.dot),
    ::Type{T},
    ::Type{MOI.ScalarQuadraticFunction{T}}
    ) where T
    MOI.ScalarQuadraticFunction{T}
    ::Type{T},
    ::Type{MOI.ScalarQuadraticFunction{T}},
) where {T}
    return MOI.ScalarQuadraticFunction{T}
end
# flip
function MOIU.operate(::typeof(LinearAlgebra.dot), ::Type{T},
function MOIU.operate(
    ::typeof(LinearAlgebra.dot),
    ::Type{T},
    f::Union{
        MOI.VariableIndex,
        MOI.ScalarAffineFunction{T},
        MOI.ScalarQuadraticFunction{T}
        },
    α::T) where T
        MOI.ScalarQuadraticFunction{T},
    },
    α::T,
) where {T}
    return MOIU.operate(LinearAlgebra.dot, T, α, f)
end
# pass to *
function MOIU.operate(::typeof(LinearAlgebra.dot), ::Type{T},
    f::Union{
        T,
        MOI.VariableIndex,
        MOI.ScalarAffineFunction{T}
        },
    g::Union{
        MOI.VariableIndex,
        MOI.ScalarAffineFunction{T}
        }
    ) where T
function MOIU.operate(
    ::typeof(LinearAlgebra.dot),
    ::Type{T},
    f::Union{T,MOI.VariableIndex,MOI.ScalarAffineFunction{T}},
    g::Union{MOI.VariableIndex,MOI.ScalarAffineFunction{T}},
) where {T}
    return MOIU.operate(*, T, f, g)
end
function MOIU.operate(::typeof(LinearAlgebra.dot), ::Type{T},
function MOIU.operate(
    ::typeof(LinearAlgebra.dot),
    ::Type{T},
    α::T,
    f::MOI.ScalarQuadraticFunction{T}
    ) where T
    f::MOI.ScalarQuadraticFunction{T},
) where {T}
    return MOIU.operate(*, T, f, α)
end

# vector
function MOIU.promote_operation(::typeof(LinearAlgebra.dot), ::Type{T},
    ::Type{<:Union{MOI.VectorOfVariables, MOI.VectorAffineFunction{T}}},
    ::Type{Vector{T}}
    ) where T
    MOI.VectorAffineFunction{T}
function MOIU.promote_operation(
    ::typeof(LinearAlgebra.dot),
    ::Type{T},
    ::Type{<:Union{MOI.VectorOfVariables,MOI.VectorAffineFunction{T}}},
    ::Type{Vector{T}},
) where {T}
    return MOI.VectorAffineFunction{T}
end
function MOIU.promote_operation(::typeof(LinearAlgebra.dot), ::Type{T},
function MOIU.promote_operation(
    ::typeof(LinearAlgebra.dot),
    ::Type{T},
    ::Type{Vector{T}},
    ::Type{<:Union{MOI.VectorOfVariables, MOI.VectorAffineFunction{T}}}
    ) where T
    MOI.VectorAffineFunction{T}
    ::Type{<:Union{MOI.VectorOfVariables,MOI.VectorAffineFunction{T}}},
) where {T}
    return MOI.VectorAffineFunction{T}
end
function MOIU.promote_operation(::typeof(LinearAlgebra.dot), ::Type{T},
    ::Type{<:Union{MOI.VectorOfVariables, MOI.VectorAffineFunction{T}}},
    ::Type{<:Union{MOI.VectorOfVariables, MOI.VectorAffineFunction{T}}}
    ) where T
    MOI.VectorQuadraticFunction{T}
function MOIU.promote_operation(
    ::typeof(LinearAlgebra.dot),
    ::Type{T},
    ::Type{<:Union{MOI.VectorOfVariables,MOI.VectorAffineFunction{T}}},
    ::Type{<:Union{MOI.VectorOfVariables,MOI.VectorAffineFunction{T}}},
) where {T}
    return MOI.VectorQuadraticFunction{T}
end
function MOIU.promote_operation(::typeof(LinearAlgebra.dot), ::Type{T},
function MOIU.promote_operation(
    ::typeof(LinearAlgebra.dot),
    ::Type{T},
    ::Type{MOI.VectorQuadraticFunction{T}},
    ::Type{Vector{T}}
    ) where T
    MOI.VectorQuadraticFunction{T}
    ::Type{Vector{T}},
) where {T}
    return MOI.VectorQuadraticFunction{T}
end
function MOIU.promote_operation(::typeof(LinearAlgebra.dot), ::Type{T},
function MOIU.promote_operation(
    ::typeof(LinearAlgebra.dot),
    ::Type{T},
    ::Type{Vector{T}},
    ::Type{MOI.VectorQuadraticFunction{T}}
    ) where T
    MOI.VectorQuadraticFunction{T}
    ::Type{MOI.VectorQuadraticFunction{T}},
) where {T}
    return MOI.VectorQuadraticFunction{T}
end
# flip
function MOIU.operate(::typeof(LinearAlgebra.dot), ::Type{T},
function MOIU.operate(
    ::typeof(LinearAlgebra.dot),
    ::Type{T},
    f::Union{
        MOI.VectorOfVariables,
        MOI.VectorAffineFunction{T},
        MOI.VectorQuadraticFunction{T}
        },
    α::Vector{T}) where T
        MOI.VectorQuadraticFunction{T},
    },
    α::Vector{T},
) where {T}
    return MOIU.operate(LinearAlgebra.dot, T, α, f)
end
# pass to _operate(LinearAlgebra.dot, ...)
function MOIU.operate(::typeof(LinearAlgebra.dot), ::Type{T},
    f::Union{
        Vector{T},
        MOI.VectorOfVariables,
        MOI.VectorAffineFunction{T}
        },
    g::Union{
        MOI.VectorOfVariables,
        MOI.VectorAffineFunction{T}
        }
    ) where T
function MOIU.operate(
    ::typeof(LinearAlgebra.dot),
    ::Type{T},
    f::Union{Vector{T},MOI.VectorOfVariables,MOI.VectorAffineFunction{T}},
    g::Union{MOI.VectorOfVariables,MOI.VectorAffineFunction{T}},
) where {T}
    return _operate(LinearAlgebra.dot, T, f, g)
end
function MOIU.operate(::typeof(LinearAlgebra.dot), ::Type{T},
function MOIU.operate(
    ::typeof(LinearAlgebra.dot),
    ::Type{T},
    α::T,
    f::MOI.VectorQuadraticFunction{T}
    ) where T
    f::MOI.VectorQuadraticFunction{T},
) where {T}
    return _operate(LinearAlgebra.dot, T, f, α)
end
function _operate(::typeof(LinearAlgebra.dot), ::Type{T},
function _operate(
    ::typeof(LinearAlgebra.dot),
    ::Type{T},
    f::Union{
        Vector{T},
        MOI.VectorOfVariables,
        MOI.VectorAffineFunction{T},
        MOI.VectorQuadraticFunction{T}
        },
        MOI.VectorQuadraticFunction{T},
    },
    g::Union{
        MOI.VectorOfVariables,
        MOI.VectorAffineFunction{T},
        MOI.VectorQuadraticFunction{T}
    }) where T

        MOI.VectorQuadraticFunction{T},
    },
) where {T}
    dim = MOI.output_dimension(g)
    if MOI.output_dimension(f) != dim
        throw(DimensionMismatch("f and g are of different MOI.output_dimension's!"))
        throw(
            DimensionMismatch(
                "f and g are of different MOI.output_dimension's!",
            ),
        )
    end

    fs = MOIU.scalarize(f)

@@ -241,5 +272,5 @@

Loading


    return out
end
MOIU.scalarize(v::Vector{T}) where T<:Number = v
MOI.output_dimension(v::Vector{T}) where T<:Number = length(v)#
MOIU.scalarize(v::Vector{T}) where {T<:Number} = v
MOI.output_dimension(v::Vector{T}) where {T<:Number} = length(v)#

@@ -19,17 +19,23 @@

Loading

    # maps the BilevelVariableRef index
    # to JuMP variables of the correct level
    # variable that appear in both levels are inboth dicts
    var_upper::Dict{Int, JuMP.AbstractVariableRef}
    var_lower::Dict{Int, JuMP.AbstractVariableRef}
    var_upper::Dict{Int,JuMP.AbstractVariableRef}
    var_lower::Dict{Int,JuMP.AbstractVariableRef}

    # additional info for variables such as bound hints
    # holds the variable level: LOWER_BOTH UPPER_BOTH LOWER_ONLY UPPER_ONLY DUAL_OF_LOWER
    var_info::Dict{Int, BilevelVariableInfo}
    var_info::Dict{Int,BilevelVariableInfo}

    # maps JuMP.VariableRef to BilevelVariableRef
    # built upon necessity for getting contraints and functions
    var_upper_rev::Union{Nothing, Dict{JuMP.AbstractVariableRef, JuMP.AbstractVariableRef}}
    var_lower_rev::Union{Nothing, Dict{JuMP.AbstractVariableRef, JuMP.AbstractVariableRef}}
    var_upper_rev::Union{
        Nothing,
        Dict{JuMP.AbstractVariableRef,JuMP.AbstractVariableRef},
    }
    var_lower_rev::Union{
        Nothing,
        Dict{JuMP.AbstractVariableRef,JuMP.AbstractVariableRef},
    }

    # JuMP.VariableRef of variables from named level that are NOT linking
    upper_only::Set{JuMP.AbstractVariableRef}

@@ -37,56 +43,59 @@

Loading

    # upper level decisions that are "parameters" of the second level
    # keys are *decision* variables from the upper level
    # values are *parameter* variables from the lower level (linked to the keys)
    upper_to_lower_link::Dict{JuMP.AbstractVariableRef, JuMP.AbstractVariableRef}
    upper_to_lower_link::Dict{JuMP.AbstractVariableRef,JuMP.AbstractVariableRef}
    # lower level decisions that are input to upper
    # keys are *decision* variables from the lower level
    # values are *parameter* variables from the upper level (linked to the keys)
    lower_to_upper_link::Dict{JuMP.AbstractVariableRef, JuMP.AbstractVariableRef}
    lower_to_upper_link::Dict{JuMP.AbstractVariableRef,JuMP.AbstractVariableRef}
    # lower level decisions that are input to upper
    # keys are upper level variables (representing lower level dual variables)
    # values are lower level constraints
    upper_var_to_lower_ctr_link::Dict{JuMP.AbstractVariableRef, JuMP.ConstraintRef}
    upper_var_to_lower_ctr_link::Dict{
        JuMP.AbstractVariableRef,
        JuMP.ConstraintRef,
    }
    # joint link
    # for all variables that appear in both models
    # keys are upper indices and values are lower indices
    # same as: merge(upper_to_lower_link, reverse(lower_to_upper_link))
    link::Dict{JuMP.AbstractVariableRef, JuMP.AbstractVariableRef}
    link::Dict{JuMP.AbstractVariableRef,JuMP.AbstractVariableRef}

    # Integer index of the last constraint added (for indexing BilevelConstraintRef's)
    nextconidx::Int

    # maps the BilevelConstraintRef index
    # to JuMP ConstraintRef of the correct level
    ctr_upper::Dict{Int, JuMP.ConstraintRef}
    ctr_lower::Dict{Int, JuMP.ConstraintRef}
    ctr_upper::Dict{Int,JuMP.ConstraintRef}
    ctr_lower::Dict{Int,JuMP.ConstraintRef}

    # additional info for constraints such as bound hints and start values
    ctr_info::Dict{Int, BilevelConstraintInfo}
    ctr_info::Dict{Int,BilevelConstraintInfo}

    # maps JuMP.ConstraintRef to BilevelConstraintRef
    # built upon necessity for getting contraints and functions
    ctr_upper_rev::Union{Nothing, Dict{JuMP.ConstraintRef, JuMP.ConstraintRef}} # bilevel ref no defined
    ctr_lower_rev::Union{Nothing, Dict{JuMP.ConstraintRef, JuMP.ConstraintRef}} # bilevel ref no defined
    ctr_upper_rev::Union{Nothing,Dict{JuMP.ConstraintRef,JuMP.ConstraintRef}} # bilevel ref no defined
    ctr_lower_rev::Union{Nothing,Dict{JuMP.ConstraintRef,JuMP.ConstraintRef}} # bilevel ref no defined

    #
    solver#::MOI.ModelLike
    mode
    solver::Any#::MOI.ModelLike
    mode::Any

    # maps for MPEC based solution methods
    # from upper level JuMP.index(JuMP.VariableRef) = (MOI.VI)
    # to mpec indices
    upper_to_sblm
    upper_to_sblm::Any
    # from lower MOI indices
    # to mpec indices
    lower_to_sblm
    lower_to_sblm::Any
    # from lower dual MOI indices
    # to mpec indices
    lower_dual_to_sblm
    lower_dual_to_sblm::Any
    # from mped indices to solver indices
    sblm_to_solver
    sblm_to_solver::Any
    # lower primal to dual map
    # to obtain dual variables from primal constraints
    lower_primal_dual_map
    lower_primal_dual_map::Any

    # results from opt process
    solve_time::Float64

@@ -98,35 +107,34 @@

Loading

    pass_start::Bool

    # for completing the JuMP.Model API
    objdict::Dict{Symbol, Any}    # Same that JuMP.Model's field `objdict`
    objdict::Dict{Symbol,Any}    # Same that JuMP.Model's field `objdict`

    function BilevelModel()

        model = new(
            JuMP.Model(),
            JuMP.Model(),

            # var
            0,
            Dict{Int, JuMP.AbstractVariable}(),
            Dict{Int, JuMP.AbstractVariable}(),
            Dict{Int, BilevelVariableInfo}(),
            Dict{Int,JuMP.AbstractVariable}(),
            Dict{Int,JuMP.AbstractVariable}(),
            Dict{Int,BilevelVariableInfo}(),
            nothing,
            nothing,

            # links
            Set{JuMP.AbstractVariableRef}(),
            Set{JuMP.AbstractVariableRef}(),
            Dict{JuMP.AbstractVariable, JuMP.AbstractVariable}(),
            Dict{JuMP.AbstractVariable, JuMP.AbstractVariable}(),
            Dict{JuMP.AbstractVariable, JuMP.ConstraintRef}(),
            Dict{JuMP.AbstractVariable, JuMP.AbstractVariable}(),
            Dict{JuMP.AbstractVariable,JuMP.AbstractVariable}(),
            Dict{JuMP.AbstractVariable,JuMP.AbstractVariable}(),
            Dict{JuMP.AbstractVariable,JuMP.ConstraintRef}(),
            Dict{JuMP.AbstractVariable,JuMP.AbstractVariable}(),

            #ctr
            0,
            Dict{Int, JuMP.AbstractConstraint}(),
            Dict{Int, JuMP.AbstractConstraint}(),
            Dict{Int, BilevelConstraintInfo}(),
            Dict{Int,JuMP.AbstractConstraint}(),
            Dict{Int,JuMP.AbstractConstraint}(),
            Dict{Int,BilevelConstraintInfo}(),
            nothing,
            nothing,


@@ -149,19 +157,20 @@

Loading

            false,
            true,
            # jump api
            Dict{Symbol, Any}(),
            )
            Dict{Symbol,Any}(),
        )

        return model
    end
end
function BilevelModel(optimizer_constructor;
        mode::AbstractBilevelSolverMode = SOS1Mode(),
        add_bridges::Bool=true
    )
function BilevelModel(
    optimizer_constructor;
    mode::AbstractBilevelSolverMode = SOS1Mode(),
    add_bridges::Bool = true,
)
    bm = BilevelModel()
    set_mode(bm, mode)
    JuMP.set_optimizer(bm, optimizer_constructor; add_bridges=add_bridges)
    JuMP.set_optimizer(bm, optimizer_constructor; add_bridges = add_bridges)
    return bm
end
function set_mode(bm::BilevelModel, mode::AbstractBilevelSolverMode)

@@ -193,15 +202,23 @@

Loading


# obj

function set_link!(m::UpperModel, upper::JuMP.AbstractVariableRef, lower::JuMP.AbstractVariableRef)
function set_link!(
    m::UpperModel,
    upper::JuMP.AbstractVariableRef,
    lower::JuMP.AbstractVariableRef,
)
    bilevel_model(m).upper_to_lower_link[upper] = lower
    bilevel_model(m).link[upper] = lower
    nothing
    return nothing
end
function set_link!(m::LowerModel, upper::JuMP.AbstractVariableRef, lower::JuMP.AbstractVariableRef)
function set_link!(
    m::LowerModel,
    upper::JuMP.AbstractVariableRef,
    lower::JuMP.AbstractVariableRef,
)
    bilevel_model(m).lower_to_upper_link[lower] = upper
    bilevel_model(m).link[upper] = lower
    nothing
    return nothing
end

# Models to deal with variables that are not exchanged between models

@@ -223,14 +240,25 @@

Loading

mylevel_var_list(m::LowerOnlyModel) = bilevel_model(m).var_lower
mylevel_var_list(m::UpperOnlyModel) = bilevel_model(m).var_upper

in_upper(l::Level) = l == LOWER_BOTH || l == UPPER_BOTH || l == UPPER_ONLY || l == DUAL_OF_LOWER
function in_upper(l::Level)
    return l == LOWER_BOTH ||
           l == UPPER_BOTH ||
           l == UPPER_ONLY ||
           l == DUAL_OF_LOWER
end
in_lower(l::Level) = l == LOWER_BOTH || l == UPPER_BOTH || l == LOWER_ONLY

function push_single_level_variable!(m::LowerOnlyModel, vref::JuMP.AbstractVariableRef)
    push!(bilevel_model(m).lower_only, vref)
function push_single_level_variable!(
    m::LowerOnlyModel,
    vref::JuMP.AbstractVariableRef,
)
    return push!(bilevel_model(m).lower_only, vref)
end
function push_single_level_variable!(m::UpperOnlyModel, vref::JuMP.AbstractVariableRef)
    push!(bilevel_model(m).upper_only, vref)
function push_single_level_variable!(
    m::UpperOnlyModel,
    vref::JuMP.AbstractVariableRef,
)
    return push!(bilevel_model(m).upper_only, vref)
end
#### Model ####


@@ -245,19 +273,21 @@

Loading

end

# Constraints
const BilevelConstraintRef = JuMP.ConstraintRef{BilevelModel, Int}#, Shape <: AbstractShape
const BilevelConstraintRef = JuMP.ConstraintRef{BilevelModel,Int}#, Shape <: AbstractShape

# Objective

# Etc

JuMP.object_dictionary(m::BilevelModel) = m.objdict
JuMP.object_dictionary(m::AbstractBilevelModel) = JuMP.object_dictionary(bilevel_model(m))
function JuMP.object_dictionary(m::AbstractBilevelModel)
    return JuMP.object_dictionary(bilevel_model(m))
end

function convert_indices(d::Dict)
    ret = Dict{VI,VI}()
    # sizehint!(ret, length(d))
    for (k,v) in d
    for (k, v) in d
        ret[JuMP.index(k)] = JuMP.index(v)
    end
    return ret

@@ -265,7 +295,7 @@

Loading

function index2(d::Dict)
    ret = Dict{VI,CI}()
    # sizehint!(ret, length(d))
    for (k,v) in d
    for (k, v) in d
        ret[JuMP.index(k)] = JuMP.index(v)
    end
    return ret

@@ -345,7 +375,6 @@

Loading

    return nothing
end


# Statuses
function JuMP.primal_status(model::BilevelModel)
    _check_solver(model)

@@ -355,8 +384,11 @@

Loading

    return JuMP.primal_status(model.m)
end

JuMP.dual_status(::BilevelModel) = error(
    "Dual status cant be queried for BilevelModel, but you can query for Upper and Lower models.")
function JuMP.dual_status(::BilevelModel)
    return error(
        "Dual status cant be queried for BilevelModel, but you can query for Upper and Lower models.",
    )
end
function JuMP.dual_status(model::UpperModel)
    _check_solver(model.m)
    return MOI.get(model.m.solver, MOI.DualStatus())

@@ -382,7 +414,7 @@

Loading

function build_reverse_var_map!(um::UpperModel)
    m = bilevel_model(um)
    if m.var_upper_rev === nothing
        m.var_upper_rev = Dict{JuMP.AbstractVariableRef, BilevelVariableRef}()
        m.var_upper_rev = Dict{JuMP.AbstractVariableRef,BilevelVariableRef}()
        for (idx, ref) in m.var_upper
            m.var_upper_rev[ref] = BilevelVariableRef(m, idx)
        end

@@ -392,7 +424,7 @@

Loading

function build_reverse_var_map!(lm::LowerModel)
    m = bilevel_model(lm)
    if m.var_lower_rev === nothing
        m.var_lower_rev = Dict{JuMP.AbstractVariableRef, BilevelVariableRef}()
        m.var_lower_rev = Dict{JuMP.AbstractVariableRef,BilevelVariableRef}()
        for (idx, ref) in m.var_lower
            m.var_lower_rev[ref] = BilevelVariableRef(m, idx)
        end

@@ -403,70 +435,101 @@

Loading

get_reverse_var_map(m::LowerModel) = m.m.var_lower_rev
function reverse_replace_variable(f, m::InnerBilevelModel)
    build_reverse_var_map!(m)
    return replace_variables(f, mylevel_model(m), get_reverse_var_map(m), level(m))
    return replace_variables(
        f,
        mylevel_model(m),
        get_reverse_var_map(m),
        level(m),
    )
end
function replace_variables(var::VV, # JuMP.VariableRef
function replace_variables(
    var::VV, # JuMP.VariableRef
    model::M,
    variable_map::Dict{I, V},
    level::Level) where {I,V<:JuMP.AbstractVariableRef, M, VV<:JuMP.AbstractVariableRef}
    variable_map::Dict{I,V},
    level::Level,
) where {I,V<:JuMP.AbstractVariableRef,M,VV<:JuMP.AbstractVariableRef}
    return variable_map[var]
end
function replace_variables(var::BilevelVariableRef,
function replace_variables(
    var::BilevelVariableRef,
    model::M,
    variable_map::Dict{I, V},
    level::Level) where {I,V<:JuMP.AbstractVariableRef, M<:BilevelModel}
    variable_map::Dict{I,V},
    level::Level,
) where {I,V<:JuMP.AbstractVariableRef,M<:BilevelModel}
    if var.model === model && in_level(var, level)
        return variable_map[var.idx]
    elseif var.model === model
        error("Variable $(var) belonging Only to $(var.level) level, was added in the $(level) level.")
        error(
            "Variable $(var) belonging Only to $(var.level) level, was added in the $(level) level.",
        )
    else
        error("A BilevelModel cannot have expression using variables of a BilevelModel different from itself")
        error(
            "A BilevelModel cannot have expression using variables of a BilevelModel different from itself",
        )
    end
end
function replace_variables(aff::JuMP.GenericAffExpr{C, VV},
function replace_variables(
    aff::JuMP.GenericAffExpr{C,VV},
    model::M,
    variable_map::Dict{I, V},
    level::Level) where {I,C,V<:JuMP.AbstractVariableRef, M, VV}
    result = JuMP.GenericAffExpr{C, replace_var_type(M)}(0.0)#zero(aff)
    variable_map::Dict{I,V},
    level::Level,
) where {I,C,V<:JuMP.AbstractVariableRef,M,VV}
    result = JuMP.GenericAffExpr{C,replace_var_type(M)}(0.0)#zero(aff)
    result.constant = aff.constant
    for (coef, var) in JuMP.linear_terms(aff)
        JuMP.add_to_expression!(result,
        coef,
        replace_variables(var, model, variable_map, level))
        JuMP.add_to_expression!(
            result,
            coef,
            replace_variables(var, model, variable_map, level),
        )
    end
    return result
end
function replace_variables(quad::JuMP.GenericQuadExpr{C, VV},
function replace_variables(
    quad::JuMP.GenericQuadExpr{C,VV},
    model::M,
    variable_map::Dict{I, V},
    level::Level) where {I,C,V<:JuMP.AbstractVariableRef, M, VV}
    variable_map::Dict{I,V},
    level::Level,
) where {I,C,V<:JuMP.AbstractVariableRef,M,VV}
    aff = replace_variables(quad.aff, model, variable_map, level)
    quadv = JuMP.GenericQuadExpr{C, replace_var_type(M)}(aff)
    quadv = JuMP.GenericQuadExpr{C,replace_var_type(M)}(aff)
    for (coef, var1, var2) in JuMP.quad_terms(quad)
        JuMP.add_to_expression!(quadv,
        coef,
        replace_variables(var1, model, variable_map, level),
        replace_variables(var2, model, variable_map, level))
        JuMP.add_to_expression!(
            quadv,
            coef,
            replace_variables(var1, model, variable_map, level),
            replace_variables(var2, model, variable_map, level),
        )
    end
    return quadv
end
replace_variables(funcs::Vector, args...) = map(f -> replace_variables(f, args...), funcs)
function replace_variables(funcs::Vector, args...)
    return map(f -> replace_variables(f, args...), funcs)
end

function print_lp(m, name, file_format = MOI.FileFormats.FORMAT_AUTOMATIC)
    dest = MOI.FileFormats.Model(format = file_format, filename = name)
    dest = MOI.FileFormats.Model(; format = file_format, filename = name)
    MOI.copy_to(dest, m)
    MOI.write_to_file(dest, name)
    return MOI.write_to_file(dest, name)
end

# Optimize

JuMP.optimize!(::T) where {T<:AbstractBilevelModel} =
    error("Can't solve a model of type: $T ")
function JuMP.optimize!(model::BilevelModel;
    lower_prob = "", upper_prob = "", bilevel_prob = "", solver_prob = "", file_format = MOI.FileFormats.FORMAT_AUTOMATIC)

function JuMP.optimize!(::T) where {T<:AbstractBilevelModel}
    return error("Can't solve a model of type: $T ")
end
function JuMP.optimize!(
    model::BilevelModel;
    lower_prob = "",
    upper_prob = "",
    bilevel_prob = "",
    solver_prob = "",
    file_format = MOI.FileFormats.FORMAT_AUTOMATIC,
)
    if model.mode === nothing
        error("No solution mode selected, use `set_mode(model, mode)` or initialize with `BilevelModel(optimizer_constructor, mode = some_mode)`")
        error(
            "No solution mode selected, use `set_mode(model, mode)` or initialize with `BilevelModel(optimizer_constructor, mode = some_mode)`",
        )
    else
        mode = model.mode
    end

@@ -497,8 +560,7 @@

Loading


    t0 = time()

    moi_upper = JuMP.index.(
        collect(values(model.upper_to_lower_link)))
    moi_upper = JuMP.index.(collect(values(model.upper_to_lower_link)))
    moi_link = convert_indices(model.link)
    moi_link2 = index2(model.upper_var_to_lower_ctr_link)


@@ -506,9 +568,20 @@

Loading

    # build bound for FortunyAmatMcCarlMode
    build_bounds!(model, mode)

    single_blm, upper_to_sblm, lower_to_sblm, lower_primal_dual_map, lower_dual_to_sblm =
        build_bilevel(upper, lower, moi_link, moi_upper, mode, moi_link2,
            copy_names = model.copy_names, pass_start = model.pass_start)
    single_blm,
    upper_to_sblm,
    lower_to_sblm,
    lower_primal_dual_map,
    lower_dual_to_sblm = build_bilevel(
        upper,
        lower,
        moi_link,
        moi_upper,
        mode,
        moi_link2;
        copy_names = model.copy_names,
        pass_start = model.pass_start,
    )

    # pass additional info (hints - not actual problem data)
    # for lower level dual variables (start, upper hint, lower hint)

@@ -517,8 +590,9 @@

Loading

            ctr = model.ctr_lower[idx]
            # this fails for vector-constrained variables due dualization 0.3.5
            # because of constrained variables that change the dual
            pre_duals = lower_primal_dual_map.primal_con_dual_var[JuMP.index(ctr)] # vector
            duals = map(x->lower_dual_to_sblm[x], pre_duals)
            pre_duals =
                lower_primal_dual_map.primal_con_dual_var[JuMP.index(ctr)] # vector
            duals = map(x -> lower_dual_to_sblm[x], pre_duals)
            pass_dual_info(single_blm, duals, info)
        end
    end

@@ -538,7 +612,7 @@

Loading

    end

    sblm_to_solver = MOI.copy_to(solver, single_blm)
    

    if _has_nlp_data(model.upper)
        # NLP requires an upstream jump model
        # probably is neough to have the fields:

@@ -556,14 +630,15 @@

Loading

            vi_ss = sblm_to_solver[vi_sb]
            vi_is = vars_in_solver[i]
            if vi_ss != vi_is
                error("Failed building Non linear problem, please report an issue")
                error(
                    "Failed building Non linear problem, please report an issue",
                )
                # in case jump or MOI change something in copy/nlpblock
            end
        end
        _load_nlp_data(nlp_model)
    end


    if length(solver_prob) > 0
        print_lp(solver, solver_prob, file_format)
    end

@@ -590,14 +665,18 @@

Loading


function pass_primal_info(single_blm, primal, info::BilevelVariableInfo)
    if !isnan(info.upper) &&
        !MOI.is_valid(single_blm, CI{MOI.VariableIndex,LT{Float64}}(primal.value))
        MOI.add_constraint(single_blm,
            primal, LT{Float64}(info.upper))
       !MOI.is_valid(
        single_blm,
        CI{MOI.VariableIndex,LT{Float64}}(primal.value),
    )
        MOI.add_constraint(single_blm, primal, LT{Float64}(info.upper))
    end
    if !isnan(info.lower) &&
        !MOI.is_valid(single_blm, CI{MOI.VariableIndex,GT{Float64}}(primal.value))
        MOI.add_constraint(single_blm,
            primal, GT{Float64}(info.lower))
       !MOI.is_valid(
        single_blm,
        CI{MOI.VariableIndex,GT{Float64}}(primal.value),
    )
        MOI.add_constraint(single_blm, primal, GT{Float64}(info.lower))
    end
    return
end

@@ -607,31 +686,52 @@

Loading

        MOI.set(single_blm, MOI.VariablePrimalStart(), dual[], info.start)
    end
    if !isnan(info.upper) &&
        !MOI.is_valid(single_blm, CI{MOI.VariableIndex,LT{Float64}}(dual[].value))
        MOI.add_constraint(single_blm,
            dual[], LT{Float64}(info.upper))
       !MOI.is_valid(
        single_blm,
        CI{MOI.VariableIndex,LT{Float64}}(dual[].value),
    )
        MOI.add_constraint(single_blm, dual[], LT{Float64}(info.upper))
    end
    if !isnan(info.lower) &&
        !MOI.is_valid(single_blm, CI{MOI.VariableIndex,GT{Float64}}(dual[].value))
        MOI.add_constraint(single_blm,
            dual[], GT{Float64}(info.lower))
       !MOI.is_valid(
        single_blm,
        CI{MOI.VariableIndex,GT{Float64}}(dual[].value),
    )
        MOI.add_constraint(single_blm, dual[], GT{Float64}(info.lower))
    end
    return
end
function pass_dual_info(single_blm, dual, info::BilevelConstraintInfo{Vector{Float64}})
function pass_dual_info(
    single_blm,
    dual,
    info::BilevelConstraintInfo{Vector{Float64}},
)
    for i in eachindex(dual)
        if !isnan(info.start[i])
            MOI.set(single_blm, MOI.VariablePrimalStart(), dual[i], info.start[i])
            MOI.set(
                single_blm,
                MOI.VariablePrimalStart(),
                dual[i],
                info.start[i],
            )
        end
        if !isnan(info.upper[i]) &&
            !MOI.is_valid(single_blm, CI{MOI.VariableIndex,LT{Float64}}(dual[i].value))
            MOI.add_constraint(single_blm,
                dual[i], LT{Float64}(info.upper[i]))
           !MOI.is_valid(
            single_blm,
            CI{MOI.VariableIndex,LT{Float64}}(dual[i].value),
        )
            MOI.add_constraint(single_blm, dual[i], LT{Float64}(info.upper[i]))
        end
        if !isnan(info.lower[i]) &&
            !MOI.is_valid(single_blm, CI{MOI.VariableIndex,GT{Float64}}(dual[i].value))
            MOI.add_constraint(single_blm,
                dual[i], MOI.GreaterThan{Float64}(info.lower[i]))
           !MOI.is_valid(
            single_blm,
            CI{MOI.VariableIndex,GT{Float64}}(dual[i].value),
        )
            MOI.add_constraint(
                single_blm,
                dual[i],
                MOI.GreaterThan{Float64}(info.lower[i]),
            )
        end
    end
    return

@@ -705,13 +805,13 @@

Loading

inf_if_nan(::typeof(-), val) = ifelse(isnan(val), -Inf, val)

dual_lower_bound(::CI{F,LT{T}}) where {F,T} = -Inf
dual_upper_bound(::CI{F,LT{T}}) where {F,T} =  0.0
dual_upper_bound(::CI{F,LT{T}}) where {F,T} = 0.0

dual_lower_bound(::CI{F,GT{T}}) where {F,T} =  0.0
dual_lower_bound(::CI{F,GT{T}}) where {F,T} = 0.0
dual_upper_bound(::CI{F,GT{T}}) where {F,T} = +Inf

dual_lower_bound(::CI{F,ET{T}}) where {F,T} =  0.0
dual_upper_bound(::CI{F,ET{T}}) where {F,T} =  0.0
dual_lower_bound(::CI{F,ET{T}}) where {F,T} = 0.0
dual_upper_bound(::CI{F,ET{T}}) where {F,T} = 0.0

dual_lower_bound(::CI{F,S}) where {F,S} = -Inf
dual_upper_bound(::CI{F,S}) where {F,S} = +Inf

@@ -720,17 +820,23 @@

Loading


function _check_solver(bm::BilevelModel)
    if bm.solver === nothing
        error("No solver attached, use `set_optimizer(model, optimizer_constructor)` or initialize with `BilevelModel(optimizer_constructor)`")
        error(
            "No solver attached, use `set_optimizer(model, optimizer_constructor)` or initialize with `BilevelModel(optimizer_constructor)`",
        )
    end
end

function JuMP.set_optimizer(bm::BilevelModel, optimizer_constructor;
    add_bridges::Bool=true)
function JuMP.set_optimizer(
    bm::BilevelModel,
    optimizer_constructor;
    add_bridges::Bool = true,
)
    # error_if_direct_mode(model, :set_optimizer)
    if add_bridges
        # If `default_copy_to` without names is supported,
        # no need for a second cache.
        optimizer = MOI.instantiate(optimizer_constructor, with_bridge_type=Float64)
        optimizer =
            MOI.instantiate(optimizer_constructor; with_bridge_type = Float64)
        # for bridge_type in model.bridge_types
        #     _moi_add_bridge(optimizer, bridge_type)
        # end

@@ -740,26 +846,34 @@

Loading


    bm.solver = optimizer
    if !MOI.is_empty(bm.solver)
        error("Calling the `optimizer_constructor` must return an empty optimizer")
        error(
            "Calling the `optimizer_constructor` must return an empty optimizer",
        )
    end
    return bm
end


function pass_cache(bm::BilevelModel, mode::FortunyAmatMcCarlMode{T}) where T
function pass_cache(bm::BilevelModel, mode::FortunyAmatMcCarlMode{T}) where {T}
    mode.cache = bm.mode.cache
    return nothing
end
function pass_cache(bm::BilevelModel, mode::AbstractBilevelSolverMode{T}) where T
function pass_cache(
    bm::BilevelModel,
    mode::AbstractBilevelSolverMode{T},
) where {T}
    return nothing
end

function check_mixed_mode(::MixedMode{T}) where T
end
function check_mixed_mode(::MixedMode{T}) where {T} end
function check_mixed_mode(mode)
    error("Cant set/get mode on a specific object because the base mode is $mode while it should be MixedMode in this case. Run `set_mode(model, BilevelJuMP.MixedMode())`")
    return error(
        "Cant set/get mode on a specific object because the base mode is $mode while it should be MixedMode in this case. Run `set_mode(model, BilevelJuMP.MixedMode())`",
    )
end
function set_mode(ci::BilevelConstraintRef, mode::AbstractBilevelSolverMode{T}) where T
function set_mode(
    ci::BilevelConstraintRef,
    mode::AbstractBilevelSolverMode{T},
) where {T}
    bm = ci.model
    check_mixed_mode(bm.mode)
    _mode = deepcopy(mode)

@@ -787,15 +901,18 @@

Loading

    end
end

function set_mode(::BilevelConstraintRef, ::MixedMode{T}) where T
    error("Cant set MixedMode in a specific constraint")
function set_mode(::BilevelConstraintRef, ::MixedMode{T}) where {T}
    return error("Cant set MixedMode in a specific constraint")
end
function set_mode(::BilevelConstraintRef, ::StrongDualityMode{T}) where T
    error("Cant set StrongDualityMode in a specific constraint")
function set_mode(::BilevelConstraintRef, ::StrongDualityMode{T}) where {T}
    return error("Cant set StrongDualityMode in a specific constraint")
end

# mode for variable bounds
function set_mode(vi::BilevelVariableRef, mode::AbstractBilevelSolverMode{T}) where T
function set_mode(
    vi::BilevelVariableRef,
    mode::AbstractBilevelSolverMode{T},
) where {T}
    bm = vi.model
    check_mixed_mode(bm.mode)
    _mode = deepcopy(mode)

@@ -824,19 +941,19 @@

Loading

    end
end

function set_mode(::BilevelVariableRef, ::MixedMode{T}) where T
    error("Cant set MixedMode in a specific variable")
function set_mode(::BilevelVariableRef, ::MixedMode{T}) where {T}
    return error("Cant set MixedMode in a specific variable")
end
function set_mode(::BilevelVariableRef, ::StrongDualityMode{T}) where T
    error("Cant set StrongDualityMode in a specific variable")
function set_mode(::BilevelVariableRef, ::StrongDualityMode{T}) where {T}
    return error("Cant set StrongDualityMode in a specific variable")
end

function MOI.set(::BilevelModel, ::MOI.LazyConstraintCallback, func)
    error("Callbacks are not available in BilevelJuMP Models")
    return error("Callbacks are not available in BilevelJuMP Models")
end
function MOI.set(::BilevelModel, ::MOI.UserCutCallback, func)
    error("Callbacks are not available in BilevelJuMP Models")
    return error("Callbacks are not available in BilevelJuMP Models")
end
function MOI.set(::BilevelModel, ::MOI.HeuristicCallback, func)
    error("Callbacks are not available in BilevelJuMP Models")
end

@@ -1,8 +1,8 @@

Loading

function in_upper(cref::BilevelConstraintRef)
    cref.model.ctr_info[cref.index].level == UPPER_ONLY
    return cref.model.ctr_info[cref.index].level == UPPER_ONLY
end
function in_lower(cref::BilevelConstraintRef)
    cref.model.ctr_info[cref.index].level == LOWER_ONLY
    return cref.model.ctr_info[cref.index].level == LOWER_ONLY
end
function raw_ref(model::BilevelModel, idx::Int)
    if haskey(model.ctr_upper, idx)

@@ -20,24 +20,34 @@

Loading

    return JuMP.ConstraintRef(model, idx, raw.shape)
end
level(cref::BilevelConstraintRef) = cref.model.ctr_info[cref.index].level
function JuMP.add_constraint(::BilevelModel, ::JuMP.AbstractConstraint, ::String="")
    error(
        "Can't add constraint directly to the bilevel model `m`, "*
        "attach the constraint to the upper or lower model "*
        "with @constraint(Upper(m), ...) or @constraint(Lower(m), ...)")
function JuMP.add_constraint(
    ::BilevelModel,
    ::JuMP.AbstractConstraint,
    ::String = "",
)
    return error(
        "Can't add constraint directly to the bilevel model `m`, " *
        "attach the constraint to the upper or lower model " *
        "with @constraint(Upper(m), ...) or @constraint(Lower(m), ...)",
    )
end
function JuMP.constraint_object(con_ref::ConstraintRef{BilevelModel, Int})
function JuMP.constraint_object(con_ref::ConstraintRef{BilevelModel,Int})
    raw = raw_ref(con_ref)
    return JuMP.constraint_object(raw)
end
# JuMP.add_constraint(m::UpperModel, c::JuMP.VectorConstraint, name::String="") =
#     error("no vec ctr")
function JuMP.add_constraint(m::InnerBilevelModel, c::Union{JuMP.ScalarConstraint{F,S},JuMP.VectorConstraint{F,S}}, name::String="") where {F,S}
function JuMP.add_constraint(
    m::InnerBilevelModel,
    c::Union{JuMP.ScalarConstraint{F,S},JuMP.VectorConstraint{F,S}},
    name::String = "",
) where {F,S}
    blm = bilevel_model(m)
    blm.nextconidx += 1
    cref = JuMP.ConstraintRef(blm, blm.nextconidx, JuMP.shape(c))
    func = JuMP.jump_function(c)
    level_func = replace_variables(func, bilevel_model(m), mylevel_var_list(m), level(m))
    level_func =
        replace_variables(func, bilevel_model(m), mylevel_var_list(m), level(m))
    level_c = JuMP.build_constraint(error, level_func, c.set)
    level_cref = JuMP.add_constraint(mylevel_model(m), level_c, name)
    mylevel_ctr_list(m)[cref.index] = level_cref

@@ -47,12 +57,15 @@

Loading

    end
    blm.ctr_upper_rev = nothing
    blm.ctr_lower_rev = nothing
    cref
    return cref
end

JuMP.is_valid(m::BilevelModel, cref::BilevelConstraintRef) = cref.index in keys(m.ctr_info)
JuMP.is_valid(m::InnerBilevelModel, cref::BilevelConstraintRef) =
    JuMP.is_valid(bilevel_model(m), cref) && level(cref) == level(m)
function JuMP.is_valid(m::BilevelModel, cref::BilevelConstraintRef)
    return cref.index in keys(m.ctr_info)
end
function JuMP.is_valid(m::InnerBilevelModel, cref::BilevelConstraintRef)
    return JuMP.is_valid(bilevel_model(m), cref) && level(cref) == level(m)
end
function JuMP.constraint_object(cref::BilevelConstraintRef, F::Type, S::Type)
    cidx = cref.index
    model = cref.model

@@ -65,16 +78,21 @@

Loading

        return reverse_replace_variable(con, Lower(model))
    end
end
function reverse_replace_variable(con::JuMP.VectorConstraint, m::InnerBilevelModel)
function reverse_replace_variable(
    con::JuMP.VectorConstraint,
    m::InnerBilevelModel,
)
    func = reverse_replace_variable(con.func, m)
    JuMP.VectorConstraint(func, con.set, con.shape)
    return JuMP.VectorConstraint(func, con.set, con.shape)
end
function reverse_replace_variable(con::JuMP.ScalarConstraint, m::InnerBilevelModel)
function reverse_replace_variable(
    con::JuMP.ScalarConstraint,
    m::InnerBilevelModel,
)
    func = reverse_replace_variable(con.func, m)
    JuMP.ScalarConstraint(func, con.set)
    return JuMP.ScalarConstraint(func, con.set)
end


function empty_info(level, c::JuMP.ScalarConstraint{F,S}) where {F,S}
    return BilevelConstraintInfo{Float64}(level)
end

@@ -84,71 +102,101 @@

Loading


function _assert_dim(cref, array::Vector, value::Vector)
    if length(array) != length(value)
        error("For the Vector constraint {$(cref)}, expected a Vector of length = $(length(array)) and got a Vector of length = $(length(value))")
        error(
            "For the Vector constraint {$(cref)}, expected a Vector of length = $(length(array)) and got a Vector of length = $(length(value))",
        )
    end
    return
end
function _assert_dim(cref, array::Vector, value::Number)
    error("For the Vector constraint {$(cref)}, expected a Vector (of length = $(length(array))) and got the scalar $value")
    error(
        "For the Vector constraint {$(cref)}, expected a Vector (of length = $(length(array))) and got the scalar $value",
    )
    return
end
function _assert_dim(cref, array::Number, value::Number)
    return
end
function _assert_dim(cref, array::Number, value::Vector)
    error("For the Scalar constraint {$(cref)}, expected a Scalar and got the Vector $(value)")
    error(
        "For the Scalar constraint {$(cref)}, expected a Scalar and got the Vector $(value)",
    )
    return
end

function JuMP.set_dual_start_value(cref::BilevelConstraintRef, value::T) where T<:Number
function JuMP.set_dual_start_value(
    cref::BilevelConstraintRef,
    value::T,
) where {T<:Number}
    _assert_dim(cref, cref.model.ctr_info[cref.index].start, value)
    cref.model.ctr_info[cref.index].start = value
    return cref.model.ctr_info[cref.index].start = value
end
function JuMP.set_dual_start_value(cref::BilevelConstraintRef, value::T) where T<:Vector{S} where S
function JuMP.set_dual_start_value(
    cref::BilevelConstraintRef,
    value::T,
) where {T<:Vector{S}} where {S}
    array = cref.model.ctr_info[cref.index].start
    _assert_dim(cref, array, value)
    copyto!(array, value)
    return copyto!(array, value)
end
function JuMP.dual_start_value(cref::BilevelConstraintRef)
    cref.model.ctr_info[cref.index].start
    return cref.model.ctr_info[cref.index].start
end

function set_dual_upper_bound_hint(cref::BilevelConstraintRef, value::T) where T<:Number
function set_dual_upper_bound_hint(
    cref::BilevelConstraintRef,
    value::T,
) where {T<:Number}
    _assert_dim(cref, cref.model.ctr_info[cref.index].upper, value)
    cref.model.ctr_info[cref.index].upper = value
    return cref.model.ctr_info[cref.index].upper = value
end
function set_dual_upper_bound_hint(cref::BilevelConstraintRef, value::T) where T<:Vector{S} where S
function set_dual_upper_bound_hint(
    cref::BilevelConstraintRef,
    value::T,
) where {T<:Vector{S}} where {S}
    array = cref.model.ctr_info[cref.index].upper
    _assert_dim(cref, array, value)
    copyto!(array, value)
    return copyto!(array, value)
end
function get_dual_upper_bound_hint(cref::BilevelConstraintRef)
    cref.model.ctr_info[cref.index].upper
    return cref.model.ctr_info[cref.index].upper
end
function set_dual_lower_bound_hint(cref::BilevelConstraintRef, value::T) where T<:Number
function set_dual_lower_bound_hint(
    cref::BilevelConstraintRef,
    value::T,
) where {T<:Number}
    _assert_dim(cref, cref.model.ctr_info[cref.index].lower, value)
    cref.model.ctr_info[cref.index].lower = value
    return cref.model.ctr_info[cref.index].lower = value
end
function set_dual_lower_bound_hint(cref::BilevelConstraintRef, value::T) where T<:Vector{S} where S
function set_dual_lower_bound_hint(
    cref::BilevelConstraintRef,
    value::T,
) where {T<:Vector{S}} where {S}
    array = cref.model.ctr_info[cref.index].lower
    _assert_dim(cref, array, value)
    copyto!(array, value)
    return copyto!(array, value)
end
function get_dual_lower_bound_hint(cref::BilevelConstraintRef)
    cref.model.ctr_info[cref.index].lower
    return cref.model.ctr_info[cref.index].lower
end

function set_primal_upper_bound_hint(vref::BilevelVariableRef, value::T) where T<:Number
    vref.model.var_info[vref.idx].upper = value
function set_primal_upper_bound_hint(
    vref::BilevelVariableRef,
    value::T,
) where {T<:Number}
    return vref.model.var_info[vref.idx].upper = value
end
function get_primal_upper_bound_hint(vref::BilevelVariableRef)
    vref.model.var_info[vref.idx].upper
    return vref.model.var_info[vref.idx].upper
end
function set_primal_lower_bound_hint(vref::BilevelVariableRef, value::T) where T<:Number
    vref.model.var_info[vref.idx].lower = value
function set_primal_lower_bound_hint(
    vref::BilevelVariableRef,
    value::T,
) where {T<:Number}
    return vref.model.var_info[vref.idx].lower = value
end
function get_primal_lower_bound_hint(vref::BilevelVariableRef)
    vref.model.var_info[vref.idx].lower
    return vref.model.var_info[vref.idx].lower
end

function JuMP.value(cref::BilevelConstraintRef; result::Int = 1)

@@ -165,7 +213,11 @@

Loading

    end
    # Solver constraint associated with the single bilevel model constraint
    con_solver_idx = cref.model.sblm_to_solver[con_sblm_idx]
    return MOI.get(cref.model.solver, MOI.ConstraintPrimal(result), con_solver_idx)
    return MOI.get(
        cref.model.solver,
        MOI.ConstraintPrimal(result),
        con_solver_idx,
    )
end
# variables again (duals)
# code for using dual variables associated with lower level constraints

@@ -185,14 +237,14 @@

Loading

end
function JuMP.num_constraints(model::BilevelModel, f, s)
    return JuMP.num_constraints(Upper(model), f, s) +
        JuMP.num_constraints(Lower(model), f, s)
           JuMP.num_constraints(Lower(model), f, s)
end

struct DualOf
    ci::BilevelConstraintRef
end
function DualOf(::AbstractArray{<:T}) where {T<:JuMP.ConstraintRef}
    error(
    return error(
        "If you are trying to do something like:\n" *
        "@constraint(Lower(m), my_constraint_vector[t in 1:T], ...)\n" *
        "@variable(Upper(m), my_variable[1:N], " *

@@ -201,7 +253,7 @@

Loading

        "@variable(Upper(m), my_variable[t=1:N], " *
        "DualOf(my_constraint_vector[t]))\n" *
        "Or use anonynous variables:\n" *
        "@variable(Upper(m), variable_type = DualOf(my_constraint_vector[t]))"
        "@variable(Upper(m), variable_type = DualOf(my_constraint_vector[t]))",
    )
end
struct DualVariableInfo

@@ -214,9 +266,10 @@

Loading

    dual_of::DualOf;
    extra_kw_args...,
)

    if level(dual_of.ci) != LOWER_ONLY
        error("Variables can only be tied to LOWER level constraints, got $(dual_of.ci.level) level")
        error(
            "Variables can only be tied to LOWER level constraints, got $(dual_of.ci.level) level",
        )
    end
    for (kwarg, _) in extra_kw_args
        _error("Unrecognized keyword argument $kwarg")

@@ -232,37 +285,48 @@

Loading

        # info.has_ub = false
        # info.upper_bound = NaN
    end
    info.has_fix   && _error("Dual variable does not support fixing")
    info.has_fix && _error("Dual variable does not support fixing")
    if info.has_start
        JuMP.set_dual_start_value(dual_of.ci, info.start)
        # info.has_start = false
        # info.start = NaN
    end
    info.binary    && _error("Dual variable cannot be binary")
    info.integer   && _error("Dual variable cannot be integer")
    info.binary && _error("Dual variable cannot be binary")
    info.integer && _error("Dual variable cannot be integer")

    info = JuMP.VariableInfo(false, NaN, false, NaN,
                             false, NaN, false, NaN,
                             false, false)

    return DualVariableInfo(
        info,
        dual_of.ci
    info = JuMP.VariableInfo(
        false,
        NaN,
        false,
        NaN,
        false,
        NaN,
        false,
        NaN,
        false,
        false,
    )

    return DualVariableInfo(info, dual_of.ci)
end
function JuMP.add_variable(inner::UpperModel, dual_info::DualVariableInfo, name::String="")
function JuMP.add_variable(
    inner::UpperModel,
    dual_info::DualVariableInfo,
    name::String = "",
)
    # TODO vector version
    m = bilevel_model(inner)
    m.last_variable_index += 1
    vref = BilevelVariableRef(m, m.last_variable_index, DUAL_OF_LOWER)
    v_upper = JuMP.add_variable(m.upper, JuMP.ScalarVariable(dual_info.info), name)
    v_upper =
        JuMP.add_variable(m.upper, JuMP.ScalarVariable(dual_info.info), name)
    m.var_upper[vref.idx] = v_upper
    m.upper_var_to_lower_ctr_link[v_upper] = m.ctr_lower[dual_info.ci.index]
    m.var_info[vref.idx] = empty_info(DUAL_OF_LOWER)
    JuMP.set_name(vref, name)
    m.var_upper_rev = nothing
    m.var_lower_rev = nothing
    vref
    return vref
end

function get_constrain_ref(vref::BilevelVariableRef)

@@ -285,7 +349,8 @@

Loading

        con_lower_ref = cref.model.ctr_lower[cref.index]
        con_lower_idx = con_lower_ref.index
        # Dual variable associated with constraint index
        model_var_idxs = cref.model.lower_primal_dual_map.primal_con_dual_var[con_lower_idx]
        model_var_idxs =
            cref.model.lower_primal_dual_map.primal_con_dual_var[con_lower_idx]
        # Single bilevel model variable associated with the dual variable
        sblm_var_idxs = MOI.VariableIndex[]
        for vi in model_var_idxs

@@ -296,22 +361,27 @@

Loading

        for vi in sblm_var_idxs
            push!(solver_var_idxs, cref.model.sblm_to_solver[vi])
        end
        pre_duals = MOI.get(cref.model.solver, MOI.VariablePrimal(), solver_var_idxs)
        pre_duals =
            MOI.get(cref.model.solver, MOI.VariablePrimal(), solver_var_idxs)
        return JuMP.reshape_vector(
            pre_duals,
            JuMP.dual_shape(con_lower_ref.shape)
            )
            JuMP.dual_shape(con_lower_ref.shape),
        )
    elseif in_upper(cref)
        m = cref.model
        con_upper_ref = cref.model.ctr_upper[cref.index]
        solver_ctr_idx = m.sblm_to_solver[m.upper_to_sblm[JuMP.index(con_upper_ref)]]
        pre_duals = MOI.get(cref.model.solver, MOI.ConstraintDual(), solver_ctr_idx)
        solver_ctr_idx =
            m.sblm_to_solver[m.upper_to_sblm[JuMP.index(con_upper_ref)]]
        pre_duals =
            MOI.get(cref.model.solver, MOI.ConstraintDual(), solver_ctr_idx)
        return JuMP.reshape_vector(
            pre_duals,
            JuMP.dual_shape(con_upper_ref.shape)
            )
            JuMP.dual_shape(con_upper_ref.shape),
        )
    else
        error("Dual solutions of upper level constraints are not available. Either the solution method does nto porvide duals or or the solver failed to get one.")
        error(
            "Dual solutions of upper level constraints are not available. Either the solution method does nto porvide duals or or the solver failed to get one.",
        )
    end
end


@@ -327,7 +397,10 @@

Loading

    return JuMP.add_to_function_constant(raw_ref(cref), val)
end

function JuMP.normalized_coefficient(cref::BilevelConstraintRef, var::BilevelVariableRef)
function JuMP.normalized_coefficient(
    cref::BilevelConstraintRef,
    var::BilevelVariableRef,
)
    model = cref.model
    level_var = if in_upper(cref)
        model.var_upper[var.idx]

@@ -338,7 +411,10 @@

Loading

end

function JuMP.set_normalized_coefficient(
    cref::BilevelConstraintRef, var::BilevelVariableRef, val)
    cref::BilevelConstraintRef,
    var::BilevelVariableRef,
    val,
)
    model = cref.model
    level_var = if in_upper(cref)
        model.var_upper[var.idx]

@@ -356,35 +432,39 @@

Loading

function JuMP.list_of_constraint_types(
    model::BilevelModel,
)::Vector{Tuple{DataType,DataType}}
    return unique!(vcat(
        JuMP.list_of_constraint_types(Upper(model)),
        JuMP.list_of_constraint_types(Lower(model)),
    ))
    return unique!(
        vcat(
            JuMP.list_of_constraint_types(Upper(model)),
            JuMP.list_of_constraint_types(Lower(model)),
        ),
    )
end

function JuMP.all_constraints(model::BilevelModel, f, s)
    return unique!(vcat(
        JuMP.all_constraints(Upper(model), f, s),
        JuMP.all_constraints(Lower(model), f, s),
    ))
    return unique!(
        vcat(
            JuMP.all_constraints(Upper(model), f, s),
            JuMP.all_constraints(Lower(model), f, s),
        ),
    )
end

function JuMP.all_constraints(model::InnerBilevelModel, f, s)
    build_reverse_ctr_map!(model)
    m = mylevel_model(model)
    list = JuMP.all_constraints(m, f, s)
    get_reverse_ctr_map.(model, list)
    return get_reverse_ctr_map.(model, list)
end
function build_reverse_ctr_map!(um::UpperModel)
    m = bilevel_model(um)
    m.ctr_upper_rev = Dict{JuMP.ConstraintRef, JuMP.ConstraintRef}()
    m.ctr_upper_rev = Dict{JuMP.ConstraintRef,JuMP.ConstraintRef}()
    for (idx, ref) in m.ctr_upper
        m.ctr_upper_rev[ref] = BilevelConstraintRef(m, idx)
    end
end
function build_reverse_ctr_map!(lm::LowerModel)
    m = bilevel_model(lm)
    m.ctr_lower_rev = Dict{JuMP.ConstraintRef, JuMP.ConstraintRef}()
    m.ctr_lower_rev = Dict{JuMP.ConstraintRef,JuMP.ConstraintRef}()
    for (idx, ref) in m.ctr_lower
        m.ctr_lower_rev[ref] = BilevelConstraintRef(m, idx)
    end

@@ -411,4 +491,4 @@

Loading

411	491		model.ctr_upper_rev = nothing
412	492		model.ctr_lower_rev = nothing
413	493		return nothing
414		-	end

@@ -7,10 +7,16 @@

Loading


function JuMP.set_optimizer_attribute(bm::BilevelModel, name::String, value)
    _check_solver(bm)
    return JuMP.set_optimizer_attribute(bm, MOI.RawOptimizerAttribute(name), value)
    return JuMP.set_optimizer_attribute(
        bm,
        MOI.RawOptimizerAttribute(name),
        value,
    )
end
function JuMP.set_optimizer_attribute(
    bm::BilevelModel, attr::MOI.AbstractOptimizerAttribute, value
    bm::BilevelModel,
    attr::MOI.AbstractOptimizerAttribute,
    value,
)
    _check_solver(bm)
    return MOI.set(bm.solver, attr, value)

@@ -23,10 +29,14 @@

Loading


function JuMP.get_optimizer_attribute(bm::BilevelModel, name::String)
    _check_solver(bm)
    return JuMP.get_optimizer_attribute(bm.solver, MOI.RawOptimizerAttribute(name))
    return JuMP.get_optimizer_attribute(
        bm.solver,
        MOI.RawOptimizerAttribute(name),
    )
end
function JuMP.get_optimizer_attribute(
    bm::BilevelModel, attr::MOI.AbstractOptimizerAttribute
    bm::BilevelModel,
    attr::MOI.AbstractOptimizerAttribute,
)
    _check_solver(bm)
    return MOI.get(bm.solver, attr)

@@ -95,4 +105,4 @@

Loading

95	105		end
96	106		function get_pass_start(bm::BilevelModel)
97	107		return bm.pass_start
98		-	end

@@ -1,38 +1,55 @@

Loading

function JuMP.set_objective_sense(m::InnerBilevelModel, sense::MOI.OptimizationSense)
    JuMP.set_objective_sense(mylevel_model(m), sense)
function JuMP.set_objective_sense(
    m::InnerBilevelModel,
    sense::MOI.OptimizationSense,
)
    return JuMP.set_objective_sense(mylevel_model(m), sense)
end
function JuMP.set_objective(
    m::InnerBilevelModel,
    sense::MOI.OptimizationSense,
    f::JuMP.AbstractJuMPScalar,
)
    level_f =
        replace_variables(f, bilevel_model(m), mylevel_var_list(m), level(m))
    return JuMP.set_objective(mylevel_model(m), sense, level_f)
end
function JuMP.set_objective(
    m::InnerBilevelModel,
    sense::MOI.OptimizationSense,
    f::Real,
)
    return JuMP.set_objective(mylevel_model(m), sense, f)
end
function JuMP.objective_sense(m::InnerBilevelModel)
    return JuMP.objective_sense(mylevel_model(m))
end
function JuMP.set_objective(m::InnerBilevelModel, sense::MOI.OptimizationSense,
    f::JuMP.AbstractJuMPScalar)
    level_f = replace_variables(f, bilevel_model(m), mylevel_var_list(m), level(m))
    JuMP.set_objective(mylevel_model(m), sense, level_f)
end
function JuMP.set_objective(m::InnerBilevelModel, sense::MOI.OptimizationSense,
    f::Real)
    JuMP.set_objective(mylevel_model(m), sense, f)
end
JuMP.objective_sense(m::InnerBilevelModel) = JuMP.objective_sense(mylevel_model(m))
function JuMP.objective_function_type(m::InnerBilevelModel)
    tp = JuMP.objective_function_type(mylevel_model(m))
    return bilevel_type(m, tp)
end
bilevel_type(::InnerBilevelModel, ::Type{JuMP.VariableRef}) = BilevelVariableRef
function bilevel_type(::InnerBilevelModel, ::Type{JuMP.GenericAffExpr{C, V}}
) where {C, V}
    JuMP.GenericAffExpr{C, BilevelVariableRef}
end
function bilevel_type(::InnerBilevelModel, ::Type{JuMP.GenericQuadExpr{C, V}}
) where {C, V}
    JuMP.GenericAffExpr{C, BilevelVariableRef}
function bilevel_type(
    ::InnerBilevelModel,
    ::Type{JuMP.GenericAffExpr{C,V}},
) where {C,V}
    return JuMP.GenericAffExpr{C,BilevelVariableRef}
end
function bilevel_type(
    ::InnerBilevelModel,
    ::Type{JuMP.GenericQuadExpr{C,V}},
) where {C,V}
    return JuMP.GenericAffExpr{C,BilevelVariableRef}
end
# JuMP.objective_function(m::InnerBilevelModel) = mylevel_obj_function(m)
function JuMP.objective_function(m::InnerBilevelModel)
    f = JuMP.objective_function(mylevel_model(m))
    reverse_replace_variable(f, m)
    return reverse_replace_variable(f, m)
end
function JuMP.objective_function(m::InnerBilevelModel, FT::Type)
    f = JuMP.objective_function(mylevel_model(m), FT)
    f2 = reverse_replace_variable(f, m)
    f2 isa FT || error("The objective function is not of type $FT, show $(typeof(f2))")
    f2 isa FT ||
        error("The objective function is not of type $FT, show $(typeof(f2))")
    return f2
end


@@ -43,7 +60,7 @@

Loading

function JuMP.relative_gap(bm::UpperModel)::Float64
    return JuMP.relative_gap(bm.m)
end
function JuMP.dual_objective_value(bm::BilevelModel; result::Int=1)::Float64
function JuMP.dual_objective_value(bm::BilevelModel; result::Int = 1)::Float64
    _check_solver(bm)
    return MOI.get(bm.solver, MOI.DualObjectiveValue(result))
end

@@ -55,18 +72,25 @@

Loading

    return JuMP.objective_bound(bm.m)
end

function JuMP.set_objective(m::BilevelModel, sense::MOI.OptimizationSense,
    f::JuMP.AbstractJuMPScalar)
    bilevel_obj_error()
function JuMP.set_objective(
    m::BilevelModel,
    sense::MOI.OptimizationSense,
    f::JuMP.AbstractJuMPScalar,
)
    return bilevel_obj_error()
end
JuMP.objective_sense(m::BilevelModel) = JuMP.objective_sense(m.upper)# bilevel_obj_error()
JuMP.objective_function_type(model::BilevelModel) = bilevel_obj_error()
JuMP.objective_function(model::BilevelModel) = bilevel_obj_error()
function JuMP.objective_function(model::BilevelModel, FT::Type)
    bilevel_obj_error()
    return bilevel_obj_error()
end

bilevel_obj_error() = error("There is no objective for BilevelModel use Upper(.) and Lower(.)")
function bilevel_obj_error()
    return error(
        "There is no objective for BilevelModel use Upper(.) and Lower(.)",
    )
end

function JuMP.objective_value(model::BilevelModel)
    _check_solver(model)

@@ -82,22 +106,26 @@

Loading

function lower_objective_value(model::BilevelModel; result::Int = 1)
    f = JuMP.objective_function(Lower(model))
    # Evaluate the lower objective expression
    return JuMP.value(f, result = result)
    return JuMP.value(f; result = result)
    # return JuMP.value(v -> JuMP.value(v, result = result), f)
    # return JuMP.value(v -> inner_ref_to_value(Lower(model), v), f)
end

function JuMP.set_objective_coefficient(
    ::UpperModel, variable::BilevelVariableRef, coeff::Real)
    ::UpperModel,
    variable::BilevelVariableRef,
    coeff::Real,
)
    level_var = variable.model.var_upper[variable.idx]
    model = JuMP.owner_model(level_var)
    JuMP.set_objective_coefficient(
        model, level_var, coeff)
    return JuMP.set_objective_coefficient(model, level_var, coeff)
end
function JuMP.set_objective_coefficient(
    ::LowerModel, variable::BilevelVariableRef, coeff::Real)
    ::LowerModel,
    variable::BilevelVariableRef,
    coeff::Real,
)
    level_var = variable.model.var_lower[variable.idx]
    model = JuMP.owner_model(level_var)
    JuMP.set_objective_coefficient(
        model, level_var, coeff)
end

@@ -1,10 +1,13 @@

Loading


mylevel(v::BilevelVariableRef) = v.level
in_level(v::BilevelVariableRef, level::Level) = (
    v.level === LOWER_BOTH ||
    v.level === UPPER_BOTH ||
    v.level === level ||
    (v.level === DUAL_OF_LOWER && level === UPPER_ONLY))
function in_level(v::BilevelVariableRef, level::Level)
    return (
        v.level === LOWER_BOTH ||
        v.level === UPPER_BOTH ||
        v.level === level ||
        (v.level === DUAL_OF_LOWER && level === UPPER_ONLY)
    )
end

in_level(v::BilevelVariableRef, ::UpperModel) = in_upper(v)
in_level(v::BilevelVariableRef, ::LowerModel) = in_lower(v)

@@ -13,8 +16,8 @@

Loading

upper_ref(v::BilevelVariableRef) = v.model.var_upper[v.idx]
lower_ref(v::BilevelVariableRef) = v.model.var_lower[v.idx]

const BilevelAffExpr = GenericAffExpr{Float64, BilevelVariableRef}
const BilevelQuadExpr = GenericQuadExpr{Float64, BilevelVariableRef}
const BilevelAffExpr = GenericAffExpr{Float64,BilevelVariableRef}
const BilevelQuadExpr = GenericQuadExpr{Float64,BilevelVariableRef}

function jump_var_ref(v::BilevelVariableRef)
    level = mylevel(v)

@@ -28,22 +31,25 @@

Loading

function solver_ref(v::BilevelVariableRef)
    m = v.model
    if mylevel(v) == LOWER_ONLY
        return m.sblm_to_solver[
            m.lower_to_sblm[JuMP.index(lower_ref(v))]]
        return m.sblm_to_solver[m.lower_to_sblm[JuMP.index(lower_ref(v))]]
    else
        return m.sblm_to_solver[
            m.upper_to_sblm[JuMP.index(upper_ref(v))]]
        return m.sblm_to_solver[m.upper_to_sblm[JuMP.index(upper_ref(v))]]
    end
end

Base.broadcastable(v::BilevelVariableRef) = Ref(v)
Base.copy(v::BilevelVariableRef) = v
Base.:(==)(v::BilevelVariableRef, w::BilevelVariableRef) =
    v.model === w.model && v.idx == w.idx && v.level == w.level
function Base.:(==)(v::BilevelVariableRef, w::BilevelVariableRef)
    return v.model === w.model && v.idx == w.idx && v.level == w.level
end
JuMP.owner_model(v::BilevelVariableRef) = v.model
JuMP.isequal_canonical(v::BilevelVariableRef, w::BilevelVariableRef) = v == w
# add in both levels
function JuMP.add_variable(inner::InnerBilevelModel, v::JuMP.AbstractVariable, name::String="")
function JuMP.add_variable(
    inner::InnerBilevelModel,
    v::JuMP.AbstractVariable,
    name::String = "",
)
    m = bilevel_model(inner)
    m.last_variable_index += 1
    vref = BilevelVariableRef(m, m.last_variable_index, level_both(inner))

@@ -58,9 +64,13 @@

Loading

    JuMP.set_name(vref, name)
    m.var_upper_rev = nothing
    m.var_lower_rev = nothing
    vref
    return vref
end
function JuMP.add_variable(single::SingleBilevelModel, v::JuMP.AbstractVariable, name::String="")
function JuMP.add_variable(
    single::SingleBilevelModel,
    v::JuMP.AbstractVariable,
    name::String = "",
)
    m = bilevel_model(single)
    m.last_variable_index += 1
    vref = BilevelVariableRef(m, m.last_variable_index, level(single))

@@ -71,7 +81,7 @@

Loading

    JuMP.set_name(vref, name)
    m.var_upper_rev = nothing
    m.var_lower_rev = nothing
    vref
    return vref
end
function JuMP.delete(::BilevelModel, vref::BilevelVariableRef)
    model = vref.model

@@ -97,9 +107,12 @@

Loading

    model.var_lower_rev = nothing
    return nothing
end
JuMP.is_valid(m::BilevelModel, vref::BilevelVariableRef) = vref.idx in keys(m.var_info)
JuMP.is_valid(m::InnerBilevelModel, vref::BilevelVariableRef) =
    JuMP.is_valid(bilevel_model(m), vref) && in_level(vref, level(m))
function JuMP.is_valid(m::BilevelModel, vref::BilevelVariableRef)
    return vref.idx in keys(m.var_info)
end
function JuMP.is_valid(m::InnerBilevelModel, vref::BilevelVariableRef)
    return JuMP.is_valid(bilevel_model(m), vref) && in_level(vref, level(m))
end
JuMP.num_variables(m::BilevelModel) = length(m.var_info)
JuMP.num_variables(m::UpperModel) = length(m.m.var_upper)
JuMP.num_variables(m::LowerModel) = length(m.m.var_lower)

@@ -130,22 +143,38 @@

Loading

"""
function split_variable(::UpperModel, v::JuMP.AbstractVariable)
    var_upper = v
    var_lower = JuMP.ScalarVariable(JuMP.VariableInfo(
        false, NaN,
        false, NaN,
        false, NaN,
        v.info.has_start, v.info.start,
        false, false))
    var_lower = JuMP.ScalarVariable(
        JuMP.VariableInfo(
            false,
            NaN,
            false,
            NaN,
            false,
            NaN,
            v.info.has_start,
            v.info.start,
            false,
            false,
        ),
    )
    return var_upper, var_lower
end
function split_variable(::LowerModel, v::JuMP.AbstractVariable)
    var_lower = v
    var_upper = JuMP.ScalarVariable(JuMP.VariableInfo(
        false, NaN,
        false, NaN,
        false, NaN,
        v.info.has_start, v.info.start,
        false, false))
    var_upper = JuMP.ScalarVariable(
        JuMP.VariableInfo(
            false,
            NaN,
            false,
            NaN,
            false,
            NaN,
            v.info.has_start,
            v.info.start,
            false,
            false,
        ),
    )
    return var_upper, var_lower
end


@@ -153,14 +182,14 @@

Loading

    if mylevel(vref) == DUAL_OF_LOWER
        return !isnan(get_dual_lower_bound_hint(get_constrain_ref(vref)))
    end
    JuMP.has_lower_bound(jump_var_ref(vref))
    return JuMP.has_lower_bound(jump_var_ref(vref))
end
function JuMP.lower_bound(vref::BilevelVariableRef)
    if mylevel(vref) == DUAL_OF_LOWER
        return get_dual_lower_bound_hint(get_constrain_ref(vref))
    end
    # @assert !JuMP.is_fixed(vref)
    JuMP.lower_bound(jump_var_ref(vref))
    return JuMP.lower_bound(jump_var_ref(vref))
end
function JuMP.set_lower_bound(vref::BilevelVariableRef, lower::Number)
    if mylevel(vref) == DUAL_OF_LOWER

@@ -182,14 +211,14 @@

Loading

    if mylevel(vref) == DUAL_OF_LOWER
        return !isnan(get_dual_upper_bound_hint(get_constrain_ref(vref)))
    end
    JuMP.has_upper_bound(jump_var_ref(vref))
    return JuMP.has_upper_bound(jump_var_ref(vref))
end
function JuMP.upper_bound(vref::BilevelVariableRef)
    if mylevel(vref) == DUAL_OF_LOWER
        return get_dual_upper_bound_hint(get_constrain_ref(vref))
    end
    # @assert !JuMP.is_fixed(vref)
    JuMP.upper_bound(jump_var_ref(vref))
    return JuMP.upper_bound(jump_var_ref(vref))
end
function JuMP.set_upper_bound(vref::BilevelVariableRef, upper)
    if mylevel(vref) == DUAL_OF_LOWER

@@ -204,29 +233,29 @@

Loading

        set_dual_upper_bound_hint(get_constrain_ref(vref), NaN)
        return
    end
    JuMP.delete_upper_bound(jump_var_ref(vref))
    return JuMP.delete_upper_bound(jump_var_ref(vref))
end

JuMP.is_fixed(vref::BilevelVariableRef) = JuMP.is_fixed(jump_var_ref(vref))
JuMP.fix_value(vref::BilevelVariableRef) = JuMP.fix_value(jump_var_ref(vref))
function JuMP.fix(vref::BilevelVariableRef, value; force::Bool=false)
function JuMP.fix(vref::BilevelVariableRef, value; force::Bool = false)
    if mylevel(vref) == DUAL_OF_LOWER
        error("Dual variable cannot be fixed.")
    end
    JuMP.fix(jump_var_ref(vref), value; force=force)
    return JuMP.fix(jump_var_ref(vref), value; force = force)
end
function JuMP.unfix(vref::BilevelVariableRef)
    if mylevel(vref) == DUAL_OF_LOWER
        error("Dual variable cannot be fixed.")
    end
    JuMP.unfix(jump_var_ref(vref))
    return JuMP.unfix(jump_var_ref(vref))
end

function JuMP.start_value(vref::BilevelVariableRef)
    if mylevel(vref) == DUAL_OF_LOWER
        return JuMP.dual_start_value(get_constrain_ref(vref))
    end
    JuMP.start_value(jump_var_ref(vref))
    return JuMP.start_value(jump_var_ref(vref))
end
function JuMP.set_start_value(vref::BilevelVariableRef, start)
    if mylevel(vref) == DUAL_OF_LOWER

@@ -243,26 +272,26 @@

Loading

    if mylevel(vref) == DUAL_OF_LOWER
        error("Dual variable cannot be binary.")
    end
    JuMP.set_binary(jump_var_ref(vref))
    return JuMP.set_binary(jump_var_ref(vref))
end
function JuMP.unset_binary(vref::BilevelVariableRef)
    if mylevel(vref) == DUAL_OF_LOWER
        error("Dual variable cannot be binary.")
    end
    JuMP.unset_binary(jump_var_ref(vref))
    return JuMP.unset_binary(jump_var_ref(vref))
end
JuMP.is_integer(vref::BilevelVariableRef) = JuMP.is_integer(jump_var_ref(vref))
function JuMP.set_integer(vref::BilevelVariableRef)
    if mylevel(vref) == DUAL_OF_LOWER
        error("Dual variable cannot be integer.")
    end
    JuMP.set_integer(jump_var_ref(vref))
    return JuMP.set_integer(jump_var_ref(vref))
end
function JuMP.unset_integer(vref::BilevelVariableRef)
    if mylevel(vref) == DUAL_OF_LOWER
        error("Dual variable cannot be integer.")
    end
    JuMP.unset_integer(jump_var_ref(vref))
    return JuMP.unset_integer(jump_var_ref(vref))
end

function JuMP.value(v::BilevelVariableRef; result::Int = 1)::Float64

@@ -270,4 +299,4 @@

Loading

270	299		solver = m.solver
271	300		ref = solver_ref(v)
272	301		return MOI.get(solver, MOI.VariablePrimal(result), ref)
273		-	end

@@ -6,7 +6,7 @@

Loading

=#

function _has_nlp_data(model)
    return  model.nlp_data !== nothing
    return model.nlp_data !== nothing
end
function _load_nlp_data(model)
    # callen in JuMP.optimize!

@@ -35,7 +35,9 @@

Loading


no_nlp() = error("Non-linear data must be passed to the Upper(.) model")
no_nlp_lower() = error("NLconstraint(s) are not allowed in the lower level")
no_nlp_lower_param() = error("NLparameter(s) are not allowed in the lower level")
function no_nlp_lower_param()
    return error("NLparameter(s) are not allowed in the lower level")
end

JuMP._init_NLP(m::UpperModel) = JuMP._init_NLP(mylevel_model(m))
JuMP._init_NLP(m::LowerModel) = no_nlp_lower()

@@ -49,10 +51,10 @@

Loading

end

function JuMP._new_parameter(::LowerModel, ::Number)
    no_nlp_lower_param()
    return no_nlp_lower_param()
end
function JuMP._new_parameter(::BilevelModel, ::Number)
    no_nlp()
    return no_nlp()
end

# function JuMP.set_objective_function(m::UpperModel, func::JuMP._NonlinearExprData)

@@ -73,7 +75,8 @@

Loading

    m.nlp_data.nlobj = ex
    return
end
function JuMP.set_objective(::LowerModel,
function JuMP.set_objective(
    ::LowerModel,
    ::MOI.OptimizationSense,
    ::JuMP._NonlinearExprData,
)

@@ -86,14 +89,26 @@

Loading

    return nothing
end

function JuMP._parse_NL_expr_runtime(m::UpperModel, x::BilevelVariableRef, tape, parent, values)
function JuMP._parse_NL_expr_runtime(
    m::UpperModel,
    x::BilevelVariableRef,
    tape,
    parent,
    values,
)
    if !in_upper(x)
        error(
            "Variable in nonlinear expression does not belong to the " *
            "upper model, it is a LowerOnly variable",
        )
    end
    JuMP._parse_NL_expr_runtime(mylevel_model(m), upper_ref(x), tape, parent, values)
    JuMP._parse_NL_expr_runtime(
        mylevel_model(m),
        upper_ref(x),
        tape,
        parent,
        values

279	316		con = Complement(true, ci, func, set_with_zero(set), map[ci])
280	317		return con
281	318		end
282		-	function get_canonical_complement(primal_model, map,
283		-	ci::CI{F,S}) where {F, S<:SCALAR_SETS}
	319	+	function get_canonical_complement(
	320	+	primal_model,
	321	+	map,
	322	+	ci::CI{F,S},
	323	+	) where {F,S<:SCALAR_SETS}
284	324		T = Float64
285	325		func = MOI.copy(MOI.get(primal_model, MOI.ConstraintFunction(), ci))::F
286	326		set = MOI.copy(MOI.get(primal_model, MOI.ConstraintSet(), ci))::S
287		-	constant = Dualization.set_dot(1, set, T) *
	327	+	constant =
	328	+	Dualization.set_dot(1, set, T) *
288	329		Dualization.get_scalar_term(primal_model, ci)[]
289	330		if F == MOI.VariableIndex
290	331		func = MOIU.operate(+, T, func, constant)

311	352		mode,
312	353		upper_var_to_lower_ctr::Dict{VI,CI} = Dict{VI,CI}();
313	354		copy_names::Bool = false,
314		-	pass_start::Bool = false
315		-	)
	355	+	pass_start::Bool = false,
	356	+	)
316	357
317	358		# Start with an empty problem
318	359		moi_mode = MOIU.AUTOMATIC
319		-	m = MOIU.CachingOptimizer(MOIU.UniversalFallback(MOIU.Model{Float64}()), moi_mode)
	360	+	m = MOIU.CachingOptimizer(
	361	+	MOIU.UniversalFallback(MOIU.Model{Float64}()),
	362	+	moi_mode,
	363	+	)
320	364
321	365		#=
322	366		Create Lower DUAL level model
323	367		=#
324	368		# dualize the second level
325		-	dual_problem = Dualization.dualize(lower,
326		-	dual_names = DualNames("dual_","dual_"),
	369	+	dual_problem = Dualization.dualize(
	370	+	lower;
	371	+	dual_names = DualNames("dual_", "dual_"),
327	372		variable_parameters = upper_variables,
328	373		ignore_objective = ignore_dual_objective(mode),
329	374		consider_constrained_variables = false,

413	464		=#
414	465
415	466		# build map bound map for FortunyAmatMcCarlMode
416		-	build_full_map!(mode,
417		-	upper_idxmap, lower_idxmap, lower_dual_idxmap, lower_primal_dual_map)
	467	+	build_full_map!(
	468	+	mode,
	469	+	upper_idxmap,
	470	+	lower_idxmap,
	471	+	lower_dual_idxmap,
	472	+	lower_primal_dual_map,
	473	+	)
418	474
419	475		if ignore_dual_objective(mode)
420	476		# complementary slackness

450	529		return CI[c]
451	530		else
452	531		func_up = MOIU.operate(-, T, func, mode.epsilon)
453		-	c_up = MOIU.normalize_and_add_constraint(m, func_up, MOI.LessThan(zero(T)))
	532	+	c_up =
	533	+	MOIU.normalize_and_add_constraint(m, func_up, MOI.LessThan(zero(T)))
454	534		MOI.set(m, MOI.ConstraintName(), c_up, "lower_strong_duality_up")
455	535
456	536		func_lo = MOIU.operate(+, T, func, mode.epsilon)
457		-	c_lo = MOIU.normalize_and_add_constraint(m, func_lo, MOI.GreaterThan(zero(T)))
	537	+	c_lo = MOIU.normalize_and_add_constraint(
	538	+	m,
	539	+	func_lo,
	540	+	MOI.GreaterThan(zero(T)),
	541	+	)
458	542		MOI.set(m, MOI.ConstraintName(), c_lo, "lower_strong_duality_lo")
459	543
460	544		return CI[c_up, c_lo]

514	607		end
515	608		end
516	609		for (idx, func) in mode.function_cache
517		-	_add_aggregate_constraints(
518		-	m, func, eps[idx], idx, copy_names)
	610	+	_add_aggregate_constraints(m, func, eps[idx], idx, copy_names)
519	611		end
520	612		return nothing
521	613		end
522	614
523		-	function _get_eps_idx(mode::ProductMode{T}) where T
	615	+	function _get_eps_idx(mode::ProductMode{T}) where {T}
524	616		idx = mode.aggregation_group
525	617		eps = mode.epsilon
526	618		return eps, idx

10	10		const LT = MOI.LessThan
11	11		const ET = MOI.EqualTo
12	12
13		-	const SCALAR_SETS = Union{
14		-	MOI.GreaterThan{Float64},
15		-	MOI.LessThan{Float64},
16		-	MOI.EqualTo{Float64},
17		-	}
	13	+	const SCALAR_SETS =
	14	+	Union{MOI.GreaterThan{Float64},MOI.LessThan{Float64},MOI.EqualTo{Float64}}
18	15
19		-	const VECTOR_SETS = Union{
20		-	MOI.SecondOrderCone,
21		-	MOI.RotatedSecondOrderCone,
22		-	}
	16	+	const VECTOR_SETS = Union{MOI.SecondOrderCone,MOI.RotatedSecondOrderCone}
23	17
24	18		# dual variable info
25		-	mutable struct BilevelConstraintInfo{T<:Union{Float64, Vector{Float64}}}
	19	+	mutable struct BilevelConstraintInfo{T<:Union{Float64,Vector{Float64}}}
26	20		level::Level
27	21		start::T
28	22		upper::T
29	23		lower::T
30	24		function BilevelConstraintInfo{Float64}(level)
31		-	new(level, NaN, NaN, NaN)
	25	+	return new(level, NaN, NaN, NaN)
32	26		end
33	27		function BilevelConstraintInfo{Vector{Float64}}(level, N::Integer)
34		-	new(level, fill(NaN, N), fill(NaN, N), fill(NaN, N))
	28	+	return new(level, fill(NaN, N), fill(NaN, N), fill(NaN, N))
35	29		end
36	30		end
37	31
38		-	mutable struct BilevelVariableInfo{T<:Union{Float64, Vector{Float64}}}
	32	+	mutable struct BilevelVariableInfo{T<:Union{Float64,Vector{Float64}}}
39	33		level::Level
40	34		upper::T
41	35		lower::T
42	36		function BilevelVariableInfo(level)
43		-	new{Float64}(level, NaN, NaN)
	37	+	return new{Float64}(level, NaN, NaN)
44	38		end
45	39		function BilevelVariableInfo(level, N::Integer)
46		-	new{Vector{Float64}}(level, fill(NaN, N), fill(NaN, N))
	40	+	return new{Vector{Float64}}(level, fill(NaN, N), fill(NaN, N))
47	41		end
48	42		end
49		-	function BilevelVariableInfo(_info::BilevelConstraintInfo{T}) where T
	43	+	function BilevelVariableInfo(_info::BilevelConstraintInfo{T}) where {T}
50	44		if isa(_info.upper, Number)
51	45		info = BilevelVariableInfo(DUAL_OF_LOWER)
52	46		info.lower = _info.lower

60	54		end
61	55
62	56		struct Complement#{M1 <: MOI.ModelLike, M2 <: MOI.ModelLike, F, S}
63		-	is_vec
	57	+	is_vec::Any
64	58		# primal::M1
65		-	constraint
66		-	func_w_cte#::F
67		-	set_w_zero#::S
	59	+	constraint::Any
	60	+	func_w_cte::Any#::F
	61	+	set_w_zero::Any#::S
68	62		# dual::M2
69		-	variable#::VI
	63	+	variable::Any#::VI
70	64		# var_set#::S2
71	65		end
72	66
73	67		abstract type AbstractBilevelSolverMode{T} end
74	68
75		-	mutable struct NoMode{T} <: AbstractBilevelSolverMode{T}
76		-	end
	69	+	mutable struct NoMode{T} <: AbstractBilevelSolverMode{T} end
77	70
78	71		mutable struct SOS1Mode{T} <: AbstractBilevelSolverMode{T}
79	72		function SOS1Mode()

83	76
84	77		mutable struct ComplementMode{T} <: AbstractBilevelSolverMode{T}
85	78		with_slack::Bool
86		-	function ComplementMode(;with_slack = false)
	79	+	function ComplementMode(; with_slack = false)
87	80		return new{Float64}(with_slack)
88	81		end
89	82		end

92	85		epsilon::T
93	86		with_slack::Bool
94	87		aggregation_group::Int # only useful in mixed mode
95		-	function_cache::Union{Nothing, MOI.AbstractScalarFunction}
	88	+	function_cache::Union{Nothing,MOI.AbstractScalarFunction}
96	89		function ProductMode(
97		-	eps::T=zero(Float64);
	90	+	eps::T = zero(Float64);
98	91		with_slack::Bool = false,
99		-	aggregation_group = nothing
100		-	) where T<:Float64 # Real
	92	+	aggregation_group = nothing,
	93	+	) where {T<:Float64} # Real
101	94		@assert aggregation_group === nothing \|\| aggregation_group >= 1
102	95		# nothing means individualized
103	96		# positive integers point to their numbers

106	99		with_slack,
107	100		aggregation_group === nothing ? 0 : aggregation_group,
108	101		nothing,
109		-	)
	102	+	)
110	103		end
111	104		end
112	105

121	114
122	115		struct ComplementBoundCache
123	116		# internal usage
124		-	upper::Dict{VI, BilevelVariableInfo}
125		-	lower::Dict{VI, BilevelVariableInfo}
126		-	ldual::Dict{CI, BilevelConstraintInfo}
	117	+	upper::Dict{VI,BilevelVariableInfo}
	118	+	lower::Dict{VI,BilevelVariableInfo}
	119	+	ldual::Dict{CI,BilevelConstraintInfo}
127	120		# full map
128		-	map::Dict{VI, BilevelVariableInfo}
	121	+	map::Dict{VI,BilevelVariableInfo}
129	122		function ComplementBoundCache()
130	123		return new(
131		-	Dict{VI, BilevelVariableInfo}(),
132		-	Dict{VI, BilevelVariableInfo}(),
133		-	Dict{CI, BilevelConstraintInfo}(),
134		-	Dict{VI, BilevelVariableInfo}(),
	124	+	Dict{VI,BilevelVariableInfo}(),
	125	+	Dict{VI,BilevelVariableInfo}(),
	126	+	Dict{CI,BilevelConstraintInfo}(),
	127	+	Dict{VI,BilevelVariableInfo}(),
135	128		)
136	129		end
137	130		end

141	134		primal_big_M::Float64
142	135		dual_big_M::Float64
143	136		cache::ComplementBoundCache
144		-	function FortunyAmatMcCarlMode(;with_slack = false,
145		-	primal_big_M = Inf, dual_big_M = Inf)
	137	+	function FortunyAmatMcCarlMode(;
	138	+	with_slack = false,
	139	+	primal_big_M = Inf,
	140	+	dual_big_M = Inf,
	141	+	)
146	142		return new{Float64}(
147	143		with_slack,
148	144		primal_big_M,
149	145		dual_big_M,
150		-	ComplementBoundCache()
	146	+	ComplementBoundCache(),
151	147		)
152	148		end
153	149		end
154	150
155	151		mutable struct MixedMode{T} <: AbstractBilevelSolverMode{T}
156	152		default::AbstractBilevelSolverMode{T}
157		-	constraint_mode_map_c::Dict{CI, AbstractBilevelSolverMode{T}}
158		-	constraint_mode_map_v::Dict{VI, AbstractBilevelSolverMode{T}}
	153	+	constraint_mode_map_c::Dict{CI,AbstractBilevelSolverMode{T}}
	154	+	constraint_mode_map_v::Dict{VI,AbstractBilevelSolverMode{T}}
159	155		cache::ComplementBoundCache
160	156		function_cache::Dict{Int,MOI.AbstractScalarFunction}
161		-	function MixedMode(;default = SOS1Mode())
	157	+	function MixedMode(; default = SOS1Mode())
162	158		return new{Float64}(
163	159		default,
164		-	Dict{CI, AbstractBilevelSolverMode{Float64}}(),
165		-	Dict{VI, AbstractBilevelSolverMode{Float64}}(),
	160	+	Dict{CI,AbstractBilevelSolverMode{Float64}}(),
	161	+	Dict{VI,AbstractBilevelSolverMode{Float64}}(),
166	162		ComplementBoundCache(),
167		-	Dict{Int,MOI.AbstractScalarFunction}()
	163	+	Dict{Int,MOI.AbstractScalarFunction}(),
168	164		)
169	165		end
170	166		end

201	197		return nothing
202	198		end
203	199
204		-	function build_full_map!(mode,
205		-	upper_idxmap, lower_idxmap, lower_dual_idxmap, lower_primal_dual_map)
	200	+	function build_full_map!(
	201	+	mode,
	202	+	upper_idxmap,
	203	+	lower_idxmap,
	204	+	lower_dual_idxmap,
	205	+	lower_primal_dual_map,
	206	+	)
206	207		return nothing
207	208		end
208		-	function build_full_map!(mode::FortunyAmatMcCarlMode,
209		-	upper_idxmap, lower_idxmap, lower_dual_idxmap, lower_primal_dual_map)
210		-	_build_bound_map!(mode.cache,
211		-	upper_idxmap, lower_idxmap, lower_dual_idxmap, lower_primal_dual_map)
	209	+	function build_full_map!(
	210	+	mode::FortunyAmatMcCarlMode,
	211	+	upper_idxmap,
	212	+	lower_idxmap,
	213	+	lower_dual_idxmap,
	214	+	lower_primal_dual_map,
	215	+	)
	216	+	_build_bound_map!(
	217	+	mode.cache,
	218	+	upper_idxmap,
	219	+	lower_idxmap,
	220	+	lower_dual_idxmap,
	221	+	lower_primal_dual_map,
	222	+	)
212	223		return nothing
213	224		end
214		-	function build_full_map!(mode::MixedMode,
215		-	upper_idxmap, lower_idxmap, lower_dual_idxmap, lower_primal_dual_map)
216		-	_build_bound_map!(mode.cache,
217		-	upper_idxmap, lower_idxmap, lower_dual_idxmap, lower_primal_dual_map)
218		-	return nothing
	225	+	function build_full_map!(
	226	+	mode::MixedMode,
	227	+	upper_idxmap,
	228	+	lower_idxmap,
	229	+	lower_dual_idxmap,
	230	+	lower_primal_dual_map,
	231	+	)
	232	+	_build_bound_map!(
	233	+	mode.cache,
	234	+	upper_idxmap,
	235	+	lower_idxmap,
	236	+	lower_dual_idxmap,
	237	+	lower_primal_dual_map,
	238	+	)
	239	+	return nothing
219	240		end
220		-	function _build_bound_map!(mode::ComplementBoundCache,
221		-	upper_idxmap, lower_idxmap, lower_dual_idxmap, lower_primal_dual_map)
	241	+	function _build_bound_map!(
	242	+	mode::ComplementBoundCache,
	243	+	upper_idxmap,
	244	+	lower_idxmap,
	245	+	lower_dual_idxmap,
	246	+	lower_primal_dual_map,
	247	+	)
222	248		empty!(mode.map)
223		-	for (k,v) in mode.upper
	249	+	for (k, v) in mode.upper
224	250		mode.map[upper_idxmap[k]] = v
225	251		end
226		-	for (k,v) in mode.lower
	252	+	for (k, v) in mode.lower
227	253		mode.map[lower_idxmap[k]] = v
228	254		end
229		-	for (k,v) in mode.ldual
	255	+	for (k, v) in mode.ldual
230	256		vec = lower_primal_dual_map.primal_con_dual_var[k]#[1] # TODO check this scalar
231	257		for var in vec
232	258		mode.map[lower_dual_idxmap[var]] = BilevelVariableInfo(v)

238	264		mutable struct StrongDualityMode{T} <: AbstractBilevelSolverMode{T}
239	265		inequality::Bool
240	266		epsilon::T
241		-	function StrongDualityMode(eps::T=zero(Float64); inequality = true) where T
	267	+	function StrongDualityMode(
	268	+	eps::T = zero(Float64);
	269	+	inequality = true,
	270	+	) where {T}
242	271		return new{T}(inequality, eps)
243	272		end
244	273		end
245	274
246		-	ignore_dual_objective(::AbstractBilevelSolverMode{T}) where T = true
247		-	ignore_dual_objective(::StrongDualityMode{T}) where T = false
	275	+	ignore_dual_objective(::AbstractBilevelSolverMode{T}) where {T} = true
	276	+	ignore_dual_objective(::StrongDualityMode{T}) where {T} = false
248	277
249		-	function accept_vector_set(mode::AbstractBilevelSolverMode{T}, con::Complement) where T
	278	+	function accept_vector_set(
	279	+	mode::AbstractBilevelSolverMode{T},
	280	+	con::Complement,
	281	+	) where {T}
250	282		if con.is_vec
251		-	error("Set $(typeof(con.set_w_zero)) is not accepted when solution method is $(typeof(mode))")
	283	+	error(
	284	+	"Set $(typeof(con.set_w_zero)) is not accepted when solution method is $(typeof(mode))",
	285	+	)
252	286		end
253	287		return nothing
254	288		end
255		-	accept_vector_set(::ProductMode{T}, ::Complement) where T = nothing
256		-	accept_vector_set(::MixedMode{T}, ::Complement) where T = nothing
	289	+	accept_vector_set(::ProductMode{T}, ::Complement) where {T} = nothing
	290	+	accept_vector_set(::MixedMode{T}, ::Complement) where {T} = nothing
257	291
258	292		function get_canonical_complements(primal_model, primal_dual_map)
259	293		map = primal_dual_map.primal_con_dual_var

264	298		end
265	299		return out
266	300		end
267		-	function get_canonical_complement(primal_model, map,
268		-	ci::CI{F,S}) where {F, S<:VECTOR_SETS}
	301	+	function get_canonical_complement(
	302	+	primal_model,
	303	+	map,
	304	+	ci::CI{F,S},
	305	+	) where {F,S<:VECTOR_SETS}
269	306		T = Float64
270	307		func = MOI.copy(MOI.get(primal_model, MOI.ConstraintFunction(), ci))::F
271	308		set = MOI.copy(MOI.get(primal_model, MOI.ConstraintSet(), ci))::S

553	666		return nothing
554	667		end
555	668
556		-	function get_mode(mode::MixedMode{T}, ci::CI{F,S}, map) where {
	669	+	function get_mode(
	670	+	mode::MixedMode{T},
	671	+	ci::CI{F,S},
	672	+	map,
	673	+	) where {
557	674		T,
558	675		F<:MOI.VariableIndex,
559		-	S<:Union{MOI.EqualTo{T}, MOI.LessThan{T}, MOI.GreaterThan{T}}
	676	+	S<:Union{MOI.EqualTo{T},MOI.LessThan{T},MOI.GreaterThan{T}},
560	677		}
561	678		# key = map[VI(ci.value)]
562	679		key = VI(ci.value)

575	692		end
576	693		end
577	694
578		-	function add_complement(mode::ComplementMode{T}, m, comp::Complement,
579		-	idxmap_primal, idxmap_dual, copy_names, pass_start::Bool) where T
	695	+	function add_complement(
	696	+	mode::ComplementMode{T},
	697	+	m,
	698	+	comp::Complement,
	699	+	idxmap_primal,
	700	+	idxmap_dual,
	701	+	copy_names,
	702	+	pass_start::Bool,
	703	+	) where {T}
580	704		f = comp.func_w_cte
581	705		s = comp.set_w_zero
582	706		v = comp.variable

620	749		else
621	750		new_f = MOIU.operate(vcat, T, f_dest, dual)
622	751
623		-	c = MOI.add_constraint(m,
624		-	new_f,
625		-	MOI.Complements(1))
	752	+	c = MOI.add_constraint(m, new_f, MOI.Complements(1))
626	753
627	754		if copy_names
628	755		nm = MOI.get(m, MOI.VariableName(), dual)

651	785		equality = MOIU.normalize_and_add_constraint(m, new_f, MOI.EqualTo(zero(T)))
652	786
653	787		dual = idxmap_dual[v]
654		-	c1 = MOI.add_constraint(m,
	788	+	c1 = MOI.add_constraint(
	789	+	m,
655	790		MOI.VectorOfVariables([slack, dual]),
656		-	MOI.SOS1([1.0, 2.0]))
	791	+	MOI.SOS1([1.0, 2.0]),
	792	+	)
657	793
658	794		if copy_names
659	795		nm = MOI.get(m, MOI.VariableName(), dual)

354	399		# get primal obj
355	400		type_primal_obj = MOI.get(lower, MOI.ObjectiveFunctionType())
356	401		@assert type_primal_obj !== nothing
357		-	lower_primal_obj = MOI.get(lower, MOI.ObjectiveFunction{type_primal_obj}())
	402	+	lower_primal_obj =
	403	+	MOI.get(lower, MOI.ObjectiveFunction{type_primal_obj}())
358	404		# deepcopy and delete dual obj
359	405		# MOI.set(lower, MOI.ObjectiveFunction{MOI.ScalarAffineFunction{Float64}}(), MOI.ScalarAffineFunction(MOI.ScalarAffineTerm{Float64}[], 0.0))
360	406		end

366	412		end
367	413
368	414		# append the second level primal
369		-	append_to(m, lower, lower_idxmap, allow_single_bounds = true)
	415	+	append_to(m, lower, lower_idxmap; allow_single_bounds = true)
370	416		if copy_names
371	417		pass_names(m, lower, lower_idxmap)
372	418		end

380	426		# get dual obj
381	427		tp_dual_obj = MOI.get(lower_dual, MOI.ObjectiveFunctionType())
382	428		@assert tp_dual_obj !== nothing
383		-	lower_dual_obj = MOI.get(lower_dual, MOI.ObjectiveFunction{tp_dual_obj}())
	429	+	lower_dual_obj =
	430	+	MOI.get(lower_dual, MOI.ObjectiveFunction{tp_dual_obj}())
384	431		# delete dual obj
385	432		# MOI.set(lower_dual, MOI.ObjectiveFunction{MOI.ScalarAffineFunction{Float64}}(), MOI.ScalarAffineFunction(MOI.ScalarAffineTerm{Float64}[], 0.0))
386	433		end

389	436		lower_dual_idxmap = MOIU.IndexMap()
390	437		# 1) for QP's there are dual variable that are linked to:
391	438		# 1.1) primal variables
392		-	for (lower_primal_var_key, lower_dual_quad_slack_val) in lower_primal_dual_map.primal_var_dual_quad_slack
393		-	lower_dual_idxmap[lower_dual_quad_slack_val] = lower_idxmap[lower_primal_var_key]
	439	+	for (lower_primal_var_key, lower_dual_quad_slack_val) in
	440	+	lower_primal_dual_map.primal_var_dual_quad_slack
	441	+	lower_dual_idxmap[lower_dual_quad_slack_val] =
	442	+	lower_idxmap[lower_primal_var_key]
394	443		end
395	444		# 1.2) and to upper level variable which are lower level parameters
396		-	for (lower_primal_param_key, lower_dual_param_val) in lower_primal_dual_map.primal_parameter
397		-	lower_dual_idxmap[lower_dual_param_val] = lower_idxmap[lower_primal_param_key]
	445	+	for (lower_primal_param_key, lower_dual_param_val) in
	446	+	lower_primal_dual_map.primal_parameter
	447	+	lower_dual_idxmap[lower_dual_param_val] =
	448	+	lower_idxmap[lower_primal_param_key]
398	449		end
399	450		# 2) Dual variables might appear in the upper level
400	451		for (upper_var, lower_con) in upper_var_to_lower_ctr

422	478		for comp in comps
423	479		if !is_equality(comp.set_w_zero)
424	480		accept_vector_set(mode, comp)
425		-	add_complement(mode, m, comp,
426		-	lower_idxmap, lower_dual_idxmap, copy_names, pass_start)
	481	+	add_complement(
	482	+	mode,
	483	+	m,
	484	+	comp,
	485	+	lower_idxmap,
	486	+	lower_dual_idxmap,
	487	+	copy_names,
	488	+	pass_start,
	489	+	)
427	490		else
428	491		# feasible equality constraints always satisfy complementarity
429	492		end
430	493		end
431	494		else # strong duality
432		-	add_strong_duality(mode, m, lower_primal_obj, lower_dual_obj, lower_idxmap, lower_dual_idxmap)
	495	+	add_strong_duality(
	496	+	mode,
	497	+	m,
	498	+	lower_primal_obj,
	499	+	lower_dual_obj,
	500	+	lower_idxmap,
	501	+	lower_dual_idxmap,
	502	+	)
433	503		end
434	504		add_aggregate_constraints(m, mode, copy_names)
435	505
436		-	return m, upper_idxmap, lower_idxmap, lower_primal_dual_map, lower_dual_idxmap
	506	+	return m,
	507	+	upper_idxmap,
	508	+	lower_idxmap,
	509	+	lower_primal_dual_map,
	510	+	lower_dual_idxmap
437	511		end
438	512
439		-	function add_strong_duality(mode::StrongDualityMode{T}, m, primal_obj, dual_obj,
440		-	idxmap_primal, idxmap_dual) where T
441		-
	513	+	function add_strong_duality(
	514	+	mode::StrongDualityMode{T},
	515	+	m,
	516	+	primal_obj,
	517	+	dual_obj,
	518	+	idxmap_primal,
	519	+	idxmap_dual,
	520	+	) where {T}
442	521		primal = MOIU.map_indices.(Ref(idxmap_primal), primal_obj)
443		-	dual = MOIU.map_indices.(Ref(idxmap_dual), dual_obj)
	522	+	dual = MOIU.map_indices.(Ref(idxmap_dual), dual_obj)
444	523
445	524		func = MOIU.operate(-, T, primal, dual)
446	525

464	548		add_aggregate_constraints(m, mode, copy_names) = nothing
465	549
466	550		function _add_aggregate_constraints(
467		-	m, func::F, eps, idx, copy_names
468		-	) where F<:MOI.ScalarQuadraticFunction{T} where T
	551	+	m,
	552	+	func::F,
	553	+	eps,
	554	+	idx,
	555	+	copy_names,
	556	+	) where {F<:MOI.ScalarQuadraticFunction{T}} where {T}
469	557		prod_f1 = MOIU.operate(-, T, func, eps)
470		-	c1 = MOIU.normalize_and_add_constraint(m,
471		-	prod_f1,
472		-	MOI.LessThan{T}(0.0))
	558	+	c1 = MOIU.normalize_and_add_constraint(m, prod_f1, MOI.LessThan{T}(0.0))
473	559		# appush!(out_ctr, c1)
474	560		if true # comp.is_vec
475	561		prod_f2 = MOIU.operate(+, T, func, eps)
476		-	c2 = MOIU.normalize_and_add_constraint(m,
	562	+	c2 = MOIU.normalize_and_add_constraint(
	563	+	m,
477	564		prod_f2,
478		-	MOI.GreaterThan{T}(0.0))
	565	+	MOI.GreaterThan{T}(0.0),
	566	+	)
479	567		# appush!(out_ctr, c2)
480	568		end
481	569		if copy_names

491	579		return nothing
492	580		end
493	581		_add_aggregate_constraints(
494		-	m, mode.function_cache, mode.epsilon, 0, copy_names)
	582	+	m,
	583	+	mode.function_cache,
	584	+	mode.epsilon,
	585	+	0,
	586	+	copy_names,
	587	+	)
495	588		return nothing
496	589		end
497		-	function add_aggregate_constraints(m, mode::MixedMode{T}, copy_names) where T
	590	+	function add_aggregate_constraints(m, mode::MixedMode{T}, copy_names) where {T}
498	591		if isempty(mode.function_cache)
499	592		return nothing
500	593		end
501		-	eps = Dict{Int, T}()
	594	+	eps = Dict{Int,T}()
502	595		for list in (
503	596		mode.constraint_mode_map_c,
504	597		mode.constraint_mode_map_v,
505		-	Dict(nothing=>mode.default)
	598	+	Dict(nothing => mode.default),
506	599		)
507	600		for md in values(list)
508	601		val, idx = _get_eps_idx(md)

529	621		return 0.0, 0
530	622		end
531	623
532		-	function add_complement(mode::MixedMode{T}, m, comp::Complement,
533		-	idxmap_primal, idxmap_dual, copy_names::Bool, pass_start::Bool) where T
	624	+	function add_complement(
	625	+	mode::MixedMode{T},
	626	+	m,
	627	+	comp::Complement,
	628	+	idxmap_primal,
	629	+	idxmap_dual,
	630	+	copy_names::Bool,
	631	+	pass_start::Bool,
	632	+	) where {T}
534	633		_mode = get_mode(mode, comp.constraint, idxmap_primal)
535	634		accept_vector_set(_mode, comp)
536		-	ret = add_complement(_mode, m, comp,
537		-	idxmap_primal, idxmap_dual, copy_names, pass_start)
	635	+	ret = add_complement(
	636	+	_mode,
	637	+	m,
	638	+	comp,
	639	+	idxmap_primal,
	640	+	idxmap_dual,
	641	+	copy_names,
	642	+	pass_start,
	643	+	)
538	644		add_function_to_cache(mode, _mode)
539	645		return ret
540	646		end
541		-	add_function_to_cache(mode::MixedMode{T}, _mode) where T = nothing
542		-	function add_function_to_cache(mode::MixedMode{T}, _mode::ProductMode{T}) where T
	647	+	add_function_to_cache(mode::MixedMode{T}, _mode) where {T} = nothing
	648	+	function add_function_to_cache(
	649	+	mode::MixedMode{T},
	650	+	_mode::ProductMode{T},
	651	+	) where {T}
543	652		idx = _mode.aggregation_group
544	653		if _mode.function_cache !== nothing && idx > 0
545	654		if haskey(mode.function_cache, idx)
546		-	mode.function_cache[idx] = MOIU.operate(+, T,
547		-	mode.function_cache[idx], _mode.function_cache)
	655	+	mode.function_cache[idx] = MOIU.operate(
	656	+	+,
	657	+	T,
	658	+	mode.function_cache[idx],
	659	+	_mode.function_cache,
	660	+	)
548	661		else
549	662		mode.function_cache[idx] = _mode.function_cache
550	663		end

592	716		if with_slack
593	717		slack, slack_in_set = MOI.add_constrained_variable(m, s)
594	718		new_f = MOIU.operate(-, T, f_dest, slack)
595		-	equality = MOIU.normalize_and_add_constraint(m, new_f, MOI.EqualTo(zero(T)))
	719	+	equality =
	720	+	MOIU.normalize_and_add_constraint(m, new_f, MOI.EqualTo(zero(T)))
596	721
597	722		if pass_start
598	723		val = MOIU.eval_variables(
599		-	x-> nothing_to_nan(MOI.get(m, MOI.VariablePrimalStart(), x)), f_dest)
	724	+	x -> nothing_to_nan(MOI.get(m, MOI.VariablePrimalStart(), x)),
	725	+	f_dest,
	726	+	)
600	727		if !isnan(val)
601	728		MOI.set(m, MOI.VariablePrimalStart(), slack, val)
602	729		end
603	730		end
604	731
605		-	c = MOI.add_constraint(m,
	732	+	c = MOI.add_constraint(
	733	+	m,
606	734		MOI.VectorOfVariables([slack, dual]),
607		-	MOI.Complements(1))
	735	+	MOI.Complements(1),
	736	+	)
608	737		if copy_names
609	738		nm = MOI.get(m, MOI.VariableName(), dual)
610	739		MOI.set(m, MOI.VariableName(), slack, "slk_($(nm))")

635	762		return out_var, out_ctr
636	763		end
637	764
638		-	function add_complement(mode::SOS1Mode{T}, m, comp::Complement,
639		-	idxmap_primal, idxmap_dual, copy_names::Bool, pass_start::Bool) where T
	765	+	function add_complement(
	766	+	mode::SOS1Mode{T},
	767	+	m,
	768	+	comp::Complement,
	769	+	idxmap_primal,
	770	+	idxmap_dual,
	771	+	copy_names::Bool,
	772	+	pass_start::Bool,
	773	+	) where {T}
640	774		f = comp.func_w_cte
641	775		s = comp.set_w_zero
642	776		v = comp.variable

Updating our web app

667	803		end
668	804
669	805		is_equality(set::S) where {S<:MOI.AbstractSet} = false
670		-	is_equality(set::MOI.EqualTo{T}) where T = true
	806	+	is_equality(set::MOI.EqualTo{T}) where {T} = true
671	807		is_equality(set::MOI.Zeros) = true
672	808
673	809		only_variable_functions(v::MOI.VariableIndex) = v

684	820		end
685	821		return nothing
686	822		end
687		-	function add_complement(mode::ProductMode{T}, m, comp::Complement,
688		-	idxmap_primal, idxmap_dual, copy_names::Bool, pass_start::Bool) where T
	823	+	function add_complement(
	824	+	mode::ProductMode{T},
	825	+	m,
	826	+	comp::Complement,
	827	+	idxmap_primal,
	828	+	idxmap_dual,
	829	+	copy_names::Bool,
	830	+	pass_start::Bool,
	831	+	) where {T}
689	832		f = comp.func_w_cte
690	833		s = comp.set_w_zero
691	834		v = comp.variable

696	839		eps = mode.epsilon
697	840		with_slack = mode.with_slack
698	841
699		-	f_dest = MOIU.map_indices(x->idxmap_primal[x], f)
	842	+	f_dest = MOIU.map_indices(x -> idxmap_primal[x], f)
700	843
701		-	dual = comp.is_vec ? map(x->idxmap_dual[x], v) : idxmap_dual[v]
	844	+	dual = comp.is_vec ? map(x -> idxmap_dual[x], v) : idxmap_dual[v]
702	845
703	846		if with_slack
704	847		slack, slack_in_set = if comp.is_vec

708	851		end
709	852		new_f = MOIU.operate(-, T, f_dest, only_variable_functions(slack))
710	853		if comp.is_vec
711		-	equality = MOIU.normalize_and_add_constraint(m, new_f, MOI.Zeros(length(slack)))
	854	+	equality = MOIU.normalize_and_add_constraint(
	855	+	m,
	856	+	new_f,
	857	+	MOI.Zeros(length(slack)),
	858	+	)
712	859		else
713		-	equality = MOIU.normalize_and_add_constraint(m, new_f, MOI.EqualTo(zero(T)))
	860	+	equality = MOIU.normalize_and_add_constraint(
	861	+	m,
	862	+	new_f,
	863	+	MOI.EqualTo(zero(T)),
	864	+	)
714	865		end
715	866
716		-	prod_f = MOIU.operate(dot, T, only_variable_functions(slack), only_variable_functions(dual))
	867	+	prod_f = MOIU.operate(
	868	+	dot,
	869	+	T,
	870	+	only_variable_functions(slack),
	871	+	only_variable_functions(dual),
	872	+	)
717	873
718	874		appush!(out_var, slack)
719	875		appush!(out_ctr, slack_in_set)

721	877
722	878		if mode.aggregation_group == 0
723	879		prod_f1 = MOIU.operate(-, T, prod_f, eps)
724		-	c1 = MOIU.normalize_and_add_constraint(m,
	880	+	c1 = MOIU.normalize_and_add_constraint(
	881	+	m,
725	882		prod_f1,
726		-	MOI.LessThan{Float64}(0.0))
	883	+	MOI.LessThan{Float64}(0.0),
	884	+	)
727	885		appush!(out_ctr, c1)
728	886		if comp.is_vec
729	887		prod_f2 = MOIU.operate(+, T, prod_f, eps)
730		-	c2 = MOIU.normalize_and_add_constraint(m,
	888	+	c2 = MOIU.normalize_and_add_constraint(
	889	+	m,
731	890		prod_f2,
732		-	MOI.GreaterThan{Float64}(0.0))
	891	+	MOI.GreaterThan{Float64}(0.0),
	892	+	)
733	893		appush!(out_ctr, c2)
734	894		end
735	895		else

760	922		if mode.aggregation_group == 0
761	923		MOI.set(m, MOI.ConstraintName(), c1, "compl_prodWslk_($(nm))")
762	924		if comp.is_vec
763		-	MOI.set(m, MOI.ConstraintName(), c2, "compl_prodWslk2_($(nm))")
	925	+	MOI.set(
	926	+	m,
	927	+	MOI.ConstraintName(),
	928	+	c2,
	929	+	"compl_prodWslk2_($(nm))",
	930	+	)
764	931		end
765	932		end
766	933		end

768	935		new_f = MOIU.operate(dot, T, f_dest, only_variable_functions(dual))
769	936		if mode.aggregation_group == 0
770	937		new_f1 = MOIU.operate(-, T, new_f, eps)
771		-	c1 = MOIU.normalize_and_add_constraint(m,
	938	+	c1 = MOIU.normalize_and_add_constraint(
	939	+	m,
772	940		new_f1,
773		-	MOI.LessThan{T}(0.0))
	941	+	MOI.LessThan{T}(0.0),
	942	+	)
774	943		appush!(out_ctr, c1)
775	944		if comp.is_vec # conic
776	945		new_f2 = MOIU.operate(+, T, new_f, eps)
777		-	c2 = MOIU.normalize_and_add_constraint(m,
	946	+	c2 = MOIU.normalize_and_add_constraint(
	947	+	m,
778	948		new_f2,
779		-	MOI.GreaterThan{T}(0.0))
	949	+	MOI.GreaterThan{T}(0.0),
	950	+	)
780	951		appush!(out_ctr, c2)
781	952		end
782	953		if copy_names

797	968		return out_var, out_ctr
798	969		end
799	970
800		-	function add_complement(mode::IndicatorMode{T}, m, comp::Complement,
801		-	idxmap_primal, idxmap_dual, copy_names::Bool, pass_start::Bool) where T
	971	+	function add_complement(
	972	+	mode::IndicatorMode{T},
	973	+	m,
	974	+	comp::Complement,
	975	+	idxmap_primal,
	976	+	idxmap_dual,
	977	+	copy_names::Bool,
	978	+	pass_start::Bool,
	979	+	) where {T}
802	980		f = comp.func_w_cte
803	981		s = comp.set_w_zero
804	982		v = comp.variable

808	986		is_tight = false
809	987		has_start = false
810	988
811		-	f_dest = MOIU.map_indices(x->idxmap_primal[x], f)
	989	+	f_dest = MOIU.map_indices(x -> idxmap_primal[x], f)
812	990
813	991		dual = idxmap_dual[v]
814	992
815	993		if comp.is_vec
816		-	error("Vector constraint is (currently) not supported by indicator mode")
	994	+	error(
	995	+	"Vector constraint is (currently) not supported by indicator mode",
	996	+	)
817	997		end
818	998
819	999		if copy_names

854	1034
855	1035		if pass_start
856	1036		val = MOIU.eval_variables(
857		-	x-> nothing_to_nan(MOI.get(m, MOI.VariablePrimalStart(), x)), f_dest)
	1037	+	x -> nothing_to_nan(MOI.get(m, MOI.VariablePrimalStart(), x)),
	1038	+	f_dest,
	1039	+	)
858	1040		if !isnan(val)
859	1041		is_tight = abs(val) < 1e-8
860	1042		has_start = true