[Bridges] fix CountAtLeastToCountBelongsBridge (#1926)

Author: odow

src/Bridges/Constraint/bridges/count_at_least.jl

@@ -11,7 +11,7 @@
 
   * ``x \\in \\textsf{CountAtLeast}(n, d, set)`` to
     ``(n_i, x_{d_i}) \\in \\textsf{CountBelongs}(1+d)``
-    and ``\\sum\\limits n_i \\ge n``
+    and ``n_i \\ge n``
 
 ## Source node
 
@@ -27,7 +27,7 @@ where `F` is [`MOI.VectorOfVariables`](@ref) or
 `CountAtLeastToCountBelongsBridge` creates:
 
   * `F` in [`MOI.CountBelongs`](@ref)
-  * [`MOI.ScalarAffineFunction{T}`](@ref) in [`MOI.GreaterThan{T}`](@ref)
+  * [`MOI.VariableIndex`](@ref) in [`MOI.GreaterThan{T}`](@ref)
 """
 mutable struct CountAtLeastToCountBelongsBridge{
     T,
@@ -37,7 +37,19 @@ mutable struct CountAtLeastToCountBelongsBridge{
     s::MOI.CountAtLeast
     variables::Vector{MOI.VariableIndex}
     ci::Vector{MOI.ConstraintIndex{F,MOI.CountBelongs}}
-    count::MOI.ConstraintIndex{MOI.ScalarAffineFunction{T},MOI.GreaterThan{T}}
+    # We need an explicit inner constructor to avoid the unbound type parameter
+    # T (it doesn't appear in the fields).
+    function CountAtLeastToCountBelongsBridge{T}(
+        f::Union{MOI.VectorOfVariables,MOI.VectorAffineFunction{T}},
+        s::MOI.CountAtLeast,
+    ) where {T}
+        return new{T,typeof(f)}(
+            f,
+            s,
+            MOI.VariableIndex[],
+            MOI.ConstraintIndex{typeof(f),MOI.CountBelongs}[],
+        )
+    end
 end
 
 const CountAtLeastToCountBelongs{T,OT<:MOI.ModelLike} =
@@ -50,25 +62,21 @@ function bridge_constraint(
     s::MOI.CountAtLeast,
 ) where {T,F<:Union{MOI.VectorOfVariables,MOI.VectorAffineFunction{T}}}
     x = collect(MOI.Utilities.eachscalar(f))
-    variables = MOI.VariableIndex[]
-    cis = MOI.ConstraintIndex{F,MOI.CountBelongs}[]
-    count_f = MOI.ScalarAffineFunction(MOI.ScalarAffineTerm{T}[], zero(T))
+    bridge = CountAtLeastToCountBelongsBridge{T}(f, s)
     offset = 0
     for p in s.partitions
         indices = offset .+ (1:p)
-        y = MOI.add_variable(model)
-        push!(variables, y)
-        push!(count_f.terms, MOI.ScalarAffineTerm(one(T), y))
+        y, _ = MOI.add_constrained_variable(model, MOI.GreaterThan(T(s.n)))
+        push!(bridge.variables, y)
         ci = MOI.add_constraint(
             model,
             MOI.Utilities.operate(vcat, T, y, x[indices]...),
             MOI.CountBelongs(1 + p, s.set),
         )
-        push!(cis, ci)
+        push!(bridge.ci, ci)
         offset += p
     end
-    count = MOI.add_constraint(model, count_f, MOI.GreaterThan(T(s.n)))
-    return CountAtLeastToCountBelongsBridge{T,F}(f, s, variables, cis, count)
+    return bridge
 end
 
 function MOI.supports_constraint(
@@ -80,18 +88,15 @@ function MOI.supports_constraint(
 end
 
 function MOI.Bridges.added_constrained_variable_types(
-    ::Type{<:CountAtLeastToCountBelongsBridge},
-)
-    return Tuple{Type}[]
+    ::Type{<:CountAtLeastToCountBelongsBridge{T}},
+) where {T}
+    return Tuple{Type}[(MOI.GreaterThan{T},)]
 end
 
 function MOI.Bridges.added_constraint_types(
     ::Type{CountAtLeastToCountBelongsBridge{T,F}},
 ) where {T,F}
-    return Tuple{Type,Type}[
-        (F, MOI.CountBelongs),
-        (MOI.ScalarAffineFunction{T}, MOI.GreaterThan{T}),
-    ]
+    return Tuple{Type,Type}[(F, MOI.CountBelongs)]
 end
 
 function concrete_bridge_type(
@@ -125,7 +130,6 @@ function MOI.delete(
     for ci in bridge.ci
         MOI.delete(model, ci)
     end
-    MOI.delete(model, bridge.count)
     for x in bridge.variables
         MOI.delete(model, x)
     end
@@ -161,18 +165,18 @@ function MOI.get(
 end
 
 function MOI.get(
-    ::CountAtLeastToCountBelongsBridge{T,F},
-    ::MOI.NumberOfConstraints{MOI.ScalarAffineFunction{T},MOI.GreaterThan{T}},
-)::Int64 where {T,F}
-    return 1
+    bridge::CountAtLeastToCountBelongsBridge{T},
+    ::MOI.NumberOfConstraints{MOI.VariableIndex,MOI.GreaterThan{T}},
+)::Int64 where {T}
+    return length(bridge.variables)
 end
 
 function MOI.get(
-    bridge::CountAtLeastToCountBelongsBridge{T,F},
-    ::MOI.ListOfConstraintIndices{
-        MOI.ScalarAffineFunction{T},
-        MOI.GreaterThan{T},
-    },
-) where {T,F}
-    return [bridge.count]
+    bridge::CountAtLeastToCountBelongsBridge{T},
+    ::MOI.ListOfConstraintIndices{MOI.VariableIndex,MOI.GreaterThan{T}},
+) where {T}
+    return [
+        MOI.ConstraintIndex{MOI.VariableIndex,MOI.GreaterThan{T}}(x.value) for
+        x in bridge.variables
+    ]
 end

test/Bridges/Constraint/count_at_least.jl

@@ -30,16 +30,19 @@ function test_runtests_VectorOfVariables()
         [a, b, b, c] in CountAtLeast(1, [2, 2], Set([3]))
         a in Interval(1.0, 3.0)
         b in Interval(1.0, 3.0)
-        c in Interval(1.0, 3.0)
+        c >= 1.0
+        c <= 3.0
         """,
         """
         variables: a, b, c, y1, y2
         [y1, a, b] in CountBelongs(3, Set([3]))
         [y2, b, c] in CountBelongs(3, Set([3]))
-        y1 + y2 >= 1.0
+        y1 >= 1.0
+        y2 >= 1.0
         a in Interval(1.0, 3.0)
         b in Interval(1.0, 3.0)
-        c in Interval(1.0, 3.0)
+        c >= 1.0
+        c <= 3.0
         """,
     )
     return
@@ -59,7 +62,8 @@ function test_runtests_VectorAffineFunction()
         variables: a, b, c, y1, y2
         [y1, 1.0 * a, b + 1.0] in CountBelongs(3, Set([3]))
         [y2, 1.0 * b, 1.0 * c] in CountBelongs(3, Set([3]))
-        y1 + y2 >= 1.0
+        y1 >= 1.0
+        y2 >= 1.0
         a in Interval(1.0, 3.0)
         b in Interval(1.0, 3.0)
         c in Interval(1.0, 3.0)