In linear control, most physical models start as ordinary differential equations (ODEs) with constant coefficients derived from Newton's laws, Kirchhoff's laws, or energy balance. For a generic single-input single-output (SISO) system with state variable \( x(t) \) and input \( u(t) \), we often obtain an equation of the form

\[ a_n \frac{d^n x(t)}{dt^n} + a_{n-1} \frac{d^{n-1} x(t)}{dt^{n-1}} + \cdots + a_1 \frac{dx(t)}{dt} + a_0 x(t) = \\ b_m \frac{d^m u(t)}{dt^m} + \cdots + b_1 \frac{du(t)}{dt} + b_0 u(t). \]

Solving such ODEs directly in the time domain can be tedious, especially when we later need to handle interconnections of subsystems. The Laplace transform replaces derivatives by multiplication with a complex variable \( s \), converting differential equations into algebraic equations. This is the algebraic foundation upon which transfer functions (Chapter 4) and many classical control tools are built.

At a high level, the workflow for using Laplace transforms in control can be summarized as:

flowchart TD
  A["Time-domain ODE model (mass-spring-damper, motor, etc.)"]
    --> B["Apply unilateral Laplace transform (assume t >= 0)"]
  B --> C["Obtain algebraic equation in 's' (polynomial in s times X(s) and U(s))"]
  C --> D["Solve for 'X(s)' in terms of 'U(s)' (input-output relation)"]
  D --> E["Use known inverse pairs or later tools to recover x(t)"]
        

This lesson focuses on the mathematical foundation up to the point of constructing algebraic relations in the \( s \)-domain; inversion techniques and systematic property tables are deepened in Lesson 4 and Lesson 5.

In control engineering, we usually work with the unilateral Laplace transform, defined for causal signals \( f(t) \) with \( f(t) = 0 \) for \( t < 0 \). Let \( s = \sigma + \mathrm{j}\omega \in \mathbb{C} \). The unilateral Laplace transform is defined as

\[ \mathcal{L}\{f(t)\}(s) = F(s) = \int_{0}^{\infty} f(t) e^{-st}\, dt, \quad s \in \mathbb{C}, \]

whenever the improper integral converges. The variable \( s \) is called the complex frequency, and the image \( F(s) \) is a complex-valued function defined on some subset of the complex plane.

We say the transform \( F(s) \) exists at a particular \( s \) if the integral converges absolutely:

\[ \int_{0}^{\infty} \left| f(t) e^{-st} \right| dt = \int_{0}^{\infty} |f(t)| e^{-\sigma t} dt < \infty. \]

The set of all such values of \( s \) where the integral converges is called the region of convergence (ROC) of \( F(s) \). For most causal LTI control systems, the ROC will be a right half-plane \( \{s : \operatorname{Re}(s) > \sigma_0\} \).

flowchart TD
  S["Time signal f(t), t >= 0"] --> I["Check growth: exponential order?"]
  I -->|yes| R["ROC is right-half plane: Re(s) > sigma0"]
  I -->|no| N["No Laplace transform \n(or only in distribution sense)"]
        

A standard sufficient condition for existence is that a signal be of exponential order.

Definition (Exponential order). A function \( f : [0,\infty) \to \mathbb{R} \) is of exponential order \( \alpha \) if there exist constants \( M > 0 \) and \( \alpha \in \mathbb{R} \) such that

\[ |f(t)| \le M e^{\alpha t} \quad \text{for all } t \ge 0. \]

Theorem. If \( f(t) \) is piecewise continuous on every finite interval of \( [0,\infty) \) and of exponential order \( \alpha \), then \( \mathcal{L}\{f(t)\}(s) \) exists for all \( s \) with \( \operatorname{Re}(s) > \alpha \).

Proof (sketch). Let \( s = \sigma + \mathrm{j}\omega \). Under the exponential-order assumption,

\[ \int_{0}^{\infty} |f(t)| e^{-\sigma t} dt \le \int_{0}^{\infty} M e^{\alpha t} e^{-\sigma t} dt = M \int_{0}^{\infty} e^{-(\sigma - \alpha)t} dt. \]

The right-hand side converges if and only if \( \sigma - \alpha > 0 \), that is \( \sigma > \alpha \). Thus the Laplace transform exists on the open half-plane \( \operatorname{Re}(s) > \alpha \). In control engineering, signals describing bounded physical states and inputs are typically of exponential order, so their Laplace transforms exist on some right half-plane.

We now derive several fundamental Laplace transform pairs that will be used throughout the course. Let \( u(t) \) denote the unit step function, \( u(t) = 0 \) for \( t < 0 \) and \( u(t) = 1 \) for \( t \ge 0 \).

(a) Constant (unit step).

\[ f(t) = u(t) \quad \Rightarrow \quad F(s) = \mathcal{L}\{u(t)\}(s) = \int_{0}^{\infty} 1 \cdot e^{-st} dt = \frac{1}{s}, \quad \operatorname{Re}(s) > 0. \]

(b) Exponential. For \( a \in \mathbb{R} \),

\[ f(t) = e^{at} u(t) \quad \Rightarrow \quad F(s) = \int_{0}^{\infty} e^{at} e^{-st} dt = \int_{0}^{\infty} e^{-(s-a)t} dt = \frac{1}{s-a}, \quad \operatorname{Re}(s) > a. \]

(c) Polynomial. For integer \( n \ge 0 \),

\[ f(t) = t^n u(t) \quad \Rightarrow \quad F(s) = \int_{0}^{\infty} t^n e^{-st} dt = \frac{n!}{s^{n+1}}, \quad \operatorname{Re}(s) > 0. \]

This follows from repeated integration by parts or from the definition of the Gamma function.

(d) Sinusoidal signals. Assume \( \omega_0 > 0 \).

\[ f(t) = \sin(\omega_0 t)u(t) \quad \Rightarrow \quad F(s) = \frac{\omega_0}{s^2 + \omega_0^2}, \quad \operatorname{Re}(s) > 0, \]

\[ f(t) = \cos(\omega_0 t)u(t) \quad \Rightarrow \quad F(s) = \frac{s}{s^2 + \omega_0^2}, \quad \operatorname{Re}(s) > 0. \]

These are obtained by rewriting sine and cosine via complex exponentials and using the exponential transform pair.

These elementary pairs already describe typical signals in control: steps (actuator commands), exponentials (natural responses), and sinusoids (test signals and disturbances).

The most important structural property for control is the interaction between Laplace transforms and differentiation. We start with linearity, then derive the derivative property.

Linearity. For scalars \( a,b \in \mathbb{R} \) and functions \( f(t), g(t) \) for which the transforms exist,

\[ \mathcal{L}\{ a f(t) + b g(t) \}(s) = a \mathcal{L}\{f(t)\}(s) + b \mathcal{L}\{g(t)\}(s). \]

Derivative property (first derivative). Suppose \( f(t) \) and its derivative \( f'(t) \) are of exponential order and continuous from the right at \( t = 0 \). Then

\[ \mathcal{L}\{ f'(t) \}(s) = s F(s) - f(0^+), \]

where \( F(s) = \mathcal{L}\{f(t)\}(s) \).

Proof. By definition,

\[ \mathcal{L}\{f'(t)\}(s) = \int_{0}^{\infty} f'(t) e^{-st} dt. \]

Perform integration by parts with \( u = e^{-st} \), \( dv = f'(t)\, dt \), hence \( du = -s e^{-st} dt \) and \( v = f(t) \):

\[ \int_{0}^{\infty} f'(t) e^{-st} dt = \left[ f(t)e^{-st} \right]_{0}^{\infty} + s \int_{0}^{\infty} f(t) e^{-st} dt. \]

Under the exponential-order assumption and suitable regularity, \( f(t)e^{-st} \to 0 \) as \( t \to \infty \) for all \( s \) in the ROC, so the boundary term at infinity vanishes. Thus

\[ \mathcal{L}\{f'(t)\}(s) = - f(0^+) + s \int_{0}^{\infty} f(t)e^{-st} dt = s F(s) - f(0^+). \]

Second derivative. Applying the first derivative property to \( f'(t) \), we get

\[ \mathcal{L}\{f''(t)\}(s) = s \mathcal{L}\{f'(t)\}(s) - f'(0^+) = s\big(s F(s) - f(0^+)\big) - f'(0^+) = \\ s^2 F(s) - s f(0^+) - f'(0^+). \]

Higher-order derivatives follow similarly and will be used extensively when transforming high-order ODE models.

Consider a first-order LTI system often used to approximate a robot joint velocity loop or a simple RC circuit,

\[ \tau \frac{dx(t)}{dt} + x(t) = u(t), \quad t \ge 0, \]

where \( x(t) \) is the output (e.g., joint velocity), \( u(t) \) is the input (e.g., voltage command), and \( \tau > 0 \) is the time constant. Assume zero initial condition \( x(0^+) = 0 \) and a step input

\[ u(t) = U_0\,u(t) \quad \text{(constant step of magnitude } U_0 \text{)}. \]

Taking the unilateral Laplace transform of both sides and using the derivative property,

\[ \tau \left( s X(s) - x(0^+) \right) + X(s) = \frac{U_0}{s}, \]

which simplifies (since \( x(0^+) = 0 \)) to

\[ (\tau s + 1) X(s) = \frac{U_0}{s} \quad \Rightarrow \quad X(s) = \frac{U_0}{s(\tau s + 1)}. \]

We can decompose this rational function into simpler terms whose inverse transforms are known. Perform partial fraction expansion:

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

Solving for \( A,B \) yields \( A = U_0 \), \( B = -U_0 \). Thus

\[ X(s) = \frac{U_0}{s} - \frac{U_0}{\tau s + 1} = U_0\left( \frac{1}{s} - \frac{1}{\tau s + 1} \right). \]

Using the basic pairs \( \mathcal{L}^{-1}\{1/s\} = u(t) \) and \( \mathcal{L}^{-1}\{1/(\tau s + 1)\} = e^{-t/\tau}u(t) \), we obtain

\[ x(t) = U_0\left( 1 - e^{-t/\tau} \right)u(t), \]

which is the familiar first-order step response. This simple example illustrates the general pattern: Laplace transforms convert an ODE into an algebraic equation in \( s \), which we solve and then invert using known pairs or, in later lessons, systematic algebra.

Python offers mature symbolic and control libraries that are widely used in robotics and control research: sympy for symbolic Laplace transforms, scipy for numerical work, and python-control and roboticstoolbox for system modeling and simulation (used more heavily in later chapters).

The following script demonstrates the symbolic Laplace transform of the first-order system discussed above, using sympy.

import sympy as sp

# Symbols
t, s = sp.symbols('t s', real=True, positive=True)
tau, U0 = sp.symbols('tau U0', positive=True)

# Time-domain variables
x = sp.Function('x')
u = U0  # Step input of magnitude U0 for t >= 0

# Define the ODE: tau * dx/dt + x(t) = u(t), with x(0) = 0
ode = sp.Eq(tau * sp.diff(x(t), t) + x(t), u)

# Take Laplace transform of both sides (unilateral)
X = sp.Function('X')
X_s = sp.Function('X')(s)  # placeholder

# Sympy provides laplace_transform directly
X_s = sp.laplace_transform(x(t), t, s, noconds=True)
U_s = sp.laplace_transform(u, t, s, noconds=True)  # = U0 / s

# Express the transformed ODE using the derivative property manually:
# L{dx/dt} = s * X(s) - x(0)
x0 = sp.Symbol('x0')
laplace_ode = sp.Eq(tau * (s * X_s - x0) + X_s, U_s)

# Assume x(0) = 0 and solve for X(s)
laplace_ode_zero_ic = laplace_ode.subs(x0, 0)
X_s_solution = sp.solve(laplace_ode_zero_ic, X_s)[0]
print("X(s) =", sp.simplify(X_s_solution))

# Inverse Laplace to get x(t)
x_t = sp.inverse_laplace_transform(X_s_solution, s, t)
print("x(t) =", sp.simplify(x_t))
      

In robotics applications, the same symbolic representation of \( X(s) \) will later be connected to a joint dynamics model or actuator model within python-control or roboticstoolbox, but here we focus purely on the Laplace mechanics.

In low-level robotic controllers (e.g., firmware or real-time loops in ROS/ROS 2), C++ is often used. There is no standard symbolic Laplace library, but we can numerically approximate \( F(s) = \int_{0}^{\infty} f(t)e^{-st}dt \) by truncating the integral to a finite horizon and using numerical integration. Libraries like Eigen are frequently used for linear algebra, and control/robotics frameworks such as ros_control build upon these.

#include <iostream>
#include <functional>
#include <cmath>

// Simple numerical Laplace transform approximation for real s > 0
double laplace_numeric(const std::function<double(double)>& f,
                       double s, double t_max, int N) {
    double h = t_max / static_cast<double>(N);
    double sum = 0.0;
    for (int k = 0; k <= N; ++k) {
        double t = k * h;
        double w = (k == 0 || k == N) ? 0.5 : 1.0; // trapezoidal rule weights
        sum += w * f(t) * std::exp(-s * t);
    }
    return h * sum;
}

int main() {
    // Example: f(t) = exp(-t / tau) * u(t), tau > 0
    double tau = 0.5;
    auto f = [tau](double t) {
        if (t < 0.0) return 0.0;
        return std::exp(-t / tau);
    };

    double s = 2.0;          // evaluation point in s-domain (real axis)
    double t_max = 10.0;     // truncate at t_max
    int N = 10000;           // number of integration steps

    double F_s = laplace_numeric(f, s, t_max, N);
    std::cout << "Approximate F(" << s << ") = " << F_s << std::endl;

    // For comparison, analytic value is 1 / (s + 1/tau)
    double F_exact = 1.0 / (s + 1.0 / tau);
    std::cout << "Exact      F(" << s << ") = " << F_exact << std::endl;
    return 0;
}
      

In a robotics context, such numerical Laplace approximations are sometimes used in model validation or in off-line analysis tools built around C++-based simulation engines, especially when coupled with libraries such as Eigen for matrix operations and physics engines for dynamics.

Java is used in some robotics platforms (e.g., educational robotics and FIRST Robotics Competition). We can implement a similar numerical Laplace approximation in Java. Libraries such as Apache Commons Math provide numerical integration and linear algebra utilities.

public class LaplaceNumeric {

    // Interface for a scalar function of time
    @FunctionalInterface
    public interface TimeFunction {
        double value(double t);
    }

    // Trapezoidal-rule approximation of Laplace transform at real s > 0
    public static double laplaceNumeric(TimeFunction f, double s,
                                        double tMax, int N) {
        double h = tMax / (double) N;
        double sum = 0.0;
        for (int k = 0; k <= N; ++k) {
            double t = k * h;
            double w = (k == 0 || k == N) ? 0.5 : 1.0;
            sum += w * f.value(t) * Math.exp(-s * t);
        }
        return h * sum;
    }

    public static void main(String[] args) {
        // Example: f(t) = u(t) (unit step), analytic F(s) = 1/s
        TimeFunction step = (double t) -> (t >= 0.0 ? 1.0 : 0.0);

        double s = 3.0;
        double tMax = 20.0;
        int N = 20000;

        double numeric = laplaceNumeric(step, s, tMax, N);
        double exact = 1.0 / s;

        System.out.println("Approximate F(" + s + ") = " + numeric);
        System.out.println("Exact       F(" + s + ") = " + exact);
    }
}
      

Such utility functions can be integrated into higher-level Java robotics libraries to analyze approximate frequency-domain characteristics of simple models, even before introducing full transfer-function-based toolchains.

MATLAB, together with Simulink and Robotics System Toolbox, is a de-facto standard in industrial control and robotics. It provides symbolic and numeric tools for Laplace transforms and ODE solving.

The following script uses the Symbolic Math Toolbox to reproduce the derivation of the first-order step response via Laplace transform.

syms t s tau U0 x(t)

% Define the ODE: tau * dx/dt + x(t) = U0, x(0) = 0
ode = tau * diff(x, t) + x == U0;

% Laplace transform both sides
X = laplace(x, t, s);
U = laplace(U0, t, s);   % = U0/s

% Use derivative property manually:
% L{diff(x,t)} = s * X - x(0)
x0 = sym('x0');
laplaceEq = tau * (s * X - x0) + X == U;

% Apply initial condition x(0) = 0
laplaceEq0 = subs(laplaceEq, x0, 0);
X_s = solve(laplaceEq0, X);           % solve algebraic equation for X(s)
X_s_simplified = simplify(X_s)

% Inverse Laplace to get x(t)
x_t = ilaplace(X_s_simplified, s, t)
pretty(x_t)
      

In Simulink, the same system can be modeled graphically by integrating the ODE \( \tau \dot{x} + x = u \) using an Integrator block and algebraic sum; Simulink internally constructs a numerical solver but the underlying theory is consistent with the Laplace representation derived here.

Wolfram Mathematica provides built-in commands LaplaceTransform and InverseLaplaceTransform, as well as ODE solvers. It is often used in theoretical control and robotics for symbolic derivations of dynamic models and their frequency-domain representations.

(* Define symbols *)
Clear[t, s, tau, U0, x]
tau > 0;
U0 > 0;

(* Time-domain ODE: tau x'(t) + x(t) == U0, x(0) == 0 *)
ode = tau x'[t] + x[t] == U0;
ic  = x[0] == 0;

(* Solve using LaplaceTransform explicitly *)
X[s_] = LaplaceTransform[x[t], t, s];
U[s_] = LaplaceTransform[U0, t, s]; (* = U0/s *)

(* Using the derivative property: LaplaceTransform[x'[t], t, s] =
   s X[s] - x[0] *)
eqLaplace = tau (s X[s] - x[0]) + X[s] == U[s];

(* Apply initial condition x[0] == 0 and solve for X[s] *)
eqLaplace0 = eqLaplace /. x[0] -> 0;
solX = Solve[eqLaplace0, X[s]][[1, 1, 2]] // Simplify

(* Inverse Laplace transform to get x(t) *)
xSolution[t_] = InverseLaplaceTransform[solX, s, t] // Simplify

xSolution[t]
      

Later in the course, similar Mathematica scripts can be extended to multi-DOF robot arms, where the Laplace-domain representation of each joint or actuator is combined with rigid-body dynamics for analysis and controller design.

In this lesson we introduced the unilateral Laplace transform as a mapping from time-domain signals to complex-frequency-domain functions. We defined the transform and region of convergence, established a sufficient existence condition via exponential order, and derived key elementary transform pairs for exponentials, polynomials, and sinusoids.

The linearity and derivative properties were shown to convert constant-coefficient ODEs into algebraic equations in \( s \). This mechanism was illustrated with a first-order model commonly used in control and robotics, revealing the classical exponential step response. Finally, we implemented Laplace transforms computationally in Python, C++, Java, MATLAB/Simulink, and Wolfram Mathematica, foreshadowing their integration into robotics and control toolchains.

In the next lesson we will formalize additional Laplace properties (shift theorems, convolution, initial and final value theorems) that are essential for systematic control-system analysis and design.