Combining and Composing Functions Advanced. This lesson goes beyond core Algebra I. You can skip it.

Building new functions by arithmetic

Suppose two functions share the same input. Say $f(x) = 3x$ gives the distance in meters that one runner has covered after $x$ seconds, and $g(x) = x + 2$ gives a second runner’s distance, starting from a two-meter head start. At any moment $x$ you can ask about the two runners together: their combined distance is $f(x) + g(x)$, and the difference between their positions is $f(x) - g(x)$. Nothing exotic is happening. You evaluate each function at the same input, then combine the two outputs with ordinary arithmetic. That one idea defines four brand-new functions:

Read the left side of each line as the name of a single new function. The symbol $f + g$ is one function whose rule is “evaluate $f$, evaluate $g$, and add the results.” To find its output at any input, you do exactly that.

The first three combinations accept every input that both $f$ and $g$ accept, so they need no special care. The quotient is the one that does. You already know that division by zero is undefined, so the fraction $\dfrac{f(x)}{g(x)}$ has no value at any input where the denominator $g(x)$ equals zero. Those inputs have to be thrown out, even when $f$ and $g$ are both perfectly happy there. So the quotient $\dfrac{f}{g}$ is defined wherever $f$ and $g$ are both defined and, on top of that, $g(x) \neq 0$: it carries the same requirement as the other three combinations, plus one extra ban. This is not a new rule to memorize; it is the old ban on dividing by zero, now applied to the output of $g$.

Composing: feeding one function into another

Combining with arithmetic keeps the two functions side by side. Composition instead stands them in a line. Picture a small factory with two machines. The first machine takes your raw input and produces a part; the second machine takes that part and finishes it. The output of the first becomes the input of the second.

Make it concrete with $g(x) = x + 4$ and $f(x) = x^2$. Start with an input, say $3$. Run $g$ first: $g(3) = 3 + 4 = 7$. Now take that result, $7$, and run it through $f$: $f(7) = 7^2 = 49$. The end product of the two-step process is $49$. Written on one line, this is $f(g(3))$: the inner function $g$ acts on $3$, and $f$ acts on whatever $g$ hands it.

This two-step operation is composition, and it has its own symbol. The composition of $f$ and $g$ is written $f \circ g$ (read ”$f$ composed with $g$,” or ”$f$ after $g$”), and it is defined by

The little ring $\circ$ is not multiplication and not the letter o; it is the composition sign. The right-hand side, $f(g(x))$, is the form you actually calculate with.

Notice how different this is from the product $fg$ from the last section. The product runs $f$ and $g$ side by side on the same input and multiplies the two outputs. Composition runs them in a chain: $g$‘s output becomes $f$‘s input. For $f(x) = x + 1$ and $g(x) = 2x$ at $x = 3$, the product is $(fg)(3) = f(3) \cdot g(3) = 4 \cdot 6 = 24$, but the composition is $(f \circ g)(3) = f(g(3)) = f(6) = 7$. Same two functions, same input, two very different answers.

Which function runs first? The nested notation answers the question on its own. In $f(g(x))$ the input $x$ is wrapped inside $g$, and $g(x)$ then sits inside the parentheses of $f$. Just as with nested parentheses in arithmetic, you work from the inside out: whatever is deepest gets evaluated first. So $g$ runs first on the raw input, and $f$ runs second on $g$‘s output. The inner function, the one written closest to the input, always goes first, even though in the name $f \circ g$ it is written second.

Finding a formula for a composition

Evaluating at one input is fine, but usually you want a single formula for $f \circ g$ that works at every allowed input at once, that is, every input that survives both steps of the composition. The recipe is the substitution you have used since your first algebra lesson. To build $f(g(x))$, take the entire rule for $g(x)$ and drop that rule into $f$ wherever $f$ expects its input.

Order matters: a composition is not commutative

Look back at the last two worked examples. In both, swapping the order changed the answer: $f(g(3)) = 49$ but $g(f(3)) = 13$, and the formula $f(g(x)) = x^2 + 8x + 16$ against $g(f(x)) = x^2 + 4$. This is not a fluke of one example. Composition is not commutative: in general $f \circ g$ and $g \circ f$ are different functions, and reversing the order usually changes the result. This is the single most important idea in the lesson, so it is worth understanding why it happens rather than just noting that it does.

The reason is exactly the assembly-line picture. In $f \circ g$ the last machine to touch the number is $f$, so the final answer is always something $f$ produced. In $g \circ f$ the last machine is $g$, so the final answer is always something $g$ produced. For these two functions $f$ and $g$ do different jobs, one squares and one shifts, so the two lines hand you different products. Squaring and then adding four is not the same as adding four and then squaring: $g(f(x)) = x^2 + 4$ puts the four in at the very end. By contrast, $f(g(x)) = (x + 4)^2$ adds the four first and then squares the whole thing, which spreads the four through the extra middle term $8x$. The four enters at a different stage, and the machine that comes after it treats it differently.

The domain of a composition

Because a composition runs in two steps, an input has to survive both to be allowed through. Here is a case where that catches an input by surprise.

That is not a coincidence of these two particular functions; the same two-step test decided the outcome for $4$ above, and it decides every composition’s domain. Here is that test stated exactly.

Composition models a two-step process

Composition is not just a symbol game. Any time one quantity depends on a second, which in turn depends on a third, you have a composition waiting to be written down. Discounts followed by fees, readings passed through a converter, a shape whose size grows with time: each is one function feeding the next.

Common mistakes