Polynomial Functions: Shapes and Behaviors

Learning Objectives

By the end of this section you will be able to:

• Recognise a polynomial the moment you see one — and explain why only non-negative integer exponents are allowed.
• Predict the end behaviour of a polynomial in two seconds, using only the degree $n$ and the leading sign $\operatorname{sgn}(a_n)$.
• Count the maximum possible real roots ($\le n$) and turning points ($\le n - 1$) from the degree alone.
• Read a polynomial in factored form and tell whether each root makes the curve cross, kiss, or flex through the x-axis.
• Evaluate a polynomial in two ways in Python and PyTorch, and explain why Horner's method is what every numerical library actually uses.

The Problem Polynomials Solve

You already know two extreme kinds of functions. Constant functions are rigid — they refuse to change. Linear functions change at a fixed rate. Real systems do neither: a thrown ball speeds up as it falls, a population grows in spurts, the area of a square scales faster than its side length. We need a family of functions that

1. is rich enough to bend — multiple times, in either direction,
2. but is still built entirely from the four arithmetic operations you can do by hand: addition, subtraction, multiplication by a constant, and raising $x$ to a positive integer power,
3. so that every machine, every spreadsheet, every CPU can evaluate it exactly without ever needing to call exp or sin.

That family is the polynomials. They are the workhorse of applied mathematics: linear regression's big brother, the carrier of Taylor approximation (Chapter 13), the bones of every spline used in graphics and CAD, the "safe" non-linearity in classical control theory. If a function can be drawn with a single unbroken pen-stroke that never grows infinitely fast, a polynomial of high enough degree can match it as closely as you like (Weierstrass, 1885).

Intuition. Think of the degree $n$ as a bend budget. A line cannot bend ($n=1$). A parabola can bend once ($n=2$). A cubic can bend twice. The higher $n$ goes, the more turns the curve can make — but never more than $n-1$.

What Counts as a Polynomial

A polynomial in a single variable is any expression of the form

where the coefficients $a_0, a_1, \ldots, a_n$ are real (or complex) constants, the leading coefficient $a_n \neq 0$, and the exponents are non-negative integers. The largest exponent that appears with a non-zero coefficient is the degree $n$.

Anatomy: Degree, Leading Term, Constant

Every polynomial has three landmarks worth naming:

1. The degree $n$ — the highest exponent. It controls everything important: how the curve flies off at the edges, how many roots and turning points it can have, and how fast it grows.
2. The leading coefficient $a_n$ — the multiplier on the highest-degree term. Its sign decides whether the tails point up or down. Its magnitude is the eventual growth rate of the curve.
3. The constant term $a_0$ — the y-intercept: $p(0) = a_0$, because every $x^k$ with $k \ge 1$ dies at $x = 0$.

Interactive — Shape Explorer

Below is a polynomial up to degree five whose every coefficient is on a slider. Try this experiment first: pick the cubic preset $y = x^3 - 3x$, then sweep $a_3$ from $+1$ to $-1$. You will see the curve flip vertically — that single sign change rewrites both tails. Then sweep $a_0$: the whole curve slides up and down without changing shape. The middle coefficients dent and ripple the curve, but the tails refuse to budge.

What to notice. Red dots mark real roots — places where $p(x) = 0$. Amber dots mark turning points — places where the curve momentarily stops going up (or stops going down) and reverses. The widget recomputes both every time you move a slider; the counts honour the bend budget $n - 1$.

End Behavior — The Tails Tell the Truth

Why does the leading term own the tails? Because for large $|x|$, every other term is dwarfed:

Each correction $a_k / (a_n x^{n-k})$ goes to zero because the denominator blows up. So for large $|x|$ the polynomial behaves exactly like $a_n x^n$. That gives the four-way rule:

Roots: Where the Curve Crosses Zero

A root (or zero) of $p$ is any number $r$ for which $p(r) = 0$. Visually it is exactly where the curve meets the x-axis. Two truths govern them, and almost everything else about polynomials follows from these two.

So the root-count is bounded by the degree:

Factored Form & Multiplicity

Whenever we have all the real roots $r_1, r_2, \ldots, r_k$, we can rebuild the polynomial as a product:

where $m_i$ is the multiplicity of root $r_i$ — how many times that linear factor appears. The multiplicities have to add up to the degree: $m_1 + m_2 + \cdots + m_k = n$.

Why multiplicity matters geometrically. Near a root $r$, the polynomial behaves like $C\,(x - r)^{m}$ for some constant $C \neq 0$. The function $(x - r)^{m}$ tells you exactly how the curve approaches zero:

• m = 1 (simple root): $(x-r)$ changes sign when $x$ passes through $r$, so $p$ changes sign — the curve crosses the x-axis transversally, like a line.
• m = 2 (double root): $(x-r)^2 \ge 0$ on both sides, so $p$ does not change sign — the curve touches the axis and bounces back, like a parabola at its vertex.
• m = 3 (triple root): $(x-r)^3$ changes sign but with zero slope — the curve flexes through the axis with a horizontal tangent, like a cubic at the origin.
• Even multiplicities → touch and bounce. Odd multiplicities → cross.

Turning Points — The Bend Budget

A turning point (a local maximum or local minimum) is a place where the curve briefly stops climbing and starts falling, or vice-versa. Between every two distinct real roots of a smooth function, there has to be at least one turning point — otherwise the curve could not get back to zero. So once you know how many roots a polynomial has, you already know a lower bound on its turning points.

The upper bound comes from a fact you will prove in Chapter 4: the turning points of $p$ are exactly the real roots of its derivative $p'$. If $p$ has degree $n$, then $p'$ has degree $n-1$, and by the fundamental theorem can have at most $n-1$ real roots. That is the famous bend budget:

A line has 0 turning points. A parabola has exactly 1. A cubic has 0 or 2 (never just one — they come in pairs of local-max/local-min, or the inflection swallows both). A quartic has 1 or 3. Open the explorer above, switch to degree 5, and try to make a curve with exactly 4 turning points — you can; with 5 — you cannot.

Worked Example — $p(x) = x^3 - 3x$

Let us put every idea above to work on a single cubic. Read first, then open the foldout and finish it with pen and paper before looking at the answers.

Python: Evaluate by Hand vs. Horner's Method

Translating the hand-trace into code does two things. First, it cements the convention you will see in every library: coefficients live in a vector indexed by exponent. Second, it reveals why nobody actually evaluates a polynomial by summing $a_i x^i$ in production — Horner's method is faster and more numerically stable for free.

1# Two ways to evaluate  p(x) = x^3 - 3x  at a point.
2# Coefficients in INCREASING order of power:  a0, a1, a2, a3
3#   a0 = 0     (constant term)
4#   a1 = -3    (coefficient of x)
5#   a2 = 0     (coefficient of x^2)
6#   a3 = 1     (coefficient of x^3)
7coeffs = [0, -3, 0, 1]
8
9def eval_direct(coeffs, x):
10    """Sum every  a_i * x**i  term naively."""
11    total = 0.0
12    for i, a in enumerate(coeffs):
13        total += a * (x ** i)
14    return total
15
16def eval_horner(coeffs, x):
17    """Nested form:  a0 + x*(a1 + x*(a2 + x*a3))  — fewer multiplies."""
18    result = 0.0
19    for a in reversed(coeffs):
20        result = result * x + a
21    return result
22
23# Probe the curve at five points.
24for x in [-2, -1, 0, 1, 2]:
25    print(f"x = {x:>2}   direct = {eval_direct(coeffs, x):>5}   "
26          f"horner = {eval_horner(coeffs, x):>5}")

PyTorch: Polynomials as Vectorised Tensors

The same algorithm scales straight to a tensor. The reason this matters is that polynomials are everywhere in modern machine learning — feature transforms, positional encodings, Chebyshev approximations, the polynomial activation layers explored in Kolmogorov-Arnold Networks (KANs). All of them rely on evaluating one polynomial at many points, fast.

1import torch
2
3# Same polynomial:  p(x) = x^3 - 3x.
4# We will evaluate it at HUNDREDS of x values in one shot.
5coeffs = torch.tensor([0.0, -3.0, 0.0, 1.0])      # [a0, a1, a2, a3]
6xs = torch.linspace(-2.5, 2.5, 11)                # 11 evenly spaced probes
7
8def poly_horner(coeffs: torch.Tensor, x: torch.Tensor) -> torch.Tensor:
9    """Vectorised Horner: works on a SCALAR x or a 1-D batch of x's."""
10    result = torch.zeros_like(x)
11    for a in torch.flip(coeffs, dims=[0]):         # leading coeff first
12        result = result * x + a
13    return result
14
15ys = poly_horner(coeffs, xs)
16for x, y in zip(xs.tolist(), ys.tolist()):
17    print(f"x = {x:+.2f}   p(x) = {y:+.4f}")

Where Polynomials Show Up in the Real World

1. Physics — projectile motion. Height as a function of time is the quadratic $h(t) = h_0 + v_0 t - \tfrac{1}{2} g t^{2}$. The single root in $t > 0$ is the landing time; the unique turning point is the apex. A degree-2 polynomial captures the entire flight.
2. Economics — cost & revenue curves. Total cost of producing $q$ units is often modelled as $C(q) = a_0 + a_1 q + a_2 q^{2} + a_3 q^{3}$: a fixed cost plus marginal costs that rise nonlinearly. Roots of marginal cost (the derivative) give the production sweet spots.
3. Computer graphics — Bézier splines. Every curve in a font, every path in an SVG, every CAD surface is a piecewise polynomial. The smoothness you feel in fonts is built into the fact that consecutive cubic Bézier pieces agree on value and first derivative at their seams.
4. Numerical analysis — Taylor approximation. Any well-behaved function can be approximated, near a point, by a polynomial whose coefficients are the function's derivatives at that point. Polynomials are the universal "local" language of smooth functions — Chapter 13 turns this into a precise theorem.
5. Machine learning — polynomial features. sklearn.preprocessing.PolynomialFeatures simply maps $x \mapsto (1, x, x^{2}, x^{3}, \ldots)$ so that a linear model can fit polynomial relationships. The bend budget you learned today is the same bend budget that controls how much such a model can overfit.

Common Pitfalls

Summary

• A polynomial is a finite sum $p(x) = \sum_{i=0}^{n} a_i x^{i}$ with $a_n \neq 0$ and non-negative integer exponents.
• The degree $n$ caps the number of real roots ($\le n$) and turning points ($\le n - 1$) — your bend budget.
• The leading term $a_n x^{n}$ owns the tails: parity of $n$ + sign of $a_n$ fully determines end behaviour.
• In factored form, the multiplicity of a root tells you whether the curve crosses (odd), bounces (even-2), or flexes (odd-≥3) the x-axis.
• Horner's method is the production algorithm for evaluating polynomials — fewer multiplications, better numerical stability, and identical structure on a CPU loop or a GPU tensor kernel.

Polynomials are the language a calculator can speak fluently. They are also the language in which limits, derivatives, integrals, and Taylor expansion all begin. Master their shape — degree, leading term, roots, multiplicity, turning points — and the next ten chapters will feel like reading prose instead of decoding hieroglyphs.