JOVANA
Library Glossary Getting Started Three Levels Fields How it works Mission
Join the mission
All guides

Convolution and the Convolution Theorem

Multiplying two transforms in the s-domain is easy — but what does that product mean back in time? The answer is convolution, a special blending of two functions, and it turns the impulse response into a master key that solves a system for any input at all.

A product in s-land, a puzzle in t-land

By now the Laplace round trip is second nature: transform the problem, solve easy algebra in the s-domain, then ride the inverse transform home. Along the way you keep meeting products. Solving an equation for Y(s) often leaves you with something like Y(s) = H(s) * F(s) — one transform multiplied by another. Inverting a single factor is fine, but here is the catch you may already have hit: the inverse transform of a product is not the product of the inverses. L^(-1){H * F} is almost never (L^(-1){H}) times (L^(-1){F}). So what time function does a product of transforms actually stand for?

It is worth seeing the trap concretely. Take H(s) = 1/s and F(s) = 1/s, so the product is 1/s^2. We know 1/s inverts to the constant 1, and we know 1/s^2 inverts to t. If the inverse of a product were the product of the inverses, we would get 1 times 1 = 1 — but the true answer is t. The product 1/s^2 does not come from multiplying two time functions; it comes from a different, gentler way of combining 1 with itself. That combining operation is the subject of this whole guide, and it carries a name: convolution.

What convolution actually does

The convolution of two functions f and g, written (f * g)(t), is defined by a single integral: (f * g)(t) = integral from 0 to t of f(tau) * g(t - tau) dtau. Read the pieces slowly. The variable tau runs over the interval from 0 to the present time t. At each instant tau you take the value f(tau) and multiply it by g(t - tau) — the second function reflected and slid so that its 'now' lines up with how long ago tau was. Then you add up all those products. It is a running, weighted blend of the two functions, not a pointwise product.

A picture helps. Imagine f(tau) as a stream of little inputs arriving over time, and g as the system's response to a single input that has aged by an amount (t - tau). An input that landed long ago (small tau, large t - tau) gets weighted by g evaluated far out along its tail; an input that just arrived (tau near t) gets weighted by g near its start. Convolution sums the lingering effects of every past input, each faded according to how long it has had to evolve. That 'sum over history' reading is exactly why it appears whenever a system's present state is built from its entire past.

The theorem that ties the two worlds

Here is the payoff, and it is beautifully clean. The convolution theorem says: L{f * g} = F(s) * G(s). In words, convolution in the time domain becomes ordinary multiplication in the s-domain. The messy blending integral on this side of the bridge corresponds to a plain product on the far side. This is the missing piece from the opening puzzle, run backward: since multiplying transforms equals transforming a convolution, the inverse of a product H(s) * F(s) must be the convolution L^(-1){H} * L^(-1){F} — not the product of the two time functions.

Convolution:   (f * g)(t) = integral_0^t  f(tau) g(t - tau) dtau

The theorem:   L{ f * g } = F(s) G(s)
Run backward:  L^(-1){ F(s) G(s) } = f * g

Sanity check:  1 * 1 = integral_0^t 1 * 1 dtau = t
               L{1} L{1} = (1/s)(1/s) = 1/s^2 = L{t}   ✓
The definition, the theorem in both directions, and the opening 1/s^2 puzzle resolved: 1 convolved with 1 really is t.

Notice why this is genuinely useful and not just tidy. Often you can split a stubborn Y(s) into a product of two factors you each recognize, even when partial fractions would be ugly or impossible — for instance when a factor like F(s) is left symbolic because the input is arbitrary. Instead of fighting the algebra, you invert each factor separately and convolve. The convolution theorem hands you a second, independent route home across the bridge, and sometimes it is the only practical one.

The impulse response as a master key

Now the ideas of this rung lock together. In the previous guide you met the Dirac delta and the impulse response h(t): the output of a system when you strike it with a single, instantaneous unit kick at t = 0. The claim of this section is that h(t) is not just one special answer — it secretly contains the answer to *every* input. The reason is the convolution theorem applied to a linear, time-invariant system.

Here is the chain of reasoning. The impulse response is, by definition, the inverse transform of the system's transfer function H(s) — that is, H(s) = L{h}. Now feed the same system any forcing f(t), with transform F(s); the algebra of the input-output system gives Y(s) = H(s) * F(s). Invert that product with the convolution theorem and you get y(t) = (h * f)(t) = integral from 0 to t of h(t - tau) * f(tau) dtau. Read what this says: the response to an arbitrary input is the input convolved with the impulse response. Know how the system answers a single kick, and you know how it answers anything.

A worked thread and an honest limit

  1. Take a system whose transfer function is H(s) = 1/(s + 1); transform back to find its impulse response h(t) = e^(-t).
  2. Drive it with a steady input f(t) = 1, switched on at t = 0; you want the output without re-solving the ODE.
  3. Convolve: y(t) = (h * f)(t) = integral from 0 to t of e^(-(t - tau)) * 1 dtau.
  4. Evaluate the integral to get y(t) = 1 - e^(-t) — the familiar rise toward a steady state, produced with no characteristic equation in sight.

Cross-check it the other way and the unity of the method shows: Y(s) = H(s) * F(s) = (1/(s + 1)) * (1/s) = 1/(s(s + 1)), which by partial fractions is 1/s - 1/(s + 1), inverting to 1 - e^(-t). Same answer, two roads. That equivalence is not a coincidence — it is the integral-and-product correspondence that the convolution theorem packages. When the input is concrete, partial fractions is usually quicker; when the input is left general or genuinely awkward, the convolution route wins.

Be honest about what convolution does and does not buy you. The formula y = h * f delivers only the part of the response driven by the input — the forced part starting from a system fully at rest. If your problem carries nonzero initial conditions, those contribute their own extra terms from the derivative rule, which you add on separately. Convolution is also clean mainly because we assumed the system is linear and time-invariant; with variable coefficients or nonlinearity, h is no longer a single fixed shape and the simple 'one kick tells all' story breaks down. Within its honest domain, though, it is one of the most powerful single ideas in the whole subject.