openscvx 0.5.3.dev50__tar.gz → 0.5.3.dev51__tar.gz

{openscvx-0.5.3.dev50/openscvx.egg-info → openscvx-0.5.3.dev51}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openscvx
-Version: 0.5.3.dev50
+Version: 0.5.3.dev51
 Summary: A general Python-based successive convexification implementation which uses a JAX backend.
 Author-email: Chris Hayner and Griffin Norris <haynec@uw.edu>
 License: Apache Software License

{openscvx-0.5.3.dev50 → openscvx-0.5.3.dev51}/docs/Foundations/discretization.md

@@ -91,4 +91,41 @@ def dVdt(self, tau: float, V: jnp.ndarray, u_cur: np.ndarray, u_next: np.ndarray
     )
     return dVdt.flatten()
 ```
-    
+
+## Supplying your own Jacobian
+
+The state and control Jacobians above (`dfdx`, `dfdu`) come from automatic
+differentiation of the dynamics you wrote. Occasionally the exact Jacobian is
+not the one you want: a drag law, a contact model, or a lookup table can be
+smooth enough to integrate while its true derivative makes the convex
+subproblem badly conditioned, so the trust region collapses and the SCP loop
+crawls. The standard remedy is to linearize with a deliberately simplified
+(inexact) Jacobian.
+
+`Expr.with_jacobian` applies that remedy to a single term:
+
+``` py
+drag = -0.5 * rho * ox.Norm(vel) * vel
+J_drag = -0.5 * rho * ox.Norm(vel) * np.eye(3)  # drops the d||v||/dv term
+
+dynamics = {"pos": vel, "vel": thrust / m + drag.with_jacobian({vel: J_drag})}
+```
+
+The keys are the `State` or `Control` objects the derivative is taken with
+respect to, and each value is an expression (or constant array) of shape
+`(*term.shape, *variable.shape)`. Directions you do not name are still
+differentiated automatically, so the example above hands over `∂/∂vel` while
+`∂/∂thrust` still comes from autodiff.
+
+The *value* of the term is untouched — only the search direction changes — so a
+converged trajectory still satisfies the original nonlinear dynamics; the
+defect and the propagated solution are computed with the term as written. An
+inexact Jacobian trades linearization accuracy (and hence convergence rate) for
+conditioning, so reach for it when a term is a known source of stiffness, not
+as a default.
+
+The override lives inside the lowered JAX function, so every downstream
+derivative picks it up: the discretizer's `A`/`B`, nonconvex constraint
+linearization, and the sparsity pattern used for coloring. It has no meaning
+inside a constraint that is handed to the convex solver as written, and lowering
+one there raises.

{openscvx-0.5.3.dev50 → openscvx-0.5.3.dev51}/openscvx/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.5.3.dev50'
-__version_tuple__ = version_tuple = (0, 5, 3, 'dev50')
+__version__ = version = '0.5.3.dev51'
+__version_tuple__ = version_tuple = (0, 5, 3, 'dev51')
 
-__commit_id__ = commit_id = 'g7ab51dee3'
+__commit_id__ = commit_id = 'g21d5581a4'

{openscvx-0.5.3.dev50 → openscvx-0.5.3.dev51}/openscvx/symbolic/expr/__init__.py

@@ -33,6 +33,11 @@ Module Organization:
         Array manipulation operations including `Index`, `Concat`, `Stack`, `Hstack`,
         and `Vstack` for indexing, slicing, and combining arrays.
 
+    User-Supplied Jacobians (autodiff.py):
+        `WithJacobian`, built by `Expr.with_jacobian`, replaces a subexpression's
+        derivative with respect to chosen variables — the inexact-Jacobian knob for
+        SCP conditioning.
+
     Constraints (constraint.py):
         Constraint types including `Constraint`, `Equality`, `Inequality`,
         `NodalConstraint`, and `CTCS` (Continuous-Time Constraint Satisfaction).
@@ -80,6 +85,9 @@ from .arithmetic import Add, Div, MatMul, Mul, Neg, Power, Sub
 # Array operations
 from .array import Block, Concat, Hstack, Index, Stack, Vstack
 
+# User-supplied Jacobians
+from .autodiff import WithJacobian
+
 # Specialized constraints
 from .constraint import (
     CTCS,
@@ -258,4 +266,6 @@ __all__ = [
     "ctcs",
     # Vmap
     "Vmap",
+    # User-supplied Jacobians
+    "WithJacobian",
 ]

openscvx-0.5.3.dev51/openscvx/symbolic/expr/autodiff.py

@@ -0,0 +1,159 @@
+"""User-supplied Jacobians for a subexpression.
+
+Successive convexification linearizes the dynamics and constraints at every
+iteration, so the *Jacobian* — not the value — is what shapes each convex
+subproblem. Occasionally the exact Jacobian is the wrong one to hand the
+solver: an aerodynamic drag term, a contact model, or a lookup table can be
+smooth enough to integrate but stiff enough that its true derivative wrecks the
+conditioning of the subproblem. The standard remedy is a deliberately
+simplified (inexact) Jacobian — the trajectory still converges to a solution of
+the *nonlinear* problem, because the value used for the defect is untouched;
+only the search direction changes.
+
+:class:`WithJacobian` is that remedy, written at sub-expression granularity::
+
+    drag = -0.5 * rho * ox.Norm(vel) * vel
+    accel = thrust / m + drag.with_jacobian({vel: J_drag})
+
+The node wraps a subexpression and carries an override Jacobian per variable.
+Lowering to JAX emits a :func:`jax.custom_jvp` rule around the wrapped
+subexpression, so every downstream differentiation — the discretizer's
+``jacfwd``, constraint linearization, sparse coloring — sees the user's
+Jacobian in the overridden directions and autodiff everywhere else, with no
+further special-casing. The primal value is always the wrapped expression
+itself.
+"""
+
+import hashlib
+from typing import Dict, List, Tuple
+
+import numpy as np
+
+from .expr import Expr, to_expr
+from .variable import Variable
+
+
+def _without_unit_axes(shape: Tuple[int, ...]) -> Tuple[int, ...]:
+    """Drop length-1 axes, the way :class:`Constant` squeezes a wrapped array."""
+    return tuple(d for d in shape if d != 1)
+
+
+class WithJacobian(Expr):
+    """A subexpression whose derivative w.r.t. chosen variables is user-supplied.
+
+    Construct this through :meth:`Expr.with_jacobian` rather than directly. The
+    node evaluates exactly like the expression it wraps; only differentiation
+    differs, and only in the overridden directions (see the module docstring for
+    the motivation).
+
+    Attributes:
+        expr: The wrapped expression, and the node's value.
+        overrides: ``(variable, jacobian)`` pairs in the order given, each
+            Jacobian shaped ``(*expr.shape, *variable.shape)``.
+    """
+
+    def __init__(self, expr: Expr, jacobians: Dict[Variable, Expr]):
+        """Wrap ``expr`` with an override Jacobian per variable.
+
+        Args:
+            expr: Expression whose derivative is being overridden.
+            jacobians: Map from a ``State`` or ``Control`` to the Jacobian of
+                ``expr`` with respect to it. Values are coerced with
+                :func:`to_expr`, so constant matrices are accepted.
+
+        Raises:
+            TypeError: If a key is not a decision variable.
+            ValueError: If no Jacobian is given.
+        """
+        if not jacobians:
+            raise ValueError(
+                "with_jacobian needs at least one {variable: jacobian} entry; an empty "
+                "mapping would wrap the expression without changing anything."
+            )
+        self.expr = to_expr(expr)
+        overrides = []
+        for var, jac in jacobians.items():
+            if not isinstance(var, Variable):
+                raise TypeError(
+                    f"with_jacobian keys must be the State or Control the derivative is "
+                    f"taken with respect to, got {type(var).__name__}. Write "
+                    f"`expr.with_jacobian({{vel: J_vel}})` with `vel` the variable itself."
+                )
+            overrides.append((var, to_expr(jac)))
+        self.overrides: List[Tuple[Variable, Expr]] = overrides
+
+    def children(self) -> List[Expr]:
+        """Return the wrapped expression followed by each override Jacobian.
+
+        The overridden variables are not children: they identify *directions*,
+        not operands, and appear as leaves inside the Jacobian expressions only
+        if the user put them there.
+        """
+        return [self.expr, *(jac for _, jac in self.overrides)]
+
+    def canonicalize(self) -> Expr:
+        """Canonicalize the wrapped expression and every override Jacobian."""
+        return WithJacobian(
+            self.expr.canonicalize(),
+            {var: jac.canonicalize() for var, jac in self.overrides},
+        )
+
+    def check_shape(self) -> Tuple[int, ...]:
+        """Return the wrapped expression's shape, validating each Jacobian.
+
+        A Jacobian must be shaped ``(*expr.shape, *var.shape)``. Unit axes are
+        ignored in the comparison: a constant is squeezed when it is wrapped, so
+        an honest ``(3, 1)`` Jacobian arrives as ``(3,)``. The JAX lowering
+        reshapes it back before contracting.
+
+        Returns:
+            The shape of the wrapped expression — the wrapper is value-transparent.
+
+        Raises:
+            ValueError: If a Jacobian's shape is not ``(*expr.shape, *var.shape)``.
+        """
+        shape = self.expr.check_shape()
+        for var, jac in self.overrides:
+            expected = (*shape, *var.shape)
+            got = jac.check_shape()
+            if _without_unit_axes(got) != _without_unit_axes(expected):
+                raise ValueError(
+                    f"Jacobian for {var.__class__.__name__} '{var.name}' has shape {got}, "
+                    f"expected {expected}: the derivative of an expression of shape "
+                    f"{shape} with respect to a variable of shape {var.shape}."
+                )
+        return shape
+
+    def sparsity(self, n_x: int, n_u: int) -> Tuple[np.ndarray, np.ndarray]:
+        """Conservative pattern: the children's, widened to the overridden columns.
+
+        The default union over children is not enough here. A user Jacobian may
+        be a constant (no dependence of its own) yet still couple outputs to
+        every entry of the overridden variable, so those columns are marked
+        dense on top of the children's pattern.
+        """
+        from .control import Control
+
+        S_x, S_u = super().sparsity(n_x, n_u)
+        for var, _ in self.overrides:
+            if var._slice is None:
+                continue
+            S = S_u if isinstance(var, Control) else S_x
+            S[:, var._slice] = True
+        return S_x, S_u
+
+    def _hash_into(self, hasher: "hashlib._Hash") -> None:
+        """Hash the wrapper, the wrapped expression, and each override in order.
+
+        Args:
+            hasher: A hashlib hash object to update
+        """
+        hasher.update(b"WithJacobian")
+        self.expr._hash_into(hasher)
+        for var, jac in self.overrides:
+            var._hash_into(hasher)
+            jac._hash_into(hasher)
+
+    def __repr__(self) -> str:
+        vars_ = ", ".join(var.name for var, _ in self.overrides)
+        return f"{self.expr!r}.with_jacobian({{{vars_}}})"

{openscvx-0.5.3.dev50 → openscvx-0.5.3.dev51}/openscvx/symbolic/expr/expr.py

@@ -308,6 +308,47 @@ class Expr:
         """
         return NodeReference(self, k)
 
+    def with_jacobian(self, jacobians: dict) -> "Expr":
+        """Override this expression's derivative w.r.t. chosen variables.
+
+        Successive convexification linearizes at every iteration, so the Jacobian
+        of a term — not its value — is what conditions the convex subproblem. A
+        deliberately simplified (inexact) Jacobian is a standard remedy for a term
+        that is smooth enough to integrate but whose true derivative makes the
+        subproblem badly conditioned. The value of the expression is untouched, so
+        the converged trajectory still satisfies the original nonlinear problem;
+        only the search direction changes.
+
+        Directions that are not overridden are still differentiated automatically,
+        so a single term can hand-specify its state Jacobian and let the control
+        Jacobian fall out of autodiff.
+
+        Args:
+            jacobians: Map from a ``State`` or ``Control`` to the Jacobian of this
+                expression with respect to it, shaped ``(*self.shape, *var.shape)``
+                (a variable of shape ``(n,)`` and a scalar expression give shape
+                ``(n,)``). Constant matrices are accepted alongside expressions.
+
+        Returns:
+            Expr: A ``WithJacobian`` node wrapping this expression.
+
+        Example:
+            Damp the drag Jacobian without changing the drag force:
+
+                drag = -0.5 * rho * ox.Norm(vel) * vel
+                J_drag = -0.5 * rho * ox.Norm(vel) * np.eye(3)  # drops the d|v|/dv term
+
+                dynamics = {"vel": thrust / m + drag.with_jacobian({vel: J_drag})}
+
+        Note:
+            The override applies on the JAX path — dynamics linearization and
+            constraint linearization. Inside a constraint lowered to CVXPy the
+            wrapper has no meaning and raises.
+        """
+        from .autodiff import WithJacobian
+
+        return WithJacobian(self, jacobians)
+
     def children(self) -> List["Expr"]:
         """Return the child expressions of this node.
 

{openscvx-0.5.3.dev50 → openscvx-0.5.3.dev51}/openscvx/symbolic/expr/variable.py

@@ -58,6 +58,12 @@ class Variable(Leaf):
     def __repr__(self) -> str:
         return f"Var({self.name!r})"
 
+    # ``Expr.__eq__`` builds an Equality constraint rather than comparing, which
+    # makes Python drop the inherited ``__hash__``. Variables are identities, not
+    # values, so restore hashing by identity: it lets a variable key a dict, as in
+    # ``expr.with_jacobian({vel: J_vel})``.
+    __hash__ = object.__hash__
+
     def _hash_into(self, hasher: "hashlib._Hash") -> None:
         """Hash Variable using its slice (canonical position, name-invariant).
 

{openscvx-0.5.3.dev50 → openscvx-0.5.3.dev51}/openscvx/symbolic/lowerers/cvxpy/__init__.py

@@ -22,6 +22,7 @@ Example::
 from openscvx.symbolic.lowerers.cvxpy import (
     arithmetic,  # noqa: F401
     array,  # noqa: F401
+    autodiff,  # noqa: F401
     constraint,  # noqa: F401
     control,  # noqa: F401
     expr,  # noqa: F401

openscvx-0.5.3.dev51/openscvx/symbolic/lowerers/cvxpy/autodiff.py

@@ -0,0 +1,36 @@
+"""CVXPy visitors for user-supplied Jacobians.
+
+Visitors: WithJacobian
+
+A ``WithJacobian`` override reshapes a *linearization*, and linearization happens
+on the JAX path. The convex subproblem sees convex constraints verbatim, with no
+derivative taken, so the wrapper has nothing to act on here and raises
+``NotImplementedError`` — the same treatment ``CTCS`` gets for being a
+JAX-side construct.
+"""
+
+import cvxpy as cp
+
+from openscvx.symbolic.expr.autodiff import WithJacobian
+from openscvx.symbolic.lowerers.cvxpy._registry import visitor  # noqa: F401
+
+
+@visitor(WithJacobian)
+def _visit_with_jacobian(lowerer, node: WithJacobian) -> cp.Expression:
+    """Raise NotImplementedError for a Jacobian override inside a convex constraint.
+
+    Args:
+        node: WithJacobian expression node
+
+    Raises:
+        NotImplementedError: Always — see the module docstring.
+    """
+    raise NotImplementedError(
+        "`.with_jacobian(...)` overrides the derivative used when a nonconvex "
+        "expression is linearized, which only happens on the JAX path (dynamics and "
+        "nonconvex constraints). This expression was lowered to CVXPy as part of a "
+        "convex constraint, which is passed to the solver as written and never "
+        "differentiated, so the override has no meaning here. Apply "
+        "`.with_jacobian(...)` to the nonconvex term instead, or drop it from this "
+        "constraint."
+    )

{openscvx-0.5.3.dev50 → openscvx-0.5.3.dev51}/openscvx/symbolic/lowerers/jax/__init__.py

@@ -23,6 +23,7 @@ Example::
 from openscvx.symbolic.lowerers.jax import (
     arithmetic,  # noqa: F401
     array,  # noqa: F401
+    autodiff,  # noqa: F401
     constraint,  # noqa: F401
     control,  # noqa: F401
     expr,  # noqa: F401

openscvx-0.5.3.dev51/openscvx/symbolic/lowerers/jax/autodiff.py

@@ -0,0 +1,82 @@
+"""JAX visitors for user-supplied Jacobians.
+
+Visitors: WithJacobian
+
+Lowers a ``WithJacobian`` node to its wrapped subexpression wrapped in a
+:func:`jax.custom_jvp` rule. The rule zeroes the tangent of every overridden
+variable before differentiating the inner function, then adds ``J @ dvar`` for
+each override — so overridden directions come from the user's Jacobian and all
+others from autodiff. Because the override lives inside the lowered function,
+every downstream differentiation (the discretizer's ``jacfwd``, constraint
+linearization, sparse coloring) picks it up with no further plumbing.
+
+Unlike the ``Vmap`` and ``Cond`` visitors, this one does not pause the value
+memo: the nested ``jax.jvp`` trace receives its own ``(x, u)`` tracers rather
+than reusing the captured outer ones, and the memo is keyed on all four
+arguments, so a value cached in one trace can never be handed to a caller in
+another.
+"""
+
+import jax
+import jax.numpy as jnp
+
+from openscvx.symbolic.expr.autodiff import WithJacobian
+from openscvx.symbolic.expr.control import Control
+from openscvx.symbolic.lowerers.jax._registry import visitor  # noqa: F401
+
+
+@visitor(WithJacobian)
+def _visit_with_jacobian(lowerer, node: WithJacobian):
+    """Lower a user-Jacobian override to a ``jax.custom_jvp``-wrapped function.
+
+    Args:
+        node: WithJacobian expression node
+
+    Returns:
+        Function (x, u, node, params) -> value of the wrapped expression, whose
+        derivative w.r.t. each overridden variable is the user's Jacobian.
+
+    Raises:
+        ValueError: If an overridden variable has no slice assigned (unification
+            not run).
+    """
+    inner = lowerer.lower(node.expr)
+    out_shape = node.expr.check_shape()
+    overrides = []
+    for var, jac in node.overrides:
+        if var._slice is None:
+            raise ValueError(f"{var.__class__.__name__} {var.name!r} has no slice assigned")
+        # Squeezed constants come back as e.g. () for a (1, 1) Jacobian, so the
+        # declared shape is restored before contracting with the tangent.
+        jac_shape = (*out_shape, *var.shape)
+        overrides.append((var._slice, isinstance(var, Control), lowerer.lower(jac), jac_shape))
+    overrides = tuple(overrides)
+
+    def with_jacobian_fn(x, u, node_idx, params):
+        def inner_xu(x_, u_):
+            return inner(x_, u_, node_idx, params)
+
+        f = jax.custom_jvp(inner_xu)
+
+        @f.defjvp
+        def _jvp(primals, tangents):
+            x_, u_ = primals
+            dx, du = tangents
+            # Autodiff supplies the non-overridden directions: blank the
+            # overridden slices so their contribution comes only from below.
+            dx_free, du_free = dx, du
+            for sl, is_control, _, _ in overrides:
+                if is_control:
+                    du_free = du_free.at[sl].set(0.0)
+                else:
+                    dx_free = dx_free.at[sl].set(0.0)
+            out, tangent = jax.jvp(inner_xu, (x_, u_), (dx_free, du_free))
+            for sl, is_control, jac_fn, jac_shape in overrides:
+                J = jnp.reshape(jac_fn(x_, u_, node_idx, params), jac_shape)
+                dvar = du[sl] if is_control else dx[sl]
+                tangent = tangent + jnp.tensordot(J, dvar, axes=1)
+            return out, tangent
+
+        return f(x, u)
+
+    return with_jacobian_fn

{openscvx-0.5.3.dev50 → openscvx-0.5.3.dev51}/openscvx/symbolic/lowerers/latex/__init__.py

@@ -27,6 +27,7 @@ Example::
 from openscvx.symbolic.lowerers.latex import (
     arithmetic,  # noqa: F401
     array,  # noqa: F401
+    autodiff,  # noqa: F401
     constraint,  # noqa: F401
     control,  # noqa: F401
     expr,  # noqa: F401

openscvx-0.5.3.dev51/openscvx/symbolic/lowerers/latex/autodiff.py

@@ -0,0 +1,17 @@
+"""LaTeX visitors for user-supplied Jacobians.
+
+Visitors: WithJacobian
+
+A Jacobian override changes how a term is differentiated, not what it equals, so
+the rendered formulation shows the wrapped expression alone — the same choice the
+``CTCS`` visitor makes in rendering the constraint it stands for.
+"""
+
+from openscvx.symbolic.expr.autodiff import WithJacobian
+from openscvx.symbolic.lowerers.latex._registry import visitor
+
+
+@visitor(WithJacobian)
+def _visit_with_jacobian(lowerer, node: WithJacobian):
+    """Render the wrapped expression; the override is invisible in the math."""
+    return lowerer.lower(node.expr)

{openscvx-0.5.3.dev50 → openscvx-0.5.3.dev51/openscvx.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openscvx
-Version: 0.5.3.dev50
+Version: 0.5.3.dev51
 Summary: A general Python-based successive convexification implementation which uses a JAX backend.
 Author-email: Chris Hayner and Griffin Norris <haynec@uw.edu>
 License: Apache Software License

{openscvx-0.5.3.dev50 → openscvx-0.5.3.dev51}/openscvx.egg-info/SOURCES.txt

@@ -281,6 +281,7 @@ openscvx/symbolic/unified.py
 openscvx/symbolic/expr/__init__.py
 openscvx/symbolic/expr/arithmetic.py
 openscvx/symbolic/expr/array.py
+openscvx/symbolic/expr/autodiff.py
 openscvx/symbolic/expr/constraint.py
 openscvx/symbolic/expr/control.py
 openscvx/symbolic/expr/expr.py
@@ -305,6 +306,7 @@ openscvx/symbolic/lowerers/cvxpy/_lowerer.py
 openscvx/symbolic/lowerers/cvxpy/_registry.py
 openscvx/symbolic/lowerers/cvxpy/arithmetic.py
 openscvx/symbolic/lowerers/cvxpy/array.py
+openscvx/symbolic/lowerers/cvxpy/autodiff.py
 openscvx/symbolic/lowerers/cvxpy/constraint.py
 openscvx/symbolic/lowerers/cvxpy/control.py
 openscvx/symbolic/lowerers/cvxpy/expr.py
@@ -317,6 +319,7 @@ openscvx/symbolic/lowerers/jax/_lowerer.py
 openscvx/symbolic/lowerers/jax/_registry.py
 openscvx/symbolic/lowerers/jax/arithmetic.py
 openscvx/symbolic/lowerers/jax/array.py
+openscvx/symbolic/lowerers/jax/autodiff.py
 openscvx/symbolic/lowerers/jax/constraint.py
 openscvx/symbolic/lowerers/jax/control.py
 openscvx/symbolic/lowerers/jax/expr.py
@@ -334,6 +337,7 @@ openscvx/symbolic/lowerers/latex/_lowerer.py
 openscvx/symbolic/lowerers/latex/_registry.py
 openscvx/symbolic/lowerers/latex/arithmetic.py
 openscvx/symbolic/lowerers/latex/array.py
+openscvx/symbolic/lowerers/latex/autodiff.py
 openscvx/symbolic/lowerers/latex/constraint.py
 openscvx/symbolic/lowerers/latex/control.py
 openscvx/symbolic/lowerers/latex/expr.py
@@ -438,6 +442,7 @@ tests/symbolic/test_unified.py
 tests/symbolic/expr/__init__.py
 tests/symbolic/expr/test_arithmetic.py
 tests/symbolic/expr/test_array.py
+tests/symbolic/expr/test_autodiff.py
 tests/symbolic/expr/test_constraint.py
 tests/symbolic/expr/test_expr.py
 tests/symbolic/expr/test_guess_expr.py

{openscvx-0.5.3.dev50 → openscvx-0.5.3.dev51}/openscvx.egg-info/scm_file_list.json

@@ -267,6 +267,7 @@
     "openscvx/symbolic/expr/__init__.py",
     "openscvx/symbolic/expr/arithmetic.py",
     "openscvx/symbolic/expr/array.py",
+    "openscvx/symbolic/expr/autodiff.py",
     "openscvx/symbolic/expr/constraint.py",
     "openscvx/symbolic/expr/control.py",
     "openscvx/symbolic/expr/expr.py",
@@ -293,6 +294,7 @@
     "openscvx/symbolic/lowerers/cvxpy/_registry.py",
     "openscvx/symbolic/lowerers/cvxpy/arithmetic.py",
     "openscvx/symbolic/lowerers/cvxpy/array.py",
+    "openscvx/symbolic/lowerers/cvxpy/autodiff.py",
     "openscvx/symbolic/lowerers/cvxpy/constraint.py",
     "openscvx/symbolic/lowerers/cvxpy/control.py",
     "openscvx/symbolic/lowerers/cvxpy/expr.py",
@@ -305,6 +307,7 @@
     "openscvx/symbolic/lowerers/jax/_registry.py",
     "openscvx/symbolic/lowerers/jax/arithmetic.py",
     "openscvx/symbolic/lowerers/jax/array.py",
+    "openscvx/symbolic/lowerers/jax/autodiff.py",
     "openscvx/symbolic/lowerers/jax/constraint.py",
     "openscvx/symbolic/lowerers/jax/control.py",
     "openscvx/symbolic/lowerers/jax/expr.py",
@@ -322,6 +325,7 @@
     "openscvx/symbolic/lowerers/latex/_registry.py",
     "openscvx/symbolic/lowerers/latex/arithmetic.py",
     "openscvx/symbolic/lowerers/latex/array.py",
+    "openscvx/symbolic/lowerers/latex/autodiff.py",
     "openscvx/symbolic/lowerers/latex/constraint.py",
     "openscvx/symbolic/lowerers/latex/control.py",
     "openscvx/symbolic/lowerers/latex/expr.py",
@@ -406,6 +410,7 @@
     "tests/symbolic/expr/__init__.py",
     "tests/symbolic/expr/test_arithmetic.py",
     "tests/symbolic/expr/test_array.py",
+    "tests/symbolic/expr/test_autodiff.py",
     "tests/symbolic/expr/test_constraint.py",
     "tests/symbolic/expr/test_expr.py",
     "tests/symbolic/expr/test_guess_expr.py",

{openscvx-0.5.3.dev50 → openscvx-0.5.3.dev51}/openscvx.egg-info/scm_version.json

@@ -1,7 +1,7 @@
 {
   "tag": "0.5.2",
-  "distance": 50,
-  "node": "g7ab51dee32e9703abaf0ae5471aff63949bc7c5f",
+  "distance": 51,
+  "node": "g21d5581a44e245dad63fdc59c19bcf78abce2ef3",
   "dirty": false,
   "branch": "main",
   "node_date": "2026-08-15"