Signals and Systems: LTI Properties and Convolution Step by Step

Signals and Systems is the mathematical backbone of communication, control and signal processing. A signal is a function carrying information, such as a voltage over time or a sequence of audio samples. A system transforms an input signal into an output signal, like an RC filter, an amplifier or a moving-average routine in firmware. This tutorial explains how to classify systems, why linear time-invariant (LTI) systems are special, and how convolution lets you compute the output of any LTI system from a single measured response. Every idea is backed by a worked example.

Signals You Need to Know

Signals are continuous-time, written x(t), or discrete-time, written x[n] where n is an integer sample index. Two elementary signals appear everywhere. The unit step u(t) is 0 for t < 0 and 1 for t >= 0. The unit impulse δ(t) is zero everywhere except t = 0 and has unit area; its discrete version δ[n] is simply 1 at n = 0 and 0 elsewhere. Any discrete signal can be written as a sum of shifted, scaled impulses, which is the key to convolution.

x[n] = Σ x[k] δ[n - k]     (sum over all k)

Example: x[n] = {2, -1, 3} starting at n = 0
x[n] = 2δ[n] - δ[n - 1] + 3δ[n - 2]

System Properties and How to Test Them

Property	Definition	Quick test
Linearity	Response to a.x1 + b.x2 is a.y1 + b.y2	Scale and add two inputs; compare with scaled and added outputs
Time invariance	A delayed input gives an equally delayed output	Compare y for x(t - t0) with y(t - t0)
Causality	Output depends only on present and past inputs	Look for future terms such as x(t + 1)
Memory	Output depends on values other than the present input	Any delay or integral means memory
BIBO stability	Every bounded input gives a bounded output	For LTI, impulse response must be absolutely summable

Worked tests

1) y(t) = t.x(t)
   Linear: a.x1 + b.x2 -> t(a.x1 + b.x2) = a.y1 + b.y2   YES
   Time-invariant: input x(t - t0) -> t.x(t - t0)
                   delayed output   -> (t - t0).x(t - t0)   differ -> NO

2) y[n] = x[n]^2
   Linear: (x1 + x2)^2 is not x1^2 + x2^2                 NO
   Time-invariant: x[n - k]^2 = y[n - k]                  YES
   Causal and memoryless                                  YES

3) y[n] = x[n + 1] - x[n]
   Linear, time-invariant, but NOT causal (uses n + 1)

Note that y(t) = 2x(t) + 3 is not linear in the strict sense, because a zero input gives a non-zero output. Engineers call it incrementally linear. This catches many students in exams.

Why LTI Systems Are Special: Convolution

Let h[n] be the response of an LTI system to δ[n], called the impulse response. Because the input is a sum of shifted impulses, linearity lets us add the responses, and time invariance tells us that the response to δ[n - k] is h[n - k]. The output is therefore the convolution sum. The continuous version replaces the sum with an integral.

Discrete:    y[n] = Σ x[k] h[n - k]        (sum over k)
Continuous:  y(t) = ∫ x(τ) h(t - τ) dτ     (integral over τ)
Short form:  y = x * h

The impulse response completely characterises an LTI system. Measure or compute it once and you can predict the output for any input. Convolution is commutative (x * h = h * x), associative, and distributive, so systems in cascade have overall impulse response h1 * h2, and systems in parallel have h1 + h2.

Worked example 1: discrete convolution by flip and slide

x[n] = {1, 2, 3}  (n = 0, 1, 2)
h[n] = {1, 1}     (n = 0, 1)    a 2-tap summing filter

y[0] = x[0]h[0]                 = 1
y[1] = x[0]h[1] + x[1]h[0]      = 1 + 2 = 3
y[2] = x[1]h[1] + x[2]h[0]      = 2 + 3 = 5
y[3] = x[2]h[1]                 = 3

y[n] = {1, 3, 5, 3}
Length = 3 + 2 - 1 = 4 samples

The graphical method is to flip h[k] to get h[-k], shift it by n, multiply sample by sample with x[k] and add. A faster hand method is the table or multiplication method: write the sequences like two numbers to multiply, multiply without carries, and add the columns. The output length of two finite sequences of lengths N and M is always N + M - 1.

Worked example 2: continuous convolution, RC-type system

x(t) = u(t),   h(t) = e^(-at) u(t),  a > 0

For t < 0 the two signals do not overlap, so y(t) = 0.
For t >= 0:
y(t) = ∫[0 to t] 1 . e^(-a(t - τ)) dτ
     = e^(-at) . [e^(aτ) / a] from 0 to t
     = (1/a)(1 - e^(-at))

y(t) = (1/a)(1 - e^(-at)) u(t)

This is the familiar charging curve of an RC circuit, with a = 1/RC. The output rises from 0 and settles at 1/a. Doing this example once makes the meaning of convolution concrete: the output at time t is a weighted memory of all past inputs, with h giving the weights.

Causality and Stability from h[n]

For an LTI system, both properties can be read directly from the impulse response. The system is causal if h[n] = 0 for all n < 0. It is BIBO stable if the sum of |h[n]| over all n is finite. For example, h[n] = (0.5)^n u[n] has an absolute sum of 1/(1 - 0.5) = 2, so the system is stable. With h[n] = (1.2)^n u[n] the sum diverges and the system is unstable. An ideal integrator, h(t) = u(t), is also unstable, since a constant input produces an output that grows without limit.

Common Mistakes

Forgetting to flip h before sliding, which computes correlation instead of convolution.
Losing track of the starting index. If x starts at n = n1 and h at n = n2, y starts at n1 + n2.
Using the wrong integration limits in continuous convolution. Sketch both signals to find the overlap.
Calling a system with a constant offset linear.

Summary

Systems are classified by linearity, time invariance, causality, memory and stability, each with a simple test. For LTI systems, the impulse response captures everything, and the output to any input is the convolution of the input with the impulse response. Practise the flip-and-slide method on short sequences and the overlap method on exponentials. Convolution in time becomes multiplication in frequency, which is why the Fourier and Laplace transforms are the natural next step.