[Bridges] add CountBelongsToMILPBridge (#1919)

Author: odow

docs/src/submodules/Bridges/list_of_bridges.md

@@ -52,6 +52,7 @@ Bridges.Constraint.IndicatorSOS1Bridge
 Bridges.Constraint.SemiToBinaryBridge
 Bridges.Constraint.ZeroOneBridge
 Bridges.Constraint.BinPackingToMILPBridge
+Bridges.Constraint.CountBelongsToMILPBridge
 Bridges.Constraint.CountDistinctToMILPBridge
 Bridges.Constraint.TableToMILPBridge
 ```

src/Bridges/Constraint/Constraint.jl

@@ -19,6 +19,7 @@ include("set_map.jl")
 include("single_bridge_optimizer.jl")
 
 include("bridges/bin_packing.jl")
+include("bridges/count_belongs.jl")
 include("bridges/count_distinct.jl")
 include("bridges/det.jl")
 include("bridges/flip_sign.jl")
@@ -96,6 +97,7 @@ function add_all_bridges(bridged_model, ::Type{T}) where {T}
     # TODO(odow): this reformulation assumes the bins are numbered 1..N. We
     # should fix this to use the variable bounds before adding automatically.
     # MOI.Bridges.add_bridge(bridged_model, BinPackingToMILPBridge{T})
+    MOI.Bridges.add_bridge(bridged_model, CountBelongsToMILPBridge{T})
     MOI.Bridges.add_bridge(bridged_model, CountDistinctToMILPBridge{T})
     MOI.Bridges.add_bridge(bridged_model, TableToMILPBridge{T})
     return

src/Bridges/Constraint/bridges/count_belongs.jl

@@ -0,0 +1,306 @@
+# Copyright (c) 2017: Miles Lubin and contributors
+# Copyright (c) 2017: Google Inc.
+#
+# Use of this source code is governed by an MIT-style license that can be found
+# in the LICENSE.md file or at https://opensource.org/licenses/MIT.
+
+"""
+    CountBelongsToMILPBridge{T,F} <: Bridges.Constraint.AbstractBridge
+
+`CountBelongsToMILPBridge` implements the following reformulation:
+
+  * ``(n, x) \\in \\textsf{CountBelongs}(1+d, \\mathcal{S})`` into a
+    mixed-integer linear program.
+
+## Reformulation
+
+The reformulation is non-trivial, and it depends on the finite domain of each
+variable ``x_i``, which we as define ``S_i = \\{l_i,\\ldots,u_i\\}``.
+
+First, we introduce new binary variables ``z_{ij}``, which are ``1`` if variable
+``x_i`` takes the value ``j`` in the optimal solution and ``0`` otherwise:
+```math
+\\begin{aligned}
+z_{ij} \\in \\{0, 1\\}                              & \\;\\; \\forall i \\in 1\\ldots d, j \\in S_i  \\\\
+x_i - \\sum\\limits_{j\\in S_i} j \\cdot z_{ij} = 0 & \\;\\; \\forall i \\in 1\\ldots d              \\\\
+\\sum\\limits_{j\\in S_i} z_{ij} = 1                & \\;\\; \\forall i \\in 1\\ldots d              \\\\
+\\end{aligned}
+```
+
+Finally, ``n`` is constrained to be the number of ``z_{ij}`` elements that are
+in ``\\mathcal{S}``:
+```math
+n - \\sum\\limits_{j \\in \\mathcal{S}} y_{j} = 0
+```
+
+## Source node
+
+`CountBelongsToMILPBridge` supports:
+
+  * `F` in [`MOI.CountBelongs`](@ref)
+
+where `F` is [`MOI.VectorOfVariables`](@ref) or
+[`MOI.VectorAffineFunction{T}`](@ref).
+
+## Target nodes
+
+`CountBelongsToMILPBridge` creates:
+
+  * [`MOI.VariableIndex`](@ref) in [`MOI.ZeroOne`](@ref)
+  * [`MOI.ScalarAffineFunction{T}`](@ref) in [`MOI.EqualTo{T}`](@ref)
+"""
+mutable struct CountBelongsToMILPBridge{
+    T,
+    F<:Union{MOI.VectorOfVariables,MOI.VectorAffineFunction{T}},
+} <: AbstractBridge
+    f::F
+    set::MOI.CountBelongs
+    variables::Vector{MOI.VariableIndex}
+    equal_to::Vector{
+        MOI.ConstraintIndex{MOI.ScalarAffineFunction{T},MOI.EqualTo{T}},
+    }
+    function CountBelongsToMILPBridge{T}(
+        f::Union{MOI.VectorOfVariables,MOI.VectorAffineFunction{T}},
+        s::MOI.CountBelongs,
+    ) where {T}
+        return new{T,typeof(f)}(
+            f,
+            s,
+            MOI.VariableIndex[],
+            MOI.ConstraintIndex{MOI.ScalarAffineFunction{T},MOI.EqualTo{T}}[],
+        )
+    end
+end
+
+const CountBelongsToMILP{T,OT<:MOI.ModelLike} =
+    SingleBridgeOptimizer{CountBelongsToMILPBridge{T},OT}
+
+function bridge_constraint(
+    ::Type{CountBelongsToMILPBridge{T,F}},
+    model::MOI.ModelLike,
+    f::F,
+    s::MOI.CountBelongs,
+) where {T,F<:Union{MOI.VectorOfVariables,MOI.VectorAffineFunction{T}}}
+    # !!! info
+    #     Postpone creation until final_touch.
+    return CountBelongsToMILPBridge{T}(f, s)
+end
+
+function MOI.supports_constraint(
+    ::Type{<:CountBelongsToMILPBridge{T}},
+    ::Type{<:Union{MOI.VectorOfVariables,MOI.VectorAffineFunction{T}}},
+    ::Type{MOI.CountBelongs},
+) where {T}
+    return true
+end
+
+function MOI.Bridges.added_constrained_variable_types(
+    ::Type{<:CountBelongsToMILPBridge},
+)
+    return Tuple{Type}[(MOI.ZeroOne,)]
+end
+
+function MOI.Bridges.added_constraint_types(
+    ::Type{<:CountBelongsToMILPBridge{T}},
+) where {T}
+    return Tuple{Type,Type}[(MOI.ScalarAffineFunction{T}, MOI.EqualTo{T})]
+end
+
+function concrete_bridge_type(
+    ::Type{<:CountBelongsToMILPBridge{T}},
+    ::Type{F},
+    ::Type{MOI.CountBelongs},
+) where {T,F<:Union{MOI.VectorOfVariables,MOI.VectorAffineFunction{T}}}
+    return CountBelongsToMILPBridge{T,F}
+end
+
+function MOI.get(
+    ::MOI.ModelLike,
+    ::MOI.ConstraintFunction,
+    bridge::CountBelongsToMILPBridge,
+)
+    return bridge.f
+end
+
+function MOI.get(
+    ::MOI.ModelLike,
+    ::MOI.ConstraintSet,
+    bridge::CountBelongsToMILPBridge,
+)
+    return bridge.set
+end
+
+function MOI.delete(model::MOI.ModelLike, bridge::CountBelongsToMILPBridge)
+    for ci in bridge.equal_to
+        MOI.delete(model, ci)
+    end
+    empty!(bridge.equal_to)
+    for x in bridge.variables
+        MOI.delete(model, x)
+    end
+    empty!(bridge.variables)
+    return
+end
+
+function MOI.get(
+    bridge::CountBelongsToMILPBridge,
+    ::MOI.NumberOfVariables,
+)::Int64
+    return length(bridge.variables)
+end
+
+function MOI.get(bridge::CountBelongsToMILPBridge, ::MOI.ListOfVariableIndices)
+    return copy(bridge.variables)
+end
+
+function MOI.get(
+    bridge::CountBelongsToMILPBridge,
+    ::MOI.NumberOfConstraints{MOI.VariableIndex,MOI.ZeroOne},
+)::Int64
+    return length(bridge.variables)
+end
+
+function MOI.get(
+    bridge::CountBelongsToMILPBridge,
+    ::MOI.ListOfConstraintIndices{MOI.VariableIndex,MOI.ZeroOne},
+)
+    return MOI.ConstraintIndex{MOI.VariableIndex,MOI.ZeroOne}[
+        MOI.ConstraintIndex{MOI.VariableIndex,MOI.ZeroOne}(x.value) for
+        x in bridge.variables
+    ]
+end
+
+function MOI.get(
+    bridge::CountBelongsToMILPBridge{T},
+    ::MOI.NumberOfConstraints{MOI.ScalarAffineFunction{T},MOI.EqualTo{T}},
+)::Int64 where {T}
+    return length(bridge.equal_to)
+end
+
+function MOI.get(
+    bridge::CountBelongsToMILPBridge{T},
+    ::MOI.ListOfConstraintIndices{MOI.ScalarAffineFunction{T},MOI.EqualTo{T}},
+) where {T}
+    return copy(bridge.equal_to)
+end
+
+MOI.Bridges.needs_final_touch(::CountBelongsToMILPBridge) = true
+
+function _get_bounds(
+    bridge::CountBelongsToMILPBridge{T},
+    model::MOI.ModelLike,
+    bounds::Dict{MOI.VariableIndex,Tuple{T,T}},
+    f::MOI.ScalarAffineFunction{T},
+) where {T}
+    lb = ub = f.constant
+    for term in f.terms
+        ret = _get_bounds(bridge, model, bounds, term.variable)
+        if ret === nothing
+            return nothing
+        end
+        lb += term.coefficient * ret[1]
+        ub += term.coefficient * ret[2]
+    end
+    return lb, ub
+end
+
+function _get_bounds(
+    ::CountBelongsToMILPBridge{T},
+    model::MOI.ModelLike,
+    bounds::Dict{MOI.VariableIndex,Tuple{T,T}},
+    x::MOI.VariableIndex,
+) where {T}
+    if haskey(bounds, x)
+        return bounds[x]
+    end
+    ret = MOI.Utilities.get_bounds(model, T, x)
+    if ret == (typemin(T), typemax(T))
+        return nothing
+    end
+    bounds[x] = ret
+    return ret
+end
+
+"""
+    _unit_expansion(
+        ::CountBelongsToMILPBridge{T},
+        model::MOI.ModelLike,
+        f::Vector{<:Union{MOI.VariableIndex,MOI.ScalarAffineFunction{T}}}
+    ) where {T}
+
+Reformulates a vector of input functions ``f`` into a binary unit expansion.
+This is useful when writing constraint programming bridges.
+"""
+function _unit_expansion(
+    bridge::CountBelongsToMILPBridge{T},
+    model::MOI.ModelLike,
+    f::Vector{<:Union{MOI.VariableIndex,MOI.ScalarAffineFunction{T}}},
+) where {T}
+    S = Dict{T,Vector{MOI.VariableIndex}}()
+    bounds = Dict{MOI.VariableIndex,Tuple{T,T}}()
+    ci = MOI.ConstraintIndex{MOI.ScalarAffineFunction{T},MOI.EqualTo{T}}[]
+    for i in 1:length(f)
+        ret = _get_bounds(bridge, model, bounds, f[i])
+        if ret === nothing
+            BT = typeof(bridge)
+            error(
+                "Unable to use $BT because an element in the function has a " *
+                "non-finite domain: $(f[i])",
+            )
+        end
+        unit_f = MOI.ScalarAffineFunction(MOI.ScalarAffineTerm{T}[], zero(T))
+        convex_f = MOI.ScalarAffineFunction(MOI.ScalarAffineTerm{T}[], zero(T))
+        for xi in ret[1]:ret[2]
+            z, _ = MOI.add_constrained_variable(model, MOI.ZeroOne())
+            if !haskey(S, xi)
+                S[xi] = MOI.VariableIndex[]
+            end
+            push!(S[xi], z)
+            push!(unit_f.terms, MOI.ScalarAffineTerm(T(-xi), z))
+            push!(convex_f.terms, MOI.ScalarAffineTerm(one(T), z))
+        end
+        push!(
+            ci,
+            MOI.Utilities.normalize_and_add_constraint(
+                model,
+                MOI.Utilities.operate(+, T, f[i], unit_f),
+                MOI.EqualTo(zero(T));
+                allow_modify_function = true,
+            ),
+        )
+        push!(ci, MOI.add_constraint(model, convex_f, MOI.EqualTo(one(T))))
+    end
+    return S, ci
+end
+
+function MOI.Bridges.final_touch(
+    bridge::CountBelongsToMILPBridge{T,F},
+    model::MOI.ModelLike,
+) where {T,F}
+    MOI.delete(model, bridge)
+    scalars = collect(MOI.Utilities.eachscalar(bridge.f))
+    S, ci = _unit_expansion(bridge, model, scalars[2:end])
+    append!(bridge.equal_to, ci)
+    for (_, s) in S
+        append!(bridge.variables, s)
+    end
+    f = MOI.ScalarAffineFunction(MOI.ScalarAffineTerm{T}[], zero(T))
+    for s in bridge.set.set
+        if haskey(S, s)
+            for x in S[s]
+                push!(f.terms, MOI.ScalarAffineTerm(one(T), x))
+            end
+        end
+    end
+    MOI.Utilities.operate!(-, T, f, scalars[1])
+    push!(
+        bridge.equal_to,
+        MOI.Utilities.normalize_and_add_constraint(
+            model,
+            f,
+            MOI.EqualTo(zero(T));
+            allow_modify_function = true,
+        ),
+    )
+    return
+end

src/Bridges/Constraint/bridges/semi_to_binary.jl

@@ -75,6 +75,19 @@ function bridge_constraint(
     f::MOI.VariableIndex,
     s::S,
 ) where {T<:Real,S<:Union{MOI.Semicontinuous{T},MOI.Semiinteger{T}}}
+    F = MOI.VariableIndex
+    if MOI.is_valid(model, MOI.ConstraintIndex{F,MOI.GreaterThan{T}}(f.value))
+        throw(MOI.LowerBoundAlreadySet{MOI.GreaterThan{T},S}(f))
+    end
+    if MOI.is_valid(model, MOI.ConstraintIndex{F,MOI.LessThan{T}}(f.value))
+        throw(MOI.UpperBoundAlreadySet{MOI.LessThan{T},S}(f))
+    end
+    if MOI.is_valid(model, MOI.ConstraintIndex{F,MOI.EqualTo{T}}(f.value))
+        throw(MOI.LowerBoundAlreadySet{MOI.EqualTo{T},S}(f))
+    end
+    if MOI.is_valid(model, MOI.ConstraintIndex{F,MOI.Interval{T}}(f.value))
+        throw(MOI.LowerBoundAlreadySet{MOI.Interval{T},S}(f))
+    end
     binary, binary_con = MOI.add_constrained_variable(model, MOI.ZeroOne())
     # var - LB * bin >= 0
     lb = MOI.Utilities.operate(*, T, -s.lower, binary)
@@ -327,3 +340,25 @@ function MOI.get(
 ) where {T,S}
     return [b.lower_bound_index]
 end
+
+MOI.Bridges.needs_final_touch(b::SemiToBinaryBridge) = true
+
+function MOI.Bridges.final_touch(
+    b::SemiToBinaryBridge{T,S},
+    model::MOI.ModelLike,
+) where {T,S}
+    F, f = MOI.VariableIndex, b.variable
+    if MOI.is_valid(model, MOI.ConstraintIndex{F,MOI.GreaterThan{T}}(f.value))
+        throw(MOI.LowerBoundAlreadySet{S,MOI.GreaterThan{T}}(f))
+    end
+    if MOI.is_valid(model, MOI.ConstraintIndex{F,MOI.LessThan{T}}(f.value))
+        throw(MOI.UpperBoundAlreadySet{S,MOI.LessThan{T}}(f))
+    end
+    if MOI.is_valid(model, MOI.ConstraintIndex{F,MOI.EqualTo{T}}(f.value))
+        throw(MOI.LowerBoundAlreadySet{S,MOI.EqualTo{T}}(f))
+    end
+    if MOI.is_valid(model, MOI.ConstraintIndex{F,MOI.Interval{T}}(f.value))
+        throw(MOI.LowerBoundAlreadySet{S,MOI.Interval{T}}(f))
+    end
+    return
+end

src/Test/test_cpsat.jl

@@ -107,6 +107,7 @@ function test_cpsat_CountBelongs(
     @requires _supports(config, MOI.optimize!)
     y = [MOI.add_constrained_variable(model, MOI.Integer()) for _ in 1:4]
     x = first.(y)
+    MOI.add_constraint.(model, x, MOI.Interval(T(0), T(4)))
     set = Set([3, 4])
     MOI.add_constraint(
         model,