Convolution

Convolution is one of the main operations that shows up whenever a system has memory.

At a high level, convolution answers this question:

How much does each past input contribute to the present output?

The answer depends on two things:

input signal:        u(t)
system response:     h(t)

The input signal tells us what arrived over time.

The system response tells us how the system reacts to an input after it arrives.

The convolution of $h$ and $u$ is written as:

(h*u)(t)=\int_{-\infty}^{\infty}h(t-\tau)\,u(\tau)\,d\tau

This equation says:

To compute the output at time t,
look at every input value u(τ),
weight it by how the system responds after delay t - τ,
then add all those contributions together.

The variable $\tau$ is the time when the input happened.

The value $t-\tau$ is the age of that input relative to the current time $t$ .

So:

u(τ)        = input that happened at time τ
h(t - τ)    = how much that input still matters at time t

Convolution is therefore a weighted history of input.

Why convolution is written from $-\infty$ to $\infty$

The most general definition is:

(h*u)(t)=\int_{-\infty}^{\infty}h(t-\tau)\,u(\tau)\,d\tau

This is the full mathematical definition.

It considers all possible times:

past
present
future

But real-time systems usually cannot depend on future input.

A physical system, filter, controller, or online model at time $t$ should not depend on something that happens after $t$ .

That brings us to causal convolution.

Causal convolution

A system is causal if its output at time $t$ only depends on inputs from time $t$ or earlier.

In other words:

present output depends on past and present input
present output does not depend on future input

For a causal system, the impulse response is zero before time zero:

h(t)=0 \quad \text{for } t<0

This means the system does not respond before the input arrives.

A cleaner way to write a causal impulse response is:

h(t)=h(t)\,\mathbf{1}_{t\ge 0}

where:

\mathbf{1}_{t\ge 0}

is the unit step condition that makes the response zero before $t=0$ .

Now look again at the convolution:

(h*u)(t)=\int_{-\infty}^{\infty}h(t-\tau)\,u(\tau)\,d\tau

For $h(t-\tau)$ to be nonzero, we need:

t-\tau \ge 0

which means:

\tau \le t

So only inputs from the past can contribute.

If the system starts at time $0$ , then we usually also assume:

u(\tau)=0 \quad \text{for } \tau<0

So the only part of the integral that matters is:

0 \le \tau \le t

Therefore, for a causal system starting at $t=0$ , convolution becomes:

(h*u)(t)=\int_0^t h(t-\tau)\,u(\tau)\,d\tau

This is causal convolution.

It is not a different idea from full convolution. It is the same operation, but with the impossible parts removed.

Full convolution:

\int_{-\infty}^{\infty}

Causal convolution starting at $0$ :

\int_0^t

The reason is simple:

future input cannot affect the present,
and input before the system starts is assumed to be zero.

Impulse response

The function $h(t)$ is called the impulse response.

It tells us how the system responds to a tiny input placed at time zero.

Once we know $h(t)$ , we know how the system responds to any input $u(t)$ , because any input can be treated as a collection of small impulses spread over time.

Each small input $u(\tau)$ creates a shifted response:

h(t-\tau)

Then convolution adds all those shifted responses together.

That is why convolution appears everywhere in linear time-invariant systems.

The system does not need a new rule for every possible input.

It only needs one response function:

h(t)

Then every output is built by convolution:

y(t)=(h*u)(t)

Example: the leaky integrator

A leaky integrator is a simple dynamic system:

\frac{dx}{dt}=-Ax+u(t)

The state is $x(t)$ .

The input is $u(t)$ .

The constant $A$ controls how quickly the state leaks away.

If there is no input, then:

\frac{dx}{dt}=-Ax

and the solution is:

x(t)=x(0)\,e^{-At}

So the initial state fades exponentially.

Large $A$ means fast decay.

Small $A$ means slow decay.

Now include input $u(t)$ . The solution becomes:

x(t)=x(0)\,e^{-At}+\int_0^t e^{-A(t-\tau)}\,u(\tau)\,d\tau

This has two parts.

The first part:

x(0)\,e^{-At}

is the surviving contribution of the initial state.

The second part:

\int_0^t e^{-A(t-\tau)}\,u(\tau)\,d\tau

is the accumulated contribution of past input.

This second part is convolution.

The impulse response is:

h(t)=e^{-At}\,\mathbf{1}_{t\ge 0}

So the driven response is:

(h*u)(t)=\int_0^t h(t-\tau)\,u(\tau)\,d\tau

Substituting $h(t-\tau)$ :

(h*u)(t)=\int_0^t e^{-A(t-\tau)}\,u(\tau)\,d\tau

This shows exactly what the leaky integrator stores:

a fading record of past input

Recent inputs have small age $t-\tau$ , so:

e^{-A(t-\tau)} \approx 1

Old inputs have large age $t-\tau$ , so:

e^{-A(t-\tau)} \approx 0

The leaky integrator does not remember all inputs equally.

It remembers through an exponential weighting.

Convolution and transfer functions

In the time domain, the output is convolution:

y(t)=(h*u)(t)

In the Laplace domain, convolution becomes multiplication:

Y(s)=H(s)\,U(s)

This is one of the main reasons the Laplace transform is useful.

It turns a history operation into an algebraic operation.

For the leaky integrator:

h(t)=e^{-At}\,\mathbf{1}_{t\ge 0}

The Laplace transform is:

H(s)=\frac{1}{s+A}

So instead of writing:

y(t)=\int_0^t e^{-A(t-\tau)}\,u(\tau)\,d\tau

we can write:

Y(s)=\frac{1}{s+A}\,U(s)

The time-domain view says:

the system accumulates a fading history

The Laplace-domain view says:

the system multiplies the input by a transfer function

They are the same system viewed through two different representations.

Discrete convolution

Convolution also appears in discrete time.

Instead of continuous time $t$ , we have steps:

n=0,1,2,3,\dots

The discrete convolution is:

y[n]=\sum_{k=-\infty}^{\infty}h[n-k]\,u[k]

For a causal system starting at $0$ , this becomes:

y[n]=\sum_{k=0}^{n}h[n-k]\,u[k]

This is the same idea as the continuous version:

current output = sum of past inputs weighted by age

The integral becomes a sum.

The logic stays the same.

The core mental model

Convolution is not just a formula.

It is a way to describe how a system builds the present from the past.

The general form is:

(h*u)(t)=\int_{-\infty}^{\infty}h(t-\tau)\,u(\tau)\,d\tau

The causal form is:

(h*u)(t)=\int_0^t h(t-\tau)\,u(\tau)\,d\tau

The meaning is:

Each past input contributes to the present output.
The contribution depends on how old the input is.
The weighting function is the system response.

So whenever convolution appears, ask:

What is the input?
What is the response kernel?
What is being accumulated?
What does the system remember?
What gets forgotten?
Is the system causal?

That is usually enough to understand why convolution is there.

Summary

Full convolution:

(h*u)(t)=\int_{-\infty}^{\infty}h(t-\tau)\,u(\tau)\,d\tau

Causal convolution:

(h*u)(t)=\int_0^t h(t-\tau)\,u(\tau)\,d\tau

Leaky integrator kernel:

h(t)=e^{-At}\,\mathbf{1}_{t\ge 0}

Leaky integrator response:

x(t)=x(0)\,e^{-At}+\int_0^t e^{-A(t-\tau)}\,u(\tau)\,d\tau

Laplace-domain version:

Y(s)=H(s)\,U(s)

Main idea:

Convolution is weighted history.
Causal convolution is weighted past history.

Why convolution is written from −∞-\infty−∞ to ∞\infty∞