Why does a product's rate need both factors?

The product plane shows $u\cdot v$ as the area of a rectangle with sides $u(x)$ and $v(x)$. When $x$ grows by $\Delta x$, the area gains a blue strip $v\,\Delta u$, a green strip $u\,\Delta v$ and a small corner $\Delta u\,\Delta v$. The inspector confirms that these three pieces add up exactly to the change of the product. Now choose Quotient with v(x) = 0: there is no value, no tangent and no rule result at that $x$.

Intuition: a rate is a sensitivity

$u'(x)$ says how fast $u$ changes per unit of $x$. In a sum $u+v$, the two changes simply add. In a product, a change in $u$ matters more when the other factor $v$ is large: a 1-unit wider rectangle gains area equal to its height. Each factor’s rate is weighted by the other factor’s value.

Definition

For differentiable $u$, $v$ and constants $\alpha$, $\beta$:

and, wherever $v(x)\ne0$,

Mechanics: what the explorer computes

The factors have rational coefficients, so every value is exact. The rule row applies the formula above. The check row reaches the same derivative independently: for sums and products by expanding the polynomial first and differentiating term by term; for a quotient $q=u/v$ by differentiating the identity $u=q\,v$ with the product rule. The agreement row is an exact rational comparison. Where $v(x)=0$, the quotient is undefined and every row says so.

Derivation: the product rule from area

Let $\Delta u=u(x+\Delta x)-u(x)$ and $\Delta v=v(x+\Delta x)-v(x)$. Then exactly

Divide by $\Delta x$:

As $\Delta x\to0$, the two quotients tend to $u'$ and $v'$, while $\Delta u\to0$ because a differentiable $u$ is continuous. The corner term disappears, leaving $u'v+uv'$.

Quotient. If $q=u/v$ and $v\ne0$, then $u=qv$, so $u'=q'v+qv'$ and

This derivation divides by $v$; it is meaningless where $v=0$.

Worked example

Take $u=x+1$, $v=x^2+1$ at $x=1$. Then $u=2$, $v=2$, $u'=1$, $v'=2$.

• Product: $(uv)'=1\cdot2+2\cdot2=6$. Expanding first, $uv=x^3+x^2+x+1$ has derivative $3x^2+2x+1=6$.
• Quotient: $(u/v)'=(1\cdot2-2\cdot2)/2^2=-1/2$.

With $\Delta x=1/2$: $u$ grows to $2.5$ and $v$ to $3.25$. The area changes by $8.125-4=4.125$, which is $v\Delta u=1$ plus $u\Delta v=2.5$ plus $\Delta u\Delta v=0.625$.

Domains and failures

A quotient rule result exists only where the quotient itself exists. For $v=x^2-1$ the quotient $u/v$ is undefined at $x=\pm1$. At $x=-1$ with $u=x+1$, cancelling $x+1$ removes a hole, but the derivative at $-1$ still does not exist in the original function, because the original function has no value there. The explorer draws dashed caution lines where $v$ vanishes.

Executable reference code

The reference checks the product and quotient rules against expansion with Fraction and raises an error where the denominator is zero. The NumPy version differentiates polynomial products with numpy.polynomial and masks points where a quotient is undefined.

"""Product and quotient rules checked against expansion, with exact Fractions (III.5)."""
from fractions import Fraction as F


def poly_eval(c, x):
    return sum(ck * x**k for k, ck in enumerate(c))


def poly_mul(a, b):
    out = [F(0)] * (len(a) + len(b) - 1)
    for i, x in enumerate(a):
        for j, y in enumerate(b):
            out[i + j] += x * y
    return out


def poly_der(c):
    return [k * ck for k, ck in enumerate(c)][1:]


u, v = [F(1), F(1)], [F(1), F(0), F(1)]          # u = x + 1, v = x**2 + 1
x = F(1)
product_rule = poly_eval(poly_der(u), x) * poly_eval(v, x) + poly_eval(u, x) * poly_eval(poly_der(v), x)
assert product_rule == poly_eval(poly_der(poly_mul(u, v)), x) == 6


def quotient_rule(u, v, x):
    vx = poly_eval(v, x)
    if vx == 0:
        raise ZeroDivisionError("v(x) = 0: u/v and its derivative are undefined")
    return (poly_eval(poly_der(u), x) * vx - poly_eval(u, x) * poly_eval(poly_der(v), x)) / vx**2


assert quotient_rule(u, v, x) == F(-1, 2)
try:
    quotient_rule(u, [F(-1), F(0), F(1)], F(1))     # v = x**2 - 1 vanishes at 1
except ZeroDivisionError:
    pass
else:
    raise AssertionError("the quotient rule must not apply where v = 0")

"""Rules with numpy.polynomial: products differentiate like expansions; quotients are masked where v = 0 (III.5)."""
import numpy as np
from numpy.polynomial import Polynomial as P

u, v = P([1, 1]), P([1, 0, 1])
x = np.linspace(-2, 2, 9)
assert np.allclose((u * v).deriv()(x), u.deriv()(x) * v(x) + u(x) * v.deriv()(x))

w = P([-1, 0, 1])                                  # x**2 - 1: zero at +-1
valid = w(x) != 0
q_prime = (u.deriv()(x[valid]) * w(x[valid]) - u(x[valid]) * w.deriv()(x[valid])) / w(x[valid]) ** 2
assert valid.sum() == len(x) - 2 and np.all(np.isfinite(q_prime))

Explore

Make $u$ negative with Negative factor: the area picture still balances, with signed strips. Set $a=0$ so $u$ is constant: the product rule reduces to $(\text{constant}\cdot v)'=\text{constant}\cdot v'$. In quotient mode, move $c$ below zero and slide $x$ toward a root of $v$.

Common mistakes

$(uv)'\ne u'v'$: try $u=v=x$. In the quotient rule, the order $u'v-uv'$ matters. A rule result is not valid at points where the function is undefined, even if the formula’s numerator looks harmless.

Numerical considerations

These rules are exact identities; numerical issues appear only in evaluation. A quotient near a zero of $v$ divides by a tiny number, amplifying any error in $u$ or $v$; the derivative $u'v-uv'$ over $v^2$ amplifies even more. Exact arithmetic sidesteps this here; floating-point code should check how close $v$ is to zero.

Engineering and ML connections

Automatic differentiation (III.10) applies exactly these local rules — sum, product, quotient — at every node of a computation. Normalisations such as softmax or layer normalisation contain quotients, and their derivatives inherit the same domain restrictions near a vanishing denominator.

Exercises

Summary and checkpoints

Derivatives are linear; a product’s rate weights each factor’s rate by the other factor’s value; a quotient’s rule follows from the product rule and holds only where the denominator is nonzero. Next, III.6 handles functions of functions: the chain rule.