Curl and Divergence

Learning Objectives

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

1. Compute divergence and curl of vector fields in 2D and 3D using their component formulas
2. Interpret divergence physically as measuring sources, sinks, and incompressibility in fluid flows and other physical systems
3. Interpret curl physically as measuring local rotation and the axis of that rotation in 3D
4. Apply fundamental vector calculus identities, including $\nabla \times (\nabla f) = \mathbf{0}$ and $\nabla \cdot (\nabla \times \mathbf{F}) = 0$
5. Connect curl and divergence to integral theorems: Green's Theorem, Stokes' Theorem, and the Divergence Theorem

Why This Matters: Curl and divergence are the fundamental differential operators of vector calculus. They appear in Maxwell's equations of electromagnetism, the Navier-Stokes equations of fluid dynamics, and throughout physics and engineering. In machine learning, understanding these operators helps with normalizing flows, score-based diffusion models, and physics-informed neural networks.

The Big Picture

Vector fields are everywhere in nature: velocity fields of fluids, electric and magnetic fields, gravitational fields, and gradient fields in optimization. To understand these fields deeply, we need tools to measure their fundamental properties at each point.

Two questions arise naturally:

1. Is there a source or sink here? Does the field expand outward or contract inward at this point? This is what divergence measures.
2. Is there rotation here? Does the field curl around this point, and if so, in what direction? This is what curl measures.

Historical Context

The concepts of divergence and curl emerged in the 19th century from the work of physicists and mathematicians trying to understand electromagnetism and fluid dynamics.

James Clerk Maxwell (1831-1879) unified electricity, magnetism, and light into a single theory expressed through four equations—now called Maxwell's equations—that use divergence and curl as their primary language. His famous equations include:

• $\nabla \cdot \mathbf{E} = \rho/\varepsilon_0$ (Gauss's law: charges are sources of electric field)
• $\nabla \cdot \mathbf{B} = 0$ (No magnetic monopoles)
• $\nabla \times \mathbf{E} = -\frac{\partial \mathbf{B}}{\partial t}$ (Faraday's law)
• $\nabla \times \mathbf{B} = \mu_0 \mathbf{J} + \mu_0 \varepsilon_0 \frac{\partial \mathbf{E}}{\partial t}$ (Ampère-Maxwell law)

William Rowan Hamilton developed quaternion calculus, from which modern vector analysis emerged. Peter Guthrie Tait and Josiah Willard Gibbs then developed the modern vector notation we use today.

Divergence

Definition and Formulas

The divergence of a vector field measures the net outward flux per unit volume at each point. It tells us whether the field is expanding outward (like a source) or contracting inward (like a sink) at that location.

For a 3D vector field $\mathbf{F} = \langle P, Q, R \rangle$:

In 2D with $\mathbf{F} = \langle P, Q \rangle$:

Interactive: Divergence Visualizer

Explore how divergence measures expansion and contraction in vector fields. Watch the particles spread apart (positive divergence) or converge (negative divergence):

Physical Interpretation

The Flux Interpretation: Consider a tiny box centered at a point. Divergence measures the net rate at which "stuff" (fluid, electric field lines, etc.) flows outward through the faces of the box, per unit volume.

Curl

Definition and Formulas

The curl of a vector field measures the local rotation or "circulation density" at each point. It tells us how much the field rotates around that point and in which direction (the axis of rotation).

For a 3D vector field $\mathbf{F} = \langle P, Q, R \rangle$:

This can be remembered as a symbolic determinant:

In 2D with $\mathbf{F} = \langle P, Q \rangle$, the curl reduces to a scalar (the z-component):

Interactive: Curl Visualizer

Explore how curl measures rotation in vector fields. Watch the paddle wheels spin—positive curl means counterclockwise rotation (by the right-hand rule):

Interactive: 3D Curl Visualization

In 3D, the curl is a vector pointing along the axis of rotation. Explore how the curl vector varies with position in different 3D vector fields:

Physical Interpretation

The Paddle Wheel Test: Imagine placing a tiny paddle wheel at a point in a fluid flow. The curl vector points along the axis about which the paddle would spin, and its magnitude indicates how fast it would spin.

The Laplacian

The Laplacian is another fundamental operator formed by composing divergence and gradient:

The Laplacian measures how much a function differs from its local average. It appears in:

• Heat equation: $\frac{\partial u}{\partial t} = k \nabla^2 u$
• Wave equation: $\frac{\partial^2 u}{\partial t^2} = c^2 \nabla^2 u$
• Laplace's equation: $\nabla^2 f = 0$ (harmonic functions)
• Schrödinger equation: in quantum mechanics

Vector Calculus Identities

Several identities connect gradient, divergence, and curl. The two most important are:

These identities follow from the equality of mixed partial derivatives and have deep physical significance:

• $\nabla \times (\nabla f) = \mathbf{0}$: Conservative (gradient) fields have no rotation. Energy is conserved.
• $\nabla \cdot (\nabla \times \mathbf{F}) = 0$: Curl fields have no sources or sinks. This is why magnetic field lines form closed loops (no magnetic monopoles).

Interactive: Operator Identities

Hand Walkthrough: Do It Yourself

Pick up a pencil. We will walk one vector field through every operator in this section by hand: compute its divergence, its curl, its Laplacian-of-a-related-potential, and verify the identity $\nabla \times (\nabla f) = \mathbf{0}$. One example, all the ideas — nothing hidden, every partial derivative shown.

Worked Examples

Example 1: Find the divergence and curl of $\mathbf{F} = \langle x^2, y^2, z^2 \rangle$.

Solution:

Divergence: $\nabla \cdot \mathbf{F} = \frac{\partial}{\partial x}(x^2) + \frac{\partial}{\partial y}(y^2) + \frac{\partial}{\partial z}(z^2) = 2x + 2y + 2z$

Curl: The partial derivatives needed are $\frac{\partial R}{\partial y} = 0$, $\frac{\partial Q}{\partial z} = 0$, etc. All cross-derivatives vanish, so $\nabla \times \mathbf{F} = \langle 0, 0, 0 \rangle$.

Example 2: Find the divergence and curl of $\mathbf{F} = \langle -y, x, 0 \rangle$.

Solution:

Divergence: $\nabla \cdot \mathbf{F} = \frac{\partial}{\partial x}(-y) + \frac{\partial}{\partial y}(x) + \frac{\partial}{\partial z}(0) = 0 + 0 + 0 = 0$

This is an incompressible flow (like a vortex in water).

Curl: $\nabla \times \mathbf{F} = \langle 0 - 0, 0 - 0, 1 - (-1) \rangle = \langle 0, 0, 2 \rangle$

The curl is constant, pointing in the +z direction with magnitude 2. This represents uniform counterclockwise rotation in the xy-plane.

Example 3: Verify that $\nabla \times (\nabla f) = \mathbf{0}$ for $f = xyz$.

Solution: First compute $\nabla f = \langle yz, xz, xy \rangle$.

Now compute the curl:$\nabla \times (\nabla f) = \langle \frac{\partial(xy)}{\partial y} - \frac{\partial(xz)}{\partial z}, \frac{\partial(yz)}{\partial z} - \frac{\partial(xy)}{\partial x}, \frac{\partial(xz)}{\partial x} - \frac{\partial(yz)}{\partial y} \rangle$

$= \langle x - x, y - y, z - z \rangle = \langle 0, 0, 0 \rangle$

This confirms the identity.

Physical Applications

Electromagnetism

Maxwell's equations are the foundation of classical electromagnetism, and they are written entirely in terms of divergence and curl:

The identity $\nabla \cdot (\nabla \times \mathbf{B}) = 0$ implies charge conservation, since taking divergence of the Ampère-Maxwell law gives the continuity equation.

Fluid Dynamics

In fluid mechanics:

• Vorticity: $\boldsymbol{\omega} = \nabla \times \mathbf{v}$ measures local rotation of fluid elements. Vortices are regions of high vorticity magnitude.
• Incompressibility: $\nabla \cdot \mathbf{v} = 0$ describes fluids like water that maintain constant density.
• Stream functions: For 2D incompressible flow, $\mathbf{v} = \nabla \times (\psi \mathbf{k})$ automatically satisfies incompressibility.

Connection to Machine Learning

Curl and divergence appear in several modern machine learning contexts:

• Normalizing Flows: Continuous normalizing flows use the change of variables formula involving the divergence of the velocity field. The divergence controls how probability density changes as samples flow through the transformation.
• Score-Based Diffusion Models: The score function $\nabla \log p(x)$ is a gradient field (hence has zero curl). Score matching leverages this structure for density estimation.
• Physics-Informed Neural Networks (PINNs): When solving PDEs involving curl and divergence (like Maxwell's equations or Navier-Stokes), neural networks must learn to satisfy these differential constraints.
• Helmholtz Decomposition: Any sufficiently smooth vector field can be decomposed into a curl-free part (gradient) and a divergence-free part (curl of something). This decomposition is used in analyzing learned vector fields.
• Graph Laplacian: In graph neural networks, the graph Laplacian is the discrete analogue of the continuous Laplacian, measuring diffusion and smoothness on graph-structured data.

Python Implementation

Here's a complete Python implementation for computing divergence and curl numerically and verifying the fundamental identities:

P(1, 2, 3) = 1² · 2 = 2
Q(1, 2, 3) = 2² · 3 = 12
R(1, 2, 3) = 3² · 1 = 9

axis = 0, point = (1.0, 2.0, 3.0), h = 1e-5
→ p_plus  = [1.00001, 2.0, 3.0]
→ p_minus = [0.99999, 2.0, 3.0]
→ partial(P, 0, point) ≈ ( P(1.00001, 2, 3) − P(0.99999, 2, 3) ) / 2e-5
                       ≈ ( 2.00004 − 1.99996 ) / 2e-5
                       ≈ 4.0   # exact: 2xy = 2·1·2 = 4 ✓

At (1, 2, 3):
  ∂P/∂x = 2xy = 2·1·2 = 4
  ∂Q/∂y = 2yz = 2·2·3 = 12
  ∂R/∂z = 2zx = 2·3·1 = 6
  div   = 4 + 12 + 6  = 22  ✓

At (1, 2, 3):
  ∂R/∂y = 0,  ∂Q/∂z = y² = 4   →  curl_x = 0 − 4  = −4
  ∂P/∂z = 0,  ∂R/∂x = z² = 9   →  curl_y = 0 − 9  = −9
  ∂Q/∂x = 0,  ∂P/∂y = x² = 1   →  curl_z = 0 − 1  = −1
  curl(F) = (−4, −9, −1)  ✓

At point (1.0, 2.0, 3.0):
  divergence(F) = 22.0000     # hand:  22
  curl(F)       = [-4. -9. -1.] # hand: [-4, -9, -1]

Expected analytic value: 0
Observed numerical value:  ≈ 1e-8 or smaller
The scientific notation (e.g. 3.21e-08) tells you the identity holds up to floating-point noise.

grad_f_x(1, 2, 3) ≈ 2.0  # exact: 2x = 2
grad_f_y(1, 2, 3) ≈ 4.0  # exact: 2y = 4
grad_f_z(1, 2, 3) ≈ 6.0  # exact: 2z = 6

Expected: [0, 0, 0]
Observed: [ ≈1e-8,  ≈1e-8,  ≈1e-8 ]  ✓

1import numpy as np
2
3# The vector field we will study by hand and by code:
4#     F(x, y, z) = (x^2 * y,  y^2 * z,  z^2 * x)
5def P(x, y, z): return x * x * y       # F_x
6def Q(x, y, z): return y * y * z       # F_y
7def R(x, y, z): return z * z * x       # F_z
8
9def partial(f, axis, point, h=1e-5):
10    """Central-difference approximation of the partial derivative of f
11    along the given axis at the given (x, y, z) point.
12
13    axis = 0 -> ∂f/∂x,  axis = 1 -> ∂f/∂y,  axis = 2 -> ∂f/∂z
14    """
15    p_plus  = list(point)
16    p_minus = list(point)
17    p_plus[axis]  += h
18    p_minus[axis] -= h
19    return (f(*p_plus) - f(*p_minus)) / (2 * h)
20
21def divergence(point):
22    """div(F) = ∂P/∂x + ∂Q/∂y + ∂R/∂z (a scalar)."""
23    dP_dx = partial(P, 0, point)
24    dQ_dy = partial(Q, 1, point)
25    dR_dz = partial(R, 2, point)
26    return dP_dx + dQ_dy + dR_dz
27
28def curl(point):
29    """curl(F) = ( ∂R/∂y - ∂Q/∂z,
30                   ∂P/∂z - ∂R/∂x,
31                   ∂Q/∂x - ∂P/∂y )   (a vector)."""
32    dR_dy = partial(R, 1, point)
33    dQ_dz = partial(Q, 2, point)
34    dP_dz = partial(P, 2, point)
35    dR_dx = partial(R, 0, point)
36    dQ_dx = partial(Q, 0, point)
37    dP_dy = partial(P, 1, point)
38    return np.array([dR_dy - dQ_dz,
39                     dP_dz - dR_dx,
40                     dQ_dx - dP_dy])
41
42# Test the field at the same point we worked out by hand
43point = (1.0, 2.0, 3.0)
44div_value  = divergence(point)
45curl_value = curl(point)
46
47print(f"At point {point}:")
48print(f"  divergence(F) = {div_value:.4f}    # hand:  22")
49print(f"  curl(F)       = {curl_value}       # hand:  [-4, -9, -1]")
50
51# --- Sanity check: div(curl F) = 0 everywhere ------------------------
52def curl_component(i):
53    """Return a scalar function (x,y,z) -> i-th component of curl(F)."""
54    def comp(x, y, z): return curl((x, y, z))[i]
55    return comp
56
57CX, CY, CZ = curl_component(0), curl_component(1), curl_component(2)
58
59div_of_curl = (partial(CX, 0, point) +
60               partial(CY, 1, point) +
61               partial(CZ, 2, point))
62print(f"  div(curl F)   = {div_of_curl:.4e}  # identity says: 0")
63
64# --- Sanity check: curl(grad f) = 0 for f = x^2 + y^2 + z^2 ---------
65def f(x, y, z): return x*x + y*y + z*z
66def grad_f_x(x, y, z): return partial(f, 0, (x, y, z))
67def grad_f_y(x, y, z): return partial(f, 1, (x, y, z))
68def grad_f_z(x, y, z): return partial(f, 2, (x, y, z))
69
70curl_of_grad = np.array([
71    partial(grad_f_z, 1, point) - partial(grad_f_y, 2, point),
72    partial(grad_f_x, 2, point) - partial(grad_f_z, 0, point),
73    partial(grad_f_y, 0, point) - partial(grad_f_x, 1, point),
74])
75print(f"  curl(grad f)  = {curl_of_grad}  # identity says: [0, 0, 0]")

PyTorch: Exact Curl & Divergence via Autograd

The Python code above uses finite differences — fast and simple but with ~$10^{-7}$ error from the $h$ step size. PyTorch can compute these derivatives exactly (to machine precision) by building the full Jacobian with reverse-mode autodiff. Once you have the Jacobian $J_{ij} = \partial F_i / \partial x_j$:

• Divergence is its trace: $\nabla \cdot \mathbf{F} = \text{tr}(J) = J_{00} + J_{11} + J_{22}$
• Curl is the antisymmetric part: $(\nabla \times \mathbf{F})_i = \epsilon_{ijk} J_{kj}$ (with $\epsilon$ the Levi-Civita symbol)

Reading this way makes both identities obvious. The Jacobian of a gradient field is symmetric ($J_{ij} = \partial^2 f / \partial x_i \partial x_j = J_{ji}$), so its antisymmetric part — the curl — vanishes. And the divergence of a curl is a sum of $\partial^2 F_k / \partial x_i \partial x_j$ terms that cancel in pairs.

F(tensor([1., 2., 3.])) = tensor([2., 12., 9.])
# (matches our hand values for P, Q, R)

Jacobian at (1, 2, 3):
  [[ 2xy   x²    0   ]   [[ 4.   1.   0. ]
   [ 0    2yz   y²  ] =  [ 0.   12.  4. ]
   [ z²   0    2zx  ]]   [ 9.   0.   6. ]]

trace([[4, 1, 0], [0, 12, 4], [9, 0, 6]]) = 4 + 12 + 6 = 22  ✓

J = [[ 4,  1,  0],
     [ 0, 12,  4],
     [ 9,  0,  6]]

curl_x = J[2,1] − J[1,2] = 0 − 4  = −4
curl_y = J[0,2] − J[2,0] = 0 − 9  = −9
curl_z = J[1,0] − J[0,1] = 0 − 1  = −1
curl(F) = (−4, −9, −1)  ✓

Jacobian at (1, 2, 3):
tensor([[ 4.,  1.,  0.],
        [ 0., 12.,  4.],
        [ 9.,  0.,  6.]])

divergence(F) = 22.0000
curl(F)       = [-4.0, -9.0, -1.0]

1import torch
2
3# Same vector field as before: F(x, y, z) = (x^2 y, y^2 z, z^2 x)
4def F(point):
5    x, y, z = point[0], point[1], point[2]
6    return torch.stack([x * x * y,
7                        y * y * z,
8                        z * z * x])
9
10def jacobian(point):
11    """Return the 3x3 Jacobian matrix J[i, j] = ∂F_i / ∂x_j  at the point.
12
13    PyTorch builds this for us by recording how F depends on its input."""
14    point = point.detach().clone().requires_grad_(True)
15    return torch.autograd.functional.jacobian(F, point)
16
17def divergence_torch(point):
18    """div(F) = trace(Jacobian) = sum of the diagonal entries."""
19    J = jacobian(point)
20    return torch.trace(J)
21
22def curl_torch(point):
23    """curl(F) read off the off-diagonal entries of the Jacobian:
24        curl_x = J[2,1] - J[1,2]    (∂R/∂y − ∂Q/∂z)
25        curl_y = J[0,2] - J[2,0]    (∂P/∂z − ∂R/∂x)
26        curl_z = J[1,0] - J[0,1]    (∂Q/∂x − ∂P/∂y)"""
27    J = jacobian(point)
28    return torch.stack([J[2, 1] - J[1, 2],
29                        J[0, 2] - J[2, 0],
30                        J[1, 0] - J[0, 1]])
31
32point = torch.tensor([1.0, 2.0, 3.0])
33print("Jacobian at (1, 2, 3):")
34print(jacobian(point))
35print(f"\ndivergence(F) = {divergence_torch(point).item():.4f}")
36print(f"curl(F)       = {curl_torch(point).tolist()}")

Common Mistakes to Avoid

Test Your Understanding

Summary

In this section, we explored the two fundamental differential operators for vector fields:

1. Divergence ($\nabla \cdot \mathbf{F}$) measures sources and sinks—how much a field expands or contracts at each point. Zero divergence means incompressible flow.
2. Curl ($\nabla \times \mathbf{F}$) measures local rotation—both the axis and rate of spinning. Zero curl means the field is irrotational (conservative in simply connected domains).
3. Laplacian ($\nabla^2 f = \nabla \cdot (\nabla f)$) measures deviation from local average, appearing in heat, wave, and Schrödinger equations.
4. Fundamental identities: $\nabla \times (\nabla f) = \mathbf{0}$ (gradients don't rotate) and $\nabla \cdot (\nabla \times \mathbf{F}) = 0$ (curls have no sources).

Looking Ahead: In the following sections, we'll study parametric surfaces and surface integrals, then connect everything with the major theorems of vector calculus: Stokes' Theorem (relating surface integrals of curl to line integrals) and the Divergence Theorem (relating volume integrals of divergence to surface integrals). These theorems are generalizations of the Fundamental Theorem of Calculus to higher dimensions.