cbfpy 0.0.1__py3-none-any.whl

cbfpy/config/cbf_config.py

@@ -0,0 +1,401 @@
+"""
+# CBF Configuration class
+
+## Defining the problem:
+
+CBFs have two primary implementation requirements: the dynamics functions, and the barrier function(s). 
+These can be specified through the `f`, `g`, and `h` methods, respectively. Note that the main requirements
+for these functions are that (1) the dynamics are control-affine, and (2) the barrier function(s) are "zeroing"
+barriers, as opposed to "reciprocal" barriers. A zeroing barrier is one which is positive in the interior of the
+safe set, and zero on the boundary. 
+
+Depending on the relative degree of your barrier function(s), you should implement the `h_1` method 
+(for a relative-degree-1 barrier), and/or the `h_2` method (for a relative-degree-2 barrier).
+
+## Tuning the CBF:
+
+The CBF config provides a default implementation of the CBF "gain" function `alpha`, and `alpha_2` for
+relative-degree-2 barriers. To change the sensitivity of the CBF, these functions can be modified to
+increase or decrease the effect of the barrier(s). For instance, `alpha(h) = h` is the default implementation,
+but to increase the sensitivity of the CBF, one could use `alpha(h) = 2 * h`. The only requirements for these
+functions are that they are monotonically increasing and pass through the origin (class Kappa functions).
+
+The CBFConfig also provides a default implementation of the CBF QP objective function, which is to minimize
+the norm of the difference between the safe control input and the desired control input. This can also be modified
+through the `P` and `q` methods, which define the quadratic and linear terms in the QP objective, respectively. This
+does require that P is positive semi-definite.
+
+## Relaxation:
+
+Depending on the construction of the barrier functions and if control limits are provided, the CBF QP may not always be
+feasible. If allowing for relaxation in the CBFConfig, a slack variable will be introduced to ensure that the
+problem is always feasible, with a high penalty on any infeasibility. This is generally useful for controller
+robustness, but means that safety is not guaranteed. 
+
+If strict enforcement of the CBF is desired, your higest-level controller should handle the case where the QP
+is infeasible.
+"""
+
+from typing import Optional, Callable
+from abc import ABC, abstractmethod
+
+import numpy as np
+import jax
+import jax.numpy as jnp
+from jax import Array
+from jax.typing import ArrayLike
+
+
+class CBFConfig(ABC):
+    """Control Barrier Function (CBF) configuration class.
+
+    This is an abstract class which requires implementation of the following methods:
+
+    - `f(z)`: The uncontrolled dynamics function
+    - `g(z)`: The control affine dynamics function
+    - `h_1(z)` and/or `h_2(z)`: The barrier function(s), of relative degree 1 and/or 2
+
+    For finer-grained control over the CBF, the following methods may be updated from their defaults:
+
+    - `alpha(h)`: "Gain" of the CBF
+    - `alpha_2(h_2)`: "Gain" of the relative-degree-2 CBFs, if applicable
+    - `P(z, u_des)`: Quadratic term in the CBF QP objective
+    - `q(z, u_des)`: Linear term in the CBF QP objective
+
+    Args:
+        n (int): State dimension
+        m (int): Control dimension
+        u_min (ArrayLike, optional): Minimum control input, shape (m,). Defaults to None (Unconstrained).
+        u_max (ArrayLike, optional): Maximum control input, shape (m,). Defaults to None (Unconstrained).
+        relax_cbf (bool, optional): Whether to allow for relaxation in the CBF QP. Defaults to True.
+        cbf_relaxation_penalty (float, optional): Penalty on the slack variable in the relaxed CBF QP. Defaults to 1e3.
+            Note: only applies if relax_cbf is True.
+        solver_tol (float, optional): Tolerance for the QP solver. Defaults to 1e-3.
+        init_args (tuple, optional): If your barrier function relies on additional arguments other than just the state,
+            include an initial seed for these arguments here. This is to help test the output of the barrier function.
+            Defaults to ().
+    """
+
+    def __init__(
+        self,
+        n: int,
+        m: int,
+        u_min: Optional[ArrayLike] = None,
+        u_max: Optional[ArrayLike] = None,
+        relax_cbf: bool = True,
+        cbf_relaxation_penalty: float = 1e3,
+        solver_tol: float = 1e-3,
+        init_args: tuple = (),
+    ):
+        if not (isinstance(n, int) and n > 0):
+            raise ValueError(f"n must be a positive integer. Got: {n}")
+        self.n = n
+
+        if not (isinstance(m, int) and m > 0):
+            raise ValueError(f"m must be a positive integer. Got: {m}")
+        self.m = m
+
+        if not isinstance(relax_cbf, bool):
+            raise ValueError(f"relax_cbf must be a boolean. Got: {relax_cbf}")
+        self.relax_cbf = relax_cbf
+
+        if not (
+            isinstance(cbf_relaxation_penalty, (int, float))
+            and cbf_relaxation_penalty >= 0
+        ):
+            raise ValueError(
+                f"CBF relaxation penalty must be a non-negative value. Got: {cbf_relaxation_penalty}"
+            )
+        self.cbf_relaxation_penalty = float(cbf_relaxation_penalty)
+
+        if not (isinstance(solver_tol, (int, float)) and solver_tol > 0):
+            raise ValueError(f"solver_tol must be a positive value. Got: {solver_tol}")
+        self.solver_tol = float(solver_tol)
+
+        if not isinstance(init_args, tuple):
+            raise ValueError(f"init_args must be a tuple. Got: {init_args}")
+        self.init_args = init_args
+
+        # Control limits require a bit of extra handling. They can be both None if unconstrained,
+        # but we should not have one limit as None and the other as some value
+        u_min = np.asarray(u_min, dtype=float).flatten() if u_min is not None else None
+        u_max = np.asarray(u_max, dtype=float).flatten() if u_max is not None else None
+        if u_min is not None or u_max is not None:
+            self.control_constrained = True
+            if u_min is None and u_max is not None:
+                u_min = -np.inf * np.ones(self.m)
+            elif u_min is not None and u_max is None:
+                u_max = np.inf * np.ones(self.m)
+        else:
+            self.control_constrained = False
+        if u_min is not None:
+            assert u_min.shape == (self.m,)
+            u_min = tuple(u_min)
+        if u_max is not None:
+            assert u_max.shape == (self.m,)
+            u_max = tuple(u_max)
+        self.u_min = u_min
+        self.u_max = u_max
+
+        # Test if the methods are provided and verify their output dimension
+        z_test = jnp.ones(self.n)
+        u_test = jnp.ones(self.m)
+        f_test = self.f(z_test)
+        g_test = self.g(z_test)
+        if f_test.shape != (self.n,):
+            raise ValueError(
+                f"Invalid shape for f(z). Got {f_test.shape}, expected ({self.n},)"
+            )
+        if g_test.shape != (self.n, self.m):
+            raise ValueError(
+                f"Invalid shape for g(z). Got {g_test.shape}, expected ({self.n}, {self.m})"
+            )
+        try:
+            h1_test = self.h_1(z_test, *self.init_args)
+            h2_test = self.h_2(z_test, *self.init_args)
+        except TypeError as e:
+            raise ValueError(
+                "Cannot test the barrier function; likely missing additional arguments.\n"
+                + "Please provide an initial seed for these args in the config's init_args input"
+            ) from e
+        if h1_test.ndim != 1 or h2_test.ndim != 1:
+            raise ValueError("Barrier function(s) must be 1D arrays")
+        self.num_rd1_cbf = h1_test.shape[0]
+        self.num_rd2_cbf = h2_test.shape[0]
+        self.num_cbf = self.num_rd1_cbf + self.num_rd2_cbf
+        if self.num_cbf == 0:
+            raise ValueError(
+                "No barrier functions provided."
+                + "\nYou can implement this via the h_1 and/or h_2 methods in your config class"
+            )
+        h_test = jnp.concatenate([h1_test, h2_test])
+        alpha_test = self.alpha(h_test)
+        alpha_2_test = self.alpha_2(h2_test)
+        if alpha_test.shape != (self.num_cbf,):
+            raise ValueError(
+                f"Invalid shape for alpha(h(z)): {alpha_test.shape}. Expected ({self.num_cbf},)"
+                + "\nCheck that the output of the alpha() function matches the number of CBFs"
+            )
+        if alpha_2_test.shape != (self.num_rd2_cbf,):
+            raise ValueError(
+                f"Invalid shape for alpha_2(h_2(z)): {alpha_2_test.shape}. Expected ({self.num_rd2_cbf},)"
+                + "\nCheck that the output of the alpha_2() function matches the number of RD2 CBFs"
+            )
+        self._check_class_kappa(self.alpha, self.num_cbf)
+        self._check_class_kappa(self.alpha_2, self.num_rd2_cbf)
+        try:
+            P_test = self.P(z_test, u_test, *self.init_args)
+        except TypeError as e:
+            raise ValueError(
+                "Cannot test the P matrix; likely missing additional arguments.\n"
+                + "Please provide an initial seed for these args in the config's init_args input"
+            ) from e
+        if P_test.shape != (self.m, self.m):
+            raise ValueError(
+                f"Invalid shape for P(z). Got {P_test.shape}, expected ({self.m}, {self.m})"
+            )
+        if not self._is_symmetric_psd(P_test):
+            raise ValueError("P matrix must be symmetric positive semi-definite")
+
+    ## Control Affine Dynamics ##
+
+    @abstractmethod
+    def f(self, z: ArrayLike) -> Array:
+        """The uncontrolled dynamics function. Possibly nonlinear, and locally Lipschitz
+
+        i.e. the function f, such that z_dot = f(z) + g(z) u
+
+        Args:
+            z (ArrayLike): The state, shape (n,)
+
+        Returns:
+            Array: Uncontrolled state derivative component, shape (n,)
+        """
+        pass
+
+    @abstractmethod
+    def g(self, z: ArrayLike) -> Array:
+        """The control affine dynamics function. Locally Lipschitz.
+
+        i.e. the function g, such that z_dot = f(z) + g(z) u
+
+        Args:
+            z (ArrayLike): The state, shape (n,)
+
+        Returns:
+            Array: Control matrix, shape (n, m)
+        """
+        pass
+
+    ## Barriers ##
+
+    def h_1(self, z: ArrayLike, *h_args) -> Array:
+        """Relative-degree-1 barrier function(s).
+
+        A (zeroing) CBF is a continuously-differentiable function h, such that for any state z in the interior of
+        the safe set, h(z) should be > 0, and h(z) = 0 on the boundary. When in the unsafe set, h(z) < 0.
+
+        Relative degree can generally be thought of as the number of integrations required between the
+        input and output of the system. For instance, a (relative-degree-1) CBF based on velocities,
+        with acceleration inputs, will be directly modified on the next timestep.
+
+        If your barrier function is relative-degree-2, or if you would like to enforce additional barriers
+        which are relative-degree-2, use the `h_2` method.
+
+        Args:
+            z (ArrayLike): State, shape (n,)
+            *h_args: Optional additional arguments for the barrier function. Note: If using additional args with your
+                barrier, these must be a static shape/type, or else this will trigger a recompilation in Jax.
+
+        Returns:
+            Array: Barrier function(s), shape (num_rd1_barr,)
+        """
+        return jnp.array([])
+
+    def h_2(self, z: ArrayLike, *h_args) -> Array:
+        """Relative-degree-2 (high-order) barrier function(s).
+
+        A (zeroing) CBF is a continuously-differentiable function h, such that for any state z in the interior of
+        the safe set, h(z) should be > 0, and h(z) = 0 on the boundary. When in the unsafe set, h(z) < 0.
+
+        Relative degree can generally be thought of as the number of integrations required between the
+        input and output of the system. For instance, a (relative-degree-2) CBF based on position,
+        with acceleration inputs, will be modified in two timesteps: the acceleration changes the velocity,
+        which then changes the position.
+
+        If your barrier function is relative-degree-1, or if you would like to enforce additional barriers
+        which are relative-degree-1, use the `h_1` method.
+
+        Args:
+            z (ArrayLike): State, shape (n,)
+            *h_args: Optional additional arguments for the barrier function. Note: If using additional args with your
+                barrier, these must be a static shape/type, or else this will trigger a recompilation in Jax.
+
+        Returns:
+            Array: Barrier function(s), shape (num_rd2_barr,)
+        """
+        return jnp.array([])
+
+    ## Additional tuning functions ##
+
+    def alpha(self, h: ArrayLike) -> Array:
+        """A class Kappa function, dictating the "gain" of the barrier function(s)
+
+        For reference, a class Kappa function is a monotonically increasing function which passes through the origin.
+        A simple example is alpha(h) = h
+
+        The default implementation can be overridden for more fine-grained control over the CBF
+
+        Args:
+            h (ArrayLike): Evaluation of the barrier function(s) at the current state, shape (num_cbf,)
+
+        Returns:
+            Array: alpha(h(z)), shape (num_cbf,)
+        """
+        return h
+
+    def alpha_2(self, h_2: ArrayLike) -> Array:
+        """A second class Kappa function which dictactes the "gain" associated with the relative-degree-2
+        barrier functions
+
+        For reference, a class Kappa function is a monotonically increasing function which passes through the origin.
+        A simple example is alpha_2(h_2) = h_2
+
+        The default implementation can be overridden for more fine-grained control over the CBF
+
+        Args:
+            h_2 (ArrayLike): Evaluation of the RD2 barrier function(s) at the current state, shape (num_rd2_cbf,)
+
+        Returns:
+            Array: alpha_2(h_2(z)), shape (num_rd2_cbf,).
+        """
+        return h_2
+
+    # Objective function tuning
+
+    def P(self, z: Array, u_des: Array, *h_args) -> Array:
+        """Quadratic term in the CBF QP objective (minimize 0.5 * x^T P x + q^T x)
+
+        This defaults to 2 * I, which is the value of P when minimizing the standard CBF objective,
+        ||u - u_des||_{2}^{2}
+
+        To change the objective, override this method. **Note that P must be PSD**
+
+        Args:
+            z (Array): State, shape (n,)
+            u_des (Array): Desired control input, shape (m,)
+            *h_args: Optional additional arguments for the barrier function.
+
+        Returns:
+            Array: P matrix, shape (m, m)
+        """
+        return 2 * jnp.eye(self.m)
+
+    def q(self, z: Array, u_des: Array, *h_args) -> Array:
+        """Linear term in the CBF QP objective (minimize 0.5 * x^T P x + q^T x)
+
+        This defaults to -2 * u_des, which is the value of q when minimizing the standard CBF objective,
+        ||u - u_des||_{2}^{2}
+
+        To change the objective, override this method.
+
+        Args:
+            z (Array): State, shape (n,)
+            u_des (Array): Desired control input, shape (m,)
+            *h_args: Optional additional arguments for the barrier function.
+
+        Returns:
+            Array: q vector, shape (m,)
+        """
+        return -2 * u_des
+
+    ## Helper functions ##
+
+    def _check_class_kappa(
+        self, func: Callable[[ArrayLike], ArrayLike], dim: int
+    ) -> None:
+        """Checks that the provided function is in class Kappa
+
+        Args:
+            func (Callable): Function to check
+            dim (int): Expected dimension of the output
+        """
+        assert isinstance(func, Callable)
+        try:
+            # Check that func(0) == 0
+            assert jnp.allclose(func(jnp.zeros(dim)), 0.0)
+            # Check that func is monotonically increasing
+            n_test = 100
+            test_points = jnp.repeat(
+                jnp.linspace(-1e6, 1e6, n_test).reshape(n_test, 1), dim, axis=1
+            )
+            a = jax.vmap(func, in_axes=0)(test_points)
+            assert jnp.all(a[:-1, :] < a[1:, :])
+        except AssertionError as e:
+            raise ValueError(
+                f"{func.__name__} does not appear to be a class Kappa function"
+            ) from e
+
+    def _is_symmetric_psd(self, mat: Array) -> bool:
+        """Check that a matrix is symmetric positive semi-definite
+
+        Args:
+            mat (Array): Matrix to check
+
+        Returns:
+            bool: True if the matrix is symmetric PSD, False otherwise
+        """
+        mat = np.asarray(mat)
+        # Must be square
+        if mat.shape[0] != mat.shape[1]:
+            return False
+        # Must be symmetric or hermitian
+        if not np.allclose(mat, mat.conj().T, atol=1e-14):
+            return False
+        # Check PSD with cholesky. Cholesky can only tell if a matrix is PD, not PSD,
+        # but adding a small regularization term will allow this test to work
+        try:
+            np.linalg.cholesky(mat + np.eye(mat.shape[0]) * 1e-14)
+        except np.linalg.LinAlgError:
+            return False
+        return True

cbfpy/config/clf_cbf_config.py

@@ -0,0 +1,251 @@
+"""
+# CLF-CBF Configuration class
+
+## Defining the problem:
+
+As with the CBF, we require implementation of the dynamics functions `f` and `g`, as well as the barrier function(s) 
+`h`. Now, with the CLF-CBF, we require the definition of the Control Lyapunov Function (CLF) `V`. This CLF must be a
+positive definite function of the state. 
+
+Depending on the relative degree of your barrier function(s), you should implement the `h_1` method 
+(for a relative-degree-1 barrier), and/or the `h_2` method (for a relative-degree-2 barrier).
+
+Likewise, for the CLF, you should implement the `V_1` method (for a relative-degree-1 CLF), and/or the `V_2` method
+(for a relative-degree-2 CLF).
+
+## Tuning the CLF-CBF:
+
+As with the CBF, the CLF-CBF config allows for adjustment of the class-Kappa CBF "gain" functions `alpha` and `alpha_2`.
+Additionally, the CLF-CBF config allows for adjustment of the class-Kappa CLF "gain" functions `gamma` and `gamma_2`
+(for relative-degree-2 CLFs).
+
+The CLF-CBF config also allows for adjustment of the quadratic control term `H` and the linear control term `F` in the
+CLF objective. These can be used to adjust the weightings between inputs, for instance.
+
+## Relaxation:
+
+If the CBF constraints are not necessarily globally feasible, you can enable further relaxation in the CLFCBFConfig. 
+However, since the CLF constraint was already relaxed with respect to the CBF constraint, this means that tuning the
+relaxation parameters is critical. In general, the penalty on the CBF relaxation should be much higher than the penalty
+on the CLF relaxation.
+
+If strict enforcement of the CLF-CBF is desired, your higest-level controller should handle the case where the QP
+is infeasible.
+"""
+
+from typing import Optional
+
+import jax.numpy as jnp
+from jax import Array
+from jax.typing import ArrayLike
+
+from cbfpy.config.cbf_config import CBFConfig
+
+
+class CLFCBFConfig(CBFConfig):
+    """Control Lyapunov Function / Control Barrier Function (CLF-CBF) configuration class.
+
+    This is an abstract class which requires implementation of the following methods:
+
+    - `f(z)`: The uncontrolled dynamics function
+    - `g(z)`: The control affine dynamics function
+    - `h_1(z)` and/or `h_2(z)`: The barrier function(s), of relative degree 1 and/or 2
+    - `V_1(z)` and/or `V_2(z)`: The Lyapunov function(s), of relative degree 1 and/or 2
+
+    For finer-grained control over the CLF-CBF, the following methods may be updated from their defaults:
+
+    - `alpha(h)`: "Gain" of the CBF
+    - `alpha_2(h_2)`: "Gain" of the relative-degree-2 CBFs, if applicable
+    - `gamma(v)`: "Gain" of the CLF
+    - `gamma_2(v)`: "Gain" of the relative-degree-2 CLFs, if applicable
+    - `H(z)`: Quadratic control term in the CLF objective
+    - `F(z)`: Linear control term in the CLF objective
+
+    Args:
+        n (int): State dimension
+        m (int): Control dimension
+        u_min (ArrayLike, optional): Minimum control input, shape (m,). Defaults to None (Unconstrained).
+        u_max (ArrayLike, optional): Maximum control input, shape (m,). Defaults to None (Unconstrained).
+        relax_cbf (bool, optional): Whether to allow for relaxation in the CBF QP. Defaults to True.
+        cbf_relaxation_penalty (float, optional): Penalty on the slack variable in the relaxed CBF QP. Defaults to 1e4.
+            Note: only applies if relax_cbf is True.
+        clf_relaxation_penalty (float): Penalty on the CLF slack variable when enforcing the CBF. Defaults to 1e2
+        solver_tol (float, optional): Tolerance for the QP solver. Defaults to 1e-3.
+        init_args (tuple, optional): If your barrier function relies on additional arguments other than just the state,
+            include an initial seed for these arguments here. This is to help test the output of the barrier function.
+            Defaults to ().
+    """
+
+    def __init__(
+        self,
+        n: int,
+        m: int,
+        u_min: Optional[ArrayLike] = None,
+        u_max: Optional[ArrayLike] = None,
+        relax_cbf: bool = True,
+        cbf_relaxation_penalty: float = 1e4,
+        clf_relaxation_penalty: float = 1e2,
+        solver_tol: float = 1e-3,
+        init_args: tuple = (),
+    ):
+        super().__init__(
+            n,
+            m,
+            u_min,
+            u_max,
+            relax_cbf,
+            cbf_relaxation_penalty,
+            solver_tol,
+            init_args,
+        )
+
+        if not (
+            isinstance(clf_relaxation_penalty, (int, float))
+            and clf_relaxation_penalty > 0
+        ):
+            raise ValueError(
+                f"Invalid clf_relaxation_penalty: {clf_relaxation_penalty}. Must be a positive value."
+            )
+        self.clf_relaxation_penalty = float(clf_relaxation_penalty)
+
+        # Check on CLF dimension
+        z_test = jnp.ones(self.n)
+        v1_test = self.V_1(jnp.ones(self.n))
+        v2_test = self.V_2(jnp.ones(self.n))
+        if v1_test.ndim != 1 or v2_test.ndim != 1:
+            raise ValueError("CLF(s) must output 1D arrays")
+        self.num_rd1_clf = v1_test.shape[0]
+        self.num_rd2_clf = v2_test.shape[0]
+        self.num_clf = self.num_rd1_clf + self.num_rd2_clf
+        if self.num_clf == 0:
+            raise ValueError(
+                "No Lyanpunov functions provided."
+                + "\nYou can implement this via the V_1 and/or V_2 methods in your config class"
+            )
+        v_test = jnp.concatenate([v1_test, v2_test])
+        gamma_test = self.gamma(v_test)
+        gamma_2_test = self.gamma_2(v2_test)
+        if gamma_test.shape != (self.num_clf,):
+            raise ValueError(
+                f"Invalid shape for gamma(V(z)): {gamma_test.shape}. Expected ({self.num_clf},)"
+                + "\nCheck that the output of the gamma() function matches the number of CLFs"
+            )
+        if gamma_2_test.shape != (self.num_rd2_clf,):
+            raise ValueError(
+                f"Invalid shape for gamma_2(V_2(z)): {gamma_2_test.shape}. Expected ({self.num_rd2_clf},)"
+                + "\nCheck that the output of the gamma_2() function matches the number of RD2 CLFs"
+            )
+        self._check_class_kappa(self.gamma, self.num_clf)
+        self._check_class_kappa(self.gamma_2, self.num_rd2_clf)
+        H_test = self.H(z_test)
+        if H_test.shape != (self.m, self.m):
+            raise ValueError(
+                f"Invalid shape for H(z): {H_test.shape}. Expected ({self.m}, {self.m})"
+            )
+        if not self._is_symmetric_psd(H_test):
+            raise ValueError("H(z) must be symmetric positive semi-definite")
+        # TODO: add a warning if the CLF relaxation penalty > the QP relaxation penalty?
+
+    def V_1(self, z: ArrayLike) -> Array:
+        """Relative-Degree-1 Control Lyapunov Function (CLF)
+
+        A CLF is a positive-definite function which evaluates to zero at the equilibrium point, and is
+        such that there exists a control input u which makes the time-derivative of the CLF negative.
+
+        Relative degree can generally be thought of as the number of integrations required between the
+        input and output of the system. For instance, a (relative-degree-1) CLF based on velocities,
+        with acceleration inputs, will be directly modified on the next timestep.
+
+        At least one of `V_1` or `V_2` must be implemented. Multiple CLFs is possible, but generally, these cannot all
+        be strictly enforced.
+
+        Args:
+            z (ArrayLike): State, shape (n,)
+
+        Returns:
+            Array: V(z): The RD1 CLF evaluation, shape (num_rd1_clf,)
+        """
+        return jnp.array([])
+
+    # TODO: Check if the math behind this is actually valid
+    def V_2(self, z: ArrayLike) -> Array:
+        """Relative-Degree-2 (high-order) Control Lyapunov Function (CLF)
+
+        A CLF is a positive-definite function which evaluates to zero at the equilibrium point, and is
+        such that there exists a control input u which makes the time-derivative of the CLF negative.
+
+        Relative degree can generally be thought of as the number of integrations required between the
+        input and output of the system. For instance, a (relative-degree-2) CLF based on position,
+        with acceleration inputs, will be modified in two timesteps: the acceleration changes the velocity,
+        which then changes the position.
+
+        At least one of `V_1` or `V_2` must be implemented. Multiple CLFs is possible, but generally, these cannot all
+        be strictly enforced.
+
+        Args:
+            z (ArrayLike): State, shape (n,)
+
+        Returns:
+            Array: V(z): The RD2 CLF evaluation, shape (num_rd2_clf,)
+        """
+        return jnp.array([])
+
+    def gamma(self, v: ArrayLike) -> Array:
+        """A class Kappa function, dictating the "gain" of the CLF
+
+        For reference, a class Kappa function is a monotonically increasing function which passes through the origin.
+
+        The default implementation can be overridden for more fine-grained control over the CLF
+
+        Args:
+            v (ArrayLike): Evaluation of the CLF(s) at the current state, shape (num_clf,).
+
+        Returns:
+            Array: gamma(V(z)), shape (num_clf,).
+        """
+        return v
+
+    def gamma_2(self, v_2: ArrayLike) -> Array:
+        """A second class Kappa function, dictating the "gain" associated with the derivative of the CLF
+
+        For reference, a class Kappa function is a monotonically increasing function which passes through the origin.
+
+        The default implementation can be overridden for more fine-grained control over the CLF
+
+        Args:
+            v_2 (ArrayLike): Evaluation of the RD2 CLF(s) at the current state, shape (num_rd2_clf,)
+
+        Returns:
+            Array: gamma_2(V_2(z)), shape (num_rd2_clf,)
+        """
+        return v_2
+
+    def H(self, z: ArrayLike) -> Array:
+        """Matrix defining the quadratic control term in the CLF objective (minimize 0.5 * u^T H u + F^T u)
+
+        **Must be PSD!**
+
+        The default implementation is just the (m x m) identity matrix, but this can be overridden
+        for more fine-grained control over the objective
+
+        Args:
+            z (ArrayLike): State, shape (n,)
+
+        Returns:
+            Array: H, shape (m, m)
+        """
+        return jnp.eye(self.m)
+
+    def F(self, z: ArrayLike) -> Array:
+        """Vector defining the linear term in the CLF objective (minimize 0.5 * u^T H u + F^T u)
+
+        The default implementation is a zero vector, but this can be overridden
+        for more fine-grained control over the objective
+
+        Args:
+            z (ArrayLike): State, shape (n,)
+
+        Returns:
+            Array: F, shape (m,)
+        """
+        return jnp.zeros(self.m)