cvxgrp
diff --git a/‎cvxpy/cvxcore/python/canonInterface.py‎
Lines changed: 3 additions & 1 deletion b/‎cvxpy/cvxcore/python/canonInterface.py‎
Lines changed: 3 additions & 1 deletion
diff --git a/‎cvxpy/expressions/leaf.py‎
Lines changed: 32 additions & 6 deletions b/‎cvxpy/expressions/leaf.py‎
Lines changed: 32 additions & 6 deletions
diff --git a/‎cvxpy/expressions/variable.py‎
Lines changed: 4 additions & 9 deletions b/‎cvxpy/expressions/variable.py‎
Lines changed: 4 additions & 9 deletions
diff --git a/‎cvxpy/problems/problem.py‎
Lines changed: 11 additions & 5 deletions b/‎cvxpy/problems/problem.py‎
Lines changed: 11 additions & 5 deletions
diff --git a/‎cvxpy/reductions/cvx_attr2constr.py‎
Lines changed: 103 additions & 37 deletions b/‎cvxpy/reductions/cvx_attr2constr.py‎
Lines changed: 103 additions & 37 deletions
@@ -47,7 +47,9 @@ def get_parameter_vector(param_size,
     -------
         A flattened NumPy array of parameter values, of length param_size + 1
     """
-    #TODO handle parameters with structure.
+    # Parameters with dim-reducing attributes (sparsity, diag, symmetric, PSD,
+    # NSD) are handled by CvxAttr2Constr, which replaces them with reduced-size
+    # parameters before this point.
     if param_size == 0:
         return None
     param_vec = np.zeros(param_size + 1)
 
@@ -166,6 +166,7 @@ def __init__(
                 "Sparsity and diag attributes force zeros, which contradicts "
                 "strict positivity/negativity."
             )
+        self._leaf_of_provenance = None
         self.args = []
         self.bounds = self._ensure_valid_bounds(bounds)
         self.attributes['bounds'] = self.bounds
@@ -506,7 +507,7 @@ def save_value(self, val, sparse_path=False) -> None:
         if val is None:
             self._value = None
         elif self.sparse_idx is not None and not sparse_path:
-            self._value = sp.coo_array((val[self.sparse_idx], self.sparse_idx), shape=self.shape)
+            self._value = val[self.sparse_idx]
         elif self.sparse_idx is not None and sparse_path:
             self._value = val.data
         else:
@@ -523,7 +524,7 @@ def value(self) -> Optional[np.ndarray]:
             if self._value is None:
                 return None
             val = np.zeros(self.shape, dtype=self._value.dtype)
-            val[self.sparse_idx] = self._value.data
+            val[self.sparse_idx] = self._value
             return val
 
     @value.setter
@@ -538,10 +539,7 @@ def value_sparse(self) -> Optional[...]:
         """The numeric value of the expression if it is a sparse variable."""
         if self._value is None:
             return None
-        if isinstance(self._value, np.ndarray):
-            return sp.coo_array((self._value, self.sparse_idx), shape=self.shape)
-        else:
-            return self._value
+        return sp.coo_array((self._value, self.sparse_idx), shape=self.shape)
 
     @value_sparse.setter
     def value_sparse(self, val) -> None:
@@ -702,6 +700,34 @@ def is_dpp(self, context: str = 'dcp') -> bool:
     def atoms(self) -> list[Atom]:
         return []
 
+    def attributes_were_lowered(self) -> bool:
+        """True iff this leaf was generated when lowering a leaf with attributes."""
+        return self._leaf_of_provenance is not None
+
+    def set_leaf_of_provenance(self, leaf: Leaf) -> None:
+        assert leaf.attributes
+        self._leaf_of_provenance = leaf
+
+    def leaf_of_provenance(self) -> Leaf | None:
+        """Returns a leaf with attributes from which this leaf was generated."""
+        return self._leaf_of_provenance
+
+    @property
+    def _has_dim_reducing_attr(self) -> bool:
+        return (self.sparse_idx is not None or self.attributes['diag'] or
+                self.attributes['symmetric'] or self.attributes['PSD'] or
+                self.attributes['NSD'])
+
+    @property
+    def _reduced_size(self) -> int:
+        if self.sparse_idx is not None:
+            return len(self.sparse_idx[0])
+        elif self.attributes['diag']:
+            return self.shape[0]
+        elif self.attributes['symmetric'] or self.attributes['PSD'] or self.attributes['NSD']:
+            return self.shape[0] * (self.shape[0] + 1) // 2
+        return self.size
+
     def _validate_sparse_bound(self, val):
         """Validate a single sparse bound entry.
 
 
@@ -48,7 +48,6 @@ def __init__(
         else:
             raise TypeError("Variable name %s must be a string." % name)
 
-        self._variable_with_attributes: Variable | None = None
         self._value = None
         self.delta = None
         self.gradient = None
@@ -116,17 +115,13 @@ def canonicalize(self) -> Tuple[Expression, list[Constraint]]:
         obj = lu.create_var(self.shape, self.id)
         return (obj, [])
 
-    def attributes_were_lowered(self) -> bool:
-        """True iff variable generated when lowering a variable with attributes."""
-        return self._variable_with_attributes is not None
-
     def set_variable_of_provenance(self, variable: Variable) -> None:
-        assert variable.attributes
-        self._variable_with_attributes = variable
+        """Deprecated: use set_leaf_of_provenance instead."""
+        self.set_leaf_of_provenance(variable)
 
     def variable_of_provenance(self) -> Optional[Variable]:
-        """Returns a variable with attributes from which this variable was generated."""
-        return self._variable_with_attributes
+        """Deprecated: use leaf_of_provenance instead."""
+        return self.leaf_of_provenance()
 
     def __repr__(self) -> str:
         """String to recreate the variable."""
 
@@ -1224,13 +1224,17 @@ def backward(self) -> None:
         # reductions that transform parameters (e.g., DGP log transform,
         # Complex2Real split into real/imag).
         for param in self.parameters():
-            # Start with the direct gradient if the param passed through unchanged
-            grad = 0.0 if param.id not in dparams else dparams[param.id]
+            grad = 0.0
+            handled = False
             # Apply chain rule through any reductions that transformed this param
             for reduction in self._cache.solving_chain.reductions:
                 reduction_grad = reduction.param_backward(param, dparams)
                 if reduction_grad is not None:
                     grad = grad + reduction_grad
+                    handled = True
+            # Fall back to the direct gradient if no reduction transformed this param
+            if not handled and param.id in dparams:
+                grad = dparams[param.id]
             param.gradient = grad
 
     def derivative(self) -> None:
@@ -1300,14 +1304,16 @@ def derivative(self) -> None:
         # Complex2Real split into real/imag).
         for param in self.parameters():
             delta = param.delta if param.delta is not None else np.zeros(param.shape)
-            # If param passed through unchanged, add its delta directly
-            if param.id in param_prog.param_id_to_col:
-                param_deltas[param.id] = np.asarray(delta, dtype=np.float64)
+            handled = False
             # Apply chain rule through any reductions that transformed this param
             for reduction in self._cache.solving_chain.reductions:
                 transformed_deltas = reduction.param_forward(param, delta)
                 if transformed_deltas is not None:
                     param_deltas.update(transformed_deltas)
+                    handled = True
+            # If no reduction transformed this param, add its delta directly
+            if not handled and param.id in param_prog.param_id_to_col:
+                param_deltas[param.id] = np.asarray(delta, dtype=np.float64)
         dc, _, dA, db = param_prog.apply_parameters(param_deltas,
                                                     zero_offset=True)
         start = time.time()
 
@@ -23,6 +23,7 @@
 from cvxpy.atoms.affine.upper_tri import upper_tri_to_full
 from cvxpy.expressions import cvxtypes
 from cvxpy.expressions.constants import Constant
+from cvxpy.expressions.constants.parameter import Parameter
 from cvxpy.expressions.variable import Variable
 from cvxpy.reductions.reduction import Reduction
 from cvxpy.reductions.solution import Solution
@@ -73,7 +74,7 @@ def attributes_present(variables, attr_map) -> list[str]:
                                              in variables)]
 
 
-def recover_value_for_variable(variable, lowered_value, project: bool = True):
+def recover_value_for_leaf(variable, lowered_value, project: bool = True):
     if variable.attributes['diag']:
         return sp.diags_array(lowered_value.flatten(order='F'))
     elif attributes_present([variable], SYMMETRIC_ATTRIBUTES):
@@ -93,21 +94,66 @@ def recover_value_for_variable(variable, lowered_value, project: bool = True):
         return lowered_value
 
 
-def lower_value(variable, value) -> np.ndarray:
+def lower_value(variable, value=None) -> np.ndarray:
+    """Extract the reduced representation of a leaf's value.
+
+    Args:
+        variable: The leaf whose attributes determine the reduction.
+        value: If provided, a full-size value (e.g. a differentiation delta)
+            to reduce.  If ``None``, reads the leaf's stored ``_value``.
+
+    Notes:
+        Called without *value* by ``update_parameters`` and ``apply`` to read
+        the current parameter value into the reduced parameter.  Called *with*
+        an explicit value by ``param_forward`` to reduce a full-size delta.
+
+        For sparse leaves ``Leaf.save_value`` already stores only the nonzero
+        entries, so when ``value is None`` the sparse branch can return
+        ``_value`` directly.  An explicit *value* is always full-size and must
+        be extracted at the sparse indices.
+    """
+    # Track whether the caller supplied a full-size value.  When value is None
+    # we read _value, which for sparse leaves is already in reduced form.
+    full_size = value is not None
+    if value is None:
+        value = variable._value
     if attributes_present([variable], SYMMETRIC_ATTRIBUTES):
         return value[np.triu_indices(variable.shape[0])]
     elif variable.attributes['diag']:
         return np.diag(value)
+    elif variable.attributes['sparsity']:
+        if full_size:
+            return np.asarray(value)[variable.sparse_idx]
+        else:
+            # _value already stores only the nonzero data (see Leaf.save_value).
+            return np.asarray(value)
     else:
         return value
 
 
+def build_dim_reduced_expression(leaf, reduced_leaf):
+    """Build Expression that reconstructs full shape from a reduced-size leaf."""
+    if attributes_present([leaf], SYMMETRIC_ATTRIBUTES):
+        n = leaf.shape[0]
+        return reshape(Constant(upper_tri_to_full(n)) @ reduced_leaf, (n, n), order='F')
+    elif leaf.sparse_idx is not None:
+        n = len(leaf.sparse_idx[0])
+        row_idx = np.ravel_multi_index(leaf.sparse_idx, leaf.shape, order='F')
+        coeff = Constant(sp.csc_array((np.ones(n), (row_idx, np.arange(n))),
+                         shape=(np.prod(leaf.shape, dtype=int), n)), name="sparse_coeff")
+        return reshape(coeff @ reduced_leaf, leaf.shape, order='F')
+    elif leaf.attributes['diag']:
+        return diag(reduced_leaf)
+    return reduced_leaf
+
+
 class CvxAttr2Constr(Reduction):
     """Expand convex variable attributes into constraints."""
 
     def __init__(self, problem=None, reduce_bounds: bool = False) -> None:
         """If reduce_bounds, reduce lower and upper bounds on variables."""
         self.reduce_bounds = reduce_bounds
+        self._parameters = {}  # {orig_param: reduced_param}
         super(CvxAttr2Constr, self).__init__(problem=problem)
 
     def reduction_attributes(self) -> List[str]:
@@ -123,7 +169,9 @@ def accepts(self, problem) -> bool:
         return True
 
     def apply(self, problem):
-        if not attributes_present(problem.variables(), CONVEX_ATTRIBUTES):
+        has_var_attrs = attributes_present(problem.variables(), CONVEX_ATTRIBUTES)
+        has_param_attrs = any(p._has_dim_reducing_attr for p in problem.parameters())
+        if not has_var_attrs and not has_param_attrs:
             return problem, ()
 
         # The attributes to be reduced.
@@ -144,31 +192,21 @@ def apply(self, problem):
                         new_var = True
                         new_attr[key] = None if key == 'bounds' else False
 
-                if attributes_present([var], SYMMETRIC_ATTRIBUTES):
-                    n = var.shape[0]
-                    shape = (n*(n+1)//2, 1)
-                    upper_tri = Variable(shape, var_id=var.id, **new_attr)
-                    upper_tri.set_variable_of_provenance(var)
-                    id2new_var[var.id] = upper_tri
-                    fill_coeff = Constant(upper_tri_to_full(n))
-                    full_mat = fill_coeff @ upper_tri
-                    obj = reshape(full_mat, (n, n), order='F')
-                elif var.attributes['sparsity']:
-                    n = len(var.sparse_idx[0])
-
-                    # Transform bounds for reduced variable if bounds are not being reduced
-                    if 'bounds' not in reduction_attributes and new_attr.get('bounds'):
+                if var._has_dim_reducing_attr:
+                    n = var._reduced_size
+
+                    # Transform bounds for sparse reduced variable
+                    if var.attributes['sparsity'] and \
+                            'bounds' not in reduction_attributes and new_attr.get('bounds'):
                         bounds = new_attr['bounds']
                         transformed_bounds = []
                         for bound in bounds:
                             if sp.issparse(bound):
-                                # Extract data from sparse bound
-                                # (already validated to match sparsity)
                                 coo = sp.coo_array(bound)
                                 coo.sum_duplicates()
                                 transformed_bounds.append(coo.data)
-                            elif np.isscalar(bound) or (hasattr(bound, 'ndim') and bound.ndim == 0):
-                                # Scalar bounds - keep as-is
+                            elif np.isscalar(bound) or (
+                                    hasattr(bound, 'ndim') and bound.ndim == 0):
                                 transformed_bounds.append(bound)
                             else:
                                 raise ValueError(
@@ -177,23 +215,13 @@ def apply(self, problem):
                                 )
                         new_attr['bounds'] = transformed_bounds
 
-                    sparse_var = Variable(n, var_id=var.id, **new_attr)
-                    sparse_var.set_variable_of_provenance(var)
-                    id2new_var[var.id] = sparse_var
-                    row_idx = np.ravel_multi_index(var.sparse_idx, var.shape, order='F')
-                    col_idx = np.arange(n)
-                    coeff_matrix = Constant(sp.csc_array((np.ones(n), (row_idx, col_idx)),
-                                                    shape=(np.prod(var.shape, dtype=int), n)),
-                                                    name="sparse_coeff")
-                    obj = reshape(coeff_matrix @ sparse_var, var.shape, order='F')
-                elif var.attributes['diag']:
-                    diag_var = Variable(var.shape[0], var_id=var.id, **new_attr)
-                    diag_var.set_variable_of_provenance(var)
-                    id2new_var[var.id] = diag_var
-                    obj = diag(diag_var)
+                    reduced_var = Variable(n, var_id=var.id, **new_attr)
+                    reduced_var.set_leaf_of_provenance(var)
+                    id2new_var[var.id] = reduced_var
+                    obj = build_dim_reduced_expression(var, reduced_var)
                 elif new_var:
                     obj = Variable(var.shape, var_id=var.id, **new_attr)
-                    obj.set_variable_of_provenance(var)
+                    obj.set_leaf_of_provenance(var)
                     id2new_var[var.id] = obj
                 else:
                     obj = var
@@ -209,6 +237,23 @@ def apply(self, problem):
                 if self.reduce_bounds:
                     var._bound_domain(obj, constr)
 
+        # For each unique parameter with dim-reducing attributes, create a
+        # reduced parameter and a reconstruction expression.
+        for param in problem.parameters():
+            if param._has_dim_reducing_attr and id(param) not in id2new_obj:
+                n = param._reduced_size
+                new_attr = param.attributes.copy()
+                for key in reduction_attributes:
+                    if new_attr[key]:
+                        new_attr[key] = None if key == 'bounds' else False
+                reduced_param = Parameter(n, id=param.id, **new_attr)
+                reduced_param.set_leaf_of_provenance(param)
+                self._parameters[param] = reduced_param
+                if param.value is not None:
+                    reduced_param.value = lower_value(param)
+                obj = build_dim_reduced_expression(param, reduced_param)
+                id2new_obj[id(param)] = obj
+
         # Create new problem.
         obj = problem.objective.tree_copy(id_objects=id2new_obj)
         cons_id_map = {}
@@ -218,6 +263,27 @@ def apply(self, problem):
         inverse_data = (id2new_var, id2old_var, cons_id_map)
         return cvxtypes.problem()(obj, constr), inverse_data
 
+    def update_parameters(self, problem) -> None:
+        """Update reduced parameter values from original parameters."""
+        for param, reduced_param in self._parameters.items():
+            reduced_param.value = lower_value(param)
+
+    def param_backward(self, param, dparams):
+        """Recover full-size gradient from reduced-size gradient."""
+        if param not in self._parameters:
+            return None
+        reduced_param = self._parameters[param]
+        if reduced_param.id not in dparams:
+            return None
+        return recover_value_for_leaf(param, dparams[reduced_param.id])
+
+    def param_forward(self, param, delta):
+        """Transform full-size delta to reduced-size delta."""
+        if param not in self._parameters:
+            return None
+        reduced_param = self._parameters[param]
+        return {reduced_param.id: lower_value(param, delta)}
+
     def invert(self, solution, inverse_data) -> Solution:
         if not inverse_data:
             return solution
@@ -227,7 +293,7 @@ def invert(self, solution, inverse_data) -> Solution:
         for id, var in id2old_var.items():
             new_var = id2new_var[id]
             if new_var.id in solution.primal_vars:
-                pvars[id] = recover_value_for_variable(
+                pvars[id] = recover_value_for_leaf(
                     var, solution.primal_vars[new_var.id])
 
         dvars = {orig_id: solution.dual_vars[vid]