Test ConstraintDual for bridges

Author: blegat

docs/src/submodules/Bridges/implementation.md

@@ -79,7 +79,7 @@ julia> MOI.Bridges.runtests(
            """,
        )
 Test Summary:    | Pass  Total  Time
-Bridges.runtests |   29     29  0.0s
+Bridges.runtests |   30     30  0.0s
 ```
 
 There are a number of other useful keyword arguments.
@@ -123,5 +123,5 @@ Subject to:
 ScalarAffineFunction{Int64}-in-LessThan{Int64}
  (0) - (1) x <= (-1)
 Test Summary:    | Pass  Total  Time
-Bridges.runtests |   29     29  0.0s
+Bridges.runtests |   30     30  0.0s
 ```

src/Bridges/Bridges.jl

@@ -283,7 +283,7 @@ julia> MOI.Bridges.runtests(
            end,
        )
 Test Summary:    | Pass  Total  Time
-Bridges.runtests |   32     32  0.8s
+Bridges.runtests |   33     33  0.8s
 ```
 """
 function runtests(args...; kwargs...)
@@ -293,12 +293,60 @@ function runtests(args...; kwargs...)
     return
 end
 
+# A good way to check that the linear mapping implemented in the setter of
+# `ConstraintDual` is the inverse-adjoint of the mapping implemented in the
+# constraint transformation is to check `get_fallback` for `DualObjectiveValue`.
+# Indeed, it will check that the inner product between the constraint constants
+# and the dual is the same before and after the bridge transformations.
+# For this test to be enabled, the bridge should implement `supports`
+# for `ConstraintDual` and implement `MOI.set` for `ConstraintDual`.
+# Typically, this would be achieved using
+# `Union{ConstraintDual,ConstraintDualStart}` for `MOI.get`, `MOI.set` and
+# `MOI.supports`
+function _test_dual(
+    Bridge::Type{<:AbstractBridge},
+    input_fn::Function;
+    dual,
+    eltype,
+    model_eltype,
+)
+    inner = MOI.Utilities.UniversalFallback(MOI.Utilities.Model{model_eltype}())
+    mock = MOI.Utilities.MockOptimizer(inner)
+    model = _bridged_model(Bridge{eltype}, mock)
+    input_fn(model)
+    final_touch(model)
+    # Should be able to call final_touch multiple times.
+    final_touch(model)
+    # If the bridges does not support `ConstraintDualStart`, it probably won't
+    # support `ConstraintDual` so we skip these tests
+    list_of_constraints = MOI.get(model, MOI.ListOfConstraintTypesPresent())
+    attr = MOI.ConstraintDual()
+    for (F, S) in list_of_constraints
+        if !MOI.supports(model, attr, MOI.ConstraintIndex{F,S})
+            # We need all duals for `DualObjectiveValue` fallback
+            # TODO except the ones with no constants, we could ignore them
+            return
+        end
+        for ci in MOI.get(model, MOI.ListOfConstraintIndices{F,S}())
+            set = MOI.get(model, MOI.ConstraintSet(), ci)
+            MOI.set(model, MOI.ConstraintDual(), ci, _fake_start(dual, set))
+        end
+    end
+    model_dual =
+        MOI.Utilities.get_fallback(model, MOI.DualObjectiveValue(), eltype)
+    mock_dual =
+        MOI.Utilities.get_fallback(mock, MOI.DualObjectiveValue(), eltype)
+    # Need `atol` in case one of them is zero and the other one almost zero
+    Test.@test model_dual ≈ mock_dual atol = 1e-6
+end
+
 function _runtests(
     Bridge::Type{<:AbstractBridge},
     input_fn::Function,
     output_fn::Function;
     variable_start = 1.2,
     constraint_start = 1.2,
+    dual = constraint_start,
     eltype = Float64,
     model_eltype = eltype,
     print_inner_model::Bool = false,
@@ -403,6 +451,11 @@ function _runtests(
     Test.@testset "Test delete" begin                                           # COV_EXCL_LINE
         _test_delete(Bridge, model, inner)
     end
+    if !isnothing(dual)
+        Test.@testset "Test ConstraintDual" begin
+            _test_dual(Bridge, input_fn; dual, eltype, model_eltype)
+        end
+    end
     return
 end
 

src/Bridges/Constraint/bridges/SplitHyperRectangleBridge.jl

@@ -196,7 +196,11 @@ end
 
 function MOI.supports(
     model::MOI.ModelLike,
-    attr::Union{MOI.ConstraintPrimalStart,MOI.ConstraintDualStart},
+    attr::Union{
+        MOI.ConstraintPrimalStart,
+        MOI.ConstraintDualStart,
+        MOI.ConstraintDual,
+    },
     ::Type{<:SplitHyperRectangleBridge{T,G}},
 ) where {T,G}
     return MOI.supports(model, attr, MOI.ConstraintIndex{G,MOI.Nonnegatives})
@@ -284,7 +288,7 @@ end
 
 function MOI.set(
     model::MOI.ModelLike,
-    attr::MOI.ConstraintDualStart,
+    attr::Union{MOI.ConstraintDualStart,MOI.ConstraintDual},
     bridge::SplitHyperRectangleBridge{T},
     values::AbstractVector{T},
 ) where {T}

src/Utilities/results.jl

@@ -88,9 +88,17 @@ function _dual_objective_value(
     )
 end
 
+_lower(set::MOI.Interval, ::Type) = set.lower
+_upper(set::MOI.Interval, ::Type) = set.upper
+_lower(::MOI.ZeroOne, ::Type{T}) where {T} = zero(T)
+_upper(::MOI.ZeroOne, ::Type{T}) where {T} = one(T)
+
 function _dual_objective_value(
     model::MOI.ModelLike,
-    ci::MOI.ConstraintIndex{<:MOI.AbstractScalarFunction,<:MOI.Interval},
+    ci::MOI.ConstraintIndex{
+        <:MOI.AbstractScalarFunction,
+        <:Union{MOI.ZeroOne,MOI.Interval},
+    },
     ::Type{T},
     result_index::Integer,
 ) where {T}
@@ -100,10 +108,10 @@ function _dual_objective_value(
     if dual < zero(dual)
         # The dual is negative so it is in the dual of the MOI.LessThan cone
         # hence the upper bound of the Interval set is tight
-        constant -= set.upper
+        constant -= _upper(set, T)
     else
         # the lower bound is tight
-        constant -= set.lower
+        constant -= _lower(set, T)
     end
     return set_dot(constant, dual, set)
 end
@@ -119,14 +127,26 @@ function _dual_objective_value(
     set = MOI.get(model, MOI.ConstraintSet(), ci)
     dual = MOI.get(model, MOI.ConstraintDual(result_index), ci)
     constant = map(eachindex(func_constant)) do i
-        return func_constant[i] - if dual[i] < zero(dual[i])
-            # The dual is negative so it is in the dual of the MOI.LessThan cone
-            # hence the upper bound of the Interval set is tight
-            set.upper[i]
+        constant = func_constant[i]
+        if isfinite(set.upper[i])
+            if isfinite(set.lower[i])
+                if dual[i] < zero(dual[i])
+                    # The dual is negative so it is in the dual of the MOI.LessThan cone
+                    # hence the upper bound of the Interval set is tight
+                    constant -= set.upper[i]
+                else
+                    # the lower bound is tight
+                    constant -= set.lower[i]
+                end
+            else
+                constant -= set.upper[i]
+            end
         else
-            # the lower bound is tight
-            set.lower[i]
+            if isfinite(set.lower[i])
+                constant -= set.lower[i]
+            end
         end
+        return constant
     end
     return set_dot(constant, dual, set)
 end

test/Bridges/Constraint/ScalarFunctionizeBridge.jl

@@ -317,6 +317,7 @@ function test_FunctionConversionBridge()
         variables: x, y
         ScalarNonlinearFunction(1.0 * x * x + 2.0 * x * y + 3.0 * y + 4.0) >= 1.0
         """,
+        dual = nothing, # `get_fallback` ignores the constant `4.0` of the function
     )
     # VectorAffineFunction -> VectorQuadraticFunction
     MOI.Bridges.runtests(