pepflow 0.1.0__py3-none-any.whl

pepflow/point_test.py

@@ -0,0 +1,329 @@
+import time
+
+import numpy as np
+
+from pepflow import expression_manager as exm
+from pepflow import function as fc
+from pepflow import pep as pep
+from pepflow import point, scalar, utils
+
+
+def test_point_hash_different():
+    pep_builder = pep.PEPBuilder()
+    with pep_builder.make_context("test"):
+        p1 = point.Point(is_basis=True, eval_expression=None)
+        p2 = point.Point(is_basis=True, eval_expression=None)
+    assert p1.uid != p2.uid
+
+
+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)
+    assert s1.uid != s2.uid
+
+
+def test_point_tag():
+    pep_builder = pep.PEPBuilder()
+    with pep_builder.make_context("test"):
+        p1 = point.Point(is_basis=True, eval_expression=None)
+        p1.add_tag(tag="my_tag")
+    assert p1.tags == ["my_tag"]
+
+
+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")
+    assert s1.tags == ["my_tag"]
+
+
+def test_point_in_a_list():
+    pep_builder = pep.PEPBuilder()
+    with pep_builder.make_context("test"):
+        p1 = point.Point(is_basis=True, eval_expression=None)
+        p2 = point.Point(is_basis=True, eval_expression=None)
+        p3 = point.Point(is_basis=True, eval_expression=None)
+    assert p1 in [p1, p2]
+    assert p3 not in [p1, p2]
+
+
+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)
+    assert s1 in [s1, s2]
+    assert s3 not in [s1, s2]
+
+
+def test_expression_manager_on_basis_point():
+    pep_builder = pep.PEPBuilder()
+    with pep_builder.make_context("test") as ctx:
+        p1 = point.Point(is_basis=True, eval_expression=None, tags=["p1"])
+        p2 = point.Point(is_basis=True, eval_expression=None, tags=["p2"])
+        pm = exm.ExpressionManager(ctx)
+
+        np.testing.assert_allclose(pm.eval_point(p1).vector, np.array([1, 0]))
+        np.testing.assert_allclose(pm.eval_point(p2).vector, np.array([0, 1]))
+
+        p3 = point.Point(is_basis=True, eval_expression=None, tags=["p3"])  # noqa: F841
+        pm = exm.ExpressionManager(ctx)
+
+    np.testing.assert_allclose(pm.eval_point(p1).vector, np.array([1, 0, 0]))
+    np.testing.assert_allclose(pm.eval_point(p2).vector, np.array([0, 1, 0]))
+
+
+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)
+
+        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)
+
+        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_point():
+    pep_builder = pep.PEPBuilder()
+    with pep_builder.make_context("test") as ctx:
+        p1 = point.Point(is_basis=True)
+        p2 = point.Point(is_basis=True)
+        p3 = 2 * p1 + p2 / 4
+        p4 = p3 + p1
+
+        pm = exm.ExpressionManager(ctx)
+    np.testing.assert_allclose(pm.eval_point(p3).vector, np.array([2, 0.25]))
+    np.testing.assert_allclose(pm.eval_point(p4).vector, np.array([3, 0.25]))
+
+
+def test_expression_manager_eval_scalar():
+    pep_builder = pep.PEPBuilder()
+    with pep_builder.make_context("test") as ctx:
+        s1 = scalar.Scalar(is_basis=True)
+        s2 = scalar.Scalar(is_basis=True)
+        s3 = 2 * s1 + s2 / 4 + 5
+        s4 = s3 + s1
+        s5 = s4 + 5
+
+        p1 = point.Point(is_basis=True)
+        p2 = point.Point(is_basis=True)
+        s6 = p1 * p2
+
+        p3 = point.Point(is_basis=True)
+        p4 = point.Point(is_basis=True)
+        s7 = 5 * p3 * p4
+
+        s8 = s6 + s7
+
+        pm = exm.ExpressionManager(ctx)
+
+    np.testing.assert_allclose(pm.eval_scalar(s3).vector, np.array([2, 0.25]))
+    np.testing.assert_allclose(pm.eval_scalar(s3).constant, 5)
+    np.testing.assert_allclose(pm.eval_scalar(s4).vector, np.array([3, 0.25]))
+    np.testing.assert_allclose(pm.eval_scalar(s5).vector, np.array([3, 0.25]))
+    np.testing.assert_allclose(pm.eval_scalar(s5).constant, 10)
+
+    np.testing.assert_allclose(pm.eval_point(p1).vector, np.array([1, 0, 0, 0]))
+    np.testing.assert_allclose(pm.eval_point(p2).vector, np.array([0, 1, 0, 0]))
+    np.testing.assert_allclose(pm.eval_point(p3).vector, np.array([0, 0, 1, 0]))
+    np.testing.assert_allclose(pm.eval_point(p4).vector, np.array([0, 0, 0, 1]))
+
+    np.testing.assert_allclose(
+        pm.eval_scalar(s6).matrix,
+        np.array(
+            [
+                [0.0, 0.5, 0.0, 0.0],
+                [0.5, 0.0, 0.0, 0.0],
+                [0.0, 0.0, 0.0, 0.0],
+                [0.0, 0.0, 0.0, 0.0],
+            ]
+        ),
+    )
+    np.testing.assert_allclose(
+        pm.eval_scalar(s7).matrix,
+        np.array(
+            [
+                [0.0, 0.0, 0.0, 0.0],
+                [0.0, 0.0, 0.0, 0.0],
+                [0.0, 0.0, 0.0, 2.5],
+                [0.0, 0.0, 2.5, 0.0],
+            ]
+        ),
+    )
+
+    np.testing.assert_allclose(
+        pm.eval_scalar(s8).matrix,
+        np.array(
+            [
+                [0.0, 0.5, 0.0, 0.0],
+                [0.5, 0.0, 0.0, 0.0],
+                [0.0, 0.0, 0.0, 2.5],
+                [0.0, 0.0, 2.5, 0.0],
+            ]
+        ),
+    )
+
+
+def test_constraint():
+    pep_builder = pep.PEPBuilder()
+    with pep_builder.make_context("test") as ctx:
+        s1 = scalar.Scalar(is_basis=True)
+        s2 = scalar.Scalar(is_basis=True)
+        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
+
+    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
+
+    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
+
+
+def test_expression_manager_eval_point_large_scale():
+    pep_builder = pep.PEPBuilder()
+    with pep_builder.make_context("test") as ctx:
+        all_basis = [point.Point(is_basis=True) for _ in range(100)]
+        p = all_basis[0]
+        for i in range(len(all_basis)):
+            for j in range(i + 1, len(all_basis)):
+                p += all_basis[i] * 2 + all_basis[j]
+        pm = exm.ExpressionManager(ctx)
+        t = time.time()
+        for pp in ctx.points:
+            pm.eval_point(pp)
+
+        assert (time.time() - t) < 0.1
+
+
+def test_function_generate_triplet():
+    pep_builder = pep.PEPBuilder()
+    with pep_builder.make_context("test") as ctx:
+        f = fc.Function(is_basis=True, reuse_gradient=True)
+        g = fc.Function(is_basis=True, reuse_gradient=True)
+        h = 5 * f + 5 * g
+
+        f1 = fc.Function(is_basis=True, reuse_gradient=False)
+        g1 = fc.Function(is_basis=True, reuse_gradient=False)
+        h1 = 5 * f1 + 5 * g1
+
+        p1 = point.Point(is_basis=True)
+        _, func_value, grad = h.generate_triplet(p1)
+        _, func_value_1, grad_1 = h.generate_triplet(p1)
+
+        _, func_value_2, grad_2 = h1.generate_triplet(p1)
+        _, func_value_3, grad_3 = h1.generate_triplet(p1)
+
+        pm = exm.ExpressionManager(ctx)
+
+    np.testing.assert_allclose(
+        pm.eval_point(p1).vector, np.array([1, 0, 0, 0, 0, 0, 0])
+    )
+
+    np.testing.assert_allclose(
+        pm.eval_point(grad).vector, np.array([0, 5, 5, 0, 0, 0, 0])
+    )
+    np.testing.assert_allclose(
+        pm.eval_scalar(func_value).vector, np.array([5, 5, 0, 0])
+    )
+
+    np.testing.assert_allclose(
+        pm.eval_point(grad_1).vector, np.array([0, 5, 5, 0, 0, 0, 0])
+    )
+    np.testing.assert_allclose(
+        pm.eval_scalar(func_value_1).vector, np.array([5, 5, 0, 0])
+    )
+
+    np.testing.assert_allclose(
+        pm.eval_point(grad_2).vector, np.array([0, 0, 0, 5, 5, 0, 0])
+    )
+    np.testing.assert_allclose(
+        pm.eval_scalar(func_value_2).vector, np.array([0, 0, 5, 5])
+    )
+
+    np.testing.assert_allclose(
+        pm.eval_point(grad_3).vector, np.array([0, 0, 0, 0, 0, 5, 5])
+    )
+    np.testing.assert_allclose(
+        pm.eval_scalar(func_value_3).vector, np.array([0, 0, 5, 5])
+    )
+
+
+def test_function_add_stationary_point():
+    pep_builder = pep.PEPBuilder()
+    with pep_builder.make_context("test") as ctx:
+        f = fc.Function(is_basis=True, reuse_gradient=True)
+        x_opt = f.add_stationary_point()
+
+        pm = exm.ExpressionManager(ctx)
+
+    np.testing.assert_allclose(pm.eval_point(x_opt).vector, np.array([1, 0]))
+
+    np.testing.assert_allclose(
+        pm.eval_scalar(f.constraints[0].scalar).matrix, [[0, 0], [0, 1]]
+    )
+    np.testing.assert_allclose(pm.eval_scalar(f.constraints[0].scalar).vector, [0])
+    np.testing.assert_allclose(pm.eval_scalar(f.constraints[0].scalar).constant, 0)
+    assert f.constraints[0].comparator == utils.Comparator.EQ
+
+
+def test_smooth_interpolability_constraints():
+    pep_builder = pep.PEPBuilder()
+    with pep_builder.make_context("test") as ctx:
+        f = fc.SmoothConvexFunction(L=1)
+        _ = f.add_stationary_point()
+
+        x_0 = point.Point(is_basis=True)
+        _, _, _ = f.generate_triplet(x_0)
+
+        all_interpolation_constraints = f.get_interpolation_constraints()
+
+        pm = exm.ExpressionManager(ctx)
+
+    np.testing.assert_allclose(
+        pm.eval_scalar(all_interpolation_constraints[1].scalar).vector, [1, -1]
+    )
+    np.testing.assert_allclose(
+        pm.eval_scalar(all_interpolation_constraints[1].scalar).matrix,
+        [
+            [0.0, -0.5, 0.0, 0.0],
+            [-0.5, 0.5, 0.5, -0.5],
+            [0.0, 0.5, 0.0, 0.0],
+            [0.0, -0.5, 0.0, 0.5],
+        ],
+    )
+
+    np.testing.assert_allclose(
+        pm.eval_scalar(all_interpolation_constraints[1].scalar).constant, 0
+    )

pepflow/scalar.py

@@ -0,0 +1,219 @@
+from __future__ import annotations
+
+import uuid
+from typing import TYPE_CHECKING, Any
+
+import attrs
+import numpy as np
+
+from pepflow import constraint as ctr
+from pepflow import pep_context as pc
+from pepflow import utils
+
+if TYPE_CHECKING:
+    from pepflow.point import Point
+
+
+def is_numerical_or_scalar(val: Any) -> bool:
+    return utils.is_numerical(val) or isinstance(val, Scalar)
+
+
+def is_numerical_or_evaluatedscalar(val: Any) -> bool:
+    return utils.is_numerical(val) or isinstance(val, EvaluatedScalar)
+
+
+@attrs.frozen
+class EvalExpressionScalar:
+    op: utils.Op
+    left_scalar: Point | Scalar | float
+    right_scalar: Point | Scalar | float
+
+
+@attrs.frozen
+class EvaluatedScalar:
+    vector: np.array
+    matrix: np.array
+    constant: float
+
+    def __add__(self, other):
+        assert is_numerical_or_evaluatedscalar(other)
+        if utils.is_numerical(other):
+            return EvaluatedScalar(
+                vector=self.vector, matrix=self.matrix, constant=self.constant + other
+            )
+        else:
+            return EvaluatedScalar(
+                vector=self.vector + other.vector,
+                matrix=self.matrix + other.matrix,
+                constant=self.constant + other.constant,
+            )
+
+    def __radd__(self, other):
+        assert is_numerical_or_evaluatedscalar(other)
+        if utils.is_numerical(other):
+            return EvaluatedScalar(
+                vector=self.vector, matrix=self.matrix, constant=other + self.constant
+            )
+        else:
+            return EvaluatedScalar(
+                vector=other.vector + self.vector,
+                matrix=other.matrix + self.matrix,
+                constant=other.constant + self.constant,
+            )
+
+    def __sub__(self, other):
+        assert is_numerical_or_evaluatedscalar(other)
+        if utils.is_numerical(other):
+            return EvaluatedScalar(
+                vector=self.vector, matrix=self.matrix, constant=self.constant - other
+            )
+        else:
+            return EvaluatedScalar(
+                vector=self.vector - other.vector,
+                matrix=self.matrix - other.matrix,
+                constant=self.constant - other.constant,
+            )
+
+    def __rsub__(self, other):
+        assert is_numerical_or_evaluatedscalar(other)
+        if utils.is_numerical(other):
+            return EvaluatedScalar(
+                vector=-self.vector, matrix=-self.matrix, constant=other - self.constant
+            )
+        else:
+            return EvaluatedScalar(
+                vector=other.vector - self.vector,
+                matrix=other.matrix - self.matrix,
+                constant=other.constant - self.constant,
+            )
+
+    def __mul__(self, other):
+        assert utils.is_numerical(other)
+        return EvaluatedScalar(
+            vector=self.vector * other,
+            matrix=self.matrix * other,
+            constant=self.constant * other,
+        )
+
+    def __rmul__(self, other):
+        assert utils.is_numerical(other)
+        return EvaluatedScalar(
+            vector=other * self.vector,
+            matrix=other * self.matrix,
+            constant=other * self.constant,
+        )
+
+    def __neg__(self):
+        return self.__rmul__(other=-1)
+
+    def __truediv__(self, other):
+        assert utils.is_numerical(other)
+        return EvaluatedScalar(
+            vector=self.vector / other,
+            matrix=self.matrix / other,
+            constant=self.constant / other,
+        )
+
+
+@attrs.frozen
+class Scalar:
+    # If true, the scalar is the basis for the evaluations of F
+    is_basis: bool
+
+    # Not sure on this yet
+    eval_expression: EvalExpressionScalar | None = None
+
+    # Human tagged value for the scalar
+    tags: list[str] = attrs.field(factory=list)
+
+    # Generate an automatic id
+    uid: uuid.UUID = attrs.field(factory=uuid.uuid4, init=False)
+
+    def __attrs_post_init__(self):
+        if self.is_basis:
+            assert self.eval_expression is None
+        else:
+            assert self.eval_expression is not None
+
+        pep_context = pc.get_current_context()
+        if pep_context is None:
+            raise RuntimeError("Did you forget to create a context?")
+        pep_context.add_scalar(self)
+
+    def add_tag(self, tag: str):
+        self.tags.append(tag)
+
+    def __add__(self, other):
+        assert is_numerical_or_scalar(other)
+        return Scalar(
+            is_basis=False,
+            eval_expression=EvalExpressionScalar(utils.Op.ADD, self, other),
+        )
+
+    def __radd__(self, other):
+        assert is_numerical_or_scalar(other)
+        return Scalar(
+            is_basis=False,
+            eval_expression=EvalExpressionScalar(utils.Op.ADD, other, self),
+        )
+
+    def __sub__(self, other):
+        assert is_numerical_or_scalar(other)
+        return Scalar(
+            is_basis=False,
+            eval_expression=EvalExpressionScalar(utils.Op.SUB, self, other),
+        )
+
+    def __rsub__(self, other):
+        assert is_numerical_or_scalar(other)
+        return Scalar(
+            is_basis=False,
+            eval_expression=EvalExpressionScalar(utils.Op.SUB, other, self),
+        )
+
+    def __mul__(self, other):
+        assert utils.is_numerical(other)
+        return Scalar(
+            is_basis=False,
+            eval_expression=EvalExpressionScalar(utils.Op.MUL, self, other),
+        )
+
+    def __rmul__(self, other):
+        assert utils.is_numerical(other)
+        return Scalar(
+            is_basis=False,
+            eval_expression=EvalExpressionScalar(utils.Op.MUL, other, self),
+        )
+
+    def __neg__(self):
+        return self.__rmul__(other=-1)
+
+    def __truediv__(self, other):
+        assert utils.is_numerical(other)
+        return Scalar(
+            is_basis=False,
+            eval_expression=EvalExpressionScalar(utils.Op.DIV, self, other),
+        )
+
+    def __hash__(self):
+        return hash(self.uid)
+
+    def __eq__(self, other):
+        if not isinstance(other, Scalar):
+            return NotImplemented
+        return self.uid == other.uid
+
+    def le(self, other, name: str) -> ctr.Constraint:
+        return ctr.Constraint(self - other, comparator=utils.Comparator.LT, name=name)
+
+    def lt(self, other, name: str) -> ctr.Constraint:
+        return ctr.Constraint(self - other, comparator=utils.Comparator.LT, name=name)
+
+    def ge(self, other, name: str) -> ctr.Constraint:
+        return ctr.Constraint(self - other, comparator=utils.Comparator.GT, name=name)
+
+    def gt(self, other, name: str) -> ctr.Constraint:
+        return ctr.Constraint(self - other, comparator=utils.Comparator.GT, name=name)
+
+    def eq(self, other, name: str) -> ctr.Constraint:
+        return ctr.Constraint(self - other, comparator=utils.Comparator.EQ, name=name)

pepflow/solver.py

@@ -0,0 +1,98 @@
+import warnings
+
+import cvxpy
+
+from pepflow import constraint as ctr
+from pepflow import expression_manager as exm
+from pepflow import pep_context as pc
+from pepflow import scalar as sc
+from pepflow import utils
+
+
+def evaled_scalar_to_cvx_express(
+    eval_scalar: sc.EvaluatedScalar, vec_var: cvxpy.Variable, matrix_var: cvxpy.Variable
+) -> cvxpy.Expression:
+    return (
+        vec_var @ eval_scalar.vector
+        + cvxpy.trace(matrix_var @ eval_scalar.matrix)
+        + eval_scalar.constant
+    )
+
+
+class DualVariableManager:
+    def __init__(self, named_constraints: list[tuple[str, cvxpy.Constraint]]):
+        self.named_constraints = {}
+        for name, c in named_constraints:
+            self.add_constraint(name, c)
+
+    def cvx_constraints(self) -> list[cvxpy.Constraint]:
+        return list(self.named_constraints.values())
+
+    def clear(self) -> None:
+        self.named_constraints.clear()
+
+    def add_constraint(self, name: str, constraint: cvxpy.Constraint) -> None:
+        if name in self.named_constraints:
+            raise KeyError(f"There is already a constraint named {name}")
+        self.named_constraints[name] = constraint
+
+    def dual_value(self, name: str) -> float | None:
+        if name not in self.named_constraints:
+            raise KeyError(f"Cannot find the constraint named {name}")
+        dual_value = self.named_constraints[name].dual_value
+        if dual_value is None:
+            warnings.warn("Did you forget to solve the problem first?")
+            return None
+        return dual_value
+
+
+class CVXSolver:
+    def __init__(
+        self,
+        perf_metric: sc.Scalar,
+        constraints: list[ctr.Constraint],
+        context: pc.PEPContext,
+    ):
+        self.perf_metric = perf_metric
+        self.constraints = constraints
+        self.dual_var_manager = DualVariableManager([])
+        self.context = context
+
+    def build_problem(self) -> cvxpy.Problem:
+        em = exm.ExpressionManager(self.context)
+        f_var = cvxpy.Variable(em._num_basis_scalars)
+        g_var = cvxpy.Variable(
+            (em._num_basis_points, em._num_basis_points), symmetric=True
+        )
+
+        # Evaluate all poiints and scalars in advance to store it in cache.
+        for point in self.context.points:
+            em.eval_point(point)
+        for scalar in self.context.scalars:
+            em.eval_scalar(scalar)
+
+        self.dual_var_manager.clear()
+        self.dual_var_manager.add_constraint("PSD of Grammian Matrix", g_var >> 0)
+        for c in self.constraints:
+            exp = evaled_scalar_to_cvx_express(em.eval_scalar(c.scalar), f_var, g_var)
+            if c.comparator == utils.Comparator.GT:
+                self.dual_var_manager.add_constraint(c.name, exp >= 0)
+            elif c.comparator == utils.Comparator.LT:
+                self.dual_var_manager.add_constraint(c.name, exp <= 0)
+            elif c.comparator == utils.Comparator.EQ:
+                self.dual_var_manager.add_constraint(c.name, exp == 0)
+            else:
+                raise ValueError(f"Unknown comparator {c.comparator}")
+
+        obj = evaled_scalar_to_cvx_express(
+            em.eval_scalar(self.perf_metric), f_var, g_var
+        )
+
+        return cvxpy.Problem(
+            cvxpy.Maximize(obj), self.dual_var_manager.cvx_constraints()
+        )
+
+    def solve(self, **kwargs):
+        problem = self.build_problem()
+        result = problem.solve(**kwargs)
+        return result

pepflow/solver_test.py

@@ -0,0 +1,51 @@
+import numpy as np
+
+from pepflow import pep as pep
+from pepflow import point as pp
+from pepflow import solver as ps
+
+
+def test_cvx_solver_case1():
+    pep_builder = pep.PEPBuilder()
+    with pep_builder.make_context("test"):
+        p1 = pp.Point(is_basis=True)
+        s1 = pp.Scalar(is_basis=True)
+        s2 = -(1 + p1 * p1)
+        constraints = [(p1 * p1).gt(1, name="x^2 >= 1"), s1.gt(0, name="s1 > 0")]
+
+    solver = ps.CVXSolver(
+        perf_metric=s2,
+        constraints=constraints,
+        context=pep_builder.get_context("test"),
+    )
+
+    # It is a simple `min_x 1 + x^2; s.t. x^2 >= 1` problem.
+    problem = solver.build_problem()
+    result = problem.solve()
+    assert abs(-result - 2) < 1e-6
+
+    assert np.isclose(solver.dual_var_manager.dual_value("x^2 >= 1"), 1)
+    assert solver.dual_var_manager.dual_value("s1 > 0") == 0
+
+
+def test_cvx_solver_case2():
+    pep_builder = pep.PEPBuilder()
+    with pep_builder.make_context("test"):
+        p1 = pp.Point(is_basis=True)
+        s1 = pp.Scalar(is_basis=True)
+        s2 = -(p1 - 1) * (p1 - 2)
+        constraints = [(p1 * p1).lt(1, name="x^2 <= 1"), s1.gt(0, name="s1 > 0")]
+
+    solver = ps.CVXSolver(
+        perf_metric=s2,
+        constraints=constraints,
+        context=pep_builder.get_context("test"),
+    )
+
+    # It is a simple `min_x (x-1)(x-2); s.t. x^2 <= 1` problem.
+    problem = solver.build_problem()
+    result = problem.solve()
+    assert abs(-result) < 1e-6
+
+    assert np.isclose(solver.dual_var_manager.dual_value("x^2 <= 1"), 0)
+    assert solver.dual_var_manager.dual_value("s1 > 0") == 0