Kernel and Image, Without Coordinates

Two subspaces born from a map

Given T: V -> W, two sets organize everything. The kernel is everything that T sends to zero: ker T = { v in V : T(v) = 0 }. The image is everything T actually produces: im T = { T(v) : v in V }. We define both coordinate-free, straight from the map — no matrix needed.

Both are subspaces, and this is worth checking once by hand. If T(u) = 0 and T(v) = 0 then T(u + v) = T(u) + T(v) = 0, so ker T is closed under addition; scaling works the same way. The image is closed because T(u) + T(v) = T(u + v) is itself an output. In Vol I you knew these as the null space and column space of a matrix — same objects, now read off the map.

Injective, surjective, read off instantly

The kernel detects injectivity with a single clean test: T is injective (one-to-one) if and only if ker T = {0}. The proof is short. If ker T = {0} and T(u) = T(v), then T(u - v) = 0, so u - v lies in the kernel, forcing u = v. Conversely a nonzero kernel vector and 0 both map to 0, breaking injectivity.

The image detects surjectivity just as directly: T is surjective (onto) if and only if im T = W. A map that is both injective and surjective is an invertible map — it has a two-sided inverse. But beware: between spaces of unequal dimension you can have a one-sided inverse only, and the side that exists tells you exactly which of injective/surjective holds.

1. A left inverse L with L∘T = id_V exists exactly when T is injective (it undoes T on inputs).
2. A right inverse R with T∘R = id_W exists exactly when T is surjective (it hits every output).
3. When both hold, the left and right inverses coincide and T is genuinely invertible.

Rank-nullity, the abstract version

The kernel measures how much T collapses; the image measures how much survives. The total dimension of V splits perfectly between them. This is rank-nullity in abstract form: dim(ker T) + dim(im T) = dim V. No coordinates, no row reduction — it is a statement about the map.

T: R^3 -> R^3,  T(x, y, z) = (x + y, x + y, z)

Kernel: need x + y = 0 and z = 0
  ker T = { (t, -t, 0) }  -> dimension 1

Image: outputs look like (a, a, b)
  im T = { (a, a, b) }    -> dimension 2

Check rank-nullity:
  dim(ker T) + dim(im T) = 1 + 2 = 3 = dim R^3   OK