openscvx 0.5.3.dev37__tar.gz → 0.5.3.dev38__tar.gz

{openscvx-0.5.3.dev37/openscvx.egg-info → openscvx-0.5.3.dev38}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openscvx
-Version: 0.5.3.dev37
+Version: 0.5.3.dev38
 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.dev37 → openscvx-0.5.3.dev38}/examples/spacecraft/relative_loitering.py

@@ -353,7 +353,6 @@ def build_relative_loitering_problem(
         time=time,
         constraints=constraints,
         N=n_nodes,
-        licq_min=0.0,
         licq_max=1e-8,
         discretizer={
             "ode_solver": "Dopri8",

{openscvx-0.5.3.dev37 → openscvx-0.5.3.dev38}/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.dev37'
-__version_tuple__ = version_tuple = (0, 5, 3, 'dev37')
+__version__ = version = '0.5.3.dev38'
+__version_tuple__ = version_tuple = (0, 5, 3, 'dev38')
 
-__commit_id__ = commit_id = 'gdb86fef25'
+__commit_id__ = commit_id = 'g235acbb25'

{openscvx-0.5.3.dev37 → openscvx-0.5.3.dev38}/openscvx/problem.py

@@ -340,8 +340,7 @@ class Problem:
         dynamics_prop: Optional[dict] = None,
         states_prop: Optional[List[State]] = None,
         algebraic_prop: Optional[dict] = None,
-        licq_min: Union[float, Dict[int, float]] = 0.0,
-        licq_max: Union[float, Dict[int, float]] = 1e-4,
+        licq_max: float = 1e-4,
         algorithm: Optional[Union[Algorithm, dict]] = None,
         discretizer: Optional[Union[Discretizer, dict]] = None,
         solver: Optional[Union[ConvexSolver, dict]] = None,
@@ -373,12 +372,11 @@ class Problem:
                 Only specify additional states beyond optimization states. Used with dynamics_prop.
             algebraic_prop (dict, optional): Dictionary mapping names to symbolic expressions
                 for outputs evaluated (not integrated) during propagation.
-            licq_min: Minimum LICQ constraint value. Defaults to 0.0.
-                Either a scalar (applied to all CTCS groups) or a dict
-                mapping CTCS group ``idx`` to per-group bounds.
-            licq_max: Maximum LICQ constraint value. Defaults to 1e-4.
-                Either a scalar (applied to all CTCS groups) or a dict
-                mapping CTCS group ``idx`` to per-group bounds.
+            licq_max: Problem-wide upper bound for CTCS augmented states
+                (default: 1e-4). Serves as the default for all constraint
+                groups; a ``licq_max`` set on an individual constraint (via
+                ``ctcs(...)`` or ``.over(...)``) overrides it for that
+                constraint's augmented state.
             algorithm: SCP algorithm configuration. Accepts:
 
                 - ``None`` — uses ``PenalizedTrustRegion()`` with defaults.
@@ -539,7 +537,6 @@ class Problem:
             controls=controls,
             N=N,
             time=time,
-            licq_min=licq_min,
             licq_max=licq_max,
             dynamics_prop_extra=dynamics_prop,
             states_prop_extra=states_prop,

{openscvx-0.5.3.dev37 → openscvx-0.5.3.dev38}/openscvx/symbolic/augmentation.py

@@ -54,7 +54,7 @@ Example:
         # controls_aug includes original controls + time dilation
 """
 
-from typing import Dict, List, Optional, Tuple, Union
+from typing import Dict, List, Optional, Tuple
 
 import numpy as np
 
@@ -448,8 +448,7 @@ def augment_dynamics_with_ctcs(
     N: int,
     xdelta: Optional[Expr] = None,
     *,
-    licq_min: Union[float, Dict[int, float]] = 0.0,
-    licq_max: Union[float, Dict[int, float]] = 1e-4,
+    licq_max: float = 1e-4,
 ) -> Tuple[Expr, Optional[Expr], List[State], List[Control]]:
     """Augment dynamics with continuous-time constraint satisfaction states.
 
@@ -467,18 +466,20 @@ def augment_dynamics_with_ctcs(
         aug_dot = penalty(g(x, u))  # For each constraint group
         time_dot = 1.0
 
+    Each augmented state is bounded to [0, licq_max], where the group's bound
+    is taken from its member constraints' ``licq_max`` attribute (constraints in
+    a group must agree) and falls back to the problem-wide ``licq_max`` when no
+    member specifies one.
+
     Args:
         xdot: Original dynamics expression for states
         states: List of state variables (must include a state named "time")
         controls: List of control variables
         constraints_ctcs: List of CTCS constraints (should be sorted and grouped)
         N: Number of discretization nodes
-        licq_min: Minimum bound for augmented states (default: 0.0).
-            Either a scalar (applied to all groups) or a dict mapping
-            CTCS group ``idx`` to per-group bounds.
-        licq_max: Maximum bound for augmented states (default: 1e-4).
-            Either a scalar (applied to all groups) or a dict mapping
-            CTCS group ``idx`` to per-group bounds.
+        licq_max: Problem-wide default upper bound for augmented states
+            (default: 1e-4). Per-constraint ``licq_max`` values override it
+            for their group.
 
     Returns:
         Tuple of:
@@ -489,6 +490,8 @@ def augment_dynamics_with_ctcs(
 
     Raises:
         ValueError: If no state named "time" is found in the states list
+        ValueError: If constraints sharing an augmented state specify
+            conflicting ``licq_max`` values
 
     Example:
         Augment dynamics with CTCS penalty states:
@@ -509,6 +512,9 @@ def augment_dynamics_with_ctcs(
         states_aug includes x, time, and _ctcs_aug_0,
         controls_aug includes u and _time_dilation
     """
+    if licq_max <= 0:
+        raise ValueError(f"licq_max must be a positive number, got {licq_max!r}")
+
     # Save if discrete dynamics is null
     discrete_dynamics_set = xdelta is not None
 
@@ -535,24 +541,6 @@ def augment_dynamics_with_ctcs(
                 penalty_groups[ctcs.idx] = []
             penalty_groups[ctcs.idx].append(ctcs)
 
-        # Validate dict-valued licq_min / licq_max keys against actual groups.
-        valid_ids = set(penalty_groups.keys())
-        for name, val in [("licq_min", licq_min), ("licq_max", licq_max)]:
-            if isinstance(val, dict):
-                unknown = set(val.keys()) - valid_ids
-                if unknown:
-                    raise ValueError(
-                        f"{name} dict contains unknown CTCS group idx: {unknown}. "
-                        f"Valid idx values: {sorted(valid_ids)}"
-                    )
-                missing = valid_ids - set(val.keys())
-                if missing:
-                    raise ValueError(
-                        f"{name} dict is missing entries for CTCS group idx: "
-                        f"{sorted(missing)}. When using a dict, all groups must "
-                        f"have an entry. Valid idx values: {sorted(valid_ids)}"
-                    )
-
         # Create augmented state expressions for each group and corresponding
         # augmented state variables. For discrete dynamics, preserve these states
         # by identity mapping across impulsive updates.
@@ -566,17 +554,25 @@ def augment_dynamics_with_ctcs(
                 augmented_state_expr = Add(*penalty_terms)
             augmented_state_exprs.append(augmented_state_expr)
 
-            # Resolve per-group LICQ bounds
-            idx_min = licq_min[idx] if isinstance(licq_min, dict) else licq_min
-            idx_max = licq_max[idx] if isinstance(licq_max, dict) else licq_max
+            # Resolve the group's LICQ bound from its member constraints:
+            # explicit values must agree; otherwise fall back to the
+            # problem-wide default.
+            explicit = {c.licq_max for c in penalty_terms if c.licq_max is not None}
+            if len(explicit) > 1:
+                raise ValueError(
+                    f"CTCS constraints sharing augmented state idx={idx} specify "
+                    f"conflicting licq_max values: {sorted(explicit)}. Constraints "
+                    f"in the same group must agree on licq_max; set the same value "
+                    f"on each, or separate them into different groups via idx."
+                )
+            group_licq_max = explicit.pop() if explicit else licq_max
 
             aug_var = State(f"_ctcs_aug_{idx}", shape=(1,))
-            aug_var.initial = np.array([idx_min])  # Set initial to respect bounds
+            aug_var.initial = np.array([0.0])
             aug_var.final = [("free", 0)]
-            aug_var.min = np.array([idx_min])
-            aug_var.max = np.array([idx_max])
-            # Set guess to idx_min as well
-            aug_var.guess = np.full([N, 1], idx_min)  # N x num augmented states
+            aug_var.min = np.array([0.0])
+            aug_var.max = np.array([group_licq_max])
+            aug_var.guess = np.zeros([N, 1])  # N x num augmented states
             states_augmented.append(aug_var)
             augmented_state_exprs_discrete.append(aug_var)
 

{openscvx-0.5.3.dev37 → openscvx-0.5.3.dev38}/openscvx/symbolic/builder.py

@@ -29,7 +29,7 @@ Pipeline stages:
 See `preprocess_symbolic_problem()` for the main entry point.
 """
 
-from typing import Dict, List, Optional, Tuple, Union
+from typing import Dict, List, Optional, Tuple
 
 import numpy as np
 
@@ -71,8 +71,7 @@ def preprocess_symbolic_problem(
     controls: List[Control],
     N: int,
     time: Time,
-    licq_min: Union[float, Dict[int, float]] = 0.0,
-    licq_max: Union[float, Dict[int, float]] = 1e-4,
+    licq_max: float = 1e-4,
     dynamics_prop_extra: dict = None,
     dynamics_discrete: dict = None,
     states_prop_extra: List[State] = None,
@@ -106,12 +105,9 @@ def preprocess_symbolic_problem(
         controls: List of user-defined Control objects (should NOT include time dilation)
         N: Number of discretization nodes in the trajectory
         time: Time configuration object specifying time bounds and constraints
-        licq_min: Minimum bound for CTCS augmented states (default: 0.0).
-            Either a scalar (applied to all groups) or a dict mapping
-            CTCS group ``idx`` to per-group bounds.
-        licq_max: Maximum bound for CTCS augmented states (default: 1e-4).
-            Either a scalar (applied to all groups) or a dict mapping
-            CTCS group ``idx`` to per-group bounds.
+        licq_max: Problem-wide default upper bound for CTCS augmented states
+            (default: 1e-4). Per-constraint ``licq_max`` values override it
+            for their group.
         dynamics_prop_extra: Optional dictionary of additional dynamics for propagation-only
             states (default: None)
         states_prop_extra: Optional list of additional State objects for propagation only
@@ -350,7 +346,6 @@ def preprocess_symbolic_problem(
         constraints.ctcs,
         N,
         xdelta=dynamics_discrete_concat,
-        licq_min=licq_min,
         licq_max=licq_max,
     )
 

{openscvx-0.5.3.dev37 → openscvx-0.5.3.dev38}/openscvx/symbolic/expr/constraint.py

@@ -127,6 +127,7 @@ class Constraint(Expr):
         penalty: str = "squared_relu",
         idx: Optional[int] = None,
         check_nodally: bool = False,
+        licq_max: Optional[float] = None,
     ) -> "CTCS":
         """Apply this constraint over a continuous interval using CTCS.
 
@@ -135,11 +136,22 @@ class Constraint(Expr):
             penalty: Penalty function type ("squared_relu", "huber", "smooth_relu")
             idx: Optional grouping index for multiple augmented states
             check_nodally: Whether to also enforce this constraint nodally
+            licq_max: Optional upper bound on the augmented state that accumulates
+                this constraint's violation penalty. Constraints sharing an
+                augmented state must agree on the value; groups without one use
+                the problem-wide ``licq_max`` (a ``Problem`` argument).
 
         Returns:
             CTCS constraint wrapping this constraint with interval specification
         """
-        return CTCS(self, penalty=penalty, nodes=interval, idx=idx, check_nodally=check_nodally)
+        return CTCS(
+            self,
+            penalty=penalty,
+            nodes=interval,
+            idx=idx,
+            check_nodally=check_nodally,
+            licq_max=licq_max,
+        )
 
     def convex(self) -> "Constraint":
         """Mark this constraint as convex for CVXPy lowering.
@@ -609,6 +621,11 @@ class CTCS(Expr):
             an augmented state. If None, auto-assigned based on node intervals.
         check_nodally: Whether to also enforce the constraint at discrete nodes for
             additional numerical robustness (creates both continuous and nodal constraints)
+        licq_max: Optional upper bound on the augmented state accumulating this
+            constraint's violation penalty. Smaller values enforce the constraint
+            more strictly between nodes. Constraints sharing an augmented state
+            must agree on the value; groups without one use the problem-wide
+            ``licq_max`` (a ``Problem`` argument).
 
     Example:
         Single augmented state (default behavior - same node interval):
@@ -642,6 +659,7 @@ class CTCS(Expr):
         nodes: Optional[Tuple[int, int]] = None,
         idx: Optional[int] = None,
         check_nodally: bool = False,
+        licq_max: Optional[float] = None,
     ):
         """Initialize a CTCS constraint.
 
@@ -662,11 +680,16 @@ class CTCS(Expr):
             check_nodally: If True, also enforce the constraint at discrete nodes for
                 numerical stability (creates both continuous and nodal constraints).
                 Defaults to False.
+            licq_max: Optional upper bound on the augmented state accumulating this
+                constraint's violation penalty. Constraints sharing an augmented
+                state must agree on the value; groups without one use the
+                problem-wide ``licq_max`` (a ``Problem`` argument).
 
         Raises:
             TypeError: If constraint is not a Constraint instance
             ValueError: If nodes is not None or a 2-tuple of integers
             ValueError: If nodes[0] >= nodes[1] (invalid interval)
+            ValueError: If licq_max is not a positive number
         """
         if not isinstance(constraint, Constraint):
             raise TypeError("CTCS must wrap a Constraint")
@@ -683,12 +706,19 @@ class CTCS(Expr):
             if nodes[0] >= nodes[1]:
                 raise ValueError("CTCS node range must have start < end")
 
+        if licq_max is not None:
+            if not isinstance(licq_max, (int, float)) or licq_max <= 0:
+                raise ValueError(f"licq_max must be a positive number, got {licq_max!r}")
+            licq_max = float(licq_max)
+
         self.constraint = constraint
         self.penalty = penalty
         self.nodes = nodes  # (start, end) node range or None for all nodes
         self.idx = idx  # Optional grouping index for multiple augmented states
         # Whether to also enforce this constraint nodally for numerical stability
         self.check_nodally = check_nodally
+        # Upper bound on the augmented state; None defers to the group default
+        self.licq_max = licq_max
 
     def children(self) -> List[Expr]:
         """Return the wrapped constraint as the only child.
@@ -711,6 +741,7 @@ class CTCS(Expr):
             nodes=self.nodes,
             idx=self.idx,
             check_nodally=self.check_nodally,
+            licq_max=self.licq_max,
         )
 
     def check_shape(self) -> Tuple[int, ...]:
@@ -767,6 +798,11 @@ class CTCS(Expr):
             hasher.update(b"None")
         # Hash check_nodally
         hasher.update(b"1" if self.check_nodally else b"0")
+        # Hash licq_max
+        if self.licq_max is not None:
+            hasher.update(struct.pack(">d", self.licq_max))
+        else:
+            hasher.update(b"None")
         # Hash the wrapped constraint
         self.constraint._hash_into(hasher)
 
@@ -794,6 +830,7 @@ class CTCS(Expr):
             nodes=interval,
             idx=self.idx,
             check_nodally=self.check_nodally,
+            licq_max=self.licq_max,
         )
 
     def __repr__(self) -> str:
@@ -809,6 +846,8 @@ class CTCS(Expr):
             parts.append(f"idx={self.idx}")
         if self.check_nodally:
             parts.append(f"check_nodally={self.check_nodally}")
+        if self.licq_max is not None:
+            parts.append(f"licq_max={self.licq_max}")
         return f"CTCS({', '.join(parts)})"
 
     def penalty_expr(self) -> Expr:
@@ -861,6 +900,7 @@ def ctcs(
     nodes: Optional[Tuple[int, int]] = None,
     idx: Optional[int] = None,
     check_nodally: bool = False,
+    licq_max: Optional[float] = None,
 ) -> CTCS:
     """Helper function to create CTCS (Continuous-Time Constraint Satisfaction) constraints.
 
@@ -876,6 +916,10 @@ def ctcs(
         idx: Optional grouping index for multiple augmented states
         check_nodally: Whether to also enforce constraint at discrete nodes.
             Defaults to False.
+        licq_max: Optional upper bound on the augmented state accumulating this
+            constraint's violation penalty. Constraints sharing an augmented
+            state must agree on the value; groups without one use the
+            problem-wide ``licq_max`` (a ``Problem`` argument).
 
     Returns:
         CTCS: A CTCS constraint wrapping the input constraint
@@ -899,4 +943,4 @@ def ctcs(
 
             altitude_constraint = (altitude >= 10).over((0, 100), penalty="huber")
     """
-    return CTCS(constraint, penalty, nodes, idx, check_nodally)
+    return CTCS(constraint, penalty, nodes, idx, check_nodally, licq_max)

{openscvx-0.5.3.dev37 → openscvx-0.5.3.dev38}/openscvx/symbolic/expr/stl.py

@@ -310,6 +310,7 @@ class STLExpr(Expr):
         penalty: str = "smooth_relu",
         idx: Optional[int] = None,
         check_nodally: bool = False,
+        licq_max: Optional[float] = None,
         interval_type: IntervalKind = "nodes",
     ) -> "CTCS":
         """Apply this STL expression over an enforcement interval using CTCS.
@@ -323,6 +324,10 @@ class STLExpr(Expr):
             penalty: Penalty function type for CTCS
             idx: Optional grouping index for multiple augmented states
             check_nodally: Whether to also enforce at discrete nodes
+            licq_max: Optional upper bound on the augmented state accumulating
+                this constraint's violation penalty. Constraints sharing an
+                augmented state must agree on the value; groups without one use
+                the problem-wide ``licq_max`` (a ``Problem`` argument).
 
         Returns:
             Continuous-time constraint satisfaction wrapper
@@ -359,6 +364,7 @@ class STLExpr(Expr):
             nodes=(coerced.start, coerced.end),
             idx=idx,
             check_nodally=check_nodally,
+            licq_max=licq_max,
         )
 
     def at(self, nodes: Union[list, tuple]) -> "NodalConstraint":
@@ -863,6 +869,7 @@ class Always(_TemporalSTLExpr):
         penalty: str = "smooth_relu",
         idx: Optional[int] = None,
         check_nodally: bool = False,
+        licq_max: Optional[float] = None,
         interval_type: IntervalKind = "nodes",
     ) -> "CTCS":
         """Convert this ``Always`` to a ``CTCS`` constraint.
@@ -876,6 +883,10 @@ class Always(_TemporalSTLExpr):
             penalty: CTCS penalty function name.
             idx: Optional grouping index for multiple augmented states.
             check_nodally: Whether to additionally enforce at discrete nodes.
+            licq_max: Optional upper bound on the augmented state accumulating
+                this constraint's violation penalty. Constraints sharing an
+                augmented state must agree on the value; groups without one use
+                the problem-wide ``licq_max`` (a ``Problem`` argument).
 
         Returns:
             A ``CTCS`` constraint enforcing the inner predicate over the
@@ -903,7 +914,7 @@ class Always(_TemporalSTLExpr):
 
         if isinstance(self.predicate, STLExpr):
             return self.predicate.over(
-                chosen, penalty=penalty, idx=idx, check_nodally=check_nodally
+                chosen, penalty=penalty, idx=idx, check_nodally=check_nodally, licq_max=licq_max
             )
 
         from .constraint import CTCS
@@ -914,6 +925,7 @@ class Always(_TemporalSTLExpr):
             nodes=(chosen.start, chosen.end),
             idx=idx,
             check_nodally=check_nodally,
+            licq_max=licq_max,
         )
 
     def __repr__(self) -> str:

{openscvx-0.5.3.dev37 → openscvx-0.5.3.dev38}/openscvx/symbolic/expr/stljax.py

@@ -59,6 +59,7 @@ class STLJaxExpr(Expr):
         penalty: str = "squared_relu",
         idx: Optional[int] = None,
         check_nodally: bool = False,
+        licq_max: Optional[float] = None,
     ) -> "CTCS":
         """Apply this STL expression over a continuous interval using CTCS.
 
@@ -70,6 +71,10 @@ class STLJaxExpr(Expr):
             penalty: Penalty function type for CTCS
             idx: Optional grouping index for multiple augmented states
             check_nodally: Whether to also enforce at discrete nodes
+            licq_max: Optional upper bound on the augmented state accumulating
+                this constraint's violation penalty. Constraints sharing an
+                augmented state must agree on the value; groups without one use
+                the problem-wide ``licq_max`` (a ``Problem`` argument).
 
         Returns:
             Continuous-time constraint satisfaction wrapper
@@ -89,7 +94,12 @@ class STLJaxExpr(Expr):
         constraint = Inequality(Neg(self), Constant(np.array(0.0)))
 
         return CTCS(
-            constraint, penalty=penalty, nodes=interval, idx=idx, check_nodally=check_nodally
+            constraint,
+            penalty=penalty,
+            nodes=interval,
+            idx=idx,
+            check_nodally=check_nodally,
+            licq_max=licq_max,
         )
 
     def at(self, nodes: Union[list, tuple]) -> "NodalConstraint":

{openscvx-0.5.3.dev37 → openscvx-0.5.3.dev38/openscvx.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openscvx
-Version: 0.5.3.dev37
+Version: 0.5.3.dev38
 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.dev38/openscvx.egg-info/scm_version.json

@@ -0,0 +1,8 @@
+{
+  "tag": "0.5.2",
+  "distance": 38,
+  "node": "g235acbb255b0d235e487ea4b5d7f507bc698e36a",
+  "dirty": false,
+  "branch": "main",
+  "node_date": "2026-07-13"
+}