Rename ESR/HSR to linearizable_convex/linearizable_concave

Spell out opaque acronyms for clarity per PR review feedback:
is_atom_esr → is_atom_linearizable_convex,
is_atom_hsr → is_atom_linearizable_concave,
is_esr → is_linearizable_convex, is_hsr → is_linearizable_concave,
is_smooth → is_linearizable.

Docstrings clarify that "linearizable convex" means the expression is
convex after linearizing all smooth subexpressions.

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

Author: Transurgeon

CLAUDE.md

@@ -76,13 +76,15 @@ prob.solve(nlp=True, solver=cp.IPOPT, best_of=5)
 - Target Python version: 3.11+
 - Line length: 100 characters
 - **IMPORTANT: IMPORTS AT THE TOP** of files - circular imports are the only exception
+- Ruff excludes all `*__init__.py` files (configured in `pyproject.toml`)
+- Pre-commit hooks include: ruff (with `--fix`), check-jsonschema (GitHub workflows/dependabot), actionlint, and validate-pyproject
 
 ## License Header
 
-New files should include the Apache 2.0 license header:
+New files should include the Apache 2.0 license header (matching the convention used in the majority of the codebase):
 ```python
 """
-Copyright 2025, the CVXPY developers
+Copyright, the CVXPY authors
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
@@ -129,6 +131,8 @@ Key reduction classes in `cvxpy/reductions/`:
 
 For DNLP: `CvxAttr2Constr` → `Dnlp2Smooth` → `NLPSolver`
 
+Note: The standard `SolvingChain` in `solving_chain.py` handles DCP/DGP/DQCP solver selection automatically. NLP solving is triggered explicitly via `prob.solve(nlp=True)` and bypasses the standard chain.
+
 ### Solver Categories
 
 - **ConicSolvers** (`cvxpy/reductions/solvers/conic_solvers/`) - SCS, Clarabel, ECOS, etc.
@@ -142,12 +146,20 @@ The NLP infrastructure provides oracle-based interfaces for nonlinear solvers:
   - `Bounds` class: extracts variable/constraint bounds from problem
   - `Oracles` class: provides function and derivative oracles (objective, gradient, constraints, jacobian, hessian)
 - `dnlp2smooth.py` - Transforms DNLP problems to smooth form via `Dnlp2Smooth` reduction
-- DNLP validation: expressions must be smooth (ESR and HSR)
+- DNLP validation: expressions must be linearizable (linearizable convex and linearizable concave)
 - Problem validity checked via `problem.is_dnlp()` method
 
 ### Diff Engine (SparseDiffPy)
 
-The automatic differentiation engine is provided by the [SparseDiffPy](https://github.com/SparseDifferentiation/SparseDiffPy) package (`pip install sparsediffpy`), which wraps the [SparseDiffEngine](https://github.com/SparseDifferentiation/SparseDiffEngine) C library. It builds expression trees from CVXPY problems and computes derivatives (gradients, Jacobians, Hessians) for NLP solvers. New diff engine atoms require C-level additions in SparseDiffPy.
+The automatic differentiation engine is provided by the [SparseDiffPy](https://github.com/SparseDifferentiation/SparseDiffPy) package (installed automatically as a hard dependency), which wraps the [SparseDiffEngine](https://github.com/SparseDifferentiation/SparseDiffEngine) C library. It builds expression trees from CVXPY problems and computes derivatives (gradients, Jacobians, Hessians) for NLP solvers.
+
+Adding a new diff engine atom requires:
+1. C-level implementation in SparseDiffPy
+2. Python-side converter in `cvxpy/reductions/solvers/nlp_solvers/diff_engine/converters.py` (add to `ATOM_CONVERTERS` dict)
+
+The diff engine supports CVXPY `Parameter` objects: `C_problem` registers parameters with the C engine and `update_params()` re-pushes values without rebuilding the expression tree. Sparse parameter values are fused into sparse matmul operations.
+
+`DerivativeChecker` in `nlp_solver.py` provides finite-difference verification of gradients, Jacobians, and Hessians during development.
 
 ## Implementing New Atoms
 
@@ -164,15 +176,15 @@ The automatic differentiation engine is provided by the [SparseDiffPy](https://g
 1. Create a canonicalizer in `cvxpy/reductions/dnlp2smooth/canonicalizers/`
 2. The canonicalizer converts non-smooth atoms to smooth equivalents using auxiliary variables
 3. Register in `canonicalizers/__init__.py` by adding to `SMOOTH_CANON_METHODS` dict
-4. Ensure the atom has proper `is_smooth()`, `is_esr()`, `is_hsr()` methods
+4. Ensure the atom has proper `is_linearizable()`, `is_linearizable_convex()`, `is_linearizable_concave()` methods
 
-### DNLP Rules (ESR/HSR)
+### DNLP Rules (Linearizable Convex / Linearizable Concave)
 
-- **Smooth**: functions that are both ESR and HSR (analogous to affine in DCP)
-- **ESR** (Essentially Smooth Respecting): can be minimized or appear in `<= 0` constraints
-- **HSR** (Hierarchically Smooth Respecting): can be maximized or appear in `>= 0` constraints
+- **Linearizable**: functions that are both linearizable convex and linearizable concave (analogous to affine in DCP)
+- **Linearizable Convex**: can be minimized or appear in `<= 0` constraints
+- **Linearizable Concave**: can be maximized or appear in `>= 0` constraints
 
-Use `expr.is_smooth()`, `expr.is_esr()`, `expr.is_hsr()` to check expression properties.
+Use `expr.is_linearizable()`, `expr.is_linearizable_convex()`, `expr.is_linearizable_concave()` to check expression properties.
 
 ## Testing
 
@@ -192,3 +204,12 @@ class TestMyFeature(BaseTest):
 ```
 
 NLP tests are in `cvxpy/tests/nlp_tests/` with Jacobian and Hessian verification tests.
+
+## Benchmarks
+
+Benchmarks use [Airspeed Velocity](https://asv.readthedocs.io/) and live in the `benchmarks/` directory. To run locally:
+```bash
+cd benchmarks
+pip install -e .
+asv run
+```

cvxpy/atoms/affine/affine_atom.py

@@ -57,13 +57,13 @@ def is_atom_concave(self) -> bool:
         """
         return True
 
-    def is_atom_esr(self) -> bool:
-        """Is the atom esr?
+    def is_atom_linearizable_convex(self) -> bool:
+        """Is the atom convex after linearizing?
         """
         return True
 
-    def is_atom_hsr(self) -> bool:
-        """Is the atom hsr?
+    def is_atom_linearizable_concave(self) -> bool:
+        """Is the atom concave after linearizing?
         """
         return True
 

cvxpy/atoms/atom.py

@@ -188,16 +188,16 @@ def is_atom_affine(self) -> bool:
         """
         return self.is_atom_concave() and self.is_atom_convex()
 
-    def is_atom_esr(self) -> bool:
-        """Is the atom esr?
+    def is_atom_linearizable_convex(self) -> bool:
+        """Is the atom convex after linearizing?
         """
-        raise NotImplementedError("is_atom_esr not implemented for %s."
+        raise NotImplementedError("is_atom_linearizable_convex not implemented for %s."
                                    % self.__class__.__name__)
 
-    def is_atom_hsr(self) -> bool:
-        """Is the atom hsr?
+    def is_atom_linearizable_concave(self) -> bool:
+        """Is the atom concave after linearizing?
         """
-        raise NotImplementedError("is_atom_hsr not implemented for %s."
+        raise NotImplementedError("is_atom_linearizable_concave not implemented for %s."
                                    % self.__class__.__name__)
 
     def is_atom_log_log_convex(self) -> bool:
@@ -272,34 +272,34 @@ def is_concave(self) -> bool:
             return False
 
     @perf.compute_once
-    def is_esr(self) -> bool:
-        """Is the expression epigraph smooth representable?
+    def is_linearizable_convex(self) -> bool:
+        """Is the expression convex after linearizing all smooth subexpressions?
         """
         # Applies DNLP composition rule.
         if self.is_constant():
             return True
-        elif self.is_atom_esr():
+        elif self.is_atom_linearizable_convex():
             for idx, arg in enumerate(self.args):
-                if not (arg.is_smooth() or
-                        (arg.is_esr() and self.is_incr(idx)) or
-                        (arg.is_hsr() and self.is_decr(idx))):
+                if not (arg.is_linearizable() or
+                        (arg.is_linearizable_convex() and self.is_incr(idx)) or
+                        (arg.is_linearizable_concave() and self.is_decr(idx))):
                     return False
             return True
         else:
             return False
 
     @perf.compute_once
-    def is_hsr(self) -> bool:
-        """Is the expression hypograph smooth representable?
+    def is_linearizable_concave(self) -> bool:
+        """Is the expression concave after linearizing all smooth subexpressions?
         """
         # Applies DNLP composition rule.
         if self.is_constant():
             return True
-        elif self.is_atom_hsr():
+        elif self.is_atom_linearizable_concave():
             for idx, arg in enumerate(self.args):
-                if not (arg.is_smooth() or
-                        (arg.is_hsr() and self.is_incr(idx)) or
-                        (arg.is_esr() and self.is_decr(idx))):
+                if not (arg.is_linearizable() or
+                        (arg.is_linearizable_concave() and self.is_incr(idx)) or
+                        (arg.is_linearizable_convex() and self.is_decr(idx))):
                     return False
             return True
         else:

cvxpy/atoms/elementwise/abs.py

@@ -56,13 +56,13 @@ def is_atom_concave(self) -> bool:
         """
         return False
 
-    def is_atom_esr(self) -> bool:
-        """Is the atom esr?
+    def is_atom_linearizable_convex(self) -> bool:
+        """Is the atom convex after linearizing?
         """
         return True
 
-    def is_atom_hsr(self) -> bool:
-        """Is the atom hsr?
+    def is_atom_linearizable_concave(self) -> bool:
+        """Is the atom concave after linearizing?
         """
         return False
 

cvxpy/atoms/elementwise/entr.py

@@ -58,13 +58,13 @@ def is_atom_concave(self) -> bool:
         """
         return True
 
-    def is_atom_esr(self) -> bool:
-        """Is the atom esr?
+    def is_atom_linearizable_convex(self) -> bool:
+        """Is the atom convex after linearizing?
         """
         return True
 
-    def is_atom_hsr(self) -> bool:
-        """Is the atom hsr?
+    def is_atom_linearizable_concave(self) -> bool:
+        """Is the atom concave after linearizing?
         """
         return True
 

cvxpy/atoms/elementwise/exp.py

@@ -55,13 +55,13 @@ def is_atom_concave(self) -> bool:
         """
         return False
 
-    def is_atom_esr(self) -> bool:
-        """Is the atom esr?
+    def is_atom_linearizable_convex(self) -> bool:
+        """Is the atom convex after linearizing?
         """
         return True
 
-    def is_atom_hsr(self) -> bool:
-        """Is the atom hsr?
+    def is_atom_linearizable_concave(self) -> bool:
+        """Is the atom concave after linearizing?
         """
         return True
 

cvxpy/atoms/elementwise/huber.py

@@ -71,13 +71,13 @@ def is_atom_concave(self) -> bool:
         """Is the atom concave?"""
         return False
 
-    def is_atom_esr(self) -> bool:
-        """Is the atom esr?
+    def is_atom_linearizable_convex(self) -> bool:
+        """Is the atom convex after linearizing?
         """
         return True
 
-    def is_atom_hsr(self) -> bool:
-        """Is the atom hsr?
+    def is_atom_linearizable_concave(self) -> bool:
+        """Is the atom concave after linearizing?
         """
         return False
 

cvxpy/atoms/elementwise/hyperbolic.py

@@ -50,13 +50,13 @@ def is_atom_concave(self) -> bool:
         """
         return False
 
-    def is_atom_esr(self) -> bool:
-        """Is the atom esr?
+    def is_atom_linearizable_convex(self) -> bool:
+        """Is the atom convex after linearizing?
         """
         return True
 
-    def is_atom_hsr(self) -> bool:
-        """Is the atom hsr?
+    def is_atom_linearizable_concave(self) -> bool:
+        """Is the atom concave after linearizing?
         """
         return True
 
@@ -108,13 +108,13 @@ def is_atom_concave(self) -> bool:
         """
         return False
 
-    def is_atom_esr(self) -> bool:
-        """Is the atom esr?
+    def is_atom_linearizable_convex(self) -> bool:
+        """Is the atom convex after linearizing?
         """
         return True
 
-    def is_atom_hsr(self) -> bool:
-        """Is the atom hsr?
+    def is_atom_linearizable_concave(self) -> bool:
+        """Is the atom concave after linearizing?
         """
         return True
 
@@ -160,10 +160,10 @@ def is_atom_convex(self) -> bool:
     def is_atom_concave(self) -> bool:
         return False
 
-    def is_atom_esr(self) -> bool:
+    def is_atom_linearizable_convex(self) -> bool:
         return True
 
-    def is_atom_hsr(self) -> bool:
+    def is_atom_linearizable_concave(self) -> bool:
         return True
 
     def is_incr(self, idx) -> bool:
@@ -202,10 +202,10 @@ def is_atom_convex(self) -> bool:
     def is_atom_concave(self) -> bool:
         return False
 
-    def is_atom_esr(self) -> bool:
+    def is_atom_linearizable_convex(self) -> bool:
         return True
 
-    def is_atom_hsr(self) -> bool:
+    def is_atom_linearizable_concave(self) -> bool:
         return True
 
     def is_incr(self, idx) -> bool:

cvxpy/atoms/elementwise/kl_div.py

@@ -55,13 +55,13 @@ def is_atom_concave(self) -> bool:
         """
         return False
 
-    def is_atom_esr(self) -> bool:
-        """Is the atom esr?
+    def is_atom_linearizable_convex(self) -> bool:
+        """Is the atom convex after linearizing?
         """
         return True
 
-    def is_atom_hsr(self) -> bool:
-        """Is the atom hsr?
+    def is_atom_linearizable_concave(self) -> bool:
+        """Is the atom concave after linearizing?
         """
         return True
 

cvxpy/atoms/elementwise/log.py

@@ -56,13 +56,13 @@ def is_atom_concave(self) -> bool:
         """
         return True
 
-    def is_atom_esr(self) -> bool:
-        """Is the atom esr?
+    def is_atom_linearizable_convex(self) -> bool:
+        """Is the atom convex after linearizing?
         """
         return True
 
-    def is_atom_hsr(self) -> bool:
-        """Is the atom hsr?
+    def is_atom_linearizable_concave(self) -> bool:
+        """Is the atom concave after linearizing?
         """
         return True