When the Grid Refuses to Build

By the end of this section you will recognize the moment a grid collapses — when a second vector promises a new direction and delivers none. Section 3 showed that any pair of genuinely different directions builds a working grid. This section shows what happens when they are not genuinely different: the construction does not just work worse, it fails outright, and the plane you hoped for stays a line.

What You Will Be Able to Do

The Big Picture: A Pair That Cannot Build Anything New

Start with one working ruler, $\vec v = (1, 2)$. By itself it spans a line: every scaling $t\vec v$ lands somewhere on that line, and nowhere else. Now hand the grid a second vector, $\vec w = (3, 6)$, hoping it opens up the plane the way Section 3’s pairs did.

It does not — because $\vec w$ is not a new direction at all:

Every combination $x\vec v + y\vec w$ is really $x\vec v + y(3\vec v) = (x + 3y)\vec v$ — still just some multiple of $\vec v$. No matter how you scale and mix the two, you never leave the original line. The grid you were promised — two vectors, a whole plane — never gets built. $\vec w$ is extra: it cannot help the set reach anywhere$\vec v$ could not already reach alone.

This is the constructive picture of linear dependence: a set is dependent when one of its vectors is redundant in exactly this way — reachable from the others, contributing zero new reach. The later sections make this precise with a single number, the determinant, that goes to zero at the exact instant a pair collapses like this.

The Owner's Two Examples, Worked

The teaching notes behind this chapter work through this exact failure twice, with two concrete matrices. Both are worth doing by hand, because the second one forces a small but important detour into how a matrix gets written down.

Two copies of the same direction

The plainest possible case: hand the grid the same vector twice. Naming $\vec b_1 = (1, 0)$ and $\vec b_2 = (1, 0)$ as the columns of a matrix,

every combination collapses the same way Section 3’s example did — just with the scalar equal to exactly 1 this time:

No matter what $x$ and $y$ you pick, the result is always some multiple of $(1, 0)$ — every reachable point sits on the x-axis. Two vectors went in; one dimension came out.

The notes' second example — and a convention to reconcile

The handwritten notes give a second version of the same failure, written as “A = [1, 0; 2, 0]”. Read literally as a matrix with rows separated by the semicolon, that is:

Every matrix in this book — and in the studio — is written the other way: basis vectors as columns, not rows. The same two vectors, $\vec b_1 = (1, 0)$ and $\vec b_2 = (2, 0)$, filed as columns instead of rows, give:

$A$ is literally the transpose of $A_{\text{notes}}$ — same two vectors, same information, just filed by rows instead of columns. From here on this chapter uses the column form, matching every other matrix in the book; keep the transpose in mind if you ever compare notes against the original handwritten pages.

With $\vec b_2 = (2, 0) = 2\vec b_1$, the same collapse happens, just scaled:

Again, every combination is stuck as a multiple of $\vec b_1$ — still just the x-axis, still just one dimension, however you scale $y$.

The Determinant Catches It

Both collapses leave a fingerprint in the numbers themselves. For a $2 \times 2$ matrix $\begin{bmatrix} a & b \\ c & d \end{bmatrix}$, the determinant is $ad - bc$. Work it out for both examples, digit by digit.

First example, $A = \begin{bmatrix} 1 & 1 \\ 0 & 0 \end{bmatrix}$ ($a=1, b=1, c=0, d=0$):

Second example, $A = \begin{bmatrix} 1 & 2 \\ 0 & 0 \end{bmatrix}$ ($a=1, b=2, c=0, d=0$):

Both come out exactly zero — not a coincidence of these particular numbers, but the signature of the failure itself. A nonzero determinant measures how much the unit square's area got stretched by the transformation; a collapsed grid has no area left to stretch, because it never leaves a line. Dependence, one vector is extra, and det = 0 are three ways of saying the exact same thing.

One more detail worth being precise about: which vector is “extra” is not unique. In the second example you could just as well keep $\vec b_1 = (1, 0)$ and call it the redundant one, dropping it in favor of $\vec b_2 = (2, 0)$ alone — the reachable set (the x-axis) is identical either way. Dependence is a property of the pair, not a label stuck to one vector.

See It Live: Finish the Collapse

The viewer below opens on Stage 4 — Your Grid. Open the presets list and choose “The notes' example — finish the collapse”. It loads $\vec b_1 = (1, 0)$ and $\vec b_2 = (2, 0.35)$ — deliberately not yet the notes' exact $(2, 0)$. The rank chip still reads 2 and the amber grid still (barely) covers the plane, because $\vec b_2$ has not quite lined up with $\vec b_1$ yet.

Drag the green handle ($\vec b_2$) straight down onto the x-axis, landing on $(2, 0)$ — the exact point worked out above. Watch the rank chip flip from 2 to 1 the instant it lands, the amber grid thin out to a single line, and a dashed red null-space direction appear. That is the collapse this section has been describing, built with your own hands instead of read off a page.

Checking Rank With NumPy

In practice nobody computes a 2×2 determinant by hand to check for collapse — you ask for the rank directly. $\texttt{np.linalg.matrix\_rank}$ reads the rank off a singular value decomposition, tolerant of floating-point noise. Compare this section's collapsed matrix against Section 3’s full-rank one:

after import: np.linalg.* available

⬆ A_collapsed.shape = (2, 2)

⬆ A_full_rank.shape = (2, 2)

stdout: rank(A_collapsed) = 1

stdout: rank(A_full_rank) = 2

1import numpy as np
2
3A_collapsed = np.array([[1.0, 2.0],
4                         [0.0, 0.0]])   # b1=(1,0), b2=(2,0) as columns
5
6A_full_rank = np.array([[1.0, -1.0],
7                         [1.0, 1.0]])   # u1=(1,1), u2=(-1,1) as columns
8
9print("rank(A_collapsed) =", np.linalg.matrix_rank(A_collapsed))
10print("rank(A_full_rank) =", np.linalg.matrix_rank(A_full_rank))

Same function, same tolerance-aware algorithm, two very different verdicts — because the two matrices really do describe two very different grids: one plane, one line.

Common Misconceptions

“Dependent means the vectors are equal”

Why it is tempting: the cleanest example — two copies of the same vector — makes it look like dependence requires literal equality. Correction: equality is only one way to be dependent; being collinear is enough. Any two vectors on the same line through the origin, however differently scaled or even pointing opposite ways, are dependent. Example: $\vec b_1 = (1, 0)$ and $\vec b_2 = (-3, 0)$ are not equal, not even the same length, and point in opposite directions — yet $\vec b_2 = -3\vec b_1$, so they are just as dependent as two literal copies. Every combination of the two still lands on the x-axis.

Practice Problems

Beginner

B1. For $A = \begin{bmatrix} 1 & 3 \\ 2 & 6 \end{bmatrix}$, compute $\det A$ and state whether the two columns are dependent.
Hint: is column 2 a scalar multiple of column 1?

Conceptual

C1. For $\vec b_1 = (1, 2)$, find every $\vec b_2$ that makes $\{\vec b_1, \vec b_2\}$ dependent. Describe the answer as a set, not a single vector.
Hint: dependence with $\vec b_1$ means lying on $\vec b_1$'s own line — every point of that line, for every real scalar $t$.

Coding

K1. Using NumPy, write a small function that takes a $2 \times 2$ array and prints “independent” or “dependent” based on $\texttt{np.linalg.matrix\_rank}$. Test it on both matrices from the worked examples above.
Hint: rank 2 means independent; rank less than 2 means dependent.