Why one family of systems gets all the love
In rung 1 you met signals — the things that flow through wires and air. A system is whatever sits in the middle and transforms one signal into another: an amplifier, a filter, a guitar pedal, a cruise-control loop, even a concrete bridge swaying in the wind. Feed in a signal x, get out a signal y. The whole game of engineering is predicting that y. The bad news: in full generality, that game is unwinnable. A system can be nonlinear, can change its behaviour by the second, can depend on its entire history in tangled ways. There is no tidy formula for an arbitrary box.
The good news is that an astonishing slice of the engineered world is — at least over a useful operating range — well-described by systems with two tame properties: linearity and time-invariance. Put them together and you get the LTI system, the single most important object in all of signals and systems. LTI systems are tame enough that one number-crunch tells you everything, yet rich enough to model amplifiers, RC circuits, antennas, control loops, audio reverb, and the propagation of light through glass. Master them and a huge fraction of electrical engineering suddenly clicks into place.
Linearity = scaling + adding, with no surprises
Linearity is the promise that the system never surprises you when you combine inputs. It has two halves, and together they are called superposition. First, homogeneity (scaling): if input x produces output y, then turning the input up by a factor a gives exactly a·y — twice the input, twice the output, no more and no less. Second, additivity: if x₁ gives y₁ and x₂ gives y₂, then feeding x₁ + x₂ at the same time gives exactly y₁ + y₂ — the two inputs pass through without interfering, fighting, or breeding new frequencies.
Why does this matter so much? Because if a system is linear, you can break any messy input into a sum of simple pieces, run each simple piece through the system on its own, and just add up the answers. Hard problems dissolve into easy ones. This is exactly the logic behind the superposition theorem you may have seen for resistor networks — and here it is promoted into a defining property of an entire class of systems.
Time-invariance = the system doesn't care what time it is
The second superpower is time-invariance, and it is even easier to picture. A system is time-invariant if delaying the input simply delays the output by the same amount, with the *shape* of the response unchanged. Knock on a wooden door today and it goes "thunk"; knock the identical knock tomorrow and you get the identical "thunk", just shifted to tomorrow. The door's behaviour does not depend on what o'clock it is. Formally: if x(t) → y(t), then x(t − τ) → y(t − τ) for every shift τ.
What breaks time-invariance? Anything whose rule explicitly mentions the clock — a coefficient that drifts with time, a gain you ramp up, a multiply-by-t. A circuit whose components are slowly heating up is, strictly, time-varying; so is an amplifier whose battery is draining. We usually ignore those slow drifts because over the milliseconds that matter, the system is *effectively* time-invariant. As with linearity, time-invariance is a deserved approximation, not a free gift.
Two worked tests: pass and fail
Theory is cheap; let's actually test two innocent-looking systems. The recipe is mechanical, and worth memorizing: for linearity, push a scaled-and-summed input through, then compare against the scaled-and-summed outputs. For time-invariance, delay the input, then check whether the output is just the delayed original. First victim: the discrete-time system y[n] = 2·x[n] + 3. It looks linear — there's a multiply and an add — but watch what the constant does.
SYSTEM A: y[n] = 2*x[n] + 3 <- the sneaky +3
LINEARITY TEST (does scaling pass through?)
let a = 2.
scale input first: x'[n] = a*x[n] = 2*x[n]
-> system gives: 2*(2*x[n]) + 3 = 4*x[n] + 3
scale output instead: a*y[n] = 2*(2*x[n] + 3) = 4*x[n] + 6
4*x[n] + 3 != (NOT) 4*x[n] + 6 <-- mismatch of 3
=> homogeneity FAILS => NOT linear.
(The +3 is an output even when x = 0. A linear system
must obey "zero in -> zero out". This one doesn't.)
VERDICT: affine, not linear -> NOT an LTI system.
(It IS time-invariant -- no 'n' in the coeffs --
but you need BOTH, so it's still out.)Now a continuous-time example that fails the *other* test: y(t) = t·x(t), a system that multiplies the input by time itself. Is it linear? Yes — scale x and the output scales; add two inputs and the outputs add, because t is just a fixed multiplier at each instant. But is it time-invariant? Let's delay and see.
SYSTEM B: y(t) = t * x(t)
TIME-INVARIANCE TEST (does a delay just delay the output?)
Path 1 -- delay the OUTPUT by tau:
y(t - tau) = (t - tau) * x(t - tau)
Path 2 -- delay the INPUT by tau, then run the system:
feed x(t - tau) -> system multiplies by t
-> t * x(t - tau)
Compare: (t - tau)*x(t-tau) vs t*x(t-tau)
differ by tau*x(t-tau) != 0 in general
=> the two paths DISAGREE => NOT time-invariant.
VERDICT: linear, but time-VARYING -> NOT an LTI system.
(The multiplier 't' literally is the clock,
so the system's behaviour depends on when
the signal arrives.)The payoff: one tap reveals everything
Here is where the bookkeeping pays off spectacularly. Suppose your system passed both tests — it is LTI. Now feed it the sharpest, simplest poke you can imagine: an impulse, a single infinitely-brief spike, written δ. What comes out is called the impulse response, named h. It is the system's signature, its fingerprint, the sound it makes when you flick it once. And the staggering claim of LTI theory is this: h is all you ever need to know. Tell me h, and I can predict the output for *any* input you will ever apply — a sine wave, a song, a noisy sensor reading, anything.
- Decompose. By linearity, chop any input signal into a dense train of tiny scaled impulses — one impulse per instant, each weighted by the input's value there.
- Shift. By time-invariance, each delayed impulse produces the *same* response h, just slid to its own arrival time. One fingerprint, copied and shifted.
- Superpose. Add up all those shifted, scaled copies of h. That grand sum *is* the output — and the operation has a name: convolution, written y = x ∗ h.
Read those three steps again: decompose, shift, superpose. Step 1 leans on linearity, step 2 leans on time-invariance, and step 3 is the addition that only linearity permits. Convolution is not an arbitrary formula handed down from on high — it is the *direct logical consequence* of the two properties you just learned to test for. The next rung builds the convolution machine in full; for now, simply hold the headline: for an LTI system, the impulse response is a complete description. That single curve h captures gain, delay, ringing, smoothing — the entire personality of the box.