Consider a standard negative-feedback loop with open-loop transfer function \( G(s)H(s) \) and proportional loop gain \( K \ge 0 \). In this chapter we take \( H(s)=1 \) for simplicity and write

\[ G(s) = K \,\frac{N(s)}{D(s)} = K\,\frac{\displaystyle\prod_{j=1}^{m}(s - z_j)}{\displaystyle\prod_{i=1}^{n}(s - p_i)}, \quad n \ge m, \]

where \( \{p_i\} \) are open-loop poles, \( \{z_j\} \) are open-loop zeros, and all coefficients are real (as is typical in control of physical systems).

The closed-loop characteristic equation under unity feedback is

\[ 1 + G(s) = 0 \quad\Longleftrightarrow\quad 1 + K\,\frac{N(s)}{D(s)} = 0 \quad\Longleftrightarrow\quad D(s) + K N(s) = 0. \]

For a fixed real gain \( K \ge 0 \), the closed-loop poles are the roots of \( D(s) + K N(s) = 0 \). The root locus is the set of points in the complex plane that are closed-loop poles for some \( K \ge 0 \):

\[ \mathcal{L} = \left\{ s \in \mathbb{C} \;:\; \exists K \ge 0 \text{ such that } D(s) + K N(s)=0 \right\}. \]

Using the complex representation \( G(s) = |G(s)|e^{\mathrm{j}\angle G(s)} \), the characteristic equation \( 1 + G(s)=0 \) can be rewritten as the pair of conditions

\[ \begin{aligned} |G(s)| &= 1, \\ \angle G(s) &= (2k+1)\pi, \quad k \in \mathbb{Z}, \end{aligned} \]

or, equivalently,

\[ K = \frac{1}{\left|\dfrac{N(s)}{D(s)}\right|} = \frac{|D(s)|}{|N(s)|}, \quad \angle\!\left(\frac{N(s)}{D(s)}\right) = (2k+1)\pi. \]

The second equation is the angle condition, while the first provides the magnitude condition, yielding the gain \( K \) associated with each point on the locus. All classical rules for constructing root loci are consequences of these two conditions plus the algebraic properties of polynomials with real coefficients.

Let the open-loop transfer function be strictly proper (or at most proper), so that \( n \ge m \). For any fixed \( K \ge 0 \), the characteristic equation \( D(s)+K N(s) = 0 \) is a polynomial of degree \( n \) in \( s \). Thus:

• The closed-loop system has \( n \) poles.
• The root locus has \( n \) branches, each branch being a continuous curve traced out by one pole as \( K \) varies from \( 0 \) to \( +\infty \).

2.1 Starting Points: Open-Loop Poles

Consider the characteristic equation for small gain \( K \ge 0 \). Write

\[ f(s,K) := D(s) + K N(s). \]

When \( K = 0 \), the equation reduces to \( f(s,0) = D(s) = 0 \), so the roots are exactly the open-loop poles \( \{p_i\}_{i=1}^n \). By continuity of polynomial roots as functions of the coefficients (a consequence of, for example, the implicit function theorem), for small \( K \) each closed-loop pole lies in a small neighborhood of some open-loop pole \( p_i \). Thus:

Rule 1A. Each root-locus branch starts at an open-loop pole \( p_i \) when \( K=0 \).

2.2 Ending Points: Open-Loop Zeros and Infinity

For large \( K \), it is convenient to divide the characteristic equation by \( K \):

\[ \frac{1}{K}D(s) + N(s) = 0. \]

As \( K \to +\infty \), the term \( \dfrac{1}{K}D(s) \) vanishes, and the limiting equation becomes

\[ N(s) = 0. \]

Hence:

• \( m \) branches terminate at the finite open-loop zeros \( \{z_j\} \).
• The remaining \( n-m \) branches go off to infinity. Their precise asymptotic directions and intersection on the real axis will be characterized rigorously in the next lesson.

Rule 1B. As \( K \to +\infty \), each branch either terminates at a finite open-loop zero or tends to infinity.

Assume that the coefficients of \( D(s) \) and \( N(s) \) are real. Then these polynomials satisfy

\[ \overline{D(s)} = D(\overline{s}), \quad \overline{N(s)} = N(\overline{s}), \]

where the overline denotes complex conjugation. Suppose \( s_0 \) is a closed-loop pole for some \( K \ge 0 \), i.e.,

\[ D(s_0) + K N(s_0) = 0. \]

Take complex conjugates of both sides:

\[ \overline{D(s_0)} + K \,\overline{N(s_0)} = 0 \quad\Longleftrightarrow\quad D(\overline{s_0}) + K N(\overline{s_0}) = 0. \]

Hence \( \overline{s_0} \) is also a closed-loop pole for the same gain \( K \). Since the root locus is formed by closed-loop poles as \( K \) varies, we obtain:

Rule 2. If \( G(s) \) has real coefficients, the root locus is symmetric with respect to the real axis. Every branch in the upper half-plane has a mirror branch in the lower half-plane.

This property is crucial when sketching: once we determine the locus in the upper half-plane, we automatically know the locus in the lower half-plane.

A distinctive feature of root loci is that some segments lie on the real axis (for systems with real coefficients). We now derive the classical rule for deciding which portions of the real axis belong to the locus.

4.1 Angle Condition on the Real Axis

Write the open-loop transfer function explicitly as

\[ G(s) = K \frac{\displaystyle\prod_{j=1}^{m}(s - z_j)}{\displaystyle\prod_{i=1}^{n}(s - p_i)}. \]

Let \( s_0 \) be a real point on the real axis that is not equal to any pole or zero. The angle of \( G(s_0) \) is

\[ \angle G(s_0) = \sum_{j=1}^{m} \angle(s_0 - z_j) - \sum_{i=1}^{n} \angle(s_0 - p_i). \]

For real poles and zeros located at real positions \( a \), the vector from \( a \) to the real point \( s_0 \) lies on the real axis, so its angle is either \( 0 \) (if the point is to the right) or \( \pi \) (if the point is to the left).

Complex conjugate pole/zero pairs contribute angles that sum to an even multiple of \( \pi \) when evaluated on the real axis, because the geometry is symmetric with respect to the real axis. Therefore, the angle modulo \( 2\pi \) is entirely determined by the real poles and zeros.

4.2 Counting Real Poles and Zeros to the Right

Each real pole or zero to the right of \( s_0 \) contributes an angle of \( 0 \) and each to the left contributes \( \pi \) (or \( -\pi \), which is equivalent modulo \( 2\pi \)). Let \( N_{\text{R}} \) denote the number of real poles plus real zeros that lie to the right of \( s_0 \). Modulo \( 2\pi \), we obtain

\[ \angle G(s_0) \equiv N_{\text{R}} \pi \;\;(\text{mod } 2\pi). \]

The angle condition for the root locus is \( \angle G(s_0) = (2k+1)\pi \) for some integer \( k \). Therefore the condition becomes

\[ N_{\text{R}} \pi \equiv (2k+1)\pi \;\;(\text{mod } 2\pi), \]

which is satisfied if and only if \( N_{\text{R}} \) is odd.

Rule 3 (Real-Axis Rule). A point on the real axis belongs to the root locus if and only if the total number of real poles and zeros of \( G(s) \) that lie to its right is odd.

This rule yields real-axis segments by scanning the real line from \( -\infty \) to \( +\infty \) and counting how the parity of \( N_{\text{R}} \) changes as we cross each real pole or zero.

In many control systems the open-loop transfer function has repeated poles or zeros, for example a double pole at the origin. The local behavior of the root locus near these points follows from the multiplicity of the root in the characteristic equation.

5.1 Multiplicity in the Characteristic Equation

Suppose \( s = p_0 \) is a pole of multiplicity \( r \) of \( G(s) \), so that

\[ D(s) = (s - p_0)^r D_1(s), \quad D_1(p_0) \ne 0. \]

The characteristic equation is

\[ (s - p_0)^r D_1(s) + K N(s) = 0. \]

For small positive \( K \), the roots close to \( p_0 \) satisfy

\[ (s - p_0)^r D_1(p_0) + K N(p_0) \approx 0, \]

or

\[ (s - p_0)^r \approx -\,\frac{K N(p_0)}{D_1(p_0)}. \]

For fixed \( K > 0 \), the right-hand side is a complex constant. The equation \( (s - p_0)^r = C \) has exactly \( r \) distinct solutions that are uniformly spaced in angle by \( \dfrac{2\pi}{r} \) in the complex plane.

Rule 4A. If \( p_0 \) is a pole of multiplicity \( r \), then \( r \) branches of the root locus leave \( p_0 \) as \( K \) increases from \( 0 \). Locally, these branches are separated by equal angles of \( 2\pi / r \).

A completely analogous argument shows that if \( z_0 \) is a repeated zero of multiplicity \( r \), then \( r \) branches of the root locus approach \( z_0 \) as \( K \to +\infty \).

When \( n > m \), there are \( n-m \) branches that do not terminate at finite zeros. These branches must go to infinity while preserving continuity and satisfying the angle and magnitude conditions. A simple degree argument shows that they behave approximately like straight rays for large \( |s| \).

Let the leading terms of \( D(s) \) and \( N(s) \) be

\[ D(s) = s^{n} + d_{n-1} s^{n-1} + \cdots, \quad N(s) = s^{m} + n_{m-1} s^{m-1} + \cdots, \]

after normalizing so that the leading coefficient is \( 1 \) in each. Then

\[ D(s) + K N(s) = s^{n} + \bigl(d_{n-1} + K n_{m-1}\bigr) s^{n-1} + \cdots + K s^{m} + \cdots. \]

For large \( |s| \) and large \( K \), the higher-degree terms dominate, and the roots follow trajectories whose detailed description (including asymptotic directions and a special real intercept) will be derived in the next lesson using more refined asymptotic analysis.

For the purposes of this lesson we record the qualitative fact:

Rule 5 (Qualitative). When \( n > m \), there are \( n-m \) root-locus branches that tend to infinity as \( K \to +\infty \). Far from the origin these branches are approximately straight and are sometimes referred to as asymptotic branches. Their precise geometry will be addressed in Lesson 3.

The basic rules can be synthesized into a systematic sketching procedure for SISO systems. The diagram below summarizes a typical workflow for hand construction, stopping before the more advanced topics of asymptotes and breakaway points that will be treated in the next lesson.

flowchart TD
  A["Start with G(s) = K N(s) / D(s)"] --> B["Plot all open-loop poles and zeros in the s-plane"]
  B --> C["Count n = number of poles, m = number of zeros"]
  C --> D["Apply Rule 1: n branches, start at poles, end at zeros or infinity"]
  D --> E["Use symmetry: reflect upper half-plane branches across real axis"]
  E --> F["Apply real-axis rule: mark segments where number of real poles+zeros to the right is odd"]
  F --> G["At repeated poles/zeros: fan out r branches separated by 2pi/r"]
  G --> H["Refine sketch and prepare for asymptotes/breakaway analysis (next lesson)"]
        

Python, combined with the python-control library, is widely used in robotics and mechatronics for control design. For reproducibility, we also show how to implement a simple root-locus routine from scratch.

Consider the open-loop transfer function \( G(s) = K \dfrac{s+1}{s(s+2)(s+4)} \). The code below constructs and plots its root locus.

import numpy as np
import matplotlib.pyplot as plt

# Optional: use python-control if available (commonly used in robotics control stacks)
try:
    import control  # python-control
    USE_CONTROL_LIB = True
except ImportError:
    USE_CONTROL_LIB = False

# Open-loop transfer function G(s) = K (s+1) / [s (s+2) (s+4)]
num = np.array([1.0, 1.0])        # s + 1
den = np.polymul([1.0, 0.0],      # s
                 np.polymul([1.0, 2.0], [1.0, 4.0]))  # (s+2)(s+4)

if USE_CONTROL_LIB:
    # Using python-control
    G = control.tf(num, den)
    plt.figure()
    control.rlocus(G, kvect=np.linspace(0, 200, 400))
    plt.title("Root locus of G(s) = K (s+1) / [s (s+2) (s+4)]")
    plt.xlabel("Real axis")
    plt.ylabel("Imag axis")
    plt.grid(True)
    plt.show()
else:
    # From-scratch root locus computation (brute-force)
    kvect = np.linspace(0.0, 200.0, 400)
    poles_real = []
    poles_imag = []

    for K in kvect:
        # Characteristic polynomial: D(s) + K N(s) = 0
        # Here D(s) = den(s), N(s) = num(s)
        # So: den(s) + K * num(s) = 0
        # We form polynomial coefficients:
        # deg(den) = 3, deg(num) = 1, so we pad appropriately.
        den_pad = np.array(den, dtype=float)
        num_pad = np.pad(num, (len(den_pad) - len(num), 0))
        char_poly = den_pad + K * num_pad

        roots = np.roots(char_poly)
        poles_real.extend(np.real(roots))
        poles_imag.extend(np.imag(roots))

    plt.figure()
    plt.scatter(poles_real, poles_imag, s=5)
    plt.axhline(0.0, linewidth=1)
    plt.axvline(0.0, linewidth=1)
    plt.title("Root locus (brute-force) of G(s) = K (s+1) / [s (s+2) (s+4)]")
    plt.xlabel("Real axis")
    plt.ylabel("Imag axis")
    plt.grid(True)
    plt.show()
      

The brute-force method numerically solves the characteristic equation \( D(s) + K N(s) = 0 \) for a range of gains \( K \), then scatters the resulting poles. The rule-based analysis from earlier sections can be used to cross-check the numerical plot.

In C++, robotics libraries frequently rely on Eigen for linear algebra. While C++ does not include polynomial root-finding in the standard library, one can implement or wrap an eigen-solver for the companion matrix. The snippet below shows a minimal structure for computing closed-loop poles as gain varies.

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

// Construct companion matrix for a monic polynomial
// p(s) = s^n + a_{n-1} s^{n-1} + ... + a_0
Eigen::MatrixXd companion_from_coeffs(const std::vector<double> &a) {
    int n = static_cast<int>(a.size());
    Eigen::MatrixXd C = Eigen::MatrixXd::Zero(n, n);
    // Last row: negative coefficients
    for (int i = 0; i < n; ++i) {
        C(n-1, i) = -a[i];
    }
    // Superdiagonal of ones
    for (int i = 0; i < n-1; ++i) {
        C(i, i+1) = 1.0;
    }
    return C;
}

// Evaluate closed-loop poles for a given K
std::vector<std::complex<double> >
closed_loop_poles(const std::vector<double> &den,
                  const std::vector<double> &num,
                  double K) {
    int n = static_cast<int>(den.size()) - 1;
    // Pad numerator to same degree as denominator
    std::vector<double> num_pad(den.size(), 0.0);
    int shift = static_cast<int>(den.size()) - static_cast<int>(num.size());
    for (int i = 0; i < static_cast<int>(num.size()); ++i) {
        num_pad[i + shift] = num[i];
    }
    // Characteristic polynomial coefficients (monic assumed in den)
    std::vector<double> a(n);
    for (int i = 0; i < n; ++i) {
        // den[i+1] corresponds to s^{n-1-i}, similarly for num_pad
        a[i] = den[i+1] + K * num_pad[i+1];
    }
    Eigen::MatrixXd C = companion_from_coeffs(a);
    Eigen::EigenSolver<Eigen::MatrixXd> es(C);
    Eigen::VectorXcd eig = es.eigenvalues();
    std::vector<std::complex<double> > poles(eig.size());
    for (int i = 0; i < eig.size(); ++i) {
        poles[i] = eig[i];
    }
    return poles;
}

int main() {
    // G(s) = K (s+1) / [s (s+2) (s+4)]
    std::vector<double> num = {1.0, 1.0};         // s + 1
    std::vector<double> den = {1.0, 6.0, 8.0, 0.0}; // s^3 + 6 s^2 + 8 s

    for (double K : {0.0, 10.0, 50.0, 200.0}) {
        auto poles = closed_loop_poles(den, num, K);
        std::cout << "K = " << K << std::endl;
        for (auto &p : poles) {
            std::cout << "  pole = " << p << std::endl;
        }
    }
    return 0;
}
      

In a robotics context, such a routine could be integrated into a joint servo tuning tool to visualize how proportional gain affects the joint dynamics modeled by a low-order transfer function.

Java-based control or robotics frameworks (for example within certain robot simulators) often use EJML for linear algebra. Below is a sketch of how one could compute closed-loop poles by forming a companion matrix and calling a complex eigen-solver.

import org.ejml.data.Complex_F64;
import org.ejml.data.DenseMatrix64F;
import org.ejml.factory.DecompositionFactory;
import org.ejml.interfaces.decomposition.EigenDecomposition;

public class RootLocusJava {

    public static DenseMatrix64F companion(double[] a) {
        int n = a.length;
        DenseMatrix64F C = new DenseMatrix64F(n, n);
        // Last row: negative coefficients
        for (int i = 0; i < n; ++i) {
            C.set(n - 1, i, -a[i]);
        }
        // Superdiagonal of ones
        for (int i = 0; i < n - 1; ++i) {
            C.set(i, i + 1, 1.0);
        }
        return C;
    }

    public static Complex_F64[] closedLoopPoles(double[] den, double[] num, double K) {
        int n = den.length - 1;
        double[] numPad = new double[den.length];
        int shift = den.length - num.length;
        for (int i = 0; i < num.length; ++i) {
            numPad[i + shift] = num[i];
        }
        double[] a = new double[n];
        for (int i = 0; i < n; ++i) {
            a[i] = den[i + 1] + K * numPad[i + 1];
        }
        DenseMatrix64F C = companion(a);
        EigenDecomposition<DenseMatrix64F> eig =
                DecompositionFactory.eig(n, false);
        eig.decompose(C);
        Complex_F64[] poles = new Complex_F64[n];
        for (int i = 0; i < n; ++i) {
            poles[i] = eig.getEigenvalue(i);
        }
        return poles;
    }

    public static void main(String[] args) {
        double[] num = {1.0, 1.0};          // s + 1
        double[] den = {1.0, 6.0, 8.0, 0.0}; // s^3 + 6 s^2 + 8 s

        double[] gains = {0.0, 10.0, 50.0, 200.0};
        for (double K : gains) {
            System.out.println("K = " + K);
            Complex_F64[] poles = closedLoopPoles(den, num, K);
            for (Complex_F64 p : poles) {
                System.out.println("  pole = " + p.real + " + j" + p.imaginary);
            }
        }
    }
}
      

This pattern can be embedded in higher-level tooling that supports automatic gain scans, for example during robot arm joint tuning or automated controller benchmarking.

MATLAB and Simulink provide native root-locus tools that integrate naturally with robotics toolboxes and Simscape models.

% Open-loop transfer function: G(s) = K (s+1) / [s (s+2) (s+4)]
num = [1 1];                 % s + 1
den = conv([1 0], conv([1 2], [1 4]));  % s * (s+2) * (s+4)

G = tf(num, den);

figure;
rlocus(G)
title('Root locus of G(s) = K (s+1) / [s (s+2) (s+4)]')
grid on

% Example: choose a gain K for desired closed-loop pole location
s_des = -2 + 2j;  % desired closed-loop pole
[K, poles] = rlocfind(G, s_des);  %#ok<NOPTS>
disp('Selected gain K:');
disp(K);
disp('Closed-loop poles at this K:');
disp(poles);

% In a Simulink model, G(s) can be implemented with Transfer Fcn blocks
% and the gain K with a Gain block in the forward path. The root locus
% analysis can be performed analytically using this G and then K applied
% in the Simulink block diagram for robotic joint or actuator models.
      

In robotics applications, rlocus is frequently used on linearized joint or end-effector dynamics to tune low-level servo gains while satisfying stability and damping requirements.

Wolfram Mathematica can also be used to compute and visualize root loci, either by directly scanning gains or by leveraging control-system functions from the control systems packages.

(* Define the open-loop transfer function:
   G(s) = K (s + 1) / [s (s + 2) (s + 4)] *)

Clear[s, K];

num[s_] := s + 1;
den[s_] := s (s + 2) (s + 4);

charPoly[s_, K_] := Expand[den[s] + K num[s]];

(* Compute roots as a function of gain *)
kValues = Range[0, 200, 1];

rootCurves =
  Table[
    {K0, s /. NSolve[charPoly[s, K0] == 0, s]},
    {K0, kValues}
  ];

(* Flatten for plotting *)
points =
  Flatten[
    Table[
      {Re[rootCurves[[k, 2, i]]], Im[rootCurves[[k, 2, i]]]},
      {k, Length[kValues]}, {i, 3}
    ],
    1
  ];

ListPlot[
  points,
  AxesLabel -> {"Real axis", "Imag axis"},
  PlotRange -> All,
  AspectRatio -> 1/2,
  PlotMarkers -> Automatic,
  GridLines -> Automatic,
  PlotLabel -> "Root locus of G(s) = K (s + 1) / [s (s + 2) (s + 4)]"
]
      

The earlier rules (number of branches, starting points at poles, real-axis segments) can be verified against this numerical plot, reinforcing the theoretical understanding.

Problem 1 (Counting Branches and Start/End Points).

Consider the open-loop transfer function \( G(s) = K \dfrac{s+3}{s(s+1)(s+4)} \).

1. Determine the number of root-locus branches.
2. Determine where each branch starts when \( K=0 \).
3. Determine how many branches end at finite zeros and how many go to infinity.

Solution.

We have one finite zero at \( s=-3 \) and three poles at \( s=0, -1, -4 \). Therefore \( n=3 \), \( m=1 \).

• There are \( n = 3 \) branches of the root locus.
• By Rule 1A, the branches start at the open-loop poles: one at \( s=0 \), one at \( s=-1 \), and one at \( s=-4 \).
• By Rule 1B, one branch terminates at the finite zero \( s=-3 \). The remaining \( n-m = 2 \) branches go to infinity.

Problem 2 (Real-Axis Segments).

For the same system as in Problem 1, determine which segments of the real axis belong to the root locus.

Solution.

The real poles and zeros are at \( -4, -3, -1, 0 \). We examine each interval:

• \( s > 0 \): to the right of any test point (e.g., \( s=1 \)) are no real poles or zeros; so the count \( N_{\text{R}} = 0 \) is even. This segment is not on the root locus.
• \( -1 < s < 0 \): choose \( s=-0.5 \). To its right lies \( 0 \) only, so \( N_{\text{R}} = 1 \), which is odd. This segment is on the root locus.
• \( -3 < s < -1 \): choose \( s=-2 \). To its right lie \( 0, -1 \), so \( N_{\text{R}} = 2 \), which is even. This segment is not on the root locus.
• \( -4 < s < -3 \): choose \( s=-3.5 \). To its right lie \( -3, -1, 0 \), so \( N_{\text{R}} = 3 \), which is odd. This segment is on the root locus.
• \( s < -4 \): choose \( s=-5 \). To its right lie \( -4, -3, -1, 0 \), so \( N_{\text{R}} = 4 \), even. This segment is not on the root locus.

Therefore, the real-axis locus lies on \( (-4, -3) \) and \( (-1, 0) \).

Problem 3 (Symmetry Proof).

Let \( G(s) \) have real coefficients. Prove that if \( s_0 \) is on the root locus for some \( K \ge 0 \), then \( \overline{s_0} \) is also on the root locus for the same \( K \).

Solution.

By assumption, \( s_0 \) satisfies the characteristic equation \( D(s_0) + K N(s_0) = 0 \) with real-coefficient polynomials \( D, N \) and real \( K \). Taking complex conjugates gives

\[ \overline{D(s_0)} + K\,\overline{N(s_0)} = 0. \]

Using the property \( \overline{D(s_0)} = D(\overline{s_0}) \) and similarly for \( N \), we obtain

\[ D(\overline{s_0}) + K N(\overline{s_0}) = 0. \]

Thus \( \overline{s_0} \) is also a closed-loop pole for gain \( K \), which proves symmetry of the root locus with respect to the real axis.

Problem 4 (Repeated Pole Behavior).

Consider \( G(s) = \dfrac{K}{s^2(s+4)} \). Show that two branches of the root locus leave the double pole at the origin, and argue qualitatively how they must separate in angle.

Solution.

The denominator is \( D(s) = s^2(s+4) \), so \( s=0 \) is a pole of multiplicity \( r=2 \). Applying the analysis from Section 5, factor out \( (s-0)^2 \) and write

\[ D(s) = s^2 D_1(s), \quad D_1(0) = 4. \]

The characteristic equation is

\[ s^2 D_1(s) + K = 0. \]

Near \( s=0 \), approximate \( D_1(s) \approx D_1(0) = 4 \), giving

\[ 4 s^2 + K \approx 0 \quad\Longrightarrow\quad s^2 \approx -\frac{K}{4}. \]

For \( K > 0 \), the right-hand side is a negative real number, so the solutions are \( s \approx \pm \mathrm{j}\sqrt{K}/2 \). Thus there are \( r=2 \) branches leaving the double pole at \( s=0 \), locally heading toward the imaginary axis at right angles (separated by \( 180^{\circ} \)). More generally, for multiplicity \( r \) there are \( r \) branches separated by \( 360^{\circ}/r \).

Problem 5 (Angle Condition on the Real Axis).

Let \( G(s) \) have distinct real poles and zeros at \( a_1, \dots, a_{\ell} \) on the real axis. Show that a point \( s_0 \) on the real axis satisfies the angle condition if and only if the number of \( a_i \) to the right of \( s_0 \) is odd.

Solution.

For each real pole or zero at \( a_i \), the vector from \( a_i \) to \( s_0 \) lies on the real axis, giving an angle of \( 0 \) if \( s_0 \) is to the right and \( \pi \) (or \( -\pi \)) if \( s_0 \) is to the left. Complex conjugate pairs contribute angles that cancel modulo \( 2\pi \). Therefore the net angle of \( G(s_0) \) modulo \( 2\pi \) is

\[ \angle G(s_0) \equiv N_{\text{R}} \pi \;\;(\text{mod } 2\pi), \]

where \( N_{\text{R}} \) is the number of real poles and zeros to the right of \( s_0 \). The angle condition requires \( \angle G(s_0) = (2k+1)\pi \) for some integer \( k \), which holds exactly when \( N_{\text{R}} \) is odd.

Hence the real-axis rule is rigorously justified.

In this lesson we derived the foundational rules for constructing root loci from the characteristic equation and the angle/magnitude conditions. We showed that the number of branches equals the number of open-loop poles, branches start at poles and end at zeros or infinity, the locus is symmetric with respect to the real axis, and real-axis segments are characterized by an odd count of real poles and zeros to the right of a point. We also studied the behavior near multiple poles and recorded qualitative properties of unbounded branches, preparing the way for the precise asymptotic formulas (asymptotes and centroid) and breakaway analysis in the next lesson. Finally, we implemented numerical root locus plotting in several programming environments that are relevant for control and robotics.