Velocity fields: an arrow at every point

Every point gets an arrow that gives direction and speed

Think of a weather map of the wind, with a small arrow drawn over each town. Each arrow is a vector. Its direction is the direction of motion, and its length is the speed. That vector is the velocity: how fast the position changes with time, in each coordinate. In other words, each coordinate of the velocity is the derivative of that coordinate of the position with respect to time.

A velocity field is a rule that gives the velocity at every point p. We write it v(p). If the arrows change over time, we write v(p, t).

Your turn. The sink field is v(p) = (1, 1) − p. Which arrow sits at (4, 2)? Where does a particle in this field come to rest?

A particle traces a path by following the arrows

A particle in a field moves, at every moment, with the velocity given by the arrow where it is. As it moves, it reaches new arrows, so its direction and speed change. The curve it traces is its path. Two particles that start at different points usually follow different paths and may end in different places.

Generative models use fields like this one: where a noise point starts decides which kind of example it becomes.

In a smooth field, two particles never meet

Suppose two particles were ever at the same place at the same time. From then on they would read the same arrows and move together. Run time backward from that moment, and they would also read the same arrows, so they must have been together all along. So in a field whose arrows change smoothly from point to point, two particles that start at different points are never at the same place at the same time.

If the field does not change with time, the paths never cross at all. If it does change, two particles can pass through the same spot at different times, but never at the same time.

This fact matters for flow matching. Its straight training paths often bring two points to the same place at the same time, heading different ways. Particles that follow its learned field never meet, so their paths bend instead.

read_arrows.py

import numpy as np

def swirl(p):
    # Turn around the origin: the arrow at (x, y) is (-y, x).
    x, y = p
    return np.array([-y, x]) + 0.0     # + 0.0 turns -0.0 into 0.0

def sink(p, target=np.array([1.0, 1.0])):
    # Head for a target: the arrow points from p to the target.
    return target - p

for p in [(2.0, 0.0), (0.0, 1.0), (3.0, 4.0)]:
    v = swirl(np.array(p))
    speed = np.linalg.norm(v)   # np.linalg.norm gives the length of the arrow v
    print("swirl at", p, "->", v, " speed", round(speed, 2))
print("sink at (4, 2) ->", sink(np.array([4.0, 2.0])))

swirl at (2.0, 0.0) -> [0. 2.]  speed 2.0
swirl at (0.0, 1.0) -> [-1.  0.]  speed 1.0
swirl at (3.0, 4.0) -> [-4.  3.]  speed 5.0
sink at (4, 2) -> [-3. -1.]