In System Dynamics, an input–output description treats a system as a transformation that maps an input signal to an output signal. In this lesson, we restrict attention to \( \text{linear} \) and \( \text{time-invariant} \) systems, because they admit a complete characterization in the time domain by a single function: the \( \text{impulse response} \).

After completing this lesson, you will be able to:

• State and apply the operator definitions of \( \text{linearity} \) and \( \text{time invariance} \).
• Define the unit impulse \( \delta(t) \) and use its sampling (sifting) property.
• Prove that an LTI system output is given by \( y(t)=(x*h)(t) \).
• Use algebraic identities of convolution (commutativity, associativity, distributivity) and compute common examples.
• Implement convolution numerically in Python, C++, Java, MATLAB/Simulink, and Wolfram Mathematica.

flowchart TD
  A["Input x(t)"] --> B["Write x(t) as weighted shifted impulses"]
  B --> C["Impulse response h(t) = output to a unit impulse"]
  C --> D["Shift + scale h(t), then add (superposition)"]
  D --> E["Output y(t) = x(t) * h(t)"]
        

We model a system as an operator \( \mathcal{T} \) mapping an input function \( x(t) \) to an output function \( y(t) \): \( y(t)=\mathcal{T}\{x(t)\} \).

Definition (Linearity). The operator \( \mathcal{T} \) is linear if for all signals \( x_1(t), x_2(t) \) and scalars \( a,b \in \mathbb{R} \),

\[ \mathcal{T}\{a x_1(t) + b x_2(t)\} = a\,\mathcal{T}\{x_1(t)\} + b\,\mathcal{T}\{x_2(t)\}. \]

Definition (Time invariance). The operator \( \mathcal{T} \) is time-invariant if whenever \( y(t)=\mathcal{T}\{x(t)\} \), then for any shift \( t_0 \in \mathbb{R} \),

\[ \mathcal{T}\{x(t-t_0)\} = y(t-t_0). \]

We call a system LTI if it satisfies both properties. Linearity enables superposition; time invariance ensures that the same input pattern produces the same output pattern regardless of when it occurs.

In physical systems, the simplest form of input–output analysis often assumes the system is initially relaxed (no stored energy). In time-domain terms, this means the output arises only from the applied input, not from pre-existing internal conditions. This “initial rest” assumption will be made explicit whenever needed.

The unit impulse \( \delta(t) \) is not an ordinary function; it is a generalized object (distribution) defined operationally by its sampling property.

Definition (Sampling/Sifting). For sufficiently nice test functions \( \varphi(t) \),

\[ \int_{-\infty}^{\infty} \delta(t-t_0)\,\varphi(t)\,dt = \varphi(t_0). \]

A common engineering approximation is a narrow rectangular pulse of area 1:

\[ \delta_\varepsilon(t) = \begin{cases} \dfrac{1}{\varepsilon}, & |t|\, < \, \dfrac{\varepsilon}{2} \\ 0, & |t| \, \ge \, \dfrac{\varepsilon}{2} \end{cases} \quad\text{so that}\quad \int_{-\infty}^{\infty}\delta_\varepsilon(t)\,dt = 1, \ \ \text{and}\ \ \delta_\varepsilon \to \delta \ \text{(in the distribution sense)}. \]

For an LTI system \( \mathcal{T} \), the impulse response is defined as the output to a unit impulse input.

\[ h(t) \; \triangleq \; \mathcal{T}\{\delta(t)\}. \]

By time invariance, the response to a shifted impulse \( \delta(t-t_0) \) is a shifted impulse response:

\[ \mathcal{T}\{\delta(t-t_0)\} = h(t-t_0). \]

By linearity, the response to a scaled impulse \( a\,\delta(t-t_0) \) is \( a\,h(t-t_0) \). These two facts are the core mechanism behind convolution.

The fundamental theorem states that an LTI system is completely described by its impulse response: the output is the input convolved with \( h(t) \).

Step 1: Write any input as a continuous superposition of shifted impulses.

Using the sampling property, one can represent (formally) an input \( x(t) \) as:

\[ x(t) = \int_{-\infty}^{\infty} x(\tau)\,\delta(t-\tau)\,d\tau. \]

Step 2: Apply the system operator and use linearity.

\[ y(t) = \mathcal{T}\{x(t)\} = \mathcal{T}\left\{\int_{-\infty}^{\infty} x(\tau)\,\delta(t-\tau)\,d\tau\right\}. \]

Under mild technical conditions (which hold for standard engineering signal classes, or can be formalized using distributions), we interchange the operator with the integral (linearity + continuity):

\[ y(t) = \int_{-\infty}^{\infty} x(\tau)\,\mathcal{T}\{\delta(t-\tau)\}\,d\tau. \]

Step 3: Use time invariance to replace the inner response.

\[ \mathcal{T}\{\delta(t-\tau)\} = h(t-\tau), \]

so

\[ y(t) = \int_{-\infty}^{\infty} x(\tau)\,h(t-\tau)\,d\tau. \]

Definition (Convolution). The convolution of \( x \) and \( h \) is

\[ (x*h)(t) \;\triangleq\; \int_{-\infty}^{\infty} x(\tau)\,h(t-\tau)\,d\tau. \]

Theorem (Convolution representation of LTI systems).

\[ \boxed{ \ y(t) = (x*h)(t) \ } \quad\text{where}\quad h(t)=\mathcal{T}\{\delta(t)\}. \]

This theorem provides a purely time-domain characterization. In Lesson 2, we will connect this result to Laplace transforms and derive transfer functions, where convolution becomes multiplication.

Discrete-time analog. For sequences \( x[k] \), \( h[k] \):

\[ (x*h)[k] \;\triangleq\; \sum_{n=-\infty}^{\infty} x[n]\,h[k-n], \quad\text{and}\quad y[k]=(x*h)[k]. \]

The convolution operator inherits a rich algebra that is essential for system interconnections and simplifications. Throughout, assume integrals/sums converge absolutely (or interpret via distributions).

5.1 Commutativity: \( x*h = h*x \).

\[ (x*h)(t) = \int_{-\infty}^{\infty} x(\tau)\,h(t-\tau)\,d\tau. \]

Proof. Substitute \( \lambda = t-\tau \) so \( \tau = t-\lambda \) and \( d\tau = -d\lambda \):

\[ (x*h)(t) = \int_{\infty}^{-\infty} x(t-\lambda)\,h(\lambda)\,(-d\lambda) = \int_{-\infty}^{\infty} h(\lambda)\,x(t-\lambda)\,d\lambda = (h*x)(t). \]

5.2 Associativity: \( (x*h_1)*h_2 = x*(h_1*h_2) \).

Proof sketch (Fubini argument).

\[ \begin{aligned} ((x*h_1)*h_2)(t) &= \int_{-\infty}^{\infty} (x*h_1)(\tau)\,h_2(t-\tau)\,d\tau \\ &= \int_{-\infty}^{\infty}\left(\int_{-\infty}^{\infty} x(\lambda)\,h_1(\tau-\lambda)\,d\lambda\right)h_2(t-\tau)\,d\tau \\ &\overset{\text{swap}}{=}\int_{-\infty}^{\infty} x(\lambda)\left(\int_{-\infty}^{\infty} h_1(\tau-\lambda)\,h_2(t-\tau)\,d\tau\right)d\lambda \\ &= \int_{-\infty}^{\infty} x(\lambda)\,(h_1*h_2)(t-\lambda)\,d\lambda \\ &= (x*(h_1*h_2))(t). \end{aligned} \]

5.3 Distributivity: \( x*(h_1+h_2)=x*h_1+x*h_2 \).

Proof. Expand inside the integral and split the integral by linearity of integration.

5.4 Identity element (impulse): \( x*\delta = x \).

\[ (x*\delta)(t)=\int_{-\infty}^{\infty} x(\tau)\,\delta(t-\tau)\,d\tau = x(t). \]

5.5 Time shift: If \( x_{t_0}(t)=x(t-t_0) \), then

\[ (x_{t_0}*h)(t) = (x*h)(t-t_0). \]

This matches time invariance: shifting the input shifts the output by the same amount.

5.6 Differentiation under convolution (useful for step/impulse relations).

If \( h \) is differentiable and the interchange of differentiation and integration is justified, then:

\[ \frac{d}{dt}(x*h)(t) = x * \frac{dh}{dt}(t). \]

Step response relation (preview-level, time-domain only).

Let the unit step be \( \mathbf{1}(t) \) where \( \mathbf{1}(t)=0 \) for \( t < 0 \) and \( \mathbf{1}(t)=1 \) for \( t \ge 0 \). Define the step response \( g(t)=\mathcal{T}\{\mathbf{1}(t)\} \). Then:

\[ g(t) = (\mathbf{1}*h)(t) = \int_{-\infty}^{\infty}\mathbf{1}(\tau)\,h(t-\tau)\,d\tau = \int_{0}^{\infty} h(t-\tau)\,d\tau. \]

With substitution \( \lambda=t-\tau \):

\[ g(t)=\int_{-\infty}^{t} h(\lambda)\,d\lambda, \quad\text{and (formally)}\quad \frac{dg}{dt}(t)=h(t). \]

Practically, engineers often measure a step response and differentiate it to estimate the impulse response.

Consider the first-order input–output differential equation (common in thermal and RC models):

\[ \frac{dy(t)}{dt} + a\,y(t) = b\,x(t), \qquad a > 0, \]

with initial rest \( y(0^-)=0 \). We compute the impulse response by choosing \( x(t)=\delta(t) \).

Impulse response derivation (distribution-aware). Let \( x(t)=\delta(t) \). For \( t > 0 \), the equation becomes homogeneous:

\[ \frac{dh(t)}{dt} + a\,h(t) = 0 \quad (t > 0), \]

so

\[ h(t) = C\,e^{-a t}\quad (t > 0). \]

To determine \( C \), integrate the differential equation across a small interval around \( t=0 \):

\[ \int_{-\varepsilon}^{\varepsilon}\left(\frac{dh}{dt} + a h(t)\right)dt = b\int_{-\varepsilon}^{\varepsilon}\delta(t)\,dt = b. \]

The left side becomes \( h(\varepsilon)-h(-\varepsilon) + a\int_{-\varepsilon}^{\varepsilon}h(t)dt \). Under initial rest and finite energy, \( h(-\varepsilon)\approx 0 \) and the integral term vanishes as \( \varepsilon \to 0 \), giving \( h(0^+)=b \). Thus \( C=b \), and

\[ \boxed{ h(t)= b\,e^{-a t}\,\mathbf{1}(t) } \]

Output for a step input via convolution. Let \( x(t)=\mathbf{1}(t) \). Then

\[ y(t) = (x*h)(t) = \int_{-\infty}^{\infty}\mathbf{1}(\tau)\,b\,e^{-a(t-\tau)}\mathbf{1}(t-\tau)\,d\tau. \]

The factors enforce \( \tau \ge 0 \) and \( t-\tau \ge 0 \), hence \( 0 \le \tau \le t \) for \( t \ge 0 \). Therefore:

\[ y(t) = \int_{0}^{t} b\,e^{-a(t-\tau)}\,d\tau = b\int_{0}^{t} e^{-a(t-\tau)}\,d\tau = \frac{b}{a}\left(1-e^{-a t}\right)\mathbf{1}(t). \]

This is the familiar exponential approach to the steady value \( b/a \), obtained purely from impulse response + convolution.

In computation, we typically sample signals on a uniform grid \( t_k = k\Delta t \). For a continuous-time convolution, a straightforward Riemann approximation yields:

\[ y(t_k) = \int_{-\infty}^{\infty} x(\tau)\,h(t_k-\tau)\,d\tau \approx \Delta t \sum_{n=-\infty}^{\infty} x(t_n)\,h(t_k-t_n). \]

If signals are causal and sampled from \( t=0 \), the practical finite-sum form becomes:

\[ y[k] \approx \Delta t \sum_{n=0}^{k} x[n]\,h[k-n]. \]

flowchart TD
  S["Choose dt and time grid t_k = k*dt"] --> A["Sample x[k]=x(t_k), h[k]=h(t_k)"]
  A --> B["For each k: accumulate sum y[k] = dt * sum_{n=0..k} x[n]*h[k-n]"]
  B --> C["Use y[k] as approximation of y(t_k)"]
  C --> D["If long signals: consider FFT-based convolution"]
        

Direct summation is \( \mathcal{O}(N^2) \). For long signals, FFT-based convolution can reduce complexity to approximately \( \mathcal{O}(N\log N) \), but direct summation is often preferred for short records, educational clarity, and careful control of boundary effects.

We simulate the first-order impulse response \( h(t)=b e^{-a t}\mathbf{1}(t) \), convolve it with an input, and compare against directly integrating the ODE. Relevant libraries: numpy, scipy.signal, scipy.integrate, and (optionally) control.

import numpy as np
from scipy.integrate import solve_ivp
from scipy.signal import fftconvolve

# First-order LTI element: y' + a y = b x(t)
a = 2.0
b = 3.0

# Time grid
dt = 1e-3
T = 2.0
t = np.arange(0.0, T + dt, dt)

# Input: a piecewise signal (e.g., step at 0.2s, then a pulse)
x = np.zeros_like(t)
x[t >= 0.2] = 1.0
x[(t >= 0.8) & (t <= 1.0)] += 0.5

# Impulse response h(t) = b*exp(-a t)*1(t) sampled on the grid
h = b * np.exp(-a * t)

# Convolution approximation: y[k] ≈ dt * sum x[n]*h[k-n]
y_conv = dt * np.convolve(x, h, mode="full")[:len(t)]

# Faster version (FFT-based) for longer signals:
y_fft = dt * fftconvolve(x, h, mode="full")[:len(t)]

# ODE integration for comparison (initial rest y(0)=0)
def rhs(ti, yi):
    # interpolate x(t) on the grid
    xi = np.interp(ti, t, x)
    return -a * yi + b * xi

sol = solve_ivp(rhs, (t[0], t[-1]), y0=[0.0], t_eval=t, rtol=1e-8, atol=1e-10)
y_ode = sol.y[0]

# Simple numerical discrepancy measures
err_conv = np.max(np.abs(y_ode - y_conv))
err_fft = np.max(np.abs(y_ode - y_fft))
print("max|y_ode - y_conv| =", err_conv)
print("max|y_ode - y_fft|  =", err_fft)

Remarks: (i) The factor \( \Delta t \) is essential when using discrete convolution to approximate a continuous-time integral. (ii) Boundary effects arise because we truncate signals to a finite time window.

Below is a minimal direct-convolution implementation suitable for sampled approximations. Common numerical libraries in C++ for System Dynamics workflows include: Eigen (linear algebra), Boost.Odeint (ODE integration), and FFTW (FFT-based convolution).

Note: HTML rendering escapes angle brackets inside code blocks; when compiling, replace <, > with <, >.

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

std::vector<double> convolve_continuous_approx(
    const std::vector<double>& x,
    const std::vector<double>& h,
    double dt
) {
    // y[k] = dt * sum_{n=0..k} x[n] * h[k-n]  (assuming causal, same dt)
    const std::size_t N = x.size();
    const std::size_t M = h.size();
    std::vector<double> y(N, 0.0);

    for (std::size_t k = 0; k < N; ++k) {
        double acc = 0.0;
        std::size_t n_min = 0;
        std::size_t n_max = (k < M - 1) ? k : (M - 1);

        for (std::size_t n = n_min; n <= n_max; ++n) {
            acc += x[n] * h[k - n];
        }
        y[k] = dt * acc;
    }
    return y;
}

int main() {
    // Example: first-order impulse response h(t)=b*exp(-a t), sampled
    const double a = 2.0;
    const double b = 3.0;
    const double dt = 1e-3;
    const double T = 2.0;

    const std::size_t N = static_cast<std::size_t>(T / dt) + 1;

    std::vector<double> t(N), x(N), h(N);
    for (std::size_t k = 0; k < N; ++k) {
        t[k] = k * dt;
        x[k] = (t[k] >= 0.2) ? 1.0 : 0.0;     // step at 0.2s
        h[k] = b * std::exp(-a * t[k]);      // sampled impulse response
    }

    auto y = convolve_continuous_approx(x, h, dt);

    std::cout << "y[0]=" << y[0] << ", y[end]=" << y.back() << "\n";
    return 0;
}

Java implementations commonly rely on primitive arrays for speed and simplicity. For larger projects, common numerical libraries include: Apache Commons Math (numerics/FFT), EJML (linear algebra), and JTransforms (FFT).

public class ConvolutionLTI {

    // y[k] = dt * sum_{n=0..k} x[n] * h[k-n]  (causal assumption)
    public static double[] convolveContinuousApprox(double[] x, double[] h, double dt) {
        int N = x.length;
        int M = h.length;
        double[] y = new double[N];

        for (int k = 0; k < N; k++) {
            double acc = 0.0;
            int nMax = Math.min(k, M - 1);
            for (int n = 0; n <= nMax; n++) {
                acc += x[n] * h[k - n];
            }
            y[k] = dt * acc;
        }
        return y;
    }

    public static void main(String[] args) {
        double a = 2.0;
        double b = 3.0;
        double dt = 1e-3;
        double T = 2.0;

        int N = (int) Math.round(T / dt) + 1;

        double[] t = new double[N];
        double[] x = new double[N];
        double[] h = new double[N];

        for (int k = 0; k < N; k++) {
            t[k] = k * dt;
            x[k] = (t[k] >= 0.2) ? 1.0 : 0.0;      // step
            h[k] = b * Math.exp(-a * t[k]);       // sampled impulse response
        }

        double[] y = convolveContinuousApprox(x, h, dt);

        System.out.println("y[0] = " + y[0] + ", y[end] = " + y[N - 1]);
    }
}

MATLAB provides conv for discrete convolution. To approximate continuous-time convolution, multiply by \( \Delta t \). We also compare with ode45 integration of the governing ODE.

% First-order system: y' + a y = b x(t)
a = 2.0;
b = 3.0;

dt = 1e-3;
T  = 2.0;
t  = 0:dt:T;

% Input x(t): step at 0.2 s plus a short pulse
x = zeros(size(t));
x(t >= 0.2) = 1.0;
x(t >= 0.8 & t <= 1.0) = x(t >= 0.8 & t <= 1.0) + 0.5;

% Impulse response h(t) = b*exp(-a t)*1(t), sampled for t>=0
h = b * exp(-a * t);

% Continuous-time convolution approximation: y ~= dt * conv(x,h)
y_conv_full = dt * conv(x, h, 'full');
y_conv = y_conv_full(1:length(t));

% ODE integration for comparison
rhs = @(tt, yy) -a*yy + b*interp1(t, x, tt, 'linear', 0.0);
[ts, ys] = ode45(rhs, [t(1), t(end)], 0.0);
y_ode = interp1(ts, ys, t, 'linear');

fprintf('max|y_ode - y_conv| = %.3e\n', max(abs(y_ode - y_conv)));

Simulink (impulse-response measurement via narrow pulse).

Since an ideal impulse is not physically realizable, approximate \( \delta(t) \) by a narrow pulse of width \( \varepsilon \) and amplitude \( 1/\varepsilon \). Build the first-order dynamics using basic blocks: Sum, Gain, Integrator.

Block equations implemented in Simulink:

\[ \frac{dy(t)}{dt} = -a\,y(t) + b\,x(t). \]

MATLAB script to programmatically create a minimal Simulink model:

% Programmatic Simulink build for y' = -a y + b x
a = 2.0; b = 3.0;

model = 'first_order_impulse';
new_system(model); open_system(model);

add_block('simulink/Sources/Pulse Generator', [model '/Pulse']);
set_param([model '/Pulse'], 'Amplitude', '1000', 'Period', '10', 'PulseWidth', '0.1'); % area ~ 1

add_block('simulink/Math Operations/Gain', [model '/Gain_b']);
set_param([model '/Gain_b'], 'Gain', num2str(b));

add_block('simulink/Math Operations/Gain', [model '/Gain_a']);
set_param([model '/Gain_a'], 'Gain', num2str(-a));

add_block('simulink/Math Operations/Sum', [model '/Sum']);
set_param([model '/Sum'], 'Inputs', '++');

add_block('simulink/Continuous/Integrator', [model '/Integrator']);
set_param([model '/Integrator'], 'InitialCondition', '0');

add_block('simulink/Sinks/Scope', [model '/Scope']);

add_line(model, 'Pulse/1', 'Gain_b/1');
add_line(model, 'Gain_b/1', 'Sum/1');
add_line(model, 'Integrator/1', 'Gain_a/1');
add_line(model, 'Gain_a/1', 'Sum/2');
add_line(model, 'Sum/1', 'Integrator/1');
add_line(model, 'Integrator/1', 'Scope/1');

set_param(model, 'StopTime', '2');
save_system(model);

The scope output approximates the impulse response \( h(t) \). Refinement requires decreasing pulse width while keeping unit area.

Mathematica offers symbolic and numerical convolution tools (Convolve, Integrate, NDSolve), enabling direct verification of analytical results.

(* First-order system impulse response and step response via convolution *)
a = 2; b = 3;

h[t_] := b Exp[-a t] UnitStep[t];
xStep[t_] := UnitStep[t];

(* Convolution y(t) = (x*h)(t) *)
yConv[t_] := Assuming[t >= 0, FullSimplify[Convolve[xStep[τ], h[τ], τ, t]]]

(* Expected result: (b/a)(1 - exp(-a t)) UnitStep[t] *)
yExpected[t_] := (b/a) (1 - Exp[-a t]) UnitStep[t];

(* Verify symbolic equality *)
FullSimplify[yConv[t] - yExpected[t]]

(* Numerical check vs ODE solution for a custom input *)
x[t_] := UnitStep[t - 1/5] + 1/2 (UnitStep[t - 4/5] - UnitStep[t - 1]);

yODE = First@NDSolve[
  {y'[t] + a y[t] == b x[t], y[0] == 0},
  y, {t, 0, 2}
];

(* Numerical convolution integral (finite window approximation) *)
yNumConv[t_] := NIntegrate[x[τ] h[t - τ], {τ, -5, 5}];

{yODE[0.7], yNumConv[0.7]} (* compare values *)

The following problems are typical of first exposure to impulse response and convolution in system dynamics and signals. Unless otherwise stated, assume signals are such that integrals/sums converge (or interpret via distributions).

Problem 1 (Derive convolution from LTI axioms):
Let \( \mathcal{T} \) be linear and time-invariant, and define \( h(t)=\mathcal{T}\{\delta(t)\} \). Show that for any input \( x(t) \) representable as \( x(t)=\int_{-\infty}^{\infty}x(\tau)\delta(t-\tau)d\tau \), the output satisfies \( y(t)=\int_{-\infty}^{\infty}x(\tau)h(t-\tau)d\tau \).

Solution:
Apply \( \mathcal{T} \) to the impulse decomposition, interchange operator and integral by linearity/continuity, and use time invariance:

\[ \begin{aligned} y(t) &= \mathcal{T}\{x(t)\} = \mathcal{T}\left\{\int_{-\infty}^{\infty}x(\tau)\delta(t-\tau)\,d\tau\right\} = \int_{-\infty}^{\infty}x(\tau)\mathcal{T}\{\delta(t-\tau)\}\,d\tau \\ &= \int_{-\infty}^{\infty}x(\tau)h(t-\tau)\,d\tau = (x*h)(t). \end{aligned} \]

Problem 2 (Compute a continuous-time convolution explicitly):
Let \( x(t)=\mathbf{1}(t) \) and \( h(t)=e^{-t}\mathbf{1}(t) \). Compute \( y(t)=(x*h)(t) \).

Solution:
For \( t < 0 \), \( y(t)=0 \). For \( t \ge 0 \):

\[ \begin{aligned} y(t) &= \int_{-\infty}^{\infty}\mathbf{1}(\tau)\,e^{-(t-\tau)}\mathbf{1}(t-\tau)\,d\tau = \int_{0}^{t} e^{-(t-\tau)}\,d\tau = \left[ -e^{-(t-\tau)} \right]_{\tau=0}^{\tau=t} \\ &= 1 - e^{-t}. \end{aligned} \]

Therefore \( y(t)=(1-e^{-t})\mathbf{1}(t) \).

Problem 3 (Discrete-time convolution):
Let \( x[0]=1, x[1]=2, x[2]=0 \) and \( h[0]=1, h[1]=-1 \), with other samples zero. Compute \( y[k]=(x*h)[k] \) for \( k=0,1,2,3 \).

Solution:
Use \( y[k]=\sum_{n=-\infty}^{\infty}x[n]h[k-n] \). Only terms with defined samples contribute.

\[ \begin{aligned} y[0] &= x[0]h[0] = 1\cdot 1 = 1, \\ y[1] &= x[0]h[1] + x[1]h[0] = 1\cdot(-1) + 2\cdot 1 = 1, \\ y[2] &= x[1]h[1] + x[2]h[0] = 2\cdot(-1) + 0\cdot 1 = -2, \\ y[3] &= x[2]h[1] = 0\cdot(-1) = 0. \end{aligned} \]

Problem 4 (Prove commutativity of convolution):
Prove that \( (x*h)(t)=(h*x)(t) \).

Solution:
Start from the definition and substitute \( \lambda=t-\tau \):

\[ (x*h)(t)=\int_{-\infty}^{\infty}x(\tau)h(t-\tau)\,d\tau =\int_{-\infty}^{\infty}h(\lambda)x(t-\lambda)\,d\lambda =(h*x)(t). \]

Problem 5 (Step response and impulse response relationship):
Let \( g(t)=\mathcal{T}\{\mathbf{1}(t)\} \) be the step response of an LTI system with impulse response \( h(t) \). Show that \( g(t)=\int_{-\infty}^{t}h(\lambda)\,d\lambda \), and (formally) \( h(t)=dg(t)/dt \).

Solution:
By convolution, \( g(t)=(\mathbf{1}*h)(t)=\int_{-\infty}^{\infty}\mathbf{1}(\tau)h(t-\tau)\,d\tau=\int_{0}^{\infty}h(t-\tau)\,d\tau \). Substitute \( \lambda=t-\tau \) to obtain \( g(t)=\int_{-\infty}^{t}h(\lambda)\,d\lambda \). If differentiation under the integral is valid, then \( dg/dt = h(t) \).

We defined LTI systems as linear, time-invariant operators and introduced the impulse response \( h(t)=\mathcal{T}\{\delta(t)\} \). Using the impulse decomposition of signals and the LTI axioms, we proved the convolution representation \( y(t)=(x*h)(t) \). We also established essential convolution properties and implemented numerical convolution across multiple programming environments. In the next lesson, we will connect convolution to Laplace transforms and derive transfer functions under zero initial conditions.