Add SOCtoQuad bridge

Author: blegat

src/Bridges/Bridges.jl

@@ -25,6 +25,7 @@ include("lazybridgeoptimizer.jl")
 
 # This is used by JuMP and removes the need to update JuMP everytime a bridge is added
 MOIU.@model AllBridgedConstraints () (Interval,) (SecondOrderCone, RotatedSecondOrderCone, GeometricMeanCone, LogDetConeTriangle, RootDetConeTriangle) () () (ScalarAffineFunction,) (VectorOfVariables,) (VectorAffineFunction,)
+
 """
     fullbridgeoptimizer(model::MOI.ModelLike, ::Type{T}) where T
 
@@ -33,20 +34,23 @@ Returns a `LazyBridgeOptimizer` bridging `model` for every bridge defined in thi
 function fullbridgeoptimizer(model::MOI.ModelLike, ::Type{T}) where T
     bridgedmodel = MOIB.LazyBridgeOptimizer(model, AllBridgedConstraints{T}())
     addbridge!(bridgedmodel, MOIB.SplitIntervalBridge{T})
+    addbridge!(bridgedmodel, MOIB.RSOCBridge{T})
+    addbridge!(bridgedmodel, MOIB.SOCtoQuadBridge{T})
     addbridge!(bridgedmodel, MOIB.GeoMeanBridge{T})
     addbridge!(bridgedmodel, MOIB.SquarePSDBridge{T})
     addbridge!(bridgedmodel, MOIB.LogDetBridge{T})
     addbridge!(bridgedmodel, MOIB.RootDetBridge{T})
-    addbridge!(bridgedmodel, MOIB.RSOCBridge{T})
-    addbridge!(bridgedmodel, MOIB.RSOCtoPSDCBridge{T})
     addbridge!(bridgedmodel, MOIB.SOCtoPSDCBridge{T})
+    addbridge!(bridgedmodel, MOIB.RSOCtoPSDCBridge{T})
     bridgedmodel
 end
 
 include("intervalbridge.jl")
 @bridge SplitInterval SplitIntervalBridge () (Interval,) () () (SingleVariable,) (ScalarAffineFunction, ScalarQuadraticFunction) () ()
 include("rsocbridge.jl")
 @bridge RSOC RSOCBridge () () (RotatedSecondOrderCone,) () () () (VectorOfVariables,) (VectorAffineFunction,)
+include("soctoquadbridge.jl")
+@bridge SOCtoQuad SOCtoQuadBridge () () (SecondOrderCone,) () () () (VectorOfVariables,) (VectorAffineFunction,)
 include("geomeanbridge.jl")
 @bridge GeoMean GeoMeanBridge () () (GeometricMeanCone,) () () () (VectorOfVariables,) (VectorAffineFunction,)
 include("squarepsdbridge.jl")

src/Bridges/bridge.jl

@@ -76,3 +76,11 @@ function concrete_bridge_type(bridge_type::DataType,
                               ::Type{<:MOI.AbstractSet})
     return bridge_type
 end
+
+"""
+    need_constraint_primal_fallback(BT::Type{<:AbstractBridge})
+
+Return a `Bool` indicating whether bridges of concrete type `BT` need the bridge
+optimizer to use `get_fallback`.
+"""
+need_constraint_primal_fallback(::Type{<:AbstractBridge}) = false

src/Bridges/bridgeoptimizer.jl

@@ -250,6 +250,30 @@ function MOI.get(b::AbstractBridgeOptimizer, attr::ResultConstraintAttribute,
         MOI.get(b.model, attr, ci)
     end
 end
+function MOI.canget(b::AbstractBridgeOptimizer, attr::MOI.ConstraintPrimal,
+                    ci::Type{CI{F, S}}) where {F, S}
+    if isbridged(b, F, S)
+        if need_constraint_primal_fallback(concrete_bridge_type(b, F, S))
+            return true
+        else
+            return MOI.canget(b, attr, concrete_bridge_type(b, F, S))
+        end
+    else
+        return MOI.canget(b.model, attr, ci)
+    end
+end
+function MOI.get(b::AbstractBridgeOptimizer, attr::MOI.ConstraintPrimal,
+                 ci::CI{F, S}) where {F, S}
+    if isbridged(b, typeof(ci))
+        if need_constraint_primal_fallback(concrete_bridge_type(b, F, S))
+            MOIU.get_fallback(b, attr, ci)
+        else
+            MOI.get(b, attr, bridge(b, ci))
+        end
+    else
+        MOI.get(b.model, attr, ci)
+    end
+end
 ## Model constraint attributes
 const ModelConstraintAttribute = Union{MOI.ConstraintName,
                                        MOI.ConstraintFunction,

src/Bridges/soctoquadbridge.jl

@@ -0,0 +1,83 @@
+"""
+    SOCtoQuadBridge{T}
+
+Constraints of the form `VectorOfVariables`-in-`SecondOrderCone` (resp.
+`VectorAffineFunction`-in-`SecondOrderCone`) can be transformed into a
+`ScalarQuadraticFunction`-in-`GreaterThan` and a
+`SingleVariable`-in-`GreaterThan` (resp.
+`ScalarAffineFunction`-in-`SecondOrderCone`). Indeed, the definition of the
+second-order cone
+```math
+t \\ge || x ||_2 \\}
+```
+is equivalent to
+```math
+\\sum x_i^2 \\le t^2
+```
+with ``t \\ge 0``.
+"""
+struct SOCtoQuadBridge{T, F, G} <: AbstractBridge
+    quad::CI{F, MOI.GreaterThan{T}}
+    t_nonneg::CI{G, MOI.GreaterThan{T}}
+end
+function SOCtoQuadBridge{T, F, G}(model::MOI.ModelLike,
+                                  f::MOI.AbstractVectorFunction,
+                                  s::MOI.SecondOrderCone) where {T, F, G}
+    d = s.dimension
+    f_scalars = MOIU.eachscalar(f)
+    t = f_scalars[1]
+    t_nonneg = MOIU.add_scalar_constraint(model, t, MOI.GreaterThan(zero(T)))
+    quad_f = MOIU.operate(*, T, t, t)
+    for i in 2:d
+        x = f_scalars[i]
+        quad_f = MOIU.operate!(-, T, quad_f, MOIU.operate(*, T, x, x))
+    end
+    quad = MOIU.add_scalar_constraint(model, quad_f, MOI.GreaterThan(zero(T)))
+    return SOCtoQuadBridge{T, F, G}(quad, t_nonneg)
+end
+
+function MOI.supportsconstraint(::Type{SOCtoQuadBridge{T}},
+                                ::Type{<:MOI.AbstractVectorFunction},
+                                ::Type{MOI.SecondOrderCone}) where T
+    return true
+end
+function addedconstrainttypes(::Type{SOCtoQuadBridge{T, F, G}}) where {T, F, G}
+    list = [(F, MOI.GreaterThan{T})]
+    if F != G
+        push!(list, (G, MOI.GreaterThan{T}))
+    end
+    return list
+end
+function concrete_bridge_type(::Type{<:SOCtoQuadBridge{T}},
+                              H::Type{<:MOI.AbstractVectorFunction},
+                              ::Type{MOI.SecondOrderCone}) where T
+    G = MOIU.scalar_type(H)
+    Q = MOIU.promote_operation(*, T, G, G)
+    F = MOIU.promote_operation(-, T, Q, Q)
+    return SOCtoQuadBridge{T, F, G}
+end
+
+# Attributes, Bridge acting as an model
+function MOI.get(b::SOCtoQuadBridge{T, F, G},
+                 ::MOI.NumberOfConstraints{H, MOI.GreaterThan{T}}) where {T, F, G, H}
+    return (F == H) + (G == H)
+end
+function MOI.get(b::SOCtoQuadBridge{T, F, G},
+                 ::MOI.ListOfConstraintIndices{H, MOI.GreaterThan{T}}) where {T, F, G, H}
+    list = CI{H, MOI.GreaterThan{T}}[]
+    if F == H
+        push!(list, b.quad)
+    end
+    if G == H
+        push!(list, b.t_nonneg)
+    end
+    return list
+end
+
+# References
+function MOI.delete!(model::MOI.ModelLike, bridge::SOCtoQuadBridge)
+    MOI.delete!(model, bridge.t_nonneg)
+    MOI.delete!(model, bridge.quad)
+end
+
+need_constraint_primal_fallback(::Type{<:SOCtoQuadBridge}) = true

src/Utilities/constraints.jl

@@ -1,3 +1,7 @@
+function add_scalar_constraint(model::MOI.ModelLike, func::MOI.SingleVariable,
+                               set::MOI.AbstractScalarSet)
+    return MOI.addconstraint!(model, func, set)
+end
 function add_scalar_constraint(model::MOI.ModelLike,
                                func::Union{MOI.ScalarAffineFunction{T},
                                            MOI.ScalarQuadraticFunction{T}},