fix diff engine converter bugs: 1D matmul dims, reshape, transpose, quad form

- helpers.py: fix 1D dimension normalization in dense matmul helpers.
  Right-matmul treated 1D A as (1,n) instead of (n,1), causing segfaults.
- converters.py: reshape 1D child to column vector in left-matmul for
  dot products; add constant-atom fallback for unfolded expressions;
  move QuadForm/SymbolicQuadForm dispatch out of ATOM_CONVERTERS (needs
  n_vars); tolerate 1D dimension mismatches via reshape instead of error.
- registry.py: support C-order reshape via transpose decomposition;
  fix 1D transpose to be a no-op; improve scalar quad form P handling;
  raise NotImplementedError for vector SymbolicQuadForm (TODO: native
  block quadform in SparseDiffPy).
- perspective_canon.py: handle DiffengineConeProgram which stores
  q, d, A, b as separate arrays (vs ParamConeProg sparse tensors).

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: Transurgeon

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/solvers/nlp_solvers/diff_engine/converters.py

@@ -31,7 +31,18 @@
 
 
 def convert_matmul(expr, children, var_dict, n_vars, param_dict):
-    """Convert matrix multiplication A @ f(x), f(x) @ A, or X @ Y."""
+    """Convert matrix multiplication A @ f(x), f(x) @ A, or X @ Y.
+
+    NumPy matmul semantics for 1D arrays:
+      (n,) @ (m,k) → treat left as (1,n)
+      (m,k) @ (n,) → treat right as (n,1)
+      (n,) @ (n,)  → dot product, treat as (1,n) @ (n,1) → scalar
+
+    The C engine only has 2D nodes. 1D expressions are stored as (1,n) by
+    normalize_shape.  For left-matmul A @ child, if the child is 1D we must
+    reshape it to (n,1) so the inner dimensions agree.  For right-matmul
+    child @ A, the helpers already handle 1D A via the ndim==1 branch.
+    """
     left_arg, right_arg = expr.args
 
     if left_arg.is_constant():
@@ -40,9 +51,15 @@ def convert_matmul(expr, children, var_dict, n_vars, param_dict):
             param_node = param_dict[left_arg.id]
         else:
             param_node = None
+        child = children[1]
+        # If the right operand is 1D, the C node is (1,n) but left-matmul
+        # needs it as (n,1) so inner dims match: A(m,n) @ child(n,1).
+        if len(right_arg.shape) <= 1 and right_arg.size > 1:
+            n = right_arg.size
+            child = _diffengine.make_reshape(child, n, 1)
         if sparse.issparse(A):
-            return make_sparse_left_matmul(param_node, children[1], A)
-        return make_dense_left_matmul(param_node, children[1], A)
+            return make_sparse_left_matmul(param_node, child, A)
+        return make_dense_left_matmul(param_node, child, A)
 
     elif right_arg.is_constant():
         A = right_arg.value
@@ -98,11 +115,22 @@ def convert_expr(expr, var_dict, n_vars, param_dict=None):
         return param_dict[expr.id]
 
     # Base case: constant (in the diff engine, a constant is a parameter with ID -1)
+    # Also handles atoms applied to pure constants (e.g. PnormApprox(Constant), floor(Constant))
+    # that weren't folded by Dcp2Cone.
     if isinstance(expr, cp.Constant):
         c = to_dense_float(expr.value)
         d1, d2 = normalize_shape(expr.shape)
         return _diffengine.make_parameter(d1, d2, -1, n_vars, c.flatten(order='F'))
 
+    # Constant atom: no variables/parameters, so it must have a concrete value.
+    # Handles atoms like floor(NegExpression(Constant(5.0))) after EvalParams.
+    # Check variables()/parameters() before .value to avoid triggering
+    # numeric() on atoms that don't support it (e.g. cached SymbolicQuadForm).
+    if not expr.variables() and not expr.parameters() and expr.value is not None:
+        c = to_dense_float(expr.value)
+        d1, d2 = normalize_shape(expr.shape)
+        return _diffengine.make_parameter(d1, d2, -1, n_vars, c.flatten(order='F'))
+
     # Recursive case: atoms
     atom_name = type(expr).__name__
     children = [convert_expr(arg, var_dict, n_vars, param_dict) for arg in expr.args]
@@ -113,6 +141,11 @@ def convert_expr(expr, var_dict, n_vars, param_dict=None):
         C_expr = convert_matmul(expr, children, var_dict, n_vars, param_dict)
     elif atom_name == "multiply":
         C_expr = convert_multiply(expr, children, var_dict, n_vars, param_dict)
+    elif atom_name in ("QuadForm", "SymbolicQuadForm"):
+        from cvxpy.reductions.solvers.nlp_solvers.diff_engine.registry import (
+            convert_quad_form,
+        )
+        C_expr = convert_quad_form(expr, children, n_vars)
     elif atom_name in ATOM_CONVERTERS:
         C_expr = ATOM_CONVERTERS[atom_name](expr, children)
     else:
@@ -123,10 +156,16 @@ def convert_expr(expr, var_dict, n_vars, param_dict=None):
     d1_Python, d2_Python = normalize_shape(expr.shape)
 
     if d1_C != d1_Python or d2_C != d2_Python:
-        raise ValueError(
-            f"Dimension mismatch for atom '{atom_name}': "
-            f"C dimensions ({d1_C}, {d2_C}) vs Python dimensions ({d1_Python}, {d2_Python})"
-        )
-
+        # 1D Python shapes (n,) normalize to (1, n), but the C engine may
+        # produce (n, 1) — e.g. matrix @ scalar or transpose of a vector.
+        # Both represent the same 1D data; reshape to match Python convention.
+        if len(expr.shape) <= 1 and d1_C * d2_C == d1_Python * d2_Python:
+            C_expr = _diffengine.make_reshape(C_expr, d1_Python, d2_Python)
+        else:
+            raise ValueError(
+                f"Dimension mismatch for atom '{atom_name}': "
+                f"C dimensions ({d1_C}, {d2_C}) vs "
+                f"Python dimensions ({d1_Python}, {d2_Python})"
+            )
 
     return C_expr

cvxpy/reductions/solvers/nlp_solvers/diff_engine/helpers.py

@@ -53,7 +53,10 @@ def make_sparse_left_matmul(param_node, child, A):
 
 
 def make_dense_left_matmul(param_node, child, A):
-    m, n = normalize_shape(A.shape)
+    if A.ndim == 1:
+        m, n = 1, A.shape[0]
+    else:
+        m, n = A.shape
     return _diffengine.make_left_matmul(
         param_node, child, 'dense', A.flatten(order='C'), m, n)
 
@@ -70,7 +73,10 @@ def make_sparse_right_matmul(param_node, child, A):
 
 
 def make_dense_right_matmul(param_node, child, A):
-    m, n = normalize_shape(A.shape)
+    if A.ndim == 1:
+        m, n = A.shape[0], 1
+    else:
+        m, n = A.shape
     return _diffengine.make_right_matmul(
         param_node, child, 'dense', A.flatten(order='C'), m, n)
 

cvxpy/reductions/solvers/nlp_solvers/diff_engine/registry.py

@@ -92,42 +92,58 @@ def convert_rel_entr(expr, children):
     return _diffengine.make_rel_entr(children[0], children[1])
 
 
-def convert_quad_form(expr, children):
-    """Convert quadratic form x.T @ P @ x."""
+def convert_quad_form(expr, children, n_vars):
+    """Convert quadratic form x.T @ P @ x.
 
+    Currently only handles scalar quad forms (shape ()). Vector-shaped
+    SymbolicQuadForm (e.g. from huber, quad_over_lin with axis) requires
+    native block quadform support in SparseDiffPy.
+    """
     P = expr.args[1]
 
-    if not isinstance(P, cp.Constant):
+    if not P.is_constant():
         raise NotImplementedError("quad_form requires P to be a constant matrix")
 
-    P = P.value
+    # TODO: vector-shaped SymbolicQuadForm (e.g. from huber, quad_over_lin
+    # with axis) needs native block quadform support in SparseDiffPy rather
+    # than decomposing into diag(P) * power(x, 2).
+    if expr.size > 1:
+        raise NotImplementedError(
+            f"Vector-shaped quad form (shape {expr.shape}) not yet supported "
+            "by the diffengine backend. Needs native block quadform in SparseDiffPy."
+        )
 
-    if not isinstance(P, sparse.csr_matrix):
-          P = sparse.csr_matrix(P)
+    P_val = P.value
+    if sparse.issparse(P_val):
+        P_val = P_val.toarray()
+    P_val = np.asarray(P_val, dtype=np.float64)
 
+    P_csr = sparse.csr_matrix(P_val)
     return _diffengine.make_quad_form(
         children[0],
-        P.data.astype(np.float64),
-        P.indices.astype(np.int32),
-        P.indptr.astype(np.int32),
-        P.shape[0],
-        P.shape[1],
+        P_csr.data.astype(np.float64),
+        P_csr.indices.astype(np.int32),
+        P_csr.indptr.astype(np.int32),
+        P_csr.shape[0],
+        P_csr.shape[1],
     )
 
 
 def convert_reshape(expr, children):
-    """Convert reshape - only Fortran order is supported.
+    """Convert reshape.
 
-    Note: Only order='F' (Fortran/column-major) is supported.
+    F-order (column-major) uses make_reshape directly.
+    C-order (row-major) is decomposed as: transpose(reshape(transpose(x), (n, m), F))
+    since reshape(x, (m, n), C) == transpose(reshape(transpose(x), (n, m), F)).
     """
-    if expr.order != "F":
-        raise NotImplementedError(
-            f"reshape with order='{expr.order}' not supported. "
-            "Only order='F' (Fortran) is currently supported."
-        )
-
     d1, d2 = normalize_shape(expr.shape)
-    return _diffengine.make_reshape(children[0], d1, d2)
+    if expr.order == "F":
+        return _diffengine.make_reshape(children[0], d1, d2)
+    else:
+        # C-order: transpose input, F-reshape to swapped dims, transpose output
+        transposed = _diffengine.make_transpose(children[0])
+        reshaped = _diffengine.make_reshape(transposed, d2, d1)
+        return _diffengine.make_transpose(reshaped)
 
 def convert_broadcast(expr, children):
     d1, d2 = expr.broadcast_shape
@@ -173,9 +189,12 @@ def convert_prod(expr, children):
         return _diffengine.make_prod_axis_one(children[0])
 
 def convert_transpose(expr, children):
-    # If the child is a vector (shape (n,) or (n,1) or (1,n)), use reshape to transpose
-    child_shape = normalize_shape(expr.args[0].shape)
+    # In CVXPY, transposing a 1D vector (n,) is a no-op: (n,).T == (n,).
+    # The C engine stores 1D as (1, n), so we must not flip it to (n, 1).
+    if len(expr.args[0].shape) <= 1:
+        return children[0]
 
+    child_shape = normalize_shape(expr.args[0].shape)
     if 1 in child_shape:
         return _diffengine.make_reshape(children[0], child_shape[1], child_shape[0])
     else:
@@ -229,8 +248,8 @@ def convert_upper_tri(_expr, children):
     # Reductions
     "Sum": convert_sum,
     # Bivariate
-    "QuadForm": convert_quad_form,
-    "SymbolicQuadForm": convert_quad_form,
+    # QuadForm and SymbolicQuadForm are dispatched directly in convert_expr
+    # (they need n_vars for creating constant nodes in the vector case).
     "quad_over_lin": convert_quad_over_lin,
     "rel_entr": convert_rel_entr,
     # Elementwise univariate with parameter