In previous lessons you learned how to compute the Laplace transform \( F(s) = \mathcal{L}\{f(t)\}(s) \) and key properties such as linearity, time shift, and differentiation. In control engineering, however, we often start from a Laplace-domain description (obtained from differential equations) and need to recover the time-domain signal \( f(t) \). This is the task of the inverse Laplace transform.

Formally, for a function \( f(t) \) of exponential order with Laplace transform \( F(s) \), the inverse Laplace transform is defined by the Bromwich integral:

\[ f(t) = \mathcal{L}^{-1}\{F(s)\}(t) = \frac{1}{2\pi i}\int_{\gamma - i\infty}^{\gamma + i\infty} e^{st} F(s)\, ds, \quad t > 0, \]

where \( \gamma \) is chosen so that the vertical line \( \operatorname{Re}(s) = \gamma \) lies in the region of convergence of \( F(s) \).

In practice, control engineers almost never evaluate this contour integral directly. Instead, we exploit the fact that most LTI models used in control and robotics produce rational Laplace transforms:

\[ F(s) = \frac{N(s)}{D(s)}, \quad N(s), D(s) \text{ polynomials,} \quad \deg N(s) < \deg D(s). \]

For such rational functions, the inverse Laplace transform can be computed by factoring \( D(s) \) and applying partial fraction expansion. This connects algebraic factorization in the complex plane with time-domain exponentials and damped sinusoids.

Recall the (one-sided) Laplace transform:

\[ F(s) = \mathcal{L}\{f(t)\}(s) = \int_{0}^{\infty} e^{-st} f(t)\, dt, \quad \operatorname{Re}(s) > \sigma_0, \]

where \( \sigma_0 \) depends on the growth of \( f(t) \). Under mild regularity assumptions, we have:

• Uniqueness: If \( \mathcal{L}\{f(t)\}(s) = \mathcal{L}\{g(t)\}(s) \) in some right half-plane, then \( f(t) = g(t) \) for almost all \( t \ge 0 \).
• Existence of inverse: If \( F(s) \) is analytic in a right half-plane and satisfies a suitable growth condition as \( |s| \to \infty \), then there exists \( f(t) \) such that \( F(s) = \mathcal{L}\{f(t)\}(s) \), and \( f(t) \) is given by the Bromwich integral.

The Bromwich integral can be evaluated using complex analysis (residue theorem). For rational transforms with isolated poles, the contour integral reduces to a finite sum of residues. This is exactly what partial fraction expansion encodes in an algebraic way.

In linear control (and in many robotics actuators modeled as LTI systems), the Laplace transform of interest is almost always a proper rational function \( F(s) = N(s)/D(s) \) with \( \deg N < \deg D \). Suppose

\[ D(s) = \prod_{k=1}^{r} (s - p_k)^{m_k}, \quad p_k \in \mathbb{C}, \; m_k \in \mathbb{N}, \]

where the \( p_k \) are distinct poles, possibly repeated with multiplicity \( m_k \). Then we can write:

\[ F(s) = \sum_{k=1}^{r} \sum_{\ell=1}^{m_k} \frac{A_{k,\ell}}{(s - p_k)^{\ell}}, \]

where the \( A_{k,\ell} \) are complex constants called residues. The inverse Laplace transform is then obtained term-by-term using known transform pairs such as \( \mathcal{L}^{-1}\{1/(s-a)\}(t) = e^{at} u(t) \) and \( \mathcal{L}^{-1}\{1/(s-a)^n\}(t) = t^{n-1} e^{at}/(n-1)! \cdot u(t) \).

For rational functions, a practical computational workflow is:

flowchart TD
  A["Start: F(s) = N(s)/D(s)"] --> B["Check proper: degree(N) less than degree(D)"]
  B --> C["Factor D(s) into (s - pk)^mk"]
  C --> D["Compute residues A_k_l (algebraic or via limits)"]
  D --> E["Write F(s) as sum of simple terms"]
  E --> F["Use known Laplace pairs to get f(t)"]
  F --> G["Interpret f(t) as system response in time domain"]
  

In what follows, we will examine how to compute the coefficients \( A_{k,\ell} \) for the most important cases.

Assume \( F(s) = N(s)/D(s) \) is proper and that \( D(s) \) factors into distinct real linear factors:

\[ D(s) = (s - p_1)(s - p_2)\cdots(s - p_n), \quad p_i \in \mathbb{R}, \; p_i \neq p_j \text{ for } i \neq j. \]

Then the partial fraction expansion has the form

\[ F(s) = \sum_{k=1}^{n} \frac{A_k}{s - p_k}. \]

Multiplying both sides by \( (s - p_k) \) and taking the limit as \( s \to p_k \) yields the residue formula

\[ A_k = \lim_{s \to p_k} (s - p_k) F(s) = \frac{N(p_k)}{\displaystyle\prod_{\substack{j=1 \\ j \neq k}}^{n} (p_k - p_j)}. \]

The inverse Laplace transform is then

\[ f(t) = \mathcal{L}^{-1}\{F(s)\}(t) = \sum_{k=1}^{n} A_k e^{p_k t} u(t), \]

so each real pole \( p_k \) contributes a real exponential term. For stable LTI models used in control, these poles lie in the left half-plane \( \operatorname{Re}(p_k) < 0 \), yielding decaying exponentials.

Example 4.1: Simple rational transform

Consider

\[ F(s) = \frac{4s + 1}{(s + 1)(s + 3)}. \]

Here \( p_1 = -1 \), \( p_2 = -3 \). Compute \( A_1, A_2 \):

\[ A_1 = \lim_{s \to -1} (s + 1)F(s) = \frac{4(-1) + 1}{(-1 + 3)} = \frac{-3}{2} = -\frac{3}{2}, \]

\[ A_2 = \lim_{s \to -3} (s + 3)F(s) = \frac{4(-3) + 1}{(-3 + 1)} = \frac{-11}{-2} = \frac{11}{2}. \]

Thus

\[ F(s) = -\frac{3}{2}\frac{1}{s + 1} + \frac{11}{2}\frac{1}{s + 3}, \quad f(t) = \left(-\frac{3}{2}e^{-t} + \frac{11}{2}e^{-3t}\right)u(t). \]

This corresponds to the impulse response of a simple second-order LTI system with two real modes.

Suppose \( F(s) \) has a pole \( p \) of multiplicity \( m \ge 2 \), so that

\[ F(s) = \frac{N(s)}{(s - p)^m Q(s)}, \quad Q(p) \neq 0. \]

Then the partial fraction expansion around that pole has the form

\[ F(s) = \sum_{\ell=1}^{m} \frac{A_{\ell}}{(s - p)^{\ell}} + \text{terms from other poles}. \]

The coefficients \( A_{\ell} \) can be obtained using the generalized residue formulas:

\[ A_{\ell} = \frac{1}{(m - \ell)!} \lim_{s \to p} \frac{d^{\,m - \ell}}{ds^{\,m - \ell}} \Bigl[(s - p)^{m} F(s)\Bigr], \quad \ell = 1, \dots, m. \]

For instance, for \( m = 2 \):

\[ F(s) = \frac{A_1}{s - p} + \frac{A_2}{(s - p)^2} + \cdots, \quad A_2 = \lim_{s \to p} (s - p)^2 F(s), \quad A_1 = \frac{d}{ds}\Bigl[(s - p)^2 F(s)\Bigr]_{s = p}. \]

The inverse Laplace transform of these terms is

\[ \mathcal{L}^{-1}\left\{\frac{A_{\ell}}{(s - p)^{\ell}}\right\}(t) = A_{\ell}\frac{t^{\ell - 1}}{(\ell - 1)!} e^{pt} u(t). \]

Example 5.1: Second-order repeated pole

Consider

\[ F(s) = \frac{1}{(s + 2)^2}. \]

Here \( p = -2 \), \( m = 2 \), and there is only one term. We know from standard pairs that

\[ f(t) = \mathcal{L}^{-1}\{F(s)\}(t) = t e^{-2t} u(t). \]

This appears, for example, as a critically damped mode in mechanical systems.

Many underdamped mechanical or robotic joint models produce complex conjugate poles:

\[ D(s) = (s - p)(s - \bar{p}), \quad p = \alpha + i\beta,\; \bar{p} = \alpha - i\beta, \quad \alpha, \beta \in \mathbb{R},\; \beta \neq 0. \]

With real coefficients, the corresponding partial fraction terms can always be written in the real-combination form

\[ F(s) = \frac{B s + C}{(s - \alpha)^2 + \beta^2}, \quad B, C \in \mathbb{R}. \]

Using standard Laplace pairs:

\[ \mathcal{L}^{-1}\left\{\frac{1}{(s - \alpha)^2 + \beta^2}\right\}(t) = \frac{1}{\beta} e^{\alpha t}\sin(\beta t) u(t), \]

\[ \mathcal{L}^{-1}\left\{\frac{s - \alpha}{(s - \alpha)^2 + \beta^2}\right\}(t) = e^{\alpha t}\cos(\beta t) u(t), \]

we obtain

\[ f(t) = e^{\alpha t} \left[ B\cos(\beta t) + \frac{C - B\alpha}{\beta}\sin(\beta t) \right] u(t). \]

Thus complex poles correspond to damped oscillations. In later chapters on second-order systems, you will see that the parameters \( \alpha \) and \( \beta \) encode damping and natural frequency.

flowchart TD
  A["Poles of D(s)"] --> B["Real, distinct: \nexponentials e^{p_k t}"]
  A --> C["Real, repeated: \nt^(m-1) e^{p t}"]
  A --> D["Complex conjugate: \ne^{alpha t} * sinusoid"]
  B --> E["Overdamped motions"]
  C --> F["Critically damped motions"]
  D --> G["Underdamped oscillations"]
        

Consider a simple mass-damper system (no spring) subjected to a unit step input \( u(t) \), with equation

\[ \dot{y}(t) + 3 y(t) = u(t), \quad y(0) = 0. \]

This kind of first-order dynamics is a basic building block for servo and robotic actuators. Taking Laplace transforms (using properties from earlier lessons):

\[ s Y(s) - y(0) + 3 Y(s) = \frac{1}{s}, \quad y(0) = 0, \]

\[ (s + 3) Y(s) = \frac{1}{s} \quad \Rightarrow \quad Y(s) = \frac{1}{s(s + 3)}. \]

We now perform partial fraction expansion:

\[ \frac{1}{s(s + 3)} = \frac{A}{s} + \frac{B}{s + 3}. \]

Multiplying by \( s(s+3) \) gives \( 1 = A(s+3) + B s \). Setting \( s = 0 \): \( 1 = 3A \Rightarrow A = \frac{1}{3} \). Setting \( s = -3 \): \( 1 = -3B \Rightarrow B = -\frac{1}{3} \). Therefore

\[ Y(s) = \frac{1}{3}\frac{1}{s} - \frac{1}{3}\frac{1}{s + 3}. \]

Using known inverse transforms:

\[ y(t) = \frac{1}{3} u(t) - \frac{1}{3}e^{-3t} u(t) = \frac{1}{3}\bigl(1 - e^{-3t}\bigr)u(t). \]

This is a standard first-order step response with final value \( 1/3 \) and time constant \( 1/3 \). In robotic joint control, similar expressions describe how joint velocity or position approaches a commanded value.

In Python, sympy provides symbolic Laplace tools, and the python-control library (widely used for control and robotics) provides convenient interfaces for working with transfer-function-like objects. Below we:

1. Symbolically compute a partial fraction expansion and inverse Laplace transform.
2. Use python-control to represent the same rational function.

import sympy as sp

# Symbolic variables
s, t = sp.symbols('s t', real=True, positive=True)

# Example: Y(s) = 1 / (s*(s + 3))
Y = 1 / (s * (s + 3))

# Partial fraction expansion (apart)
Y_part = sp.apart(Y, s)
print("Partial fraction expansion:", Y_part)

# Inverse Laplace transform
y_t = sp.inverse_laplace_transform(Y, s, t)
print("y(t) =", sp.simplify(y_t))

# Using python-control for a similar rational function
# pip install control
import control

# Transfer function with numerator 1 and denominator s*(s+3)
num = [1]
den = [1, 3, 0]  # s^2 + 3s + 0 = s*(s+3)
G = control.TransferFunction(num, den)

print("G(s) =", G)

# Step response (useful in servo/robot joint models)
t_vec, y_step = control.step_response(G)

# t_vec and y_step can be plotted or compared with the analytic y(t)
      

In a robotics context, such models appear as simplified joint or motor dynamics, where Laplace-domain rational functions are mapped back to time-domain responses for controller tuning.

C++ does not have a built-in symbolic engine, but we can compute residues by solving linear systems. Libraries such as Eigen (widely used in robotics, including ROS-based stacks) handle the linear algebra. For distinct poles, coefficients satisfy: \( F(s) = \sum_k A_k/(s - p_k) \). Evaluating this identity at \( n \) different values of \( s \) yields a linear system in the unknown \( A_k \).

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

// Example: F(s) = 1 / (s*(s+3)) with distinct real poles
// Goal: find A, B such that F(s) = A/s + B/(s+3)

std::complex<double> F(std::complex<double> s) {
    return 1.0 / (s * (s + 3.0));
}

int main() {
    using cd = std::complex<double>;

    // Choose two distinct sample points s0, s1 (avoid poles)
    cd s0(0.5, 0.0);
    cd s1(1.0, 0.0);

    Eigen::Matrix<cd, 2, 2> M;
    Eigen::Matrix<cd, 2, 1> b;

    // F(s) = A/s + B/(s+3)
    // So F(s_i) = A/s_i + B/(s_i + 3)
    M(0, 0) = 1.0 / s0;
    M(0, 1) = 1.0 / (s0 + 3.0);
    b(0, 0) = F(s0);

    M(1, 0) = 1.0 / s1;
    M(1, 1) = 1.0 / (s1 + 3.0);
    b(1, 0) = F(s1);

    Eigen::Matrix<cd, 2, 1> x = M.colPivHouseholderQr().solve(b);
    cd A = x(0, 0);
    cd B = x(1, 0);

    std::cout << "A = " << A << std::endl;
    std::cout << "B = " << B << std::endl;

    // In embedded robotics controllers, such coefficients can be precomputed offline
    // and the time-domain response evaluated using exponentials e^{p_k t}.
    return 0;
}
      

In robotic control firmware, these coefficients are typically computed offline (e.g., in a design tool) and then hard-coded or stored in configuration files used by C++ controllers.

In Java-based robotics stacks (for example, in some educational robotics platforms), one can use libraries such as Apache Commons Math to solve for partial fraction coefficients. The idea is similar to the C++ example: evaluate the rational function at several \( s \) values and solve for the unknown residues.

import org.apache.commons.math3.complex.Complex;
import org.apache.commons.math3.linear.Array2DRowFieldMatrix;
import org.apache.commons.math3.linear.ArrayFieldVector;
import org.apache.commons.math3.linear.FieldDecompositionSolver;
import org.apache.commons.math3.linear.FieldLUDecomposition;
import org.apache.commons.math3.linear.FieldVector;

public class PartialFractionJava {

    // Example: F(s) = 1 / (s*(s+3))
    public static Complex F(Complex s) {
        return Complex.ONE.divide(s.multiply(s.add(new Complex(3.0, 0.0))));
    }

    public static void main(String[] args) {
        Complex s0 = new Complex(0.5, 0.0);
        Complex s1 = new Complex(1.0, 0.0);

        Complex[][] data = new Complex[][] {
            { Complex.ONE.divide(s0), Complex.ONE.divide(s0.add(new Complex(3.0, 0.0))) },
            { Complex.ONE.divide(s1), Complex.ONE.divide(s1.add(new Complex(3.0, 0.0))) }
        };
        Complex[] rhs = new Complex[] { F(s0), F(s1) };

        Array2DRowFieldMatrix<Complex> M = new Array2DRowFieldMatrix<>(data);
        ArrayFieldVector<Complex> b = new ArrayFieldVector<>(rhs);

        FieldDecompositionSolver<Complex> solver =
            new FieldLUDecomposition<>(M).getSolver();
        FieldVector<Complex> x = solver.solve(b);

        Complex A = x.getEntry(0);
        Complex B = x.getEntry(1);

        System.out.println("A = " + A);
        System.out.println("B = " + B);

        // In control design tools for Java-based robots (e.g., FRC libraries),
        // such rational models can be used to predict time responses.
    }
}
      

MATLAB, together with Simulink and Robotics System Toolbox, is heavily used in robotics and control. MATLAB provides the function residue for partial fraction expansion of rational functions:

% Example: Y(s) = 1 / (s*(s+3))
num = 1;
den = [1 3 0];  % s^2 + 3s + 0

% Partial fraction expansion
[R, P, K] = residue(num, den);  % R: residues, P: poles, K: direct term

disp('Residues R:');
disp(R);
disp('Poles P:');
disp(P);

% Build transfer function and simulate step response
sys = tf(num, den);  % requires Control System Toolbox
figure;
step(sys);
title('Step response of Y(s) = 1 / (s (s + 3))');

% In Simulink:
% - Use a Step block as input, connect to a Transfer Fcn block with numerator [1]
%   and denominator [1 3 0].
% - Scope block displays y(t).
% Such blocks are often used inside larger robotic models built with Robotics System Toolbox.
      

The residue coefficients R correspond exactly to analytic residues \( A_k \), and the poles P to \( p_k \). This bridges symbolic partial fraction expansions and numerical simulation.

Wolfram Mathematica has built-in functions Apart (for partial fractions) and InverseLaplaceTransform. These are useful for deriving analytic expressions that can later be implemented in control and robotics software.

(* Example: Y(s) = 1 / (s (s + 3)) *)

Clear[s, t];
Y[s_] := 1/(s (s + 3));

(* Partial fraction expansion *)
Ypart = Apart[Y[s], s]
(* Output: 1/3 1/s - 1/3 1/(s + 3) *)

(* Inverse Laplace transform *)
y[t_] = InverseLaplaceTransform[Y[s], s, t] // FullSimplify
(* Output: (1/3) (1 - Exp[-3 t]) UnitStep[t] *)

(* For more complex systems, combine with TransferFunctionModel and StateSpaceModel
   to derive symbolic responses before exporting them to embedded robotics code. *)
      

Mathematica is especially valuable when deriving closed-form responses for higher-order systems that would be tedious to treat by hand.

In this lesson we introduced the inverse Laplace transform and its formal definition via the Bromwich integral. For the rational Laplace transforms that dominate linear control and robotics applications, we showed how partial fraction expansion provides an efficient and conceptually clear route to time-domain responses. Distinct real poles yield sums of exponentials, repeated poles add polynomial-in-time factors, and complex conjugate poles produce damped sinusoids.

We derived residue formulas for distinct and repeated poles, demonstrated a full ODE solution via Laplace and partial fractions, and connected these ideas to computational workflows in Python, C++, Java, MATLAB/Simulink, and Wolfram Mathematica. In the next chapter, these inverse Laplace tools will be used systematically when defining and analyzing transfer functions for LTI systems.