Transformations — vertical - horizontal shifts, reflections, stretches - compressions: Visual walkthrough

Before line one, let us agree on the only piece of notation we lean on.

Step 1 — The single dot we will follow

WHAT. Pick one dot on the parent graph and name it $P = (a, f (a))$ .

Read this slowly: $a$ is just some fixed input number (say the machine is fed $2$ ). Then $f (a)$ is the height the machine returns for that input. So $P$ is "at horizontal position $a$ , the graph is $f (a)$ tall."

WHY start with one dot? Because a graph is nothing but its dots. If we can prove where one arbitrary dot goes, and $a$ was arbitrary, then every dot obeys the same rule — the whole curve moves as one.

PICTURE. The parent $f$ in ink, with our chosen dot $P$ circled and its two coordinates measured off the axes.

Figure — Transformations — vertical - horizontal shifts, reflections, stretches - compressions

$P = (fixed input, the horizontal spot a, the height there f (a))$

Step 2 — Edit the OUTPUT: add $k$ (vertical shift)

WHAT. Build a new machine $g (x) = f (x) + k$ . Feed it the same input $a$ : $g (a) = old height f (a) + extra height added k$

So the dot $P = (a, f (a))$ becomes $P^{'} = (a, f (a) + k)$ .

WHY does the picture move up? We touched only the output. The horizontal spot $a$ never changed — the machine still gets $a$ . But whatever height came out, we glue $k$ more on top. Height is vertical position, so the dot climbs by $k$ . Since $a$ was arbitrary, every dot climbs by the same $k$ : the whole curve slides up rigidly (if $k < 0$ it slides down by $∣ k ∣$ ).

PICTURE. The same dot lifted straight up by the arrow of length $k$ ; horizontal position pinned.

Recall

Adding to the output moves the graph which direction? ::: Vertically — up if $k > 0$ , down if $k < 0$ . Horizontal position never changes.

Step 3 — Edit the OUTPUT: multiply by $a$ (vertical stretch, and reflection)

WHAT. Now scale the output: $g (x) = a f (x)$ . (Here $a$ is a multiplier — reusing the letter from the general form; do not confuse it with the input number, which we already spent in Step 1. From here I write the input number as $c$ .) Feed input $c$ : $g (c) = stretch factor a \cdot old height f (c)$ The dot $(c, f (c))$ becomes $(c, a \cdot f (c))$ .

WHY multiplication and not addition here? Addition (Step 2) moves every dot by the same distance — a rigid slide. Multiplication moves each dot by an amount proportional to its own height: a dot twice as high moves twice as far from the $x$ -axis. That is exactly what "stretch away from the axis" means. This is why the tool is $\times$ , not $+$ .

ALL CASES for the factor $a$ :

PICTURE. One panel showing the same curve stretched ( $a = 2$ ), compressed ( $a = \frac{1}{2}$ ), and flipped ( $a = - 1$ ), the fixed $x$ -intercept marked.

Step 4 — Edit the INPUT: replace $x$ by $x - h$ (horizontal shift, the paradox)

WHAT. Now we edit the input: $g (x) = f (x - h)$ . We ask the deciding question — for which $x$ does the new graph do what the old graph did at $c$ ? We need the machine to actually receive $c$ : $x - h = c ⟹ x = c + h$ So the dot that was at horizontal position $c$ now lives at $c + h$ : $(c, f (c)) \to (c + h, f (c))$ .

WHY does subtracting $h$ shift right? Because subtraction happens before the machine sees the number. To hand the machine its favourite input $c$ , you must feed it something $h$ larger, so the subtraction can eat the $h$ back off. You compensate by going right. This is the inside-out paradox — every input edit runs backwards from what the sign suggests.

PICTURE. The dot slides horizontally by $h$ ; height pinned. A "what input does the machine actually receive" tag shows $c$ arriving even though we typed $x = c + h$ .

$what the machine receives x - h = its favourite input c \Rightarrow where you must stand x = c + h$

Step 5 — Edit the INPUT: replace $x$ by $b x$ (horizontal stretch, the counter-intuition)

WHAT. Scale the input: $g (x) = f (b x)$ . Again ask "which $x$ delivers $c$ to the machine?" $b x = c ⟹ x = \frac{c}{b}$ So $(c, f (c)) \to (\frac{c}{b}, f (c))$ — horizontal position divided by $b$ .

WHY does $b > 1$ compress? Division. If $b = 2$ , the dot that lived at $c$ now lives at $c /2$ — closer to the $y$ -axis. Every dot is pulled in by the same fraction, so the whole curve squeezes toward the vertical axis. Bigger $b$ ⇒ smaller landing spot ⇒ tighter squeeze. This is why the effect feels backwards, and it is the same inside-out logic as Step 4.

PICTURE. $cos x$ (period $2 π$ ) beside $cos 2 x$ (period $π$ ): same shape, positions halved.

Step 6 — The degenerate cases we must not skip

WHAT / WHY. A rule is only trustworthy once you've checked the boundaries where it might break.

PICTURE. Left: legal squeeze $b = 2$ . Right: the collapse at $b = 0$ (a flat line) — a visual warning.

Step 7 — Assemble everything: the order is forced by composition

WHAT. Stack all four edits into $g (x) = a f (b (x - h)) + k$ and track our dot $(c, f (c))$ from the inside out, exactly as composition demands (the innermost bracket runs first):

$x - h x - h \times b b (x - h) f f (\dots) \times a a f (\dots) + k a f (\dots) + k$

Following the dot: to get input $c$ into the machine we need $b (x - h) = c$ , so $x = h + \frac{c}{b}$ , and the output becomes $a f (c) + k$ . Net: $(c, f (c)) ⟼ (h + \frac{c}{b}, a f (c) + k)$

WHY this exact order — Shift, Squeeze, Stretch, Shift? The two input edits ( $- h$ then $\times b$ ) live inside the bracket and must respect their nesting: shift first, then scale, or the numbers land wrong. The two output edits ( $\times a$ then $+ k$ ) happen after $f$ fires, and multiplication precedes addition there too. Do them out of order and the compensation arithmetic no longer matches the picture.

PICTURE. The dot's four-arrow journey from parent to final graph, each arrow labelled with its edit.

The one-picture summary

The whole chapter is one migration rule for a single dot: $(c, f (c)) ⟼ (h + \frac{c}{b}, a f (c) + k)$ Inputs edit the left coordinate and run backwards ( $- h$ shifts right, $\div b$ squeezes). Outputs edit the right coordinate and run forwards ( $\times a$ stretches, $+ k$ lifts). See also Inverse Functions, Absolute Value Functions, and Piecewise Functions for parents that carry these same edits.

Recall Feynman retelling — say it like a story

Imagine a machine that eats a number and spits out a height, and you're tracking one bead sitting on the curve. To move the bead up, you add height to whatever comes out — that's $+ k$ . To make it flee the floor, you multiply the height — that's $\times a$ , and if $a$ is negative the bead flips to the other side of the floor. Now the sneaky part: to move the bead sideways, you edit the number before the machine tastes it. If you subtract $h$ inside, you must stand $h$ further right so the machine still receives its favourite number — that's the paradox. And if you multiply the input by $b$ , the bead lands at position-divided-by- $b$ , so a big $b$ crushes the picture inward. Do the inside edits first (shift, then squeeze), then the outside edits (stretch, then shift), because that's the order the machine actually processes them. One bead, four honest edits, and the whole zoo of graphs falls out.