In this course we mostly consider single-input single-output (SISO) continuous-time systems. Mathematically, a system is modeled as an operator \( \mathcal{S} \) mapping an input signal to an output signal:

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

where \( \mathcal{U} \) is a set of admissible input signals (e.g. piecewise-continuous functions \( u:\mathbb{R} \rightarrow \mathbb{R} \)) and \( \mathcal{Y} \) is the corresponding set of output signals.

Many physical systems can be described by ordinary differential equations relating the input \( u(t) \), the output \( y(t) \), and their derivatives:

\[ F\bigl(t,y(t),\dot y(t),\dots,y^{(n)}(t),u(t),\dot u(t),\dots,u^{(m)}(t)\bigr) = 0. \]

How coefficients appear in this equation will determine whether the system is linear or nonlinear, and whether it is time-invariant or time-varying.

flowchart TD
  U["Input signal u(t)"] --> S["Physical system or mathematical model"]
  S --> Y["Output signal y(t)"]

  S --> C1["Check linearity (superposition)"]
  S --> C2["Check time invariance \n(shift property)"]
  C1 --> CL["Class: linear vs nonlinear"]
  C2 --> CT["Class: time invariant \nvs time varying"]
        

The central property of a linear system is the superposition principle. Let \( \mathcal{S} \) be a system operator. Denote by \( y_1(t) = \mathcal{S}[u_1](t) \) and \( y_2(t) = \mathcal{S}[u_2](t) \) the outputs corresponding to inputs \( u_1 \) and \( u_2 \). Then \( \mathcal{S} \) is linear if and only if

\[ \mathcal{S}[\alpha u_1 + \beta u_2](t) = \alpha\,\mathcal{S}[u_1](t) + \beta\,\mathcal{S}[u_2](t) \quad \text{for all } \alpha,\beta \in \mathbb{R},\; u_1,u_2 \in \mathcal{U}. \]

This is the superposition property. It is equivalent to the combination of:

• Additivity: \( \mathcal{S}[u_1 + u_2] = \mathcal{S}[u_1] + \mathcal{S}[u_2] \).
• Homogeneity (scaling): \( \mathcal{S}[\alpha u] = \alpha\,\mathcal{S}[u] \) for all scalars \( \alpha \).

Proposition. Additivity and homogeneity together are equivalent to full superposition.

Proof.

• (Superposition → additivity + homogeneity): take \( \alpha = \beta = 1 \) to get additivity; take \( \beta = 0 \), \( u_2 = 0 \) to get homogeneity.
• (Additivity + homogeneity → superposition): For any \( \alpha,\beta \) and \( u_1,u_2 \),

  \[ \begin{aligned} \mathcal{S}[\alpha u_1 + \beta u_2] &= \mathcal{S}[\alpha u_1] + \mathcal{S}[\beta u_2] &&\text{(additivity)} \\ &= \alpha\,\mathcal{S}[u_1] + \beta\,\mathcal{S}[u_2] &&\text{(homogeneity),} \end{aligned} \]

  which is superposition.

An important consequence is the zero-input property: for a linear system \( \mathcal{S}[0] = 0 \). Indeed, taking \( \alpha = 0 \) in homogeneity yields \( \mathcal{S}[0] = 0 \cdot \mathcal{S}[u] = 0 \).

Time invariance formalizes the idea that system behavior does not depend on the absolute origin of time. Define the time-shift operator \( \mathcal{T}_\tau \) by

\[ (\mathcal{T}_\tau u)(t) := u(t - \tau), \quad \tau \in \mathbb{R}. \]

A system \( \mathcal{S} \) is time invariant if for all admissible inputs \( u \) and all real shifts \( \tau \),

\[ \mathcal{S}[\mathcal{T}_\tau u] = \mathcal{T}_\tau \mathcal{S}[u]. \]

Concretely, if \( y(t) = \mathcal{S}[u](t) \), then the response to the shifted input \( u(t - \tau) \) is \( y(t - \tau) \). The system does not change when we slide the input in time; its behavior is the same shape, just shifted.

If this property does not hold, the system is time varying.

flowchart TD
  U1["Input u(t)"] --> S1["System S"]
  S1 --> Y1["Output y(t)"]

  U2["Shifted input (T_tau u)(t) = u(t - tau)"] --> S2["System S"]
  S2 --> Y2["Output y_tau(t)"]

  Y1 --> CMP["Time invariance test: is y_tau(t) = y(t - tau)?"]
        

For many control systems we postulate a relationship between \( y(t) \), \( u(t) \), and their derivatives in the form of an \( n \)-th order ODE:

\[ a_n(t) y^{(n)}(t) + a_{n-1}(t) y^{(n-1)}(t) + \dots + a_1(t) \dot y(t) + a_0(t) y(t) = \\ b_m(t) u^{(m)}(t) + \dots + b_1(t) \dot u(t) + b_0(t) u(t). \]

This equation is linear in \( y \) and \( u \) because the unknown functions and their derivatives appear only multiplied by scalar coefficient functions \( a_i(t), b_j(t) \) and are never multiplied together or passed through nonlinearities.

We distinguish two important subclasses:

• Linear time-varying (LTV): coefficient functions \( a_i(t), b_j(t) \) explicitly depend on \( t \).
• Linear time-invariant (LTI): coefficients are constants \( a_i(t) = a_i, b_j(t) = b_j \).

Formally, an LTI system is described by

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

with constant coefficients \( a_i, b_j \). This equation is both linear and time invariant.

By contrast, a nonlinear system may contain terms such as \( y^2(t) \), \( \sin(y(t)) \), \( y(t) u(t) \), or \( u^3(t) \), e.g.

\[ \dot y(t) = -y^3(t) + u(t). \]

Here the superposition property fails.

Example 1 (Static gain). Let

\[ y(t) = k\,u(t), \quad k \in \mathbb{R}. \]

For any \( \alpha,\beta \), \( u_1,u_2 \),

\[ \mathcal{S}[\alpha u_1 + \beta u_2](t) = k\bigl(\alpha u_1(t) + \beta u_2(t)\bigr) = \alpha k u_1(t) + \beta k u_2(t) = \alpha \mathcal{S}[u_1](t) + \beta \mathcal{S}[u_2](t), \]

so the system is linear. It is time invariant because replacing \( u(t) \) by \( u(t-\tau) \) simply shifts \( y(t) \) by \( \tau \).

Thus, this is a linear time-invariant (LTI) system.

Example 2 (Offset). Consider

\[ y(t) = k\,u(t) + c. \]

Take \( u_1(t) = 0 \), then \( \mathcal{S}[u_1](t) = c \neq 0 \) (if \( c \neq 0 \)). But for a linear system we must have \( \mathcal{S}[0] = 0 \). Thus this system is nonlinear. It is, however, time invariant: shifting \( u(t) \) by \( \tau \) just shifts \( k u(t) \) while the constant \( c \) remains unchanged.

Example 3 (Squaring nonlinearity). Let

\[ y(t) = u^2(t). \]

For \( u_1(t) \) and scalar \( \alpha \), \( \mathcal{S}[\alpha u_1](t) = (\alpha u_1(t))^2 = \alpha^2 u_1^2(t) \), which is not equal to \( \alpha \mathcal{S}[u_1](t) = \alpha u_1^2(t) \) unless \( \alpha = 0 \) or \( \alpha = 1 \). Homogeneity fails, so the system is nonlinear. It is time invariant because time shifting the input simply time shifts the square.

Example 4 (Time-dependent gain). Let

\[ y(t) = t\,u(t). \]

Linearity: for any \( \alpha,\beta,u_1,u_2 \),

\[ \mathcal{S}[\alpha u_1 + \beta u_2](t) = t\bigl(\alpha u_1(t) + \beta u_2(t)\bigr) = \alpha t u_1(t) + \beta t u_2(t) = \alpha \mathcal{S}[u_1](t) + \beta \mathcal{S}[u_2](t), \]

so the system is linear. Now check time invariance:

\[ \mathcal{S}[\mathcal{T}_\tau u](t) = t\,u(t-\tau), \qquad \mathcal{T}_\tau \mathcal{S}[u](t) = \mathcal{S}[u](t-\tau) = (t-\tau)u(t-\tau). \]

These differ unless \( \tau = 0 \). Hence the system is linear but time varying (LTV).

These simple examples already demonstrate that the four classes (linear/nonlinear) × (time-invariant/time-varying) are all possible.

Real robotic systems (manipulators, mobile robots, drones) are governed by nonlinear, time-varying dynamics (e.g. friction, saturations, changing loads). However, many classical control design tools that we will study in this course (transfer functions, root locus, frequency response) apply directly to LTI models.

Typical workflow (informally at this stage):

• Derive a physics-based nonlinear model (from mechanics, electromagnetics).
• Approximate it locally by a linear, often LTI, model for small deviations.
• Design a controller using LTI theory, then validate on the original nonlinear system.

For example, a DC motor joint in a robot arm is often approximated by a first-order LTI ODE

\[ J \dot \omega(t) + B \omega(t) = K_t i(t), \qquad u(t) = i(t), \]

where \( \omega(t) \) is angular velocity, \( i(t) \) the armature current, and \( J,B,K_t \) are constant parameters. This is linear and time invariant and will in later chapters be represented by a transfer function.

In practice, robotics software frameworks and libraries assume or exploit linear models:

• Python: python-control, scipy.integrate, roboticstoolbox-python for modeling and simulating linearized joint dynamics.
• C++: Eigen for matrix computations, ros_control and controllers in ROS-based robotic systems for LTI joint controllers.
• Java: WPILib (for educational robots) includes linear system utilities, and generic math libraries (e.g. Apache Commons Math) are used for LTI simulations.
• MATLAB/Simulink: Control System Toolbox and Robotics System Toolbox are built around LTI representations and simulation blocks.
• Wolfram Mathematica: functions like StateSpaceModel and TransferFunctionModel support symbolic and numeric work with linear systems.

We now implement simple numerical tests of linearity and time invariance for three toy systems:

• S1: \( y(t) = k u(t) \) (LTI).
• S2: \( y(t) = t u(t) \) (linear, time varying).
• S3: \( y(t) = u^2(t) \) (nonlinear, time invariant).

import numpy as np

# Discrete-time grid for testing
t = np.linspace(0.0, 5.0, 501)
dt = t[1] - t[0]

# Define some test inputs
def u1(t):
    # Unit step
    return (t >= 0.0).astype(float)

def u2(t):
    # Ramp
    return t

def u_shifted(t, tau):
    return u1(t - tau)

# System definitions (vectorized in t)
def S1(u):
    k = 2.0
    return k * u

def S2(u, t):
    return t * u

def S3(u):
    return u**2

def check_linearity(S, t, use_t=False):
    alpha, beta = 1.5, -0.7
    u1_vec = u1(t)
    u2_vec = u2(t)
    u_combo = alpha * u1_vec + beta * u2_vec

    if use_t:
        y_combo = S(u_combo, t)
        y_lin = alpha * S(u1_vec, t) + beta * S(u2_vec, t)
    else:
        y_combo = S(u_combo)
        y_lin = alpha * S(u1_vec) + beta * S(u2_vec)

    err = np.linalg.norm(y_combo - y_lin, ord=2)
    return err

def check_time_invariance(S, t, tau=0.5, use_t=False):
    u_orig = u1(t)
    u_tau = u_shifted(t, tau)

    if use_t:
        y_from_shifted = S(u_tau, t)
        y_orig = S(u_orig, t)
    else:
        y_from_shifted = S(u_tau)
        y_orig = S(u_orig)

    # Shift the original output numerically by tau
    y_orig_shifted = np.interp(t, t + tau, y_orig, left=0.0, right=y_orig[-1])

    err = np.linalg.norm(y_from_shifted - y_orig_shifted, ord=2)
    return err

print("S1 linearity error:", check_linearity(S1, t))
print("S1 time invariance error:", check_time_invariance(S1, t))

print("S2 linearity error:", check_linearity(lambda u: S2(u, t), t, use_t=False))
print("S2 time invariance error:", check_time_invariance(lambda u: S2(u, t), t))

print("S3 linearity error:", check_linearity(S3, t))
print("S3 time invariance error:", check_time_invariance(S3, t))
      

The errors for a truly linear (or time-invariant) system are limited only by numerical interpolation and floating-point effects; for nonlinear or time-varying systems they are significantly larger. This simple test structure underlies many automated model-checking routines in robotics simulation toolchains (e.g., verifying linear approximations in python-control or roboticstoolbox).

In C++, we typically use Eigen to represent vectors and matrices of sampled signals. Below we implement a linearity check for a simple LTI joint torque model \( \tau(t) = k u(t) \) sampled at discrete times. The same pattern appears inside ROS-based controllers within ros_control.

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

using Eigen::VectorXd;

// Discrete-time input generators
VectorXd step_input(const VectorXd& t) {
    VectorXd u(t.size());
    for (int i = 0; i < t.size(); ++i) {
        u(i) = (t(i) >= 0.0) ? 1.0 : 0.0;
    }
    return u;
}

VectorXd ramp_input(const VectorXd& t) {
    VectorXd u(t.size());
    for (int i = 0; i < t.size(); ++i) {
        u(i) = t(i);
    }
    return u;
}

// LTI gain system: y = k * u
VectorXd S_gain(const VectorXd& u, double k = 3.0) {
    return k * u;
}

// LTV gain system: y = t * u
VectorXd S_time_varying(const VectorXd& u, const VectorXd& t) {
    VectorXd y(t.size());
    for (int i = 0; i < t.size(); ++i) {
        y(i) = t(i) * u(i);
    }
    return y;
}

double linearity_error_gain(const VectorXd& t) {
    double alpha = 1.2, beta = -0.8;
    VectorXd u1 = step_input(t);
    VectorXd u2 = ramp_input(t);
    VectorXd u_combo = alpha * u1 + beta * u2;

    VectorXd y_combo = S_gain(u_combo);
    VectorXd y_lin = alpha * S_gain(u1) + beta * S_gain(u2);

    return (y_combo - y_lin).norm();
}

int main() {
    int N = 501;
    VectorXd t(N);
    double t0 = 0.0, tf = 5.0;
    double dt = (tf - t0) / (N - 1);
    for (int i = 0; i < N; ++i) {
        t(i) = t0 + i * dt;
    }

    double err_gain = linearity_error_gain(t);
    std::cout << "Linearity error (LTI gain): " << err_gain << std::endl;

    // For robotics: this pattern would be embedded in a controller update loop
    // with u as actuator commands and y as torque or velocity.
    return 0;
}
      

In ROS-based robotic controllers, similar checks can be performed offline using logged input-output data to validate that an assumed LTI model is adequate over an operating region.

Java is often used in educational robotics platforms (e.g., FRC). The following code snippet shows how to numerically test superposition for a discrete-time system implemented as a functional interface.

import java.util.function.BiFunction;

public class LinearityTest {

    // System interface: y[i] = S(u[i], t[i])
    @FunctionalInterface
    public interface DiscreteSystem {
        double[] apply(double[] u, double[] t);
    }

    public static double[] stepInput(double[] t) {
        double[] u = new double[t.length];
        for (int i = 0; i < t.length; i++) {
            u[i] = (t[i] >= 0.0) ? 1.0 : 0.0;
        }
        return u;
    }

    public static double[] rampInput(double[] t) {
        double[] u = new double[t.length];
        for (int i = 0; i < t.length; i++) {
            u[i] = t[i];
        }
        return u;
    }

    public static double linearityError(DiscreteSystem S, double[] t) {
        double alpha = 1.5;
        double beta = -0.4;

        double[] u1 = stepInput(t);
        double[] u2 = rampInput(t);
        double[] uCombo = new double[t.length];

        for (int i = 0; i < t.length; i++) {
            uCombo[i] = alpha * u1[i] + beta * u2[i];
        }

        double[] yCombo = S.apply(uCombo, t);
        double[] yLin1 = S.apply(u1, t);
        double[] yLin2 = S.apply(u2, t);

        double err2 = 0.0;
        for (int i = 0; i < t.length; i++) {
            double yLin = alpha * yLin1[i] + beta * yLin2[i];
            double diff = yCombo[i] - yLin;
            err2 += diff * diff;
        }
        return Math.sqrt(err2);
    }

    public static void main(String[] args) {
        int N = 501;
        double[] t = new double[N];
        double t0 = 0.0;
        double tf = 5.0;
        double dt = (tf - t0) / (N - 1);
        for (int i = 0; i < N; i++) {
            t[i] = t0 + i * dt;
        }

        // LTI gain system
        DiscreteSystem S1 = (u, time) -> {
            double k = 2.0;
            double[] y = new double[u.length];
            for (int i = 0; i < u.length; i++) {
                y[i] = k * u[i];
            }
            return y;
        };

        // Nonlinear squaring system
        DiscreteSystem S3 = (u, time) -> {
            double[] y = new double[u.length];
            for (int i = 0; i < u.length; i++) {
                y[i] = u[i] * u[i];
            }
            return y;
        };

        System.out.println("S1 linearity error = " + linearityError(S1, t));
        System.out.println("S3 linearity error = " + linearityError(S3, t));
    }
}
      

In robotics libraries such as WPILib, internal plant models for mechanisms (e.g., flywheels, arms) are often assumed LTI; tests such as the above can help verify this assumption from measured data.

MATLAB and Simulink are standard tools in control and robotics. The following script compares an LTI and an LTV first-order system for the same step input:

% Time vector
t = linspace(0, 10, 1001);
u = ones(size(t));  % unit step

% LTI system: dy/dt + y = u
f_lti = @(t, y, u_val) (-y + u_val);

% LTV system: dy/dt + (1 + 0.5*t)*y = u
f_ltv = @(t, y, u_val) (-(1 + 0.5*t)*y + u_val);

% Simple forward Euler simulation
dt = t(2) - t(1);
y_lti = zeros(size(t));
y_ltv = zeros(size(t));

for k = 1:length(t)-1
    y_lti(k+1) = y_lti(k) + dt * f_lti(t(k), y_lti(k), u(k));
    y_ltv(k+1) = y_ltv(k) + dt * f_ltv(t(k), y_ltv(k), u(k));
end

figure;
plot(t, y_lti, 'LineWidth', 1.5); hold on;
plot(t, y_ltv, '--', 'LineWidth', 1.5);
xlabel('t [s]');
ylabel('y(t)');
legend('LTI', 'LTV');
grid on;
title('Response of LTI vs LTV first-order systems');

% In Simulink, one would construct equivalent diagrams using Integrator blocks
% and Gain blocks where the LTV coefficient is implemented as a time-varying block.
      

In Simulink, LTI systems are represented with constant gains and fixed transfer function blocks. LTV systems require blocks whose parameters depend on time signals. This distinction is central when building realistic robot models with the Robotics System Toolbox.

Wolfram Mathematica can treat signals symbolically. We can express the superposition property directly at the symbolic level for generic input signals:

(* Define symbolic input signals *)
Clear[u1, u2, t, alpha, beta];
u1[t_] := u1[t];
u2[t_] := u2[t];

(* Define systems *)
S1[u_][t_] := 3 u[t];           (* LTI gain *)
S2[u_][t_] := t u[t];           (* Linear time-varying *)
S3[u_][t_] := u[t]^2;           (* Nonlinear *)

(* Superposition test for S1 *)
lhs1 = S1[alpha u1 + beta u2][t];
rhs1 = alpha S1[u1][t] + beta S1[u2][t];
FullSimplify[lhs1 - rhs1]

(* Superposition test for S3 *)
lhs3 = S3[alpha u1 + beta u2][t];
rhs3 = alpha S3[u1][t] + beta S3[u2][t];
FullSimplify[lhs3 - rhs3]

(* Time invariance test for S2 *)
tau = Symbol["tau"];
Ttau[u_][t_] := u[t - tau];

lhs_ti = S2[Ttau[u1]][t];
rhs_ti = Ttau[S2[u1]][t];
FullSimplify[lhs_ti - rhs_ti]
      

The symbolic differences show that S1 satisfies superposition, S3 does not, and S2 violates time invariance. Such symbolic manipulations are useful when deriving general properties of classes of systems before committing to particular numerical parameter values.

In this lesson we formalized the notions of linear and time-invariant systems using operator theory on signal spaces. We showed that linearity is equivalent to the superposition of responses and that time invariance can be expressed via commutation with the time-shift operator. We connected these properties to the structure of ordinary differential equations and classified several example systems, including simple models relevant to actuators in robotics.

We also implemented numerical and symbolic tests of these properties in Python, C++, Java, MATLAB/Simulink, and Wolfram Mathematica, highlighting common software libraries used in control and robotics modeling. The key takeaway is that LTI systems form the central class for the rest of this course; later chapters will build analysis and design tools that rely on these definitions.