A sequence of numbers, secretly a function
In the previous guide we saw the Bromwich contour invert a Laplace transform — the continuous-time story. Now switch to the world of computers, where a signal is not a smooth function of time but a sequence: a stream of samples x_0, x_1, x_2, ... arriving one per clock tick. This is the home of digital audio, control loops, and every filter inside your phone. We need a tool that does for sequences what the Laplace transform did for functions, and it turns out to be something you already understand deeply: a power series.
The z-transform of a sequence x_n is defined as the sum X(z) = sum x_n z^(-n), taken over the relevant range of n. Notice the negative power: z^(-n), not z^n. So a sequence becomes a series in 1/z, which is exactly a Laurent series — the two-sided power series you met when classifying singularities. The samples x_n are nothing but the Laurent coefficients of X(z). A signal and a complex function are, quite literally, two views of the same object.
The region of convergence is an annulus
A Laurent series does not converge everywhere — it converges in an annulus, a ring r < |z| < R. The same is true here, and engineers give this ring its own name: the region of convergence, or ROC. Where does the ring come from? The terms with positive n (the past and present samples, x_0 z^0 + x_1 z^(-1) + ...) are powers of 1/z; they converge when |z| is large enough, giving an outer condition |z| > r. Any terms with negative n are honest powers of z and converge when |z| is small enough, giving |z| < R. Put together, exactly the annulus of convergence you already know.
This is not a footnote — it is the whole subject in miniature. The same formula X(z) can have several different annuli on which it converges, and each one corresponds to a different sequence x_n. A causal signal (one that is silent before time zero) lives outside a disk; an anticausal one lives inside; a two-sided one lives in a true ring between two radii. So you cannot invert a z-transform from its formula alone: you must also be told the ROC. The algebra fixes the poles; the ring tells you which side of each pole you are on.
X(z) = sum_{n>=0} a^n z^(-n) = 1 / (1 - a z^(-1)) = z / (z - a)
pole at z = a ROC: |z| > |a| -> x_n = a^n for n >= 0 (causal)
same formula ROC: |z| < |a| -> x_n = -a^n for n < 0 (anticausal)Poles and the unit circle decide stability
Now the payoff. A filter is stable in the engineer's sense — bounded inputs produce bounded outputs, with nothing running away to infinity — exactly when its impulse response x_n is absolutely summable, sum |x_n| < infinity. From our toy example x_n = a^n, that sum is finite precisely when |a| < 1. The geometric sequence decays when its pole sits inside the unit circle |z| = 1, and explodes when the pole sits outside. The behaviour of a whole signal in time is read off from the position of a single point in the plane.
For a causal filter this sharpens into one of the cleanest rules in all of engineering: a causal system is stable if and only if every pole of its transfer function lies strictly inside the unit circle. The unit circle |z| = 1 is the boundary between order and chaos. (This is the z-plane cousin of the continuous-time rule, where stability means every pole has negative real part — lying in the left half-plane. The conformal map sending the left half-plane to the unit disk is exactly what carries one rule into the other.)
The transfer function and reading it off
Most useful filters are described by a recurrence: the new output is a weighted mix of recent inputs and recent outputs, like y_n = x_n + 0.5 y_(n-1). Taking the z-transform turns every 'delay by one tick' into a factor of z^(-1), so the recurrence becomes a plain algebraic equation, and solving for the ratio Y(z)/X(z) gives a rational function H(z). This is the transfer function — a ratio of polynomials whose roots of the denominator are the poles and whose roots of the numerator are the zeros. The differential-equation-into-algebra trick that made the Laplace transform so powerful works identically here.
Once you have H(z) as a rational function, recovering the impulse response is a contour integral. The inverse z-transform is x_n = (1 / 2 pi i) times the integral of X(z) z^(n-1) dz around a circle inside the ROC, and that integral is evaluated by the residue theorem — you simply sum the residues at the poles enclosed by the circle. This is the discrete echo of the Bromwich contour from the last guide: there you ran up a vertical line, here you run around a circle, but in both cases the residues at the poles ARE the time-domain answer.
- Write the filter's recurrence, e.g. y_n = x_n + 0.5 y_(n-1), and z-transform it: Y(z) = X(z) + 0.5 z^(-1) Y(z).
- Solve for the transfer function: H(z) = Y(z)/X(z) = 1 / (1 - 0.5 z^(-1)) = z / (z - 0.5).
- Find the pole: z = 0.5. Since |0.5| < 1, the pole is inside the unit circle, so the causal filter is stable.
- Invert by residues to read the impulse response: x_n = (0.5)^n for n >= 0 — a gentle decaying echo, exactly what a stable pole inside the circle should give.
Counting encirclements: the argument principle returns
How would you check stability when H is too tangled to factor by hand, or when a feedback loop changes the poles? You count, and the counting tool is one you already own. The argument principle says that as z traverses a closed contour, the number of times the image curve H(z) winds around the origin equals (zeros inside) minus (poles inside). Feed the contour around the unit circle through the loop's open-loop function and watch how many times the output encircles a critical point. This is the Nyquist criterion, and it is nothing more than the argument principle wearing an engineer's hat.
The picture is wonderfully concrete. The closed-loop system is unstable exactly when the open-loop response, plotted as a curve in the plane as the frequency sweeps round the unit circle, encircles the critical point the wrong number of times. No factoring, no solving — just watch a curve and count its turns around a point, the same winding-number idea that powered Rouche's theorem back in the argument-principle rung. A whole stability question collapses to: how many times does this loop go around that dot?