Line Integrals

Learning Objectives

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

1. Understand the concept of a line integral as integrating a function along a curve, rather than over a straight interval on the x-axis
2. Distinguish between scalar and vector line integrals ($\int_C f\, ds$ vs $\int_C \mathbf{F} \cdot d\mathbf{r}$) and pick the right one for the problem
3. Derive the arc-length element $ds = |\mathbf{r}'(t)|\, dt$ from first principles
4. Evaluate line integrals by parametrization and reduce a curve integral to a familiar one-variable integral in $t$
5. Compute work done by a force field along a curved path
6. Implement line integrals in plain Python and then in PyTorch with automatic differentiation

Why this matters: A line integral generalizes the integral$\int_a^b f(x)\, dx$ from straight intervals to arbitrary curved paths. Once you have it, you can compute mass of a non-uniform wire, work done by a varying force along a winding road, circulation of fluid around a closed loop, the EMF in a circuit by Maxwell's equations, and the cost accumulated by an optimizer as it walks through a loss landscape.

The Big Picture

Standard one-variable integration $\int_a^b f(x)\, dx$ sweeps across a straight interval on the x-axis. A line integral sweeps across an arbitrary curve $C$ in 2D or 3D space. Everything else stays the same: we slice the path into infinitesimal pieces, multiply each piece by the value of the function there, and sum.

The scalar form does not care which way you walk the curve; the vector form does — reverse direction and the sign flips. That difference will turn out to be the foundation of conservative fields, Green's theorem, and Stokes' theorem in the sections to come.

Where ds Comes From (Intuition)

Before any formula, picture this. You parametrize a curve with $\mathbf{r}(t) = (x(t), y(t))$. The parameter $t$ is like time. As $t$ ticks forward by a tiny amount $dt$, the point on the curve moves by a tiny displacement vector $d\mathbf{r} = \mathbf{r}'(t)\, dt$.

The length of that tiny displacement is the arc-length element: $ds = |d\mathbf{r}| = |\mathbf{r}'(t)|\, dt$. This is just the Pythagorean theorem in infinitesimal form —$ds = \sqrt{(dx)^2 + (dy)^2} = \sqrt{(x'(t))^2 + (y'(t))^2}\, dt$.

That is the entire trick. A scalar line integral measures $f \cdot ds$ — a value times a length. A vector line integral measures $\mathbf{F} \cdot d\mathbf{r}$ — a force dotted with a displacement. Everything that follows is bookkeeping.

Historical Context

Line integrals were invented to answer concrete physical questions in the 18th and 19th centuries: Lagrange and Laplace used path integrals to study gravitational potentials and the motion of planets; Cauchy formalized them in the complex plane, leading to the powerful Cauchy integral theorem; George Green connected line integrals to double integrals through Green's Theorem; and Maxwell built electromagnetism on top of them — the EMF around a loop and the current through a surface are both line/surface integrals. The unifying problem was always the same: a force that varies along a curved path makes the schoolbook formula work = force times distance meaningless, and line integrals fix it.

Scalar Line Integrals

Definition and Notation

Given a scalar function $f(x, y)$ and a smooth curve $C$, the scalar line integral of $f$ along $C$ is the limit of Riemann sums: $\int_C f\, ds = \lim_{n \to \infty} \sum_{i=1}^{n} f(x_i^*, y_i^*)\, \Delta s_i$, where the curve is sliced into $n$ small arcs of length $\Delta s_i$ and $(x_i^*, y_i^*)$ is any sample point on the $i$-th arc.

Evaluation Using Parametrization

To actually compute, parametrize $\mathbf{r}(t) = (x(t), y(t))$ for $a \le t \le b$. Substituting $ds = |\mathbf{r}'(t)|\, dt$: $\int_C f\, ds = \int_a^b f(x(t), y(t))\, |\mathbf{r}'(t)|\, dt$. The line integral on the left (geometric, hard to compute directly) becomes a plain single-variable integral on the right (mechanical).

The Arc Length Element ds

Spelled out: $ds = \sqrt{\left(\tfrac{dx}{dt}\right)^2 + \left(\tfrac{dy}{dt}\right)^2}\, dt$. In 3D add a $(dz/dt)^2$ term. When $f = 1$, the scalar line integral collapses to the arc length: $\text{Length}(C) = \int_C 1\, ds = \int_a^b |\mathbf{r}'(t)|\, dt$.

Worked Example (Step by Step)

We will compute both a scalar and a vector line integral on the same curve, so you can see exactly what is shared and what is different. The curve is the parabola $y = x^2$ from $(0, 0)$ to $(1, 1)$.

Interactive: Scalar Line Integral

Explore how scalar line integrals work by integrating different functions along various curves. Watch how the Riemann sum approximation converges as you increase the number of segments. The colors indicate the value of the function at each point along the curve.

Interactive: Parametric Curves and ds

Understanding the relationship between the parameter $t$ and the arc-length element $ds$ is crucial. Drag the slider to move along the curve and watch how $ds = |\mathbf{r}'(t)|\, dt$ turns parameter changes into actual distances.

Vector Line Integrals

Work and the Line Integral of a Vector Field

When a force $\mathbf{F}$ moves an object along a path $C$, the work done is $W = \int_C \mathbf{F} \cdot d\mathbf{r}$. This is the vector line integral (or work integral). Unlike its scalar cousin, it depends on the direction of traversal: walk the curve backwards and the answer flips sign.

The Dot Product Form

With parametrization $\mathbf{r}(t)$ for $a \le t \le b$: $\int_C \mathbf{F} \cdot d\mathbf{r} = \int_a^b \mathbf{F}(\mathbf{r}(t)) \cdot \mathbf{r}'(t)\, dt$. Writing $\mathbf{F} = (P, Q)$, this is also $\int_C P\, dx + Q\, dy$, where $dx = x'(t)\, dt$ and $dy = y'(t)\, dt$.

Interactive: Work Done by a Force Field

Explore how different vector fields do work along various paths. Green segments show positive work (force helping motion), red segments show negative work (force opposing motion). Notice how the total work depends on both the field and the path.

Properties of Line Integrals

More Worked Examples

Real-World Applications

Physics: Work and Circulation

Work by a force: when a particle traces path $C$ through a force field, the work done is $W = \int_C \mathbf{F} \cdot d\mathbf{r}$. Gravity, electric forces on a charge, drag — all of them.

Circulation: for a fluid with velocity field $\mathbf{v}$, the circulation around a closed curve is $\oint_C \mathbf{v} \cdot d\mathbf{r}$ — a measurement of how strongly the fluid rotates around that loop. Stokes' theorem will turn this into a surface integral of the curl.

Engineering: Mass and Charge of a Wire

For a wire along curve $C$ with linear density $\rho$, the mass is $M = \int_C \rho\, ds$. Replace $\rho$ with linear charge density and you get total charge. Pair this with electric/magnetic field knowledge and you can compute capacitance, inductance, and EMF of arbitrary wire shapes.

Machine Learning: Optimizer Trajectories

Gradient descent traces a path through the loss landscape. For a loss $L(\mathbf{w})$, the total change in loss along an update trajectory $C$ is $\Delta L = \int_C \nabla L \cdot d\mathbf{w}$. Since the optimizer steps in the negative gradient direction, this work integral is negative — that is just "the loss went down" written in vector-calculus form. It also explains why path-dependent regularizers (e.g. natural gradient, mirror descent) require this framework to analyze.

Python Implementation

Here is a clean Python implementation of both line integrals using the midpoint Riemann rule. We then test it on the exact worked example from above: $\rho(x, y) = 1 + x$ on the parabola $y = x^2$ (gives mass $\approx 1.7878$), and $\mathbf{F} = (2xy, x^2)$ on the same curve (gives work $= 1$).

1import numpy as np
2
3def scalar_line_integral(f, r, r_prime, a, b, n=1000):
4    """
5    Compute integral of f ds over a smooth curve C parametrized by r(t),
6    t in [a, b], using the midpoint Riemann rule.
7
8    Formula:
9        integral_C f ds = integral_a^b f(r(t)) * |r'(t)| dt
10    """
11    dt = (b - a) / n
12    total = 0.0
13
14    for i in range(n):
15        t = a + (i + 0.5) * dt          # midpoint of the i-th sub-interval
16        x, y = r(t)                     # position on the curve
17        dx, dy = r_prime(t)             # velocity vector r'(t)
18        speed = np.sqrt(dx*dx + dy*dy)  # |r'(t)|
19        total += f(x, y) * speed * dt   # f(r(t)) * ds
20
21    return total
22
23def vector_line_integral(F, r, r_prime, a, b, n=1000):
24    """
25    Compute integral of F . dr along curve C.
26
27    Formula:
28        integral_C F . dr = integral_a^b F(r(t)) . r'(t) dt
29
30    Interpretation: work done by force field F along the path.
31    """
32    dt = (b - a) / n
33    work = 0.0
34
35    for i in range(n):
36        t = a + (i + 0.5) * dt
37        x, y = r(t)
38        dx, dy = r_prime(t)
39        Fx, Fy = F(x, y)
40        work += (Fx * dx + Fy * dy) * dt   # dot product times dt
41
42    return work
43
44# --- Test problem: wire on the parabola y = x^2 from (0,0) to (1,1) ---
45
46def f(x, y):                # mass density of the wire
47    return 1.0 + x
48
49def r(t):                   # parametrization
50    return (t, t * t)
51
52def r_prime(t):
53    return (1.0, 2.0 * t)
54
55mass = scalar_line_integral(f, r, r_prime, 0.0, 1.0, n=10_000)
56print(f"Mass of wire = {mass:.6f}")
57# Closed form: integral_0^1 (1 + t) sqrt(1 + 4t^2) dt approx 1.7878
58
59# --- Work done by F(x, y) = (2xy, x^2) along the same curve ---
60
61def F(x, y):
62    return (2.0 * x * y, x * x)
63
64W = vector_line_integral(F, r, r_prime, 0.0, 1.0, n=10_000)
65print(f"Work W = {W:.6f}")
66# Closed form: integral_0^1 4 t^3 dt = 1

PyTorch Implementation (Differentiable)

Now we upgrade. PyTorch buys us two things on top of the Python version. First, vectorization: the inner for-loop disappears because we evaluate the integrand at all $n$ midpoints in a single tensor op. Second, differentiability: every input (the endpoints, the field parameters, the curve parameters) becomes something we can take a derivative with respect to via torch.autograd. The example below uses this to verify the Fundamental Theorem of Calculus on the upper limit: $\frac{d}{db} \int_a^b g(t)\, dt = g(b)$.

1import torch
2
3# ----- Differentiable line integrals with torch.autograd -----
4# We treat the parameter t as a dense tensor and use vectorized ops.
5# Bonus: every input (curve params, field params, endpoints) becomes
6# something we can backpropagate through.
7
8def line_integral_torch(F, r, r_prime, a, b, n=10_000):
9    """
10    Vectorized line integral of F . dr using the midpoint rule.
11
12    F, r, r_prime take a 1-D torch.Tensor of parameter values and return
13    tensors of shape (n,) for scalar fields or (n, 2) for vector fields.
14    """
15    a = torch.as_tensor(a, dtype=torch.float64)
16    b = torch.as_tensor(b, dtype=torch.float64)
17    dt = (b - a) / n
18
19    # Midpoints of the n sub-intervals, shape (n,)
20    t = a + (torch.arange(n, dtype=torch.float64) + 0.5) * dt
21
22    pos = r(t)              # (n, 2)
23    vel = r_prime(t)        # (n, 2)
24    force = F(pos)          # (n, 2)
25
26    # dot product per row, then weighted sum
27    dot = (force * vel).sum(dim=-1)   # (n,)
28    return (dot * dt).sum()           # scalar
29
30# Curve: parabola y = x^2, x in [0, 1]
31def r(t):
32    return torch.stack([t, t**2], dim=-1)
33
34def r_prime(t):
35    return torch.stack([torch.ones_like(t), 2 * t], dim=-1)
36
37# Conservative field F = grad(x^2 y) = (2xy, x^2)
38def F(pos):
39    x, y = pos[..., 0], pos[..., 1]
40    return torch.stack([2 * x * y, x ** 2], dim=-1)
41
42W = line_integral_torch(F, r, r_prime, 0.0, 1.0)
43print(f"W = {W.item():.6f}")    # expected 1.000000
44
45# ----- Differentiate W with respect to the endpoint -----
46# Make 'b' a learnable scalar; the line integral becomes a function
47# of how far we travel along the curve.
48
49b = torch.tensor(1.0, dtype=torch.float64, requires_grad=True)
50W_b = line_integral_torch(F, r, r_prime, 0.0, b)
51
52# dW/db should equal F(r(b)) . r'(b), by the fundamental theorem
53# applied to the upper limit.
54(dW_db,) = torch.autograd.grad(W_b, b)
55print(f"dW/db (autograd) = {dW_db.item():.6f}")
56print(f"F(r(1)).r'(1)    = {(F(r(b)) * r_prime(b)).sum().item():.6f}")
57# Both print 3.000000

Test Your Understanding

Summary

1. Scalar line integral $\int_C f\, ds$: scalar function weighted by arc length. Compute via $\int_a^b f(\mathbf{r}(t))\, |\mathbf{r}'(t)|\, dt$. Direction-independent.
2. Vector line integral $\int_C \mathbf{F} \cdot d\mathbf{r}$: vector field projected onto direction of motion. Compute via $\int_a^b \mathbf{F}(\mathbf{r}(t)) \cdot \mathbf{r}'(t)\, dt$. Sign flips under reversal.
3. Arc-length element $ds = |\mathbf{r}'(t)|\, dt$: the conversion factor from parameter time to physical distance along the curve.
4. Reduction to single-variable integration: in every case, the line integral collapses to $\int_a^b (\text{something in } t)\, dt$ via the parametrization.
5. From Python to PyTorch: same Riemann-sum logic, but PyTorch vectorizes it and makes it differentiable end-to-end.

Looking ahead: in the next section, we will discover that for conservative (gradient) fields, the work integral depends only on the endpoints — not the path. This is the Fundamental Theorem for Line Integrals, the natural continuation of the worked example above where we recovered $W = 1$ two different ways.