In linear control, physical systems (robot joints, vehicle speed, motor position, etc.) are modeled by ordinary differential equations (ODEs). A general single-input single-output LTI model with input \( u(t) \) and output \( y(t) \) can be written as

\[ a_n \frac{d^n y(t)}{dt^n} + a_{n-1} \frac{d^{n-1} y(t)}{dt^{n-1}} + \dots + a_1 \frac{dy(t)}{dt} + a_0 y(t) = b_m \frac{d^m u(t)}{dt^m} + \dots + b_1 \frac{du(t)}{dt} + b_0 u(t), \]

with constant real coefficients \( a_i, b_j \). Direct time-domain solution is often tedious. Laplace transform properties convert this to an algebraic relation between \( Y(s) \) and \( U(s) \) (Laplace transforms of \( y(t) \) and \( u(t) \)), provided we know:

• Linearity: how sums and scalar multiples behave under the transform.
• Time shift and exponential weighting: how delays and exponentials appear as factors in \( s \).
• Differentiation/integration: how derivatives and integrals become polynomials and divisions in \( s \).
• Convolution: how input and impulse response combine in time vs. products in the \( s \)-domain.
• Initial and final value theorems: how to read off values \( y(0^+) \) and steady state from \( Y(s) \).

Recall the unilateral Laplace transform definition (used in control):

\[ \mathcal{L}\{x(t)\} = X(s) = \int_0^{\infty} x(t) e^{-st} \, dt, \quad s \in \mathbb{C} \]

with a region of convergence in the complex plane typically of the form \( \Re(s) > \sigma_0 \). Every property in this lesson is derived from this definition and from standard calculus (integration by parts, Fubini's theorem, etc.).

The Laplace transform is linear. For any signals \( x_1(t), x_2(t) \) with transforms \( X_1(s), X_2(s) \) and scalars \( \alpha, \beta \in \mathbb{R} \),

\[ \mathcal{L}\{\alpha x_1(t) + \beta x_2(t)\} = \alpha X_1(s) + \beta X_2(s). \]

Proof. By the definition,

\[ \begin{aligned} \mathcal{L}\{\alpha x_1(t) + \beta x_2(t)\} &= \int_0^{\infty} \big(\alpha x_1(t) + \beta x_2(t)\big) e^{-st} \, dt \\ &= \alpha \int_0^{\infty} x_1(t) e^{-st} \, dt + \beta \int_0^{\infty} x_2(t) e^{-st} \, dt \\ &= \alpha X_1(s) + \beta X_2(s). \end{aligned} \]

Implication for control: for LTI systems, if \( y_1(t) \) is the response to \( u_1(t) \) and \( y_2(t) \) is the response to \( u_2(t) \), then the response to \( \alpha u_1(t) + \beta u_2(t) \) is \( \alpha y_1(t) + \beta y_2(t) \) (superposition principle). Laplace linearity is the transform-space reflection of time-domain superposition.

In robotics and mechatronic systems, sensor and actuator signals often experience pure delays (communication latency, computation time, etc.). A positive delay of \( T > 0 \) applied to a causal signal \( x(t) \) can be written as \( x(t - T) u(t - T) \), where \( u(t) \) is the unit step.

Property (time shift). If \( \mathcal{L}\{x(t)\} = X(s) \), then

\[ \mathcal{L}\{x(t - T) u(t - T)\} = e^{-sT} X(s), \quad T > 0. \]

Proof. Substitute \( \tau = t - T \), so that \( t = \tau + T \),

\[ \begin{aligned} \mathcal{L}\{x(t - T) u(t - T)\} &= \int_0^{\infty} x(t - T) u(t - T) e^{-st} \, dt \\ &= \int_T^{\infty} x(t - T) e^{-st} \, dt \quad (\text{since } u(t - T) = 0 \text{ for } t < T) \\ &\overset{t = \tau + T}{=} \int_0^{\infty} x(\tau) e^{-s(\tau + T)} \, d\tau \\ &= e^{-sT} \int_0^{\infty} x(\tau) e^{-s\tau} \, d\tau = e^{-sT} X(s). \end{aligned} \]

This factor \( e^{-sT} \) will later be crucial when we study how delays affect stability margins in the frequency domain.

Exponential factors of the form \( e^{at} \) frequently appear when solving ODEs, or when analyzing signals that grow/decay exponentially.

Property (frequency shift). If \( \mathcal{L}\{x(t)\} = X(s) \), then

\[ \mathcal{L}\{e^{at} x(t)\} = X(s - a). \]

Proof.

\[ \begin{aligned} \mathcal{L}\{e^{at} x(t)\} &= \int_0^{\infty} e^{at} x(t) e^{-st} \, dt = \int_0^{\infty} x(t) e^{-(s - a)t} \, dt = X(s - a), \end{aligned} \]

with region of convergence shifted by \( a \), i.e., if \( \Re(s) > \sigma_0 \) for \( X(s) \), then \( \Re(s) > \sigma_0 + a \) for \( X(s - a) \).

In control, this property is used repeatedly when solving homogeneous and forced responses of systems whose natural modes are exponentials like \( e^{\lambda t} \).

The most important properties for turning ODEs into algebraic equations are the derivative and integral properties.

5.1 First derivative

Property. Suppose \( x(t) \) is piecewise continuous and of exponential order, with finite right limit \( x(0^+) \). Then

\[ \mathcal{L}\left\{\frac{dx(t)}{dt}\right\} = s X(s) - x(0^+). \]

Proof (integration by parts). Start from the definition:

\[ \begin{aligned} \mathcal{L}\left\{\frac{dx(t)}{dt}\right\} &= \int_0^{\infty} \frac{dx(t)}{dt} e^{-st} \, dt. \end{aligned} \]

Let \( u = e^{-st} \), \( dv = \frac{dx(t)}{dt}\, dt \). Then \( du = -s e^{-st}\, dt \), \( v = x(t) \). Using integration by parts,

\[ \begin{aligned} \int_0^{\infty} \frac{dx(t)}{dt} e^{-st} \, dt &= \left[ x(t) e^{-st} \right]_0^{\infty} - \int_0^{\infty} x(t) (-s e^{-st}) \, dt \\ &= \lim_{T \to \infty} x(T) e^{-sT} - x(0^+) + s \int_0^{\infty} x(t) e^{-st} \, dt. \end{aligned} \]

Under the exponential order assumption and for \( \Re(s) \) sufficiently large, \( \lim_{T \to \infty} x(T) e^{-sT} = 0 \), hence

\[ \mathcal{L}\left\{\frac{dx(t)}{dt}\right\} = - x(0^+) + s X(s). \]

5.2 Higher-order derivatives

By repeated application, the Laplace transform of the \( n \)-th derivative is

\[ \mathcal{L}\left\{\frac{d^n x(t)}{dt^n}\right\} = s^n X(s) - s^{n-1} x(0^+) - s^{n-2} x'(0^+) - \dots - x^{(n-1)}(0^+). \]

This formula is the cornerstone for transforming an \( n \)-th order ODE of a control system into an algebraic equation in \( s \) that incorporates initial conditions explicitly.

5.3 Integration in time

Property.

\[ \mathcal{L}\left\{\int_0^t x(\tau)\, d\tau \right\} = \frac{1}{s} X(s). \]

Proof. Let

\[ y(t) = \int_0^t x(\tau) \, d\tau. \]

Then \( \frac{dy(t)}{dt} = x(t) \) and \( y(0^+) = 0 \). Using the derivative property,

\[ \mathcal{L}\{x(t)\} = \mathcal{L}\left\{\frac{dy(t)}{dt}\right\} = s Y(s) - y(0^+) = s Y(s), \]

so \( Y(s) = \frac{1}{s} X(s) \). Therefore \( \mathcal{L}\{\int_0^t x(\tau)\, d\tau\} = \frac{1}{s} X(s) \).

Consider a causal LTI system with impulse response \( g(t) \). For an input \( u(t) \), the output \( y(t) \) satisfies the convolution integral

\[ y(t) = (g * u)(t) = \int_0^t g(\tau)\, u(t - \tau)\, d\tau. \]

Convolution property. If \( \mathcal{L}\{g(t)\} = G(s) \) and \( \mathcal{L}\{u(t)\} = U(s) \), then

\[ \mathcal{L}\{y(t)\} = \mathcal{L}\{(g * u)(t)\} = G(s)\, U(s). \]

Proof (sketch).

\[ \begin{aligned} \mathcal{L}\{(g * u)(t)\} &= \int_0^{\infty} \left[\int_0^t g(\tau) u(t - \tau)\, d\tau \right] e^{-st} dt \\ &\text{(use Fubini's theorem and change the order of integration)} \\ &= \int_0^{\infty} g(\tau) \left[\int_{\tau}^{\infty} u(t - \tau) e^{-st} dt\right] d\tau. \end{aligned} \]

With substitution \( \theta = t - \tau \), the inner integral becomes \( e^{-s\tau} \int_0^{\infty} u(\theta) e^{-s\theta} d\theta = e^{-s\tau} U(s) \), so

\[ \mathcal{L}\{(g * u)(t)\} = \int_0^{\infty} g(\tau) e^{-s\tau} \, d\tau \cdot U(s) = G(s) U(s). \]

This property allows us to replace time-domain convolution by simple multiplication in the \( s \)-domain, which is crucial when connecting subsystems in series in control.

The initial and final value theorems allow us to recover \( x(0^+) \) and steady-state values from \( X(s) \) without computing the full inverse Laplace transform.

7.1 Initial value theorem

Theorem. If \( x(t) \) is such that \( \lim_{t \to 0^+} x(t) \) exists, then

\[ \lim_{t \to 0^+} x(t) = \lim_{s \to \infty} s X(s), \]

provided the limit on the right-hand side exists.

7.2 Final value theorem

Theorem. Suppose \( x(t) \) is such that \( \lim_{t \to \infty} x(t) \) exists and is finite, and that all poles of \( s X(s) \) lie strictly in the left half-plane \( \Re(s) < 0 \) except possibly a simple pole at \( s = 0 \). Then

\[ \lim_{t \to \infty} x(t) = \lim_{s \to 0} s X(s). \]

In later chapters, this theorem will be used extensively to compute steady-state error of feedback control systems for step, ramp, and higher-order reference signals.

The assumptions on the poles of \( sX(s) \) effectively require that the time response is asymptotically steady and does not contain persistent sinusoidal or exponentially growing terms.

The following diagram summarizes how the Laplace properties interact when solving dynamics in control problems.

flowchart TD
  A["Model physical system as ODE"] --> B["Apply Laplace definition"]
  B --> C["Use derivative property to obtain algebraic equation in s"]
  C --> D["Insert input Laplace U(s) (step, ramp, etc.)"]
  D --> E["Solve algebraically for Y(s)"]
  E --> F["Use partial fractions and table of transforms"]
  F --> G["Apply inverse transform to get y(t)"]
  G --> H["Use initial / final value theorem to check behavior"]
        

Different modeling situations call for specific Laplace properties. The decision flow below can guide you when setting up a control problem.

flowchart TD
  S["Start from dynamic equation \nor signal"] --> U1["Is there pure delay?"]
  U1 -->|yes| P1["Use time shift: \nmultiply by exp(-sT)"]
  U1 -->|no| U2["Are derivatives or \nintegrals present?"]
  U2 -->|yes| P2["Use derivative / \nintegral properties"]
  U2 -->|no| U3["Is system defined \nvia impulse response?"]
  U3 -->|yes| P3["Use convolution: \nY(s) = G(s) U(s)"]
  U3 -->|no| U4["Need initial / \nsteady-state values?"]
  U4 -->|yes| P4["Use initial or \nfinal value theorems"]
  U4 -->|no| P5["Use linearity and \nknown transform pairs"]
        

In practice, Laplace-based analysis is complemented by symbolic and numeric software. We show small examples in Python, C++, Java, MATLAB/Simulink, and Wolfram Mathematica, with an eye toward robotic joint dynamics as a canonical LTI system.

10.1 Python: Symbolic Laplace with sympy and robotics context

Consider a simplified rotary joint (e.g., a robot elbow) with inertia \( J \) and viscous friction coefficient \( b \). The speed \( \omega(t) \) satisfies

\[ J \frac{d\omega(t)}{dt} + b \omega(t) = u(t), \]

where \( u(t) \) is the applied torque. Using the derivative property,

\[ J\left[s \Omega(s) - \omega(0^+)\right] + b \Omega(s) = U(s). \]

The code below verifies the derivative property for a test signal using sympy.

import sympy as sp

# Symbols
t, s = sp.symbols('t s', real=True, positive=True)
J, b = sp.symbols('J b', positive=True)
omega0 = sp.symbols('omega0')

# Example joint speed signal (free response of first-order system)
omega_t = omega0 * sp.exp(-b/J * t)

# Laplace transform of omega(t)
Omega_s = sp.laplace_transform(omega_t, t, s)[0]

# Laplace of derivative d omega/dt
lhs = sp.laplace_transform(sp.diff(omega_t, t), t, s)[0]

# s*Omega(s) - omega(0+)
rhs = s * Omega_s - omega_t.subs(t, 0)

print("Omega(s) =", Omega_s)
print("L{d omega/dt} =", lhs)
print("s*Omega(s) - omega(0+) =", rhs)
print("Identity holds:", sp.simplify(lhs - rhs) == 0)
      

In robotic applications, Python libraries such as python-control and roboticstoolbox-python build on these properties to model and simulate arm dynamics and closed-loop controllers. In later chapters, you will use them to construct and analyze full control loops.

10.2 C++: Numerical Convolution for a First-Order Joint

For a first-order system with impulse response \( g(t) = \frac{1}{\tau} e^{-t/\tau} u(t) \), the step response is \( y(t) = 1 - e^{-t/\tau} \). The code below approximates the convolution integral numerically, illustrating the convolution property used in LTI dynamics, as would appear in a real-time robotic controller.

#include <iostream>
#include <vector>
#include <cmath>

int main() {
    double dt = 0.001;
    int N = 5000;
    double tau = 0.2; // time constant

    std::vector<double> g(N), u(N), y(N, 0.0);

    // Impulse response and unit step input
    for (int k = 0; k < N; ++k) {
        double t = k * dt;
        g[k] = (t >= 0.0) ? (1.0 / tau) * std::exp(-t / tau) : 0.0;
        u[k] = (t >= 0.0) ? 1.0 : 0.0;
    }

    // Discrete-time convolution y[k] ~= sum_j g[j] * u[k-j] * dt
    for (int k = 0; k < N; ++k) {
        double sum = 0.0;
        for (int j = 0; j <= k; ++j) {
            sum += g[j] * u[k - j] * dt;
        }
        y[k] = sum;
    }

    // Print a few samples
    for (int k = 0; k < N; k += 500) {
        double t = k * dt;
        std::cout << "t=" << t
                  << "  y(t)~" << y[k]
                  << "  analytic=" << (1.0 - std::exp(-t / tau))
                  << std::endl;
    }
    return 0;
}
      

C++ control and robotics frameworks (e.g., ROS with ros_control, often using Eigen for linear algebra) implicitly rely on these convolution and derivative relationships in their continuous-time models, before discretization.

10.3 Java: Discrete Approximation of Convolution

Java-based robotic simulators and control stacks (often built on Apache Commons Math for numerics) can numerically approximate convolution to obtain responses to arbitrary inputs.

public class FirstOrderConvolution {
    public static void main(String[] args) {
        double dt = 0.001;
        int N = 5000;
        double tau = 0.2;

        double[] g = new double[N];
        double[] u = new double[N];
        double[] y = new double[N];

        for (int k = 0; k < N; ++k) {
            double t = k * dt;
            g[k] = (t >= 0.0) ? (1.0 / tau) * Math.exp(-t / tau) : 0.0;
            u[k] = (t >= 0.0) ? 1.0 : 0.0; // unit step
        }

        for (int k = 0; k < N; ++k) {
            double sum = 0.0;
            for (int j = 0; j <= k; ++j) {
                sum += g[j] * u[k - j] * dt;
            }
            y[k] = sum;
        }

        for (int k = 0; k < N; k += 500) {
            double t = k * dt;
            double analytic = 1.0 - Math.exp(-t / tau);
            System.out.printf("t=%.3f  y(t)~%.4f  analytic=%.4f%n", t, y[k], analytic);
        }
    }
}
      

This discrete convolution implements, in numerical form, the Laplace-domain relation \( Y(s) = G(s) U(s) \) for the corresponding continuous-time model.

10.4 MATLAB/Simulink: Symbolic Laplace and Block Modeling

MATLAB has built-in symbolic Laplace transforms. The code below verifies the derivative property for the same rotary joint model.

syms t s J b omega0 real positive

omega = omega0 * exp(-b/J * t);          % omega(t)
Omega = laplace(omega, t, s);           % Omega(s)
lhs   = laplace(diff(omega, t), t, s);  % L{d omega/dt}
rhs   = s * Omega - subs(omega, t, 0);  % s*Omega(s) - omega(0+)

disp('L{d omega/dt} - (s*Omega(s) - omega(0+)) =');
disp(simplify(lhs - rhs))              % should be 0
      

In Simulink, the same dynamics can be modeled directly as an ODE: blocks representing the sum \( J \frac{d\omega}{dt} + b \omega = u \), with integrator and gain blocks. The continuous-time behavior is governed by the same Laplace transform properties derived in this lesson. MATLAB's Robotics System Toolbox uses such LTI models internally for manipulator joint control and trajectory tracking.

10.5 Wolfram Mathematica: Laplace and Convolution

Mathematica has native support for Laplace transforms and convolution. The code below verifies the derivative and convolution properties symbolically.

(* First-order joint with speed omega(t) *)
Clear[t, s, J, b, omega0];
omega[t_] := omega0 * Exp[-b t / J];

Omega[s_] = LaplaceTransform[omega[t], t, s];

lhs = LaplaceTransform[D[omega[t], t], t, s];
rhs = s * Omega[s] - omega[0];

FullSimplify[lhs - rhs]

(* Convolution of impulse response g(t) with step input u(t) *)
Clear[t, tau, tauSym];

tauSym = Symbol["tau"];
g[t_] := (1/tau) * Exp[-t/tau] * UnitStep[t];
u[t_] := UnitStep[t];

yConv[t_] = Integrate[g[tauSym] * u[t - tauSym], {tauSym, 0, t},
                     Assumptions -> t >= 0 && tau > 0];

Y[s_] = LaplaceTransform[yConv[t], t, s] // FullSimplify
G[s_] = LaplaceTransform[g[t], t, s]     // FullSimplify
U[s_] = LaplaceTransform[u[t], t, s]     // FullSimplify

FullSimplify[Y[s] - G[s]*U[s]]
      

Mathematica is widely used for theoretical control analysis and symbolic manipulation of Laplace-domain expressions, particularly in research settings.

In this lesson we formalized the key Laplace transform properties that make linear control tractable:

• Linearity allows superposition and modular treatment of inputs.
• Time shifts model pure delays via factors \( e^{-sT} \).
• Exponential weighting shifts the Laplace variable from \( s \) to \( s - a \).
• Derivatives and integrals in time become polynomial factors and divisions by \( s \) in the transform domain.
• Convolution in time for LTI systems becomes multiplication \( Y(s) = G(s) U(s) \).
• Initial and final value theorems connect \( X(s) \) to \( x(0^+) \) and steady-state values.

These properties will be systematically used in subsequent chapters to move from physical differential equations to algebraic descriptions, and ultimately to design and analyze controllers for mechanical, electrical, and robotic systems.