openscvx 0.5.3.dev30__py3-none-any.whl → 0.5.3.dev32__py3-none-any.whl

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.dev30'
-__version_tuple__ = version_tuple = (0, 5, 3, 'dev30')
+__version__ = version = '0.5.3.dev32'
+__version_tuple__ = version_tuple = (0, 5, 3, 'dev32')
 
-__commit_id__ = commit_id = None
+__commit_id__ = commit_id = 'gd1964080e'

openscvx/algorithms/__init__.py

@@ -52,7 +52,12 @@ from .autotuner import (
 )
 from .autotuner.base import AutotuningBase
 from .base import Algorithm
-from .history import AlgorithmHistory, DiscretizationResult
+from .history import (
+    AlgorithmHistory,
+    DiscretizationResult,
+    MultishotPropagation,
+    unpack_multishot_V,
+)
 from .hyperparams import HyperParams
 from .optimization_results import OptimizationResults
 from .scvx import PenalizedTrustRegion
@@ -145,6 +150,8 @@ __all__ = [
     "CandidateIterate",
     "adaptive_state_code_to_str",
     "DiscretizationResult",
+    "MultishotPropagation",
+    "unpack_multishot_V",
     "Weights",
     # Core results
     "OptimizationResults",

openscvx/algorithms/autotuner/augmented_lagrangian.py

@@ -206,7 +206,7 @@ class AugmentedLagrangian(AcceptanceRatioAutotuner):
 
         for idx, constraint in enumerate(nodal_constraints.nodal):
             g = constraint.func(candidate.x, candidate.u, 0, params)
-            nu = jnp.maximum(0.0, g)
+            nu = jnp.abs(g) if constraint.is_equality else jnp.maximum(0.0, g)
 
             if constraint.nodes is not None:
                 nodes_array = jnp.asarray(constraint.nodes)
@@ -245,7 +245,7 @@ class AugmentedLagrangian(AcceptanceRatioAutotuner):
 
         for idx, constraint in enumerate(nodal_constraints.cross_node):
             g = constraint.func(candidate.x, candidate.u, params)
-            nu = jnp.sum(jnp.maximum(0.0, g))
+            nu = jnp.sum(jnp.abs(g) if constraint.is_equality else jnp.maximum(0.0, g))
             current = state.lam_vb_cross[idx]
             case1 = current + nu * scale
             case2 = current + (nu**2) / state.hyper.ep * scale

openscvx/algorithms/history.py

@@ -1,16 +1,21 @@
-"""CPU-side append-only iteration log for SCP algorithms.
+"""CPU-side append-only iteration log and discretization read helpers for SCP.
 
 :class:`AlgorithmHistory` is the mutable, host-side container the SCP loop grows
 after each iteration via :py:meth:`~AlgorithmHistory.record_iteration` — it
 never crosses the JAX boundary. :class:`DiscretizationResult` unpacks a raw
 discretization matrix once so history reads are trivial slicing-free access.
+:class:`MultishotPropagation` complements :class:`DiscretizationResult` by
+exposing the full substep state trajectories stored during multishot
+discretization.
 
 Last in the algorithms import order: it depends on
 :mod:`openscvx.algorithms.state` and nothing here depends on it.
 """
 
+from __future__ import annotations
+
 from dataclasses import dataclass, field
-from typing import TYPE_CHECKING, List, Optional, Tuple, Union
+from typing import TYPE_CHECKING, List, Optional, Sequence, Tuple, Union
 
 import jax
 import numpy as np
@@ -19,6 +24,9 @@ from .state import AdaptiveStateCode, AlgorithmState, adaptive_state_code_to_str
 
 if TYPE_CHECKING:
     from openscvx.config import Config
+    from openscvx.symbolic.expr.state import State
+
+StateLike = Union[str, "State"]
 
 
 @dataclass(frozen=True, slots=True)
@@ -92,6 +100,150 @@ class DiscretizationResult:
         )
 
 
+# ---------------------------------------------------------------------------
+# Multishot propagation — read-side helpers for integration matrix V
+# ---------------------------------------------------------------------------
+
+
+def _resolve_state_slice(name_or_state: StateLike, states: Sequence) -> slice:
+    from openscvx.symbolic.expr.state import State
+
+    if isinstance(name_or_state, State):
+        if name_or_state._slice is None:
+            raise ValueError(f"State {name_or_state.name!r} has no slice assigned")
+        return name_or_state._slice
+    for state in states:
+        if state.name == name_or_state:
+            if state._slice is None:
+                raise ValueError(f"State {name_or_state!r} has no slice assigned")
+            return state._slice
+    available = sorted({state.name for state in states})
+    raise KeyError(f"Unknown state {name_or_state!r}. Available: {available}")
+
+
+def segment_size(n_x: int, n_u: int) -> int:
+    """Packed row count per multishot segment (state + STM + sensitivities)."""
+    return n_x + n_x * n_x + 2 * n_x * n_u
+
+
+@dataclass(frozen=True)
+class MultishotPropagation:
+    """Unpacked SCP multishot integration matrix ``V``.
+
+    ``V`` shape: ``(n_segments * segment_size, n_substeps)`` where
+    ``segment_size = n_x + n_x**2 + 2 * n_x * n_u``.
+    """
+
+    V: np.ndarray
+    n_x: int
+    n_u: int
+    t_nodes: np.ndarray
+    states: tuple = ()
+
+    @property
+    def segment_size(self) -> int:
+        return segment_size(self.n_x, self.n_u)
+
+    @property
+    def n_segments(self) -> int:
+        return int(self.V.shape[0] // self.segment_size)
+
+    @property
+    def n_substeps(self) -> int:
+        return int(self.V.shape[1])
+
+    def segment_states(self, seg_idx: int) -> np.ndarray:
+        """Integrated states for one segment, shape ``(n_substeps, n_x)``."""
+        seg_start = seg_idx * self.segment_size
+        rows = self.V[seg_start : seg_start + self.n_x, :]
+        return np.asarray(rows, dtype=np.float64).T
+
+    def segments(self) -> list[np.ndarray]:
+        """All segment state arrays, each shape ``(n_substeps, n_x)``."""
+        return [self.segment_states(seg_idx) for seg_idx in range(self.n_segments)]
+
+    def chronological(self) -> tuple[np.ndarray, np.ndarray]:
+        """Time-ordered stitched full states and times.
+
+        Skips duplicated segment-boundary samples (``j0 = 0`` on seg 0, else ``1``).
+
+        Returns:
+            ``states`` — ``(n_samples, n_x)``
+            ``t`` — ``(n_samples,)``, linearly interpolated within each segment
+        """
+        t_nodes = np.asarray(self.t_nodes, dtype=np.float64).ravel()
+        n_sub = self.n_substeps
+        state_rows: list[np.ndarray] = []
+        t_rows: list[float] = []
+        for seg_idx in range(self.n_segments):
+            t0, t1 = float(t_nodes[seg_idx]), float(t_nodes[seg_idx + 1])
+            j0 = 0 if seg_idx == 0 else 1
+            for j in range(j0, n_sub):
+                alpha = j / (n_sub - 1) if n_sub > 1 else 0.0
+                state_rows.append(self.segment_states(seg_idx)[j])
+                t_rows.append((1.0 - alpha) * t0 + alpha * t1)
+        if not state_rows:
+            return np.empty((0, self.n_x), dtype=np.float64), np.empty(0, dtype=np.float64)
+        return np.stack(state_rows, axis=0), np.asarray(t_rows, dtype=np.float64)
+
+    def state(self, name_or_state: StateLike) -> tuple[np.ndarray, np.ndarray]:
+        """Chronological trajectory for one symbolic state.
+
+        ``name_or_state`` may be a :class:`~openscvx.symbolic.expr.state.State`
+        instance or a string name matching ``State.name`` in ``self.states``.
+        """
+        state_slice = _resolve_state_slice(name_or_state, self.states)
+        return self.slice_states(state_slice)
+
+    def slice_states(self, state_slice: slice) -> tuple[np.ndarray, np.ndarray]:
+        """``chronological()`` then apply ``state_slice`` to the state dimension."""
+        states, t = self.chronological()
+        return states[:, state_slice], t
+
+
+def unpack_multishot_V(
+    V: np.ndarray,
+    *,
+    n_x: int,
+    n_u: int,
+    t_nodes: np.ndarray,
+    states: Sequence = (),
+) -> MultishotPropagation:
+    """Validate ``V`` layout and return :class:`MultishotPropagation`.
+
+    Raises:
+        ValueError: invalid ``V`` shape, empty matrix, or ``len(t_nodes) != n_segments + 1``.
+    """
+    V = np.asarray(V, dtype=np.float64)
+    if V.size == 0:
+        raise ValueError("multishot V matrix is empty")
+    seg_size = segment_size(n_x, n_u)
+    if seg_size <= 0:
+        raise ValueError(f"invalid multishot dimensions n_x={n_x}, n_u={n_u}")
+    n_rows, n_sub = V.shape
+    if n_sub < 1:
+        raise ValueError("multishot V must have at least one substep column")
+    if n_rows % seg_size != 0:
+        raise ValueError(
+            f"multishot V row count {n_rows} is not divisible by segment_size {seg_size}"
+        )
+    n_segments = n_rows // seg_size
+    t_nodes_arr = np.asarray(t_nodes, dtype=np.float64).ravel()
+    if len(t_nodes_arr) != n_segments + 1:
+        raise ValueError(
+            f"multishot t_nodes length {len(t_nodes_arr)} != n_segments + 1 "
+            f"({n_segments + 1}); pass optimization node times from "
+            "results.nodes['time'] or an explicit array."
+        )
+    return MultishotPropagation(
+        V=V,
+        n_x=n_x,
+        n_u=n_u,
+        t_nodes=t_nodes_arr,
+        states=tuple(states),
+    )
+
+
 # ---------------------------------------------------------------------------
 # AlgorithmHistory — CPU-side append-only iteration log
 # ---------------------------------------------------------------------------

openscvx/algorithms/optimization_results.py

@@ -7,7 +7,7 @@ import jax.numpy as jnp
 import numpy as np
 
 if TYPE_CHECKING:
-    from openscvx.algorithms.history import AlgorithmHistory
+    from openscvx.algorithms.history import AlgorithmHistory, MultishotPropagation
     from openscvx.algorithms.state import AlgorithmState
     from openscvx.problem import Problem
 
@@ -180,6 +180,36 @@ class OptimizationResults:
         """
         return self.U[-1]
 
+    def multishot_propagation(
+        self,
+        iteration: int = -1,
+        *,
+        t_nodes: Optional[np.ndarray] = None,
+    ) -> Optional["MultishotPropagation"]:
+        """Return unpacked multishot data for SCP iteration ``iteration`` (default: final).
+
+        Returns ``None`` when ``discretization_history`` is empty (e.g. ``solve_jax``).
+
+        Attaches ``self._states`` so ``.state("q")`` works without passing slices manually.
+        """
+        from openscvx.algorithms.history import unpack_multishot_V
+
+        dh = self.discretization_history
+        if not dh:
+            return None
+        V = np.asarray(dh[iteration], dtype=np.float64)
+        n_x, n_u = self.x.shape[1], self.u.shape[1]
+        if t_nodes is None:
+            t_nodes_raw = self.nodes.get("time")
+            if t_nodes_raw is None:
+                t_final = float(self.t_final)
+                t_nodes = np.linspace(0.0, t_final, self.x.shape[0])
+            else:
+                t_nodes = np.asarray(t_nodes_raw, dtype=np.float64).ravel()
+        return unpack_multishot_V(
+            V, n_x=n_x, n_u=n_u, t_nodes=t_nodes, states=tuple(self._states or ())
+        )
+
     # Post-processing results (added by propagate_trajectory_results)
     t_full: Optional[np.ndarray] = field(default=None, metadata={"npz": "optional_array"})
     x_full: Optional[np.ndarray] = field(default=None, metadata={"npz": "optional_array"})

openscvx/algorithms/penalty.py

@@ -96,12 +96,14 @@ def calculate_nonlinear_penalty(
         else:
             g_filtered = g
             w = lam_vb_nodal[:, idx]
-        nodal_penalty = nodal_penalty + jnp.sum(w * jnp.maximum(0.0, g_filtered))
+        viol = jnp.abs(g_filtered) if constraint.is_equality else jnp.maximum(0.0, g_filtered)
+        nodal_penalty = nodal_penalty + jnp.sum(w * viol)
 
     for idx, constraint in enumerate(nodal_constraints.cross_node):
         w = lam_vb_cross[idx]
         g = constraint.func(x_bar, u_bar, params)
-        nodal_penalty = nodal_penalty + w * jnp.sum(jnp.maximum(0.0, g))
+        viol = jnp.abs(g) if constraint.is_equality else jnp.maximum(0.0, g)
+        nodal_penalty = nodal_penalty + w * jnp.sum(viol)
 
     cost = calculate_cost_from_state(x_bar, settings, lam_cost)
     x_diff = settings.sim.inv_S_x @ (x_bar[1:, :] - x_prop).T

openscvx/algorithms/scvx/iteration.py

@@ -145,6 +145,11 @@ def make_scp_iteration(
     n_u = settings.sim.n_controls
     n_nodal = len(jax_constraints.nodal)
 
+    # Equality columns measure violation two-sided (|nu_vb|); inequalities use
+    # the positive part. Built once at trace time as static boolean masks.
+    nodal_eq_mask = jnp.asarray([c.is_equality for c in jax_constraints.nodal], dtype=bool)
+    cross_eq_mask = jnp.asarray([c.is_equality for c in jax_constraints.cross_node], dtype=bool)
+
     # Accept either a bare ``jax.jit`` callable or a ``jax.export`` wrapper.
     dis_continuous = dis_continuous.call if hasattr(dis_continuous, "call") else dis_continuous
     dis_impulsive = dis_impulsive.call if hasattr(dis_impulsive, "call") else dis_impulsive
@@ -311,9 +316,13 @@ def make_scp_iteration(
         VC = jnp.abs(inv_S_x @ solution.nu.T).T
         J_tr = jnp.sum(TR**2)
         J_vc = jnp.sum(VC)
-        J_vb = jnp.sum(jnp.maximum(0.0, solution.nu_vb)) + jnp.sum(
-            jnp.maximum(0.0, solution.nu_vb_cross)
+        nodal_vb = jnp.where(
+            nodal_eq_mask, jnp.abs(solution.nu_vb), jnp.maximum(0.0, solution.nu_vb)
+        )
+        cross_vb = jnp.where(
+            cross_eq_mask, jnp.abs(solution.nu_vb_cross), jnp.maximum(0.0, solution.nu_vb_cross)
         )
+        J_vb = jnp.sum(nodal_vb) + jnp.sum(cross_vb)
         state = state.replace(
             J_tr=jnp.asarray(J_tr, dtype=state.J_tr.dtype),
             J_vb=jnp.asarray(J_vb, dtype=state.J_vb.dtype),

openscvx/lowered/jax_constraints.py

@@ -37,12 +37,19 @@ class LoweredNodalConstraint:
 
         nodes (Optional[List[int]]): List of node indices where this constraint applies.
             Set after lowering from NodalConstraint.
+
+        is_equality (bool): True if the source constraint was an ``Equality``
+            (``g == 0``), False for an ``Inequality`` (``g <= 0``). Controls the
+            virtual-buffer penalty shape downstream: equalities are penalized
+            two-sided (``|nu_vb|``), inequalities one-sided (``pos(nu_vb)``).
+            Defaults to False, preserving the inequality behavior.
     """
 
     func: Callable[[jnp.ndarray, jnp.ndarray], jnp.ndarray]
     grad_g_x: Optional[Callable[[jnp.ndarray, jnp.ndarray], jnp.ndarray]] = None
     grad_g_u: Optional[Callable[[jnp.ndarray, jnp.ndarray], jnp.ndarray]] = None
     nodes: Optional[List[int]] = None
+    is_equality: bool = False
 
 
 @dataclass
@@ -110,6 +117,7 @@ class LoweredCrossNodeConstraint:
     func: Callable[[jnp.ndarray, jnp.ndarray, dict], jnp.ndarray]
     grad_g_X: Callable[[jnp.ndarray, jnp.ndarray, dict], jnp.ndarray]
     grad_g_U: Callable[[jnp.ndarray, jnp.ndarray, dict], jnp.ndarray]
+    is_equality: bool = False
 
 
 @dataclass

openscvx/plotting/scp_iteration.py

@@ -102,12 +102,14 @@ def plot_scp_iterations(
     V_history = result.discretization_history if result.discretization_history else []
     X_prop_history = []
     if V_history and show_propagation:
-        i4 = n_x + n_x * n_x + 2 * n_x * n_u
+        from openscvx.algorithms.history import unpack_multishot_V
+
         for V in V_history:
-            pos_traj = []
-            for i_multi in range(V.shape[1]):
-                pos_traj.append(V[:, i_multi].reshape(-1, i4)[:, :n_x])
-            X_prop_history.append(np.array(pos_traj))
+            n_segments = V.shape[0] // (n_x + n_x * n_x + 2 * n_x * n_u)
+            placeholder_t = np.linspace(0.0, 1.0, n_segments + 1)
+            prop = unpack_multishot_V(V, n_x=n_x, n_u=n_u, t_nodes=placeholder_t, states=())
+            segs = prop.segments()
+            X_prop_history.append(np.stack(segs, axis=1))
 
     n_iterations = len(result.X)
     if X_prop_history:

openscvx/plotting/viser/scp.py

@@ -209,8 +209,8 @@ def extract_propagation_positions(
 
     The discretization history contains the multi-shot integration results.
     Each V matrix has shape (flattened_size, n_timesteps) where:
-    - flattened_size = (N-1) * i4
-    - i4 = n_x + n_x*n_x + 2*n_x*n_u (state + STM + control influence matrices)
+    - flattened_size = (N-1) * segment_size
+    - segment_size = n_x + n_x*n_x + 2*n_x*n_u (state + STM + control influence matrices)
     - n_timesteps = number of integration substeps
 
     Args:
@@ -224,35 +224,18 @@ def extract_propagation_positions(
         List of propagation trajectories per iteration.
         Each iteration contains a list of (n_substeps, 3) arrays, one per segment.
     """
+    from openscvx.algorithms.history import unpack_multishot_V
+
     if not discretization_history:
         return []
 
-    i4 = n_x + n_x * n_x + 2 * n_x * n_u
     propagations = []
-
     for V in discretization_history:
-        # V shape: (flattened_size, n_timesteps)
-        n_timesteps = V.shape[1]
-        n_segments = V.shape[0] // i4  # N-1 segments
-
-        iteration_segments = []
-        for seg_idx in range(n_segments):
-            # Extract this segment's data across all timesteps
-            seg_start = seg_idx * i4
-            seg_end = seg_start + i4
-
-            # For each timestep, extract the position from the state
-            segment_positions = []
-            for t_idx in range(n_timesteps):
-                # Get full state at this segment and timestep
-                state = V[seg_start:seg_end, t_idx][:n_x]
-                # Extract position components
-                pos = state[position_slice] / scene_scale
-                segment_positions.append(pos)
-
-            iteration_segments.append(np.array(segment_positions, dtype=np.float32))
-
-        propagations.append(iteration_segments)
+        n_segments = V.shape[0] // (n_x + n_x * n_x + 2 * n_x * n_u)
+        placeholder_t = np.linspace(0.0, 1.0, n_segments + 1)
+        prop = unpack_multishot_V(V, n_x=n_x, n_u=n_u, t_nodes=placeholder_t, states=())
+        iteration_segments = [seg[:, position_slice] / scene_scale for seg in prop.segments()]
+        propagations.append([np.asarray(seg, dtype=np.float32) for seg in iteration_segments])
 
     return propagations
 

openscvx/solvers/cvxpy_ptr_solver.py

@@ -490,18 +490,21 @@ class CVXPyPTRSolver(PTRSolver):
         # Virtual Control Slack
         cost += sum(cp.sum(lam_vc[i - 1] * cp.abs(nu[i - 1])) for i in range(1, settings.sim.n))
 
-        # Virtual buffer penalty for nodal constraints (per-node weighting)
+        # Virtual buffer penalty for nodal constraints (per-node weighting).
+        # Equalities penalize |nu_vb|, inequalities penalize pos(nu_vb).
         idx_ncvx = 0
         if jax_constraints.nodal:
             for constraint in jax_constraints.nodal:
-                cost += lam_vb_nodal[:, idx_ncvx] @ cp.pos(nu_vb[idx_ncvx])
+                pen = cp.abs if constraint.is_equality else cp.pos
+                cost += lam_vb_nodal[:, idx_ncvx] @ pen(nu_vb[idx_ncvx])
                 idx_ncvx += 1
 
         # Virtual slack penalty for cross-node constraints
         idx_cross = 0
         if jax_constraints.cross_node:
             for constraint in jax_constraints.cross_node:
-                cost += lam_vb_cross[idx_cross] * cp.pos(nu_vb_cross[idx_cross])
+                pen = cp.abs if constraint.is_equality else cp.pos
+                cost += lam_vb_cross[idx_cross] * pen(nu_vb_cross[idx_cross])
                 idx_cross += 1
 
         return cost

openscvx/solvers/moreau_ptr_solver.py

@@ -490,6 +490,12 @@ class MoreauPTRSolver(PTRSolver):
         self._c_u_j = jnp.asarray(self._c_u, dtype=f)
         self._jax_dtype = f
 
+        if any(c.is_equality for c in jax_constraints.nodal):
+            raise NotImplementedError(
+                "MoreauPTRSolver does not support L1-penalized equality "
+                "constraints. Use CVXPyPTRSolver."
+            )
+
         self.layout = _ConicLayout(N=N, n_x=n_x, n_u=n_u, n_nodal=len(jax_constraints.nodal))
         self._jax_constraints = jax_constraints
         self._x_unified = x_unified

openscvx/solvers/qpax_ptr_solver.py

@@ -329,6 +329,12 @@ class QPAXPTRSolver(PTRSolver):
         self._c_u_j = jnp.asarray(self._c_u, dtype=f)
         self._jax_dtype = f
 
+        if any(c.is_equality for c in jax_constraints.nodal):
+            raise NotImplementedError(
+                "QPAXPTRSolver does not support L1-penalized equality "
+                "constraints. Use CVXPyPTRSolver."
+            )
+
         self.layout = _QPLayout(N=N, n_x=n_x, n_u=n_u, n_nodal=len(jax_constraints.nodal))
         self._jax_constraints = jax_constraints
         self._x_unified = x_unified

openscvx/symbolic/augmentation.py

@@ -75,30 +75,6 @@ from openscvx.symbolic.expr.state import State
 from openscvx.symbolic.expr.time import Time
 
 
-def _check_nonconvex_equality(constraint: Constraint, context: str) -> None:
-    """Raise a helpful error if constraint is a non-convex equality.
-
-    Non-convex equality constraints are not supported.
-
-    Args:
-        constraint: The constraint to check
-        context: Description of where this constraint appears (for error message)
-
-    Raises:
-        ValueError: If constraint is an Equality and not marked as convex
-    """
-    if isinstance(constraint, Equality) and not constraint.is_convex:
-        raise ValueError(
-            f"Non-convex equality constraint in {context}. "
-            f"Equality constraints must be affine (linear) and marked as convex "
-            f"using .convex(). For example:\n"
-            f"    (velocity.at(0) == velocity.at(n-1)).convex()\n"
-            f"If your equality constraint is nonlinear, consider reformulating it "
-            f"as two inequality constraints or using a different approach.\n"
-            f"Constraint: {constraint}"
-        )
-
-
 def sort_ctcs_constraints(
     constraints_ctcs: List[CTCS],
 ) -> Tuple[List[CTCS], List[Tuple[int, int]], int]:
@@ -265,9 +241,6 @@ def separate_constraints(constraint_set: ConstraintSet, n_nodes: int) -> Constra
                     f"Constraint: {c.constraint}"
                 )
 
-            # Check for non-convex equality constraints
-            _check_nonconvex_equality(c.constraint, "nodal constraint")
-
             # Regular nodal constraint - categorize by convexity
             if c.constraint.is_convex:
                 constraint_set.nodal_convex.append(c)
@@ -277,9 +250,6 @@ def separate_constraints(constraint_set: ConstraintSet, n_nodes: int) -> Constra
         elif isinstance(c, Constraint):
             # Bare constraint - check if it's a cross-node constraint
             if _contains_node_reference(c):
-                # Check for non-convex equality constraints
-                _check_nonconvex_equality(c, "cross-node constraint")
-
                 # Cross-node constraint: wrap in CrossNodeConstraint
                 cross_node = CrossNodeConstraint(c)
                 if c.is_convex:
@@ -287,9 +257,6 @@ def separate_constraints(constraint_set: ConstraintSet, n_nodes: int) -> Constra
                 else:
                     constraint_set.cross_node.append(cross_node)
             else:
-                # Check for non-convex equality constraints
-                _check_nonconvex_equality(c, "nodal constraint")
-
                 # Regular constraint: apply at all nodes
                 all_nodes = list(range(n_nodes))
                 nodal_constraint = NodalConstraint(c, all_nodes)
@@ -310,9 +277,6 @@ def separate_constraints(constraint_set: ConstraintSet, n_nodes: int) -> Constra
     # Add nodal constraints from CTCS constraints that have check_nodally=True
     ctcs_nodal_constraints = get_nodal_constraints_from_ctcs(constraint_set.ctcs)
     for constraint, interval in ctcs_nodal_constraints:
-        # Check for non-convex equality constraints
-        _check_nonconvex_equality(constraint, "CTCS check_nodally constraint")
-
         # CTCS check_nodally constraints cannot have NodeReferences (validated above)
         # Convert CTCS interval (start, end) to list of nodes [start, start+1, ..., end-1]
         interval_nodes = list(range(interval[0], interval[1]))

openscvx/symbolic/lower.py

@@ -73,7 +73,7 @@ from openscvx.lowered import (
     LoweredProblem,
 )
 from openscvx.symbolic.constraint_set import ConstraintSet
-from openscvx.symbolic.expr import Expr, NodeReference, traverse
+from openscvx.symbolic.expr import Equality, Expr, NodeReference, traverse
 from openscvx.symbolic.expr.control import Control
 from openscvx.symbolic.unified import unify_controls, unify_states
 
@@ -628,6 +628,7 @@ def _lower_jax_constraints(
                 grad_g_x=jax.vmap(jacfwd(fn, argnums=0), in_axes=(0, 0, None, None)),
                 grad_g_u=jax.vmap(jacfwd(fn, argnums=1), in_axes=(0, 0, None, None)),
                 nodes=constraints.nodal[i].nodes,
+                is_equality=isinstance(constraints.nodal[i].constraint, Equality),
             )
             lowered_nodal.append(constraint)
 
@@ -644,6 +645,7 @@ def _lower_jax_constraints(
             func=constraint_fn,
             grad_g_X=grad_g_X,
             grad_g_U=grad_g_U,
+            is_equality=isinstance(cross_node_constraint.constraint, Equality),
         )
         lowered_cross_node.append(cross_node_lowered)
 

{openscvx-0.5.3.dev30.dist-info → openscvx-0.5.3.dev32.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openscvx
-Version: 0.5.3.dev30
+Version: 0.5.3.dev32
 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.dev30.dist-info → openscvx-0.5.3.dev32.dist-info}/RECORD

@@ -1,27 +1,27 @@
 openscvx/__init__.py,sha256=sxiqBoS5jv9UmNSxnrokFXeFMnDSkAxUCtC4X-s-vHk,4456
 openscvx/__main__.py,sha256=Hwm7mtVg3tLdvoUPkpcQv8KF3wxl72PNLBp9axFu8GY,2991
-openscvx/_version.py,sha256=948RKF_zwogF4wPVyRjlc14TbZVtWn-Pjer2jbbmK6Y,535
+openscvx/_version.py,sha256=Z4316e4iRgR9n9GBJeiTH0nozaVh11apRsu9LgCQnWE,543
 openscvx/config.py,sha256=qfDDYoCe6WqJglKsx5b2W48YOglXenKr-PVRRdCFhYE,9898
 openscvx/loader.py,sha256=5WDLVA6CQxnyi1pRBfP8jQQc0r8RiAM2O_ItKgMXxAk,7660
 openscvx/problem.py,sha256=0hsAdpj74XXsYfOn8VBPzjCpO3mH5bSzHOwpezIBiYY,96230
-openscvx/algorithms/__init__.py,sha256=6J0ip07ec06q0kzPdrh74Wcnro3PGx0X1eGHRXcQfv8,5528
+openscvx/algorithms/__init__.py,sha256=xEB2sZ_fFbQUSOJY4hOzsZe0cdCuD5LawvrF4fzSt8E,5645
 openscvx/algorithms/base.py,sha256=jMneNL5lc-qg24vvcGQ4NP93d71boRiUGh6uKBykOlM,11638
-openscvx/algorithms/history.py,sha256=-Ltrf9VT45nWhrLZ4-PI7JlK1QhP4vGrFd6OhLwoh0U,11716
+openscvx/algorithms/history.py,sha256=aAS3VWT5d4kfsIl5a34YFYglHayPqn0hZGmhXVGbE0g,17456
 openscvx/algorithms/hyperparams.py,sha256=BmNDHerJ-eWi5wO5aryXMSe9jDzLsMxXNcCSeNHOCYY,4560
 openscvx/algorithms/loop.py,sha256=S03KlW_z4hWdrP50rfEzWmDRaOOl7XHmlzImpkKXGX4,3927
-openscvx/algorithms/optimization_results.py,sha256=wpo9-DtsBqrYkNvIGfEbAsff5dGENtmNDIh6FD3YuIQ,22421
-openscvx/algorithms/penalty.py,sha256=zDhp0t7tl9UshaMWeI-WfheZ3YkYr3nn_WyE7ZRpaX8,4196
+openscvx/algorithms/optimization_results.py,sha256=TVZVeoUpbAmEILmxFrLZz0GT9ze4Apzwm_tXfpBOPjQ,23614
+openscvx/algorithms/penalty.py,sha256=sqfH11bVr-ZG1VUUA4FjF6ETYDuA06ZXiOAvxBPBcts,4329
 openscvx/algorithms/state.py,sha256=-ooDqgPezM-GwcWj8Y4q7yB_GQGjlvVucIeGbl8271Q,15787
 openscvx/algorithms/weights.py,sha256=DQV9NOR_-59lISv6d_el3cpQ-EcFasSGb1oZr4ma-yA,20682
 openscvx/algorithms/autotuner/__init__.py,sha256=ZVALKx4lEgIazIQP8-doSi6VIdy9YxUaTiQ1L0C551o,769
 openscvx/algorithms/autotuner/acceptance_ratio.py,sha256=yP7LnnWBQ6ea9dX3JMkJAlt_VWHvBpsaxk_7i0vA0Nk,9422
 openscvx/algorithms/autotuner/adaptive_proximal_weight.py,sha256=HgnJfrx8Mue-dN63jIw9hwn465HjFD8wgzNc7TuLvqQ,2436
-openscvx/algorithms/autotuner/augmented_lagrangian.py,sha256=1VmzYzJdTMDKdgv8yIpbsAu-13imIkc16dD-V_jVKWg,11762
+openscvx/algorithms/autotuner/augmented_lagrangian.py,sha256=yaBev93800giRBcDXldoDNNmzoTXhYAw-HREDILip1I,11846
 openscvx/algorithms/autotuner/base.py,sha256=mKV9r7GoxA07e0jXZwWeu00b6z7D6p1m3EAoqPA70Qw,12771
 openscvx/algorithms/autotuner/constant_proximal_weight.py,sha256=xM6Ruxo6INtaV0HcLZuHqgRukl4p3Dzoo6jcxJHS_b4,2858
 openscvx/algorithms/autotuner/ramp_proximal_weight.py,sha256=hcJnKCR6CBC8tDlT03p7GC2pQkkaVAueM-bO8kaSj-I,3276
 openscvx/algorithms/scvx/__init__.py,sha256=uhMalFKvygm7s7LGYwKKg_a8qeKioM92E74o-b8nN2U,154
-openscvx/algorithms/scvx/iteration.py,sha256=zfGWeV-0PArEIz_EK5whAMGvhucwgedR20Fc2M1UHlM,14979
+openscvx/algorithms/scvx/iteration.py,sha256=PTVKaXJ76uTSszHhEB9GVhmWZrp5DtnOBjUYCUR-Oow,15509
 openscvx/algorithms/scvx/penalized_trust_region.py,sha256=JBIH8ASwv70Sih4Dh9Wh1ILEv5Ykou80UJSN7RsHRcA,12572
 openscvx/discretization/__init__.py,sha256=lDMVvJMuaP3s78IqwQ2N-BmPPp7_vnll-TX5cU3ezlo,2799
 openscvx/discretization/base.py,sha256=bxjfPk_IGyWDcgooUFHNN9AZFJk5VOLw9Sb1IP6sZw0,10373
@@ -51,21 +51,21 @@ openscvx/lowered/__init__.py,sha256=P1xtMVkXWa3uz4tiJeTllurwGFeugdwxqU8h0Mt6uTo,
 openscvx/lowered/cvxpy_constraints.py,sha256=CcgJLweSJEeNGfD21HUjHdNbBcvHhNejhq0gncU7lP0,846
 openscvx/lowered/cvxpy_variables.py,sha256=4ZHZzun6X7m7KZeNrNj2e8-rYaqAdYZgmT8jT7XqGgU,5593
 openscvx/lowered/dynamics.py,sha256=EzgzQmOnFJoBUC6sMPJSJo_9Nb1IO8D51bsb6prZSSk,2400
-openscvx/lowered/jax_constraints.py,sha256=9h96qKx_ZbK35S6OpvmthsI55FAk3-kdx3TVjSKiCVk,6063
+openscvx/lowered/jax_constraints.py,sha256=7QL_KSsCWmYvTjbE5P3HPkC-_HuLjQxjCJCYt_h8Aao,6506
 openscvx/lowered/parameters.py,sha256=F01f08EKaRMHG_5eO0AXGWsDjaQ1qDJDq9gJSD1SawQ,1992
 openscvx/lowered/problem.py,sha256=r4Zgw2MMAOmk1K0j-5J2GkYrsSoC9Q3WfU14HFJFLZQ,2689
 openscvx/lowered/unified.py,sha256=6PxwCi-cNRYqwAkEBE9HmXL8dpRNP6fVK0u3PymVMxc,41761
 openscvx/plotting/__init__.py,sha256=SadvlFghMOCYSzY8Oz95ttw_MrGMZZfobQ8SZyGtIck,3396
 openscvx/plotting/plotting.py,sha256=1mNIbeuV-VE1VYPep2O7Y77A08k5aeS--ypjUOsv7aU,32608
 openscvx/plotting/publication.py,sha256=-htOFrdJoSKtGSfJ_qeexRndNQZEJUMXakIEQhh1_fA,22171
-openscvx/plotting/scp_iteration.py,sha256=2EpP1tC1HJNu_Drkrj6ieORqktv0YybhLZQDJAKX8w8,21650
+openscvx/plotting/scp_iteration.py,sha256=9zs4IcYkmLP1_vb0RN16_miwEebzrHfHq7BhrZLikt0,21800
 openscvx/plotting/viser/__init__.py,sha256=9y9tD8AdwJi8gICYrMn_KoT-K50XtlXl6ZwHDIUg-6o,4160
 openscvx/plotting/viser/animated.py,sha256=ymm3voHn5-i6nb9Indr5oU79c8MlAVJz7VMddAdTv4s,27541
 openscvx/plotting/viser/coordinates.py,sha256=KoZmD7aLM5cAS2GbDVdnjXqnE36voWmGfo8IEZDZPXY,643
 openscvx/plotting/viser/orbits.py,sha256=oh3ss8TX9rezxCRJ-l8YJQVA6dVwxolae_MWgQi6Lk4,2989
 openscvx/plotting/viser/plotly_integration.py,sha256=UUpiqdLAax-1WzPt2Z6CBPMxw7Qk_tP9YN9KTeVUhII,12229
 openscvx/plotting/viser/primitives.py,sha256=k8Y7hGtK5miSzbiROOVagdCipcLDcXKVwFO_9qc5zPM,11574
-openscvx/plotting/viser/scp.py,sha256=WTGhjg11Qsy-PjDirGt_0U83GKTedVLmkN5Qt54VaFk,16103
+openscvx/plotting/viser/scp.py,sha256=VBguWdgYlJdY1As_bOcLx19Rjc9g4_qs4uadjKMS90c,15652
 openscvx/plotting/viser/server.py,sha256=rRRHDejVTcqWCkKO1EgwezEcmFktiqqx1YwAE3WfMR8,4156
 openscvx/propagation/__init__.py,sha256=XjlOoEwgo2Vow0uW0mMCcLIN53VzFBnSuer3ZzPqnbk,1851
 openscvx/propagation/post_processing.py,sha256=vsPbTj0EMkSgoEBEvjU5QBRNS7YyL5R4KPXjLDatV80,7731
@@ -73,18 +73,18 @@ openscvx/propagation/propagation.py,sha256=RZlAKBSHfp4XLMxHbzk6YXGgyBFv8sxsyBqdh
 openscvx/solvers/__init__.py,sha256=TCEAag4hzzluzNj3sUNOMdxtbDxHp2WJEzzGQVmxrI0,3715
 openscvx/solvers/base.py,sha256=1LOYRAbnFh2uQJk-SRqHV4U1Meu6ycPmZnkMahlqRb4,17469
 openscvx/solvers/cones.py,sha256=h2_ssdTIiFTCVEkCPXLTUZ1zQIRz0XCvQbSr2bWfoww,3491
-openscvx/solvers/cvxpy_ptr_solver.py,sha256=_ytZK-3oP7eCiygt3goRJ1ecKY8zlHySgYi9OjoVKLs,53886
-openscvx/solvers/moreau_ptr_solver.py,sha256=7tQyC-2rlx6HwVLFnroXPdTmTyrK4cPq76DRdU2YgLE,84315
+openscvx/solvers/cvxpy_ptr_solver.py,sha256=AiXMsUIR16otjC8sH6DnJSAHwPKFTkvdA4ObxsX7OFg,54088
+openscvx/solvers/moreau_ptr_solver.py,sha256=L5066qrLxlxlIej2AvOfn-4iPBCU56hrV6zcutgmF8E,84556
 openscvx/solvers/ptr_solver.py,sha256=ve72jPObf9NlaXXTKw16KjvNbAgBy7ntkenrlkrabYo,26212
-openscvx/solvers/qpax_ptr_solver.py,sha256=J28O96tj4FCg_OSPZhJM_H20ezIG9L5VXZLpfoZuE4U,67749
+openscvx/solvers/qpax_ptr_solver.py,sha256=m8kgmhWNQrqOWj8d-1QdPj-PfxaUKtzxuunI0Wsdlyo,67988
 openscvx/symbolic/__init__.py,sha256=aBwrKg6OnmbDL9pma9k4G009QWCOjM2Lmt_6MZPF7I4,294
 openscvx/symbolic/affine.py,sha256=42erm6azKMf8QCgaG2tULevZtw5PEScw4wLvpneCy_k,6935
-openscvx/symbolic/augmentation.py,sha256=qZWpcFenJawRM_VIRZmoJtYOLErx0jmb8eLvSf_xCvI,29555
+openscvx/symbolic/augmentation.py,sha256=vl29NH_4hkqETLb75CgH0GyFEtQjioLuuACLiGqmRg4,28036
 openscvx/symbolic/builder.py,sha256=ivkPY9tecg6KEgguEuOHknh_FRabWXlCUjXrnWuiwe0,24631
 openscvx/symbolic/canonicalize.py,sha256=htZBm648a1nmeRcm3hJlND1Z99IXpxUKF74L2TOi8gc,11079
 openscvx/symbolic/constraint_set.py,sha256=HtLKmXvji9B47l1jzd5fEJSAFAKX93vyzDwux1xxayM,3476
 openscvx/symbolic/hashing.py,sha256=OLSwuqFal9tKKtMxLAM9HBGb1bo5vzo-DG7srSy21lI,4686
-openscvx/symbolic/lower.py,sha256=6st0ANLBJTtDnjpCCgY9yaTQK9T1wUvrGoQJGdTxiKA,31662
+openscvx/symbolic/lower.py,sha256=ebP6KUQETEIt-SNcEGe08zSvp3fXh8pTBVA_Q6JBITk,31835
 openscvx/symbolic/preprocessing.py,sha256=Sqy_i5ntGWXdxcJCvql_034ZWoYU-kBRPEX34wgB344,36318
 openscvx/symbolic/problem.py,sha256=TblK3Z0orLaI_6_uPBVZP4SMxTSFXnUfNb0SICR-vFg,4853
 openscvx/symbolic/sparsity.py,sha256=9CVvvOz3FiBSMKL7TAcrq9FzMIis8m3iOq0URXWO0F8,5973
@@ -159,9 +159,11 @@ openscvx/utils/caching.py,sha256=Uw2e0G1UNn_vmMDqUZGszIH-O9LJhR4wdVKSPToHiy0,169
 openscvx/utils/printing.py,sha256=dsccZ9sXc3TBWShQvBg1Al4UFGMP77ApblfxteEJHLQ,16515
 openscvx/utils/profiling.py,sha256=k2x-i0CpG_kRe6dNcNBGu-ylrOtQw4B4C1UaOTjUMfU,1678
 openscvx/utils/utils.py,sha256=M25RHE_7DSr3Reaca0xCXnDSY9KHuqYvXdh5m1ZotEc,3047
-openscvx-0.5.3.dev30.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-openscvx-0.5.3.dev30.dist-info/METADATA,sha256=Wekkm0U_c5btIvskOAM8F0FTieyEhOsz33poVFhnLVA,10924
-openscvx-0.5.3.dev30.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
-openscvx-0.5.3.dev30.dist-info/entry_points.txt,sha256=1Oqek8Sy28hmAZFgZXDxFXYVf56YLYWlHjhh9RYJ7wE,52
-openscvx-0.5.3.dev30.dist-info/top_level.txt,sha256=nUT4Ybefzh40H8tVXqc1RzKESy_MAowElb-CIvAbd4Q,9
-openscvx-0.5.3.dev30.dist-info/RECORD,,
+openscvx-0.5.3.dev32.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+openscvx-0.5.3.dev32.dist-info/METADATA,sha256=XXhrDLUkvtNt4WmXaTzoH9bCMVCALAKXrNaka2XPFbw,10924
+openscvx-0.5.3.dev32.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+openscvx-0.5.3.dev32.dist-info/entry_points.txt,sha256=1Oqek8Sy28hmAZFgZXDxFXYVf56YLYWlHjhh9RYJ7wE,52
+openscvx-0.5.3.dev32.dist-info/scm_file_list.json,sha256=P96pyN84uItLcscnhrCP38tuIysoml65tPPFBc4xp7w,17957
+openscvx-0.5.3.dev32.dist-info/scm_version.json,sha256=z2WLKMlWjAoff2oDizDMr-sKCqbNuFSWdST4g_wFCkI,161
+openscvx-0.5.3.dev32.dist-info/top_level.txt,sha256=nUT4Ybefzh40H8tVXqc1RzKESy_MAowElb-CIvAbd4Q,9
+openscvx-0.5.3.dev32.dist-info/RECORD,,

openscvx-0.5.3.dev32.dist-info/scm_file_list.json

@@ -0,0 +1,423 @@
+{
+  "files": [
+    "README.md",
+    ".gitmodules",
+    "LICENSE",
+    "pyproject.toml",
+    "mkdocs.yml",
+    "CONTRIBUTING.md",
+    ".gitignore",
+    "scripts/gen_example_pages.py",
+    "scripts/gen_ref_pages.py",
+    "scripts/mkdocs_copy_viser_client_hook.py",
+    "docs/examples.md",
+    "docs/citation.md",
+    "docs/versions.json",
+    "docs/index.md",
+    "docs/Foundations/time_dilation.md",
+    "docs/Foundations/scvx.md",
+    "docs/Foundations/control_parameterization.md",
+    "docs/Foundations/constraint_reformulation.md",
+    "docs/Foundations/ocp.md",
+    "docs/Foundations/discretization.md",
+    "docs/UnderTheHood/vectorization_and_vmapping.md",
+    "docs/UnderTheHood/custom_algorithms_autotuners.md",
+    "docs/UnderTheHood/lowering_architecture.md",
+    "docs/UnderTheHood/batching_jit_grad.md",
+    "docs/assets/openscvx_logo_square.png",
+    "docs/assets/favicon.png",
+    "docs/assets/logo.svg",
+    "docs/assets/viser-client/index.html",
+    "docs/assets/images/ct-scvx_light.png",
+    "docs/assets/images/problem_class_light.png",
+    "docs/assets/images/problem_class_dark.png",
+    "docs/assets/images/ctcs_light.png",
+    "docs/assets/images/ct-scvx_dark.png",
+    "docs/assets/images/ctcs_dark.png",
+    "docs/assets/viser-recordings/franka_fr3v2_pick_place.viser",
+    "docs/assets/viser-recordings/drone_racing.viser",
+    "docs/javascripts/mathjax.js",
+    "docs/UsersGuide/04_viewpoint_constraints.md",
+    "docs/UsersGuide/05_visualization.md",
+    "docs/UsersGuide/03_obstacle_avoidance_vmap.md",
+    "docs/UsersGuide/09_mjx_dynamics.md",
+    "docs/UsersGuide/07_lie.md",
+    "docs/UsersGuide/06_logic.md",
+    "docs/UsersGuide/01_hello_world_brachistochrone.md",
+    "docs/UsersGuide/00_introduction.md",
+    "docs/UsersGuide/02_drone_racing_constraints.md",
+    "docs/UsersGuide/08_mpcc.md",
+    "openscvx/__init__.py",
+    "openscvx/config.py",
+    "openscvx/loader.py",
+    "openscvx/problem.py",
+    "openscvx/__main__.py",
+    "openscvx/discretization/__init__.py",
+    "openscvx/discretization/discretize_linearize.py",
+    "openscvx/discretization/linearize_discretize_sparse.py",
+    "openscvx/discretization/linearize_discretize.py",
+    "openscvx/discretization/base.py",
+    "openscvx/discretization/sparse_utils/__init__.py",
+    "openscvx/discretization/sparse_utils/sparse_jacobian.py",
+    "openscvx/discretization/sparse_utils/bcoo_helpers.py",
+    "openscvx/symbolic/lower.py",
+    "openscvx/symbolic/__init__.py",
+    "openscvx/symbolic/hashing.py",
+    "openscvx/symbolic/augmentation.py",
+    "openscvx/symbolic/unified.py",
+    "openscvx/symbolic/builder.py",
+    "openscvx/symbolic/sparsity.py",
+    "openscvx/symbolic/preprocessing.py",
+    "openscvx/symbolic/constraint_set.py",
+    "openscvx/symbolic/canonicalize.py",
+    "openscvx/symbolic/problem.py",
+    "openscvx/symbolic/affine.py",
+    "openscvx/symbolic/expr/vmap.py",
+    "openscvx/symbolic/expr/stl.py",
+    "openscvx/symbolic/expr/control.py",
+    "openscvx/symbolic/expr/__init__.py",
+    "openscvx/symbolic/expr/time.py",
+    "openscvx/symbolic/expr/constraint.py",
+    "openscvx/symbolic/expr/spatial.py",
+    "openscvx/symbolic/expr/state.py",
+    "openscvx/symbolic/expr/stljax.py",
+    "openscvx/symbolic/expr/expr.py",
+    "openscvx/symbolic/expr/variable.py",
+    "openscvx/symbolic/expr/logic.py",
+    "openscvx/symbolic/expr/linalg.py",
+    "openscvx/symbolic/expr/array.py",
+    "openscvx/symbolic/expr/arithmetic.py",
+    "openscvx/symbolic/expr/parameter.py",
+    "openscvx/symbolic/expr/math.py",
+    "openscvx/symbolic/expr/lie/__init__.py",
+    "openscvx/symbolic/expr/lie/se3.py",
+    "openscvx/symbolic/expr/lie/so3.py",
+    "openscvx/symbolic/expr/lie/adjoint.py",
+    "openscvx/symbolic/lowerers/__init__.py",
+    "openscvx/symbolic/lowerers/jax/vmap.py",
+    "openscvx/symbolic/lowerers/jax/stl.py",
+    "openscvx/symbolic/lowerers/jax/control.py",
+    "openscvx/symbolic/lowerers/jax/__init__.py",
+    "openscvx/symbolic/lowerers/jax/constraint.py",
+    "openscvx/symbolic/lowerers/jax/spatial.py",
+    "openscvx/symbolic/lowerers/jax/state.py",
+    "openscvx/symbolic/lowerers/jax/_lowerer.py",
+    "openscvx/symbolic/lowerers/jax/stljax.py",
+    "openscvx/symbolic/lowerers/jax/expr.py",
+    "openscvx/symbolic/lowerers/jax/_registry.py",
+    "openscvx/symbolic/lowerers/jax/logic.py",
+    "openscvx/symbolic/lowerers/jax/linalg.py",
+    "openscvx/symbolic/lowerers/jax/array.py",
+    "openscvx/symbolic/lowerers/jax/arithmetic.py",
+    "openscvx/symbolic/lowerers/jax/math.py",
+    "openscvx/symbolic/lowerers/jax/lie.py",
+    "openscvx/symbolic/lowerers/cvxpy/control.py",
+    "openscvx/symbolic/lowerers/cvxpy/__init__.py",
+    "openscvx/symbolic/lowerers/cvxpy/constraint.py",
+    "openscvx/symbolic/lowerers/cvxpy/state.py",
+    "openscvx/symbolic/lowerers/cvxpy/_lowerer.py",
+    "openscvx/symbolic/lowerers/cvxpy/expr.py",
+    "openscvx/symbolic/lowerers/cvxpy/_registry.py",
+    "openscvx/symbolic/lowerers/cvxpy/logic.py",
+    "openscvx/symbolic/lowerers/cvxpy/linalg.py",
+    "openscvx/symbolic/lowerers/cvxpy/array.py",
+    "openscvx/symbolic/lowerers/cvxpy/arithmetic.py",
+    "openscvx/symbolic/lowerers/cvxpy/math.py",
+    "openscvx/symbolic/parser/tokenizer.py",
+    "openscvx/symbolic/parser/stl.py",
+    "openscvx/symbolic/parser/__init__.py",
+    "openscvx/symbolic/parser/constraint.py",
+    "openscvx/symbolic/parser/spatial.py",
+    "openscvx/symbolic/parser/stljax.py",
+    "openscvx/symbolic/parser/parser.py",
+    "openscvx/symbolic/parser/_registry.py",
+    "openscvx/symbolic/parser/logic.py",
+    "openscvx/symbolic/parser/linalg.py",
+    "openscvx/symbolic/parser/array.py",
+    "openscvx/symbolic/parser/math.py",
+    "openscvx/symbolic/parser/lie.py",
+    "openscvx/utils/__init__.py",
+    "openscvx/utils/utils.py",
+    "openscvx/utils/profiling.py",
+    "openscvx/utils/printing.py",
+    "openscvx/utils/cache.py",
+    "openscvx/utils/caching.py",
+    "openscvx/init/__init__.py",
+    "openscvx/init/interpolation.py",
+    "openscvx/init/inverse_kinematics.py",
+    "openscvx/integrations/__init__.py",
+    "openscvx/integrations/frax.py",
+    "openscvx/integrations/mjx.py",
+    "openscvx/integrations/menagerie.py",
+    "openscvx/integrations/_utils.py",
+    "openscvx/integrations/base.py",
+    "openscvx/plotting/plotting.py",
+    "openscvx/plotting/__init__.py",
+    "openscvx/plotting/scp_iteration.py",
+    "openscvx/plotting/publication.py",
+    "openscvx/plotting/viser/__init__.py",
+    "openscvx/plotting/viser/plotly_integration.py",
+    "openscvx/plotting/viser/orbits.py",
+    "openscvx/plotting/viser/scp.py",
+    "openscvx/plotting/viser/animated.py",
+    "openscvx/plotting/viser/primitives.py",
+    "openscvx/plotting/viser/server.py",
+    "openscvx/plotting/viser/coordinates.py",
+    "openscvx/expert/__init__.py",
+    "openscvx/expert/byof.py",
+    "openscvx/expert/lowering.py",
+    "openscvx/expert/validation.py",
+    "openscvx/propagation/__init__.py",
+    "openscvx/propagation/propagation.py",
+    "openscvx/propagation/post_processing.py",
+    "openscvx/solvers/cones.py",
+    "openscvx/solvers/ptr_solver.py",
+    "openscvx/solvers/__init__.py",
+    "openscvx/solvers/cvxpy_ptr_solver.py",
+    "openscvx/solvers/moreau_ptr_solver.py",
+    "openscvx/solvers/qpax_ptr_solver.py",
+    "openscvx/solvers/base.py",
+    "openscvx/algorithms/hyperparams.py",
+    "openscvx/algorithms/optimization_results.py",
+    "openscvx/algorithms/__init__.py",
+    "openscvx/algorithms/state.py",
+    "openscvx/algorithms/loop.py",
+    "openscvx/algorithms/weights.py",
+    "openscvx/algorithms/history.py",
+    "openscvx/algorithms/penalty.py",
+    "openscvx/algorithms/base.py",
+    "openscvx/algorithms/scvx/__init__.py",
+    "openscvx/algorithms/scvx/iteration.py",
+    "openscvx/algorithms/scvx/penalized_trust_region.py",
+    "openscvx/algorithms/autotuner/ramp_proximal_weight.py",
+    "openscvx/algorithms/autotuner/__init__.py",
+    "openscvx/algorithms/autotuner/acceptance_ratio.py",
+    "openscvx/algorithms/autotuner/constant_proximal_weight.py",
+    "openscvx/algorithms/autotuner/augmented_lagrangian.py",
+    "openscvx/algorithms/autotuner/adaptive_proximal_weight.py",
+    "openscvx/algorithms/autotuner/base.py",
+    "openscvx/lowered/cvxpy_constraints.py",
+    "openscvx/lowered/__init__.py",
+    "openscvx/lowered/parameters.py",
+    "openscvx/lowered/jax_constraints.py",
+    "openscvx/lowered/unified.py",
+    "openscvx/lowered/cvxpy_variables.py",
+    "openscvx/lowered/dynamics.py",
+    "openscvx/lowered/problem.py",
+    "openscvx/integrators/__init__.py",
+    "openscvx/integrators/diffrax.py",
+    "openscvx/integrators/runge_kutta.py",
+    "tests/test_loader.py",
+    "tests/brachistochrone_analytical.py",
+    "tests/test_examples.py",
+    "tests/test_optimization_results.py",
+    "tests/test_plotting.py",
+    "tests/__init__.py",
+    "tests/test_integrators.py",
+    "tests/test_discretization.py",
+    "tests/test_init.py",
+    "tests/test_multishot_propagation.py",
+    "tests/test_propagation.py",
+    "tests/hohmann_analytical.py",
+    "tests/test_expert.py",
+    "tests/test_solve_batched_inference.py",
+    "tests/test_solve_jax_bare_brachistochrone.py",
+    "tests/test_cvxpygen_optional.py",
+    "tests/test_solve_batched_export_roundtrip.py",
+    "tests/test_solve_batched_brachistochrone.py",
+    "tests/_marks.py",
+    "tests/test_impulsive.py",
+    "tests/conftest.py",
+    "tests/test_solve_jax_vmap_brachistochrone.py",
+    "tests/test_brachistochrone.py",
+    "tests/test_solve_jax_jit_brachistochrone.py",
+    "tests/test_autotuning.py",
+    "tests/test_solve_batched_cvxpy_export_errors.py",
+    "tests/test_solve_jax_vmap_converged_no_drift.py",
+    "tests/symbolic/test_preprocessing.py",
+    "tests/symbolic/__init__.py",
+    "tests/symbolic/test_lower_cvxpy.py",
+    "tests/symbolic/test_augmentation.py",
+    "tests/symbolic/test_unified.py",
+    "tests/symbolic/test_sparsity.py",
+    "tests/symbolic/test_hashing.py",
+    "tests/symbolic/test_lower_jax.py",
+    "tests/symbolic/expr/test_node_reference.py",
+    "tests/symbolic/expr/test_scaling.py",
+    "tests/symbolic/expr/test_math.py",
+    "tests/symbolic/expr/test_variable.py",
+    "tests/symbolic/expr/__init__.py",
+    "tests/symbolic/expr/test_lie.py",
+    "tests/symbolic/expr/test_array.py",
+    "tests/symbolic/expr/test_expr.py",
+    "tests/symbolic/expr/test_logic.py",
+    "tests/symbolic/expr/test_arithmetic.py",
+    "tests/symbolic/expr/test_constraint.py",
+    "tests/symbolic/expr/test_vmap.py",
+    "tests/symbolic/expr/test_spatial.py",
+    "tests/symbolic/expr/test_stl.py",
+    "tests/symbolic/expr/test_parameters.py",
+    "tests/symbolic/expr/test_linalg.py",
+    "tests/symbolic/parser/test_math.py",
+    "tests/symbolic/parser/__init__.py",
+    "tests/symbolic/parser/test_lie.py",
+    "tests/symbolic/parser/test_array.py",
+    "tests/symbolic/parser/test_logic.py",
+    "tests/symbolic/parser/test_parser.py",
+    "tests/symbolic/parser/test_load.py",
+    "tests/symbolic/parser/test_constraint.py",
+    "tests/symbolic/parser/test_vmap.py",
+    "tests/symbolic/parser/test_tokenizer.py",
+    "tests/symbolic/parser/test_spatial.py",
+    "tests/symbolic/parser/test_stl.py",
+    "tests/symbolic/parser/test_linalg.py",
+    "tests/fixtures/brachistochrone.yaml",
+    "tests/fixtures/brachistochrone.json",
+    "tests/integrations/test_mjx_dynamics.py",
+    "tests/integrations/__init__.py",
+    "tests/integrations/test_mjx.py",
+    "tests/expr/test_gmsr.py",
+    "tests/expr/__init__.py",
+    "tests/solvers/__init__.py",
+    "tests/solvers/test_moreau_ptr_solver.py",
+    "tests/solvers/test_qpax_ptr_solver.py",
+    "tests/solvers/test_subproblem_pytree.py",
+    "tests/solvers/test_iteration_callback_moreau.py",
+    "tests/solvers/test_iteration_callback_qpax.py",
+    "tests/solvers/test_cvxpy_callback_jit_spike.py",
+    "tests/solvers/_iteration_callback_helpers.py",
+    "tests/solvers/test_iteration_callback_cvxpy.py",
+    "tests/solvers/test_iteration_callback_vmap.py",
+    "tests/algorithms/_iteration_helpers.py",
+    "tests/algorithms/__init__.py",
+    "tests/algorithms/test_make_solve_loop.py",
+    "tests/algorithms/test_algorithm_state_pytree.py",
+    "tests/algorithms/test_iteration_fn_jit.py",
+    "tests/algorithms/test_iteration_fn_parity.py",
+    "tests/algorithms/autotuner/__init__.py",
+    "tests/algorithms/autotuner/test_defaults_agreement.py",
+    "tests/algorithms/autotuner/test_hyper_overrides.py",
+    "tests/algorithms/autotuner/test_update_weights_jit.py",
+    "figures/dtlos_dr.gif",
+    "figures/oscvx_structure_full_dark.svg",
+    "figures/ctlos_cine.gif",
+    "figures/dtlos_cine.gif",
+    "figures/ctlos_dr.gif",
+    "figures/openscvx_logo_square.png",
+    "figures/openscvx_logo.svg",
+    "figures/video_preview.png",
+    "material/__init__.py",
+    "material/overrides/home.html",
+    "material/overrides/main.html",
+    "material/overrides/partials/home-pipeline.html",
+    "material/overrides/partials/home-dropin-banner.html",
+    "material/overrides/partials/home-diagram.html",
+    "material/overrides/partials/home-viser-strip.html",
+    "material/overrides/partials/home-hero.html",
+    "material/overrides/assets/stylesheets/home-viser.css",
+    "material/overrides/assets/stylesheets/home-dropin.css",
+    "material/overrides/assets/stylesheets/home-hero.css",
+    "material/overrides/assets/stylesheets/custom.css",
+    "examples/plotting.py",
+    "examples/_viser_embed_export.py",
+    "examples/plotting_viser.py",
+    "examples/spacecraft/halo_orbit.py",
+    "examples/spacecraft/let_transfer.py",
+    "examples/spacecraft/relative_loitering.py",
+    "examples/spacecraft/hohmann_transfer.py",
+    "examples/spacecraft/proxops_cw.py",
+    "examples/abstract/impulsive.py",
+    "examples/abstract/hypersensitive.py",
+    "examples/abstract/brachistochrone_batched.py",
+    "examples/abstract/flappy_bird.py",
+    "examples/abstract/stl_or.py",
+    "examples/abstract/stl_integer_variable.py",
+    "examples/abstract/brachistochrone.py",
+    "examples/aircraft/supersonic_time_to_climb.py",
+    "examples/drone/dr_vp.py",
+    "examples/drone/openscvx_logo.py",
+    "examples/drone/cinema_vp.py",
+    "examples/drone/dr_double_integrator.py",
+    "examples/drone/drone_racing.py",
+    "examples/drone/obstacle_avoidance_vmap.py",
+    "examples/drone/dr_vp_polytope.py",
+    "examples/drone/obstacle_avoidance_nodal.py",
+    "examples/drone/logo.py",
+    "examples/drone/obstacle_avoidance.py",
+    "examples/drone/2d_obstacle_avoidance_batched_ic.py",
+    "examples/drone/drone_racing_batched_gates.py",
+    "examples/drone/cinema_vp_nodal.py",
+    "examples/drone/obstacle_avoidance_vmap_2d.py",
+    "examples/drone/dr_vp_nodal.py",
+    "examples/drone/multi_agent_circle_swap.py",
+    "examples/drone/logo_utils/svg_path_utils.py",
+    "examples/drone/logo_utils/openscvx_logo_single.svg",
+    "examples/drone/logo_utils/quadrotor_mesh.py",
+    "examples/drone/logo_utils/acl_logo.svg",
+    "examples/rocket/3DoF_pdg.py",
+    "examples/rocket/ascent_launch_vehicle.py",
+    "examples/rocket/6DoF_pdg_batched_ic.py",
+    "examples/rocket/6DoF_pdg.py",
+    "examples/car/dubins_car_obstacle_stl.py",
+    "examples/car/dubins_car_stl_or.py",
+    "examples/car/dubins_car_obstacle_conditional.py",
+    "examples/car/dubins_car.py",
+    "examples/car/dubins_car_disjoint.py",
+    "examples/car/dubins_car_waypoint_stl.py",
+    "examples/arm/3_dof_arm.py",
+    "examples/arm/7_dof_arm_vp.py",
+    "examples/arm/7_dof_arm_collision.py",
+    "examples/arm/franka_fr3v2_viewplanning_nodal.py",
+    "examples/arm/franka_fr3v2_pick_place.py",
+    "examples/arm/7_dof_arm.py",
+    "examples/arm/franka_fr3v2_viewplanning.py",
+    "examples/mjx/triple_cartpole_3d_mjx.py",
+    "examples/mjx/skydio_x2_mjx.py",
+    "examples/mjx/triple_cartpole_mjx.py",
+    "examples/mjx/cartpole_mjx.py",
+    "examples/mjx/double_cartpole_mjx.py",
+    "examples/mjx/triple_cartpole_game.py",
+    "examples/animations/_sensor_view.py",
+    "examples/animations/obstacle_avoidance_vmap.py",
+    "examples/animations/dr_vp_polytope.py",
+    "examples/animations/logo.py",
+    "examples/animations/franka_fr3v2_pick_place.py",
+    "examples/animations/7_dof_arm.py",
+    "examples/animations/_camera.py",
+    "examples/animations/_render.py",
+    "examples/mpc/dubins_car_circle_analytical.py",
+    "examples/mpc/dubins_car_circle_discrete.py",
+    "examples/mpc/double_integrator_discrete.py",
+    "examples/mpc/double_integrator_drone_racing.py",
+    "examples/mpc/realtime_double_integrator_drone_racing.py",
+    "examples/realtime/drone_racing_realtime.py",
+    "examples/realtime/cinema_vp_realtime.py",
+    "examples/realtime/3DoF_pdg_realtime.py",
+    "examples/realtime/obstacle_avoidance_realtime.py",
+    "examples/realtime/dubins_car_realtime.py",
+    "examples/realtime/6DoF_pdg_realtime.py",
+    "examples/realtime/base_problems/cinema_vp_realtime_base.py",
+    "examples/realtime/base_problems/drone_racing_realtime_base.py",
+    "examples/realtime/base_problems/obstacle_avoidance_realtime_base.py",
+    "examples/realtime/base_problems/dubins_car_realtime_base.py",
+    "examples/realtime/base_problems/6DoF_pdg_realtime_base.py",
+    "examples/realtime/base_problems/3DoF_pdg_realtime_base.py",
+    "examples/double_integrator/_plotting.py",
+    "examples/double_integrator/moving_safe_zones.py",
+    "examples/frax/panda_frax_viewplanning.py",
+    "examples/frax/panda_frax_pick_place.py",
+    "examples/frax/panda_frax.py",
+    "examples/frax/panda_frax_waypoint.py",
+    ".github/release-drafter.yml",
+    ".github/assets/logo.svg",
+    ".github/workflows/branch-name.yml",
+    ".github/workflows/tests-integration.yml",
+    ".github/workflows/release.yml",
+    ".github/workflows/docs.yml",
+    ".github/workflows/lint.yml",
+    ".github/workflows/release-drafter.yml",
+    ".github/workflows/_docs.yml",
+    ".github/workflows/tests-unit.yml",
+    ".github/workflows/nightly.yml"
+  ]
+}

openscvx-0.5.3.dev32.dist-info/scm_version.json

@@ -0,0 +1,8 @@
+{
+  "tag": "0.5.2",
+  "distance": 32,
+  "node": "gd1964080e22534c0d78eccd223de88e62365c296",
+  "dirty": false,
+  "branch": "main",
+  "node_date": "2026-07-01"
+}