Use MOI.RotatedSecondOrderCone in QuadOverLinAtom (#601)

Author: blegat

src/atoms/second_order_cone/QolElemAtom.jl

@@ -30,10 +30,12 @@ function new_conic_form!(context::Context{T}, q::QolElemAtom) where {T}
     x, y = q.children
     t = Variable(x.size)
     for i in 1:length(x)
-        f = vcat(y[i] + t[i], y[i] - t[i], 2 * x[i])
-        add_constraint!(context, GenericConstraint{MOI.SecondOrderCone}(f))
+        f = vcat(t[i], (1 / T(2)) * y[i], x[i])
+        add_constraint!(
+            context,
+            GenericConstraint{MOI.RotatedSecondOrderCone}(f),
+        )
     end
-    add_constraint!(context, y >= 0)
     return conic_form!(context, t)
 end
 

src/atoms/second_order_cone/QuadOverLinAtom.jl

@@ -27,12 +27,11 @@ function evaluate(q::QuadOverLinAtom)
     return x' * x / evaluate(q.children[2])
 end
 
-function new_conic_form!(context::Context, q::QuadOverLinAtom)
+function new_conic_form!(context::Context{T}, q::QuadOverLinAtom) where {T}
     t = Variable()
     x, y = q.children
-    f = vcat(y + t, y - t, 2 * x)
-    add_constraint!(context, GenericConstraint{MOI.SecondOrderCone}(f))
-    add_constraint!(context, y >= 0)
+    f = vcat(t, (1 / T(2)) * y, x)
+    add_constraint!(context, GenericConstraint{MOI.RotatedSecondOrderCone}(f))
     return conic_form!(context, t)
 end
 

src/constraints/GenericConstraint.jl

@@ -265,3 +265,16 @@ function vexity(vex, ::MOI.SecondOrderCone)
     end
     return ConvexVexity()
 end
+
+# ==============================================================================
+#     RotatedSecondOrderCone
+# ==============================================================================
+
+head(io::IO, ::MOI.RotatedSecondOrderCone) = print(io, "rsoc")
+
+function vexity(vex, ::MOI.RotatedSecondOrderCone)
+    if !(vex == ConstVexity() || vex == AffineVexity())
+        return NotDcp()
+    end
+    return ConvexVexity()
+end

test/test_atoms.jl

@@ -536,7 +536,7 @@ function test_MultiplyAtom()
     target = """
     variables: t, x
     minobjective: 1.0 * t
-    [1.0 + 1.0 * t, 1.0 + -1.0 * t, 2.0 * x] in SecondOrderCone(3)
+    [t, 0.5, x] in RotatedSecondOrderCone(3)
     """
     _test_atom(target) do context
         x = Variable()
@@ -965,7 +965,7 @@ function test_AbsAtom()
     minobjective: 1.0 * w
     [1.0 * t + -1.0 * x] in Nonnegatives(1)
     [1.0 * t + 1.0 * x] in Nonnegatives(1)
-    [1.0 + 1.0*w, 1.0 + -1.0*w, 2.0*t] in SecondOrderCone(3)
+    [w, 0.5, t] in RotatedSecondOrderCone(3)
     """
     _test_atom(target) do context
         return abs2(Variable())
@@ -1505,7 +1505,7 @@ function test_HuberAtom()
     [1.0 * c + -1.0 * s + -1.0 * n] in Zeros(1)
     [-1.0 * n + 1.0 * n_abs] in Nonnegatives(1)
     [1.0 * n + 1.0 * n_abs] in Nonnegatives(1)
-    [1.0 + 1.0 * t, 1.0 + -1.0 * t, 2.0 * s] in SecondOrderCone(3)
+    [t, 0.5, s] in RotatedSecondOrderCone(3)
     """
     _test_atom(target) do context
         return huber(Variable(), 2.0)
@@ -1533,20 +1533,19 @@ end
 
 function test_QolElemAtom()
     target = """
-    variables: y1, y2, t1, t2, x1, x2
+    variables: t1, t2, y1, y2, x1, x2
     minobjective: [1.0 * t1, 1.0 * t2]
-    [1.0 * y1, 1.0 * y2] in Nonnegatives(2)
-    [1.0 * y1 + 1.0 * t1, 1.0 * y1 + -1.0 * t1, 2.0 * x1] in SecondOrderCone(3)
-    [1.0 * y2 + 1.0 * t2, 1.0 * y2 + -1.0 * t2, 2.0 * x2] in SecondOrderCone(3)
+    [t1, 0.5 * y1, x1] in RotatedSecondOrderCone(3)
+    [t2, 0.5 * y2, x2] in RotatedSecondOrderCone(3)
     """
     _test_atom(target) do context
         return qol_elementwise(Variable(2), Variable(2))
     end
     target = """
     variables: t1, t2, x1, x2
     minobjective: [1.0 * t1, 1.0 * t2]
-    [1.0 + 1.0 * t1, 1.0 + -1.0 * t1, 2.0 * x1] in SecondOrderCone(3)
-    [1.0 + 1.0 * t2, 1.0 + -1.0 * t2, 2.0 * x2] in SecondOrderCone(3)
+    [t1, 0.5, x1] in RotatedSecondOrderCone(3)
+    [t2, 0.5, x2] in RotatedSecondOrderCone(3)
     """
     _test_atom(target) do context
         return qol_elementwise(Variable(2), constant([1, 1]))
@@ -1562,11 +1561,10 @@ function test_QolElemAtom()
         return Variable(2) .^ a
     end
     target = """
-    variables: y1, y2, t1, t2
+    variables: t1, t2, y1, y2
     minobjective: [1.0 * t1, 1.0 * t2]
-    [1.0 * y1, 1.0 * y2] in Nonnegatives(2)
-    [1.0 * y1 + 1.0 * t1, 1.0 * y1 + -1.0 * t1, 2.0] in SecondOrderCone(3)
-    [1.0 * y2 + 1.0 * t2, 1.0 * y2 + -1.0 * t2, 2.0] in SecondOrderCone(3)
+    [t1, 0.5 * y1, 1.0] in RotatedSecondOrderCone(3)
+    [t2, 0.5 * y2, 1.0] in RotatedSecondOrderCone(3)
     """
     _test_atom(target) do context
         return invpos(Variable(2))
@@ -1575,10 +1573,9 @@ function test_QolElemAtom()
         return 1 ./ Variable(2)
     end
     target = """
-    variables: y, t
+    variables: t, y
     minobjective: 3.0 * t
-    [1.0 * y] in Nonnegatives(1)
-    [1.0 * y + 1.0 * t, 1.0 * y + -1.0 * t, 2.0] in SecondOrderCone(3)
+    [t, 0.5 * y, 1.0] in RotatedSecondOrderCone(3)
     """
     _test_atom(target) do context
         return 3 / Variable()
@@ -1620,10 +1617,9 @@ end
 
 function test_QuadOverLinAtom()
     target = """
-    variables: y, t, x1, x2
+    variables: t, y, x1, x2
     minobjective: 1.0 * t
-    [1.0 * y] in Nonnegatives(1)
-    [1.0 * y + 1.0 * t, 1.0 * y + -1.0 * t, 2.0 * x1, 2.0 * x2] in SecondOrderCone(4)
+    [t, 0.5 * y, x1, x2] in RotatedSecondOrderCone(4)
     """
     _test_atom(target) do context
         return quadoverlin(Variable(2), Variable())
@@ -1931,7 +1927,7 @@ function test_quadform()
     variables: u, t, x1, x2
     minobjective: 1.0 * u
     [t, 3.999999999999999*x1+1.9999999999999998*x2, 1.9999999999999998*x1+3.999999999999999*x2] in SecondOrderCone(3)
-    [1.0+1.0*u, 1.0+-1.0*u, 2.0*t] in SecondOrderCone(3)
+    [u, 0.5, t] in RotatedSecondOrderCone(3)
     """
     _test_reformulation(target) do context
         return quadform(Variable(2), [20.0 16.0; 16.0 20.0])
@@ -1946,7 +1942,7 @@ function test_quadform()
     variables: u, t, x1, x2
     minobjective: 1.0 + -1.0 * u
     [t, 3.999999999999999*x1+1.9999999999999998*x2, 1.9999999999999998*x1+3.999999999999999*x2] in SecondOrderCone(3)
-    [1.0+1.0*u, 1.0+-1.0*u, 2.0*t] in SecondOrderCone(3)
+    [u, 0.5, t] in RotatedSecondOrderCone(3)
     """
     _test_reformulation(target) do context
         return 1 + quadform(Variable(2), -[20 16; 16 20])

test/test_constraints.jl

@@ -215,6 +215,7 @@ function test_GenericConstraint_SecondOrderCone()
     @test isapprox(c.dual, [1, -2 / t_, -3 / t_, -4 / t_]; atol = 1e-3)
     c = Convex.GenericConstraint{MOI.SecondOrderCone}(vcat(square(t), x))
     @test vexity(c) === Convex.NotDcp()
+    @test Convex.sprint(Convex.head, c) == "soc"
     return
 end
 
@@ -232,6 +233,23 @@ function test_GenericConstraint_SecondOrderCone_set_with_size()
     return
 end
 
+### constraints/GenericConstraint_RotatedSecondOrderCone
+
+function test_GenericConstraint_RotatedSecondOrderCone()
+    x = Variable(3)
+    t = Variable()
+    c = Convex.GenericConstraint{MOI.RotatedSecondOrderCone}(vcat(t, 1, x))
+    p = minimize(t, [c, x >= [2, 3, 4]])
+    solve!(p, SCS.Optimizer; silent_solver = true)
+    @test isapprox(x.value, [2, 3, 4]; atol = 1e-3)
+    @test isapprox(t.value, 29 / 2; atol = 1e-3)
+    @test isapprox(c.dual, [1, 29 / 2, -2, -3, -4]; atol = 1e-3)
+    c = Convex.GenericConstraint{MOI.RotatedSecondOrderCone}(vcat(square(t), x))
+    @test vexity(c) === Convex.NotDcp()
+    @test Convex.sprint(Convex.head, c) == "rsoc"
+    return
+end
+
 ### constraints/GenericConstraint_ExponentialCone
 
 function test_GenericConstraint_ExponentialConeConstraint()