openscvx 2.dev5__tar.gz → 2.dev6__tar.gz

{openscvx-2.dev5/openscvx.egg-info → openscvx-2.dev6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openscvx
-Version: 2.dev5
+Version: 2.dev6
 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-2.dev5 → openscvx-2.dev6}/openscvx/__init__.py

@@ -12,6 +12,7 @@ import openscvx.symbolic.expr.spatial as spatial
 import openscvx.symbolic.expr.stl as stl
 import openscvx.symbolic.expr.stljax as stljax
 from openscvx.algorithms import (
+    AdaptiveProximalWeight,
     AugmentedLagrangian,
     ConstantProximalWeight,
     PenalizedTrustRegion,
@@ -190,6 +191,7 @@ __all__ = [
     # Algorithm & Autotuning
     "PenalizedTrustRegion",
     "AugmentedLagrangian",
+    "AdaptiveProximalWeight",
     "ConstantProximalWeight",
     "RampProximalWeight",
 ]

{openscvx-2.dev5 → openscvx-2.dev6}/openscvx/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '2.dev5'
-__version_tuple__ = version_tuple = (2, 'dev5')
+__version__ = version = '2.dev6'
+__version_tuple__ = version_tuple = (2, 'dev6')
 
-__commit_id__ = commit_id = 'g4161a5a13'
+__commit_id__ = commit_id = 'gcabefce07'

{openscvx-2.dev5 → openscvx-2.dev6}/openscvx/algorithms/__init__.py

@@ -82,12 +82,19 @@ from typing import Annotated, Any, Dict, List, Optional, Union
 
 from pydantic import BaseModel, ConfigDict, Field, field_validator
 
-from .augmented_lagrangian import AugmentedLagrangian, AugmentedLagrangianSpec
+from .autotuner import (
+    AdaptiveProximalWeight,
+    AdaptiveProximalWeightSpec,
+    AugmentedLagrangian,
+    AugmentedLagrangianSpec,
+    ConstantProximalWeight,
+    ConstantProximalWeightSpec,
+    RampProximalWeight,
+    RampProximalWeightSpec,
+)
 from .base import Algorithm, AlgorithmState, AutotuningBase, DiscretizationResult
-from .constant_proximal_weight import ConstantProximalWeight, ConstantProximalWeightSpec
 from .optimization_results import OptimizationResults
-from .penalized_trust_region import PenalizedTrustRegion
-from .ramp_proximal_weight import RampProximalWeight, RampProximalWeightSpec
+from .scvx import PenalizedTrustRegion
 from .weights import Weights
 
 # ---------------------------------------------------------------------------
@@ -97,6 +104,7 @@ from .weights import Weights
 AutotunerConfig = Annotated[
     Union[
         AugmentedLagrangianSpec,
+        AdaptiveProximalWeightSpec,
         RampProximalWeightSpec,
         ConstantProximalWeightSpec,
     ],
@@ -173,6 +181,7 @@ __all__ = [
     "PenalizedTrustRegion",
     "AutotuningBase",
     "AugmentedLagrangian",
+    "AdaptiveProximalWeight",
     "ConstantProximalWeight",
     "RampProximalWeight",
     # Config models

openscvx-2.dev6/openscvx/algorithms/autotuner/__init__.py

@@ -0,0 +1,17 @@
+"""SCP weight autotuning strategies."""
+
+from .adaptive_proximal_weight import AdaptiveProximalWeight, AdaptiveProximalWeightSpec
+from .augmented_lagrangian import AugmentedLagrangian, AugmentedLagrangianSpec
+from .constant_proximal_weight import ConstantProximalWeight, ConstantProximalWeightSpec
+from .ramp_proximal_weight import RampProximalWeight, RampProximalWeightSpec
+
+__all__ = [
+    "AdaptiveProximalWeight",
+    "AdaptiveProximalWeightSpec",
+    "AugmentedLagrangian",
+    "AugmentedLagrangianSpec",
+    "ConstantProximalWeight",
+    "ConstantProximalWeightSpec",
+    "RampProximalWeight",
+    "RampProximalWeightSpec",
+]

openscvx-2.dev6/openscvx/algorithms/autotuner/adaptive_proximal_weight.py

@@ -0,0 +1,190 @@
+"""Autotuning functions for SCP (Successive Convex Programming) parameters."""
+
+from copy import deepcopy
+from typing import TYPE_CHECKING, Literal
+
+import numpy as np
+from pydantic import BaseModel, ConfigDict
+
+from openscvx.config import Config
+
+from ..base import AutotuningBase
+from .augmented_lagrangian import AugmentedLagrangian
+
+if TYPE_CHECKING:
+    from openscvx.lowered import LoweredJaxConstraints
+
+    from ..base import AlgorithmState, CandidateIterate
+    from ..weights import Weights
+
+
+class AdaptiveProximalWeight(AutotuningBase):
+    """PTR-style proximal adaptation with fixed virtual penalty weights.
+
+    Same acceptance-ratio logic as :class:`AugmentedLagrangian` for ``lam_prox``,
+    but ``lam_vc`` and ``lam_vb_*`` are held constant at their current state values.
+    """
+
+    COLUMNS = AugmentedLagrangian.COLUMNS
+
+    def __init__(
+        self,
+        gamma_1: float = 2.0,
+        gamma_2: float = 0.5,
+        eta_0: float = 1e-2,
+        eta_1: float = 1e-1,
+        eta_2: float = 0.8,
+        lam_prox_min: float = 1e-3,
+        lam_prox_max: float = 1e4,
+        lam_cost_drop: int = -1,
+        lam_cost_relax: float = 1.0,
+    ):
+        self.gamma_1 = gamma_1
+        self.gamma_2 = gamma_2
+        self.eta_0 = eta_0
+        self.eta_1 = eta_1
+        self.eta_2 = eta_2
+        self.lam_prox_min = lam_prox_min
+        self.lam_prox_max = lam_prox_max
+        self.lam_cost_drop = lam_cost_drop
+        self.lam_cost_relax = lam_cost_relax
+
+    @staticmethod
+    def _copy_virtual_weights(
+        candidate: "CandidateIterate",
+        state: "AlgorithmState",
+    ) -> None:
+        candidate.lam_vc = state.lam_vc
+        candidate.lam_vb_nodal = state.lam_vb_nodal
+        candidate.lam_vb_cross = state.lam_vb_cross
+
+    def update_weights(
+        self,
+        state: "AlgorithmState",
+        candidate: "CandidateIterate",
+        nodal_constraints: "LoweredJaxConstraints",
+        settings: Config,
+        params: dict,
+        weights: "Weights",
+    ) -> str:
+        """Update SCP proximal weight based on acceptance ratio; keep VC/VB fixed."""
+        candidate_x_prop = (
+            candidate.x_prop_plus[1:] if candidate.x_prop_plus is not None else candidate.x_prop
+        )
+        (
+            nonlinear_cost,
+            nonlinear_penalty,
+            nodal_penalty,
+        ) = self.calculate_nonlinear_penalty(
+            candidate_x_prop,
+            candidate.x,
+            candidate.u,
+            state.lam_vc,
+            state.lam_vb_nodal,
+            state.lam_vb_cross,
+            state.lam_cost,
+            nodal_constraints,
+            params,
+            settings,
+        )
+
+        candidate.J_nonlin = nonlinear_cost + nonlinear_penalty + nodal_penalty
+
+        if state.k > self.lam_cost_drop:
+            candidate.lam_cost = state.lam_cost * self.lam_cost_relax
+        else:
+            candidate.lam_cost = weights.lam_cost
+
+        lam_prox_k = deepcopy(state.lam_prox)
+
+        if state.k > 1:
+            state_x_prop_plus = state.x_prop_plus()
+            state_x_prop = (
+                state_x_prop_plus[1:] if state_x_prop_plus is not None else state.x_prop()
+            )
+            (
+                prev_nonlinear_cost,
+                prev_nonlinear_penalty,
+                prev_nodal_penalty,
+            ) = self.calculate_nonlinear_penalty(
+                state_x_prop,
+                state.x,
+                state.u,
+                state.lam_vc,
+                state.lam_vb_nodal,
+                state.lam_vb_cross,
+                state.lam_cost,
+                nodal_constraints,
+                params,
+                settings,
+            )
+
+            J_nonlin_prev = prev_nonlinear_cost + prev_nonlinear_penalty + prev_nodal_penalty
+
+            actual_reduction = J_nonlin_prev - candidate.J_nonlin
+            predicted_reduction = J_nonlin_prev - candidate.J_lin
+
+            if predicted_reduction == 0:
+                raise ValueError("Predicted reduction is 0.")
+
+            rho = actual_reduction / predicted_reduction
+
+            state.pred_reduction_history.append(predicted_reduction)
+            state.actual_reduction_history.append(actual_reduction)
+            state.acceptance_ratio_history.append(rho)
+
+            if rho < self.eta_0:
+                lam_prox_k1 = np.minimum(self.lam_prox_max, self.gamma_1 * lam_prox_k)
+                candidate.lam_prox = lam_prox_k1
+                state.reject_solution(candidate)
+                adaptive_state = "Reject Higher"
+            elif rho >= self.eta_0 and rho < self.eta_1:
+                lam_prox_k1 = np.minimum(self.lam_prox_max, self.gamma_1 * lam_prox_k)
+                candidate.lam_prox = lam_prox_k1
+                self._copy_virtual_weights(candidate, state)
+                state.accept_solution(candidate)
+                adaptive_state = "Accept Higher"
+            elif rho >= self.eta_1 and rho < self.eta_2:
+                candidate.lam_prox = lam_prox_k
+                self._copy_virtual_weights(candidate, state)
+                state.accept_solution(candidate)
+                adaptive_state = "Accept Constant"
+            else:
+                lam_prox_k1 = np.maximum(self.lam_prox_min, self.gamma_2 * lam_prox_k)
+                candidate.lam_prox = lam_prox_k1
+                self._copy_virtual_weights(candidate, state)
+                state.accept_solution(candidate)
+                adaptive_state = "Accept Lower"
+
+        else:
+            candidate.lam_prox = lam_prox_k
+            self._copy_virtual_weights(candidate, state)
+            state.accept_solution(candidate)
+            adaptive_state = "Initial"
+
+        return adaptive_state
+
+
+# =============================================================================
+# Pydantic spec for dict / YAML validation
+# =============================================================================
+
+
+class AdaptiveProximalWeightSpec(BaseModel):
+    """Validates AdaptiveProximalWeight configuration from dict/YAML input."""
+
+    type: Literal["AdaptiveProximalWeight"] = "AdaptiveProximalWeight"
+    gamma_1: float = 2.0
+    gamma_2: float = 0.5
+    eta_0: float = 1e-2
+    eta_1: float = 1e-1
+    eta_2: float = 0.8
+    lam_prox_min: float = 1e-3
+    lam_prox_max: float = 1e4
+    lam_cost_drop: int = -1
+    lam_cost_relax: float = 1.0
+
+    model_config = ConfigDict(extra="forbid")
+
+    def build(self) -> AdaptiveProximalWeight:
+        return AdaptiveProximalWeight(**self.model_dump(exclude={"type"}, exclude_unset=True))

{openscvx-2.dev5/openscvx/algorithms → openscvx-2.dev6/openscvx/algorithms/autotuner}/augmented_lagrangian.py

@@ -14,13 +14,13 @@ from openscvx.utils.printing import (
     color_adaptive_state,
 )
 
-from .base import AutotuningBase
+from ..base import AutotuningBase
 
 if TYPE_CHECKING:
     from openscvx.lowered import LoweredJaxConstraints
 
-    from .base import AlgorithmState, CandidateIterate
-    from .weights import Weights
+    from ..base import AlgorithmState, CandidateIterate
+    from ..weights import Weights
 
 
 class AugmentedLagrangian(AutotuningBase):
@@ -86,8 +86,12 @@ class AugmentedLagrangian(AutotuningBase):
             eta_2: Threshold above which solution is accepted with lower weight.
                 Defaults to 0.8.
             ep: Threshold for virtual control weight update (nu > ep vs nu <= ep).
-                Defaults to 0.5.
-            eta_lambda: Step size for virtual control weight update. Defaults to 1e0.
+                Must lie in (0, 1). Defaults to 0.99; when tuning, try 1e-1 if needed.
+                Typically tuned together with ``eta_lambda`` (often the first
+                parameters adjusted).
+            eta_lambda: Step size for virtual control weight update. Defaults to 1e1.
+                Typically tuned together with ``ep`` (often the first parameters
+                adjusted).
             lam_vc_max: Maximum virtual control penalty weight. Defaults to 1e5.
             lam_prox_min: Minimum trust region (proximal) weight. Defaults to 1e-3.
             lam_prox_max: Maximum trust region (proximal) weight. Defaults to 2e5.

{openscvx-2.dev5/openscvx/algorithms → openscvx-2.dev6/openscvx/algorithms/autotuner}/constant_proximal_weight.py

@@ -6,13 +6,13 @@ from pydantic import BaseModel, ConfigDict
 
 from openscvx.config import Config
 
-from .base import AutotuningBase
+from ..base import AutotuningBase
 
 if TYPE_CHECKING:
     from openscvx.lowered import LoweredJaxConstraints
 
-    from .base import AlgorithmState, CandidateIterate
-    from .weights import Weights
+    from ..base import AlgorithmState, CandidateIterate
+    from ..weights import Weights
 
 
 class ConstantProximalWeight(AutotuningBase):

{openscvx-2.dev5/openscvx/algorithms → openscvx-2.dev6/openscvx/algorithms/autotuner}/ramp_proximal_weight.py

@@ -7,13 +7,13 @@ from pydantic import BaseModel, ConfigDict
 
 from openscvx.config import Config
 
-from .base import AutotuningBase
+from ..base import AutotuningBase
 
 if TYPE_CHECKING:
     from openscvx.lowered import LoweredJaxConstraints
 
-    from .base import AlgorithmState, CandidateIterate
-    from .weights import Weights
+    from ..base import AlgorithmState, CandidateIterate
+    from ..weights import Weights
 
 
 class RampProximalWeight(AutotuningBase):

openscvx-2.dev6/openscvx/algorithms/scvx/__init__.py

@@ -0,0 +1,5 @@
+"""Successive convexification algorithm implementations."""
+
+from .penalized_trust_region import PenalizedTrustRegion
+
+__all__ = ["PenalizedTrustRegion"]

{openscvx-2.dev5/openscvx/algorithms → openscvx-2.dev6/openscvx/algorithms/scvx}/penalized_trust_region.py

@@ -22,11 +22,11 @@ from openscvx.utils.printing import (
     color_prob_stat,
 )
 
-from .augmented_lagrangian import AugmentedLagrangian
-from .base import Algorithm, AlgorithmState, CandidateIterate
-from .constant_proximal_weight import ConstantProximalWeight
-from .ramp_proximal_weight import RampProximalWeight
-from .weights import Weights
+from ..autotuner.augmented_lagrangian import AugmentedLagrangian
+from ..autotuner.constant_proximal_weight import ConstantProximalWeight
+from ..autotuner.ramp_proximal_weight import RampProximalWeight
+from ..base import Algorithm, AlgorithmState, CandidateIterate
+from ..weights import Weights
 
 if TYPE_CHECKING:
     from openscvx.lowered import LoweredJaxConstraints
@@ -34,7 +34,7 @@ if TYPE_CHECKING:
     from openscvx.symbolic.expr.control import Control
     from openscvx.symbolic.expr.state import State
 
-    from .base import AutotuningBase
+    from ..base import AutotuningBase
 
 warnings.filterwarnings("ignore")
 

{openscvx-2.dev5 → openscvx-2.dev6/openscvx.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openscvx
-Version: 2.dev5
+Version: 2.dev6
 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-2.dev5 → openscvx-2.dev6}/openscvx.egg-info/SOURCES.txt

@@ -152,13 +152,16 @@ openscvx.egg-info/entry_points.txt
 openscvx.egg-info/requires.txt
 openscvx.egg-info/top_level.txt
 openscvx/algorithms/__init__.py
-openscvx/algorithms/augmented_lagrangian.py
 openscvx/algorithms/base.py
-openscvx/algorithms/constant_proximal_weight.py
 openscvx/algorithms/optimization_results.py
-openscvx/algorithms/penalized_trust_region.py
-openscvx/algorithms/ramp_proximal_weight.py
 openscvx/algorithms/weights.py
+openscvx/algorithms/autotuner/__init__.py
+openscvx/algorithms/autotuner/adaptive_proximal_weight.py
+openscvx/algorithms/autotuner/augmented_lagrangian.py
+openscvx/algorithms/autotuner/constant_proximal_weight.py
+openscvx/algorithms/autotuner/ramp_proximal_weight.py
+openscvx/algorithms/scvx/__init__.py
+openscvx/algorithms/scvx/penalized_trust_region.py
 openscvx/discretization/__init__.py
 openscvx/discretization/base.py
 openscvx/discretization/discretize_linearize.py

{openscvx-2.dev5 → openscvx-2.dev6}/tests/test_autotuning.py

@@ -3,16 +3,20 @@
 import numpy as np
 import pytest
 
-from openscvx.algorithms.augmented_lagrangian import AugmentedLagrangian
+from openscvx.algorithms import (
+    AdaptiveProximalWeight,
+    AugmentedLagrangian,
+    ConstantProximalWeight,
+    PenalizedTrustRegion,
+    PenalizedTrustRegionConfig,
+    RampProximalWeight,
+)
 from openscvx.algorithms.base import (
     AlgorithmState,
     AutotuningBase,
     CandidateIterate,
     DiscretizationResult,
 )
-from openscvx.algorithms.constant_proximal_weight import ConstantProximalWeight
-from openscvx.algorithms.penalized_trust_region import PenalizedTrustRegion
-from openscvx.algorithms.ramp_proximal_weight import RampProximalWeight
 from openscvx.algorithms.weights import Weights
 from openscvx.config import (
     Config,
@@ -1434,6 +1438,194 @@ def test_augmented_lagrangian_exported():
     assert auto_tuner.lam_prox_max == 1e6
 
 
+# --- Tests for AdaptiveProximalWeight --------------------------------------------
+
+
+def test_adaptive_proximal_weight_initial_iteration(
+    settings, algorithm_state, empty_nodal_constraints, weights
+):
+    """AdaptiveProximalWeight on k=1 copies VC/VB from state and accepts."""
+    autotuner = AdaptiveProximalWeight()
+    algorithm_state.k = 1
+    candidate = CandidateIterate()
+    candidate.x = np.array([[0.0, 0.0], [1.0, 1.0], [2.0, 2.0]])
+    candidate.x_prop = np.array([[0.5, 0.5], [1.5, 1.5]])
+    candidate.u = np.array([[0.0], [0.5], [1.0]])
+    candidate.J_lin = 10.0
+
+    params = {}
+    initial_x_len = len(algorithm_state.X)
+    lam_vc_prev = algorithm_state.lam_vc
+    lam_vb_nodal_prev = algorithm_state.lam_vb_nodal
+
+    adaptive_state = autotuner.update_weights(
+        algorithm_state, candidate, empty_nodal_constraints, settings, params, weights
+    )
+
+    assert adaptive_state == "Initial"
+    assert len(algorithm_state.X) == initial_x_len + 1
+    np.testing.assert_allclose(candidate.lam_vc, lam_vc_prev)
+    np.testing.assert_allclose(candidate.lam_vb_nodal, lam_vb_nodal_prev)
+    assert len(algorithm_state.lam_vc_history) == 2
+    np.testing.assert_allclose(algorithm_state.lam_vc_history[-1], lam_vc_prev)
+
+
+def test_adaptive_proximal_weight_accept_lower_fixed_vc_vb(
+    settings, algorithm_state, nodal_constraints_with_violations, weights
+):
+    """Accept Lower decreases lam_prox but leaves lam_vc / lam_vb unchanged."""
+    autotuner = AdaptiveProximalWeight()
+    algorithm_state.k = 2
+    algorithm_state.lam_prox_history = [np.full((3, 3), 1.0)]
+    algorithm_state.lam_vc_history = [np.array([1.0, 1.0])]
+    algorithm_state.lam_vb_nodal_history = [np.full((3, 1), 1.0)]
+    algorithm_state.lam_vb_cross_history = [np.full(0, 1.0)]
+
+    algorithm_state.X.append(np.array([[0.0, 0.0], [1.0, 1.0], [2.0, 2.0]]))
+    algorithm_state.U.append(np.array([[0.0], [0.5], [1.0]]))
+
+    i4 = 2 + 4 + 4
+    flattened_size = (3 - 1) * i4
+    V_dummy = np.zeros((flattened_size, 5))
+    V_final = V_dummy[:, -1].reshape(-1, i4)
+    V_final[:, :2] = np.array([[0.0, 0.0], [1.0, 1.0]])
+    V_dummy[:, -1] = V_final.flatten()
+    algorithm_state.discretizations.append(
+        DiscretizationResult.from_V(
+            V_dummy, n_x=algorithm_state.n_x, n_u=algorithm_state.n_u, N=algorithm_state.N
+        )
+    )
+
+    candidate = CandidateIterate()
+    candidate.x = np.array([[0.0, 0.0], [1.0, 1.0], [2.0, 2.0]])
+    candidate.x_prop = np.array([[0.5, 0.5], [1.5, 1.5]])
+    candidate.u = np.array([[0.0], [0.5], [1.0]])
+    params = {}
+
+    state_x_prop = algorithm_state.x_prop()
+    lam_vc_prev = algorithm_state.lam_vc
+    lam_vb_nodal_prev = algorithm_state.lam_vb_nodal
+    lam_vb_cross_prev = algorithm_state.lam_vb_cross
+    lam_cost_prev = algorithm_state.lam_cost
+
+    prev_cost, prev_penalty, prev_nodal = AutotuningBase.calculate_nonlinear_penalty(
+        state_x_prop,
+        algorithm_state.x,
+        algorithm_state.u,
+        lam_vc_prev,
+        lam_vb_nodal_prev,
+        lam_vb_cross_prev,
+        lam_cost_prev,
+        nodal_constraints_with_violations,
+        params,
+        settings,
+    )
+    J_nonlin_prev = prev_cost + prev_penalty + prev_nodal
+
+    cand_cost, cand_penalty, cand_nodal = AutotuningBase.calculate_nonlinear_penalty(
+        candidate.x_prop,
+        candidate.x,
+        candidate.u,
+        lam_vc_prev,
+        lam_vb_nodal_prev,
+        lam_vb_cross_prev,
+        lam_cost_prev,
+        nodal_constraints_with_violations,
+        params,
+        settings,
+    )
+    J_nonlin_cand = cand_cost + cand_penalty + cand_nodal
+
+    actual_reduction = J_nonlin_prev - J_nonlin_cand
+    rho_target = autotuner.eta_2 + 0.1 * (1.0 - autotuner.eta_2)
+    predicted_reduction = actual_reduction / rho_target
+    candidate.J_lin = J_nonlin_prev - predicted_reduction
+
+    lam_prox_prev = algorithm_state.lam_prox
+
+    adaptive_state = autotuner.update_weights(
+        algorithm_state,
+        candidate,
+        nodal_constraints_with_violations,
+        settings,
+        params,
+        weights,
+    )
+
+    assert adaptive_state == "Accept Lower"
+    expected_prox = np.maximum(autotuner.lam_prox_min, autotuner.gamma_2 * lam_prox_prev)
+    np.testing.assert_allclose(algorithm_state.lam_prox_history[1], expected_prox)
+    np.testing.assert_allclose(candidate.lam_vc, lam_vc_prev)
+    np.testing.assert_allclose(candidate.lam_vb_nodal, lam_vb_nodal_prev)
+    np.testing.assert_allclose(candidate.lam_vb_cross, lam_vb_cross_prev)
+
+
+def test_adaptive_proximal_weight_reject_increase(
+    settings, algorithm_state, empty_nodal_constraints, weights
+):
+    """Reject branch increases lam_prox and does not update lam_vc history."""
+    autotuner = AdaptiveProximalWeight()
+    algorithm_state.k = 2
+    algorithm_state.lam_prox_history = [np.full((3, 3), 1.0)]
+    algorithm_state.lam_vc_history = [np.array([1.0, 1.0])]
+
+    algorithm_state.X.append(np.array([[0.0, 0.0], [1.0, 1.0], [2.0, 2.0]]))
+    algorithm_state.U.append(np.array([[0.0], [0.5], [1.0]]))
+
+    i4 = 2 + 4 + 4
+    flattened_size = (3 - 1) * i4
+    V_dummy = np.zeros((flattened_size, 5))
+    V_final = V_dummy[:, -1].reshape(-1, i4)
+    V_final[:, :2] = np.array([[0.0, 0.0], [1.0, 1.0]])
+    V_dummy[:, -1] = V_final.flatten()
+    algorithm_state.discretizations.append(
+        DiscretizationResult.from_V(
+            V_dummy, n_x=algorithm_state.n_x, n_u=algorithm_state.n_u, N=algorithm_state.N
+        )
+    )
+
+    candidate = CandidateIterate()
+    candidate.x = np.array([[0.0, 0.0], [1.0, 1.0], [2.0, 2.0]])
+    candidate.x_prop = np.array([[0.0, 0.0], [1.0, 1.0]])
+    candidate.u = np.array([[0.0], [0.5], [1.0]])
+    candidate.J_lin = 10.0
+
+    params = {}
+    lam_prox_prev = algorithm_state.lam_prox
+    lam_vc_prev = algorithm_state.lam_vc
+
+    adaptive_state = autotuner.update_weights(
+        algorithm_state, candidate, empty_nodal_constraints, settings, params, weights
+    )
+
+    assert adaptive_state == "Reject Higher"
+    assert candidate.lam_vc is None
+    np.testing.assert_allclose(
+        algorithm_state.lam_prox_history[1], autotuner.gamma_1 * lam_prox_prev
+    )
+    assert len(algorithm_state.lam_vc_history) == 1
+    assert np.allclose(algorithm_state.lam_vc_history[0], lam_vc_prev)
+
+
+def test_penalized_trust_region_config_adaptive_proximal_weight():
+    """Dict/YAML autotuner config builds AdaptiveProximalWeight."""
+    cfg = PenalizedTrustRegionConfig(
+        autotuner={"type": "AdaptiveProximalWeight", "gamma_1": 3.0},
+    )
+    algorithm = cfg.to_algorithm()
+    assert isinstance(algorithm.autotuner, AdaptiveProximalWeight)
+    assert algorithm.autotuner.gamma_1 == 3.0
+
+
+def test_adaptive_proximal_weight_exported():
+    """AdaptiveProximalWeight is exported from the top-level openscvx namespace."""
+    import openscvx as ox
+
+    autotuner = ox.AdaptiveProximalWeight()
+    assert isinstance(autotuner, AdaptiveProximalWeight)
+    assert autotuner.gamma_1 == 2.0
+
+
 # --- Tests for ConstantProximalWeight ---------------------------------------------
 
 

{openscvx-2.dev5 → openscvx-2.dev6}/tests/test_brachistochrone.py

@@ -367,6 +367,7 @@ def test_constraint_types(constraint_type):
     "autotuner_spec",
     [
         "augmented_lagrangian",
+        "adaptive_proximal",
         "constant_proximal",
         "ramp_proximal",
         "string_augmented_lagrangian",
@@ -445,6 +446,8 @@ def test_autotuning(autotuner_spec):
 
     if autotuner_spec == "augmented_lagrangian":
         autotuner = ox.AugmentedLagrangian()
+    elif autotuner_spec == "adaptive_proximal":
+        autotuner = ox.AdaptiveProximalWeight()
     elif autotuner_spec == "constant_proximal":
         autotuner = ox.ConstantProximalWeight()
     elif autotuner_spec == "ramp_proximal":