Add diffengine as DCP canonicalization backend with parameter support

cvxpy/cvxcore/python/canonInterface.py

@@ -292,6 +292,13 @@ def get_problem_matrix(linOps,
     default_canon_backend = get_default_canon_backend()
     canon_backend = default_canon_backend if not canon_backend else canon_backend
 
+    # DIFFENGINE is a reduction-layer replacement for ConeMatrixStuffing and
+    # has no lin_ops backend of its own. When code paths reach this matrix
+    # builder directly (e.g. tests that bypass the stuffing reduction), fall
+    # through to the CPP backend so the lin_ops pipeline still works.
+    if canon_backend == s.DIFFENGINE_BACKEND:
+        canon_backend = s.CPP_CANON_BACKEND
+
     if canon_backend == s.CPP_CANON_BACKEND:
         from cvxpy.cvxcore.python.cppbackend import build_matrix
         return build_matrix(id_to_col, param_to_size, param_to_col, var_length, constr_length, linOps)

cvxpy/reductions/dcp2cone/canonicalizers/perspective_canon.py

@@ -39,10 +39,22 @@ def perspective_canon(expr, args, solver_context: SolverInfo | None = None):
     prob_canon = chain.apply(aux_prob)[0]  # grab problem instance
     # get cone representation of c, A, and b for some problem.
 
-    q = prob_canon.q.toarray().flatten()[:-1]
-    d = prob_canon.q.toarray().flatten()[-1]
-    Ab = prob_canon.A.toarray().reshape((-1, len(q) + 1), order="F")
-    A, b = Ab[:, :-1], Ab[:, -1]
+    # Extract cone representation q, d, A, b.
+    # ParamConeProg stores q as sparse (n+1, n_params+1) tensor with d
+    # embedded in the last row, and A as a flattened tensor with b embedded.
+    # DiffengineConeProgram stores q, d, A, b as separate concrete arrays.
+    if hasattr(prob_canon, 'd') and not hasattr(prob_canon.q, 'toarray'):
+        # DiffengineConeProgram: concrete matrices, d stored separately.
+        q = prob_canon.q
+        d = prob_canon.d
+        A = prob_canon.A.toarray() if hasattr(prob_canon.A, 'toarray') else prob_canon.A
+        b = prob_canon.b
+    else:
+        # ParamConeProg: sparse tensor with embedded offsets.
+        q = prob_canon.q.toarray().flatten()[:-1]
+        d = prob_canon.q.toarray().flatten()[-1]
+        Ab = prob_canon.A.toarray().reshape((-1, len(q) + 1), order="F")
+        A, b = Ab[:, :-1], Ab[:, -1]
 
     # given f in epigraph form, aka epi f = \{(x,t) | f(x) \leq t\}
     # = \{(x,t) | Fx +tg + e \in K} for K a cone, the epigraph of the

cvxpy/reductions/dcp2cone/cone_matrix_stuffing.py

@@ -324,6 +324,53 @@ def split_solution(self, sltn, active_vars=None):
                         value, var.shape, order='F')
         return sltn_dict
 
+    def apply_restruct_mat(self, restruct_mat, restruct_mat_op):
+        """Apply restructuring matrix to parametric tensor A.
+
+        Parameters
+        ----------
+        restruct_mat : list
+            List of sparse matrices or linear operators (unused for this path).
+        restruct_mat_op : LinearOperator
+            Block diagonal linear operator for restructuring.
+
+        Returns
+        -------
+        ParamConeProg
+            New program with restructured A tensor.
+        """
+        if restruct_mat_op is not None:
+            unspecified, _ = np.divmod(self.A.shape[0] * self.A.shape[1],
+                                       restruct_mat_op.shape[1], dtype=np.int64)
+            reshaped_A = self.A.reshape(restruct_mat_op.shape[1],
+                                        unspecified, order='F').tocsr()
+            restructured_A = restruct_mat_op(reshaped_A).tocoo()
+            # Because of a bug in scipy versions < 1.20, `reshape`
+            # can overflow if indices are int32s.
+            restructured_A.row = restructured_A.row.astype(np.int64)
+            restructured_A.col = restructured_A.col.astype(np.int64)
+            restructured_A = restructured_A.reshape(
+                np.int64(restruct_mat_op.shape[0]) * (np.int64(self.x.size) + 1),
+                self.A.shape[1], order='F')
+        else:
+            restructured_A = self.A
+        return ParamConeProg(
+            self.q,
+            self.x,
+            restructured_A,
+            self.variables,
+            self.var_id_to_col,
+            self.constraints,
+            self.parameters,
+            self.param_id_to_col,
+            P=self.P,
+            formatted=True,
+            lower_bounds=self.lower_bounds,
+            upper_bounds=self.upper_bounds,
+            lb_tensor=self.lb_tensor,
+            ub_tensor=self.ub_tensor,
+        )
+
     def split_adjoint(self, del_vars=None):
         """Adjoint of split_solution.
         """
@@ -343,6 +390,65 @@ def split_adjoint(self, del_vars=None):
         return var_vec
 
 
+def lower_and_order_constraints(constraints):
+    """Lower equality/inequality constraints and reorder by cone type.
+
+    Converts Equality -> Zero, Inequality -> NonNeg, and normalizes
+    SOC/PowCone/ExpCone axes. Returns constraints ordered as:
+    Zero, NonNeg, SOC, PSD, ExpCone, PowCone3D, PowConeND.
+
+    Parameters
+    ----------
+    constraints : list
+        The problem constraints to lower and reorder.
+
+    Returns
+    -------
+    ordered_cons : list
+        The lowered and reordered constraints.
+    cons_id_map : dict
+        Mapping from constraint id to constraint id (identity map).
+    """
+    cons = []
+    for con in constraints:
+        if isinstance(con, Equality):
+            con = lower_equality(con)
+        elif isinstance(con, Inequality):
+            con = lower_ineq_to_nonneg(con)
+        elif isinstance(con, SOC) and con.axis == 1:
+            con = SOC(con.args[0], con.args[1].T, axis=0,
+                      constr_id=con.constr_id)
+        elif isinstance(con, PowCone3D) and con.args[0].ndim > 1:
+            x, y, z = con.args
+            alpha = con.alpha
+            con = PowCone3D(x.flatten(order='F'),
+                            y.flatten(order='F'),
+                            z.flatten(order='F'),
+                            alpha.flatten(order='F'),
+                            constr_id=con.constr_id)
+        elif isinstance(con, PowConeND) and con.axis == 1:
+            alpha = con.alpha.T
+            W = con.W.T
+            con = PowConeND(W, con.z.flatten(order='F'),
+                            alpha,
+                            axis=0,
+                            constr_id=con.constr_id)
+        elif isinstance(con, ExpCone) and con.args[0].ndim > 1:
+            x, y, z = con.args
+            con = ExpCone(x.flatten(order='F'), y.flatten(order='F'),
+                          z.flatten(order='F'),
+                          constr_id=con.constr_id)
+        cons.append(con)
+
+    constr_map = group_constraints(cons)
+    ordered_cons = constr_map[Zero] + constr_map[NonNeg] + \
+        constr_map[SOC] + constr_map.get(PSD, []) + \
+        constr_map.get(SvecPSD, []) + constr_map[ExpCone] + \
+        constr_map[PowCone3D] + constr_map[PowConeND]
+    cons_id_map = {con.id: con.id for con in ordered_cons}
+    return ordered_cons, cons_id_map
+
+
 class ConeMatrixStuffing(MatrixStuffing):
     """Construct matrices for linear cone problems.
 
@@ -384,52 +490,19 @@ def stuffed_objective(self, problem, extractor):
 
     def apply(self, problem):
         inverse_data = InverseData(problem)
-        # Lower equality and inequality to Zero and NonNeg.
-        cons = []
-        for con in problem.constraints:
-            if isinstance(con, Equality):
-                con = lower_equality(con)
-            elif isinstance(con, Inequality):
-                con = lower_ineq_to_nonneg(con)
-            elif isinstance(con, SOC) and con.axis == 1:
-                con = SOC(con.args[0], con.args[1].T, axis=0,
-                          constr_id=con.constr_id)
-            elif isinstance(con, PowCone3D) and con.args[0].ndim > 1:
-                x, y, z = con.args
-                alpha = con.alpha
-                con = PowCone3D(x.flatten(order='F'),
-                                y.flatten(order='F'),
-                                z.flatten(order='F'),
-                                alpha.flatten(order='F'),
-                                constr_id=con.constr_id)
-            elif isinstance(con, PowConeND) and con.axis == 1:
-                alpha = con.alpha.T
-                W = con.W.T
-                con = PowConeND(W, con.z.flatten(order='F'),
-                                alpha,
-                                axis=0,
-                                constr_id=con.constr_id)
-            elif isinstance(con, ExpCone) and con.args[0].ndim > 1:
-                x, y, z = con.args
-                con = ExpCone(x.flatten(order='F'), y.flatten(order='F'), z.flatten(order='F'),
-                              constr_id=con.constr_id)
-            cons.append(con)
+        # Lower equality and inequality constraints and reorder by cone type.
+        ordered_cons, cons_id_map = lower_and_order_constraints(problem.constraints)
+        inverse_data.cons_id_map = cons_id_map
+        inverse_data.constraints = ordered_cons
+
         # Need to check that intended canonicalization backend still works.
-        lowered_con_problem = problem.copy([problem.objective, cons])
+        lowered_con_problem = problem.copy(
+            [problem.objective, ordered_cons])
         canon_backend = get_canon_backend(lowered_con_problem, self.canon_backend)
         # Form the constraints
         extractor = CoeffExtractor(inverse_data, canon_backend)
         params_to_P, params_to_c, flattened_variable = self.stuffed_objective(
             problem, extractor)
-        # Reorder constraints to Zero, NonNeg, SOC, PSD, EXP, PowCone3D, PowConeND
-        constr_map = group_constraints(cons)
-        ordered_cons = constr_map[Zero] + constr_map[NonNeg] + \
-            constr_map[SOC] + constr_map.get(PSD, []) + \
-            constr_map.get(SvecPSD, []) + constr_map[ExpCone] + \
-            constr_map[PowCone3D] + constr_map[PowConeND]
-        inverse_data.cons_id_map = {con.id: con.id for con in ordered_cons}
-
-        inverse_data.constraints = ordered_cons
         # Batch expressions together, then split apart.
         expr_list = [arg for c in ordered_cons for arg in c.args]
         params_to_problem_data = extractor.affine(expr_list)