The Routh-Hurwitz stability criterion answers one question fast: how many roots of a characteristic polynomial sit in the right half-plane, without ever solving for the roots. In control systems, that count immediately tells you whether a continuous-time system is asymptotically stable.

The criterion and its symbols

For a real-coefficient polynomial

p(s)=ansn+an1sn1++a1s+a0,p(s) = a_n s^n + a_{n-1} s^{n-1} + \cdots + a_1 s + a_0,

with an>0a_n > 0, you build the Routh table and inspect its first column. Here ss is the Laplace variable, each aka_k is a real coefficient, and "right half-plane" means roots with Re(s)>0\operatorname{Re}(s) > 0.

The rule: after handling any special case, the number of sign changes in the first column equals the number of roots with positive real part. No sign changes means every root lies in the open left half-plane, so the system is stable.

One condition is easy to forget: this is the ss-plane test for continuous-time systems, not the zz-plane test for discrete-time systems.

Why the first column works

The value of the method is speed. Instead of factoring a high-degree polynomial, you read stability straight from the coefficients.

The Routh array is a structured elimination that tracks how the polynomial's roots distribute across the imaginary axis. Each lower row is built from the two rows above it, and a sign flip in the first column signals a root crossing into the right half-plane. So counting sign changes is really counting how many roots have crossed over, which is exactly the instability count.

For a cubic with positive leading coefficient, this collapses to a clean set of inequalities. Building the table from

p(s)=s3+a1s2+a2s+a3,p(s) = s^3 + a_1 s^2 + a_2 s + a_3,

gives

s31a2s2a1a3s1a1a2a3a10s0a30\begin{array}{c|cc} s^3 & 1 & a_2 \\ s^2 & a_1 & a_3 \\ s^1 & \dfrac{a_1 a_2 - a_3}{a_1} & 0 \\ s^0 & a_3 & 0 \end{array}

so asymptotic stability requires

a1>0,a2>0,a3>0,a1a2>a3.a_1 > 0,\quad a_2 > 0,\quad a_3 > 0,\quad a_1 a_2 > a_3.

That last inequality is the part people miss. Positive coefficients alone are not enough.

How to build the table

List the coefficients in descending powers of ss. The first two rows alternate coefficients:

snanan2an4sn1an1an3an5\begin{array}{c|ccc} s^n & a_n & a_{n-2} & a_{n-4} \\ s^{n-1} & a_{n-1} & a_{n-3} & a_{n-5} \end{array}

Then compute each lower row from the two rows above it, until you reach the s0s^0 row.

Worked example: positive coefficients, still unstable

Consider

p(s)=s3+s2+2s+8.p(s) = s^3 + s^2 + 2s + 8.

All coefficients are positive, so it may look stable. The table shows otherwise:

s312s218s1(1)(2)(1)(8)10s080\begin{array}{c|cc} s^3 & 1 & 2 \\ s^2 & 1 & 8 \\ s^1 & \dfrac{(1)(2) - (1)(8)}{1} & 0 \\ s^0 & 8 & 0 \end{array}

Simplifying the s1s^1 row:

s312s218s160s080\begin{array}{c|cc} s^3 & 1 & 2 \\ s^2 & 1 & 8 \\ s^1 & -6 & 0 \\ s^0 & 8 & 0 \end{array}

The first column is

1,1,6,8.1,\quad 1,\quad -6,\quad 8.

Two sign changes, from 11 to 6-6 and from 6-6 to 88. So the polynomial has 22 roots in the right half-plane, and the system is unstable. For degree 33 and higher, positive coefficients do not guarantee stability.

Practice this yourself

Run the same process on

p(s)=s3+4s2+5s+2.p(s) = s^3 + 4s^2 + 5s + 2.

Build the first column and look for sign changes. Then cross-check against the cubic condition a1a2>a3a_1 a_2 > a_3; both routes should agree that the system is stable.

Calculation traps to avoid

Checking only the coefficients. All-positive coefficients do not imply stability. The example above is exactly the counterexample.

Forgetting the domain. The standard test is for continuous-time polynomials in ss. A discrete-time system needs a different test.

Ignoring special cases. A zero in the first column or a full row of zeros is not a normal stopping point. Those need an extra step, such as a small perturbation or an auxiliary polynomial.

Not normalizing. Write the polynomial in descending powers of ss with a positive leading coefficient before building the table, or the sign test is easy to misread.

Where it is used

Reach for Routh-Hurwitz when a model produces a characteristic polynomial and you need a stability answer quickly. In control systems it checks closed-loop stability without computing poles; in circuit and mechanical models it tests whether parameter choices give decaying or growing responses; in design work it finds parameter ranges that keep a system stable. It is most valuable exactly when finding the roots would be slow or unnecessary.

Frequently Asked Questions

What does the Routh-Hurwitz criterion tell you?
It tells you how many roots of a real-coefficient characteristic polynomial lie in the right half-plane without solving for the roots. After building the Routh table and handling any special cases, the number of sign changes in the first column equals the number of roots with positive real part. No sign changes means the system is asymptotically stable.
Are positive coefficients enough to guarantee stability?
No. Positive coefficients are necessary but not sufficient. For example, the cubic s cubed plus s squared plus 2s plus 8 has all positive coefficients yet is unstable. For a cubic with positive leading coefficient you also need the product of the middle coefficients to exceed the constant term, which the Routh table reveals.
How do you build a Routh table?
List the polynomial coefficients in descending powers of s, alternating them across the first two rows. Then compute each lower row from the two rows directly above it using the standard cross-multiplication pattern, until you reach the s to the zero row. Finally, count sign changes down the first column.
Does the Routh-Hurwitz criterion work for discrete-time systems?
Not directly. The usual Routh-Hurwitz criterion applies to continuous-time systems in the s-plane, where stability means every root has negative real part. Discrete-time systems are analyzed in the z-plane with a different stability region, so the criterion should not be applied to them without modification.

Need help with a problem?

Upload your question and get a verified, step-by-step solution in seconds.

Open GPAI Solver →