pepflow 0.1.4__py3-none-any.whl → 0.1.5__py3-none-any.whl

pepflow/scalar_test.py

@@ -17,155 +17,148 @@
 # specific language governing permissions and limitations
 # under the License.
 
+from typing import Iterator
 
 import numpy as np
+import pytest
 
 from pepflow import expression_manager as exm
 from pepflow import pep as pep
-from pepflow import point, scalar, utils
+from pepflow import pep_context as pc
+from pepflow import point, scalar
 
 
-def test_scalar_add_tag():
-    pep_builder = pep.PEPBuilder()
-    with pep_builder.make_context("test"):
-        s1 = scalar.Scalar(is_basis=True, eval_expression=None, tags=["s1"])
-        s2 = scalar.Scalar(is_basis=True, eval_expression=None, tags=["s2"])
+@pytest.fixture
+def pep_context() -> Iterator[pc.PEPContext]:
+    """Prepare the pep context and reset the context to None at the end."""
+    ctx = pc.PEPContext("test").set_as_current()
+    yield ctx
+    pc.set_current_context(None)
 
-        s_add = s1 + s2
-        assert s_add.tag == "s1+s2"
 
-        s_add = s1 + 0.1
-        assert s_add.tag == "s1+0.1"
+def test_scalar_add_tag(pep_context: pc.PEPContext):
+    s1 = scalar.Scalar(is_basis=True, eval_expression=None, tags=["s1"])
+    s2 = scalar.Scalar(is_basis=True, eval_expression=None, tags=["s2"])
 
-        s_radd = 0.1 + s1
-        assert s_radd.tag == "0.1+s1"
+    s_add = s1 + s2
+    assert s_add.tag == "s1+s2"
 
-        s_sub = s1 - s2
-        assert s_sub.tag == "s1-s2"
+    s_add = s1 + 0.1
+    assert s_add.tag == "s1+0.1"
 
-        s_sub = s1 - (s2 + s1)
-        assert s_sub.tag == "s1-(s2+s1)"
+    s_radd = 0.1 + s1
+    assert s_radd.tag == "0.1+s1"
 
-        s_sub = s1 - (s2 - s1)
-        assert s_sub.tag == "s1-(s2-s1)"
+    s_sub = s1 - s2
+    assert s_sub.tag == "s1-s2"
 
-        s_sub = s1 - 0.1
-        assert s_sub.tag == "s1-0.1"
+    s_sub = s1 - (s2 + s1)
+    assert s_sub.tag == "s1-(s2+s1)"
 
-        s_rsub = 0.1 - s1
-        assert s_rsub.tag == "0.1-s1"
+    s_sub = s1 - (s2 - s1)
+    assert s_sub.tag == "s1-(s2-s1)"
 
+    s_sub = s1 - 0.1
+    assert s_sub.tag == "s1-0.1"
 
-def test_scalar_mul_tag():
-    pep_builder = pep.PEPBuilder()
-    with pep_builder.make_context("test"):
-        s = scalar.Scalar(is_basis=True, eval_expression=None, tags=["s"])
+    s_rsub = 0.1 - s1
+    assert s_rsub.tag == "0.1-s1"
 
-        s_mul = s * 0.1
-        assert s_mul.tag == "s*0.1"
 
-        s_rmul = 0.1 * s
-        assert s_rmul.tag == "0.1*s"
+def test_scalar_mul_tag(pep_context: pc.PEPContext):
+    s = scalar.Scalar(is_basis=True, eval_expression=None, tags=["s"])
 
-        s_neg = -s
-        assert s_neg.tag == "-s"
+    s_mul = s * 0.1
+    assert s_mul.tag == "s*0.1"
 
-        s_truediv = s / 0.1
-        assert s_truediv.tag == "1/0.1*s"
+    s_rmul = 0.1 * s
+    assert s_rmul.tag == "0.1*s"
 
+    s_neg = -s
+    assert s_neg.tag == "-s"
 
-def test_scalar_add_and_mul_tag():
-    pep_builder = pep.PEPBuilder()
-    with pep_builder.make_context("test"):
-        s1 = scalar.Scalar(is_basis=True, eval_expression=None, tags=["s1"])
-        s2 = scalar.Scalar(is_basis=True, eval_expression=None, tags=["s2"])
+    s_truediv = s / 0.1
+    assert s_truediv.tag == "1/0.1*s"
 
-        s_add_mul = (s1 + s2) * 0.1
-        assert s_add_mul.tag == "(s1+s2)*0.1"
 
-        s_add_mul = s1 + s2 * 0.1
-        assert s_add_mul.tag == "s1+s2*0.1"
+def test_scalar_add_and_mul_tag(pep_context: pc.PEPContext):
+    s1 = scalar.Scalar(is_basis=True, eval_expression=None, tags=["s1"])
+    s2 = scalar.Scalar(is_basis=True, eval_expression=None, tags=["s2"])
 
-        s_neg_add = -(s1 + s2)
-        assert s_neg_add.tag == "-(s1+s2)"
+    s_add_mul = (s1 + s2) * 0.1
+    assert s_add_mul.tag == "(s1+s2)*0.1"
 
-        s_rmul_add = 0.1 * (s1 + s2)
-        assert s_rmul_add.tag == "0.1*(s1+s2)"
+    s_add_mul = s1 + s2 * 0.1
+    assert s_add_mul.tag == "s1+s2*0.1"
 
+    s_neg_add = -(s1 + s2)
+    assert s_neg_add.tag == "-(s1+s2)"
 
-def test_scalar_hash_different():
-    pep_builder = pep.PEPBuilder()
-    with pep_builder.make_context("test"):
-        s1 = scalar.Scalar(is_basis=True, eval_expression=None)
-        s2 = scalar.Scalar(is_basis=True, eval_expression=None)
+    s_rmul_add = 0.1 * (s1 + s2)
+    assert s_rmul_add.tag == "0.1*(s1+s2)"
+
+
+def test_scalar_hash_different(pep_context: pc.PEPContext):
+    s1 = scalar.Scalar(is_basis=True, eval_expression=None)
+    s2 = scalar.Scalar(is_basis=True, eval_expression=None)
     assert s1.uid != s2.uid
 
 
-def test_scalar_tag():
-    pep_builder = pep.PEPBuilder()
-    with pep_builder.make_context("test"):
-        s1 = scalar.Scalar(is_basis=True, eval_expression=None)
-        s1.add_tag(tag="my_tag")
+def test_scalar_tag(pep_context: pc.PEPContext):
+    s1 = scalar.Scalar(is_basis=True, eval_expression=None)
+    s1.add_tag(tag="my_tag")
     assert s1.tags == ["my_tag"]
     assert s1.tag == "my_tag"
 
 
-def test_scalar_repr():
-    pep_builder = pep.PEPBuilder()
-    with pep_builder.make_context("test"):
-        s1 = scalar.Scalar(is_basis=True, tags=["s1"])
-        print(s1)  # it should be fine without tag
-        s1.add_tag("my_tag")
-        assert str(s1) == "my_tag"
+def test_scalar_repr(pep_context: pc.PEPContext):
+    s1 = scalar.Scalar(is_basis=True, tags=["s1"])
+    print(s1)  # it should be fine without tag
+    s1.add_tag("my_tag")
+    assert str(s1) == "my_tag"
 
 
-def test_scalar_in_a_list():
-    pep_builder = pep.PEPBuilder()
-    with pep_builder.make_context("test"):
-        s1 = scalar.Scalar(is_basis=True, eval_expression=None)
-        s2 = scalar.Scalar(is_basis=True, eval_expression=None)
-        s3 = scalar.Scalar(is_basis=True, eval_expression=None)
+def test_scalar_in_a_list(pep_context: pc.PEPContext):
+    s1 = scalar.Scalar(is_basis=True, eval_expression=None)
+    s2 = scalar.Scalar(is_basis=True, eval_expression=None)
+    s3 = scalar.Scalar(is_basis=True, eval_expression=None)
     assert s1 in [s1, s2]
     assert s3 not in [s1, s2]
 
 
-def test_expression_manager_on_basis_scalar():
-    pep_builder = pep.PEPBuilder()
-    with pep_builder.make_context("test") as ctx:
-        s1 = scalar.Scalar(is_basis=True, eval_expression=None, tags=["s1"])
-        s2 = scalar.Scalar(is_basis=True, eval_expression=None, tags=["s2"])
-        pm = exm.ExpressionManager(ctx)
+def test_expression_manager_on_basis_scalar(pep_context: pc.PEPContext):
+    s1 = scalar.Scalar(is_basis=True, eval_expression=None, tags=["s1"])
+    s2 = scalar.Scalar(is_basis=True, eval_expression=None, tags=["s2"])
+    pm = exm.ExpressionManager(pep_context)
 
-        np.testing.assert_allclose(pm.eval_scalar(s1).vector, np.array([1, 0]))
-        np.testing.assert_allclose(pm.eval_scalar(s2).vector, np.array([0, 1]))
+    np.testing.assert_allclose(pm.eval_scalar(s1).vector, np.array([1, 0]))
+    np.testing.assert_allclose(pm.eval_scalar(s2).vector, np.array([0, 1]))
 
-        s3 = scalar.Scalar(is_basis=True, eval_expression=None, tags=["s3"])  # noqa: F841
-        pm = exm.ExpressionManager(ctx)
+    s3 = scalar.Scalar(is_basis=True, eval_expression=None, tags=["s3"])  # noqa: F841
+    pm = exm.ExpressionManager(pep_context)
 
-        np.testing.assert_allclose(pm.eval_scalar(s1).vector, np.array([1, 0, 0]))
-        np.testing.assert_allclose(pm.eval_scalar(s2).vector, np.array([0, 1, 0]))
+    np.testing.assert_allclose(pm.eval_scalar(s1).vector, np.array([1, 0, 0]))
+    np.testing.assert_allclose(pm.eval_scalar(s2).vector, np.array([0, 1, 0]))
 
 
-def test_expression_manager_eval_scalar():
-    pep_builder = pep.PEPBuilder()
-    with pep_builder.make_context("test") as ctx:
-        s1 = scalar.Scalar(is_basis=True, tags=["s1"])
-        s2 = scalar.Scalar(is_basis=True, tags=["s2"])
-        s3 = 2 * s1 + s2 / 4 + 5
-        s4 = s3 + s1
-        s5 = s4 + 5
+def test_expression_manager_eval_scalar(pep_context: pc.PEPContext):
+    s1 = scalar.Scalar(is_basis=True, tags=["s1"])
+    s2 = scalar.Scalar(is_basis=True, tags=["s2"])
+    s3 = 2 * s1 + s2 / 4 + 5
+    s4 = s3 + s1
+    s5 = s4 + 5
 
-        p1 = point.Point(is_basis=True, tags=["p1"])
-        p2 = point.Point(is_basis=True, tags=["p2"])
-        s6 = p1 * p2
+    p1 = point.Point(is_basis=True, tags=["p1"])
+    p2 = point.Point(is_basis=True, tags=["p2"])
+    s6 = p1 * p2
 
-        p3 = point.Point(is_basis=True, tags=["p3"])
-        p4 = point.Point(is_basis=True, tags=["p4"])
-        s7 = 5 * p3 * p4
+    p3 = point.Point(is_basis=True, tags=["p3"])
+    p4 = point.Point(is_basis=True, tags=["p4"])
+    s7 = 5 * p3 * p4
 
-        s8 = s6 + s7
+    s8 = s6 + s7
 
-        pm = exm.ExpressionManager(ctx)
+    pm = exm.ExpressionManager(pep_context)
 
     np.testing.assert_allclose(pm.eval_scalar(s3).vector, np.array([2, 0.25]))
     np.testing.assert_allclose(pm.eval_scalar(s3).constant, 5)
@@ -214,37 +207,16 @@ def test_expression_manager_eval_scalar():
     )
 
 
-def test_constraint():
-    pep_builder = pep.PEPBuilder()
-    with pep_builder.make_context("test") as ctx:
-        s1 = scalar.Scalar(is_basis=True, tags=["s1"])
-        s2 = scalar.Scalar(is_basis=True, tags=["s2"])
-        s3 = 2 * s1 + s2 / 4 + 5
-
-        c1 = s3.le(5, name="c1")
-        c2 = s3.lt(5, name="c2")
-        c3 = s3.ge(5, name="c3")
-        c4 = s3.gt(5, name="c4")
-        c5 = s3.eq(5, name="c5")
-
-        pm = exm.ExpressionManager(ctx)
-
-    np.testing.assert_allclose(pm.eval_scalar(c1.scalar).vector, np.array([2, 0.25]))
-    np.testing.assert_allclose(pm.eval_scalar(c1.scalar).constant, 0)
-    assert c1.comparator == utils.Comparator.LT
-
-    np.testing.assert_allclose(pm.eval_scalar(c2.scalar).vector, np.array([2, 0.25]))
-    np.testing.assert_allclose(pm.eval_scalar(c2.scalar).constant, 0)
-    assert c2.comparator == utils.Comparator.LT
-
-    np.testing.assert_allclose(pm.eval_scalar(c3.scalar).vector, np.array([2, 0.25]))
-    np.testing.assert_allclose(pm.eval_scalar(c3.scalar).constant, 0)
-    assert c3.comparator == utils.Comparator.GT
+def test_zero_scalar(pep_context):
+    _ = scalar.Scalar(is_basis=True, tags=["s1"])
+    _ = point.Point(is_basis=True, tags=["p1"])
+    s0 = scalar.Scalar.zero()
 
-    np.testing.assert_allclose(pm.eval_scalar(c4.scalar).vector, np.array([2, 0.25]))
-    np.testing.assert_allclose(pm.eval_scalar(c4.scalar).constant, 0)
-    assert c4.comparator == utils.Comparator.GT
+    pm = exm.ExpressionManager(pep_context)
+    np.testing.assert_allclose(pm.eval_scalar(s0).vector, np.array([0]))
+    np.testing.assert_allclose(pm.eval_scalar(s0).matrix, np.array([[0]]))
 
-    np.testing.assert_allclose(pm.eval_scalar(c5.scalar).vector, np.array([2, 0.25]))
-    np.testing.assert_allclose(pm.eval_scalar(c5.scalar).constant, 0)
-    assert c5.comparator == utils.Comparator.EQ
+    _ = point.Point(is_basis=True, tags=["p2"])
+    pm = exm.ExpressionManager(pep_context)
+    np.testing.assert_allclose(pm.eval_scalar(s0).vector, np.array([0]))
+    np.testing.assert_allclose(pm.eval_scalar(s0).matrix, np.array([[0, 0], [0, 0]]))

pepflow/solver.py

@@ -46,6 +46,14 @@ def evaled_scalar_to_cvx_express(
 
 
 class DualVariableManager:
+    """
+    A class to access the dual variables associated with the constraints
+    of the Primal PEP. Should not be instantiated directly. Automatically
+    generated as a member variable of the :class:`PEPResult` object
+    returned when calling :py:func:`pepflow.PEPBuilder.solve_primal`.
+    """
+
+    # It is used in the primal PEP to get the dual variables.
     def __init__(self, named_constraints: list[tuple[str, cvxpy.Constraint]]):
         self.named_constraints = {}
         for name, c in named_constraints:
@@ -63,6 +71,19 @@ class DualVariableManager:
         self.named_constraints[name] = constraint
 
     def dual_value(self, name: str) -> float | None:
+        """
+        Given the name of a :class:`Constraint` object that represents a
+        constraint in Primal PEP, return the value of its corresponding
+        dual variable.
+
+        Args:
+            name (str): The name of the :class:`Constraint` object whose
+                associated dual variable we want to retrieve.
+
+        Returns:
+            float: The value of the dual variable corresponding to the
+            :class:`Constraint` object associated with the `name` argument.
+        """
         if name not in self.named_constraints:
             return None  # Is this good choice?
         dual_value = self.named_constraints[name].dual_value
@@ -71,7 +92,65 @@ class DualVariableManager:
         return dual_value
 
 
-class CVXSolver:
+class PrimalVariableManager:
+    """
+    A class to access the primal variables of the Dual PEP. The primal
+    variables of the Dual PEP are the dual variables associated with the
+    constraints of the Primal PEP. Should not be instantiated directly.
+    Automatically generated as a member variable of the :class:`PEPResult`
+    object returned when calling :py:func:`pepflow.PEPBuilder.solve_dual`.
+    """
+
+    # It is used in the dual PEP to get the primal variables.
+    def __init__(self, named_variables: list[tuple[str, cvxpy.Variable]]):
+        self.named_variables = {}
+        for name, v in named_variables:
+            self.add_variable(name, v)
+
+    def cvx_variables(self) -> list[cvxpy.Variable]:
+        return list(self.named_variables.values())
+
+    def clear(self) -> None:
+        self.named_variables.clear()
+
+    def add_variable(self, name: str, variable: cvxpy.Variable) -> None:
+        if name in self.named_variables:
+            raise KeyError(f"There is already a variable named {name}")
+        self.named_variables[name] = variable
+
+    def get_variable(self, name: str) -> cvxpy.Variable:
+        if name not in self.named_variables:
+            raise KeyError(f"Cannot find a variable named {name}")
+        return self.named_variables[name]
+
+    def primal_value(self, name: str) -> float | None:
+        """
+        The primal variables of the Dual PEP are the dual variables associated
+        with the constraints of the Primal PEP.
+
+        Given the name of a :class:`Constraint` object that represents a
+        constraint in the Primal PEP, return the value of the corresponding
+        primal variable of the Dual PEP.
+
+        Args:
+            name (str): The name of the :class:`Constraint` object whose
+                corresponding primal variable of the Dual PEP we want to
+                retrieve.
+
+        Returns:
+            float: The value of the primal variable of the Dual PEP
+            corresponding to the :class:`Constraint` object associated with
+            the `name` argument.
+        """
+        if name not in self.named_variables:
+            return None  # Is this good choice?
+        primal_value = self.named_variables[name].value
+        if primal_value is None:
+            return None
+        return primal_value
+
+
+class CVXPrimalSolver:
     def __init__(
         self,
         perf_metric: sc.Scalar,
@@ -83,8 +162,10 @@ class CVXSolver:
         self.dual_var_manager = DualVariableManager([])
         self.context = context
 
-    def build_problem(self) -> cvxpy.Problem:
-        em = exm.ExpressionManager(self.context)
+    def build_problem(
+        self, resolve_parameters: dict[str, utils.NUMERICAL_TYPE] | None = None
+    ) -> cvxpy.Problem:
+        em = exm.ExpressionManager(self.context, resolve_parameters=resolve_parameters)
         f_var = cvxpy.Variable(em._num_basis_scalars)
         g_var = cvxpy.Variable(
             (em._num_basis_points, em._num_basis_points), symmetric=True
@@ -121,3 +202,89 @@ class CVXSolver:
         problem = self.build_problem()
         result = problem.solve(**kwargs)
         return result
+
+
+class CVXDualSolver:
+    def __init__(
+        self,
+        perf_metric: sc.Scalar,
+        constraints: list[ctr.Constraint],
+        context: pc.PEPContext,
+    ):
+        self.perf_metric = perf_metric
+        self.constraints = constraints
+        self.primal_var_manager = PrimalVariableManager([])
+        self.context = context
+
+    def build_problem(
+        self, resolve_parameters: dict[str, utils.NUMERICAL_TYPE] | None = None
+    ) -> cvxpy.Problem:
+        # The primal problem is always the following form:
+        #
+        # max_{F, G}:  <perf.vec, F> + Tr(G perf.Mat) + perf.const
+        # s.t.         <constraint.vec, F> + Tr(G constraint.Mat) + constraint.const <= 0
+        #              G >= 0
+        # Caveat: we use max instead of min in primal problem.
+        #
+        # Dual prob = min_{l, S} [max_{F, G} (<perf.vec, F> + Tr(G perf.Mat) - l * (constraint) + Tr(S*G))]
+        # Note the sign above.
+        # Becaus F is unbounded and the Lagrangian w.r.t. F is linear, the coefficients of F must be 0.
+        # Similarly, the Lagrangian w.r.t. G is linear and G is PSD, the coefficients of G must << 0.
+        dual_constraints = []
+        lambd_constraints = []
+        em = exm.ExpressionManager(self.context, resolve_parameters=resolve_parameters)
+        # The one corresponding to G >= 0
+        S = cvxpy.Variable((em._num_basis_points, em._num_basis_points), PSD=True)
+        evaled_perf_metric_scalar = em.eval_scalar(self.perf_metric)
+
+        extra_constraints = []
+        obj = evaled_perf_metric_scalar.constant
+        F_coef_vec = 0
+        G_coef_mat = 0
+        # l * (Tr(G*eval_s.Matrix) + <F, eval_s.vec> + eval_s.const)
+        for c in self.constraints:
+            lambd = cvxpy.Variable()
+            self.primal_var_manager.add_variable(c.name, lambd)
+            evaled_scalar = em.eval_scalar(c.scalar)
+            if c.comparator == utils.Comparator.GT:
+                sign = 1
+                lambd_constraints.append(lambd >= 0)
+            elif c.comparator == utils.Comparator.LT:
+                sign = -1  # We flip f(x) <=0  into -f(x) >= 0
+                lambd_constraints.append(lambd >= 0)
+            elif c.comparator == utils.Comparator.EQ:
+                sign = 1
+            else:
+                raise RuntimeError(
+                    f"Unknown comparator in constraint {c.anme}: get {c.comparator=}"
+                )
+            G_coef_mat += sign * lambd * evaled_scalar.matrix
+            F_coef_vec += sign * lambd * evaled_scalar.vector
+            obj += sign * lambd * evaled_scalar.constant
+
+            # We can add extra constraints to directly manipulate the primal variable in dual PEP.
+            for comparator, val in c.associated_dual_var_constraints:
+                if c.comparator == utils.Comparator.GT:
+                    extra_constraints.append(lambd >= val)
+                elif c.comparator == utils.Comparator.LT:
+                    extra_constraints.append(lambd <= val)
+                elif c.comparator == utils.Comparator.EQ:
+                    extra_constraints.append(lambd == val)
+                else:
+                    raise RuntimeError(
+                        f"Unknown comparator in constraint {c.anme} associated dual one:"
+                        f"get {c.comparator=}"
+                    )
+
+        dual_constraints.append(F_coef_vec + evaled_perf_metric_scalar.vector == 0)
+        dual_constraints.append(S + evaled_perf_metric_scalar.matrix + G_coef_mat == 0)
+
+        return cvxpy.Problem(
+            cvxpy.Minimize(obj),
+            dual_constraints + lambd_constraints + extra_constraints,
+        )
+
+    def solve(self, **kwargs):
+        problem = self.build_problem()
+        result = problem.solve(**kwargs)
+        return result

pepflow/solver_test.py

@@ -32,7 +32,7 @@ def test_cvx_solver_case1():
         s2 = -(1 + p1 * p1)
         constraints = [(p1 * p1).gt(1, name="x^2 >= 1"), s1.gt(0, name="s1 > 0")]
 
-    solver = ps.CVXSolver(
+    solver = ps.CVXPrimalSolver(
         perf_metric=s2,
         constraints=constraints,
         context=pep_builder.get_context("test"),
@@ -55,7 +55,7 @@ def test_cvx_solver_case2():
         s2 = -p1 * p1 + 2
         constraints = [(p1 * p1).lt(1, name="x^2 <= 1"), s1.gt(0, name="s1 > 0")]
 
-    solver = ps.CVXSolver(
+    solver = ps.CVXPrimalSolver(
         perf_metric=s2,
         constraints=constraints,
         context=pep_builder.get_context("test"),
@@ -68,3 +68,51 @@ def test_cvx_solver_case2():
 
     assert np.isclose(solver.dual_var_manager.dual_value("x^2 <= 1"), 0)
     assert solver.dual_var_manager.dual_value("s1 > 0") == 0
+
+
+def test_cvx_dual_solver_case1():
+    pep_builder = pep.PEPBuilder()
+    with pep_builder.make_context("test"):
+        p1 = pp.Point(is_basis=True, tags=["p1"])
+        s1 = pp.Scalar(is_basis=True, tags=["s1"])
+        s2 = -(1 + p1 * p1)
+        constraints = [(p1 * p1).gt(1, name="x^2 >= 1"), s1.gt(0, name="s1 > 0")]
+
+    dual_solver = ps.CVXDualSolver(
+        perf_metric=s2,
+        constraints=constraints,
+        context=pep_builder.get_context("test"),
+    )
+    problem = dual_solver.build_problem()
+    result = problem.solve()
+    assert abs(-result - 2) < 1e-6
+
+    assert np.isclose(dual_solver.primal_var_manager.primal_value("x^2 >= 1"), 1)
+    assert np.isclose(dual_solver.primal_var_manager.primal_value("s1 > 0"), 0)
+
+
+def test_cvx_dual_solver_case2():
+    pep_builder = pep.PEPBuilder()
+    with pep_builder.make_context("test"):
+        p1 = pp.Point(is_basis=True, tags=["p1"])
+        s1 = pp.Scalar(is_basis=True, tags=["s1"])
+        s2 = -p1 * p1 + 2
+        constraints = [(p1 * p1).lt(1, name="x^2 <= 1"), s1.gt(0, name="s1 > 0")]
+
+    dual_solver = ps.CVXDualSolver(
+        perf_metric=s2,
+        constraints=constraints,
+        context=pep_builder.get_context("test"),
+    )
+
+    # It is a simple `min_x x^2-2; s.t. x^2 <= 1` problem.
+    problem = dual_solver.build_problem()
+    result = problem.solve()
+    assert abs(-result + 2) < 1e-6
+
+    assert np.isclose(
+        dual_solver.primal_var_manager.primal_value("x^2 <= 1"), 0, atol=1e-7
+    )
+    assert np.isclose(
+        dual_solver.primal_var_manager.primal_value("s1 > 0"), 0, atol=1e-7
+    )

pepflow/utils.py

@@ -24,6 +24,7 @@ import numbers
 from typing import TYPE_CHECKING, Any
 
 import numpy as np
+import sympy as sp
 
 if TYPE_CHECKING:
     from pepflow.function import Function
@@ -31,13 +32,17 @@ if TYPE_CHECKING:
     from pepflow.scalar import Scalar
 
 
-def SOP(v, w):
+NUMERICAL_TYPE = numbers.Number | sp.Rational
+
+
+def SOP(v, w, sympy_mode: bool = False) -> np.ndarray:
     """Symmetric Outer Product."""
-    return 1 / 2 * (np.outer(v, w) + np.outer(w, v))
+    coef = sp.S(1) / 2 if sympy_mode else 1 / 2
+    return coef * (np.outer(v, w) + np.outer(w, v))
 
 
-def SOP_self(v):
-    return SOP(v, v)
+def SOP_self(v, sympy_mode: bool = False) -> np.ndarray:
+    return SOP(v, v, sympy_mode=sympy_mode)
 
 
 class Op(enum.Enum):
@@ -54,12 +59,39 @@ class Comparator(enum.Enum):
 
 
 def is_numerical(val: Any) -> bool:
-    return isinstance(val, numbers.Number)
+    return isinstance(val, numbers.Number) or isinstance(val, sp.Rational)
+
+
+def is_numerical_or_parameter(val: Any) -> bool:
+    from pepflow import parameter as param
+
+    return is_numerical(val) or isinstance(val, param.Parameter)
+
+
+def numerical_str(val: Any) -> str:
+    from pepflow import parameter as param
+
+    if not is_numerical_or_parameter(val):
+        raise ValueError(
+            "Cannot call numerical_str for {val} since it is not numerical."
+        )
+    if isinstance(val, param.Parameter):
+        return str(val)
+    return str(val) if isinstance(val, sp.Rational) else f"{val:.4g}"
 
 
 def parenthesize_tag(val: Point | Scalar | Function) -> str:
     tmp_tag = val.tag
     if not val.is_basis:
-        if val.eval_expression.op == Op.ADD or val.eval_expression.op == Op.SUB:
-            tmp_tag = f"({val.tag})"
+        if op := getattr(val.eval_expression, "op", None):
+            if op in (Op.ADD, Op.SUB):
+                tmp_tag = f"({val.tag})"
     return tmp_tag
+
+
+def str_to_latex(s: str) -> str:
+    """Convert string into latex style."""
+    s = s.replace("star", r"\star")
+    s = s.replace("gradient_", r"\nabla ")
+    s = s.replace("|", r"\|")
+    return rf"$\displaystyle {s}$"