Vector Fields

Learning Objectives

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

1. Read a vector field as a function that assigns one arrow $\mathbf{F}(x,y) = \langle P(x,y),\,Q(x,y) \rangle$ to every point of the plane.
2. Recognise the four canonical 2-D patterns — constant, radial, rotational, and saddle — and predict what their arrows look like before you plot them.
3. Build a gradient field $\mathbf{F} = \nabla f$ from any smooth scalar potential and explain why $\nabla f$ is perpendicular to the level curves of $f$.
4. Test whether a given field is conservative using $\partial Q/\partial x = \partial P/\partial y$.
5. Interpret streamlines as solutions of the ODE $d\mathbf{r}/dt = \mathbf{F}(\mathbf{r})$ and compute them by hand for separable fields.
6. Connect the picture to gradient descent: training a neural network is flowing through the field $-\nabla L$.

The Big Picture: A Vector at Every Point

Stand outside on a windy day. At every spot around you, the air has a velocity — a direction and a speed. The collection of all those velocity arrows, one per location, is a vector field.

Calculus has been climbing a ladder. Single-variable calculus handled functions $f:\mathbb{R}\to\mathbb{R}$ — one number in, one number out. Multivariable calculus added scalar fields $f:\mathbb{R}^2\to\mathbb{R}$ — a temperature at every point on a map. Now we take the next rung:

A function whose input is a point of the plane and whose output is a vector. Once you can see this, you start seeing it everywhere.

From One Vector to a Whole Field

Up to now you have thought of a vector as one arrow living somewhere in space. A vector field is the leap from that single arrow to a whole choreography: a rule that gives you a different arrow at every location.

Here is the mental model in three steps.

1. Pick a point. Drop a pin at $(x_0, y_0)$ on the plane.
2. Look up two numbers. The field gives you $P(x_0, y_0)$ (the horizontal component) and $Q(x_0, y_0)$ (the vertical component).
3. Draw the arrow. Start at $(x_0, y_0)$, go $P$ units right and $Q$ units up. That arrow is the value $\mathbf{F}(x_0, y_0)$.

Repeat this at thousands of points and you get the pictures matplotlib calls quiver plots. The direction of an arrow says where the field is pushing; the length says how strongly.

Definition of a Vector Field

Three equivalent notations

Continuity

The field $\mathbf{F}$ is continuous at a point exactly when both components $P$ and $Q$ are continuous there. We will usually deal with smooth fields, except at isolated singular points where the field blows up or is not defined (origin of a radial field, the wire in a magnetic field, etc.).

The Four Canonical 2D Fields

Almost every example you will meet is built from these four building blocks — possibly added, scaled, or composed. Learn them once and you can recognise pieces of them in every other picture.

1. Constant field — uniform wind

$\mathbf{F}(x,y) = \langle a, b\rangle$. Every arrow is identical. Same direction, same length, everywhere. Think of a uniform wind, or the gravitational field near Earth's surface treated locally as constant $\langle 0, -g\rangle$.

2. Radial field — explosion or shrink toward a point

$\mathbf{F}(x,y) = \langle x, y\rangle$. The arrow at point $(x,y)$ is simply the position vector itself — it points directly away from the origin and grows linearly in length. Replace $\langle x,y\rangle$ with $-\langle x,y\rangle$ and the field points inward (a sink).

3. Rotational field — pure spin

$\mathbf{F}(x,y) = \langle -y, x\rangle$. This is the position vector rotated by $90^\circ$ counter-clockwise. At every point, the arrow is perpendicular to the line from the origin — exactly the velocity field of a rigid disc spinning about the origin with angular speed 1.

4. Saddle field — push along x, pull along y

$\mathbf{F}(x,y) = \langle x, -y\rangle$. This is the gradient of the saddle surface $\tfrac12 x^2 - \tfrac12 y^2$. The field pushes outward along the x-axis and pulls inward along the y-axis. The origin is an unstable equilibrium — perturbations along x grow, perturbations along y shrink.

Interactive Playground

Time to play. Pick a field, then drag the white dot to position your probe anywhere on the plane. The amber arrow shows $\mathbf{F}$ at the probe; the readout in the top-left gives the exact value of $P$, $Q$, $|\mathbf{F}|$, and the angle in degrees.

Toggle equal-length arrows to see direction information without magnitude bias (great for the radial field, where corner arrows would otherwise be huge and central ones nearly invisible).

Worked Example: Tracing $\mathbf{F} = \langle -y, x\rangle$ by Hand

The rotational field $\mathbf{F}(x,y)=\langle -y,x\rangle$ is the single most useful 2-D example. Let's evaluate it at seven points, find the magnitude and angle of each, and verify the deep geometric fact that every arrow is tangent to a circle centred at the origin.

Try each row yourself first; the worked solution is hidden in the collapsible box below.

Stepping Up to 3D

Three 3-D examples that run physics

The inverse-square law

Many 3-D fields share the family form $\mathbf{F}(\mathbf{r}) = \dfrac{c}{|\mathbf{r}|^{2}}\,\hat{\mathbf{r}}$. The magnitude falls off as $1/r^{2}$ because the field spreads over a sphere of surface area $4\pi r^{2}$ — the further you are, the more dilute the flux. This single picture explains gravity, electrostatics, and how a flashlight grows dimmer with distance.

Gradient Fields: From Hills to Arrows

Take a scalar potential $f(x,y)$ — think of it as the height of a hill. The gradient packages its two partial derivatives into one vector:

Evaluated at every point, $\nabla f$ is itself a vector field — the gradient field of $f$.

Quick examples

Example 1. Let $f(x,y) = x^2 + y^2$. Then $\nabla f = \langle 2x, 2y\rangle$ — the radial outward field scaled by 2. The level sets are circles, and the gradient points radially outward, perpendicular to them. ✓

Example 2. Let $f(x,y) = \tfrac12 x^2 - \tfrac12 y^2$. Then $\nabla f = \langle x, -y\rangle$ — the saddle field. Level sets are hyperbolas $x^2 - y^2 = 2c$; the gradient is perpendicular to each branch.

Interactive: potential $\leftrightarrow$ gradient field

The left panel shows the scalar potential as a coloured contour map. The right panel overlays the gradient arrows. Watch how the arrows are always normal to the level curves, and how they grow longer where the surface is steeper.

When is a Field a Gradient?

Not every vector field comes from a potential. The rotational field $\langle -y, x\rangle$ emphatically does not. How can we tell?

Applying the test

Radial field $\mathbf{F} = \langle x, y\rangle$: $\partial P/\partial y = 0$, $\partial Q/\partial x = 0$. Equal — conservative. (Indeed, $f = \tfrac12 (x^2+y^2)$ works.)

Rotational field $\mathbf{F} = \langle -y, x\rangle$: $\partial P/\partial y = -1$, $\partial Q/\partial x = +1$. Not equal — the field is not a gradient of any scalar potential.

Flow Lines: A Field is a Recipe for Motion

Drop a tiny massless particle into a vector field and let it ride. At every instant, the particle's velocity equals the field at its current location. The path it traces is called a flow line or streamline.

Solving for the rotational streamlines by hand

For $\mathbf{F}=\langle -y, x\rangle$, the ODE system is $dx/dt = -y,\; dy/dt = x$. Eliminate $t$ by computing the slope:

Separate variables: $y\,dy = -x\,dx$. Integrate both sides:

Streamlines are circles centred at the origin — exactly what the tangency calculation in the worked example predicted, and exactly what the playground will show you.

Interactive: streamlines for five different fields

Below you can scrub through five fields and watch the streamline pattern change. Hit Animate Particles to spawn massless dots that flow along the streamlines in real time.

Real-World Applications

1. Fluid dynamics

Wind, water, and traffic-flow models all live on a velocity field $\mathbf{v}(x,y,z,t)$. The divergence $\nabla\cdot\mathbf{v}$ measures local expansion or compression; the curl $\nabla\times\mathbf{v}$ measures local rotation (vorticity). Both are introduced in §19.5.

2. Electromagnetism

Maxwell's equations are statements about how two vector fields, $\mathbf{E}$ and $\mathbf{B}$, couple in time and space. One of them, $\nabla\times \mathbf{E} = -\partial \mathbf{B}/\partial t$, says a changing magnetic field induces an electric one — the principle behind every electric generator.

3. Weather and climate

Forecasters work simultaneously with the wind vector field, the temperature scalar field, and the pressure scalar field. Pressure gradients drive wind: $\mathbf{v}\propto -\nabla p$.

4. Computer graphics

Fluid simulation, fur shading, and texture synthesis all rely on advecting particles through pre-computed vector fields. The same math as a streamline integration.

Machine Learning Connection

Training a neural network is gradient flow on a giant loss surface. Make the connection explicit:

1. The loss $L(\theta_1, \dots, \theta_n)$ is a scalar field on parameter space $\mathbb{R}^{n}$.
2. The loss gradient $\nabla L$ is its gradient vector field — built by backprop in deep learning.
3. Gradient descent $\theta_{t+1} = \theta_t - \eta\,\nabla L(\theta_t)$ is forward-Euler integration of the ODE $d\theta/dt = -\nabla L$. The training trajectory is a discretised streamline of the field $-\nabla L$.

Python Implementation

Four short Python programs make every idea in this section runnable. Read each snippet, then expand the cards below to walk through it line by line.

1. Plot the four canonical 2-D fields

Think of it like sampling a thermometer at every spot in a room — except instead of a number per spot, you get a 2D arrow per spot.

At (−3, −3): F = (1, 0.5). At (2, 1): F = (1, 0.5). The arrow never changes.

At (1, 0): F = (1, 0), short arrow pointing right. At (3, 3): F = (3, 3), long arrow pointing up-right at 45°.

At (1, 0): F = (0, 1), arrow points up. At (0, 1): F = (−1, 0), arrow points left. At (−1, 0): F = (0, −1), arrow points down. Tracing this around: the disc spins CCW.

At (2, 0): F = (2, 0) outward. At (0, 2): F = (0, −2) inward. Sit a marble at the origin and nudge it — diagonal nudges spiral out through the corridors.

scale=25 means 'one unit of U_norm shows up as roughly 1/25 of the axis width'. Smaller scale → longer arrows; larger scale → shorter arrows.

1import numpy as np
2import matplotlib.pyplot as plt
3
4def plot_vector_field_2d():
5    """
6    Visualize 2D vector fields using matplotlib's quiver plot.
7
8    A vector field F(x, y) = (P(x,y), Q(x,y)) assigns a 2D vector
9    to each point in the plane. We visualize this by drawing an
10    arrow at a grid of sample points.
11    """
12    # 1. Build a square grid of (x, y) sample points.
13    x = np.linspace(-3, 3, 15)
14    y = np.linspace(-3, 3, 15)
15    X, Y = np.meshgrid(x, y)
16
17    # 2. Define four canonical fields as (U, V) pairs.
18    fields = {
19        'Constant: F = (1, 0.5)':  (np.ones_like(X), 0.5 * np.ones_like(Y)),
20        'Radial:   F = (x, y)':    (X, Y),
21        'Rotational: F = (-y, x)': (-Y, X),
22        'Saddle:   F = (x, -y)':   (X, -Y),
23    }
24
25    fig, axes = plt.subplots(2, 2, figsize=(12, 12))
26    axes = axes.flatten()
27
28    for ax, (name, (U, V)) in zip(axes, fields.items()):
29        # 3. |F| at every grid point, used to color the arrows.
30        magnitude = np.sqrt(U**2 + V**2)
31
32        # 4. Normalize direction so very long arrows do not dominate.
33        U_norm = U / (magnitude + 1e-3)
34        V_norm = V / (magnitude + 1e-3)
35
36        ax.quiver(X, Y, U_norm, V_norm, magnitude,
37                  cmap='viridis', scale=25)
38        ax.set_xlim(-3.5, 3.5)
39        ax.set_ylim(-3.5, 3.5)
40        ax.set_title(name)
41        ax.set_aspect('equal')
42
43    plt.tight_layout()
44    plt.show()
45
46plot_vector_field_2d()

2. Streamlines two ways: streamplot and odeint

At state = (2, 0): field returns [0, 2]. So initially the particle moves straight up — which is exactly the tangent to a CCW circle at the easternmost point.

1import numpy as np
2import matplotlib.pyplot as plt
3from scipy.integrate import odeint
4
5def plot_streamlines():
6    """
7    A streamline is a curve r(t) = (x(t), y(t)) whose tangent matches
8    the field at every point:
9
10        dr/dt = F(r(t))         (a 2D system of ODEs)
11
12    matplotlib.streamplot draws many streamlines automatically.
13    """
14    x = np.linspace(-3, 3, 100)
15    y = np.linspace(-3, 3, 100)
16    X, Y = np.meshgrid(x, y)
17
18    # Rotational field
19    U = -Y
20    V =  X
21    speed = np.sqrt(U**2 + V**2)
22
23    fig, ax = plt.subplots(figsize=(7, 7))
24    ax.streamplot(X, Y, U, V, color=speed, cmap='coolwarm',
25                  linewidth=1.5, density=2, arrowstyle='->')
26    ax.set_aspect('equal')
27    ax.set_title('Rotational field — streamlines are circles')
28    plt.show()
29
30def numerical_streamline():
31    """
32    Compute ONE streamline by solving the IVP
33
34        dx/dt = -y
35        dy/dt =  x
36        (x(0), y(0)) = (2, 0)
37
38    The exact solution is (x(t), y(t)) = (2 cos t, 2 sin t).
39    We verify numerically with a Runge–Kutta solver (odeint).
40    """
41    def field(state, t):
42        x, y = state
43        return [-y, x]
44
45    t = np.linspace(0, 2 * np.pi, 200)
46    sol = odeint(field, [2.0, 0.0], t)
47
48    plt.figure(figsize=(7, 7))
49    plt.plot(sol[:, 0], sol[:, 1], 'b-', lw=2)
50    plt.plot(2, 0, 'go', label='start (2, 0)')
51    plt.plot(sol[-1, 0], sol[-1, 1], 'ro', label='end after 2π')
52    plt.axis('equal')
53    plt.legend()
54    plt.title('Streamline of F = (-y, x) from (2, 0)')
55    plt.show()
56
57plot_streamlines()
58numerical_streamline()

3. Build a gradient field from a scalar potential

At (1, 0.5): ∇f = (2, 1). Pointing right and slightly up — away from the bottom of the bowl, the direction the surface rises fastest.

grad · tangent = (2)(−1) + (1)(2) = 0. The two vectors are perpendicular. The gradient is ALWAYS perpendicular to the level curve.

1import numpy as np
2import matplotlib.pyplot as plt
3
4def gradient_vector_field():
5    """
6    A gradient field is the special vector field
7
8        F(x, y) = ∇f(x, y) = (∂f/∂x, ∂f/∂y)
9
10    for some scalar 'potential' function f.
11
12    Key facts:
13      • ∇f is always perpendicular to the level curves of f.
14      • ∇f points uphill (in the direction of steepest ascent).
15      • Line integrals of ∇f depend only on the endpoints.
16    """
17    x = np.linspace(-3, 3, 100)
18    y = np.linspace(-3, 3, 100)
19    X, Y = np.meshgrid(x, y)
20
21    # Scalar potential and its gradient
22    f = X**2 + Y**2          # paraboloid bowl
23    grad_x = 2 * X
24    grad_y = 2 * Y
25
26    fig, axes = plt.subplots(1, 2, figsize=(14, 6))
27
28    # Left panel: contour map of f
29    ax1 = axes[0]
30    cs = ax1.contourf(X, Y, f, levels=20, cmap='viridis')
31    ax1.contour(X, Y, f, levels=20, colors='white', linewidths=0.3)
32    plt.colorbar(cs, ax=ax1, label='f(x, y) = x² + y²')
33    ax1.set_aspect('equal')
34    ax1.set_title('Scalar field f')
35
36    # Right panel: ∇f arrows on top of level curves
37    ax2 = axes[1]
38    ax2.contour(X, Y, f, levels=15, colors='gray', alpha=0.5)
39
40    x_vec = np.linspace(-2.5, 2.5, 12)
41    y_vec = np.linspace(-2.5, 2.5, 12)
42    Xv, Yv = np.meshgrid(x_vec, y_vec)
43    U = 2 * Xv
44    V = 2 * Yv
45    mag = np.sqrt(U**2 + V**2)
46
47    ax2.quiver(Xv, Yv, U / (mag + 1e-3), V / (mag + 1e-3), mag,
48               cmap='plasma', scale=25)
49    ax2.set_aspect('equal')
50    ax2.set_title('Gradient field ∇f = (2x, 2y) — perpendicular to level curves')
51
52    plt.tight_layout()
53    plt.show()
54
55    # Numerical check at one point: ∇f ⟂ tangent to level curve
56    px, py = 1.0, 0.5
57    grad = np.array([2 * px, 2 * py])         # = (2, 1)
58    tangent = np.array([-2 * py, 2 * px])     # rotate grad 90°
59    print(f"point: ({px}, {py})")
60    print(f"  grad      = {grad}")
61    print(f"  tangent   = {tangent}")
62    print(f"  grad · tangent = {grad @ tangent}   <- should be 0")
63
64gradient_vector_field()

4. Gradient descent as flow on a loss vector field

loss(2.0, 1.0) ≈ 0.082  (just the noise — best possible). loss(0, 0) ≈ 5.4  (terrible guess).

1import numpy as np
2import matplotlib.pyplot as plt
3
4def loss_gradient_field():
5    """
6    In machine learning, the loss L(θ) is a scalar field over
7    parameter space and ∇L is its gradient vector field.
8    Gradient descent simply 'flows downhill' along -∇L:
9
10        θ_{t+1} = θ_t  -  η · ∇L(θ_t)
11
12    Here we fit y = w·x + b to noisy synthetic data and watch
13    descent trace a streamline of -∇L through (w, b)-space.
14    """
15    rng = np.random.default_rng(42)
16    x_data = rng.standard_normal(50)
17    y_data = 2.0 * x_data + 1.0 + 0.3 * rng.standard_normal(50)
18
19    def loss(w, b):
20        pred = w * x_data + b
21        return np.mean((pred - y_data) ** 2)
22
23    def grad(w, b):
24        pred = w * x_data + b
25        r = pred - y_data
26        return np.array([2 * np.mean(r * x_data),
27                         2 * np.mean(r)])
28
29    # Grid of (w, b) for the contour plot
30    w_axis = np.linspace(-1, 5, 100)
31    b_axis = np.linspace(-2, 4, 100)
32    W, B = np.meshgrid(w_axis, b_axis)
33    L = np.vectorize(loss)(W, B)
34
35    fig, ax = plt.subplots(figsize=(8, 7))
36    ax.contourf(W, B, L, levels=30, cmap='viridis')
37    ax.contour (W, B, L, levels=30, colors='white', linewidths=0.3)
38
39    # Gradient descent trajectory
40    w, b = 4.5, 3.5
41    lr = 0.1
42    path = [(w, b)]
43    for _ in range(80):
44        g = grad(w, b)
45        w -= lr * g[0]
46        b -= lr * g[1]
47        path.append((w, b))
48    path = np.array(path)
49
50    ax.plot(path[:, 0], path[:, 1], 'r.-', lw=2, ms=4)
51    ax.plot(path[0, 0], path[0, 1], 'go', ms=10, label='start')
52    ax.plot(path[-1, 0], path[-1, 1], 'r*', ms=14, label='end')
53    ax.set_xlabel('w'); ax.set_ylabel('b')
54    ax.set_title('Loss surface with -∇L flow (gradient descent)')
55    ax.legend()
56    plt.show()
57
58    print(f"true   (w, b) = (2.0, 1.0)")
59    print(f"final  (w, b) = ({path[-1, 0]:.3f}, {path[-1, 1]:.3f})")
60
61loss_gradient_field()

PyTorch: Gradient Fields via Autograd

For toy potentials like $f = x^{2}+y^{2}$ the gradient is easy by hand. For a 50-million-parameter neural network it is not. PyTorch's autograd computes $\nabla f$ mechanically by walking the computation graph backwards. The snippet below uses it to rediscover the radial field $\langle 2x, 2y\rangle$ on a $5 \times 5$ grid and compares it against the closed-form answer.

1import torch
2
3def grad_field_via_autograd():
4    """
5    The same gradient field as before — but now we let PyTorch
6    differentiate the potential for us. No more pencil-and-paper
7    ∂f/∂x.
8
9    f(x, y) = x² + y²,   ∇f = (2x, 2y)
10
11    We will sample f on a grid and use torch.autograd.grad to
12    recover the field one point at a time.
13    """
14    # Sample 5 evenly-spaced points along x and y
15    xs = torch.linspace(-2, 2, 5)
16    ys = torch.linspace(-2, 2, 5)
17
18    print(f"{'(x, y)':>10}  {'f(x,y)':>8}  {'autograd ∇f':>16}  {'closed-form':>14}")
19    print('-' * 60)
20
21    for x_val in xs:
22        for y_val in ys:
23            # Each call: build a leaf tensor at (x, y), compute f, differentiate.
24            x = x_val.clone().requires_grad_(True)
25            y = y_val.clone().requires_grad_(True)
26            f = x * x + y * y                       # scalar potential
27
28            # torch.autograd.grad returns gradients of f w.r.t. (x, y)
29            (grad_x, grad_y) = torch.autograd.grad(
30                outputs=f, inputs=(x, y),
31                create_graph=False,
32            )
33            closed = (2 * x_val.item(), 2 * y_val.item())
34            print(f"({x_val.item():+.1f},{y_val.item():+.1f})  "
35                  f"{f.item():>7.3f}   "
36                  f"({grad_x.item():+.2f}, {grad_y.item():+.2f})   "
37                  f"({closed[0]:+.2f}, {closed[1]:+.2f})")
38
39grad_field_via_autograd()

Test Your Understanding

Summary

A vector field is a function that paints every point with an arrow. Two components $P,Q$ tell you the arrow at $(x,y)$. Four canonical patterns — constant, radial, rotational, saddle — are the alphabet from which most fields are built.

Coming next: §19.2 introduces line integrals — integrating a function or a vector field along a curve. We will compute the work done by a force field along a path, and discover that for gradient fields the answer depends only on the endpoints. That is the fundamental theorem of line integrals — the multivariable analogue of FTC Part 2.