Vectors, geometry, and array notation

A data record can be written as a list of numbers. Comparing two records by a dot product or distance looks straightforward, but the result depends on feature order, units, and the operation chosen. Converting centimetres to metres can change an unweighted nearest neighbour even though the physical records are unchanged. Mixing a column array with a flat array can produce every pairwise difference instead of the intended paired differences.

This module develops the mathematics and the implementation contract together. You will distinguish points from displacements, derive lengths and angle bounds, compare norms, and inspect shapes before computing. A successful numerical call establishes that an operation was executable; a mathematical interpretation needs its own assumptions about what the coordinates represent.

Retrieval check: work with real tuples and finite sums, and describe a Cartesian product. Review Module 01 and Module 03 if needed. There is no assumed earlier linear algebra. Complete NumPy array preparation before the labs; its roughly thirty-minute orientation is additional preparation when you need it. The numerical baseline uses Python 3.11 and the pinned NumPy environment described there.

A scalar is a single number used to scale a vector; here scalars are real numbers. A coordinate vector in $\mathbb R^d$ is an ordered d-tuple of real entries. The positive integer d is the number of coordinates. The Cartesian product construction from Module 03 supplies the set of all such tuples. The coordinate order is part of the specification: (height,age) and (age,height) use different feature conventions even if both arrays have length two.

In geometry, a vector can describe a displacement independent of where it is drawn. Its arrow records both magnitude and direction. Sliding the arrow without rotating or stretching it preserves that displacement. In data work, a tuple can instead collect feature measurements, some of which have different units. Writing those measurements as a vector makes coordinate algebra possible, but it does not automatically make a Euclidean length physically meaningful.

A point is a location, whereas a displacement connects locations. Given points p,q in a chosen coordinate frame, q−p is the displacement from p to q. Translating the origin adds the same coordinate offset to both points and leaves their difference unchanged. Position coordinates and displacement coordinates may use the same tuple notation, so the surrounding interpretation must identify which object is being added or compared.

A zero vector has every entry zero and describes no displacement. It is a valid vector with length zero, not a missing observation. A record with unknown age also needs a separate missing-data representation; substituting zero would assert a numerical value and change the geometry. Similarly, a vector of category codes such as 1,2,3 does not acquire meaningful distances merely because the codes are numeric. The encoding determines which comparisons make sense.

Coordinate unit vectors eᵢ have one in position i and zero elsewhere. A tuple x can be written $\sum_{i=1}^d x_i e_i$: each coordinate contributes along its own axis. In two dimensions this gives (3,4)=3(1,0)+4(0,1). These coordinate directions have unit length and are mutually perpendicular under the ordinary dot product. Module 11 develops the more general ideas of basis, dimension, and coordinate changes.

Two vectors to be added or compared must have the same coordinate dimension and corresponding meanings. A three-feature vector cannot be paired entrywise with a two-feature vector by silently dropping a coordinate. Even equal lengths are insufficient if one record uses a different feature order. The lab checks lengths before using Python zip because zip otherwise stops at the shorter input and could hide a modelling error.

The mathematical dimension d differs from storage axes. A single three-coordinate vector may be stored in a NumPy array with one axis (3,) or two axes (3,1). A table of one hundred such vectors has shape (100,3), still representing observations with three coordinates each. Keeping these counts separate prevents confusion between the number of examples, the number of features, and the number of axes in a container.

Vector addition and scalar multiplication act coordinatewise: $(u+v)_i=u_i+v_i$ and $(\alpha u)_i=\alpha u_i$. The result stays in the same coordinate dimension. Adding displacement arrows corresponds to placing the second arrow’s tail at the first arrow’s head; the combined displacement joins the starting point to the final endpoint. Negative scaling reverses direction, positive scaling preserves it, and scaling by zero gives the zero vector.

Coordinatewise real arithmetic implies commutativity and associativity of vector addition, additive identity zero, additive inverse −u, and distributive scaling rules. For example α(u+v)=αu+αv because the equality holds in every coordinate. These laws explain why finite sums of vectors can be rearranged or grouped under the stated real-number model. In floating-point software, different grouping can change small rounding errors, which Module 28 studies separately.

A linear combination has the form $\sum_{j=1}^k\alpha_jv_j$ with real coefficients and equal-dimensional vectors. Coefficients need not be positive or sum to one. The vector 2(3,4)+3(4,−3)=(18,−1) is a valid combination. Its coordinates may lie beyond either original vector’s endpoints. A linear combination is an algebraic construction, not necessarily an interpolation or a probability-weighted average.

A line through a point p in nonzero direction u is p+tu for real t. Restricting t to [0,1] gives the segment from p to p+u; other t values continue along the same line. If u is zero, this expression produces only p, so calling it a full line would be misleading. An affine line allows an offset p, whereas a line consisting only of tu passes through the chosen origin.

An affine combination of points has coefficients summing to one. For two points it is (1−t)p+tq. When 0≤t≤1 it interpolates the segment; when t lies outside that interval it extrapolates. Translating each point by b changes the combination by exactly b, since the coefficients sum to one. A coefficient sum other than one would scale that translation, making the interpreted result depend incorrectly on the point-coordinate origin.

A convex combination is an affine combination with nonnegative coefficients. The coefficient conditions are algebraic; whether they represent actual probabilities requires a separate model. In data processing, a convex mixture of feature vectors may be meaningful for continuous measurements but not for every category encoding or constrained object. A mixture of two valid numerical records need not correspond to a physically valid or observed individual.

Feature operations must retain units. Doubling a displacement measured in metres preserves its unit; adding metres to metres is meaningful. Summing coordinates measured in seconds and metres as a single physical length has no automatic interpretation. You may deliberately choose a weighted numerical geometry for learning, but document that choice and its scale factors. Algebraic compatibility and application meaning are both necessary parts of a useful calculation.

Coordinate rearrangement must be applied consistently to all compared objects. Reordering both vectors by the same permutation preserves their dot product and the standard norms later defined. Reordering only one mixes feature positions and changes the result. This distinction is a simple example of separating a change of representation from a change of the represented relationship; shape checks alone cannot detect a feature-order mismatch.

For example, one record (height,age)=(170,20) and another stored as (age,height)=(30,180) have matching array lengths but incompatible coordinate meanings. A computation pairing their first entries multiplies height by age. Reordering the second to (180,30) repairs correspondence, while choosing feature scales is still a separate task. A reliable data interface documents names and units alongside the shape tuple.

The ordinary real dot product is $u\cdot v=\sum_{i=1}^d u_iv_i$. It is a scalar, unlike entrywise multiplication, which retains a vector of products. It is symmetric and linear in each argument: u·(αv+βw)=α(u·v)+β(u·w). Its self-product u·u is a sum of squares, nonnegative and zero exactly when every coordinate is zero. Define Euclidean length as $\|u\|_2=\sqrt{u\cdot u}$.

Vectors are orthogonal when u·v=0. For nonzero vectors in ordinary geometry this means perpendicular directions. The zero vector is algebraically orthogonal to every vector but has no direction or ordinary angle. That boundary shows why the dot-product predicate and a geometric angle statement have different domain conditions. In the plane, (3,4) and (4,−3) are orthogonal because twelve minus twelve is zero.

To introduce angles, an acute right-triangle cosine is the adjacent side divided by the hypotenuse. Extend it to signed directional alignment: cosine is one for the same direction, zero at a right angle, and minus one for opposite directions. Angles between nonzero vectors run from zero to 180 degrees, equivalently zero to π radians; π radians denotes a half-turn. The inverse cosine selects the angle in that range for an alignment value between minus one and one.

For two nonzero coordinate vectors, their geometric relation is $u\cdot v=\|u\|_2\|v\|_2\cos\theta$. In the plane, choose unit direction û=u/||u||₂ and its perpendicular (−u₂,u₁)/||u||₂. The signed component of v along û is v·û; dividing it by ||v||₂ is the cosine by the right-triangle interpretation. Multiplying back gives the formula. This is not a claim that every tuple of unrelated feature measurements already has a useful physical angle.

The Cauchy–Schwarz inequality states $|u\cdot v|\leq\|u\|_2\|v\|_2$. Give a proof before dividing by lengths to form a cosine. If v=0, both sides are zero. Otherwise let t=(u·v)/(v·v). Expanding the nonnegative square length ||u−tv||₂² gives ||u||₂²−(u·v)²/||v||₂²≥0. Multiply by the positive denominator and take nonnegative square roots to get the claimed inequality.

With both vectors nonzero, equality holds exactly when u−tv=0 in that proof, meaning one is a scalar multiple of the other. Positive multiples give cosine one and negative multiples give minus one. If either vector is zero, equality also holds in the inequality, while a cosine remains undefined. Consequently a zero self-product should never be used as a divisor simply because the inequality itself includes zero vectors.

Cauchy–Schwarz guarantees the nonzero-vector cosine quotient lies in [−1,1]. In floating-point calculations a rounding error can push a value slightly outside that interval, so angle display may clamp a numerically computed quotient after the nonzero and shape checks. This is a local numerical display policy, not a new mathematical inequality. Large magnitudes or underflow can require additional numerical handling beyond our small-coordinate labs.

The dot product depends on the chosen coordinate geometry. Scaling one feature changes its contribution to products and angles; a weighted inner product can model a different geometry, but its assumptions must be stated. In AI, attention and many similarity calculations use dot products of learned feature coordinates. Their application meaning depends on how those coordinates were constructed, not only on the arithmetic fact that corresponding entries can be multiplied.

A norm assigns a nonnegative length to each vector, zero only at zero, satisfies ||αu||=|α| ||u||, and obeys the triangle inequality ||u+v||≤||u||+||v||. Nonnegativity alone is insufficient: a proposed length must satisfy every law. These properties ensure that scaling, cancellation, and path-length arguments behave consistently. The Euclidean formula just introduced is one norm among several useful coordinate choices.

The Manhattan norm is $\|u\|_1=\sum_i|u_i|$. The maximum norm is $\|u\|_\infty=\max_i|u_i|$. Both have positivity and scaling directly from absolute values. For Manhattan’s triangle law, apply |uᵢ+vᵢ|≤|uᵢ|+|vᵢ| and sum. For the maximum norm, every coordinate sum is at most ||u||∞+||v||∞ in absolute value, so taking the maximum proves its triangle law.

For Euclidean length, expand ||u+v||₂²=||u||₂²+2u·v+||v||₂². Cauchy–Schwarz bounds the middle term by 2||u||₂||v||₂, making the result at most (||u||₂+||v||₂)². Both sides are nonnegative, so taking square roots proves the triangle inequality. This links a dot-product theorem to a norm axiom rather than assuming the ordinary diagram proves the law in every coordinate dimension.

The squared Euclidean length is useful in objectives but is not itself a norm. Scaling a vector by α scales its squared length by α², rather than |α|. For u=v=(1,0), the squared length of u+v is four, greater than the sum one plus one, so the norm triangle inequality fails. Calling an optimisation penalty a squared norm describes how it was constructed; it does not transfer all norm laws to that new function.

Squaring a nonnegative distance preserves ranking, which explains why nearest-neighbour code can omit a square root when only the ordering is needed. It changes the numeric distance and its metric properties, however: on the real line the squared distance from zero to two is four, exceeding the squared zero-to-one plus one-to-two distances of two. A ranking shortcut is therefore different from substituting a new metric into a proof that needs the triangle inequality.

A metric d(p,q) is nonnegative, zero exactly when p=q, symmetric, and satisfies d(p,r)≤d(p,q)+d(q,r). A norm induces a metric d(p,q)=||q−p||. Norm positivity gives the first two conditions, homogeneity at −1 gives symmetry, and the norm triangle law applied to (q−p)+(r−q) gives the metric triangle law. The mathematical object is now a distance between points, rather than a length of one displacement vector.

Consider a query (0,0) and candidates P=(1,100),Q=(3,0), with coordinates measured in hours and centimetres. An unweighted Euclidean formula gives distances approximately 100.005 and three, selecting Q. Converting centimetres to metres changes P to (1,1), giving √2 while Q remains three, selecting P. The physical measurements have not changed; leaving the numeric metric weights fixed changed the chosen geometry.

An explicit scale vector s with positive entries defines dₛ(p,q)=sqrt(∑ᵢsᵢ²(qᵢ−pᵢ)²). This is a metric because it applies an invertible coordinate scaling then Euclidean distance. If you convert units and want to preserve an existing metric, change its scales inversely to the coordinate conversion. If a scale is zero, differences on that coordinate can be ignored even for distinct points, so the identity-of-indiscernibles metric condition can fail.

For fixed finite dimension d, the standard norms satisfy ||u||∞≤||u||₂≤||u||₁≤√d ||u||₂. The first inequalities compare a largest squared entry, the sum of squares, and the square of the absolute-entry sum. The final inequality is Cauchy–Schwarz applied to (|uᵢ|) and the all-ones vector. These bounds compare lengths, but do not make neighbour rankings identical, and their constants depend on dimension.

Choosing a norm or feature scale therefore requires a modelling reason. Similar record lengths, local paths in a grid, and maximum permitted component error can favour different measures. A numerical result is meaningful only relative to that choice and the feature semantics. Later statistical preprocessing will introduce learned scale estimates and training-only fitting; this module uses declared unit conversions so that no unlearned statistics is required.

For a nonzero vector u, normalisation divides by its Euclidean length: û=u/||u||₂. Norm homogeneity gives ||û||₂=1, and the divisor is positive, so the direction is preserved. For (3,4) the unit direction is (0.6,0.8). Dividing by the length is not the same as dividing by the sum of entries; negative coordinates and cancellation make that sum an unsuitable general length.

The zero vector cannot be normalised by this formula because its length is zero and it has no direction. An application must declare its handling: reject the operation, report an undefined score, or use a separately justified convention. Silently adding a small constant to the denominator changes the function being computed; it should be explained as a policy rather than presented as the original geometric definition.

For two nonzero vectors, cosine similarity is $\operatorname{cosim}(u,v)=(u\cdot v)/(\|u\|_2\|v\|_2)=\hat u\cdot\hat v$. It measures alignment while ignoring positive magnitude changes: replacing u with αu for α>0 leaves the score unchanged. A negative scale reverses direction and changes its sign. A score of one means parallel positive directions, not that the original vectors have equal coordinates or lengths.

For unit vectors u,v, squared Euclidean distance is ||u−v||₂²=2−2u·v=2−2cosim(u,v). Therefore among unit candidates compared with a unit query, maximising cosine and minimising Euclidean distance give the same ranking, including ties. The derivation uses both unit lengths. On raw vectors, varying magnitudes add other terms and the ranking equivalence need not hold.

Normalisation can discard information an application needs. If magnitude encodes the amount of activity or a physical displacement length, replacing each vector with its direction loses that quantity. If only direction is intended, the change may be appropriate. The important decision is which variation should count as similar; neither cosine nor Euclidean distance is universally the right choice for every embedding or measurement system.

A NumPy array has a shape tuple, a number of axes, and a dtype. Mathematical coordinates need a declared storage convention. We use flat arrays (d,) for standalone vectors, rows (1,d) and columns (d,1) when an operation requires those orientations, and tables (B,d) for B observations with d features. Module 10 develops matrix products; here identifying which axis represents features already prevents many faults.

For flat compatible vectors, u*v produces d entrywise products, while u @ v produces their summed dot product. Multiplying a (B,d) table by a length-d scale vector applies each feature scale to each row by broadcasting. np.linalg.norm(table, axis=1) returns B row lengths; omitting the intended axis can collapse an entire table to one aggregate quantity. The chosen axis is part of the mathematical question.

Broadcasting compares axis lengths from the right. Equal lengths match; length one can expand; a missing leading axis acts as one. Consequently (3,1) combined with (3,) produces (3,3). This is legal array arithmetic, but it pairs each column entry with every flat entry. A successful call cannot tell whether those pairwise combinations were intended. The correct output shape must be specified before running it.

Transposing a flat (d,) array does not make a column; it still has one axis. Use an explicit new axis, such as v[:,None], or a reshape whose entry count is checked. Turning (d,) into (d,1) changes the operation contract without changing entry values. Flattening an arbitrary table can lose the distinction between observation and feature axes, so use it only when the intended mathematical object is genuinely that one-dimensional sequence.

Arrays with more than two axes appear in images, batches, time sequences, and AI models. A shape such as (B,T,d) might mean batch, time, features; another application might assign different meanings. The shape tuple itself does not name those semantics. State the axis order, identify reductions and permitted broadcasts, and check output shape at the boundary of each operation. Tensor algebra and automatic differentiation later build on these explicit conventions.

Numerical checks should combine structure and values. Require matching expected shapes before np.allclose, since comparisons can broadcast too. Choose a tolerance appropriate to the small floating computations rather than interpreting approximate equality as an exact proof. Our loop-versus-NumPy lab compares norms at relative and absolute tolerance 10⁻¹² for small coordinates; the algebraic proofs establish the general formulas independently of that finite numerical agreement.

Complete the NumPy preparation and install the pinned numerical requirements. These scripts use small CPU arrays, with no external data. Predict first and explain the captured output; the downloaded files are the executed sources.

Lab A Loop calculations and NumPy checks

Predict: orthogonal dot product, three norms, displacement length, and the unit direction of (3,4). Run: compare loop formulas with NumPy. Explain: the coordinate unit-axis component and the length guard before zip. Change: use a negative coordinate, keep dimensions equal, and predict which norm values remain unchanged. The comparisons use explicit numerical tolerances; the lesson’s proofs are separate from these finite checks.

Download lab1_vectors.py

"""Loop-based vector calculations checked against NumPy on small real coordinates."""
from math import sqrt
import numpy as np

def dot(u, v):
    if len(u) != len(v):
        raise ValueError("Coordinate lengths must agree")
    return sum(a * b for a, b in zip(u, v))

def norm(u, kind):
    if kind == 1:
        return sum(abs(x) for x in u)
    if kind == 2:
        return sqrt(dot(u, u))
    if kind == "inf":
        return max((abs(x) for x in u), default=0)
    raise ValueError("This lab supports norms 1, 2, inf")

u, v = (3, 4), (4, -3)
print("u, v:", u, v)
print("Loop / NumPy dot:", dot(u, v), float(np.array(u) @ np.array(v)))
for kind in (1, 2, "inf"):
    reference = np.linalg.norm(np.array(u, dtype=float), ord=np.inf if kind == "inf" else kind)
    assert np.isclose(norm(u, kind), reference, rtol=1e-12, atol=1e-12)
    print("Norm", kind, ":", norm(u, kind), "; NumPy:", float(reference))
p, q = (1, 2), (4, 6)
displacement = tuple(b - a for a, b in zip(p, q))
print("Displacement q-p / Euclidean distance:", displacement, norm(displacement, 2))
unit = tuple(x / norm(u, 2) for x in u)
assert np.isclose(norm(unit, 2), 1, rtol=1e-12, atol=1e-12)
print("Unit direction of u:", unit)
direction = (1, 0)
projection = tuple(dot((2, 3), direction) * x for x in direction)
print("Component of (2,3) along the first unit axis:", projection)
try:
    dot([1, 2], [3])
except ValueError as error:
    print("Rejected:", error)
print("Tolerances compare numerical values; the length check prevents silent zip truncation.")

u, v: (3, 4) (4, -3)
Loop / NumPy dot: 0 0.0
Norm 1 : 7 ; NumPy: 7.0
Norm 2 : 5.0 ; NumPy: 5.0
Norm inf : 4 ; NumPy: 4.0
Displacement q-p / Euclidean distance: (3, 4) 5.0
Unit direction of u: (0.6, 0.8)
Component of (2,3) along the first unit axis: (2, 0)
Rejected: Coordinate lengths must agree
Tolerances compare numerical values; the length check prevents silent zip truncation.

Lab B Units and neighbour rankings

Predict: which candidate is closest to (0,0) before and after centimetres become metres. Run: read Euclidean and Manhattan orders. Explain: the changed geometry and the stable tie order in the scaled Manhattan result. Change: adjust the metric weights inversely to the unit conversion and verify the original distances return. Stability of sorting makes ties reproducible, not mathematically distinct distances.

Download lab2_feature_units.py

"""Neighbour rankings under an explicitly changed coordinate scale."""
import numpy as np

labels = np.array(["P", "Q", "R"])
# Feature 1 measured in hours; feature 2 measured in centimetres.
query = np.array([0.0, 0.0])
candidates = np.array([[1.0, 100.0], [3.0, 0.0], [0.0, 200.0]])

for name, scale in [("hours + centimetres, unweighted", np.array([1.0, 1.0])),
                    ("hours + metres, unweighted", np.array([1.0, 0.01]))]:
    differences = (candidates - query) * scale
    distances = np.linalg.norm(differences, axis=1)
    order = np.argsort(distances, kind="stable")
    print(name)
    print("Euclidean distances:", [round(float(d), 6) for d in distances])
    print("Rank order:", labels[order].tolist())
    l1 = np.abs(differences).sum(axis=1)
    print("Manhattan distances:", l1.tolist(), "; stable tie order:", labels[np.argsort(l1, kind="stable")].tolist())
assert labels[np.argmin(np.linalg.norm(candidates - query, axis=1))] == "Q"
assert labels[np.argmin(np.linalg.norm((candidates - query) * [1, 0.01], axis=1))] == "P"
print("Changing units while leaving numeric weights fixed changes the metric and can change neighbours.")
print("To preserve a chosen metric after conversion, transform its weights consistently.")

hours + centimetres, unweighted
Euclidean distances: [100.005, 3.0, 200.0]
Rank order: ['Q', 'P', 'R']
Manhattan distances: [101.0, 3.0, 200.0] ; stable tie order: ['Q', 'P', 'R']
hours + metres, unweighted
Euclidean distances: [1.414214, 3.0, 2.0]
Rank order: ['P', 'R', 'Q']
Manhattan distances: [2.0, 3.0, 2.0] ; stable tie order: ['P', 'R', 'Q']
Changing units while leaving numeric weights fixed changes the metric and can change neighbours.
To preserve a chosen metric after conversion, transform its weights consistently.

Lab C Wrong pairing and undefined cosine

Predict: the wrong (3,3) difference grid, the repaired (3,1) discrepancies, and the zero-vector result. Run: compare the two mean squared differences and rejected cases. Explain: why NumPy can produce nan for unchecked zero division and why the guarded function reports undefined instead. Change: compare unit nonzero vectors and verify distance²=2−2cosim. The code is scoped to small finite coordinates; extreme floating magnitudes require further numerical handling.

Download lab3_shape_and_cosine_faults.py

"""Repair a successful wrong broadcast and define the zero-vector policy explicitly."""
import numpy as np

predicted = np.array([1.0, 2.0, 3.0])
observed = np.array([[1.0], [2.0], [4.0]])
wrong = predicted - observed
paired = predicted[:, None] - observed
assert wrong.shape == (3, 3) and paired.shape == (3, 1)
print("Wrong broadcast shape / mean squared difference:", wrong.shape, round(float(np.mean(wrong**2)), 6))
print("Paired shape / mean squared difference:", paired.shape, round(float(np.mean(paired**2)), 6))
assert np.isclose(np.mean(paired**2), 1 / 3, rtol=1e-12, atol=1e-12)

def cosine(u, v):
    u, v = np.asarray(u, dtype=float), np.asarray(v, dtype=float)
    if u.ndim != 1 or v.ndim != 1 or u.shape != v.shape:
        raise ValueError("Require matching flat vector shapes")
    length_u, length_v = np.linalg.norm(u), np.linalg.norm(v)
    if length_u == 0 or length_v == 0:
        raise ValueError("Cosine is undefined for a zero vector")
    return float((u @ v) / (length_u * length_v))

zero, other = np.array([0.0, 0.0]), np.array([1.0, 2.0])
with np.errstate(invalid="ignore", divide="ignore"):
    bad = (zero @ other) / (np.linalg.norm(zero) * np.linalg.norm(other))
print("Unchecked zero-vector cosine:", float(bad))
assert np.isnan(bad)
for u, v in [([3, 4], [4, -3]), ([1, 0], [-1, 0]), ([0, 0], [1, 2]), ([1, 2], [1])]:
    try:
        print("Cosine:", u, v, "=", cosine(u, v))
    except ValueError as error:
        print("Rejected:", u, v, str(error))
print("Scope: small finite coordinates. Extreme floating magnitudes need further numerical handling.")

Wrong broadcast shape / mean squared difference: (3, 3) 2.333333
Paired shape / mean squared difference: (3, 1) 0.333333
Unchecked zero-vector cosine: nan
Cosine: [3, 4] [4, -3] = 0.0
Cosine: [1, 0] [-1, 0] = -1.0
Rejected: [0, 0] [1, 2] Cosine is undefined for a zero vector
Rejected: [1, 2] [1] Require matching flat vector shapes
Scope: small finite coordinates. Extreme floating magnitudes need further numerical handling.

Exercises 1–12 are required; 13–14 extend the geometry. Always annotate feature meaning and array shape when using a data interpretation.

Questions 1–9 are scored automatically. Question 10 is written and self-reviewed.

Use analytic-geometry selections from Mathematics for Machine Learning, the authors’ book companion, to compare dot products, lengths, and projections. Consult NumPy’s basic array guide and broadcasting rules for the storage operations used by the labs. The lesson’s proofs and examples are original; numerical checks do not replace the general arguments.

Separate coordinate geometry from programming terminology such as array ndim. A word used by both subjects may refer to different counts.

Without notes, compute a vector combination, prove Cauchy–Schwarz, derive the Euclidean triangle law, and explain the zero-vector exception. Give a metric-changing unit conversion and a wrong-shaped operation that runs without an exception.

Exit task: use u=(−3,4),v=(3,4). Compute u·v=7, both Euclidean lengths five, cosine 7/25, and unit directions (−0.6,0.8),(0.6,0.8). A two-row table of these vectors has shape (2,2); row norms yield (2,). Explain why a three-row two-feature table would still contain two-coordinate vectors, not three-coordinate ones.

Ready to move on: you can state coordinate and shape assumptions before applying a formula. The next linear-algebra lesson treats matrices as maps and solves linear systems. See the course overview for availability.