Introduction to Stability in Control Systems

Stability is the single most important requirement for any control system. A system that is unstable may oscillate indefinitely, diverge to dangerous limits, or fail to track a setpoint. Before deploying a controller, engineers must verify that the closed-loop system will remain stable under all expected operating conditions. The Routh-Hurwitz criterion offers a powerful, algebraic method for determining stability without solving the characteristic equation explicitly. This guide provides a thorough, beginner-friendly walkthrough of the criterion, including construction of the Routh array, interpretation of results, handling special cases, and practical applications in control engineering.

What Is the Routh-Hurwitz Criterion?

Developed independently by Edward John Routh and Adolf Hurwitz in the late 19th century, the Routh-Hurwitz criterion is a mathematical test for the stability of linear time-invariant (LTI) systems. It answers a fundamental question: Does the system’s characteristic polynomial have any roots with positive real parts? If even one such root exists, the system is unstable.

The criterion works by constructing a tabular array (the Routh array) from the coefficients of the characteristic polynomial. By examining the signs of the first column of this array, an engineer can count the number of roots with positive real parts without calculating the roots themselves. This makes the criterion invaluable for high-order systems where direct root-finding is tedious or numerically unreliable.

The Routh-Hurwitz criterion applies only to LTI systems described by rational transfer functions. It is a necessary and sufficient condition for stability when the characteristic polynomial has real coefficients – exactly the case encountered in most physical systems. For a deeper historical and theoretical perspective, refer to the classic textbook “Modern Control Engineering” by Ogata (available at Pearson).

Understanding the Characteristic Equation

The characteristic equation is derived from the denominator of the closed-loop transfer function when set to zero. For a system whose transfer function is G(s) = N(s)/D(s), the characteristic equation is D(s) = 0. In standard polynomial form:

an sn + an-1 sn-1 + ... + a1 s + a0 = 0

where an > 0 (we can always multiply by -1 to make the leading coefficient positive). All coefficients ai must be real numbers. In control engineering, the characteristic polynomial typically comes from the feedback loop denominator: 1 + G(s)H(s).

For a system to be stable, all roots of this polynomial must have strictly negative real parts (lie in the left half of the complex s-plane). If any root lies on the imaginary axis (zero real part) or in the right half-plane, the system is either marginally stable or unstable. The Routh-Hurwitz criterion directly detects such roots.

Necessary Condition for Stability

Before constructing the Routh array, a quick necessary (but not sufficient) condition can be checked: all coefficients of the characteristic polynomial must be positive. If any coefficient is zero or negative, the system is definitely unstable – the Routh test will confirm this. This simple check often weeds out obviously unstable designs. However, a polynomial with all positive coefficients may still be unstable, so the full Routh array is required.

Constructing the Routh Array

The Routh array is built row by row from the coefficients of the characteristic polynomial. Let’s illustrate with a generic polynomial of order n:

an sn + an-1 sn-1 + an-2 sn-2 + an-3 sn-3 + ... + a0 = 0

Step 1: Fill the First Two Rows

Label the rows from top to bottom by descending powers of s:

  • Row sn: place coefficients of even-indexed powers: an, an-2, an-4, …
  • Row sn-1: place coefficients of odd-indexed powers: an-1, an-3, an-5, …

Continue until you have used all coefficients. If there are not enough coefficients for a given position, fill with zeros.

Step 2: Compute Subsequent Rows

For each subsequent row (labeled sn-2, sn-3, …, s0), the elements are calculated using the following determinant rule. Let the two rows above the target row be denoted by row r and row r+1. The element in column k of the new row is:

ck = − (1 / c0) × det( [ c0 , c1 ; c0,prev , ck+1,prev ] )

where c0 is the first element of the row immediately above the target row (the pivot). In practice, the formula simplifies for each new row i:

  • Take the first element of the row above (call it b1).
  • For column j of the new row, compute: newj = (b1 * cj+1 - bj+1 * c1) / b1

where bi are elements from the row two rows above, and ci are elements from the row immediately above. This is easier to see with an example.

Example: Fourth-Order Polynomial

Consider the characteristic polynomial: s4 + 2s3 + 3s2 + 4s + 5 = 0.

First two rows:

Row s4: 1, 3, 5
Row s3: 2, 4, 0

Now compute row s2:

  • Element 1: (2*3 - 1*4)/2 = (6 - 4)/2 = 1
  • Element 2: (2*5 - 1*0)/2 = (10 - 0)/2 = 5

So row s2: 1, 5

Row s1:

  • Element 1: (1*4 - 2*5)/1 = (4 - 10) / 1 = -6
  • Element 2: (1*0 - 2*0)/1 = 0 (but we only need first column)

Row s1: -6, 0

Row s0:

  • Element 1: ( -6*5 - 1*0 ) / (-6) = (-30 - 0) / -6 = 5

Full Routh array:

s4135
s3240
s215
s1-60
s05

Interpreting the Routh Array

The first column of the completed array (from top to bottom) tells the stability story. Count the number of sign changes as you move down the column. Each sign change indicates one root with a positive real part (unstable pole). If all elements in the first column have the same sign (typically positive), the system is stable.

In the example above, the first column values are: 1, 2, 1, -6, 5. Signs: +, +, +, -, +. There are two sign changes: from 1 to -6 and from -6 to 5. Therefore, this polynomial has two roots in the right half-plane. The system is unstable.

Marginal Stability

If a complete row of zeros appears, it indicates the presence of roots symmetrically placed about the origin (e.g., pure imaginary pairs). This leads to marginal stability or instability depending on the multiplicity. Special handling is required (see next section).

Special Cases in the Routh Array

Two special situations often trip up beginners: a zero in the first column, and an entire row of zeros.

Zero in the First Column

If the first element of a row is zero but other elements in that row are nonzero, the array cannot be completed normally because division by zero is not allowed. The remedy is to replace the zero with a small positive number ε (epsilon) and proceed. Then examine the signs as ε → 0+. For example, in a polynomial s3 + 2s2 + s + 2, the s1 row first element becomes zero. Replace it with ε, continue, and analyze limiting signs.

Entire Row of Zeros

When a row (other than the top row) is entirely zero, it signifies that the characteristic polynomial has roots symmetrically located about the origin, typically pairs of pure imaginary roots or quadruples symmetric about both axes. The solution is to form an auxiliary polynomial using the row above the zero row. Differentiate this auxiliary polynomial with respect to s, then use the coefficients of the derivative to replace the zero row. Continue constructing the array. This method reveals the number of roots on the imaginary axis.

For example, polynomial s4 + 2s2 + 1 produces a zero row at s2. The auxiliary polynomial from row s4 is s4 + 2s2 + 1; its derivative is 4s3 + 4s, so coefficients 4 and 4 replace the zero row.

Practical Applications in Control Engineering

The Routh-Hurwitz criterion is not just a theoretical exercise; it is used daily in control system design and analysis.

Verifying Controller Designs

Before implementing a PID, lead-lag, or state feedback controller, the engineer can use the Routh array to check whether the closed-loop poles remain in the left half-plane. This is especially useful when the controller adds zeros and poles that alter the original characteristic equation. The criterion allows rapid iteration: adjust a gain parameter and recompute the array.

Determining Ranges of Parameter Values for Stability

Often a system contains a variable parameter (e.g., proportional gain K, or a time constant). By writing the characteristic polynomial in terms of that parameter, the Routh array yields inequalities that define the stable region. For example, for a unity feedback system with open-loop transfer function K / [s(s+1)(s+2)], the Routh array applied to s3 + 3s2 + 2s + K = 0 shows that stability requires 0 < K < 6. This is a classic result from Control Tutorials for MATLAB and Simulink.

Relative Stability

By shifting the s‑plane axis (substituting s = s' – σ), engineers can test whether all poles are to the left of a vertical line at –σ. This gives a measure of relative stability – how far the poles are from the imaginary axis. The Routh array on the shifted polynomial indicates whether the system has a guaranteed settling time or damping margin.

Limitations of the Routh-Hurwitz Criterion

While powerful, the criterion has limitations:

  • Linear, time-invariant systems only: It does not apply to nonlinear, time-varying, or discrete-time systems directly (though extensions exist for discrete via bilinear transform).
  • Real coefficients assumed: Complex coefficients violate the criterion's theoretical foundation.
  • No insight into root locations: The criterion only tells the number of unstable poles, not their exact values. For root locus or time-response specification, other methods are needed.
  • Numerical sensitivity: For high-order polynomials (e.g., above 10th order), numerical rounding errors can corrupt the array. Software tools using arbitrary precision arithmetic are recommended.
  • Special cases require extra steps: Handling zeros in the first column or entire rows of zeros adds complexity beyond the basic algorithm.

Nevertheless, the Routh-Hurwitz criterion remains a staple of control theory due to its simplicity and the insight it provides into parametric stability.

Summary and Best Practices

Mastering the Routh-Hurwitz criterion equips the control engineer with a rapid stability check that can be performed by hand or scripted. To apply it reliably:

  1. Ensure the characteristic polynomial is written with positive leading coefficient.
  2. Check the necessary condition: all coefficients positive.
  3. Construct the first two rows carefully, using the odd/even rule.
  4. Compute subsequent rows until you reach s0.
  5. Count sign changes in the first column; each change equals one unstable pole.
  6. If a zero appears in the first column, use the epsilon method.
  7. If an entire row is zero, form the auxiliary polynomial.
  8. Verify your results using software (e.g., MATLAB’s routh function or Python’s control library).

For further reading, consult the Wikipedia article on Routh–Hurwitz stability criterion for algorithmic details and historical context. Additionally, MIT OpenCourseWare lecture notes provide worked examples.

By incorporating the Routh-Hurwitz criterion into your toolkit, you can design and analyze control systems with confidence, knowing that stability is guaranteed before a single component is built.