Null space (kernel) and column space (image) — basis, dimension: Visual walkthrough

Step 1 — What is a vector, and what is a matrix doing to it?

WHAT. A vector in $R^{n}$ is just a list of $n$ numbers — an arrow from the origin (the point $0$ ) to some spot. We write the input as $x$ . A matrix $A$ is a machine: feed it an arrow $x$ , and it returns a new arrow $A x$ , possibly living in a different-sized space $R^{m}$ .

WHY start here. Every symbol in the theorem — "input space", "output", "crushed to zero" — is meaningless until you can see the arrow going in and the arrow coming out. So first we watch one arrow make the trip.

PICTURE. On the left, the input plane $R^{2}$ with a blue arrow $x$ . On the right, the output space, with the yellow arrow $A x$ that the machine produced. The wavy arrow between them is the matrix $A$ acting.

Step 2 — The output can only ever be a blend of the columns

WHAT. Split $x = (x_{1}, x_{2}, \dots, x_{n})$ . Then $A x = x_{1} col 1 c_{1} + x_{2} col 2 c_{2} + \dots + x_{n} c_{n} .$ Here $c_{j}$ is the $j$ -th column of $A$ (itself an arrow in $R^{m}$ ), and $x_{j}$ is just a number — the amount of that column you switch on.

WHY this rewrite. It reveals the deepest fact of the whole topic: the output is always a weighted sum of the columns. Nothing $A$ can ever produce escapes the set of column-blends. That set has a name — the column space $Col (A)$ . So "which outputs are reachable?" is answered entirely by the columns.

PICTURE. The three columns $c_{1}, c_{2}, c_{3}$ drawn as coloured arrows from the origin; the output $A x$ built by stacking scaled copies of them tip-to-tail. Move the sliders $x_{j}$ and $A x$ roams the shaded region — that shaded region is $Col (A)$ .

Step 3 — Some columns are fakes: they add no new direction

WHAT. Suppose column $c_{3}$ already equals a blend of $c_{1}$ and $c_{2}$ , say $c_{3} = 2 c_{1} - c_{2}$ . Then switching on $c_{3}$ reaches nowhere the first two didn't already reach. We call $c_{3}$ dependent. A column that does reach somewhere new is independent — a pivot column.

WHY this matters for size. The dimension of the column space (how many independent directions it spans) counts only the pivot columns. That count is the rank $r$ . Fakes are free riders.

PICTURE. Two solid pivot arrows $c_{1}, c_{2}$ span a flat plane (shaded). The dependent arrow $c_{3}$ lies flat inside that same plane — dashed, contributing no new dimension.

Step 4 — A fake column hands you a free direction that gets crushed

WHAT. Take the same relation $c_{3} = 2 c_{1} - c_{2}$ , i.e. $2 c_{1} - c_{2} - c_{3} = 0$ . Read it as a recipe for an input that outputs nothing: choose $x = (2, - 1, - 1)$ . Then $A x = 2 c_{1} - c_{2} - c_{3} = 0.$ This input $x$ is non-zero, yet $A$ sends it to the zero arrow. It is a member of the null space $Null (A) = {x : A x = 0}$ .

WHY. Every dependent (free) column gives one such recipe — one genuine direction in the input space that $A$ collapses to a single point. So free columns and null-space directions are the same coins, seen from the input side.

PICTURE. Left: the input arrow $x = (2, - 1, - 1)$ living in $R^{3}$ , sitting on the null line (red). Right: its image is the single point $0$ — the whole red line on the left is squashed onto that one dot on the right.

Step 5 — Every column is a pivot OR free. Never both, never neither.

WHAT. March through the $n$ columns one at a time. Each column, when row reduction reaches it, either introduces a brand-new leading 1 (pivot → new output direction, counted in rank) or does not (free → dependent, gives a crushed input, counted in nullity). There is no third option, and a column cannot be both.

WHY this is the whole theorem. We are partitioning one set — the $n$ columns — into exactly two labelled buckets. Partitioning means the bucket sizes add to the total: $all columns n = r (# pivots) + n - r (# free) .$

PICTURE. A row of $n$ column-tokens; each is coloured green (pivot) or red (free) — never grey (unassigned), never striped (both). Count green, count red, they tile the full strip.

Step 6 — Edge case A: nothing gets crushed (injective)

WHAT. If every column is a pivot, $r = n$ , so nullity $= n - n = 0$ . The only input crushed to $0$ is $x = 0$ itself. The null space is just the origin, a single point of dimension $0$ .

WHY. No free columns means no free dials, means no non-trivial recipe for zero. Distinct inputs give distinct outputs — the map is injective.

PICTURE. Input plane maps to an output plane with no squashing — a full-dimensional shadow, the red null "line" shrunk to the single origin dot.

Step 7 — Edge case B: everything gets crushed (zero matrix)

WHAT. If $A = 0$ (the all-zeros $m \times n$ matrix), no column reaches anywhere: $r = 0$ . Then nullity $= n - 0 = n$ : the entire input space is crushed to the single output point $0$ . Column space is ${0}$ , dimension $0$ .

WHY show it. It is the mirror image of Step 6 and confirms the theorem still balances at the extreme: $0 + n = n$ . The reader must never meet a case we skipped — here nothing survives, everything is crushed, and the sum still checks.

PICTURE. The whole blue input plane collapses onto one dot; the output "space" is just that origin dot. Rank bucket empty, null bucket full.

Step 8 — The mixed case, fully worked (parent's Example 1)

WHAT. $A = 1312622634126$ reduces to RREF with pivots in columns 1 and 3. So $r = 2$ , and columns 2 and 4 are free, giving nullity $2$ .

WHY revisit it as a picture. To see all three characters at once: 2 surviving directions (green pivots → a 2-D plane $Col (A)$ inside $R^{3}$ ), 2 crushed directions (red free → a 2-D plane $Null (A)$ inside $R^{4}$ ), summing to $n = 4$ .

PICTURE. Left half: the input strip of 4 tokens, columns 1,3 green and 2,4 red. Right half: the two special solutions $s_{1} = (- 2, 1, 0, 0)$ , $s_{2} = (0, 0, - 2, 1)$ as the null-space basis, each verified to land on $0$ .

The one-picture summary

Everything at once: the input space $R^{n}$ splits into a surviving part (dimension $r$ , drawn green, mapped faithfully onto $Col (A)$ ) and a crushed part (dimension $n - r$ , drawn red, squashed to the origin). The output space $R^{m}$ receives only the green shadow. Count the two coloured pieces of the input — they must rebuild the full $n$ .

Recall Feynman retelling: the whole walkthrough in plain words

A matrix is a machine that takes an arrow in and hands an arrow out. Whatever it hands out is always a mix of its column-arrows (Step 2), so the reachable outputs are exactly the column blends — the column space. Some columns are genuine new directions (pivots) and some are fakes that copy the others (Steps 3). Every fake column secretly tells you an input the machine crushes to nothing — because "col 3 equals 2·col 1 minus col 2" rearranges into "some input maps to zero" (Step 4). Now line up all $n$ columns and colour each one: green if it's a genuine new direction, red if it's a fake. There's no in-between (Step 5). The greens count the rank (how many output directions survive); the reds count the nullity (how many input directions get crushed). Since every column got exactly one colour, greens + reds = all columns = $n$ . That single sentence is Rank–Nullity. And it never breaks: if nothing's crushed the map is injective (Step 6), if everything's crushed it's the zero matrix (Step 7), and a normal mixed matrix like Example 1 splits 2 and 2 to make 4 (Step 8).

Connections

Rank–Nullity Theorem — this page is its visual derivation.
Rank of a matrix — the green count $r = dim Col (A)$ .
Row reduction & RREF — how we sort columns into green/red.
Linear independence and basis — pivots = independent = green.
Injective and surjective linear maps — Step 6's trivial kernel.
Four fundamental subspaces — Col and Null are two of the four.
Solving Ax=b — solutions = one particular arrow + the whole red crushed plane.
↑ Parent topic