➡️Vectors in n Dimensions

In the Trig Kingdom a vector was an arrow on a page: two numbers, how far across and how far up. On this isle it is something plainer and far more useful. A vector is an ordered list of numbers, and nothing in the arithmetic ever cared how many numbers were in it.

u = [3, -1, 4] a vector in R³ v = [2, 0, -5, 1] a vector in R⁴

Rⁿ is the name for the set of all lists of n numbers, so R² is the plane you already know, R³ is space, and R⁷ is a perfectly ordinary place to work that simply cannot be drawn. Each number in the list is an entry or a component, and its position matters: [3, -1, 4] and [4, -1, 3] are different vectors, exactly as (3, -1) and (-1, 3) were different points.

Two vectors are equal when they have the same length of list and agree in every slot. A vector in R³ is never equal to a vector in R⁴, however similar the numbers look — there is no rule for comparing lists of different lengths, and no rule for adding them either.

Why bother? Because lists of numbers are everywhere once you look. A shop's stock is a list of counts. A student's term is a list of scores. A colour is a list of three brightnesses. A recipe is a list of quantities. Every one of them can be added, scaled, measured and compared with the rules below, and the rules are the same for all of them.

Gatekeeper Nore's habit is worth copying. He never says where a place is; he says which way and how far along each ruled line. A vector is that instruction, written down.

Two operations do almost all the work, and both of them are done one slot at a time.

Addition and subtraction pair the entries off by position:

[3, -1, 4] + [2, 5, -1] = [3 + 2, -1 + 5, 4 + (-1)] = [5, 4, 3] [3, -1, 4] - [2, 5, -1] = [1, -6, 5]

The first entries only ever meet other first entries. Nothing crosses between the slots, ever, and that single fact is what makes vectors in seventeen dimensions no harder than vectors in two.

Scalar multiplication stretches the whole list by one number:

3[2, -1, 5] = [6, -3, 15] -2[2, -1, 5] = [-4, 2, -10]

A scalar is just an ordinary number, and it multiplies every entry. The commonest error in this whole craft is letting a scalar reach only the first slot, which quietly bends the direction into something else entirely. A negative scalar turns the vector round to point the opposite way, and it does that by changing the sign of every entry, not one of them.

Put the two together and you get a linear combination such as 3u - 2v + w: scale each vector first, then add what is left. Work down the slots and write one line per slot; it is slower to read and much faster to get right.

The laws you would expect all hold, and each is really a rule about one slot repeated down the list:

• ◆u + v = v + u — addition is commutative.
• ◆(u + v) + w = u + (v + w) — addition is associative, so brackets do not matter.
• ◆u + 0 = u, where 0 is the vector with every entry zero.
• ◆u + (-u) = 0 — every vector has an opposite, and it is the whole vector negated.
• ◆c(u + v) = cu + cv and (c + d)u = cu + du — a scalar in front of a bracket reaches everything inside it.

Pythagoras does not stop at two legs. The magnitude or length of a vector is

|u| = sqrt(u1^2 + u2² + ... + un²)

Square every entry, add all the squares, take one square root at the end. For u = [1, 2, 2]: 1 + 4 + 4 = 9, so |u| = 3.

Three things fall out of the formula. Squaring removes every minus sign, so a length is never negative and a vector is exactly as long as its opposite. The squares are added before the root, never after — sqrt(9) + sqrt(16) is 7, but sqrt(9 + 16) is 5, and only the second is a length. And the length is not the sum of the entries: walking along each ruled line in turn is always at least as far as going straight there.

The distance between two points P and Q in Rⁿ is the length of the vector between them:

distance = |Q - P|

Subtract slot by slot first, then measure. The order of the subtraction cannot change the answer, because squaring wipes out the difference.

A unit vector has length exactly 1. It carries a direction and nothing else, and you build one by dividing a vector by its own length:

u / |u|

For u = [1, 2, 2] with |u| = 3, the unit vector is [1/3, 2/3, 2/3]. Check it: 1/9 + 4/9 + 4/9 = 1. Every entry is divided, and it is divided by the length — not by one of the entries, and not by the length squared. A quick sanity check: every entry of a unit vector sits between -1 and 1.

That gives a recipe worth remembering. To build a vector of length L in the direction of u: shrink to 1, then stretch to L, which is the same as multiplying u by L / |u| in one go.

The dot product of two vectors of the same length is a single number:

u . v = u1v1 + u2v2 + ... + unvn

Pair the entries off, multiply each pair, add all the products. For u = [3, -1, 2] and v = [1, 4, 2]: (3)(1) + (-1)(4) + (2)(2) = 3 - 4 + 4 = 3.

Notice what it is not. It is not a vector — the slots are gone by the time you finish. It is not the product of the lengths. And it is not always positive: a negative product from one slot pulls the whole total down, and that is exactly how a dot product reaches zero.

Which brings us to the reason the dot product exists. Two vectors are orthogonal — at right angles — exactly when

u . v = 0

In R² you can see it. In R⁷ you cannot, and this equation is what "at right angles" now means. It is a definition that agrees with the picture wherever a picture exists, and carries on working where one does not.

Two useful consequences. First, u . u = |u|², so the dot product of a vector with itself is its length squared — the magnitude formula in disguise. Second, a vector is never orthogonal to itself unless every entry is zero, and never orthogonal to its own opposite.

Orthogonality is often asked backwards: which value of k makes these two perpendicular? Write the dot product down with k still in it, and it comes out as one equation in one unknown.

u = [3, -2, 5], v = [4, 1, k] u . v = 12 - 2 + 5k = 10 + 5k Set that to 0: 5k = -10, so k = -2.

A line in the plane has an equation y = mx + c, which is no use at all in R³ — there is no single slope. Vectors give a description that works in every dimension, and it is Nore's description exactly: where you start, and which way you go.

r(t) = p + t*d

Here p is a point on the line, d is the direction vector telling you which way it runs, and t is the parameter, a number saying how far along you have travelled. Every value of t gives one point of the line, and every point of the line comes from one value of t.

r(t) = [1, 3, 4] + t*[1, 2, 4] at t = 0: [1, 3, 4] the starting point itself at t = 2: [3, 7, 12] at t = -1: [0, 1, 0] the other side of the start

The parameter multiplies only the direction. The starting point is where the line already is and is never scaled. A negative t simply walks the other way down the same line.

Through two points. If a line passes through P and Q, its direction is the vector from one to the other:

d = Q - P, so r(t) = P + t*(Q - P)

Check it by putting t = 1 back in: you should land exactly on Q. Subtracting the wrong way round, P - Q, gives a direction pointing back the way it came, and every point you compute after that sits on the wrong side of P.

Going backwards. Given a point that lies on the line, the parameter is found by subtracting the starting point and seeing how many copies of the direction are left. One slot is enough to find t; the other slots are the check that the point really is on the line, because the same t has to work in all of them.