A transformation is linear if it satisfies exactly two properties: it preserves addition, and it preserves scalar multiplication. These two rules are the complete test. If a transformation passes both, it’s linear. If it fails either one, it’s not.
The Two Rules That Define Linearity
A transformation T takes an input vector and produces an output vector. For T to be linear, it must obey two conditions for every possible input:
- Additivity: T(u + v) = T(u) + T(v). If you add two vectors first and then transform the result, you get the same output as transforming each vector separately and then adding.
- Homogeneity: T(cv) = cT(v). If you scale a vector by some number c and then transform it, you get the same result as transforming the vector first and then scaling the output by c.
That’s it. These two properties are sometimes called “superposition,” and they capture everything it means for a transformation to be linear. You can also combine them into a single equivalent condition: T(au + bv) = aT(u) + bT(v) for all vectors u and v and all scalars a and b. This compact version says the transformation respects any linear combination of inputs.
Why the Origin Must Stay Fixed
One immediate consequence of the two rules is that a linear transformation always maps the zero vector to the zero vector. You can see this by plugging c = 0 into the homogeneity rule: T(0·v) = 0·T(v), which gives T(0) = 0. This isn’t a separate requirement you need to check. It falls out automatically from the definition. But it’s a useful quick test: if a transformation sends the origin somewhere else, it cannot be linear, and you don’t need to investigate further.
What Linear Transformations Look Like Geometrically
Thinking visually helps build intuition. Imagine a grid of evenly spaced lines covering a plane. When you apply a linear transformation, three things are always true: the origin stays put, straight lines remain straight, and the spacing between parallel lines stays even (though the lines themselves may tilt, stretch, or compress). The grid can warp dramatically, but it never curves or folds.
All the classic geometric operations you encounter in a linear algebra course are built from this idea. Rotations, reflections, scaling (stretching or shrinking along an axis), shearing, and projections all satisfy additivity and homogeneity. A rotation by 45 degrees, for example, spins every vector by the same angle. Doubling the input vector before rotating gives the same result as rotating first and then doubling. That consistency is exactly what the two rules guarantee.
What Fails the Test
Comparing linear transformations to nonlinear ones makes the rules concrete. Consider T(v) = v + [1, 0], which shifts every point one unit to the right. This is a translation, and it breaks linearity immediately because T(0) = [1, 0], not the zero vector. The origin moved, so it’s out.
Now consider T(x) = x², applied to each component of a vector. Take two numbers, say 2 and 3. T(2 + 3) = T(5) = 25, but T(2) + T(3) = 4 + 9 = 13. Those aren’t equal, so additivity fails. Squaring is not a linear operation.
Any transformation that involves adding a constant, squaring, taking absolute values, or applying thresholds (like rounding or clamping) will break at least one of the two rules. The core pattern: linear transformations can scale and mix the components of a vector, but they cannot shift, curve, or clip it.
Every Linear Transformation Has a Matrix
One of the most powerful results in linear algebra is that every linear transformation from one finite-dimensional space to another can be written as multiplication by a matrix. If T is a linear transformation that takes vectors with n components and outputs vectors with m components, there is always an m×n matrix A such that T(v) = Av for every input v.
You find this matrix by checking what T does to each of the standard basis vectors (the vectors with a 1 in one position and 0s everywhere else). The outputs become the columns of A. Once you have the matrix, you have a complete recipe for the transformation. This is why matrices dominate so much of applied math, physics, and computer graphics: they are a compact way to encode any linear operation.
Conversely, every matrix defines a linear transformation. If someone hands you a matrix and asks you to multiply vectors by it, the resulting operation automatically satisfies additivity and homogeneity. The matrix form and the two-rule definition are two sides of the same coin.
How to Prove a Transformation Is Linear
If you’re working a homework problem or verifying linearity in practice, the process is straightforward. Take two arbitrary vectors u and v and an arbitrary scalar c, then check the two rules algebraically.
Start by computing T(u + v) using whatever formula defines T. Separately compute T(u) + T(v). If they match for all possible u and v, additivity holds. Then compute T(cv) and compare it to cT(v). If those match for every v and every scalar c, homogeneity holds, and the transformation is linear.
To disprove linearity, you only need a single counterexample. Find one pair of vectors where additivity breaks, or one vector and one scalar where homogeneity breaks. A good first move is to check whether T(0) = 0. If it doesn’t, you’re done in one step.
Why Linearity Matters Beyond Math Class
The reason these two simple rules get so much attention is that linear systems are dramatically easier to analyze than nonlinear ones. When a transformation is linear, you can break a complicated input into simple pieces, transform each piece separately, and add the results back together. This “divide and conquer” approach, often called the superposition principle, is the foundation of signal processing, structural engineering, quantum mechanics, and machine learning.
In computer graphics, every time a 3D model is rotated, scaled, or projected onto a 2D screen, the operation is a linear transformation encoded as a matrix. The fact that these operations compose neatly (multiplying matrices together gives another matrix) makes real-time rendering possible. Nonlinear operations require more computational effort and don’t combine as cleanly, which is exactly why engineers care so much about identifying which parts of a system are linear and which aren’t.