JOVANA
Explore Library Glossary Getting Started Three Levels Fields How it works Mission
Join the mission
All guides

Topological Vector Bundles, Grassmannians & Classifying Spaces

Every rank-n vector bundle on a reasonable space is pulled back from one universal bundle on the infinite Grassmannian — so classifying bundles becomes classifying maps up to homotopy. We build that miracle slowly, from clutching functions on the sphere to the homotopy classification theorem.

From smooth to topological: drop the manifold, keep the gluing

You arrive at this rung already fluent in the smooth vector bundle from the bundles rung: a base manifold, a fiber R^n, and the transition functions g_ij that record how local pieces glue. The first move here is a deliberate forgetting. A topological vector bundle of rank n over a topological space X is a continuous surjection pi: E -> X that is locally a product U x R^n, with transition functions g_ij: U_i cap U_j -> GL(n, R) that are merely continuous, not smooth — and X need not be a manifold at all, only a decent space (Hausdorff and paracompact is the safe setting we will assume throughout).

Why bother weakening the hypotheses? Because the questions that matter in this rung — how many bundles are there, what invariants tell them apart — are topological, not differential, and the topological category is where they have their cleanest answers. A surprising warm-up fact sets the tone: over a contractible space every vector bundle is trivial. So R^n carries only the boring bundle, and all the richness lives over spaces with topology, like spheres and projective spaces. Keep that in mind — bundle theory is interesting exactly to the extent that the base is not contractible.

Clutching: build a bundle on the sphere from one matrix-valued map

Before the general theorem, hold a concrete miracle in your hands: every vector bundle on a sphere S^k comes from a single map. Cover S^k by two contractible caps, the upper hemisphere D_+ and the lower D_-, overlapping in a thickened equator that retracts onto S^(k-1). Each cap is contractible, so any bundle is trivial over each — there is genuinely only one transition function to specify, the one on the overlap. That single continuous map f: S^(k-1) -> GL(n, R), called the clutching function, glues the two trivial pieces U_+ x R^n and U_- x R^n into a bundle on the whole sphere.

Now the punchline that previews the whole rung: two clutching functions give isomorphic bundles exactly when they are homotopic as maps S^(k-1) -> GL(n, R). So the rank-n bundles on S^k are in bijection with the homotopy classes [S^(k-1), GL(n, R)] — that is, with pi_(k-1)(GL(n, R)). Bundle classification has silently turned into a homotopy-group computation. The simplest live example: real line bundles on S^1 correspond to pi_0(GL(1, R)) = pi_0(R minus 0), which has two components (positive and negative determinant). Two bundles, exactly: the trivial cylinder and the Mobius band. The whole apparatus we are about to build is this example, made universal.

S^k  =  D_+  u  D_-   ,   D_+ n D_- ~ S^(k-1)

clutching function:   f : S^(k-1) -> GL(n, R)

   E_f  =  (D_+ x R^n)  u  (D_- x R^n)  /  (x, v)_- ~ (x, f(x) v)_+   for x in S^(k-1)

   { rank-n bundles on S^k }   <-->   [ S^(k-1) , GL(n,R) ]  =  pi_(k-1)( GL(n,R) )

   k = 1, n = 1:   pi_0( GL(1,R) ) = { + , - }   ->   cylinder  vs.  Mobius band
A clutching function f on the equator builds a bundle on S^k; isomorphism classes are homotopy classes of f, i.e. a homotopy group of GL(n,R).

Pullback: maps move bundles, and homotopic maps move them the same way

To universalize the clutching trick we need the operation that lets a map carry a bundle. Given a bundle pi: E -> Y and a continuous map f: X -> Y, the pullback bundle f*E over X has fiber over x equal to the fiber of E over f(x); concretely it is the subspace { (x, e) : f(x) = pi(e) } of X x E. In cocycle language pullback is effortless: if E is glued by transition functions g_ij on Y, then f*E is glued by the composites g_ij after f on X. Pullback is functorial — it respects composition and isomorphism — so it is exactly the gadget for transporting bundles backward along maps.

Everything downstream rests on one theorem, the homotopy invariance of pullback: if f and g: X -> Y are homotopic maps (with X paracompact), then f*E and g*E are isomorphic bundles. The intuition is that a homotopy is a bundle on X x [0,1], and a bundle on a cylinder is the same over both ends — you can slide an isomorphism along the interval. This is precisely why a contractible base forces triviality: a constant map and the identity are homotopic on a contractible space, and pulling back along a constant map gives the trivial bundle. Hold this result tight; it is the hinge on which the classification turns.

The infinite Grassmannian: the room where every bundle already lives

Here is the central object. The Grassmannian Gr(n, N) is the space of all n-dimensional linear subspaces of R^N — for instance Gr(1, N) is the space of lines through the origin, which is projective space RP^(N-1). Each point of Gr(n, N) is literally an n-plane, so there is an obvious bundle sitting on it: the tautological bundle, whose fiber over a plane P is that very plane P. Now let N grow without bound, nesting R^1 in R^2 in R^3 and so on; the union of the Grassmannians is the infinite Grassmannian Gr(n, infinity), and the tautological bundles assemble into one rank-n bundle on it, the universal bundle EG.

Why is Gr(n, infinity) the right room? Because a rank-n bundle on X is the same data as a continuous choice, for each point x, of an n-dimensional subspace of some big R^N into which the fiber E_x sits — and a continuous choice of n-planes is precisely a map X -> Gr(n, N). The bigger N is, the more room you have to spread the fibers out without collisions; in the limit Gr(n, infinity) has enough room for any bundle on any reasonable X. To make this honest you embed the bundle into a trivial bundle X x R^N (a partition of unity over paracompact X delivers the embedding), and the resulting map sending x to the fiber's image is your classifying map f: X -> Gr(n, infinity).

The classification theorem: bundles are homotopy classes of maps

Assemble the three ingredients and the theorem falls out. We have (1) the universal bundle EG on the classifying space BG = Gr(n, infinity); (2) pullback, which turns a map f: X -> BG into a bundle f*EG on X; and (3) homotopy invariance, which says homotopic maps give isomorphic bundles. The homotopy classification theorem states that for paracompact X the assignment f -> f*EG is a bijection from homotopy classes of maps [X, Gr(n, infinity)] onto isomorphism classes of rank-n vector bundles on X. Surjective because every bundle has a classifying map (the embedding above); injective because two classifying maps for isomorphic bundles can be connected by a homotopy.

Read what this buys you. A geometric question — classify the bundles on X — has become a homotopy-theoretic one — classify the maps X -> BG up to homotopy. The space BG = Gr(n, infinity) is also written BO(n) for real bundles (and BU(n) for complex bundles, the Grassmannian of complex n-planes), because its loop-and-twist structure encodes the orthogonal group O(n). Crucially this also explains the clutching computation: a bundle on S^k is a map S^k -> BO(n), so the set of them is pi_k(BO(n)), which standard homotopy theory identifies with pi_(k-1)(O(n)) — exactly the clutching answer, now derived from the universal picture rather than guessed sphere by sphere.

Why this is the launchpad for the rest of the rung

The classification theorem is the engine for everything that follows, and the mechanism is simple to state. A characteristic class is a rule that assigns to each rank-n bundle a cohomology class on the base, natural under pullback: c(f*E) = f*(c(E)). By the theorem every bundle is f*EG for some f, so a characteristic class is completely determined by its value on the universal bundle EG — that is, by a single cohomology class in H*(BO(n)). The entire theory of characteristic classes is therefore nothing but the computation of the cohomology ring of the classifying space, read back down via classifying maps. That is literally the content of Guide 2.

  1. Start with a rank-n vector bundle E -> X you want to understand.
  2. Embed its fibers into a big trivial bundle X x R^N using a partition of unity; this produces a classifying map f: X -> Gr(n, infinity) = BO(n).
  3. Recognize E as the pullback f*EG of the universal bundle, with f unique up to homotopy.
  4. Pull universal cohomology classes from H*(BO(n)) back along f to get the bundle's characteristic classes on X.

Let us close honestly on what was set up versus what is owed. We have only the static classification — a dictionary between bundles and homotopy classes of maps — and we have not yet computed a single cohomology ring, defined one characteristic class by formula, or touched K-theory. Even the tangent bundle TM of a manifold now has a classifying map M -> BO(n) (the Gauss map of the embedding into Euclidean space), and its homotopy class is a genuine invariant of the smooth structure — but extracting numbers from it is the next guides' job. Guide 2 computes H*(BO(n)) and H*(BU(n)) to define Stiefel-Whitney and Chern classes; Guide 3 packages all bundles into the group K(X); Guides 4 and 5 reach Bott periodicity, the Thom isomorphism, the Chern character, and Atiyah-Singer. Hold the universal-room picture close; it is the floor under all of it.