Earning the Plane

By the end of this section you will know exactly what a second ruler buys you: the difference between being stuck on a line and owning the entire plane. Section 1 left you with one vector and one line. Everything off that line was, for now, unreachable. This section hands you a second ruler and asks the only question that matters: does it point somewhere new?

What You Will Be Able to Do

The Big Picture: A Second Ruler Unlocks the Plane

Add a second ruler, placed perpendicular to the first: $\hat{\jmath} = (0, 1)$. Now every point you build is a combination of two independent scalings — one along each ruler:

Try to reach a specific target, say $(3, 2)$. Because the two rulers point along the two axes, the recipe reads straight off the coordinates:

There is nothing special about $(3, 2)$ — the same recipe works for every point in the plane. Pick any target $(a, b)$ and the weights $x = a$, $y = b$ rebuild it exactly. That is the entire difference one extra, genuinely new ruler makes: the reachable set jumps from a single line to the whole plane.

Two vectors whose combinations reach everywhere are called a basis for that plane, and “everywhere they can reach” is, once again, their span. When the span is the entire plane, you are looking at a full two-dimensional vector space — not because someone declared it one, but because two rulers, used together, are provably enough to build every point in it.

Why Perpendicular? Choosing Our Grid

We placed $\hat{\jmath}$ perpendicular to $\hat{\imath}$ — but nothing about “spanning the plane” required that angle. Any second vector that does not lie on $\hat{\imath}$'s line would have earned the same result: two genuinely different directions, combined, reach everywhere. Perpendicular is not the price of admission to a two-dimensional span; it is simply the convention we chose for our grid — the one where reading off coordinates is as easy as looking straight across and straight up.

Naming the Grid: The Matrix Is the Blueprint

Once a set of rulers exists, it deserves a name. Stack $\hat{\imath}$ and $\hat{\jmath}$ side by side as the columns of a single object:

That matrix $A$ is the grid's blueprint — not a description of it, the thing itself. Its first column is $\hat{\imath}$, its second column is $\hat{\jmath}$, and “the columns of $A$ are the basis” is just another way of saying what this whole section has been building toward: every point of the plane is some combination $x \cdot \hat{\imath} + y \cdot \hat{\jmath}$ of those two columns.

See It: Watch the Line Flood Into a Plane

The same Grid Builder widget from Section 1 continues here, picking up right where the refusal left off. It opens on Stage 3 — ĵ already added, the matrix already named — and lets you go on to Stage 4.

What to look for: in Stage 3, scrub $x$ and $y$ independently and watch the reachable region flood from the single highlighted line of Section 1 out to fill the entire grid — the veil is gone, because nothing is unreachable anymore. In Stage 4, î and ĵ become draggable handles (or type the matrix directly): drag one onto the other's line and watch the rank chip drop from 2 to 1 in real time, as the amber constructed grid — drawn over the cyan ghost of the original identity grid — thins from a plane back into a line. That collapse is Section 1's refusal, replayed live: a dependent second column buys the grid nothing.

From Scratch: Is a Target Reachable?

“Span = the whole plane” is a claim about every point, not just the one we worked by hand. The cleanest way to convince yourself is to test it in code: pick a target, solve the little $2 \times 2$ system for the weights, and confirm you always find an answer when the basis is $\{\hat{\imath}, \hat{\jmath}\}$.

⬇ input: target = (3.0, 2.0), basis = ((1,0), (0,1))

b1x=1.0, b1y=0.0, b2x=0.0, b2y=1.0

det = 1.0*1.0 - 0.0*0.0 = 1.0  (nonzero -> the plane is spanned)

abs(1.0) < 1e-9 is False -> continue

x = (3.0*1.0 - 2.0*0.0) / 1.0 = 3.0

y = (1.0*2.0 - 0.0*3.0) / 1.0 = 2.0

weights = (3.0, 2.0)

rebuilt = (3*1 + 2*0, 3*0 + 2*1) = (3.0, 2.0)

random_target ≈ (2.79, -1.51)  (seeded, so reproducible)

stdout: random target (2.79, -1.51) -> (2.79, -1.51)

1def reachable_2d(target, basis):
2    # Can 'target' be written as x*b1 + y*b2 for the two vectors in basis?
3    # Solve the little 2x2 system by hand (Cramer's rule).
4    (b1x, b1y), (b2x, b2y) = basis
5    tx, ty = target
6
7    det = b1x * b2y - b1y * b2x        # determinant of [b1 | b2]
8    if abs(det) < 1e-9:
9        return None                    # the basis is degenerate -- a line, not a plane
10
11    x = (tx * b2y - ty * b2x) / det    # weight on b1 (i_hat)
12    y = (b1x * ty - b1y * tx) / det    # weight on b2 (j_hat)
13    return (x, y)
14
15i_hat = (1.0, 0.0)
16j_hat = (0.0, 1.0)
17target = (3.0, 2.0)
18
19weights = reachable_2d(target, (i_hat, j_hat))
20print("(3, 2) =", weights, "as (x, y) on (i_hat, j_hat)")
21
22# Verify: x*i_hat + y*j_hat should reproduce the target exactly.
23x, y = weights
24rebuilt = (x * i_hat[0] + y * j_hat[0], x * i_hat[1] + y * j_hat[1])
25print("rebuilt:", rebuilt, "-> reached" if rebuilt == target else "-> unreachable")
26
27# Because det != 0, {i_hat, j_hat} spans the WHOLE plane -- try a random target.
28import random
29random.seed(0)
30random_target = (random.uniform(-5, 5), random.uniform(-5, 5))
31print("random target", random_target, "->", reachable_2d(random_target, (i_hat, j_hat)))

The function reproduces the (3, 2) recipe worked out earlier, and then finds weights for a random target too — because $\det A \neq 0$, reachable_2d never returns None for this basis. That is the numeric signature of “span = the whole plane.”

Common Misconceptions

“Any two vectors span the plane”

Why it is tempting: Section 1 ended on one vector reaching only a line, so it is tempting to assume any second vector automatically fixes that. Correction: the second vector has to point somewhere the first one does not already reach — off its line entirely. Two parallel vectors, even two different-length ones, replay Section 1's refusal: still just a line. Example: $\{(1,0), (2,0)\}$ does not span the plane — both point along the x-axis, so the “grid” is still 1-dimensional; rank stays 1, not 2.

“The rulers must be perpendicular to span the plane”

Why it is tempting: this section's worked example uses perpendicular unit vectors, and the coordinate recipe reads off so cleanly that it feels load-bearing. Correction: perpendicularity was a choice for this grid, made because it is convenient — not a requirement for spanning. Any two vectors pointing genuinely different ways span the plane; a later section in this chapter builds a skewed, non-perpendicular grid that still reaches every point. Example: $\{(1, 0), (1, 1)\}$ are not perpendicular, yet they still reach every point of the plane — the recipe is just less obvious to read off by eye.

Summary

Practice Problems

1. Express the point $(-1, 4)$ in terms of $\hat{\imath}$ and $\hat{\jmath}$ — that is, find $x$ and $y$ with $(-1, 4) = x \hat{\imath} + y \hat{\jmath}$.
Hint: because î and ĵ point along the axes, the weights are just the coordinates themselves.

2. Why can't two copies of $\hat{\imath}$ reach $(0, 1)$, no matter how you scale them?
Hint: revisit the refusal from Section 1 — what is the second coordinate of any multiple of $\hat{\imath}$?

3. Which points of the plane does $\text{span}\{\hat{\imath}\}$ miss, and why does adding $\hat{\jmath}$ — but not a second î — fix that?
Hint: span{î} is the x-axis; name a point off it and say which new ruler reaches it.

Concept Map

Section 1 built one ruler and one line, then showed that a duplicate ruler cannot grow it. This section handed the grid a genuinely new ruler and watched the reach jump all the way to the plane — and gave that construction a name, the matrix.

Next up, §3 — Any Independent Pair Builds a Grid drops the requirement that the rulers be perpendicular or unit length, and shows that any independent pair draws its own transformed grid — with the identity grid from this section still ghosted silently behind it.