openscvx 0.3.2.dev215__tar.gz → 0.3.2.dev228__tar.gz

{openscvx-0.3.2.dev215/openscvx.egg-info → openscvx-0.3.2.dev228}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openscvx
-Version: 0.3.2.dev215
+Version: 0.3.2.dev228
 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.3.2.dev215 → openscvx-0.3.2.dev228}/examples/abstract/3DoF_pdg.py

@@ -38,14 +38,12 @@ position.max = np.array([3000, 3000, 3000])
 position.min = np.array([-3000, -3000, 0])
 position.initial = np.array([2000, 0, 1500])
 position.final = np.array([0, 0, 0])
-position.guess = np.linspace(position.initial, position.final, n)
 
 velocity = ox.State("velocity", shape=(3,))  # 3D velocity [vx, vy, vz]
 velocity.max = np.array([v_max, v_max, v_max])
 velocity.min = np.array([-v_max, -v_max, -v_max])
 velocity.initial = np.array([80, 30, -75])
 velocity.final = np.array([0, 0, 0])
-velocity.guess = np.linspace(velocity.initial, velocity.final, n)
 
 mass = ox.State("mass", shape=(1,))  # Vehicle mass
 mass.max = np.array([1905])
@@ -54,7 +52,6 @@ mass.initial = np.array([1905])
 mass.final = [("maximize", 1690)]
 mass.scaling_min = np.array([1690])
 # mass.scaling_max = np.array([1700])
-mass.guess = np.linspace(mass.initial, 1690, n).reshape(-1, 1)
 
 # Define control
 thrust = ox.Control("thrust", shape=(3,))  # Thrust force vector [Tx, Ty, Tz]

{openscvx-0.3.2.dev215 → openscvx-0.3.2.dev228}/examples/abstract/brachistochrone.py

@@ -38,14 +38,12 @@ position.max = np.array([10.0, 10.0])
 position.min = np.array([0.0, 0.0])
 position.initial = np.array([0.0, 10.0])
 position.final = [10.0, 5.0]
-position.guess = np.linspace(position.initial, position.final, n)
 
 velocity = ox.State("velocity", shape=(1,))  # Scalar speed
 velocity.max = np.array([10.0])
 velocity.min = np.array([0.0])
 velocity.initial = np.array([0.0])
 velocity.final = [("free", 10.0)]
-velocity.guess = np.linspace(0.0, 10.0, n).reshape(-1, 1)
 
 # Define control
 theta = ox.Control("theta", shape=(1,))  # Angle from vertical

{openscvx-0.3.2.dev215 → openscvx-0.3.2.dev228}/examples/car/dubins_car.py

@@ -35,14 +35,12 @@ position.min = np.array([-5.0, -5.0])
 position.max = np.array([5.0, 5.0])
 position.initial = np.array([0, -2])
 position.final = np.array([0, 2])
-position.guess = np.linspace(position.initial, position.final, n)
 
 theta = ox.State("theta", shape=(1,))  # Heading angle
 theta.min = np.array([-2 * jnp.pi])
 theta.max = np.array([2 * jnp.pi])
 theta.initial = np.array([0])
 theta.final = [ox.Free(0)]
-theta.guess = np.zeros((n, 1))
 
 # Define control components
 speed = ox.Control("speed", shape=(1,))  # Forward speed

{openscvx-0.3.2.dev215 → openscvx-0.3.2.dev228}/examples/car/dubins_car_disjoint.py

@@ -41,7 +41,6 @@ theta.min = np.array([-2 * jnp.pi])
 theta.max = np.array([2 * jnp.pi])
 theta.initial = np.array([0])
 theta.final = [("free", 0)]
-theta.guess = np.zeros((n, 1))
 
 # Define control components
 speed = ox.Control("speed", shape=(1,))  # Forward speed

{openscvx-0.3.2.dev215 → openscvx-0.3.2.dev228}/examples/car/dubins_car_stljax.py

@@ -37,14 +37,12 @@ position.min = np.array([-5.0, -5.0])
 position.max = np.array([5.0, 5.0])
 position.initial = np.array([0, -2])
 position.final = np.array([0, 2])
-position.guess = np.linspace(position.initial, position.final, n)
 
 theta = ox.State("theta", shape=(1,))  # Heading angle
 theta.min = np.array([-2 * jnp.pi])
 theta.max = np.array([2 * jnp.pi])
 theta.initial = np.array([0])
 theta.final = [("free", 0)]
-theta.guess = np.zeros((n, 1))
 
 # Define control components
 speed = ox.Control("speed", shape=(1,))  # Forward speed
@@ -63,7 +61,6 @@ time.max = np.array([10])
 time.min = np.array([0.0])
 time.initial = np.array([0.0])
 time.final = [ox.Minimize(total_time)]
-time.guess = np.linspace(0.0, total_time, n).reshape(-1, 1)
 
 
 # Define list of all states and controls

{openscvx-0.3.2.dev215 → openscvx-0.3.2.dev228}/examples/drone/cinema_vp.py

@@ -70,7 +70,6 @@ time.max = np.array([total_time])
 time.min = np.array([0.0])
 time.initial = np.array([0.0])
 time.final = np.array([total_time])
-time.guess = np.linspace(0.0, total_time, n).reshape(-1, 1)
 
 # Define control components
 thrust_force = ox.Control("thrust_force", shape=(3,))  # Thrust forces [fx, fy, fz]

{openscvx-0.3.2.dev215 → openscvx-0.3.2.dev228}/examples/drone/dr_double_integrator.py

@@ -38,14 +38,12 @@ position.max = np.array([200.0, 100, 50])
 position.min = np.array([-200.0, -100, 15])
 position.initial = np.array([10.0, 0, 20])
 position.final = [10.0, 0, 20]
-position.guess = np.linspace(position.initial, position.final, n)
 
 velocity = ox.State("velocity", shape=(3,))  # 3D velocity [vx, vy, vz]
 velocity.max = np.array([100, 100, 100])
 velocity.min = np.array([-100, -100, -100])
 velocity.initial = np.array([0, 0, 0])
 velocity.final = [("free", 0), ("free", 0), ("free", 0)]
-velocity.guess = np.linspace(velocity.initial, [0, 0, 0], n)
 
 # Define control
 force = ox.Control("force", shape=(3,))  # Control forces [fx, fy, fz]

{openscvx-0.3.2.dev215 → openscvx-0.3.2.dev228}/examples/drone/drone_racing.py

@@ -37,28 +37,24 @@ position.max = np.array([200.0, 100, 200])
 position.min = np.array([-200.0, -100, 15])
 position.initial = np.array([10.0, 0, 20])
 position.final = [10.0, 0, 20]
-position.guess = np.linspace(position.initial, position.final, n)
 
 velocity = ox.State("velocity", shape=(3,))  # 3D velocity [vx, vy, vz]
 velocity.max = np.array([100, 100, 100])
 velocity.min = np.array([-100, -100, -100])
 velocity.initial = np.array([0, 0, 0])
 velocity.final = [("free", 0), ("free", 0), ("free", 0)]
-velocity.guess = np.linspace(velocity.initial, [0, 0, 0], n)
 
 attitude = ox.State("attitude", shape=(4,))  # Quaternion [qw, qx, qy, qz]
 attitude.max = np.array([1, 1, 1, 1])
 attitude.min = np.array([-1, -1, -1, -1])
 attitude.initial = [("free", 1.0), ("free", 0), ("free", 0), ("free", 0)]
 attitude.final = [("free", 1), ("free", 0), ("free", 0), ("free", 0)]
-attitude.guess = np.tile([1.0, 0.0, 0.0, 0.0], (n, 1))
 
 angular_velocity = ox.State("angular_velocity", shape=(3,))  # Angular velocity [wx, wy, wz]
 angular_velocity.max = np.array([10, 10, 10])
 angular_velocity.min = np.array([-10, -10, -10])
 angular_velocity.initial = [("free", 0), ("free", 0), ("free", 0)]
 angular_velocity.final = [("free", 0), ("free", 0), ("free", 0)]
-angular_velocity.guess = np.zeros((n, 3))
 
 # Define control components
 thrust_force = ox.Control("thrust_force", shape=(3,))  # Thrust forces [fx, fy, fz]

{openscvx-0.3.2.dev215 → openscvx-0.3.2.dev228}/examples/drone/obstacle_avoidance.py

@@ -137,12 +137,6 @@ for center, A in zip(obstacle_centers, A_obs):
     obstacle_constraint = ox.ctcs(1.0 <= diff.T @ A_const @ diff)
     constraints.append(obstacle_constraint)
 
-# Set initial guesses
-position.guess = np.linspace(position.initial, position.final, n)
-velocity.guess = np.linspace(velocity.initial, [0, 0, 0], n)
-attitude.guess = np.tile([1.0, 0.0, 0.0, 0.0], (n, 1))
-angular_velocity.guess = np.zeros((n, 3))
-
 
 time = ox.Time(
     initial=0.0,

{openscvx-0.3.2.dev215 → openscvx-0.3.2.dev228}/examples/drone/obstacle_avoidance_nodal.py

@@ -136,12 +136,6 @@ for center, A in zip(obstacle_centers, A_obs):
     obstacle_constraint = 1.0 <= diff.T @ A_const @ diff
     constraints.append(obstacle_constraint)
 
-# Set initial guesses
-position.guess = np.linspace(position.initial, position.final, n)
-velocity.guess = np.linspace(velocity.initial, [0, 0, 0], n)
-attitude.guess = np.tile([1.0, 0.0, 0.0, 0.0], (n, 1))
-angular_velocity.guess = np.zeros((n, 3))
-
 time = ox.Time(
     initial=0.0,
     final=("minimize", total_time),

{openscvx-0.3.2.dev215 → openscvx-0.3.2.dev228}/examples/drone/obstacle_avoidance_realtime_base.py

@@ -137,13 +137,6 @@ for center, A in zip(obstacle_centers, A_obs):
     obstacle_constraint = ox.ctcs(1.0 <= diff.T @ A_const @ diff)
     constraints.append(obstacle_constraint)
 
-# Set initial guesses
-position.guess = np.linspace(position.initial, position.final, n)
-velocity.guess = np.linspace(velocity.initial, [0, 0, 0], n)
-attitude.guess = np.tile([1.0, 0.0, 0.0, 0.0], (n, 1))
-angular_velocity.guess = np.zeros((n, 3))
-
-
 time = ox.Time(
     initial=0.0,
     final=("minimize", total_time),

{openscvx-0.3.2.dev215 → openscvx-0.3.2.dev228}/examples/spacecraft/proxops_cw.py

@@ -54,7 +54,6 @@ position.max = np.array([100.0, 100.0, 100.0])
 position.min = np.array([-100.0, -100.0, -100.0])
 position.initial = np.array([0.0, -100.0, 0.0])  # Start 100m behind target (V-bar position)
 position.final = np.array([0.0, 0.0, 0.0])  # Dock at origin
-position.guess = np.linspace(position.initial, position.final, n_nodes)
 
 # Velocity in CW frame [vx, vy, vz] in m/s
 velocity = ox.State("velocity", shape=(3,))

{openscvx-0.3.2.dev215 → openscvx-0.3.2.dev228}/openscvx/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '0.3.2.dev215'
-__version_tuple__ = version_tuple = (0, 3, 2, 'dev215')
+__version__ = version = '0.3.2.dev228'
+__version_tuple__ = version_tuple = (0, 3, 2, 'dev228')
 
-__commit_id__ = commit_id = 'g708268a3b'
+__commit_id__ = commit_id = 'g44572a46d'

{openscvx-0.3.2.dev215 → openscvx-0.3.2.dev228}/openscvx/problem.py

@@ -164,6 +164,9 @@ class Problem:
 
             validate_byof(byof, self.symbolic.states, n_x, n_u, N)
 
+        # Store byof for cache hashing
+        self._byof = byof
+
         # Lower to JAX and CVXPy (byof handling happens inside lower_symbolic_problem)
         self._lowered: LoweredProblem = lower_symbolic_problem(self.symbolic, byof=byof)
 
@@ -458,6 +461,7 @@ class Problem:
             self.symbolic,
             dt=self.settings.prp.dt,
             total_time=self.settings.sim.total_time,
+            byof=self._byof,
         )
 
         # Compile the discretization solver

{openscvx-0.3.2.dev215 → openscvx-0.3.2.dev228}/openscvx/symbolic/builder.py

@@ -47,11 +47,15 @@ from openscvx.symbolic.expr.state import State
 from openscvx.symbolic.preprocessing import (
     collect_and_assign_slices,
     convert_dynamics_dict_to_expr,
+    fill_default_guesses,
     validate_and_normalize_constraint_nodes,
+    validate_boundary_conditions,
+    validate_bounds,
     validate_constraints_at_root,
     validate_dynamics_dict,
     validate_dynamics_dict_dimensions,
     validate_dynamics_dimension,
+    validate_guesses,
     validate_shapes,
     validate_time_parameters,
     validate_variable_names,
@@ -185,6 +189,17 @@ def preprocess_symbolic_problem(
             print([s.name for s in problem.states_prop])
     """
 
+    # Validate user-provided variables have required attributes
+    validate_boundary_conditions(states)
+    validate_bounds(states + controls)
+
+    # Fill in default guesses for user-provided states
+    # (augmented states get their guesses set by augmentation code)
+    fill_default_guesses(states, N)
+
+    # Validate that all user-provided variables have guesses
+    validate_guesses(states + controls)
+
     # ==================== PHASE 1: Time Handling & Validation ====================
 
     # Validate time handling approach and get processed parameters

{openscvx-0.3.2.dev215 → openscvx-0.3.2.dev228}/openscvx/symbolic/preprocessing.py

@@ -54,6 +54,7 @@ from openscvx.symbolic.expr import (
     Expr,
     NodalConstraint,
     State,
+    Variable,
     traverse,
 )
 
@@ -755,3 +756,84 @@ def convert_dynamics_dict_to_expr(
     dynamics_concat = Concat(*dynamics_exprs)
 
     return dynamics_converted, dynamics_concat
+
+
+def fill_default_guesses(states: List[State], N: int) -> None:
+    """Fill in default linspace guesses for states with guess=None.
+
+    For states with both initial and final conditions set, generates a linear
+    interpolation from initial to final values.
+
+    This function modifies states in-place.
+
+    Args:
+        states: List of State objects to fill guesses for
+        N: Number of discretization nodes
+    """
+    for state in states:
+        if state.guess is None and state.initial is not None and state.final is not None:
+            # state.initial and state.final are already numpy arrays of values
+            # (the setter handles parsing tuples like ("free", value))
+            state.guess = np.linspace(state.initial, state.final, N)
+
+
+def validate_boundary_conditions(states: List[State]) -> None:
+    """Validate that all states have initial and final boundary conditions set.
+
+    Args:
+        states: List of State objects to validate
+
+    Raises:
+        ValueError: If any state is missing initial or final conditions
+    """
+    for state in states:
+        if state.initial is None:
+            raise ValueError(
+                f"State '{state.name}' is missing initial condition. "
+                f"Please set {state.name}.initial"
+            )
+        if state.final is None:
+            raise ValueError(
+                f"State '{state.name}' is missing final condition. Please set {state.name}.final"
+            )
+
+
+def validate_bounds(variables: List[Variable]) -> None:
+    """Validate that all variables have min and max bounds set.
+
+    Args:
+        variables: List of Variable objects (State or Control) to validate
+
+    Raises:
+        ValueError: If any variable is missing min or max bounds
+    """
+    for var in variables:
+        if var.min is None:
+            raise ValueError(
+                f"Variable '{var.name}' is missing min bound. Please set {var.name}.min"
+            )
+        if var.max is None:
+            raise ValueError(
+                f"Variable '{var.name}' is missing max bound. Please set {var.name}.max"
+            )
+
+
+def validate_guesses(variables: List[Variable]) -> None:
+    """Validate that all variables have initial guesses set.
+
+    Args:
+        variables: List of Variable objects (State or Control) to validate
+
+    Raises:
+        ValueError: If any variable is missing a guess
+    """
+    for var in variables:
+        if var.guess is None:
+            if isinstance(var, Control):
+                raise ValueError(
+                    f"Control '{var.name}' is missing initial guess. "
+                    f"Please set {var.name}.guess (controls require explicit guesses)"
+                )
+            raise ValueError(
+                f"State '{var.name}' is missing initial guess. Please set {var.name}.guess"
+            )

{openscvx-0.3.2.dev215 → openscvx-0.3.2.dev228}/openscvx/utils/caching.py

@@ -9,14 +9,45 @@ from jax import export
 from openscvx.utils.cache import get_cache_dir
 
 if TYPE_CHECKING:
+    from openscvx.expert.byof import ByofSpec
     from openscvx.symbolic.problem import SymbolicProblem
 
 
+def _hash_byof(byof: Optional["ByofSpec"]) -> bytes:
+    """Hash BYOF functions by their bytecode and constants.
+
+    Args:
+        byof: Optional ByofSpec containing raw JAX functions
+
+    Returns:
+        Concatenated bytecode and constants of all functions, or empty bytes if no byof
+    """
+    if not byof:
+        return b""
+
+    codes = []
+    for f in byof.get("dynamics", {}).values():
+        codes.append(f.__code__.co_code)
+        codes.append(repr(f.__code__.co_consts).encode())
+    for c in byof.get("nodal_constraints", []):
+        codes.append(c["constraint_fn"].__code__.co_code)
+        codes.append(repr(c["constraint_fn"].__code__.co_consts).encode())
+    for f in byof.get("cross_nodal_constraints", []):
+        codes.append(f.__code__.co_code)
+        codes.append(repr(f.__code__.co_consts).encode())
+    for c in byof.get("ctcs_constraints", []):
+        codes.append(c["constraint_fn"].__code__.co_code)
+        codes.append(repr(c["constraint_fn"].__code__.co_consts).encode())
+
+    return b"".join(codes)
+
+
 def get_solver_cache_paths(
     symbolic_problem: "SymbolicProblem",
     dt: float,
     total_time: float,
     cache_dir: Optional[Path] = None,
+    byof: Optional["ByofSpec"] = None,
 ) -> Tuple[Path, Path]:
     """Generate cache file paths using symbolic AST hashing.
 
@@ -30,6 +61,8 @@ def get_solver_cache_paths(
         total_time: Total simulation time
         cache_dir: Directory to store cached solvers. If None, uses the default
             cache directory (see :func:`openscvx.get_cache_dir`).
+        byof: Optional ByofSpec containing raw JAX functions. If provided,
+            function bytecode is included in the hash.
 
     Returns:
         Tuple of (discretization_solver_path, propagation_solver_path)
@@ -44,6 +77,10 @@ def get_solver_cache_paths(
     final_hasher.update(problem_hash.encode())
     final_hasher.update(f"dt:{dt}".encode())
     final_hasher.update(f"total_time:{total_time}".encode())
+
+    # Include BYOF function bytecode in the hash
+    final_hasher.update(_hash_byof(byof))
+
     final_hash = final_hasher.hexdigest()[:32]
 
     solver_dir = cache_dir if cache_dir is not None else get_cache_dir()

{openscvx-0.3.2.dev215 → openscvx-0.3.2.dev228/openscvx.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openscvx
-Version: 0.3.2.dev215
+Version: 0.3.2.dev228
 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.3.2.dev215 → openscvx-0.3.2.dev228}/tests/symbolic/test_hashing.py

@@ -1047,3 +1047,42 @@ def test_duplicate_constraints_same_hash():
     # Different number of duplicates should hash differently
     p3 = make_problem(2)
     assert hash_symbolic_problem(p1) != hash_symbolic_problem(p3)
+
+
+# =============================================================================
+# BYOF Hashing Tests
+# =============================================================================
+
+
+def test_byof_hash_none():
+    """None byof should return empty bytes."""
+    from openscvx.utils.caching import _hash_byof
+
+    assert _hash_byof(None) == b""
+
+
+def test_byof_hash_empty():
+    """Empty byof dict should return empty bytes."""
+    from openscvx.utils.caching import _hash_byof
+
+    assert _hash_byof({}) == b""
+
+
+def test_byof_hash_changes_with_function():
+    """Different lambda implementations should produce different hashes."""
+    from openscvx.utils.caching import _hash_byof
+
+    byof1 = {"nodal_constraints": [{"constraint_fn": lambda x, u, n, p: x[0] - 10.0}]}
+    byof2 = {"nodal_constraints": [{"constraint_fn": lambda x, u, n, p: x[0] - 20.0}]}
+
+    assert _hash_byof(byof1) != _hash_byof(byof2)
+
+
+def test_byof_hash_same_function_same_hash():
+    """Identical lambda implementations should produce same hash."""
+    from openscvx.utils.caching import _hash_byof
+
+    byof1 = {"nodal_constraints": [{"constraint_fn": lambda x, u, n, p: x[0] - 10.0}]}
+    byof2 = {"nodal_constraints": [{"constraint_fn": lambda x, u, n, p: x[0] - 10.0}]}
+
+    assert _hash_byof(byof1) == _hash_byof(byof2)

{openscvx-0.3.2.dev215 → openscvx-0.3.2.dev228}/tests/symbolic/test_preprocessing.py

@@ -6,11 +6,15 @@ from openscvx.symbolic.expr import Add, Concat, Constant, Control, CrossNodeCons
 from openscvx.symbolic.preprocessing import (
     collect_and_assign_slices,
     convert_dynamics_dict_to_expr,
+    fill_default_guesses,
+    validate_boundary_conditions,
+    validate_bounds,
     validate_constraints_at_root,
     validate_cross_node_constraint,
     validate_dynamics_dict,
     validate_dynamics_dict_dimensions,
     validate_dynamics_dimension,
+    validate_guesses,
     validate_variable_names,
 )
 
@@ -801,3 +805,174 @@ def test_cross_node_constraint_both_sides():
     constraint2 = CrossNodeConstraint(velocity <= position.at(5))
     with pytest.raises(ValueError, match="without .at\\(\\).*vel"):
         validate_cross_node_constraint(constraint2, N)
+
+
+# =============================================================================
+# fill_default_guesses Tests
+# =============================================================================
+
+
+def test_fill_default_guesses_state_linspace():
+    """Test that state guesses are filled with linspace from initial to final."""
+    N = 11  # Use 11 so middle index (5) is exactly at midpoint
+    x = State("x", shape=(3,))
+    x.initial = np.array([0.0, 1.0, 2.0])
+    x.final = np.array([10.0, 11.0, 12.0])
+
+    fill_default_guesses([x], N)
+
+    assert x.guess is not None
+    assert x.guess.shape == (N, 3)
+    # Check first and last rows match initial and final
+    np.testing.assert_array_almost_equal(x.guess[0], [0.0, 1.0, 2.0])
+    np.testing.assert_array_almost_equal(x.guess[-1], [10.0, 11.0, 12.0])
+    # Check it's actually a linspace (middle index should be exactly at midpoint)
+    np.testing.assert_array_almost_equal(x.guess[N // 2], [5.0, 6.0, 7.0])
+
+
+def test_fill_default_guesses_preserves_existing():
+    """Test that existing guesses are not overwritten."""
+    N = 10
+    x = State("x", shape=(2,))
+    x.initial = np.array([0.0, 0.0])
+    x.final = np.array([10.0, 10.0])
+    custom_guess = np.ones((N, 2)) * 99.0
+    x.guess = custom_guess
+
+    fill_default_guesses([x], N)
+
+    # Guess should be unchanged
+    np.testing.assert_array_equal(x.guess, custom_guess)
+
+
+def test_fill_default_guesses_with_free_boundary_conditions():
+    """Test that states with free boundary conditions use the guess values."""
+    N = 10
+    x = State("x", shape=(3,))
+    # Mixed: first fixed, second free, third fixed
+    x.initial = [0.0, ("free", 5.0), 2.0]
+    x.final = [10.0, ("free", 15.0), 12.0]
+
+    fill_default_guesses([x], N)
+
+    assert x.guess is not None
+    assert x.guess.shape == (N, 3)
+    # The setter extracts values from tuples, so initial=[0, 5, 2], final=[10, 15, 12]
+    np.testing.assert_array_almost_equal(x.guess[0], [0.0, 5.0, 2.0])
+    np.testing.assert_array_almost_equal(x.guess[-1], [10.0, 15.0, 12.0])
+
+
+def test_fill_default_guesses_multiple_states():
+    """Test filling guesses for multiple states at once."""
+    N = 5
+    x1 = State("x1", shape=(2,))
+    x1.initial = np.array([0.0, 0.0])
+    x1.final = np.array([4.0, 8.0])
+
+    x2 = State("x2", shape=(1,))
+    x2.initial = np.array([10.0])
+    x2.final = np.array([20.0])
+
+    fill_default_guesses([x1, x2], N)
+
+    # Check x1
+    assert x1.guess.shape == (N, 2)
+    np.testing.assert_array_almost_equal(x1.guess[0], [0.0, 0.0])
+    np.testing.assert_array_almost_equal(x1.guess[-1], [4.0, 8.0])
+
+    # Check x2
+    assert x2.guess.shape == (N, 1)
+    np.testing.assert_array_almost_equal(x2.guess[0], [10.0])
+    np.testing.assert_array_almost_equal(x2.guess[-1], [20.0])
+
+
+# =============================================================================
+# validate_boundary_conditions Tests
+# =============================================================================
+
+
+def test_validate_boundary_conditions_passes():
+    """Test that validation passes when all states have initial and final."""
+    x = State("position", shape=(3,))
+    x.initial = np.zeros(3)
+    x.final = np.ones(3)
+
+    validate_boundary_conditions([x])
+    validate_boundary_conditions([])
+
+
+def test_validate_boundary_conditions_raises_missing():
+    """Test that validation fails fast on first missing attribute."""
+    x = State("position", shape=(2,))
+    # No initial or final set
+
+    with pytest.raises(ValueError, match="'position' is missing initial"):
+        validate_boundary_conditions([x])
+
+    # With initial but no final
+    x.initial = np.zeros(2)
+    with pytest.raises(ValueError, match="'position' is missing final"):
+        validate_boundary_conditions([x])
+
+
+# =============================================================================
+# validate_bounds Tests
+# =============================================================================
+
+
+def test_validate_bounds_passes():
+    """Test that validation passes when all variables have min and max."""
+    x = State("position", shape=(3,))
+    x.min = np.array([-10, -10, -10])
+    x.max = np.array([10, 10, 10])
+
+    u = Control("thrust", shape=(2,))
+    u.min = np.zeros(2)
+    u.max = np.array([100, 100])
+
+    validate_bounds([x, u])
+    validate_bounds([])
+
+
+def test_validate_bounds_raises_missing():
+    """Test that validation fails fast on first missing attribute."""
+    u = Control("thrust", shape=(2,))
+    # No min or max set
+
+    with pytest.raises(ValueError, match="'thrust' is missing min"):
+        validate_bounds([u])
+
+    # With min but no max
+    u.min = np.zeros(2)
+    with pytest.raises(ValueError, match="'thrust' is missing max"):
+        validate_bounds([u])
+
+
+# =============================================================================
+# validate_guesses Tests
+# =============================================================================
+
+
+def test_validate_guesses_passes():
+    """Test that validation passes when all variables have guesses."""
+    N = 10
+    x = State("position", shape=(3,))
+    x.guess = np.zeros((N, 3))
+
+    u = Control("thrust", shape=(2,))
+    u.guess = np.ones((N, 2))
+
+    validate_guesses([x, u])
+    validate_guesses([])
+
+
+def test_validate_guesses_raises_missing():
+    """Test that validation fails fast on first missing guess."""
+    u = Control("thrust", shape=(2,))
+    # No guess set
+
+    with pytest.raises(
+        ValueError,
+        match="Control 'thrust' is missing initial guess.*controls require explicit guesses",
+    ):
+        validate_guesses([u])