Up to now, stability analysis has been mostly qualitative: using pole locations or Routh–Hurwitz, we decide whether all poles lie in the open left half-plane (LHP) and hence the system is asymptotically stable. However, two systems can both be stable yet behave very differently: one may decay slowly with long settling time, while another decays quickly and is highly damped.

Let the closed-loop characteristic polynomial be \( P(s) = a_n s^n + a_{n-1} s^{n-1} + \cdots + a_1 s + a_0 \) with roots (poles) \( p_1,\dots,p_n \). Absolute stability requires \( \Re(p_i) < 0 \) for all \( i \). Relative stability asks:

• How far are the poles from the imaginary axis?
• How fast does the natural response decay?
• How much parameter variation is allowed before poles approach instability?

These questions lead to notions like degree of stability and stability margins (in the time-domain sense), which are central for controller tuning and robustness.

flowchart TD
  A["Closed-loop characteristic polynomial P(s)"] --> B["Locate poles p_i in s-plane"]
  B --> C["Check absolute stability: Re(p_i) < 0"]
  C --> D["Quantify relative stability: distance to imaginary axis, damping"]
  D --> E["Impose constraints Re(p_i) <= -alpha (degree of stability)"]
  E --> F["Translate into inequalities on controller parameters (e.g. K)"]
  F --> G["Compute time-domain stability margins (allowable parameter variation)"]
        

Consider an asymptotically stable LTI system whose homogeneous response can be written as a finite sum

\[ x(t) = \sum_{i=1}^{n} c_i e^{p_i t}, \quad \Re(p_i) < 0 \]

where \( p_i \) are the (distinct) poles and \( c_i \) are complex coefficients determined by initial conditions. Define the degree of stability (also called exponential decay rate) as

\[ \alpha \triangleq \min_{i} \bigl(-\Re(p_i)\bigr) \;> 0 . \]

Then the slowest decaying mode behaves like \( e^{-\alpha t} \). A standard argument gives an exponential bound on the state:

\[ |x(t)| = \left|\sum_{i=1}^{n} c_i e^{p_i t}\right| \le \sum_{i=1}^{n} |c_i| \, e^{\Re(p_i) t} \le \left(\sum_{i=1}^{n} |c_i|\right) e^{-\alpha t} = M e^{-\alpha t} \]

with \( M \triangleq \sum_{i=1}^n |c_i| \). Thus:

• larger \( \alpha \) implies faster decay and smaller settling time;
• for a chosen acceptable settling time \( T_s \), we can derive a desired lower bound on \( \alpha \).

For many practical systems, a rough time-domain relationship between the slowest real part \( \sigma_{\min} \triangleq \min_i \bigl(-\Re(p_i)\bigr) \) and the 2% settling time is

\[ T_s \approx \frac{4}{\sigma_{\min}} \quad \Longrightarrow \quad \sigma_{\min} \approx \frac{4}{T_s}. \]

Hence specifying a desired settling time immediately implies a requirement on the degree of stability.

Absolute stability requires all poles to lie in the open LHP. Relative stability requirements often take the form:

\[ \Re(p_i) \le -\alpha \quad \text{for all } i, \]

where \( \alpha > 0 \) is a chosen margin from the imaginary axis. Geometrically, this means all poles lie to the left of the vertical line \( \Re(s) = -\alpha \). Such a system is called \( \alpha \)-stable and has degree of stability at least \( \alpha \).

Given a characteristic polynomial

\[ P(s) = a_n s^n + a_{n-1} s^{n-1} + \cdots + a_1 s + a_0, \]

we want to test whether all its roots satisfy \( \Re(s) \le -\alpha \). Instead of deriving a new criterion, we can reduce the problem to ordinary LHP stability via the change of variable \( s = z - \alpha \), i.e.

\[ Q(z) \triangleq P(z - \alpha). \]

If \( z_i \) are the roots of \( Q(z) \) then \( s_i = z_i - \alpha \) are the roots of \( P(s) \). We have

\[ \Re(s_i) = \Re(z_i - \alpha) = \Re(z_i) - \alpha. \]

Therefore:

• If all roots of \( Q(z) \) lie in the open LHP, i.e. \( \Re(z_i) < 0 \), then \( \Re(s_i) \le -\alpha \) for all \( i \), so \( P(s) \) is \( \alpha \)-stable.
• Conversely, if \( P(s) \) is \( \alpha \)-stable, then \( \Re(z_i) = \Re(s_i + \alpha) \le 0 \), so \( Q(z) \) has all roots in the closed LHP.

Thus, to enforce a desired degree of stability:

1. Form \( Q(z) = P(z - \alpha) \).
2. Apply the standard Routh–Hurwitz stability test to \( Q(z) \) (in the variable \( z \)).
3. Require all first-column elements of the Routh array for \( Q(z) \) to be positive.

This is the basic time-domain relative stability test using a vertical-line shift.

Consider a unity-feedback configuration with a proportional controller \( K \) and plant \( G(s) \). The closed-loop transfer function is

\[ T(s) = \frac{K G(s)}{1 + K G(s)}, \]

and the characteristic equation is

\[ 1 + K G(s) = 0. \]

After moving to a common denominator, we obtain a characteristic polynomial \( P(s,K) \) with coefficients depending on the gain \( K \). For a fixed plant, the set of values of \( K \) that keep all closed-loop poles in the LHP form an interval

\[ \mathcal{K}_{\text{stab}} = (K_{\min}, K_{\max}). \]

The end-points of this interval can be computed using Routh–Hurwitz by requiring that all first-column entries of the Routh array for \( P(s,K) \) be positive. This is a time-domain gain stability margin: it tells us how far we can perturb the loop gain before losing stability, without resorting to frequency-domain tools.

We can refine this idea to relative stability margins by imposing \( \alpha \)-stability instead of mere LHP stability:

1. Choose a desired \( \alpha > 0 \) reflecting the minimum acceptable decay rate.
2. Construct \( Q(z,K) = P(z - \alpha, K) \).
3. Apply Routh–Hurwitz to \( Q(z,K) \) to find the interval \( \mathcal{K}_{\alpha\text{-stab}} \subseteq \mathcal{K}_{\text{stab}} \) for which the system is \( \alpha \)-stable.

Any nominal gain \( K_0 \in \mathcal{K}_{\alpha\text{-stab}} \) then enjoys a time-domain stability margin of at least \( \min\{K_0 - K_{\min,\alpha}, K_{\max,\alpha} - K_0\} \), where \( K_{\min,\alpha} \) and \( K_{\max,\alpha} \) are the endpoints of \( \mathcal{K}_{\alpha\text{-stab}} \).

flowchart TD
  A["Specify decay requirement (alpha) and controller parameter (e.g. K)"]
    --> B["Form characteristic polynomial P(s,K)"]
  B --> C["Shift: Q(z,K) = P(z - alpha, K)"]
  C --> D["Build Routh array of Q(z,K) in z"]
  D --> E["Solve first-column positivity inequalities for K"]
  E --> F["Interval K_{alpha-stab} = (K_min,alpha, K_max,alpha)"]
        

Consider a closed-loop characteristic polynomial

\[ P(s,K) = s^3 + 5 s^2 + 6 s + K. \]

Such a polynomial may arise from a unity-feedback loop with a third-order plant and proportional controller gain \( K \). We first find the interval of \( K \) that ensures LHP stability, then a stricter interval that guarantees a minimum degree of stability.

5.1 Absolute stability (LHP)

Build the Routh array for \( P(s,K) \):

\[ \begin{array}{c|cc} s^3 & 1 & 6 \\ s^2 & 5 & K \\ s^1 & \dfrac{5\cdot 6 - 1\cdot K}{5} & 0 \\ s^0 & K & 0 \end{array} = \begin{array}{c|cc} s^3 & 1 & 6 \\ s^2 & 5 & K \\ s^1 & \dfrac{30 - K}{5} & 0 \\ s^0 & K & 0 \end{array} \]

Routh–Hurwitz requires all elements in the first column to be positive:

\[ 1 > 0,\quad 5 > 0,\quad \frac{30-K}{5} > 0,\quad K > 0. \]

The nontrivial inequalities yield \( 0 < K < 30 \). Hence the time-domain gain stability margin (in the absolute sense) is the open interval \( (0,30) \).

5.2 Relative stability with degree \( \alpha = 0.5 \)

Suppose we require that the slowest decaying pole be at least \( 0.5 \) units away from the imaginary axis; i.e., \( \Re(p_i) \le -0.5 \) for all \( i \). Set \( \alpha = 0.5 \) and perform the shift \( s = z - 0.5 \):

\[ Q(z,K) = P(z - 0.5, K) = (z - 0.5)^3 + 5 (z - 0.5)^2 + 6 (z - 0.5) + K. \]

Expanding and collecting terms in \( z \) gives

\[ Q(z,K) = z^3 + \frac{7}{2} z^2 + \frac{7}{4} z + \left( K - \frac{15}{8} \right). \]

The Routh array for \( Q(z,K) \) is

\[ \begin{array}{c|cc} z^3 & 1 & \dfrac{7}{4} \\ z^2 & \dfrac{7}{2} & K - \dfrac{15}{8} \\ z^1 & \dfrac{\frac{7}{2}\cdot \frac{7}{4} - 1\cdot\left( K - \frac{15}{8} \right)}{\frac{7}{2}} & 0 \\ z^0 & K - \dfrac{15}{8} & 0 \end{array} \]

Simplifying the \( z^1 \) first-column entry:

\[ \frac{\frac{49}{8} - \left( K - \frac{15}{8} \right)}{\frac{7}{2}} = \frac{\frac{64}{8} - K}{\frac{7}{2}} = \frac{16 - K}{\frac{7}{2}} = \frac{2}{7}\,(16 - K). \]

Routh–Hurwitz again requires the first-column entries to be positive:

\[ 1 > 0,\quad \frac{7}{2} > 0,\quad \frac{2}{7}(16 - K) > 0,\quad \left( K - \frac{15}{8} \right) > 0. \]

Hence

\[ 16 - K > 0 \;\Rightarrow\; K < 16, \quad K - \frac{15}{8} > 0 \;\Rightarrow\; K > \frac{15}{8}. \]

Combining with the absolute stability range \( 0 < K < 30 \), we obtain the relative stability range

\[ \mathcal{K}_{\alpha\text{-stab}} = \left( \frac{15}{8},\, 16 \right) \approx (1.875,\,16). \]

Choosing, for example, \( K_0 = 10 \), we have a time-domain gain stability margin of

\[ \min\left\{ 10 - \frac{15}{8},\, 16 - 10 \right\} = \min\left\{ \frac{65}{8},\, 6 \right\} = 6. \]

This margin is purely time-domain: it is computed via coefficient inequalities, without invoking Bode or Nyquist plots (which will be introduced in later chapters).

In robotic manipulators and mobile robots, actuators (DC motors, BLDC drives, hydraulic servos) are often controlled by simple SISO loops around individual joints or wheels. Relative stability is crucial:

• A small degree of stability (poles close to the imaginary axis) yields sluggish response and makes the loop sensitive to unmodeled dynamics and friction variations.
• A larger degree of stability (poles further into the LHP) improves robustness to model uncertainty but may require higher actuator effort and can reduce steady-state accuracy if not tuned carefully.

In practice, one may specify a minimum decay rate \( \alpha \) for joint position errors, e.g., requiring that joint errors decrease by a factor of \( e^{-5} \) over \( 1 \) second. This corresponds to \( \alpha = 5 \) and can be translated into a constraint \( \Re(p_i) \le -5 \) for all closed-loop poles. The Routh shift method then yields allowable ranges of loop gain and damping for the joint controllers.

In subsequent lessons (root locus and classical frequency-domain design) we will see alternative ways to encode such requirements in the \( s \)-plane and in the frequency domain. Here, relative stability is purely understood in terms of pole locations and characteristic polynomials.

Python, with libraries such as numpy, scipy, and the python-control package, can be used to compute pole locations, degrees of stability, and Routh tables. In robotics, these tools complement packages like roboticstoolbox for modeling manipulator dynamics.

import numpy as np

def routh_table(coeffs):
    """
    Build the Routh table for a real-coefficient polynomial.
    coeffs: list or array [a_n, a_{n-1}, ..., a_0]
    Returns a 2D numpy array representing the Routh table.
    """
    coeffs = np.array(coeffs, dtype=float)
    n = len(coeffs) - 1  # polynomial degree
    m = int(np.ceil((n + 1) / 2.0))
    R = np.zeros((n + 1, m))

    # Fill first two rows
    R[0, :len(coeffs[0::2])] = coeffs[0::2]
    R[1, :len(coeffs[1::2])] = coeffs[1::2]

    for i in range(2, n + 1):
        for j in range(0, m - 1):
            a = R[i - 2, 0]
            b = R[i - 2, j + 1]
            c = R[i - 1, 0]
            d = R[i - 1, j + 1]
            if abs(c) < 1e-12:
                # Special handling for zero leading entry (epsilon trick)
                c = 1e-6
            R[i, j] = (c * b - a * d) / c
    return R

def is_stable_routh(coeffs, tol=1e-9):
    """
    Test LHP stability via Routh: all first-column entries positive.
    """
    R = routh_table(coeffs)
    first_col = R[:, 0]
    return np.all(first_col > tol)

def degree_of_stability(coeffs):
    """
    Degree of stability alpha = min_i(-Re(p_i)) if stable, else 0.
    """
    roots = np.roots(coeffs)
    if np.any(np.real(roots) >= 0.0):
        return 0.0
    return float(-np.max(np.real(roots)))

# Example: closed-loop polynomial P(s,K) = s^3 + 5 s^2 + 6 s + K
K = 10.0
den = [1.0, 5.0, 6.0, K]
print("Stable (Routh)?", is_stable_routh(den))
print("Degree of stability alpha =", degree_of_stability(den))

# Robotics context: joint-position loop of a simple motor-driven link
# Approximate plant G(s) = K_m / (J s^2 + B s), with proportional gain Kp
J = 0.01   # kg m^2
B = 0.1    # N m s/rad
K_m = 1.0  # N m/rad
Kp = 50.0  # proportional controller

# Closed-loop characteristic: J s^2 + B s + K_m * Kp = 0
den_joint = [J, B, K_m * Kp]
print("Joint loop stable?", is_stable_routh(den_joint))
print("Joint loop alpha =", degree_of_stability(den_joint))
      

The last part illustrates how relative stability can be checked for a simplified joint-position loop of a robotic arm. In more advanced setups, python-control can wrap this polynomial as a transfer function and be combined with robot models from roboticstoolbox.

In C++ robotics software (e.g., within ROS-based control nodes), the Eigen linear algebra library is widely used for dynamics computations and controller implementation. Relative stability can be quantified by forming the companion matrix of the characteristic polynomial and computing its eigenvalues.

#include <iostream>
#include <complex>
#include <Eigen/Dense>

// Degree of stability for P(s) = s^3 + 5 s^2 + 6 s + K
double degreeOfStability(double K) {
    // Companion matrix for s^3 + a2 s^2 + a1 s + a0
    double a2 = 5.0;
    double a1 = 6.0;
    double a0 = K;

    Eigen::Matrix3d A;
    A <<
        0.0, 0.0, -a0,
        1.0, 0.0, -a1,
        0.0, 1.0, -a2;

    Eigen::EigenSolver<Eigen::Matrix3d> solver(A);
    Eigen::VectorXcd eig = solver.eigenvalues();

    double alpha = std::numeric_limits<double>::infinity();
    for (int i = 0; i < eig.size(); ++i) {
        double realPart = eig[i].real();
        if (realPart >= 0.0) {
            // unstable
            return 0.0;
        }
        alpha = std::min(alpha, -realPart);
    }
    return alpha;
}

int main() {
    double K = 10.0;
    double alpha = degreeOfStability(K);
    if (alpha > 0.0) {
        std::cout << "Stable, alpha = " << alpha << std::endl;
    } else {
        std::cout << "Unstable" << std::endl;
    }

    // In a robotics controller, a similar computation could be used offline
    // to check stability margins of local joint loops before deployment.

    return 0;
}
      

Here, Eigen (commonly used in robotic frameworks) provides eigenvalues of the companion matrix, from which we compute the degree of stability. Routh–Hurwitz tests can also be implemented in C++ for symbolic parameter constraints on K.

Java is used in several educational and industrial robotics platforms (e.g., FIRST robotics libraries). Using Apache Commons Math, we can compute polynomial roots and degrees of stability for controller gains tuned in Java-based control software.

import org.apache.commons.math3.analysis.solvers.LaguerreSolver;
import org.apache.commons.math3.complex.Complex;

public class RelativeStabilityJava {

    // Degree of stability for P(s) = s^3 + 5 s^2 + 6 s + K
    public static double degreeOfStability(double K) {
        double[] coeffs = {1.0, 5.0, 6.0, K};  // highest to lowest degree
        LaguerreSolver solver = new LaguerreSolver();
        Complex[] roots = solver.solveAllComplex(coeffs, 0.0);

        double alpha = Double.POSITIVE_INFINITY;
        for (Complex r : roots) {
            double realPart = r.getReal();
            if (realPart >= 0.0) {
                return 0.0; // unstable
            }
            alpha = Math.min(alpha, -realPart);
        }
        return alpha;
    }

    public static void main(String[] args) {
        double K = 10.0;
        double alpha = degreeOfStability(K);
        if (alpha > 0.0) {
            System.out.println("Stable, alpha = " + alpha);
        } else {
            System.out.println("Unstable");
        }
    }
}
      

The same principle applies regardless of the plant order: form the characteristic polynomial, solve for its roots, and compute \( \alpha = \min_i(-\Re(p_i)) \). In robotics software, this kind of check can be integrated into simulation or tuning tools to verify that gains chosen for motor or joint controllers yield sufficient relative stability.

MATLAB® and Simulink® are standard tools in control and robotics. With the Control System Toolbox and Robotics System Toolbox, one can model robot joints, generate Simulink diagrams, and analyze relative stability via pole locations and time-domain responses.

% Characteristic polynomial P(s,K) = s^3 + 5 s^2 + 6 s + K
K = 10;
den = [1 5 6 K];

% Degree of stability from poles
poles = roots(den);
if any(real(poles) >= 0)
    alpha = 0;
else
    alpha = min(-real(poles));
end
disp(['Stable? alpha = ', num2str(alpha)]);

% Time-domain step response (for some nominal plant)
num = [K];   % assume G(s) = K / (s^3 + 5 s^2 + 6 s)
sys = tf(num, den);
step(sys);
grid on;

% Robotics context:
% In Robotics System Toolbox, a rigidBodyTree model can be linearized around
% an operating point to obtain A,B matrices. From that, the characteristic
% polynomial of a joint loop can be formed and analyzed similarly:
%
% [A,B,C,D] = linmod('robot_joint_simulink_model');
% poles = eig(A);
% alpha = min(-real(poles));
      

In Simulink, a SISO joint controller can be built using standard block diagrams; relative stability can then be inspected either by computing eigenvalues of the linearized system or by measuring decay rates in the simulated time response for different gain values \( K \).

Wolfram Mathematica can perform both symbolic and numeric manipulations of characteristic polynomials. This is useful when deriving analytic ranges of \( K \) or degrees of stability and when interfacing with multi-body models, for example via Wolfram SystemModeler for robotic mechanisms.

(* Characteristic polynomial P(s,K) = s^3 + 5 s^2 + 6 s + K *)
Clear[s, K];
poly = s^3 + 5 s^2 + 6 s + K;

(* Absolute stability range via Routh-like inequalities *)
(* For the cubic case, Routh-Hurwitz conditions reduce to: *)
ineqs = {5 > 0, (5*6 - K)/5 > 0, K > 0};
Solve[ineqs, K]

(* Degree of stability for a numeric K *)
Kval = 10;
poles = s /. NSolve[poly /. K -> Kval == 0, s];
alpha = If[Max[Re[poles]] >= 0, 0, Min[-Re[poles]]]

(* Alpha-stability with alpha = 1/2: shift s = z - 1/2 *)
Clear[z, alphaSym];
alphaSym = 1/2;
Q = Expand[poly /. s -> z - alphaSym];

(* Inspect polynomial Q(z,K) *)
Q

(* For a given K, check Routh-Hurwitz on Q(z,K) numerically
   (e.g. by checking that all roots have negative real parts). *)
Kval2 = 10;
qRoots = z /. NSolve[Q /. K -> Kval2 == 0, z];
Max[Re[qRoots]]
      

For higher-order systems, symbolic manipulation can become algebraically heavy, but Mathematica can still assist in deriving inequalities for \( K \) that ensure absolute or \( \alpha \)-stability, making it a powerful tool in theoretical control and robotics research.

Problem 1 (Absolute Stability Range): Consider the characteristic polynomial \( P(s,K) = s^3 + 6 s^2 + 5 s + K \). Determine the range of \( K \) for which the closed-loop system is asymptotically stable.

Solution:

The Routh array is

\[ \begin{array}{c|cc} s^3 & 1 & 5 \\ s^2 & 6 & K \\ s^1 & \dfrac{6\cdot 5 - 1\cdot K}{6} & 0 \\ s^0 & K & 0 \end{array} = \begin{array}{c|cc} s^3 & 1 & 5 \\ s^2 & 6 & K \\ s^1 & \dfrac{30 - K}{6} & 0 \\ s^0 & K & 0 \end{array} \]

Routh–Hurwitz requires all first-column entries positive: \( 1 > 0 \), \( 6 > 0 \), \( (30 - K)/6 > 0 \), \( K > 0 \). The nontrivial inequalities yield \( 0 < K < 30 \).

Problem 2 (Degree of Stability for a Given Gain): For the polynomial in Problem 1, take \( K = 10 \). Find the degree of stability \( \alpha \).

Solution:

With \( K = 10 \), the polynomial is \( s^3 + 6 s^2 + 5 s + 10 \). Compute its roots \( p_1, p_2, p_3 \) (e.g. numerically). Suppose they are \( p_1, p_2, p_3 \) with real parts \( \Re(p_1) \le \Re(p_2) \le \Re(p_3) < 0 \). Then

\[ \alpha = \min_i \bigl(-\Re(p_i)\bigr) = -\max_i \Re(p_i). \]

For example, if a numerical computation yields \( \Re(p_1) \approx -4.3 \), \( \Re(p_2) \approx -1.2 \), \( \Re(p_3) \approx -0.8 \), then \( \alpha \approx 0.8 \), implying a slowest decay rate roughly \( e^{-0.8 t} \) and a 2% settling time on the order of \( T_s \approx 4 / 0.8 = 5 \) seconds.

Problem 3 (Alpha-Stability via Polynomial Shift): Show that if all roots of \( Q(z) = P(z - \alpha) \) lie in the open LHP (i.e. \( \Re(z_i) < 0 \) for all roots \( z_i \) of \( Q \)), then the roots of \( P \) all satisfy \( \Re(s_i) \le -\alpha \).

Solution:

If \( z_i \) is a root of \( Q(z) \) then \( Q(z_i) = P(z_i - \alpha) = 0 \), so \( s_i = z_i - \alpha \) is a root of \( P(s) \). Then

\[ \Re(s_i) = \Re(z_i - \alpha) = \Re(z_i) - \alpha. \]

Since \( \Re(z_i) < 0 \), we have \( \Re(z_i) \le 0 \), hence \( \Re(s_i) \le -\alpha \). Thus all roots of \( P \) lie to the left of the vertical line \( \Re(s) = -\alpha \), and \( P \) is \( \alpha \)-stable.

Problem 4 (Second-Order Relative Stability and Settling Time): A standard second-order closed-loop system has characteristic polynomial \( s^2 + 2 \zeta \omega_n s + \omega_n^2 \), with poles \( p_{1,2} = -\zeta \omega_n \pm j \omega_n \sqrt{1 - \zeta^2} \). Show that its degree of stability is \( \alpha = \zeta \omega_n \) and that the 2% settling time is approximately \( T_s \approx 4 / (\zeta \omega_n) \).

Solution:

The real parts of both poles are equal to \( -\zeta \omega_n \), so \( \alpha = \min_i(-\Re(p_i)) = \zeta \omega_n \). The step response of such a second-order system can be shown (via Laplace inversion) to decay approximately as \( e^{-\zeta \omega_n t} \) multiplied by an oscillatory factor. The 2% settling time is defined as the time when the envelope \( e^{-\zeta \omega_n t} \) falls to approximately \( 0.02 \) of its initial value. Solving \( e^{-\zeta \omega_n T_s} \approx 0.02 \) yields

\[ -\zeta \omega_n T_s \approx \ln(0.02) \approx -4, \quad \Rightarrow \quad T_s \approx \frac{4}{\zeta \omega_n} = \frac{4}{\alpha}. \]

Thus for a second-order system, specifying \( T_s \) is equivalent to specifying the degree of stability \( \alpha \).

Problem 5 (Relative Stability Gain Range): For the polynomial \( P(s,K) = s^3 + 5 s^2 + 6 s + K \), derive the range of \( K \) for which the system is \( \alpha \)-stable with \( \alpha = 0.5 \).

Solution:

From Section 5, the shifted polynomial for \( \alpha = 0.5 \) is

\[ Q(z,K) = z^3 + \frac{7}{2} z^2 + \frac{7}{4} z + \left( K - \frac{15}{8} \right). \]

The Routh array leads to first-column entries \( 1 \), \( 7/2 \), \( (2/7)(16 - K) \), and \( K - 15/8 \). Requiring them to be positive yields

\[ 16 - K > 0 \;\Rightarrow\; K < 16, \quad K - \frac{15}{8} > 0 \;\Rightarrow\; K > \frac{15}{8}. \]

Combining with the absolute stability range \( 0 < K < 30 \), the \( \alpha = 0.5 \) relative stability range is \( K \in (15/8,\,16) \).

This lesson introduced relative stability as a refinement of absolute LTI stability, quantifying how far closed-loop poles lie inside the LHP and how fast trajectories decay. We defined the degree of stability \( \alpha \), related it to time-domain metrics such as settling time, and developed the \( \alpha \)-stability test via a polynomial shift and the Routh–Hurwitz criterion. Time-domain stability margins were expressed as allowable intervals of controller parameters (e.g. proportional gain \( K \)) that ensure a desired decay rate. Finally, we illustrated how Python, C++, Java, MATLAB/Simulink, and Wolfram Mathematica can be used in control and robotics contexts to compute relative stability and stability margins numerically.