Plenty of functions "move points around" — stretch a photo, warp a map, bend a curve. But not every one of them can ever be written as a matrix. Before the whole matrix toolkit (composing transformations, inverting them, finding eigenvalues) can be pointed at a transformation, that transformation has to earn the right by passing a strict gatekeeper test.

Stop thinking of a matrix as a table of numbers, and start thinking of it as an action: a rule that takes in a vector and moves it to a new one, transforming the entire plane at once. A linear transformation is a special, very well-behaved kind of motion. It must keep two promises, no exceptions:

• the origin stays fixed — T(\vec 0) = \vec 0, and
• every grid line stays straight, parallel and evenly spaced.

In symbols, a transformation T is linear exactly when it respects both addition and scaling for every pair of vectors \vec u, \vec v and every scalar c:

No bending, no curving, no shifting off the origin — just a clean stretch-and-skew of space. The rest of this page is about learning to check those two promises, rather than trusting a transformation just because it looks tidy.

The two promises, one at a time

Additivity — T(\vec u + \vec v) = T(\vec u) + T(\vec v) — says it doesn't matter whether you add two vectors first and then transform the sum, or transform each one separately and add the results after: you land in the same place either way. Picture the parallelogram with \vec u and \vec v as two edges — its far corner is \vec u+\vec v. Additivity says applying T to the whole parallelogram (edges and all) just gives another parallelogram, built the same way from T(\vec u) and T(\vec v).

Scaling (also called homogeneity) — T(c\vec v) = c\,T(\vec v) — says stretching a vector by a factor c before transforming it gives the same answer as transforming it first and then stretching the result by c. Geometrically: a whole line of evenly spaced points through the origin (multiples of \vec v) lands on another line of evenly spaced points through the origin — never bunched up, never spread apart unevenly, never bent into a curve.

Put the two together and you get the picture from the definition: a grid of straight, parallel, evenly spaced lines through the origin must land as another grid of straight, parallel, evenly spaced lines through the origin. That rigidity is the whole reason a single matrix — just a handful of numbers — can capture the entire transformation.

Watch space deform

Drag the slider to apply a transformation gradually. The grid stretches and shears — yet every line stays a line, parallel lines stay parallel, and the centre never moves. Watch the two coloured arrows: they track where the "unit" directions (1,0) and (0,1) end up, and once you know that, additivity and scaling pin down everywhere else — you're watching the two defining properties in action, not just a pretty animation.

Worked example: checking a scaling map

Let T(x,y) = (2x, 2y) — every point moves twice as far from the origin. Is it linear? Test it on two arbitrary vectors \vec u = (u_1,u_2) and \vec v=(v_1,v_2), rather than trusting a guess.

Additivity:

The two sides match exactly, for any choice of \vec u,\vec v — not just a lucky pair of numbers.

Scaling: T(c\vec v) = (2cv_1, 2cv_2) = c(2v_1,2v_2) = c\,T(\vec v). Both promises hold, so doubling is linear.

A concrete check with numbers: take \vec u=(1,3) and \vec v=(4,-1). Then \vec u+\vec v=(5,2), so T(\vec u+\vec v) = (10,4). Separately, T(\vec u)=(2,6) and T(\vec v)=(8,-2), and their sum is (10,4) too — matching, as the general argument promised.

Worked example: checking a 90° rotation

Rotating every point 90° counter-clockwise around the origin sends (x,y) to (-y,x). Test it on \vec u=(1,0) and \vec v=(0,1), then on their sum.

They agree. Rotation also preserves scaling: shrinking \vec v to \tfrac12\vec v=(0,0.5) and rotating gives (-0.5,0), exactly \tfrac12 of T(\vec v)=(-1,0). A rotation never bends a line and it always fixes the centre it spins around — so it was never in doubt, but now it's proven, not assumed.

Worked example: a transformation that fails — translation

Now test a transformation that looks perfectly innocent: sliding every point 3 units right and 2 units up, T(x,y) = (x+3,\ y+2). Before checking either property, apply the fastest possible test — does the origin stay fixed?

That single computation is already fatal: a linear map is required to send the zero vector to the zero vector (put c=0 into the scaling rule: T(\vec 0)=T(0\cdot\vec v)=0\cdot T(\vec v)=\vec 0). Translation fails before we even reach additivity. For the record, additivity fails too — take \vec u=(1,0) and \vec v=(0,1):

(4,3) \neq (7,5). Sliding the whole plane sideways is a perfectly reasonable thing to want to do to a picture — it's just not a linear thing to do. (It has its own name, an affine transformation, and its own page.)

Worked example: a transformation that fails both properties badly

Squaring each coordinate, T(x,y) = (x^2, y^2), at least fixes the origin — T(0,0)=(0,0) — so the fast test alone can't catch it. Check additivity directly with \vec u=(1,0) and \vec v=(1,0), so \vec u+\vec v = (2,0):

4 \neq 2 — additivity is broken. Scaling fails too: with c=2, T(2\vec u) = T(2,0) = (4,0), but 2\,T(\vec u) = 2(1,0) = (2,0). Squaring bends every straight line (except the axes) into a curve, so it was always going to fail — but notice that fixing the origin was not enough on its own to guarantee linearity. Both promises have to be checked, every time.

What stays linear, what doesn't

Rotations, stretches, reflections and shears are all linear — every one of them passes both tests. Bending a line into a curve is not linear; nor is sliding the whole plane sideways (that moves the origin — it's an affine move). Because linear maps preserve the grid completely, they're pinned down entirely by where just two arrows go, T(1,0) and T(0,1) — the subject of the very next page.

See it explained