A system you can summarize in one object
Across this rung you have used the same rhythm again and again: transform a differential equation, solve the algebra in s, invert. Look at what that machine actually produces for a linear, constant-coefficient system at rest. Transform an equation like y'' + 2 y' + 5 y = x(t), with every initial condition zero, and the derivatives become powers of s with no leftover boundary terms; the equation collapses to (s^2 + 2 s + 5) Y(s) = X(s). Solve for the output and you get Y(s) = X(s) / (s^2 + 2 s + 5). Notice what just happened: the system multiplied the transformed input by one fixed factor and handed back the transformed output.
That fixed factor deserves a name. The transfer function H(s) is the ratio of transformed output to transformed input, Y(s) = H(s) X(s), computed once and for all with the system starting at rest. For our example H(s) = 1/(s^2 + 2 s + 5), and you can read it straight off the coefficients of the differential equation — no solving required. It is the whole input-output personality of the system squeezed into a single ratio of polynomials in s. Feed in any input, multiply by the same H(s), invert, and out comes the response. The transfer function is the s-domain summary of everything the box does.
The impulse response: hit it once and listen
There is a twin of the transfer function that lives back in time, and it has a wonderfully physical meaning. Hit a bell once, sharply, and listen: the tone that rings out and fades is the bell's signature. The mathematical version of that single sharp tap is the unit impulse, the Dirac delta delta(t) — an input of zero duration but unit total strength. Feed delta(t) into a system that starts at rest and the output you get is called the impulse response, written h(t). It is the system's fingerprint: how it rings, decays, or resonates when you poke it once and step back.
Here is the beautiful link. The Dirac delta is the cleanest input of all in the s-domain, because its Laplace transform is just 1 — a flat, featureless spectrum. So when the input is delta(t), the transformed input X(s) equals 1, and Y(s) = H(s) X(s) becomes simply Y(s) = H(s). The transformed impulse response is the transfer function itself. In other words h(t) and H(s) are a Laplace transform pair: the impulse response is the inverse Laplace transform of H(s), and H(s) is the transform of h(t). The same system wears two faces — h(t) in time, H(s) in s — and a single integral relates them.
Why one tap predicts every input
The claim that the impulse response is a *complete* fingerprint sounds too strong. One tap, and you know the response to everything? Yet it is exactly true for linear, time-invariant systems, and the reason is the convolution theorem you met earlier in this rung. In the s-domain the output is the simple product Y(s) = H(s) X(s). The convolution theorem says that multiplying two transforms corresponds, back in time, not to multiplying the functions but to *convolving* them. So the time-domain output is y(t) = integral from 0 to t of h(tau) x(t - tau) d tau.
Read that integral as a story and it stops being mysterious. Think of the input x(t) as a dense train of impulses: in each tiny slice of past time tau, the input delivered a little kick of size x(t - tau). The system's reply to a kick is h, scaled and delayed. The convolution integral simply adds up the system's echoes to every one of those little kicks, each weighted by how big it was and faded by how long ago it landed. That is why the single response h(t) is enough — because linearity lets you build any input out of scaled, shifted impulses, and time-invariance says the system answers each one the same way, just later. The whole prediction reduces to summing echoes.
Poles in the s-plane, and what they tell you
Before we open the inverse transform, look at where the transfer function blows up. For a rational H(s), a ratio of polynomials, the values of s that make the denominator zero are called the poles — points where H(s) shoots off to infinity. For H(s) = 1/(s^2 + 2 s + 5) the denominator factors with roots s = -1 + 2 i and s = -1 - 2 i, so there are two poles sitting in the complex s-plane. These are not algebraic curiosities; their locations encode the system's entire qualitative behavior, and you can read the answer off at a glance.
A pole at s = a means the impulse response contains a term proportional to e^{a t}. So the *real part* of each pole sets the fate of that term. A pole with negative real part, sitting in the left half of the s-plane, gives a decaying e^{a t} — the system settles down. A pole with positive real part, in the right half-plane, gives a growing term — the system is unstable and runs away. And the *imaginary part* sets the ringing frequency. Our two poles at -1 +/- 2 i have real part -1 (so the response decays like e^{-t}) and imaginary part +/- 2 (so it oscillates at frequency 2): the impulse response is a damped sinusoid, e^{-t} times a sine — a struck bell that rings at pitch 2 and fades. The whole story, read off two dots in a plane.
Under the table: the Bromwich integral
All rung we inverted by reading a table backward — split F(s) with partial fractions until each piece matched an entry, then look up the time function. That works, and it is fast, but it is recognition, not definition. What *is* the inverse Laplace transform of an F(s) that appears in no table? There has to be an honest formula that recovers f(t) from F(s) directly, the exact undoing of the defining integral F(s) = integral from 0 to infinity of e^{-s t} f(t) dt. There is, and it is called the Bromwich integral.
Here is the formula, and notice immediately that it lives in the complex plane: f(t) = (1/(2 pi i)) times the integral along the vertical line Re(s) = c of e^{s t} F(s) ds. You integrate up a straight vertical line in the s-plane, from c - i*infinity at the bottom to c + i*infinity at the top, where c is any real number placed to the right of every singularity of F(s) — that is, inside the region of convergence. This vertical path is the Bromwich contour. The factor e^{s t} is the inverse partner of the e^{-s t} that built the forward transform, and the 1/(2 pi i) is the fingerprint of complex contour integration. This is where the Laplace transform stops being real-variable bookkeeping and becomes genuine complex analysis.
Im(s) Bromwich contour: vertical line Re(s)=c,
^ placed RIGHT of every pole of F(s).
| : line Re(s)=c
pole x : --> close to the LEFT with a big arc
| :
-------+--------:------------> Re(s)
| :
pole x :
| :
f(t) = (1/(2 pi i)) * integral_{c - i*inf}^{c + i*inf} e^{s t} F(s) ds
Close left, apply the residue theorem:
f(t) = sum over all poles s = a of Res[ e^{s t} F(s) , s = a ]
Simple pole at s = a -> residue = e^{a t} * (numerator / denominator')|_{s=a}
-> contributes a term proportional to e^{a t}.Closing the contour — and why partial fractions were residues all along
You almost never integrate up that infinite vertical line directly. Instead you use the master trick of complex analysis: close the contour. Bend a giant semicircular arc off to the *left*, joining the top of the line back to the bottom, so the path becomes a closed loop enclosing all the poles of F(s). For t > 0 the factor e^{s t} decays on that left arc — because s there has a large negative real part — and as the arc grows the arc's contribution vanishes (this is a Laplace-flavored Jordan's lemma). What is left is the closed loop, and a closed loop around poles is exactly what the residue theorem was built to evaluate.
The residue theorem says the closed-loop integral equals 2 pi i times the sum of the residues of the integrand at the enclosed poles. The 2 pi i cancels the 1/(2 pi i) out front, leaving the clean statement: f(t) = sum over all poles of the residue of e^{s t} F(s). And here is the payoff that ties this guide to everything before it. At a simple pole s = a, the residue of e^{s t} F(s) is a constant times e^{a t}. So inverting a rational F(s) by residues produces precisely a sum of exponential terms, one per pole — the very same answer the table-and-partial-fractions method gives. Partial fractions, it turns out, were computing residues all along, just dressed in algebra.