Visual walkthrough — Fourier analysis — DFT, FFT algorithm (Cooley-Tukey)
Step 0 — The one word we must define first:
WHAT. We will lean on one object again and again, so let us build it before anything else. Take a circle of radius centred at the origin. Mark equally spaced dots on it, starting at the point and going clockwise. Call the first dot after the start (read "omega-sub-N").
WHY clockwise? Because the DFT uses — the minus sign is a clockwise turn. We will see exactly where that minus comes from later; for now just accept the dots go clockwise.
PICTURE. In the figure, the amber dot is . Walking dots around lands you on (multiplying by is "turn one more step"). After dots you are home: . These are the $N$-th roots of unity.

Step 1 — A "pure wave" on points is a dot spinning by fixed steps
WHAT. Fix a frequency (a whole number). Build a list of points by starting at the dot and, at each new sample , jumping dots clockwise. Sample sits at . Collect those points into one object and call it .
WHY. This list is the discrete cousin of and : its horizontal shadow traces a cosine, its vertical shadow a sine. Frequency = "how many dots we jump per sample" = how fast the wave wiggles. These lists are our building blocks — the basis vectors of the parent note.
PICTURE. For , steps one dot per sample (slow spin, slow wiggle); steps two dots per sample (faster). Same circle, different stride. In the figure, follow the cyan curve () — one gentle hump — versus the amber curve () — twice as many wiggles across the same samples.

Step 2 — The DFT asks "how much of each wave is in my data?"
WHAT. Given data , the DFT coefficient measures how strongly wave appears in the data. We compute it by lining each sample up against wave and adding:
WHY the multiply-and-add? This is a projection onto an orthogonal basis. Because the waves are orthogonal (parent Step 2, a Geometric Series argument: ), matching the data against wave picks out exactly wave 's share and cancels every other wave to zero. No solving equations — just a weighted sum.
PICTURE. Think of tuning forks, one per frequency; is how loud fork rings. The figure stacks the grid of weights — colour = the angle of each weight. Read it like this: the top row () is a single flat colour — every weight is , so is just the plain sum. Walk down one row ( grows) and the colours cycle faster across the row: row sweeps through full colour-cycles as runs . The whole grid has coloured cells — that is literally the multiplies the FFT will avoid.

Step 3 — Split the sum: even samples, odd samples
WHAT. Assume is even. Sort the samples by index parity: the even-indexed ones and the odd-indexed ones . Split the one big sum into two:
WHY split by parity? Because — and this is the whole magic — the even part will turn out to be a smaller DFT, and so will the odd part. This is a divide-and-conquer move: solve two half-size copies of the same problem.
PICTURE. The figure combs the data into two shorter rows: the cyan bars are the "even comb" (), the amber bars the "odd comb" (). Notice each comb has exactly teeth — the two half-size problems.

Step 4 — Pull out one twiddle factor from the odd part
WHAT. In the odd sum, the exponent is . Since , the factor does not depend on , so it slides outside the sum:
WHY pull it out? Because once it is gone, both remaining inner sums have the identical weight . Identical structure = we can reuse one sub-routine for both. The lone leftover is called the twiddle factor — a single rotation applied per output.
PICTURE. In the figure the two cyan boxes are the even and odd sums; they now carry the same weight . The amber dot between them is the twiddle — the one rotation pulled out front, sitting in front of the odd box.

Step 5 — The key identity:
WHAT. Look at the shared weight . Group the square: . Now compute :
WHY does this finish the reduction? is the twiddle for a half-size grid. So each inner sum, is literally an -point DFT — of the even samples, of the odd samples. We have turned one size- problem into two size- problems.
PICTURE. In the figure the faint white dots are the big circle; the amber dots are the half-size circle. Stepping around the big circle at double stride (squaring) lands exactly on the amber dots — squaring = skipping every other dot = dropping onto a smaller circle.

Step 6 — The free second half: one sign flip gives two outputs
WHAT. We have for . But and are half-size DFTs, so they only naturally produce values — how do we get outputs ? Ask what happens at . Two facts:
- and repeat with period (a DFT of length wraps around): , same for .
- The twiddle flips sign: , because is the dot exactly half a lap around .
WHY this is the payoff. Put those together:
The two outputs share the same multiply — one costs a , the other a . Two results, one multiplication. This is the butterfly.
PICTURE. In the figure, the two cyan inputs enter on the left; the amber node in the middle is the single multiply ; the crossing lines carry it up (add → top output ) and down (subtract → bottom output ). Those crossing wings are why it is called a butterfly.

Step 7 — Edge & degenerate cases (never leave the reader stranded)
WHAT / WHY / PICTURE, four corners you will hit:
- (base case). A single sample has nothing to combine: . The recursion stops here — this is the "size-1 circle", one lonely dot. Every FFT bottoms out at these.
- odd / not a power of 2. The even–odd split needs even; radix-2 needs . For other you pad with zeros to the next power of two, or use mixed-radix / Bluestein. The picture: you cannot comb an odd row into two equal combs.
- (DC term). Every twiddle is : , just the plain sum (the average ). The "wave" of frequency is a flat line — no wiggle at all.
- (Nyquist). The fastest resolvable wave: it alternates . Here , so . Beyond , indices alias to negative frequencies (parent's last mistake). See Sampling & Aliasing (Nyquist).
PICTURE. The figure overlays the two extreme waves: the cyan flat line is the DC wave (, no wiggle); the amber zig-zag is the Nyquist wave (, fastest possible alternation). Every real frequency lives between these two.

The one-picture summary
Everything above collapses into a single diagram for : two length-2 DFTs (each a single butterfly) feed one layer of twiddles into two output butterflies. Trace through it and you get — the same answer as the brute-force sum, at a fraction of the cost. Read it left to right: the four inputs enter on the left; the first pair of crossings (cyan/amber) produces the half-DFT values in the middle; the second pair of crossings applies the twiddles and add/subtract to give the four outputs on the right.

Recall Feynman retelling (plain words, no symbols)
Picture a wheel with equally spaced pegs. A "wave" is a marker hopping a fixed number of pegs each tick — hop a lot for a fast wave, hop a little for a slow one. The DFT asks, for every possible hop-size, "how much of this wave is hiding in my data?" — by laying the data against that wave and adding up.
Doing that for every wave against every sample is a giant grid of little multiplies — slow. The FFT's trick: split your data into the even-numbered and odd-numbered samples. Because of one clean fact — hopping double-fast on the big wheel is the same as hopping normally on a wheel with half the pegs — each half becomes the same kind of problem, but half the size. Solve those two smaller problems, then stitch: for each pair you spin the odd answer once (the "twiddle"), then add it to get one output and subtract it to get another. Two answers, one spin. That paired add/subtract is the butterfly.
Keep halving — even/odd, even/odd — until each piece is a single number that answers itself. About layers of halving, each layer touching all numbers once. That is why becomes , and why your phone can do a Fourier transform on a photo before you finish blinking.
Recall Quick self-check
What single identity turns each half-sum into a smaller DFT? ::: — squaring the twiddle drops you onto the half-size circle. Why does cost almost nothing extra? ::: , so only the sign of the shared product flips. What are the two outputs of one butterfly? ::: and . Where does the recursion stop? ::: At , where .