A control-oriented model describes how an input signal \( u(t) \) (such as motor voltage or force) affects an output signal \( y(t) \) (such as position or velocity). In this course, we primarily study continuous-time single-input single-output (SISO) systems that can be represented by linear time-invariant (LTI) models.

At an abstract level, a (continuous-time) system is an operator \( \mathcal{S} \) that maps input functions to output functions:

\[ \mathcal{S} : \mathcal{U} \rightarrow \mathcal{Y}, \quad u(\cdot) \mapsto y(\cdot) = \mathcal{S}[u](\cdot), \]

where \( \mathcal{U} \) and \( \mathcal{Y} \) are sets of sufficiently smooth signals on \( \mathbb{R} \) (typically piecewise continuous and of at most exponential growth, in order to allow Laplace transforms in later chapters).

For physical control systems (including robot joints, end-effector axes, and actuators), the modeling workflow typically follows these steps:

flowchart TD
  P["Physical system (mechanical / electrical / robotic)"] --> IO["Define input u(t) and output y(t)"]
  IO --> M["Derive ODE from laws ('Newton', 'Kirchhoff')"]
  M --> L["Check linearity and constant parameters"]
  L --> A["Adopt LTI model or refine assumptions"]
        

In this lesson we clarify what it means for the mapping \( \mathcal{S} \) to be linear and time-invariant, and we show that many models obtained from basic physics are LTI after reasonable approximations.

2.1 Linearity

Let \( \mathcal{S} \) be a system operator as above. We say \( \mathcal{S} \) is linear if it satisfies the superposition principle:

\[ \mathcal{S}[\alpha u_1 + \beta u_2](t) = \alpha\,\mathcal{S}[u_1](t) + \beta\,\mathcal{S}[u_2](t), \quad \forall t \in \mathbb{R},\;\forall \alpha,\beta \in \mathbb{R}, \]

for all admissible inputs \( u_1, u_2 \). Linearity comprises:

• Homogeneity: \( \mathcal{S}[\alpha u](t) = \alpha \mathcal{S}[u](t) \).
• Additivity: \( \mathcal{S}[u_1 + u_2](t) = \mathcal{S}[u_1](t) + \mathcal{S}[u_2](t) \).

As a simple nonlinear example, consider the static input-output relation \( y(t) = (u(t))^2 \). Then, for \( \alpha = \beta = 1 \),

\[ \mathcal{S}[u_1 + u_2](t) = (u_1(t)+u_2(t))^2 = u_1(t)^2 + 2 u_1(t)u_2(t) + u_2(t)^2 \neq u_1(t)^2 + u_2(t)^2 = \\ \mathcal{S}[u_1](t) + \mathcal{S}[u_2](t), \]

so the system is not linear.

2.2 Time Invariance

Define the time-shift operator \( T_h \) acting on a signal \( u \) by

\[ (T_h u)(t) \triangleq u(t-h). \]

The system \( \mathcal{S} \) is time-invariant if, for every shift \( h \in \mathbb{R} \) and every input \( u \),

\[ \mathcal{S}[T_h u](t) = T_h \mathcal{S}[u](t) \quad \forall t \in \mathbb{R}. \]

In words: shifting the input in time by \( h \) results in the same output, shifted by \( h \). A system whose parameters explicitly depend on time (for instance, a resistance \( R(t) \) that changes with heating) generally fails this property and is called time-varying.

2.3 Linear Time-Invariant (LTI) Systems

A system that is both linear and time-invariant is called an LTI system. In control engineering, LTI models are fundamental because:

• They admit compact representations via differential equations and (later) transfer functions.
• Their responses to general inputs can be expressed via convolution with an impulse response.
• Stability and performance can be analyzed with powerful tools (root locus, frequency response), which we develop in later chapters.

A large class of physical systems relevant to control can be modeled (after suitable approximations) by an ordinary differential equation (ODE) of the form

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

where the coefficients \( a_k, b_k \) are real constants and \( a_n \neq 0 \). This covers, for example, mass-spring-damper systems, RLC circuits, and (after linearization) many single-joint robot axes.

3.1 Linearity of the ODE Model

We assume zero initial conditions: \( y(0) = y'(0) = \dots = y^{(n-1)}(0) = 0 \). Let \( u_1 \) and \( u_2 \) be two inputs with corresponding solutions \( y_1 = \mathcal{S}[u_1] \) and \( y_2 = \mathcal{S}[u_2] \) satisfying the ODE and the same initial conditions. Consider the input \( u = \alpha u_1 + \beta u_2 \), and define \( y = \alpha y_1 + \beta y_2 \).

Because differentiation is a linear operator, we have \( \frac{d^k}{dt^k}(\alpha y_1 + \beta y_2) = \alpha \frac{d^k y_1}{dt^k} + \beta \frac{d^k y_2}{dt^k} \) for every integer \( k \geq 0 \). Substituting into the ODE gives

\[ \begin{aligned} & a_n \frac{d^n y}{dt^n}(t) + \cdots + a_0 y(t) \\ &\quad = a_n \frac{d^n}{dt^n}(\alpha y_1 + \beta y_2)(t) + \cdots + a_0 (\alpha y_1(t) + \beta y_2(t)) \\ &\quad = \alpha\left(a_n \frac{d^n y_1}{dt^n}(t) + \cdots + a_0 y_1(t)\right) + \beta\left(a_n \frac{d^n y_2}{dt^n}(t) + \cdots + a_0 y_2(t)\right) \\ &\quad = \alpha\left(b_m \frac{d^m u_1}{dt^m}(t) + \cdots + b_0 u_1(t)\right) + \beta\left(b_m \frac{d^m u_2}{dt^m}(t) + \cdots + b_0 u_2(t)\right) \\ &\quad = b_m \frac{d^m}{dt^m}(\alpha u_1 + \beta u_2)(t) + \cdots + b_0 (\alpha u_1(t) + \beta u_2(t)) \\ &\quad = b_m \frac{d^m u}{dt^m}(t) + \cdots + b_0 u(t). \end{aligned} \]

The initial conditions are also linear: \( y(0) = \alpha y_1(0) + \beta y_2(0) = 0 \), etc. By uniqueness of solutions of linear ODEs, \( y \) is exactly the output corresponding to input \( u \), so \( \mathcal{S}[\alpha u_1 + \beta u_2] = \alpha \mathcal{S}[u_1] + \beta \mathcal{S}[u_2] \). Hence the system is linear.

3.2 Time Invariance of the ODE Model

Assume again zero initial conditions at time \( t = 0 \) and constant coefficients \( a_k, b_k \). Let \( u \) be an input with output \( y \), and consider the shifted input \( u_h(t) = u(t-h) \) with \( h > 0 \). Define \( y_h(t) = y(t-h) \).

Using the chain rule, \( \frac{d^k y_h}{dt^k}(t) = \frac{d^k y}{dt^k}(t-h) \). Substituting into the ODE evaluated at \( t-h \) yields

\[ a_n \frac{d^n y_h}{dt^n}(t) + \cdots + a_0 y_h(t) = b_m \frac{d^m u_h}{dt^m}(t) + \cdots + b_0 u_h(t). \]

Since the coefficients do not depend on \( t \), the same ODE holds for the shifted signals. With zero initial conditions at the new origin \( t = h \), the uniqueness argument shows that the output corresponding to \( u_h \) is exactly \( y_h \). Therefore,

\[ \mathcal{S}[u_h](t) = y_h(t) = y(t-h) = \mathcal{S}[u](t-h), \]

which is the time-invariance property.

Conclusion: any system described by a linear constant-coefficient ODE with fixed initial conditions defines an LTI input-output operator.

Many control and robotics problems benefit from a state-space description. We introduce it here at a basic level, and in later chapters we will connect it to transfer functions and stability analysis.

An LTI system in state-space form is given by

\[ \dot{x}(t) = A x(t) + B u(t), \quad y(t) = C x(t) + D u(t), \]

where

• \( x(t) \in \mathbb{R}^n \) is the state vector, collecting internal variables (e.g., positions and velocities of robot links).
• \( u(t) \in \mathbb{R} \) (SISO) is the input, such as torque or voltage.
• \( y(t) \in \mathbb{R} \) is the measured output.
• \( A \in \mathbb{R}^{n \times n}, B \in \mathbb{R}^{n \times 1}, C \in \mathbb{R}^{1 \times n}, D \in \mathbb{R}^{1 \times 1} \) are constant matrices.

Linearity and time invariance follow from the same argument as in Section 3: the right-hand sides are linear in \( x \) and \( u \), and the matrices \( A,B,C,D \) are constant in time.

For example, a mass-spring-damper system modeling a single translational axis of a robot (with mass \( m \), damping \( b \), stiffness \( k \), input force \( u(t) \), and output position \( q(t) \)) satisfies

\[ m \ddot{q}(t) + b \dot{q}(t) + k q(t) = u(t). \]

Defining the state as \( x_1(t) = q(t) \), \( x_2(t) = \dot{q}(t) \), we obtain

\[ \dot{x}_1(t) = x_2(t), \quad \dot{x}_2(t) = -\frac{k}{m} x_1(t) - \frac{b}{m} x_2(t) + \frac{1}{m} u(t), \]

and in matrix form

\[ A = \begin{bmatrix} 0 & 1 \\ -\frac{k}{m} & -\frac{b}{m} \end{bmatrix}, \quad B = \begin{bmatrix} 0 \\ \frac{1}{m} \end{bmatrix}, \quad C = \begin{bmatrix} 1 & 0 \end{bmatrix}, \quad D = \begin{bmatrix} 0 \end{bmatrix}. \]

This state-space model is LTI and serves as a building block for more sophisticated robot joint and actuator models.

5.1 Causality

A system is causal if its output at time \( t \) depends only on past and present input values, not on the future:

\[ \mathcal{S}[u](t) \text{ depends only on } u(\sigma) \text{ for } \sigma \leq t. \]

Physical control systems are causal. ODE models of the form in Section 3 with specified initial conditions are causal because the solution at time \( t \) can be computed from initial data and the input history up to time \( t \).

5.2 Impulse Response and Convolution Representation

For a causal LTI system with zero initial conditions, the response to any input \( u(t) \) can be expressed as a convolution with a kernel \( g(t) \), called the impulse response:

\[ y(t) = \int_0^t g(t-\sigma)\,u(\sigma)\,d\sigma = (g * u)(t), \quad t \geq 0. \]

Informally, \( g(t) \) is the output corresponding to a unit impulse at the input at time \( 0 \). By linearity, a general input is decomposed into a continuum of shifted, scaled impulses, and by time invariance and superposition, the output is the integral of the shifted impulse responses.

This convolution structure is the time-domain counterpart of the multiplication of transfer functions in the Laplace domain, which we will explore in Chapter 4.

Real physical systems are rarely exactly LTI. Control engineers adopt LTI models under explicit assumptions. Making these assumptions clear is crucial, especially when modeling robotic systems where friction, flexibility, and saturation are present.

6.1 Typical Assumptions

1. Linearity of constitutive laws. Mechanical: forces proportional to displacement and velocity (\( F_s = k q \), \( F_d = b \dot{q} \)). Electrical: \( v_R = R i \), \( v_L = L \dot{i} \), \( i_C = C \dot{v} \).
2. Small-signal operation. Motions occur around an operating point where nonlinear effects (e.g., Coulomb friction, geometric nonlinearities) are small. Formally, a nonlinear model \( \dot{x} = f(x,u) \) is approximated locally by its first-order Taylor expansion; the detailed procedure is deferred to Lesson 5 of this chapter.
3. Time-invariant parameters. Masses, inertias, resistances, and other parameters are treated as constants over the time horizon of interest. Slow drifts (e.g., heating) are neglected.
4. Lumped-parameter approximation. Spatially distributed phenomena (flexible beams, transmission lines) are approximated by a finite number of degrees of freedom, yielding finite-dimensional ODEs rather than partial differential equations.
5. Single operating mode. Discontinuities due to impacts, backlash, or switching networks are ignored or handled separately; the LTI model describes a single continuous mode.
6. Noise and disturbances treated separately. Stochastic effects are not part of the nominal deterministic LTI model; they are modeled later as additive disturbances at the input or output.

6.2 Classification of Models

With these assumptions, we can conceptually classify our models as follows:

flowchart TD
  S["Physical system"] --> L["Can we adopt linear approximation?"]
  L -->|"yes"| TI["Are parameters approximately \nconstant in time?"]
  L -->|"no"| NL["Nonlinear model \n(treated outside basic LTI theory)"]
  TI -->|"yes"| LTI["Use LTI model \n(this course)"]
  TI -->|"no"| LTV["Linear time-varying model \n(advanced topic)"]
        

This course focuses on the LTI branch. Nonlinear and time-varying models are important, especially for advanced robotics, but require more sophisticated tools introduced in later courses.

In Python, LTI systems are often represented using scipy.signal or the python-control library. For robotics, the roboticstoolbox-python package provides rigid-body models whose dynamics can be linearized and approximated as LTI around a configuration.

The following example models the mass-spring-damper axis from Section 4 in state-space form using python-control and simulates its step response (force step).

import numpy as np
import control  # pip install control

# Physical parameters (e.g., a small robot axis)
m = 1.0    # kg
b = 0.4    # N·s/m
k = 2.0    # N/m

# State-space matrices for q and q_dot
A = np.array([[0.0,      1.0],
              [-k/m, -b/m]])
B = np.array([[0.0],
              [1.0/m]])
C = np.array([[1.0, 0.0]])  # measure position
D = np.array([[0.0]])

sys = control.ss(A, B, C, D)

# Time vector and step input
T = np.linspace(0.0, 10.0, 2000)
u = np.ones_like(T)  # unit step force

T, y, x = control.forced_response(sys, T, u)

print("Final position approx:", y[-1])

# Robotics context (symbolic, not simulated here):
# Use roboticstoolbox-python to build a 1-DOF revolute joint and obtain its dynamics.
# import roboticstoolbox as rtb
# link = rtb.RevoluteDH(a=0.5, d=0.0, alpha=0.0, m=m)
# robot = rtb.DHRobot([link])
# robot.dynamics()  # returns symbolic M(q), C(q, q_dot), g(q), etc.
# Around a fixed configuration, these dynamics can be approximated by an LTI model.
      

Here, the Python code mirrors the abstract LTI model \( \dot{x}(t) = A x(t) + B u(t) \), \( y(t) = C x(t) + D u(t) \). In robotics, the same structure appears for each joint when we linearize the full robot dynamics near a reference trajectory.

In C++, matrix computations for LTI systems are commonly handled by the Eigen library. Within robotics, the ROS and ROS 2 ecosystems (ros_control / ros2_control) embed simple LTI models as joint-level plant models or observer models.

The snippet below computes a forward Euler simulation of the same second-order LTI system (mass-spring-damper) using Eigen. The state \( x = [q,\;\dot{q}]^\top \) is advanced in discrete time.

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

int main() {
    // Physical parameters
    const double m = 1.0;
    const double b = 0.4;
    const double k = 2.0;

    // Continuous-time matrices
    Eigen::Matrix2d A;
    A << 0.0,      1.0,
          -k/m, -b/m;

    Eigen::Vector2d B;
    B << 0.0,
          1.0/m;

    Eigen::Vector2d x;  // state [q; q_dot]
    x << 0.0, 0.0;

    const double u = 1.0;   // constant input (step force)
    const double dt = 0.001;
    const int steps = 10000;

    for (int i = 0; i < steps; ++i) {
        Eigen::Vector2d xdot = A * x + B * u;
        x += dt * xdot;  // Euler integration
    }

    std::cout << "Final position approx: " << x(0) << std::endl;

    // In a ROS(2) robotic joint controller, one would embed this model in a real-time loop
    // and update x using measured torques and velocities, using ros_control or ros2_control.
    return 0;
}
      

This C++ model directly implements the continuous-time LTI equations in discrete form. In later chapters, we will be more explicit about discretization and digital control; for now, the focus is on the continuous-time LTI description.

Java is used in several robotics and automation frameworks (for example, WPILib for mobile robots). Matrix and ODE utilities are available in libraries such as Apache Commons Math and EJML. Below we show a minimal pure-Java Euler simulation of the same LTI system without any external library.

public class LTIMassSpring {
    public static void main(String[] args) {
        double m = 1.0;
        double b = 0.4;
        double k = 2.0;

        double[] x = {0.0, 0.0}; // x[0] = q, x[1] = q_dot
        double dt = 0.001;
        int steps = 10000;

        for (int i = 0; i < steps; i++) {
            double u = 1.0; // constant force

            double x1dot = x[1];
            double x2dot = -(k / m) * x[0] - (b / m) * x[1] + (1.0 / m) * u;

            x[0] += dt * x1dot;
            x[1] += dt * x2dot;
        }

        System.out.println("Final position approx: " + x[0]);
    }
}
      

In a robotics context, such a class could be embedded in a high-level simulation environment or connected to sensor/actuator interfaces, while maintaining the LTI structure for analysis and controller design.

MATLAB provides native support for LTI modeling via the Control System Toolbox (functions ss, tf, etc.). Simulink offers block-diagram simulation of the same models. For robotics, the Robotics System Toolbox introduces rigid-body models that can be linearized around trajectories.

% Mass-spring-damper LTI model
m = 1.0;
b = 0.4;
k = 2.0;

A = [0 1;
    -k/m -b/m];
B = [0;
     1/m];
C = [1 0];
D = 0;

sys = ss(A, B, C, D);   % state-space LTI system

% Step response (force step)
figure;
step(sys);
title('Mass-spring-damper step response');

% Robotics context (conceptual):
% robot = importrobot('exampleRobot.urdf');
% linSys = linearize(robot, operatingPoint); % approximate LTI model around a pose
      

In Simulink, the same system can be assembled from Integrator, Gain, and Sum blocks corresponding to the ODE. This block diagram is equivalent to the mathematical LTI model of Sections 3 and 4.

Wolfram Mathematica has built-in functions for state-space and transfer-function representations, as well as symbolic manipulation of ODEs. This makes it convenient for deriving and simplifying models of robotic systems before exporting numeric parameters.

(* Mass-spring-damper parameters *)
m = 1.0; b = 0.4; k = 2.0;

A = { {0, 1}, {-k/m, -b/m} };
B = { {0}, {1/m} };
C = { {1, 0} };
D = { {0} };

sys = StateSpaceModel[{A, B, C, D}];

(* Step response from t = 0 to 10 *)
resp = OutputResponse[sys, UnitStep[t], {t, 0, 10}];
ResponsePlot[resp, {t, 0, 10},
  PlotLabel -> "Mass-spring-damper step response"];

(* Symbolic transfer function *)
s = ComplexExpand[I*omega]; (* symbol for Laplace variable is usually s *)
tf = TransferFunctionModel[sys, s];
      

Symbolic tools like StateSpaceModel and TransferFunctionModel help verify the equivalence between ODE, state-space, and (later) transfer-function descriptions of LTI systems.

In this lesson we formalized the notion of an LTI system as a linear, time-invariant, causal operator mapping input signals to output signals. We showed that linear constant-coefficient ODEs and their state-space realizations naturally define LTI systems under zero initial conditions. We highlighted the convolution representation of LTI systems and clarified the modeling assumptions that justify LTI approximations for physical plants, including robotic joints and actuators. Finally, we demonstrated how the same mathematical structure can be encoded in Python, C++, Java, MATLAB/Simulink, and Wolfram Mathematica, laying the computational foundation for subsequent chapters on transfer functions, time response, and stability.