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

The Winding Number of the Image Curve

The argument principle has a second face you can literally watch: as the input runs around a loop, the output traces its own curve, and the number of times that curve circles the origin IS the count of zeros minus poles. This guide turns the integral into a picture you can sketch and trust.

From an integral to a curve you can draw

In the last guide we proved the argument principle two ways: with residues, and with the observation that the integral of f'/f measures the total change in arg f around the loop. That second reading ended with a promise — that you could see the count without computing anything — and this whole guide is about cashing that promise. The idea is to stop thinking of f as a formula and start thinking of it as a machine that takes the boundary loop C in the z-plane and bends it into a new closed curve in the w-plane, where w = f(z). Call that new curve f(C), the image curve. Everything the argument principle says is written on the shape of f(C).

Here is the mental movie. Put a pen at the point w = f(z) in the output plane. Now slide z slowly once around the loop C, counterclockwise. The pen moves, and because C is closed and f is continuous, the pen returns exactly to where it started: f(C) is a closed curve too. While the pen travels it may loop, cross itself, swing out wide, pull in tight — but the one number we care about is starkly simple: how many net times did the pen circle the origin w = 0? Counterclockwise loops count +1, clockwise loops count -1, and they add up. That signed total is the winding number of f(C) about 0, and the argument principle says it equals Z - P.

What 'winding number' really counts

Let us pin down the winding number so it stops feeling like hand-waving. Pick a continuous choice of angle theta(t) = arg(f(z(t))) as the parameter t runs from 0 to 1 around C. You cannot just take the principal argument each instant — that jumps by 2 pi whenever the curve crosses the negative real axis. Instead you let theta accumulate honestly, the way a car's trip odometer keeps climbing rather than resetting. Because f(C) returns to its start, the output angle returns to an angle differing from the start by a whole multiple of 2 pi. That multiple is the winding number.

winding number of f(C) about 0
   =  (1 / 2 pi) * [ total continuous change in arg f around C ]
   =  (1 / 2 pi) * (net change in arg f)
   =  (1 / 2 pi i) * integral over C of  f'/f  dz
   =  Z - P
The same number, four ways: an angle swept divided by 2 pi, the net change in argument, the logarithmic-derivative integral, and the count Z - P.

Notice this is the geometric content of the net change in argument divided by 2 pi: arg f returns to itself up to full turns, the number of full turns is the winding number, and 2 pi times that is what the f'/f integral computed. The deep point is that the winding number is an integer — it has to be, because the curve closes up. An integral that on its face could be any complex number is forced, by topology, to be a whole number times 2 pi i. This is one of those moments where complex analysis quietly proves something is an integer without ever counting one by one.

Three pictures, counted by eye

Let C be the unit circle |z| = 1 throughout, and let us read three image curves straight off their shapes. First, f(z) = z. As z = e^(i theta) runs once around, the output is the same point, so f(C) is just the unit circle itself, traversed once counterclockwise. It wraps the origin exactly once: winding number 1, and indeed z has one simple zero at 0 inside, P = 0, so Z - P = 1. The simplest possible loop, the simplest possible count.

Second, f(z) = z^2. Now the output is e^(2 i theta): as z makes one lap of angle 2 pi, w races around twice, sweeping 4 pi. The image curve is the unit circle traced twice. Two loops around 0, winding number 2 — matching the double zero at the origin that we already counted in guide 1. The picture makes the multiplicity visceral: a zero of order m makes the image circle wrap m times, because squaring (or m-th power) speeds the output angle up by a factor of m.

Third, the revealing one: f(z) = z - 2. This has its only zero at z = 2, which is outside the unit circle, so we expect Z - P = 0. Watch the image: as z circles near the origin, w = z - 2 is just that same little circle shifted left to be centred at -2. A small circle around -2 does not enclose the origin at all — the pen orbits a point far to the left and never wraps 0. Winding number 0. The argument principle does not merely tolerate the zero being outside; it detects it, by the image curve refusing to loop. A zero inside makes the curve wind; a zero outside leaves it slack.

Why the count cannot wobble: continuity and degree

An integer that comes from an integral feels fragile — surely a tiny nudge to f changes the integral a tiny bit? It does, but it cannot change the winding number, because that number is an integer and integers cannot drift continuously. Deform f a little, or push the contour C a little, and as long as you never drag a zero or pole across C, the image curve f(C) wiggles but the count of its loops around 0 stays locked. This is homotopy invariance wearing a different hat: continuously deforming the curve without ever letting it pass through the origin cannot change how many times it encircles the origin.

This stability is exactly why the winding number deserves to be called a degree. The map f restricted to the boundary, viewed as taking the loop C to the loop f(C), has a topological degree: an integer that says how many times the target loop is covered, with sign, and that is invariant under continuous deformation. Counting zeros is then a question about this degree, and degree is robust by its very nature. Robustness is not a bonus here — it is the engine of the next guide. If you can wiggle f without changing the count, then two functions that stay close on the boundary must share the same count.

Reading the picture in practice

Here is the whole method as a recipe you can run on a real problem — counting the zeros of a holomorphic f inside a contour C, with no root-finding at all.

  1. Confirm f is holomorphic on and inside C and has no zero on C itself. If it does, the image curve passes through 0 and the winding number is undefined — nudge the contour first.
  2. Parametrize C and feed it through f to get the image curve w = f(z). For a polynomial on a large circle, just track the dominant term — on |z| = R huge, z^n + (lower order) behaves like z^n, which winds n times.
  3. Count the net signed loops of the image curve around the origin — by accumulating the angle, or by counting signed crossings of a fixed ray from 0.
  4. That integer is Z - P. If you arranged P = 0 (f holomorphic), it is the exact number of zeros inside C, multiplicities included — and you never solved an equation.

This image-curve view is not just a pretty restatement; it is the lens for the entire rung. The fact that two functions close on the boundary wind their images the same way is Rouche's theorem, the zero-locating tool of the next guide. The same robustness, applied to small loops around a single point, shows holomorphic maps push open sets to open sets — the open mapping theorem — and forces the maximum principle. Keep the pen-and-origin movie in your head: from here on, 'how many zeros' will almost always mean 'how many times does the image wind', and the answer is something you can sketch.