Vectors: Lists of Numbers You Can Picture

A vector is a list of numbers

Start with the whole idea in one line: a vector is an ordered list of numbers. That’s it. Here’s one:

We write a vector with a bold letter and stack its numbers in square brackets. Each number is a component. We name them by position: $a_1 = 3$ is the first component, $a_2 = 1$ the second, $a_3 = 4$ the third — in general $a_i$ (“a-sub-$i$”) is the number in slot $i$. The count of numbers is the vector’s dimension, written $n$. Our $\mathbf{a}$ has $n = 3$.

You already use vectors without the name. A color on a screen is three numbers — how much red, green, and blue — so a color is a 3-dimensional vector $[R,\, G,\, B]$. Drag the sliders and watch the list and the color move together:

The same list is also an arrow

When a vector has 2 or 3 components, you can draw it. Read $[3,\, 1]$ as directions: start at the origin, go 3 right and 1 up, and draw an arrow to where you land. Same numbers, now you can see them.

So every vector has two faces: a list (good for computing) and an arrow (good for seeing). We’ll switch between them freely.

Two quick but important details:

• Order matters. $[3,\, 1]$ points to a different place than $[1,\, 3]$. Swapping components moves the arrow.
• Equal means equal everywhere. Two vectors are the same only if every component matches: $[3,\,1] = [3,\,1]$, but $[3,\,1] \neq [3,\,2]$.
• The zero vector $\mathbf{0} = [0,\, 0]$ is the arrow that goes nowhere — it just stays at the origin.

Adding vectors

To add two vectors of the same length, add them slot by slot:

Worked example. With $\mathbf{a} = [2,\, 1]$ and $\mathbf{b} = [3,\, -2]$:

Geometrically, addition is tip-to-tail: walk along $\mathbf{a}$, then from where you stop, walk along $\mathbf{b}$. Where you end up is $\mathbf{a} + \mathbf{b}$. Drag the blue and green arrows and watch the orange sum update:

Scaling vectors

To scale a vector by a single number $c$ (called a scalar), multiply every component by $c$:

Worked example. With $\mathbf{a} = [3,\, -1]$:

• $2\mathbf{a} = [6,\, -2]$ — same direction, twice as long.
• $\tfrac{1}{2}\mathbf{a} = [1.5,\, -0.5]$ — same direction, half as long.
• $-1\,\mathbf{a} = [-3,\, 1]$ — same line, opposite direction. A negative scalar flips the arrow.

The slider in the playground above scales the blue arrow — drag it past zero to watch it flip.

Subtracting vectors

Subtraction is just adding a flipped vector: $\mathbf{a} - \mathbf{b} = \mathbf{a} + (-1)\mathbf{b}$, which works out component-wise to

Worked example. With $\mathbf{a} = [5,\, 2]$ and $\mathbf{b} = [1,\, 3]$:

There’s a clean picture: $\mathbf{a} - \mathbf{b}$ is the arrow from $\mathbf{b}$‘s tip to $\mathbf{a}$‘s tip — “what you’d add to $\mathbf{b}$ to reach $\mathbf{a}$.” Drag the two arrows and watch the difference:

Same size or it doesn’t work

Addition, subtraction, and the element-wise product (next) all pair up matching slots — so both vectors must have the same dimension. You cannot add $[1,\, 2]$ and $[1,\, 2,\, 3]$: the first vector has no third slot to pair with the $3$, so the operation is undefined.

Scaling is the one exception — it’s a single number times the vector, so it works on a vector of any size.

Two ways to multiply vectors

There’s no single “vector times vector.” The two products that matter for AI are:

1. Element-wise (the Hadamard product, written $\odot$). Multiply matching slots; the result is a vector of the same size.

Worked example. $[2,\, 3] \odot [4,\, -1] = [2\cdot4,\ 3\cdot(-1)] = [8,\, -3]$. Models use this to gate — turning some features of a vector up and others down.

2. The dot product (written $\cdot$). Multiply matching slots, then add them all into one single number.

Worked example. $[2,\, 3] \cdot [1,\, 4] = 2\cdot1 + 3\cdot4 = 2 + 12 = 14$.

That one number measures how much two vectors point the same way — it’s the engine behind attention and similarity search, so it gets its own lesson soon (Lesson 3). For now, just be able to compute it. The playground above shows both $\mathbf{a}\odot\mathbf{b}$ and $\mathbf{a}\cdot\mathbf{b}$ live as you drag.

Why this matters

Transformers don’t read words — the first thing a model does is turn each token into a vector of learned numbers called an embedding, exactly like a color is a list of numbers. From there, the machinery is the moves you just learned: attention adds vectors together (weighted by how relevant they are), scales them, and uses the dot product to decide how much each token should attend to another; the residual stream is one long running sum. Get these operations, and the rest of the course has solid ground to stand on.

When you’re ready, the assessment mixes all of this — including a few that make you combine several moves in one go.