Chain Rule

The formula

For a composite function f(g(x)) — apply g first, then f — the chain rule says:

d/dx [f(g(x))] = f'(g(x)) · g'(x)

In Leibniz notation with y = f(u) and u = g(x):

dy/dx = (dy/du) · (du/dx)

This looks like fraction multiplication, and that's no accident — the chain rule is the result of multiplying difference quotients and taking limits. The notation invites you to "cancel" du, but understand it as a derivation, not a literal cancellation.

Worked examples

Example 1 — Differentiate sin(x²)

Outer — f(u) = sin(u), so f'(u) = cos(u). Inner — g(x) = x², so g'(x) = 2x.

d/dx[sin(x²)] = cos(x²) · 2x = 2x cos(x²)

Example 2 — Differentiate e^(3x)

Outer — f(u) = e^u, f'(u) = e^u. Inner — g(x) = 3x, g'(x) = 3.

d/dx[e^(3x)] = e^(3x) · 3 = 3e^(3x)

Example 3 — Triple composition

Differentiate cos(sin(x²)). Three layers — outer cos, middle sin, inner x².

= −sin(sin(x²)) · cos(x²) · 2x

Each layer contributes one factor — derivative of cos (the −sin), evaluated at sin(x²); times derivative of sin (the cos), evaluated at x²; times derivative of x² (the 2x).

Example 4 — Implicit differentiation

The circle x² + y² = 25. Find dy/dx. Differentiate both sides with respect to x — and use chain rule on y² because y depends on x:

2x + 2y · (dy/dx) = 0
2y · (dy/dx) = −2x
dy/dx = −x/y

So at the point (3, 4) on the circle, the slope is −3/4. We didn't need to solve y = √(25 − x²) explicitly — implicit differentiation handles the curve directly.

Why the chain rule works (proof sketch)

From the limit definition:

(d/dx) f(g(x))
= lim_{h→0} (f(g(x+h)) − f(g(x))) / h

Multiply numerator and denominator by g(x+h) − g(x) (assuming nonzero):

= lim_{h→0} [(f(g(x+h)) − f(g(x))) / (g(x+h) − g(x))] · [(g(x+h) − g(x)) / h]

The first bracket is f's difference quotient at g(x), with input change g(x+h) − g(x). As h → 0, that input change → 0 (g is continuous), so the bracket approaches f'(g(x)). The second bracket is g's difference quotient, approaching g'(x). Product of limits — f'(g(x)) · g'(x).

The case where g(x+h) = g(x) for h near 0 (e.g., g constant) requires a slightly different argument; both cases agree on the same answer.

The multivariable chain rule

For a function f of several variables that themselves depend on t — say f(x(t), y(t)):

df/dt = (∂f/∂x)(dx/dt) + (∂f/∂y)(dy/dt)

The total derivative df/dt is the sum of partial derivatives of f, each weighted by how the corresponding variable changes with t. In matrix form, with vector inputs and outputs, the chain rule says — the Jacobian of the composition is the product of the Jacobians.

This is the form used in machine learning. A neural network is a deep chain of operations; the gradient of the loss with respect to weights is computed by multiplying Jacobians backward through the layers — that's backpropagation in matrix-multiply form.

JavaScript — automatic differentiation

// Forward-mode automatic differentiation using "dual numbers"
class Dual {
  constructor(real, dual = 0) { this.r = real; this.d = dual; }

  static add(a, b) { return new Dual(a.r + b.r, a.d + b.d); }
  static mul(a, b) { return new Dual(a.r * b.r, a.r * b.d + a.d * b.r); }

  static sin(a) { return new Dual(Math.sin(a.r), Math.cos(a.r) * a.d); }
  static exp(a) { const e = Math.exp(a.r); return new Dual(e, e * a.d); }
  static pow(a, n) { return new Dual(a.r ** n, n * a.r ** (n - 1) * a.d); }
}

// Compute f(x) and f'(x) simultaneously
function derivative(f, x) {
  const result = f(new Dual(x, 1));  // dual part = 1 means "differentiate w.r.t. x"
  return { value: result.r, derivative: result.d };
}

// Chain rule applies automatically — every operation propagates derivatives
const f = x => Dual.sin(Dual.pow(x, 2));  // sin(x²)
derivative(f, 1);  // { value: 0.841, derivative: 1.080 } — matches 2 cos(1)

// Real autodiff libraries (autograd, JAX, PyTorch) generalize this for
// gradients of arbitrary code, including loops and conditionals.

Where the chain rule is essential

• Anywhere you need to differentiate a composition. Almost every calculus derivative beyond elementary ones uses chain rule.
• Implicit differentiation. Curves defined by equations rather than explicit y = f(x). Chain rule handles d/dx of expressions involving y.
• Related rates. "How fast is the radius growing if the volume increases at 3 m³/s?" You differentiate the volume formula with respect to time using chain rule on radius(time).
• Backpropagation in neural networks. The gradient of loss with respect to deep weights is a chain of partial derivatives. Gradient descent updates the weights — this is the math under every modern AI training run.
• Multivariable optimization. Gradient of f(x(t), y(t)) requires the multivariable chain rule. Lagrange multipliers, Hamiltonian dynamics, and physics calculations all use it.
• Differential equations. Substitution methods (u-substitution in integrals; change of variables in PDEs) all use chain rule.

Common mistakes

• Forgetting the inner derivative. The most common chain rule bug — writing d/dx[sin(x²)] = cos(x²) instead of cos(x²) · 2x. Always include the derivative of the inner function.
• Wrong evaluation point for the outer derivative. f'(g(x)) means f' evaluated AT g(x), not at x. For sin(x²), it's cos(x²), not cos(x).
• Misidentifying the inner and outer. In sin(x²), sin is outer. In (sin x)², the squaring is outer. Pay attention to which operation is applied last.
• Stopping at the first level for nested compositions. cos(sin(x²)) is three layers; you need three derivative factors. Each layer of nesting adds one term.
• Treating dy/dx as a true fraction in non-trivial cases. For chain rule, the fraction-like manipulation works. But you can't always cancel differentials — d²y/dx² doesn't equal d²y / d(x)² in any meaningful sense.
• Forgetting that y is a function of x in implicit differentiation. When you differentiate y² with respect to x, the answer is 2y · (dy/dx), not 2y. Skipping the chain rule factor breaks the calculation.