Signals and Systems: Time-Domain Analysis

Time-domain analysis is one of the most practical ways to understand how a system transforms an input signal into an output. Instead of focusing on frequency content, you work directly with how signals evolve over time and how a system responds to changes, pulses, and sustained inputs. At the center of this viewpoint is the convolution integral, which ties together three core ideas: the input signal, the system’s impulse response, and the resulting output.

This article builds a clear path through convolution, impulse response, and the key properties of linear time-invariant (LTI) systems, with an emphasis on how engineers actually use these tools.

Why the time domain matters

Many real systems are naturally described in time. A microphone converts air pressure changes into voltage; a suspension system reacts to bumps; a communications channel smears pulses due to multipath; a digital filter processes samples one moment at a time. In each case, the main questions are time-based:

• If the input changes suddenly, does the output overshoot or lag?
• How long does the system “remember” past inputs?
• Will a pulse stay sharp or spread out?
• Can we predict the output for any input once we know the system?

For LTI systems, the answer to that last question is yes, and the mechanism is convolution.

LTI systems and their defining properties

An LTI system is characterized by two assumptions:

Linearity

A system is linear if it satisfies superposition: scaling and addition commute with the system. If input $x_1(t)$ produces output $y_1(t)$ and input $x_2(t)$ produces output $y_2(t)$, then for any constants $a$ and $b$,

$$a{x}_1(t)+b{x}_2(t)\to a{y}_1(t)+b{y}_2(t).$$

Linearity is what makes decomposition strategies work. You can break a complicated input into simpler pieces, process each piece, then add the results.

Time invariance

A system is time-invariant if shifting the input in time shifts the output by the same amount. If $x(t)\to y(t)$, then $x(t-t_0)\to y(t-t_0)$.

Time invariance implies the system’s behavior does not depend on when an input is applied. A pulse today and the same pulse tomorrow produce the same shaped response, just shifted.

Together, these two properties allow a single function, the impulse response, to fully describe the system.

Impulse response: the system’s fingerprint

The impulse response, commonly written as $h(t)$, is the output of an LTI system when the input is a unit impulse $\delta (t)$. The impulse $\delta (t)$ is an idealized signal with two essential properties:

1. It is zero everywhere except at $t=0$ (in a distributional sense).
2. Its area is 1: ${\int }_{-\infty }^{\infty }\delta (t)dt=1$.

The impulse matters because it acts like a “probe” of the system. If you know how the system responds to an impulse, you can compute its response to any input by assembling that input from shifted and scaled impulses.

A useful related concept is the step response, the output to the unit step $u(t)$. For many physical systems, the step response is easier to measure directly. In continuous time, the step response is the integral of the impulse response:

$$s(t)={\int }_{-\infty }^{t}h(\tau )d\tau ,$$

and conversely $h(t)$ is the derivative of $s(t)$ when the derivative exists.

The convolution integral in continuous time

For a continuous-time LTI system with input $x(t)$ and impulse response $h(t)$, the output $y(t)$ is given by the convolution integral:

$$y(t)=(x\ast h)(t)={\int }_{-\infty }^{\infty }x(\tau )h(t-\tau )d\tau .$$

This expression says: to find the output at time $t$, look at all past (and, mathematically, all) times $\tau$, take the input value at $\tau$, weight it by how the system responds after a delay of $t-\tau$, and integrate.

How to interpret convolution

Convolution is often described as “flip, shift, multiply, and integrate,” because $h(t-\tau )$ is a time-reversed version of $h(\tau )$ shifted by $t$ when viewed as a function of $\tau$. But the more engineering-focused interpretation is this:

• $h(t-\tau )$ represents the contribution at time $t$ from an impulse that occurred at time $\tau$.
• $x(\tau )$ tells you how strongly that impulse is “present” at time $\tau$ when expressing the input as a continuum of scaled impulses.
• The integral sums all those contributions.

In practical terms, convolution formalizes memory. If $h(t)$ is short in duration, the system has short memory. If $h(t)$ decays slowly, the system’s past persists longer in the output.

A simple example: impulse response as a smoothing kernel

If an LTI system has an impulse response that is a short, positive bump centered near zero, then convolution tends to smooth the input. Sharp changes in $x(t)$ get averaged across the support of $h(t)$. This is exactly how many low-pass filters behave in the time domain: their impulse responses spread energy over time, reducing rapid fluctuations.

Conversely, if $h(t)$ has oscillations, the output may show ringing after abrupt inputs, a common time-domain signature of resonant systems.

Discrete-time convolution

In discrete time, signals are sequences $x[n]$ and $h[n]$, and convolution becomes a sum:

$$y[n]=(x\ast h)[n]=\sum _{k=-\infty }^{\infty }x[k]h[n-k].$$

The interpretation is the same: each input sample contributes to future output samples according to the system’s impulse response, and the output at index $n$ is the weighted sum of all shifted impulse responses.

This form underlies digital filtering. A finite impulse response (FIR) filter is one where $h[n]$ is nonzero only for a finite set of indices, turning the convolution sum into a finite computation window.

Core convolution and LTI properties you should know

Once you accept $y=x\ast h$, a number of powerful properties follow. These are not abstract trivia; they are practical tools for analysis and design.

Commutativity

$$x\ast h=h\ast x.$$

You can think of filtering as either “input through the system” or “system through the input.” Mathematically it does not matter, though conceptually you typically treat $h$ as fixed.

Associativity

$$x\ast (h_1\ast h_2)=(x\ast h_1)\ast h_2.$$

Cascading two LTI systems with impulse responses $h_1$ and $h_2$ produces an equivalent single LTI system with impulse response $h_1\ast h_2$. This is crucial for building complex systems from simpler stages and for replacing multi-stage filters with a single equivalent response.

Distributivity

$$x\ast (h_1+h_2)=x\ast h_1+x\ast h_2.$$

Parallel paths add. If you split a signal into two LTI systems and sum the outputs, the equivalent impulse response is the sum of the impulse responses.

Causality and stability in the time domain

Two system properties are especially important in real-world implementations.

Causality

A causal system cannot respond before the input is applied. In time-domain terms, an LTI system is causal if and only if

• Continuous time: $h(t)=0$ for $t<0$
• Discrete time: $h[n]=0$ for $n<0$

This provides an immediate check: if an impulse response has nonzero values at negative time, the system requires “future” input information and is not physically realizable in real-time.

BIBO stability

Bounded-input bounded-output (BIBO) stability means every bounded input produces a bounded output. For LTI systems, BIBO stability is determined entirely by the impulse response:

• Continuous time: ${\int }_{-\infty }^{\infty }|h(t)|dt<\infty$
• Discrete time: ${\sum }_{n=-\infty }^{\infty }|h[n]|<\infty$

This criterion connects directly to convolution: the output is a weighted accumulation of input values, so the weights must be absolutely summable (or integrable) to prevent unbounded growth from bounded signals.

Practical workflow: using convolution for time-domain analysis

When you analyze an LTI system in the time domain, a reliable process looks like this:

1. Identify or measure __MATH_INLINE_59__ or __MATH_INLINE_60__. In modeling, you may derive it. In experiments, you may estimate it from data.
2. Check causality and stability from the impulse response. This quickly tells you whether a real-time implementation is feasible and whether outputs will remain well-behaved.
3. Compute the output via convolution. For hand analysis, you often exploit symmetry, finite support, or known convolution pairs. In practice, you compute numerically (direct convolution in time or faster