Pre-PR cleanup for DNLP merge into CVXPY master

- Remove `submodules: recursive` from CI workflows (build, test_nlp_solvers, test_backends)
- Revert `_grad` in affine_atom.py to upstream version
- Remove NaN-allowance block in leaf.py added for NLP structural jacobian
- Update is_dnlp() docstrings to use linearizable terminology
- Add normalize_shape() helper in converters.py, replacing 7 inline occurrences
- Remove unnecessary comment in nlp_solver.py
- Export UNO in cvxpy/__init__.py
- Revert README.md to upstream CVXPY version

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: Transurgeon

.github/workflows/build.yml

@@ -54,8 +54,6 @@ jobs:
 
     steps:
       - uses: actions/checkout@v5
-        with:
-          submodules: recursive
       - name: Set Additional Envs
         run: |
           echo "PYTHON_SUBVERSION=$(echo $PYTHON_VERSION | cut -c 3-)" >> $GITHUB_ENV
@@ -116,8 +114,6 @@ jobs:
 
     steps:
       - uses: actions/checkout@v5
-        with:
-          submodules: recursive
       - uses: actions/setup-python@v6
         with:
           python-version: ${{ matrix.python-version }}

.github/workflows/test_backends.yml

@@ -16,8 +16,6 @@ jobs:
         with:
           python-version: "3.12"
       - uses: actions/checkout@v5
-        with:
-          submodules: recursive
       - name: Install cvxpy dependencies
         run: |
           pip install -e .

.github/workflows/test_nlp_solvers.yml

@@ -16,8 +16,6 @@ jobs:
         os: [ubuntu-latest, macos-latest]
     steps:
       - uses: actions/checkout@v5
-        with:
-          submodules: recursive
       - uses: astral-sh/setup-uv@v7
         with:
           python-version: "3.12"

README.md

@@ -1,73 +1,156 @@
-# DNLP — Disciplined Nonlinear Programming
-The DNLP package is an extension of [CVXPY](https://www.cvxpy.org/) to general nonlinear programming (NLP).
-DNLP allows smooth functions to be freely mixed with nonsmooth convex and concave functions,
-with some rules governing how the nonsmooth functions can be used. For details, see our paper [Disciplined Nonlinear Programming](https://web.stanford.edu/~boyd/papers/dnlp.html).
+CVXPY
+=====================
+[![Build Status](https://github.com/cvxpy/cvxpy/actions/workflows/build.yml/badge.svg?event=push)](https://github.com/cvxpy/cvxpy/actions/workflows/build.yml)
+![PyPI - downloads](https://img.shields.io/pypi/dm/cvxpy.svg?label=Pypi%20downloads)
+![Conda - downloads](https://img.shields.io/conda/dn/conda-forge/cvxpy.svg?label=Conda%20downloads)
+[![Discord](https://img.shields.io/badge/Chat-Discord-Blue?color=5865f2)](https://discord.gg/4urRQeGBCr)
+[![Benchmarks](http://img.shields.io/badge/benchmarked%20by-asv-blue.svg?style=flat)](https://cvxpy.github.io/benchmarks/)
+[![OpenSSF Scorecard](https://api.securityscorecards.dev/projects/github.com/cvxpy/cvxpy/badge)](https://api.securityscorecards.dev/projects/github.com/cvxpy/cvxpy)
 
----
-## Installation
-The installation consists of two steps.
+**The CVXPY documentation is at [cvxpy.org](https://www.cvxpy.org/).**
 
-#### Step 1: Install IPOPT
-DNLP requires an NLP solver. The recommended solver is [Ipopt](https://coin-or.github.io/Ipopt/). First install the IPOPT system library, then install the Python interface [cyipopt](https://github.com/mechmotum/cyipopt):
-```bash
-# Ubuntu/Debian
-sudo apt-get install coinor-libipopt-dev
+*We are building a CVXPY community on [Discord](https://discord.gg/4urRQeGBCr). Join the conversation! For issues and long-form discussions, use [Github Issues](https://github.com/cvxpy/cvxpy/issues) and [Github Discussions](https://github.com/cvxpy/cvxpy/discussions).*
 
-# macOS
-brew install ipopt
-```
-Then install the Python interface:
-```bash
-pip install cyipopt
-```
+**Contents**
+- [Installation](#installation)
+- [Getting started](#getting-started)
+- [Issues](#issues)
+- [Community](#community)
+- [Contributing](#contributing)
+- [Team](#team)
+- [Citing](#citing)
 
-#### Step 2: Install DNLP
-DNLP is installed by cloning this repository and installing it locally:
-```bash
-git clone https://github.com/cvxgrp/DNLP.git
-cd DNLP
-pip install .
-```
 
----
-## Example
-Below we give a toy example where we maximize a convex quadratic function subject to a nonlinear equality constraint.  Many more examples, including the ones in the paper, can be found at [DNLP-examples](https://github.com/cvxgrp/dnlp-examples).
-```python
-import cvxpy as cp
-import numpy as np
+CVXPY is a Python-embedded modeling language for convex optimization problems. It allows you to express your problem in a natural way that follows the math, rather than in the restrictive standard form required by solvers.
+
+For example, the following code solves a least-squares problem where the variable is constrained by lower and upper bounds:
+
+```python3
 import cvxpy as cp
+import numpy
 
-# problem data
-np.random.seed(0)
-n = 3
-A = np.random.randn(n, n)
-A = A.T @ A
+# Problem data.
+m = 30
+n = 20
+numpy.random.seed(1)
+A = numpy.random.randn(m, n)
+b = numpy.random.randn(m)
 
-# formulate optimization problem
+# Construct the problem.
 x = cp.Variable(n)
-obj = cp.Maximize(cp.quad_form(x, A))
-constraints = [cp.sum_squares(x) == 1]
-
-# initialize and solve
-x.value = np.ones(n)
-prob = cp.Problem(obj, constraints)
-prob.solve(nlp=True, verbose=True)
-print("Optimal value from DNLP: ", prob.value)
-
-# the optimal value for this toy problem can also be found by computing the maximum eigenvalue of A
-eigenvalues  = np.linalg.eigvalsh(A)
-print("Maximum eigenvalue:      " , np.max(eigenvalues))
+objective = cp.Minimize(cp.sum_squares(A @ x - b))
+constraints = [0 <= x, x <= 1]
+prob = cp.Problem(objective, constraints)
+
+# The optimal objective is returned by prob.solve().
+result = prob.solve()
+# The optimal value for x is stored in x.value.
+print(x.value)
+# The optimal Lagrange multiplier for a constraint
+# is stored in constraint.dual_value.
+print(constraints[0].dual_value)
+```
+
+With CVXPY, you can model
+* convex optimization problems,
+* mixed-integer convex optimization problems,
+* geometric programs, and
+* quasiconvex programs.
+
+CVXPY is not a solver. It relies upon the open source solvers 
+[Clarabel](https://github.com/oxfordcontrol/Clarabel.rs), [SCS](https://github.com/bodono/scs-python),
+[OSQP](https://github.com/oxfordcontrol/osqp) and [HiGHS](https://github.com/ERGO-Code/HiGHS).
+Additional solvers are [available](https://www.cvxpy.org/tutorial/solvers/index.html#choosing-a-solver),
+but must be installed separately.
+
+CVXPY began as a Stanford University research project. It is now developed by
+many people, across many institutions and countries.
+
+
+## Installation
+CVXPY is available on PyPI, and can be installed with
+```
+pip install cvxpy
+```
+
+CVXPY can also be installed with conda, using
+```
+conda install -c conda-forge cvxpy
 ```
 
----
-## Supported Solvers
-| Solver | License | Installation |
-|--------|---------|--------------|
-| [IPOPT](https://github.com/coin-or/Ipopt) | EPL-2.0 | Install system IPOPT (see above), then `pip install cyipopt` |
-| [Knitro](https://www.artelys.com/solvers/knitro/) | Commercial | `pip install knitro` (requires license) |
+CVXPY has the following dependencies:
+
+- Python >= 3.11
+- Clarabel >= 0.5.0
+- OSQP >= 1.0.0
+- SCS >= 3.2.4.post1
+- NumPy >= 2.0.0
+- SciPy >= 1.13.0
+- highspy >= 1.11.0
+
+For detailed instructions, see the [installation
+guide](https://www.cvxpy.org/install/index.html).
+
+## Getting started
+To get started with CVXPY, check out the following:
+* [official CVXPY tutorial](https://www.cvxpy.org/tutorial/index.html)
+* [example library](https://www.cvxpy.org/examples/index.html)
+* [API reference](https://www.cvxpy.org/api_reference/cvxpy.html)
+
+## Issues
+We encourage you to report issues using the [Github tracker](https://github.com/cvxpy/cvxpy/issues). We welcome all kinds of issues, especially those related to correctness, documentation, performance, and feature requests.
+
+For basic usage questions (e.g., "Why isn't my problem DCP?"), please use [StackOverflow](https://stackoverflow.com/questions/tagged/cvxpy) instead.
+
+## Community
+The CVXPY community consists of researchers, data scientists, software engineers, and students from all over the world. We welcome you to join us!
+
+* To chat with the CVXPY community in real-time, join us on [Discord](https://discord.gg/4urRQeGBCr).
+* To have longer, in-depth discussions with the CVXPY community, use [Github Discussions](https://github.com/cvxpy/cvxpy/discussions).
+* To share feature requests and bug reports, use [Github Issues](https://github.com/cvxpy/cvxpy/issues).
+
+Please be respectful in your communications with the CVXPY community, and make sure to abide by our [code of conduct](https://github.com/cvxpy/cvxpy/blob/master/CODE_OF_CONDUCT.md).
+
+## Contributing
+We appreciate all contributions. You don't need to be an expert in convex
+optimization to help out.
+
+You should first
+install [CVXPY from source](https://www.cvxpy.org/install/index.html#install-from-source).
+Here are some simple ways to start contributing immediately:
+* Read the CVXPY source code and improve the documentation, or address TODOs
+* Enhance the [website documentation](https://github.com/cvxpy/cvxpy/tree/master/doc)
+* Browse the [issue tracker](https://github.com/cvxpy/cvxpy/issues), and look for issues tagged as "help wanted"
+* Polish the [example library](https://github.com/cvxpy/examples)
+* Add a [benchmark](https://github.com/cvxpy/benchmarks)
+
+If you'd like to add a new example to our library, or implement a new feature,
+please get in touch with us first to make sure that your priorities align with
+ours. 
+
+Contributions should be submitted as [pull requests](https://github.com/cvxpy/cvxpy/pulls).
+A member of the CVXPY development team will review the pull request and guide
+you through the contributing process.
+
+Before starting work on your contribution, please read the [contributing guide](https://github.com/cvxpy/cvxpy/blob/master/CONTRIBUTING.md).
+
+## Team
+CVXPY is a community project, built from the contributions of many
+researchers and engineers.
+
+CVXPY is developed and maintained by [Steven
+Diamond](https://stevendiamond.me/), [Akshay
+Agrawal](https://akshayagrawal.com), [Riley Murray](https://rileyjmurray.wordpress.com/), 
+[Philipp Schiele](https://www.philippschiele.com/),
+[Bartolomeo Stellato](https://stellato.io/),
+and [Parth Nobel](https://ptnobel.github.io), with many others contributing
+significantly.
+A non-exhaustive list of people who have shaped CVXPY over the
+years includes Stephen Boyd, Eric Chu, Robin Verschueren,
+Jaehyun Park, Enzo Busseti, AJ Friend, Judson Wilson, Chris Dembia, and
+William Zhang.
 
----
-## Differentiation Engine
-DNLP uses [SparseDiffPy](https://github.com/SparseDifferentiation/SparseDiffPy) as its differentiation engine. SparseDiffPy is a Python wrapper around the [SparseDiffEngine](https://github.com/SparseDifferentiation/SparseDiffEngine) C library, and is installed automatically as a dependency of DNLP.
+For more information about the team and our processes, see our [governance document](https://github.com/cvxpy/org/blob/main/governance.md).
 
-SparseDiffPy builds an expression tree from the CVXPY problem and computes exact sparse gradients, Jacobians, and Hessians required by the NLP solvers.
+## Citing
+If you use CVXPY for academic work, we encourage you to [cite our papers](https://www.cvxpy.org/resources/citing/index.html). If you use CVXPY in industry, we'd love to hear from you as well, on Discord or over email.

cvxpy/__init__.py

@@ -109,6 +109,7 @@
     SOLVER_ERROR as SOLVER_ERROR,
     UNBOUNDED as UNBOUNDED,
     UNBOUNDED_INACCURATE as UNBOUNDED_INACCURATE,
+    UNO as UNO,
     USER_LIMIT as USER_LIMIT,
     XPRESS as XPRESS,
     HIGHS as HIGHS,

cvxpy/atoms/affine/affine_atom.py

@@ -113,54 +113,58 @@ def is_nsd(self) -> bool:
         return True
 
     def _grad(self, values) -> List[Any]:
-        """Computes the gradient of the affine atom w.r.t. each argument.
+        """Gives the (sub/super)gradient of the atom w.r.t. each argument.
 
-        For affine atoms, the gradient is constant and independent of argument values.
-        We compute it by constructing the canonical matrix representation and extracting
-        the linear coefficients.
+        Matrix expressions are vectorized, so the gradient is a matrix.
 
         Args:
-            values: Argument values (unused for affine atoms).
+            values: A list of numeric values for the arguments.
 
         Returns:
-            List of gradient matrices, one for each argument.
+            A list of SciPy CSC sparse matrices or None.
         """
-        # Create fake variables for each non-constant argument to build the linear system
+        # TODO should be a simple function in cvxcore for this.
+        # Make a fake lin op tree for the function.
         fake_args = []
         var_offsets = {}
-        var_length = 0
-        
+        offset = 0
         for idx, arg in enumerate(self.args):
             if arg.is_constant():
-                fake_args.append(Constant(arg.value).canonical_form[0])
+                fake_args += [Constant(arg.value).canonical_form[0]]
             else:
-                fake_args.append(lu.create_var(arg.shape, idx))
-                var_offsets[idx] = var_length
-                var_length += arg.size
-
-        # Get the canonical matrix representation: f(x) = Ax + b
-        fake_expr, _ = self.graph_implementation(fake_args, self.shape, self.get_data())
+                fake_args += [lu.create_var(arg.shape, idx)]
+                var_offsets[idx] = offset
+                offset += arg.size
+        var_length = offset
+        fake_expr, _ = self.graph_implementation(fake_args, self.shape,
+                                                 self.get_data())
+        param_to_size = {lo.CONSTANT_ID: 1}
+        param_to_col = {lo.CONSTANT_ID: 0}
+        # Get the matrix representation of the function.
         canon_mat = canonInterface.get_problem_matrix(
-            [fake_expr], var_length, var_offsets,
-            {lo.CONSTANT_ID: 1}, {lo.CONSTANT_ID: 0}, self.size
+            [fake_expr],
+            var_length,
+            var_offsets,
+            param_to_size,
+            param_to_col,
+            self.size,
         )
-
-        # Extract gradient matrix A (exclude constant offset b)
-        grad_matrix = canon_mat.reshape((var_length + 1, self.size)).tocsc()[:-1, :]
-
-        # Split gradients by argument
+        # HACK TODO TODO convert tensors back to vectors.
+        # COO = (V[lo.CONSTANT_ID][0], (J[lo.CONSTANT_ID][0], I[lo.CONSTANT_ID][0]))
+        shape = (var_length + 1, self.size)
+        stacked_grad = canon_mat.reshape(shape).tocsc()[:-1, :]
+        # Break up into per argument matrices.
         grad_list = []
-        var_start = 0
+        start = 0
         for arg in self.args:
             if arg.is_constant():
-                # Zero gradient for constants
-                grad_shape = (arg.size, self.size)
-                grad_list.append(0 if grad_shape == (1, 1) else 
-                               sp.coo_matrix(grad_shape, dtype='float64'))
+                grad_shape = (arg.size, shape[1])
+                if grad_shape == (1, 1):
+                    grad_list += [0]
+                else:
+                    grad_list += [sp.coo_matrix(grad_shape, dtype='float64')]
             else:
-                # Extract gradient block for this variable
-                var_end = var_start + arg.size
-                grad_list.append(grad_matrix[var_start:var_end, :])
-                var_start = var_end
-
+                stop = start + arg.size
+                grad_list += [stacked_grad[start:stop, :]]
+                start = stop
         return grad_list

cvxpy/expressions/leaf.py

@@ -669,11 +669,7 @@ def _validate_value(self, val, sparse_path=False):
                     attr_str = 'in bounds'
                 else:
                     attr_str = ([k for (k, v) in self.attributes.items() if v] + ['real'])[0]
-                if np.isnan(val).any() and self.variables():
-                    # necessary for NLP package extension and computing the structural jacobian
-                    # Only allow NaN for Variables, not Parameters
-                    return val
-                elif np.isnan(val).any():
+                if np.isnan(val).any():
                     raise ValueError(
                         "%s value must be real." % self.__class__.__name__
                     )

cvxpy/problems/objective.py

@@ -158,7 +158,7 @@ def is_dcp(self, dpp: bool = False) -> bool:
 
     def is_dnlp(self) -> bool:
         """
-        The objective must be epigraph smooth representable.
+        The objective must be linearizable convex.
         """
         return self.args[0].is_linearizable_convex()
 
@@ -235,7 +235,7 @@ def is_dcp(self, dpp: bool = False) -> bool:
 
     def is_dnlp(self) -> bool:
         """
-        The objective must be hypograph smooth representable.
+        The objective must be linearizable concave.
         """
         return self.args[0].is_linearizable_concave()