Surface Integrals

Learning Objectives

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

1. Parametrise a surface in 3D and read off its area element $dS = |\mathbf{r}_u \times \mathbf{r}_v|\,du\,dv$ directly from the parametrisation.
2. Evaluate scalar surface integrals $\iint_S f\,dS$ over parametric surfaces, including surface area as a special case.
3. Compute flux integrals $\iint_S \mathbf{F} \cdot d\mathbf{S}$, measuring how much of a vector field passes through a curved surface.
4. Reason about orientation and the role of the unit normal in determining the sign of flux.
5. Connect the formalism to electromagnetism (Gauss's law), fluid dynamics (mass flow rate) and the change-of-variables formula in machine-learning normalising flows.

Why this matters: Surface integrals are how calculus measures stuff that lives on a curved skin in space — the mass of a soap bubble, the wind passing through a kite, the electric field threading a Gaussian pillbox, the probability mass squeezed by a generative model. Every "flow through a boundary" in physics is a flux integral in disguise.

The Big Picture

Calculus keeps doing the same trick — chop, evaluate, sum, take the limit — only the shape of the domain changes. Surface integrals are the natural next step:

Just as line integrals split into "scalar along a curve" and "vector circulation along a curve", surface integrals split into two species:

Historical Context

Surface integrals were invented to answer concrete questions in 19th-century physics: how does an electric field surround a charge? how does fluid mass move through a pipe? The mathematics was forged by three names you will meet again in this chapter.

Carl Friedrich Gauss (1777–1855)

Gauss spotted the deep link between flux through a closed surface and the sources sitting inside it. His electrostatic statement $\oint_S \mathbf{E}\cdot d\mathbf{S} = Q_{\text{enc}}/\varepsilon_0$ is one of Maxwell's four equations and the cleanest example of a flux integral doing real work.

George Green (1793–1841)

A self-taught miller's son who introduced the function we now call Green's function and connected surface integrals to volume integrals through what we now call Green's identities. Modern PDE theory begins with him.

George Gabriel Stokes (1819–1903)

Stokes proved the theorem now bearing his name (next section), tying the circulation of a vector field around a curve to the flux of its curl through a spanning surface.

Parametric Surfaces Review

Before integrating over a surface we have to be able to describe it. A parametric surface is a vector function from a flat 2-D parameter rectangle into 3-D space:

As $(u,v)$ sweeps through the rectangle $D$, the tip of $\mathbf{r}(u,v)$ traces out the surface$S$ in 3-D.

A small atlas of parametrisations

The Surface Area Element $dS$

Once we have $\mathbf{r}(u,v)$, the central object of the whole section is the area element:

where $\mathbf{r}_u = \partial\mathbf{r}/\partial u$ and$\mathbf{r}_v = \partial\mathbf{r}/\partial v$ are the partial derivatives of the parametrisation. Equivalently, the vector area element is $d\mathbf{S} = (\mathbf{r}_u \times \mathbf{r}_v)\,du\,dv$ — a normal vector whose magnitude is the area scale.

Where $dS$ Comes From (Intuition)

Imagine the parameter rectangle $D$ ruled with a fine grid of cells, each of width $du$ and $dv$. The map $\mathbf{r}$ sends one such cell — a tiny square — to a tiny curved patch of the surface $S$. Two edges of that patch are

• $\mathbf{r}(u+du,v) - \mathbf{r}(u,v) \approx \mathbf{r}_u\,du$ — the local edge in the $u$-direction;
• $\mathbf{r}(u,v+dv) - \mathbf{r}(u,v) \approx \mathbf{r}_v\,dv$ — the local edge in the $v$-direction.

Those two edges span a small parallelogram living tangent to the surface. The area of a parallelogram with edges $\mathbf{a}$ and $\mathbf{b}$ is $|\mathbf{a} \times \mathbf{b}|$ — that is exactly the magnitude of $(\mathbf{r}_u du) \times (\mathbf{r}_v dv) = (\mathbf{r}_u \times \mathbf{r}_v)\,du\,dv$. Take the limit as $du, dv \to 0$ and you obtain the area element$dS$. The direction of the cross product also gives a normal vector to the surface — that is going to matter the moment we talk about flux.

Interactive: Parametric Surfaces

Drag the surface, change the parametrisation, and watch how the constant- $u$ and constant-$v$ curves rule the surface. The shape itself is global; the parametrisation is a chart we paint on top of it.

Scalar Surface Integrals

Definition and Intuition

A scalar surface integral of a function $f(x,y,z)$ over a surface $S$ is the limit of Riemann sums of $f$ against the surface area:

Physical reading. If $f$ is a mass density per unit area ($\text{kg}/\text{m}^2$), the sum gives the total mass of the shell. If $f$ is a temperature, dividing the integral by the total area gives the average temperature on the surface. The pattern "integrand times area element, summed" is universal.

Computing Scalar Surface Integrals

Pull everything back to the parameter rectangle $D$:

Recipe:

1. Pick a parametrisation $\mathbf{r}(u,v)$ matched to the symmetry.
2. Differentiate to get $\mathbf{r}_u$ and $\mathbf{r}_v$.
3. Take the cross product $\mathbf{r}_u \times \mathbf{r}_v$ and its magnitude.
4. Substitute the parametrisation into $f$.
5. Evaluate a familiar double integral over $D$.

Surface Area as a Special Case

Setting $f \equiv 1$ gives total surface area:

For a sphere of radius $R$, this immediately reproduces $4\pi R^2$:

Worked Example — Center of Mass of a Hemisphere

We will compute the z-coordinate of the centroid of the upper hemisphere $x^2+y^2+z^2=R^2,\;z\ge 0$, assumed to be a thin shell of uniform area density. Hand-work below — try it yourself before peeking.

Interactive: Scalar Surface Integrals

Pick a surface, pick an integrand, and watch the Riemann sum colour-code each patch by its contribution. The running total is the surface integral.

Vector Surface Integrals (Flux)

Flux Through a Surface

The flux of a vector field $\mathbf{F}$ through an oriented surface $S$ with unit normal $\mathbf{n}$ is the scalar surface integral of the normal-component of $\mathbf{F}$:

Physical reading. If $\mathbf{F} = \rho\mathbf{v}$ is the momentum density of a fluid ($\rho$ mass density, $\mathbf{v}$ velocity), then $\Phi$ is the mass flow rate through the surface in kg/s. If$\mathbf{F} = \mathbf{E}$ is the electric field, $\Phi$ is the electric flux — by Gauss's law equal to the enclosed charge divided by $\varepsilon_0$.

Flux as a Dot Product (Intuition)

The dot product $\mathbf{F}\cdot\mathbf{n}$ filters $\mathbf{F}$ to its component through the surface. Three cases say it all:

• $\mathbf{F}\parallel\mathbf{n}$ (perpendicular to the surface): $\mathbf{F}\cdot\mathbf{n} = \pm|\mathbf{F}|$ — maximal flux per area.
• $\mathbf{F}\perp\mathbf{n}$ (parallel to the surface): $\mathbf{F}\cdot\mathbf{n} = 0$ — the field slides along the surface and contributes nothing to flux.
• General angle $\alpha$: $\mathbf{F}\cdot\mathbf{n} = |\mathbf{F}|\cos\alpha$ — only the cosine projects through.

That is why a window perpendicular to a uniform wind catches the maximum air flow, while a window aligned with the wind catches none.

Surface Orientation

Every smooth surface has two sides. Choosing one — and therefore one of the two unit normals — is called fixing the orientation. Conventions:

Computing Flux Integrals

Pull back to the parameter rectangle using the vector area element $d\mathbf{S} = (\mathbf{r}_u \times \mathbf{r}_v)\,du\,dv$:

Key observation. The cross product $\mathbf{r}_u \times \mathbf{r}_v$ already encodes both the direction of the normal and the magnitude of the area scale — so no unit vector and no extra norm appear in this version of the formula. The price is that you must check the sign of the cross product against your chosen orientation; flip the order of arguments if it points the wrong way.

Worked Example — Flux of $(0,0,z)$ Through a Paraboloid

Compute $\iint_S \mathbf{F}\cdot d\mathbf{S}$ for $\mathbf{F}=(0,0,z)$ through the paraboloid $z = 4 - x^2 - y^2,\;z\ge 0$, oriented upward. Try it yourself before expanding.

Interactive: Flux Through Surfaces

Drag the vector field, change the surface, and watch every patch's contribution light up red (positive flux, out) or blue (negative flux, in). When you tilt the surface to be parallel to the field, the running total drops to zero — the visual proof of the$\cos\alpha$ projection.

Important Surface Types

Surfaces as Graphs $z = f(x,y)$

When the surface is the graph of a function, the parametrisation is free and the formulas simplify dramatically:

Parametrisation: $\mathbf{r}(x,y) = (x,\;y,\;f(x,y)).$

Cross product (upward normal): $\mathbf{r}_x \times \mathbf{r}_y = (-f_x,\;-f_y,\;1).$

Area element: $dS = \sqrt{1 + f_x^2 + f_y^2}\,dx\,dy.$

For flux through a graph with upward normal, writing $\mathbf{F}=(P,Q,R)$:

Spheres and Cylinders

Gauss's Law as a Surface Integral

The electric field of a point charge $q$ at the origin is $\mathbf{E}(\mathbf{x}) = \dfrac{kq}{|\mathbf{x}|^2}\hat{\mathbf{r}}$. Compute the flux of $\mathbf{E}$ through any sphere of radius $R$ centred at the origin.

Real-World Applications

Physics: Electric and Magnetic Flux

Maxwell's equations are written almost entirely in the language of flux:

• Gauss's law (electric): $\oint_S \mathbf{E}\cdot d\mathbf{S} = Q_{\text{enc}}/\varepsilon_0$ — the electric flux out of a closed surface counts the charge inside.
• Gauss's law (magnetic): $\oint_S \mathbf{B}\cdot d\mathbf{S} = 0$ — no magnetic monopoles, so magnetic flux out of any closed surface is always zero.
• Faraday's law: a changing magnetic flux through a surface induces an electromotive force around its boundary — surface integrals show up on the right-hand side directly.

Fluid Dynamics: Mass Flow Rate

For a fluid of density $\rho$ and velocity $\mathbf{v}$, the mass flow rate through a surface is the flux of $\rho\mathbf{v}$:

This is the equation used to size pipes, sketch ventilation, compute lift on an airfoil, and check conservation of mass in a control volume.

Machine Learning: Normalising Flows

In a normalising flow, an invertible neural network $f$ maps samples $z$ from a simple distribution $p_0$ to samples $x = f(z)$ from a target distribution $p$. The change-of-variables formula

is the local, infinitesimal version of "probability is conserved through a flow". The global version — integrating mass through a closed surface — is exactly the Divergence Theorem we will prove in section 19.9. Surface integrals are the bridge that turns local conservation into a global accounting law.

Python Implementation

Scalar surface integral over a hemisphere

1import math
2
3def scalar_surface_integral_hemisphere(R=2.0, n_phi=50, n_theta=100):
4    """
5    Compute  I = ∬_S  z  dS   over the upper hemisphere of radius R.
6
7    Parametrization (spherical):
8        x = R sin(phi) cos(theta)
9        y = R sin(phi) sin(theta)
10        z = R cos(phi)
11
12    For a sphere:  |r_phi × r_theta| = R^2 sin(phi),
13    so the surface area element is
14        dS = R^2 sin(phi) d(phi) d(theta).
15    """
16    # Step 1. Build evenly spaced grids in the parameter rectangle.
17    d_phi   = (math.pi / 2) / n_phi          # phi runs 0 → pi/2 (upper half)
18    d_theta = (2 * math.pi) / n_theta        # theta runs 0 → 2*pi
19
20    integral = 0.0
21
22    # Step 2. Riemann sum over every (phi_i, theta_j) cell.
23    for i in range(n_phi):
24        phi = (i + 0.5) * d_phi              # midpoint of the phi cell
25        for j in range(n_theta):
26            theta = (j + 0.5) * d_theta      # midpoint of the theta cell
27
28            z   = R * math.cos(phi)          # integrand value f = z
29            dS  = R**2 * math.sin(phi) * d_phi * d_theta
30            integral += z * dS
31
32    # Step 3. Compare with the closed-form answer  pi * R^3.
33    analytical = math.pi * R**3
34    rel_err    = abs(integral - analytical) / analytical * 100
35
36    print(f"Numerical  : {integral:.6f}")
37    print(f"Analytical : {analytical:.6f}   (= pi * R^3)")
38    print(f"Relative   : {rel_err:.4f} %")
39    return integral, analytical
40
41
42scalar_surface_integral_hemisphere()

Flux integral through a paraboloid

1import math
2
3def flux_through_paraboloid(R=2.0, n_r=80, n_theta=160):
4    """
5    Compute the flux of  F(x,y,z) = (0, 0, z)
6    through the paraboloid  z = 4 - x^2 - y^2,  z >= 0,
7    oriented with the *upward* normal.
8
9    Parametrize the paraboloid in polar form:
10        x = r cos(theta)
11        y = r sin(theta)
12        z = 4 - r^2,    0 <= r <= 2,  0 <= theta <= 2*pi
13
14    Tangent vectors:
15        r_r     = ( cos(theta),  sin(theta), -2 r )
16        r_theta = (-r sin(theta), r cos(theta), 0  )
17
18    Cross product (upward-pointing):
19        r_r × r_theta = ( 2 r^2 cos(theta),  2 r^2 sin(theta),  r )
20
21    F · (r_r × r_theta) = (0, 0, 4-r^2) · (..., r) = r (4 - r^2)
22    """
23    dr     = R / n_r
24    dtheta = (2 * math.pi) / n_theta
25    flux   = 0.0
26
27    for i in range(n_r):
28        r = (i + 0.5) * dr                       # midpoint r in cell
29        radial = r * (4 - r**2)                  # F · (r_r × r_theta)
30        # All terms below depend on r only, so theta sum is just n_theta * dtheta.
31        flux += radial * dr * (2 * math.pi)
32
33    # Closed form: ∫₀^{2π} dθ ∫₀^2 (4r - r^3) dr = 2π (8 - 4) = 8π.
34    analytical = 8 * math.pi
35    print(f"Numerical  : {flux:.6f}")
36    print(f"Analytical : {analytical:.6f}   (= 8*pi)")
37    print(f"Relative   : {abs(flux - analytical)/analytical*100:.4f} %")
38    return flux, analytical
39
40
41flux_through_paraboloid()

Normalising-flow Jacobian (the ML link)

1import math
2
3def planar_flow_jacobian(z, w=(1.0, 0.5), b=0.0, u_scale=(0.5, 1.0)):
4    """
5    A toy planar normalizing flow:  x = f(z) = z + tanh(w·z + b) * u.
6
7    Returns x and the *Jacobian determinant* of the map at z.
8    The change-of-variables formula then gives
9        p(x) = p_0(z) / |det J_f(z)|.
10
11    The link to surface integrals: probability behaves like an
12    incompressible fluid in z-space; |det J_f(z)| measures how
13    much a small volume gets stretched into x-space. This is the
14    infinitesimal version of the flux that the Divergence Theorem
15    formalises in the next section.
16    """
17    z1, z2 = z
18    w1, w2 = w
19    u1, u2 = u_scale
20
21    # Forward map.
22    s   = w1 * z1 + w2 * z2 + b
23    t   = math.tanh(s)
24    x1  = z1 + t * u1
25    x2  = z2 + t * u2
26
27    # Jacobian of f at z:
28    #   J = I + u · (1 - tanh^2(s)) · w^T          (rank-1 update of I)
29    #   det(I + a b^T) = 1 + b^T a
30    #   ⇒ det J = 1 + (1 - t^2) * (w1 * u1 + w2 * u2)
31    det_J = 1.0 + (1.0 - t**2) * (w1 * u1 + w2 * u2)
32
33    return (x1, x2), det_J
34
35
36# Sanity check at two sample points.
37for z in [(0.0, 0.0), (1.5, -1.0)]:
38    x, dJ = planar_flow_jacobian(z)
39    print(f"z = {z}  →  x = ({x[0]:.4f}, {x[1]:.4f})   |det J| = {abs(dJ):.4f}")

PyTorch Implementation

With the plain-Python intuition in hand, here is the vectorised PyTorch version of the flux integral. We let autograd build the tangent vectors $\mathbf{r}_r$ and $\mathbf{r}_\theta$ symbolically through the graph — no algebraic differentiation by us. The same idea scales to learnable surface parametrisations inside a neural network.

1import torch
2import math
3
4def flux_paraboloid_torch(R: float = 2.0, n_r: int = 200, n_theta: int = 400,
5                          device: str = "cpu"):
6    """
7    Vectorised version of the same flux integral, in PyTorch.
8
9    The bonus: we let autograd build the tangent vectors r_r and r_theta
10    by differentiating the parametrisation symbolically through the graph,
11    instead of writing them out by hand.
12    """
13    # 1. Build (n_r × n_theta) grids of midpoint samples.
14    dr     = R / n_r
15    dtheta = (2 * math.pi) / n_theta
16    r      = torch.linspace(0.5*dr, R - 0.5*dr, n_r, device=device)
17    theta  = torch.linspace(0.5*dtheta, 2*math.pi - 0.5*dtheta, n_theta, device=device)
18    R_grid, T_grid = torch.meshgrid(r, theta, indexing="ij")
19    R_grid.requires_grad_(True)            # so autograd can differentiate
20    T_grid.requires_grad_(True)
21
22    # 2. Parametrisation as a single tensor expression.
23    X = R_grid * torch.cos(T_grid)
24    Y = R_grid * torch.sin(T_grid)
25    Z = 4.0 - R_grid**2
26
27    # 3. Tangent vectors via autograd — one component at a time.
28    ones = torch.ones_like(R_grid)
29    def grad(out, wrt):
30        return torch.autograd.grad(out, wrt, grad_outputs=ones,
31                                   retain_graph=True, create_graph=False)[0]
32
33    r_r = torch.stack([grad(X, R_grid), grad(Y, R_grid), grad(Z, R_grid)], dim=-1)
34    r_t = torch.stack([grad(X, T_grid), grad(Y, T_grid), grad(Z, T_grid)], dim=-1)
35
36    # 4. Cross product r_r × r_theta (upward-pointing).
37    cross = torch.cross(r_r, r_t, dim=-1)
38
39    # 5. Vector field F = (0, 0, z), evaluated on the surface.
40    F = torch.stack([torch.zeros_like(Z), torch.zeros_like(Z), Z.detach()], dim=-1)
41
42    # 6. Dot product F · (r_r × r_theta), then 2-D midpoint Riemann sum.
43    integrand = (F * cross).sum(dim=-1)
44    flux = integrand.sum() * dr * dtheta
45
46    print(f"PyTorch flux : {flux.item():.6f}")
47    print(f"Reference 8π : {8 * math.pi:.6f}")
48    return flux
49
50
51if __name__ == "__main__":
52    flux_paraboloid_torch()

Test Your Understanding

Summary

We extended integration to 2-D curved sheets sitting in 3-D space. Two flavours, one idea: chop the parameter rectangle, evaluate, weight by area, sum, take the limit.

Key formulas

Key takeaways

1. A parametric surface $\mathbf{r}(u,v)$ turns a flat rectangle into a curved sheet in $\mathbb{R}^3$.
2. The cross product $\mathbf{r}_u\times\mathbf{r}_v$ carries both the local normal direction and the area scale.
3. Scalar surface integrals add up a density. Mass, average value, surface area — all the same recipe with different $f$.
4. Flux integrals project the field onto the surface normal and accumulate. Orientation is part of the data — flip it and the sign flips.
5. The same algebra is the engine of Maxwell's equations, fluid mass-balance, and the change-of-variables formula in normalising flows.
6. Surface integrals are one side of two great theorems: Stokes (next section) and the Divergence Theorem (section 19.9).

Coming next: Stokes' theorem ties the circulation of a vector field around a closed curve to the flux of its curl through any spanning surface — the 3-D upgrade of Green's theorem.