Add NormCone for representing the epigraph of a p-norm

Author: odow

docs/src/manual/standard_form.md

@@ -79,6 +79,7 @@ The vector-valued set types implemented in MathOptInterface.jl are:
 | [`NormInfinityCone(d)`](@ref MathOptInterface.NormInfinityCone)       | ``\{ (t,x) \in \mathbb{R}^{d} : t \ge \max_i \lvert x_i \rvert \}`` |
 | [`RelativeEntropyCone(d)`](@ref MathOptInterface.RelativeEntropyCone) | ``\{ (u, v, w) \in \mathbb{R}^{d} : u \ge \sum_i w_i \log (\frac{w_i}{v_i}), v_i \ge 0, w_i \ge 0 \}`` |
 | [`HyperRectangle(l, u)`](@ref MathOptInterface.HyperRectangle)        | ``\{x \in \bar{\mathbb{R}}^d: x_i \in [l_i, u_i] \forall i=1,\ldots,d\}`` |
+| [`NormCone(p, d)`](@ref MathOptInterface.NormCone)       | ``\{ (t,x) \in \mathbb{R}^{d} : t \ge \left(\sum\limits_i |x_i|^p\right)^{\frac{1}{p}} \}`` |
 
 ## Matrix cones
 

docs/src/reference/standard_form.md

@@ -82,6 +82,7 @@ Nonnegatives
 Nonpositives
 NormInfinityCone
 NormOneCone
+NormCone
 SecondOrderCone
 RotatedSecondOrderCone
 GeometricMeanCone

docs/src/submodules/Bridges/list_of_bridges.md

@@ -41,6 +41,7 @@ Bridges.Constraint.SOCtoPSDBridge
 Bridges.Constraint.RSOCtoPSDBridge
 Bridges.Constraint.NormInfinityBridge
 Bridges.Constraint.NormOneBridge
+Bridges.Constraint.NormToPowerBridge
 Bridges.Constraint.GeoMeantoRelEntrBridge
 Bridges.Constraint.GeoMeanToPowerBridge
 Bridges.Constraint.GeoMeanBridge

src/Bridges/Constraint/Constraint.jl

@@ -39,6 +39,7 @@ include("bridges/interval.jl")
 include("bridges/ltgt_to_interval.jl")
 include("bridges/norm_infinity.jl")
 include("bridges/norm_one.jl")
+include("bridges/norm_to_power.jl")
 include("bridges/norm_spec_nuc_to_psd.jl")
 include("bridges/number_conversion.jl")
 include("bridges/quad_to_soc.jl")
@@ -93,6 +94,7 @@ function add_all_bridges(bridged_model, ::Type{T}) where {T}
     MOI.Bridges.add_bridge(bridged_model, GeoMeantoRelEntrBridge{T})
     MOI.Bridges.add_bridge(bridged_model, GeoMeanBridge{T})
     MOI.Bridges.add_bridge(bridged_model, GeoMeanToPowerBridge{T})
+    MOI.Bridges.add_bridge(bridged_model, NormToPowerBridge{T})
     MOI.Bridges.add_bridge(bridged_model, RelativeEntropyBridge{T})
     MOI.Bridges.add_bridge(bridged_model, NormSpectralBridge{T})
     MOI.Bridges.add_bridge(bridged_model, NormNuclearBridge{T})

src/Bridges/Constraint/bridges/norm_to_power.jl

@@ -0,0 +1,160 @@
+# 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.
+
+"""
+    NormToPowerBridge{T,F} <: Bridges.Constraint.AbstractBridge
+
+`NormToPowerBridge` implements the following reformulation:
+
+  * ``(t, x...) \\in NormCone(p, 1+d)`` into ``(r_i, t, x_i) \\in PowerCone(1 / p)``
+    for all ``i``, and ``\\sum\\limits_i r_i == t``.
+
+## Source node
+
+`NormToPowerBridge` supports:
+
+  * `F` in [`MOI.NormCone`](@ref)
+
+## Target nodes
+
+`NormToPowerBridge` creates:
+
+  * `F` in [`MOI.PowerCone{T}`](@ref)
+  * [`MOI.ScalarAffineFunction`](@ref) in [`MOI.EqualTo`](@ref)
+"""
+struct NormToPowerBridge{T,F} <: AbstractBridge
+    power::Vector{MOI.ConstraintIndex{F,MOI.PowerCone{T}}}
+    r::Vector{MOI.VariableIndex}
+    equal::MOI.ConstraintIndex{MOI.ScalarAffineFunction{T},MOI.EqualTo{T}}
+    set::MOI.NormCone
+end
+
+const NormToPower{T,OT<:MOI.ModelLike} =
+    SingleBridgeOptimizer{NormToPowerBridge{T},OT}
+
+function bridge_constraint(
+    ::Type{NormToPowerBridge{T,F}},
+    model::MOI.ModelLike,
+    f::F,
+    s::MOI.NormCone,
+) where {T,F}
+    d = MOI.dimension(s)
+    fi_s = MOI.Utilities.eachscalar(f)
+    r = MOI.add_variables(model, d - 1)
+    power_ci = MOI.ConstraintIndex{F,MOI.PowerCone{T}}[
+        MOI.add_constraint(
+            model,
+            MOI.Utilities.operate(vcat, T, r[i], fi_s[1], fi_s[i+1]),
+            MOI.PowerCone(T(1 / s.p)),
+        ) for i in 1:length(r)
+    ]
+    f = zero(MOI.ScalarAffineFunction{T})
+    for ri in r
+        f = MOI.Utilities.operate!(+, T, f, ri)
+    end
+    MOI.Utilities.operate!(-, T, f, fi_s[1])
+    equal_ci = MOI.add_constraint(model, f, MOI.EqualTo(zero(T)))
+    return NormToPowerBridge{T,F}(power_ci, r, equal_ci, s)
+end
+
+function MOI.supports_constraint(
+    ::Type{<:NormToPowerBridge{T}},
+    ::Type{<:MOI.AbstractVectorFunction},
+    ::Type{MOI.NormCone},
+) where {T}
+    return true
+end
+
+function MOI.Bridges.added_constrained_variable_types(
+    ::Type{<:NormToPowerBridge},
+)
+    return Tuple{Type}[]
+end
+
+function MOI.Bridges.added_constraint_types(
+    ::Type{<:NormToPowerBridge{T,F}},
+) where {T,F}
+    return Tuple{Type,Type}[
+        (F, MOI.PowerCone{T}),
+        (MOI.ScalarAffineFunction{T}, MOI.EqualTo{T}),
+    ]
+end
+
+function concrete_bridge_type(
+    ::Type{<:NormToPowerBridge{T}},
+    F::Type{<:MOI.AbstractVectorFunction},
+    ::Type{MOI.NormCone},
+) where {T}
+    return NormToPowerBridge{T,F}
+end
+
+function MOI.get(bridge::NormToPowerBridge, ::MOI.NumberOfVariables)::Int64
+    return length(bridge.r)
+end
+
+function MOI.get(bridge::NormToPowerBridge, ::MOI.ListOfVariableIndices)
+    return copy(bridge.r)
+end
+
+function MOI.get(
+    bridge::NormToPowerBridge{T,F},
+    ::MOI.NumberOfConstraints{F,MOI.PowerCone{T}},
+)::Int64 where {T,F}
+    return length(bridge.power)
+end
+
+function MOI.get(
+    bridge::NormToPowerBridge{T,F},
+    ::MOI.ListOfConstraintIndices{F,MOI.PowerCone{T}},
+) where {T,F}
+    return copy(bridge.power)
+end
+
+function MOI.get(
+    bridge::NormToPowerBridge{T},
+    ::MOI.NumberOfConstraints{MOI.ScalarAffineFunction{T},MOI.EqualTo{T}},
+)::Int64 where {T}
+    return 1
+end
+
+function MOI.get(
+    bridge::NormToPowerBridge{T},
+    ::MOI.ListOfConstraintIndices{MOI.ScalarAffineFunction{T},MOI.EqualTo{T}},
+) where {T}
+    return [bridge.equal]
+end
+
+function MOI.delete(model::MOI.ModelLike, bridge::NormToPowerBridge)
+    MOI.delete(model, bridge.power)
+    MOI.delete(model, bridge.equal)
+    MOI.delete(model, bridge.r)
+    return
+end
+
+function MOI.get(
+    model::MOI.ModelLike,
+    ::MOI.ConstraintFunction,
+    bridge::NormToPowerBridge{T,F},
+) where {T,F}
+    elements = MOI.Utilities.scalar_type(F)[]
+    for ci in bridge.power
+        f = MOI.get(model, MOI.ConstraintFunction(), ci)
+        fi_s = MOI.Utilities.eachscalar(f)
+        if isempty(elements)
+            push!(elements, fi_s[2])
+        end
+        push!(elements, fi_s[3])
+    end
+    return MOI.Utilities.operate(vcat, T, elements...)
+end
+
+function MOI.get(
+    ::MOI.ModelLike,
+    ::MOI.ConstraintSet,
+    bridge::NormToPowerBridge,
+)
+    return bridge.set
+end

src/Test/test_basic_constraint.jl

@@ -88,6 +88,7 @@ _set(::Type{MOI.Nonpositives}) = MOI.Nonpositives(2)
 _set(::Type{MOI.Nonnegatives}) = MOI.Nonnegatives(2)
 _set(::Type{MOI.NormInfinityCone}) = MOI.NormInfinityCone(3)
 _set(::Type{MOI.NormOneCone}) = MOI.NormOneCone(3)
+_set(::Type{MOI.NormCone}) = MOI.NormCone(4.0, 3)
 _set(::Type{MOI.SecondOrderCone}) = MOI.SecondOrderCone(3)
 _set(::Type{MOI.RotatedSecondOrderCone}) = MOI.RotatedSecondOrderCone(3)
 _set(::Type{MOI.GeometricMeanCone}) = MOI.GeometricMeanCone(3)
@@ -275,6 +276,7 @@ for s in [
     :Nonnegatives,
     :NormInfinityCone,
     :NormOneCone,
+    :NormCone,
     :SecondOrderCone,
     :RotatedSecondOrderCone,
     :GeometricMeanCone,

src/Test/test_conic.jl

@@ -7023,3 +7023,45 @@ function version_added(
 )
     return v"1.7.0"
 end
+
+"""
+    test_conic_NormCone(model::MOI.ModelLike, config::Config)
+
+Test [`MOI.NormCone`](@ref).
+"""
+function test_conic_NormCone(model::MOI.ModelLike, config::Config{T}) where {T}
+    @requires _supports(config, MOI.optimize!)
+    @requires MOI.supports_constraint(
+        model,
+        MOI.VectorOfVariables,
+        MOI.NormCone,
+    )
+    t = MOI.add_variable(model)
+    x = MOI.add_variables(model, 4)
+    x0 = T[1, 2, 3, 4]
+    MOI.add_constraint.(model, x, MOI.EqualTo.(x0))
+    f = MOI.VectorOfVariables([t; x])
+    MOI.add_constraint(model, f, MOI.NormCone(4, 5))
+    MOI.set(model, MOI.ObjectiveSense(), MOI.MIN_SENSE)
+    MOI.set(model, MOI.ObjectiveFunction{typeof(t)}(), t)
+    MOI.optimize!(model)
+    target = LinearAlgebra.norm(x0, 4)
+    @test ≈(MOI.get(model, MOI.VariablePrimal(), t), target, config)
+    return
+end
+
+function setup_test(
+    ::typeof(test_conic_NormCone),
+    model::MOIU.MockOptimizer,
+    ::Config{T},
+) where {T}
+    x0 = T[1, 2, 3, 4]
+    MOIU.set_mock_optimize!(
+        model,
+        (mock::MOIU.MockOptimizer) ->
+            MOIU.mock_optimize!(mock, T[LinearAlgebra.norm(x0, 4); x0]),
+    )
+    return
+end
+
+version_added(::typeof(test_conic_NormCone)) = v"1.14.0"

src/Utilities/model.jl

@@ -780,6 +780,7 @@ const LessThanIndicatorZero{T} =
         MOI.Complements,
         MOI.NormInfinityCone,
         MOI.NormOneCone,
+        MOI.NormCone,
         MOI.SecondOrderCone,
         MOI.RotatedSecondOrderCone,
         MOI.GeometricMeanCone,

src/sets.jl

@@ -668,6 +668,48 @@ end
 dual_set(s::NormOneCone) = NormInfinityCone(dimension(s))
 dual_set_type(::Type{NormOneCone}) = NormInfinityCone
 
+"""
+    NormCone(p::Float64, dimension::Int)
+
+The ``\\ell_p``-norm cone ``\\{ (t,x) \\in \\mathbb{R}^{dimension} : t \\ge \\left(\\sum\\limits_i |x_i|^p\\right)^{\\frac{1}{p}} \\}``
+of dimension `dimension`.
+
+The `dimension` must be at least `1`.
+
+## Example
+
+```jldoctest
+julia> import MathOptInterface as MOI
+
+julia> model = MOI.Utilities.Model{Float64}()
+MOIU.Model{Float64}
+
+julia> t = MOI.add_variable(model)
+MOI.VariableIndex(1)
+
+julia> x = MOI.add_variables(model, 3);
+
+julia> MOI.add_constraint(model, MOI.VectorOfVariables([t; x]), MOI.NormCone(3, 4))
+MathOptInterface.ConstraintIndex{MathOptInterface.VectorOfVariables, MathOptInterface.NormCone}(1)
+```
+"""
+struct NormCone <: AbstractVectorSet
+    p::Float64
+    dimension::Int
+
+    function NormCone(p::Real, dimension::Base.Integer)
+        if !(dimension >= 1)
+            throw(
+                DimensionMismatch(
+                    "Dimension of NormCone must be >= 1, not " *
+                    "$(dimension).",
+                ),
+            )
+        end
+        return new(convert(Float64, p), dimension)
+    end
+end
+
 """
     SecondOrderCone(dimension::Int)
 

test/Bridges/Constraint/norm_to_power.jl

@@ -0,0 +1,79 @@
+# 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.
+
+module TestConstraintNormToPower
+
+using Test
+
+import MathOptInterface as MOI
+
+function runtests()
+    for name in names(@__MODULE__; all = true)
+        if startswith("$(name)", "test_")
+            @testset "$(name)" begin
+                getfield(@__MODULE__, name)()
+            end
+        end
+    end
+    return
+end
+
+function test_runtests_dimension_5()
+    MOI.Bridges.runtests(
+        MOI.Bridges.Constraint.NormToPowerBridge,
+        """
+        variables: t, x1, x2, x3, x4
+        [t, x1, x2, x3, x4] in NormCone(4, 5)
+        """,
+        """
+        variables: t, x1, x2, x3, x4, r1, r2, r3, r4
+        [r1, t, x1] in PowerCone(0.25)
+        [r2, t, x2] in PowerCone(0.25)
+        [r3, t, x3] in PowerCone(0.25)
+        [r4, t, x4] in PowerCone(0.25)
+        r1 + r2 + r3 + r4 + -1.0 * t == 0.0
+        """,
+    )
+    return
+end
+
+function test_runtests_dimension_4()
+    MOI.Bridges.runtests(
+        MOI.Bridges.Constraint.NormToPowerBridge,
+        """
+        variables: t, x1, x2, x3
+        [t, 1.0 * x1, 2.0 * x2, x3] in NormCone(4, 4)
+        """,
+        """
+        variables: t, x1, x2, x3, r1, r2, r3
+        [r1, t, 1.0 * x1] in PowerCone(0.25)
+        [r2, t, 2.0 * x2] in PowerCone(0.25)
+        [r3, t, 1.0 * x3] in PowerCone(0.25)
+        r1 + r2 + r3 + -1.0 * t == 0.0
+        """,
+    )
+    return
+end
+
+function test_runtests_dimension_2()
+    MOI.Bridges.runtests(
+        MOI.Bridges.Constraint.NormToPowerBridge,
+        """
+        variables: t, x1
+        [t, x1] in NormCone(2, 2)
+        """,
+        """
+        variables: t, x1, r1
+        [r1, t, x1] in PowerCone(0.5)
+        r1 + -1.0 * t == 0.0
+        """,
+    )
+    return
+end
+
+end  # module
+
+TestConstraintNormToPower.runtests()