Module 1: Introduction to Vectors

4. Vectors in High Dimensions: From 3D to 1536D

Next →

Capsule overview

In this capsule you're going to make the most important conceptual leap of the module: understanding that high-dimensional vectors (100D, 1536D, 3072D) work exactly like 2D and 3D vectors, just with more axes. You won't be able to draw them, but all the geometric intuition (direction, magnitude, closeness) holds.

This capsule is crucial because in AI, real embeddings are high-dimensional vectors: OpenAI's text-embedding-3-small has 1536 dimensions, GPT-4 works with spaces of thousands of dimensions. If you don't understand that a 1536D vector is conceptually the same as a 2D vector (just with 1536 axes instead of 2), embeddings will look like magic.

When you finish, you'll understand why high dimensionality is needed in AI (more capacity to capture nuance), how to mentally visualize high dimensions (analogies, projections), and why "the curse of dimensionality" is a challenge. This intuition is the foundation of everything that follows: vector spaces (Module 2), similarity (Module 3), semantic search (Module 4), and RAG (Module 7).

From 3D to ND: The natural extension

You've already seen that:

  • 1D: [x] — A line (1 axis)
  • 2D: [x, y] — A plane (2 axes)
  • 3D: [x, y, z] — A space (3 axes)

The extension is obvious:

  • 4D: [x, y, z, w] — 4 axes
  • 5D: [x, y, z, w, t] — 5 axes
  • ND: [x₁, x₂, x₃, ..., xₙ] — N axes

Concrete example:

100D vector:
[2.3, -1.5, 0.8, 0.2, ..., -0.4]  (100 numbers)

1536D vector (a typical OpenAI embedding):
[0.234, -0.456, 0.123, 0.789, ..., -0.342]  (1536 numbers)

Interpretation:

  • Each number is the coordinate on one axis
  • 1536 numbers = 1536 axes = a 1536-dimensional space
  • It's a point in that space (or an arrow from the origin if you prefer)

There's no magic: It's exactly the same as [3, 2] in 2D. Just with many more numbers.

What does "dimension" mean?

Dimension = the number of axes (or coordinates) needed to locate a point in space.

Intuitive examples:

SpaceDimensionsWhat it representsExample
Line1DPosition on a line (e.g. km along a road)[5] = km 5
Plane2DPosition on a map (latitude, longitude)[19.4, -99.1]
Physical space3DPosition in a room (x, y, z)[2, 3, 1]
Spacetime4DPosition + time (x, y, z, t)[2, 3, 1, 10:30]
Embedding1536DThe meaning of a text[0.23, -0.45, ..., -0.34]

In AI: A 1536D embedding means each word/document is placed in a space of 1536 axes. Each axis captures one "aspect" of the meaning (although we don't know which specific aspect; models learn abstract representations).

Why high dimensions in AI?

Reason 1: More capacity to capture nuance

In 2D: You can only capture 2 aspects.

Simplified example:

  • Axis 1: "Animalness" (how animal the word is)
  • Axis 2: "Domesticity" (how domestic)

Words:

      Domesticity ↑
                  |
      "cat"  •    |   • "dog"
                  |
      "lion" •    |
                  |───────────→ Animalness

Problem: With only 2 axes, you can't properly distinguish "lion" from "cat" (both are animals that aren't very domestic). You also can't capture "size", "speed", "habitat", etc.

In 1536D: You can capture 1536 different aspects:

  • Axis 1: Animalness
  • Axis 2: Domesticity
  • Axis 3: Size
  • Axis 4: Speed
  • Axis 5: Habitat
  • ...
  • Axis 1536: ??? (some abstract aspect the model learned)

Result: "lion", "cat", "dog", "tiger", "hamster" are separated in 1536D space because each one has different values on many axes.

Analogy: If you describe a person with 2 characteristics (height, weight), many people "overlap". If you use 100 characteristics (height, weight, age, hair color, languages, profession, etc.), each person is unique. More dimensions = more capacity to distinguish.

Reason 2: Complex relationships

In high dimensions, you can capture relationships like:

Vector("king") - Vector("man") + Vector("woman") ≈ Vector("queen")

That works because in high dimensions there are "directions" that capture concepts like "royalty" or "gender". In 2D/3D it would be very hard to capture all of those relationships simultaneously.

Example: If "king - man + woman = queen" works in 1536D, it's because there are axes that capture:

  • "Gender" (masculine vs feminine)
  • "Royalty" (king/queen vs ordinary person)
  • "Role" (monarch vs other)

With only 2-3 axes, you can't represent all of those relationships at once. With 1536 axes, you can.

Reason 3: More "room" for data

In 2D, if you have 10,000 words and map them to vectors, there will be a lot of "overlap" (many words very close together even though they aren't similar). In 1536D, there's much more "room" to distribute the points, so similar words end up close and different words end up far apart.

Analogy: If you have 100 people and can only use 2 characteristics (height, weight), many will coincide. If you use 1536 characteristics, almost everyone will have a unique position in space → easier to tell apart.

How to mentally visualize high dimensions

Hard truth: You can't visualize 1536 axes in your mind. Your brain is limited to 3D (and even then, 3D on paper is hard).

But you can use analogies and abstractions:

Analogy 1: A table with 1536 columns

Imagine an Excel table with 1536 columns:

| Word    | Axis1 | Axis2  | Axis3 | ... | Axis1536 |
|---------|-------|--------|-------|-----|----------|
| dog     | 0.23  | -0.45  | 0.12  | ... | -0.34    |
| cat     | 0.25  | -0.43  | 0.10  | ... | -0.32    |
| car     | 9.34  | 5.21   | -8.12 | ... | 7.56     |

Each row is a vector (a point in 1536D space). Each column is an axis.

Similarity: "dog" and "cat" have similar values in many columns → nearby vectors. "car" has very different values → a distant vector.

Analogy 2: The genetic code

DNA has ~3 billion base pairs. You can't visualize it, but you know that:

  • Two people with similar DNA = alike
  • Two people with very different DNA = different

Embeddings are the same: A 1536D embedding is like "the DNA of a word". Two words with "similar DNA" (nearby embeddings) are similar in meaning.

Analogy 3: A personality test with 1536 questions

Imagine a test with 1536 questions. Your result is a 1536D vector (one answer per question). Two people with similar answers on most questions → nearby vectors → similar personalities.

Embeddings: Each "question" is an axis. The model learned which "questions" are useful for capturing meaning. We don't know which question corresponds to each axis (the model learned it implicitly), but the result is that similar words give similar answers → nearby vectors.

Projections: How to see high dimensions in 2D/3D

You can't draw 1536D, but you can project it to 2D/3D (dimensionality reduction).

Common techniques:

  • PCA (Principal Component Analysis): Finds the 2-3 most important axes and projects onto them
  • t-SNE: A projection that preserves closeness (points close together in high dimensions stay close in 2D)
  • UMAP: Similar to t-SNE but faster and more scalable

Conceptual example:

Original vectors (1536D):
"dog": [0.23, -0.45, ..., -0.34]  (1536 numbers)
"cat": [0.25, -0.43, ..., -0.32]  (1536 numbers)
"car": [9.34, 5.21, ..., 7.56]    (1536 numbers)

↓ t-SNE projection to 2D

Reduced vectors (2D):
"dog": [2.3, 1.8]
"cat": [2.5, 1.7]
"car": [-5.2, 8.1]

Visualization:

      ↑ Y
      |
    2 | •dog •cat
      |
    0 |─────────────→ X
      |        •car
   -8 |
     -6  0  2  4  6

Interpretation:

  • "dog" and "cat" remain close together in 2D (as they were in 1536D)
  • "car" is far away in 2D (as it was in 1536D)

Important: The projection loses information (1536D → 2D compresses a lot), but it preserves the intuition of "closeness = similarity". That's why the embedding visualizations in blogs/papers are useful even though they're only 2D.

Examples of dimensionality in AI

Model/ServiceDimensionalityTypical use
Word2Vec (Google)300DWord embeddings (classic)
GloVe300DWord embeddings (classic)
BERT (base)768DContextual embeddings
OpenAI text-embedding-3-small1536DEmbeddings for semantic search
OpenAI text-embedding-3-large3072DHigh-quality embeddings
GPT-3/GPT-4 (internal)12,288DInternal representation (not the output embedding)
Sentence-BERT768DSentence embeddings

Observation: Modern models use between 768D and 3072D for text embeddings. More dimensions = more capacity, but also more compute and more data needed to train.

The curse of dimensionality

Phenomenon: In high-dimensional spaces, counterintuitive things happen that don't happen in 2D/3D.

Problem 1: Everything is far away

In 2D: If you take 1000 random points in a square, many will be close together.

In 1000D: If you take 1000 random points in a 1000D hypercube, almost all of them are far from each other.

Why: "Volume" grows exponentially with dimensions. In high dimensions, there's "a lot of room" and random points spread out.

Consequence for AI: If you generate random embeddings, they'll all be far apart. That's why it's crucial to train the embeddings: the model learns to place similar words close together and different words far apart (not randomly).

Problem 2: The notion of a "nearest neighbor" loses meaning

In 2D: If you search for the 5 nearest neighbors of a point, they're clearly "close" (a small distance).

In 1000D: The "nearest" neighbors can be very far in absolute terms. The average distance between any pair of points is high.

Solution: In AI, we use cosine similarity (the angle between vectors) instead of Euclidean distance, because in high dimensions the angle is more robust than the distance. You'll see this in Module 3 (Similarity).

Problem 3: More data needed

In 2D: With 100 points you can cover a plane well.

In 1000D: You need exponentially more points (millions) to "cover" the space densely.

Consequence for AI: Embedding models need to train on hundreds of millions of examples to learn useful representations in 768D-1536D spaces.

Important note: The curse of dimensionality is a theoretical challenge, but in practice embeddings work well because:

  1. Real data has structure (it isn't random points)
  2. Models learn to use the dimensions efficiently
  3. We use appropriate metrics (cosine, not pure Euclidean)

Don't worry too much about the curse; just understand that high dimensionality has quirks and that researchers have found ways to work with them.

1536D vectors: A concrete example

When you use OpenAI's text-embedding-3-small for "The dog is a domestic animal", you get back a vector like this (simplified):

{
  "embedding": [
    0.234, -0.456, 0.123, 0.789, -0.234, 0.567, -0.890, 0.345,
    ... (1528 more numbers) ...,
    -0.342
  ]
}

What is this?

  • An array of 1536 numbers
  • Each number is a coordinate on an axis
  • It's a point in 1536D space
  • It represents the "meaning" of the sentence

What do we do with it?

  1. We store it in a vector database (Pinecone, Weaviate, etc.)
  2. When a query arrives ("What animals are pets?"), we convert it to a vector (1536D)
  3. We compare the query vector against the document vectors (cosine similarity)
  4. We return the documents with the closest vectors (semantic search)

Key: Everything you saw in 2D/3D (direction, magnitude, closeness) applies the same in 1536D. You just can't draw it.

Visual comparison: 2D vs 100D

In 2D (drawable):

      ↑ Y
      |
    2 | •dog •cat
      |
    1 |
      |        •tiger
    0 |─────────────────→ X
      |                •car
   -2 |
      0  1  2  3  4  5  6  7

Direct interpretation: You clearly see that "dog" and "cat" are close together, and "car" is far away.

In 100D (not drawable):

Vector "dog": [0.23, -0.45, 0.12, ..., -0.34]  (100 numbers)
Vector "cat": [0.25, -0.43, 0.10, ..., -0.32]  (100 numbers)
Vector "car": [9.34, 5.21, -8.12, ..., 7.56]   (100 numbers)

Interpretation: You can't draw it, but you can compute distance:

  • distance("dog", "cat") = small → close → similar
  • distance("dog", "car") = large → far → different

Same intuition, different tools. In 2D you use your eyes; in 100D you use mathematics (Euclidean distance, cosine, etc.).

Operations in high dimensions

Everything that works in 2D/3D works in high dimensions:

Magnitude (the length of the vector):

2D: [3, 2] → Magnitude = √(3² + 2²) = √13 ≈ 3.6

1536D: [x₁, x₂, ..., x₁₅₃₆]
→ Magnitude = √(x₁² + x₂² + ... + x₁₅₃₆²)

Interpretation: How "far from the origin" the point is (even though you can't visualize it in 1536D).

Vector addition:

2D: [3, 2] + [1, 1] = [4, 3]

1536D: [x₁, x₂, ..., x₁₅₃₆] + [y₁, y₂, ..., y₁₅₃₆]
     = [x₁+y₁, x₂+y₂, ..., x₁₅₃₆+y₁₅₃₆]

Interpretation: Combining meanings. Example: Vector("king") - Vector("man") + Vector("woman") ≈ Vector("queen").

Distance between two vectors:

2D: distance([3, 2], [1, 1]) = √((3-1)² + (2-1)²) = √5 ≈ 2.24

1536D: distance(A, B) = √((a₁-b₁)² + (a₂-b₂)² + ... + (a₁₅₃₆-b₁₅₃₆)²)

Interpretation: How different two words/documents are.

Key point: The formulas have more terms in high dimensions, but the concept is identical. You don't need to calculate by hand; vector systems do it for you. Just understand that it works the same.

What does each dimension mean?

Frequently asked: "If an embedding has 1536 dimensions, what does each one mean?"

Answer: We don't know exactly. Models learn representations implicitly during training. Each axis captures some "aspect" of meaning, but there's no label like "Axis 1 = Animalness".

Analogy: It's like the neurons in your brain. Each neuron contributes to your thinking, but you can't say "neuron 17 is the math one". The representations are distributed (many axes contribute to each concept).

Cases where we DO know:

  • In some interpretable models (e.g. Sparse Autoencoders), researchers have found that certain axes capture specific concepts (e.g. "axis 42 = gender", "axis 103 = scientific"). But in models like OpenAI embeddings, we don't have that interpretation.

Conclusion: Use embeddings as "black boxes": give me text, I get a vector, I compare vectors. You don't need to know what each axis means; only that nearby vectors = similar meanings.

Exercises

Exercise 1: Count dimensions

How many dimensions do these vectors have?

a) [3, 2]
b) [3, 2, -1, 0]
c) [0.23, -0.45, 0.12, ..., -0.34] (with 1536 numbers in total)
d) [5]

See solution

a) [3, 2]: 2 dimensions (2D)

b) [3, 2, -1, 0]: 4 dimensions (4D)

c) [0.23, -0.45, ..., -0.34] (1536 numbers): 1536 dimensions (1536D)

d) [5]: 1 dimension (1D)

Rule: Number of dimensions = the number of coordinates (numbers in the vector).

Exercise 2: Why high dimensions?

Explain in 1-2 sentences why a 1536D embedding is better than a 2D one for representing the meaning of text.

See answer guide

A possible answer: "A 1536D embedding can capture 1536 different aspects of meaning (animalness, size, emotion, context, etc.), whereas 2D can only capture 2 aspects. More dimensions allow you to better distinguish between similar concepts and to capture complex relationships."

Analogy: "It's like describing a person with 2 characteristics (height, weight) vs 1536 characteristics (height, weight, age, languages, profession, hobbies, etc.). With more characteristics, the description is far richer and more unique."

Exercise 3: Conceptual projection

You have 3 vectors in 1536D:

  • "dog": [0.23, -0.45, ..., -0.34]
  • "cat": [0.25, -0.43, ..., -0.32]
  • "car": [9.34, 5.21, ..., 7.56]

After projecting them to 2D with t-SNE, you get:

  • "dog": [2.3, 1.8]
  • "cat": [2.5, 1.7]
  • "car": [-5.2, 8.1]

What can you conclude about the relationship between these words?

See solution

Conclusion: "dog" and "cat" are similar (nearby vectors both in 1536D and in the 2D projection). "car" is different (a distant vector).

Interpretation: The 2D projection preserved the closeness structure of the original 1536D space. Even though we lost information (1536D → 2D), the intuition of "closeness = similarity" was preserved.

Practical use: When you see 2D visualizations of embeddings in blogs or papers, you can trust that nearby points → similar concepts, even though the visualization is a compressed projection.

Exercise 4: Conceptual distance

Without calculating, which pair of vectors do you think has the smaller distance?

Pair A: [2, 3] and [2.1, 3.1]
Pair B: [2, 3] and [5, 8]

See solution

Pair A has the smaller distance (the vectors are closer together).

Justification: The vectors in Pair A differ by only 0.1 on each coordinate (very close). Those in Pair B differ by 3 and 5 (much farther apart).

Analogy in AI: If two words have embeddings that differ very little on each dimension (like Pair A), they're very similar. If they differ a lot (like Pair B), they're different.

Exercise 5: The curse of dimensionality

Why do random points in high dimensions tend to all be far from each other?

See answer guide

Simplified answer: In high dimensions, there's an enormous amount of room. In 2D you have a plane; in 1000D you have a "hyper-space" with exponentially greater volume. If you generate random points, they scatter across that gigantic space and the probability that two land close together is very low.

Analogy: If you put 10 people in a room (a small space, 3D), they'll run into each other. If you put those same 10 people on an entire planet (a huge space, still 3D but very large), it's unlikely that any two will meet. High dimensionality is like having a "huge planet" of many dimensions: there's so much room that the points lose each other.

Why embeddings work: Embeddings are NOT random; they're trained to place similar words close together. That's why, despite the curse of dimensionality, embeddings are useful: they have structure, they aren't noise.

Exercise 6: Interpreting dimensions

Suppose you had a 5D embedding of animals:

Axis 1: Size (small → large)
Axis 2: Speed (slow → fast)
Axis 3: Domesticity (wild → domestic)
Axis 4: Aquatic habitat (land → water)
Axis 5: Nocturnality (diurnal → nocturnal)

What do you think the vector for "dog" would look like? (Use a scale of -5 to +5)

See answer guide

A possible "dog" vector: [2, 3, 5, -5, -3]

Justification:

  • Axis 1 (Size): +2 (medium, neither very large nor very small)
  • Axis 2 (Speed): +3 (relatively fast)
  • Axis 3 (Domesticity): +5 (very domestic)
  • Axis 4 (Aquatic habitat): -5 (entirely land-based)
  • Axis 5 (Nocturnality): -3 (mostly diurnal)

Comparison with "cat": [1, 4, 4, -5, 2]

  • Smaller (1 vs 2)
  • Faster (4 vs 3)
  • Less domestic (4 vs 5) — debatable, but some cats are semi-wild
  • Equally land-based (-5)
  • More nocturnal (2 vs -3)

Observation: "dog" and "cat" have similar values on Size, Speed, Domesticity, Habitat → nearby vectors → similar. If we worked out "car" it would be something like [4, 5, -5, -5, 0] (large, very fast, not domestic at all, land-based, neither diurnal nor nocturnal) → far from "dog" and "cat".

Note: In real embeddings we do NOT know what each axis means, but this intuition (coordinates capture aspects, similar values = similar concepts) is correct.

Troubleshooting

Problem 1: "I can't visualize 1536D"

Symptom: It frustrates you that you can't "see" high dimensions.

Solution: Nobody can. Your brain only understands 2D-3D. Accept that and use abstractions:

  • Think of vectors as "feature tables" (1536 columns)
  • Use 2D projections (t-SNE, UMAP) to visualize
  • Trust the math: distance/similarity work even when you can't see them

Analogy: You can't "see" DNA (3 billion base pairs), but you understand that similar DNA = similar people. Embeddings are the same: you don't see them, but you use them.

Problem 2: "How do I know if two 1536D vectors are close?"

Symptom: You don't know how to compare high-dimensional vectors.

Solution: Use similarity metrics (Euclidean distance, cosine). Tools like Pinecone, Weaviate, or libraries like NumPy/SciPy calculate it for you. You don't need to compute it by hand.

Conceptual example:

# Illustrative (NOT code you'll implement here)
from numpy import dot
from numpy.linalg import norm

vec_dog = [0.23, -0.45, ..., -0.34]  # 1536D
vec_cat = [0.25, -0.43, ..., -0.32]  # 1536D

similarity = dot(vec_dog, vec_cat) / (norm(vec_dog) * norm(vec_cat))
# Result: 0.95 (very high → similar)

Don't worry if you don't understand the code; we'll cover similarity in Module 3. Just understand that there are functions that compare vectors automatically.

Problem 3: "Why do embeddings have exactly 768D or 1536D?"

Symptom: You don't understand why those specific numbers.

Solution: It's an architectural decision made when the model was trained. Researchers chose 768D for BERT, 1536D for OpenAI text-embedding-3-small, etc., based on:

  • The balance between capacity and compute (more dimensions = better, but more expensive)
  • Quality benchmarks (testing which dimensionality gives the best results)

There's no "magic number". Models vary: some use 300D, others 768D, others 3072D. More dimensions usually give better quality, but at a higher computational cost.

Analogy: It's like choosing how many megapixels for a camera: 12MP is enough for many uses, 48MP is better but heavier. Researchers choose based on the quality-cost balance.

Problem 4: "Are more dimensions always better?"

Symptom: You think more dimensions = always better.

Solution: Not always. Advantages of more dimensions:

  • More capacity to capture nuance
  • Better separation of concepts

Disadvantages:

  • More compute (calculating distances in 3072D is slower than in 768D)
  • More data needed to train
  • The "curse of dimensionality" (though it can be mitigated with the right techniques)

In practice: Models with 1536D or 3072D are enough for most semantic search tasks. You don't need to go to 10,000D; there are diminishing returns.

Rule of thumb: Use pre-trained embeddings (OpenAI, Cohere, etc.) that are already optimized. They chose the optimal dimensionality. Don't try to "add dimensions" manually; it doesn't work that way.

Connection to semantic search

Now that you understand high dimensions, you can see the full semantic search flow:

1. Document → Embedding (1536D)

Document: "The dog is a domestic animal"
↓ Embedding model
Vector: [0.23, -0.45, 0.12, ..., -0.34]  (1536D)

2. Query → Embedding (1536D)

Query: "Which animals are pets?"
↓ Embedding model
Vector: [0.25, -0.43, 0.10, ..., -0.32]  (1536D)

3. Compare vectors (1536D)

Similarity(doc_vector, query_vector) = 0.92  (very high → similar)

It's computed in 1536D (across all the dimensions), not just 2-3.

4. Result

The document with the highest similarity is returned.

Why it works: In 1536D, the space has enough "resolution" to distinguish nuance. Two texts about "pets" have nearby vectors; a text about "cars" has a distant vector. High dimensionality is what enables that fine distinction.

Summary

In one sentence: High-dimensional vectors (100D, 1536D, 3072D) work exactly like 2D/3D vectors (direction, magnitude, closeness), just with many more axes; they aren't drawable but they can be used with the same operations and they have greater capacity to capture nuances of meaning.

Key points:

  • Dimension = the number of axes (1536D = 1536 axes)
  • High dimensions in AI: More capacity to capture nuances of meaning
  • Visualization: You can't draw 1536D; use 2D projections (t-SNE, UMAP) or abstractions (tables, DNA)
  • Operations: Addition, subtraction, magnitude, distance work just like in 2D/3D, only with more terms
  • The meaning of the axes: We don't know what each axis means; they're learned (implicit) representations
  • The curse of dimensionality: In high dimensions, random points are all far apart; but trained embeddings have structure and work well
  • Real examples: OpenAI text-embedding-3-small (1536D), BERT (768D), GPT-4 internal (12,288D)
  • Projections: t-SNE and UMAP reduce high dimensions to 2D/3D for visualization
  • Semantic search: Uses 1536D vectors to compare documents; high dimensionality is what allows nuance to be distinguished

Connection to the next capsule

In Capsule 05 (Basic vector operations), you'll see how to add, subtract and scale vectors. Although the examples will be in 2D/3D (so you can visualize them), the operations apply exactly the same in 1536D. Everything you saw here (high dimensions work just like low dimensions) is the foundation for understanding that Vector("king") - Vector("man") + Vector("woman") ≈ Vector("queen") works in 1536D using the same operations as [3, 2] + [1, 1] = [4, 3] in 2D.

Additional resources

  1. StatQuest: Principal Component Analysis (PCA), Step-by-Step — A 21-minute video explaining PCA (a dimensionality reduction technique). Useful for understanding how to project high dimensions to 2D/3D. In English.

  2. Distill.pub: "Visualizing High-Dimensional Space" — An interactive article on how to understand t-SNE and dimensionality reduction. With manipulable 3D visualizations. In English.

  3. Jay Alammar: "The Illustrated Word2vec" — A blog with diagrams about 300D embeddings: how they're trained, how they're used, how to visualize them. Excellent for seeing high dimensions in context. In English.

  4. Wikipedia: "Curse of Dimensionality" — A formal explanation of the curse of dimensionality with mathematical examples. Useful for going deeper. In English.

  5. Pinecone: "The Curse of Dimensionality" — A blog aimed at vector databases that explains the problem and how to mitigate it. In English.

  6. OpenAI Embeddings Guide — Official documentation on OpenAI embeddings (1536D and 3072D). For seeing real usage examples. In English.

Next capsule: 05-basic-operations.md — Addition, subtraction and scaling of vectors: the operations that let you manipulate meaning.

← Previous3. Vectors in 2D and 3D: Visualization and CoordinatesNext →5. Basic Vector Operations