Convolution and the impulse response

Lesson 2 claimed that a linear time-invariant system is completely described by one function, its impulse response. This lesson proves that claim and turns it into a calculation. The idea is simple and beautiful: any input can be written as a sum of shifted, scaled impulses; by linearity and time invariance, the output is the same sum of shifted, scaled impulse responses. The operation that performs this sum is called convolution. Convolution is how a sensor's dynamics blur a measurement, how a moving-average filter smooths encoder data, how a motor's inertia turns a torque pulse into a lingering velocity, and how a camera's lens blurs an image. It also explains why the Laplace and Fourier transforms of later lessons are so useful: they turn convolution into multiplication.

The impulse response

The impulse response h(t) of an LTI system is its output when the input is a unit impulse \( \delta(t) \) and the system starts at rest. In discrete time, h[n] is the output sequence produced by the input \( \delta[n] \), which is 1 at n = 0 and 0 elsewhere. The impulse response is a fingerprint. A first-order low-pass sensor has \( h(t) = \frac{1}{\tau}e^{-t/\tau}u(t) \), an instant jump that decays with time constant \( \tau \). A three-sample moving average has \( h[n] = \tfrac{1}{3} \) for n = 0, 1, 2 and zero otherwise. A lightly damped robot link struck by a hammer rings with a decaying oscillation, and that ringing is its impulse response; structural engineers measure it with an instrumented hammer and an accelerometer to identify vibration modes.

The impulse response also answers the questions of lesson 2 at a glance. The system is causal if h(t) = 0 for t < 0: it cannot respond before the impulse arrives. It is memoryless only if h is itself an impulse. And it is BIBO-stable exactly when the impulse response is absolutely integrable:

The decaying exponential passes this test; an integrator, whose impulse response is the unit step, fails it, consistent with lesson 2.

Building the convolution sum

Start in discrete time, where everything is a finite sum. Any input sequence can be written as a sum of scaled, shifted impulses, one per sample:

This just says the signal at n is its value at n. Now apply the system. Time invariance says the response to \( \delta[n - k] \) is \( h[n - k] \); linearity says the response to the weighted sum is the weighted sum of responses. So

This is the convolution sum, written with an asterisk. In words: each past input sample x[k] launches its own copy of the impulse response, starting at time k and scaled by x[k], and the output at time n is the sum of all those copies that are still ringing. For a causal system and an input that starts at n = 0, the sum runs only from k = 0 to k = n. The continuous-time version follows the same reasoning with integrals:

Flip, slide, multiply, add

Computing a convolution by hand follows a mechanical recipe. Write the input as a function of the dummy variable \( \tau \). Flip the impulse response to get \( h(-\tau) \), then slide it by t to get \( h(t - \tau) \). Multiply the two functions point by point, and integrate (or sum) the product. Repeat for every t of interest. As t increases, the flipped impulse response slides from left to right across the input, and the output traces the changing area of overlap. The flipping is what puts the most recent inputs at the front of the impulse response, where its weight is greatest for a typical decaying system: a sensor remembers recent inputs strongly and old ones faintly.

Convolution has useful algebraic properties. It is commutative (\( x * h = h * x \)), so either function can be flipped. It is associative, so two systems in series with impulse responses \( h_1 \) and \( h_2 \) act as one system with \( h_1 * h_2 \), and the order of LTI blocks in a cascade does not matter. It distributes over addition, so parallel systems add their impulse responses. And convolving with \( \delta(t - t_0) \) simply delays a signal by \( t_0 \), which is how a pure transport delay appears in this framework.

Step response and impulse response are related

Because the step is the integral of the impulse, the step response s(t) of an LTI system is the integral of its impulse response, and the impulse response is the derivative of the step response:

This matters experimentally. True impulses are hard to apply without saturating or damaging something, but steps are easy: switch on a voltage, change a set point. Engineers therefore often measure the step response and differentiate it, although differentiation amplifies noise, so in practice parametric models are usually fitted to the step data instead (lesson 4). In discrete time the relations are a running sum and a first difference: \( s[n] = \sum_{k \le n} h[k] \) and \( h[n] = s[n] - s[n-1] \).

Convolution in robotics

Convolution appears wherever a system smooths, blurs or remembers.

• Sensor dynamics. Every sensor has an impulse response, so every measurement is the true signal convolved with it, plus noise. A slow force sensor smears a sharp impact; a gyroscope's internal filter delays fast rotations. Knowing h lets you predict, and sometimes partly undo, this distortion.
• Digital filters. A finite impulse response (FIR) filter, such as the moving average, is literally a convolution sum with a short, fixed list of coefficients. Lesson 11 designs them.
• Motion profiles. Convolving a velocity step with a short rectangular pulse produces a ramp; convolving twice gives an S-curve with limited jerk. Some motion controllers generate smooth trajectories exactly this way, by passing a crude command through cascaded moving-average filters.
• Images. Blurring, sharpening and edge detection on camera images are two-dimensional convolutions with small kernels, the basis of classical computer vision and of the convolutional neural networks used in ROB-330.

Computing convolution

In software, a direct discrete convolution of an N-sample signal with an M-sample impulse response needs about N × M multiplications, which is cheap for short filters. NumPy's np.convolve does it in one call. For long impulse responses, the fast Fourier transform of lesson 8 computes the same result much faster, because convolution in time is multiplication in frequency. The code below applies a five-point moving average to a noisy step and confirms the delay and noise reduction predicted earlier in the course.

import numpy as np
rng = np.random.default_rng(7)
n = np.arange(400)
true = np.where(n >= 200, 1.0, 0.0)             # unit step at n = 200
x = true + rng.normal(0, 0.2, n.size)           # noisy measurement
h = np.ones(5) / 5                              # five-point moving average
y = np.convolve(x, h)[:n.size]                  # causal: keep first N outputs
sb, sa = np.std(x[:200]), np.std(y[5:200])
print("noise std before:", round(sb, 3), " after:", round(sa, 3))
print("reduction factor:", round(sb/sa, 2), " (theory sqrt(5) =", round(np.sqrt(5), 2), ")")
cross = np.argmax(np.convolve(true, h)[:n.size] >= 0.5)
print("filtered step crosses 0.5 at n =", cross, "(true step at n = 200)")

noise std before: 0.174  after: 0.077
reduction factor: 2.27  (theory sqrt(5) = 2.24 )
filtered step crosses 0.5 at n = 202 (true step at n = 200)

The noise falls by roughly the square root of the filter length, and the filtered step reaches half height two samples late, at n = 202, half the filter length. That trade between noise reduction and delay is the central compromise of all filtering, and lesson 11 quantifies it precisely with group delay.