# Linear Spaces: Duck Typing and Tuples

Part of the (very slow moving) Poincaré Project.

We've introduced the general concept of a linear space and shown how it applies to the specific notion of arrow-type vectors.

Recall that a (real) linear space is a set of objects that can be added and scaled. What 'add' means and what 'scale' means are arbitrary as long as the following rules are followed:

• the space must form a commutative group under addition, in other words:

• for any two elements u and v, u + v is also an element of the space

• there is an element 0 called the identity element such that for every element v, v + 0 = v

• for every element v there is a corresponding inverse (written -v) such that v + -v = 0

• the addition is associative, i.e u + v + w = (u + v) + w = u + (v + w)

• the addition is commutative, i.e u + v = v + u

• for any real number a and any element v, av is also an element of the space (we say v has been scaled by a)

• for any two real numbers a and b and any element v, (a + b)v = av + bv

• for any real number a and elements u and v, a(u + v) = au + av

• for any real numbers a and b and element v, a (bv) = (ab)v

• for any element v, 1v = v

(other properties fall out naturally from the above requirements. For example, it's easy to show that -v must be v scaled by -1, that v + v = 2v and so on. Because these follow from the rules above, they are true of all linear spaces.)

Note that as long as these rules (or axioms) are followed, you have a (real) linear space. It doesn't matter how the elements are actually "implemented". The arrow-type vectors we saw earlier are just one type of linear space.

Programmers might find it useful to think of this as like duck-typing. If it looks like a duck, walks like a duck and quacks like a duck: it is a duck. If you'll pardon the paraphrase, if it adds like a linear space and scales like a linear space: it is a linear space. We never need to peer into the internals of the elements themselves.

Another "implementation" of the linear space idea which is probably familiar to many of you is the n-tuple. Arbitrarily picking n to be 3, the set of 3-tuples form a linear space if we define addition

(m, n, o) + (r, q, r) = (m + r, n + q, o + r)

and scaling

a(m, n, o) = (am, an, ao)

which means, of course, that whatever m thru r are, they must themselves be able to be added and able to be scaled by a real. An obvious choice would be that m thru r are themselves real numbers. Then we have a linear space often referred to as R3.

It is important to note that a tuple-based linear space is not the same as a linear space based on arrow-type vectors. While it may be possible to map arrow-type vectors to tuples (even in a way that is obvious and intuitive), they are not interchangeable and an infinite number of possible mappings exist between an arrow-type vector based linear space and a tuple based one.

It isn't possible to point to some arrow-type vector and say, oh, that's (3, 2, -7) without having first defined how to map the two spaces (which is an extra bit of structure).

One interesting characteristic of the arrow-type vector which the tuple in and of itself lacks, is its geometric nature. An arrow-type vector can be tied to a manifold and mean something in relation to that manifold and indeed this is what makes it a geometric type of linear space. (Remember in a previous post I used the phrase "travel in a particular direction at a particular rate" — this interpretation of an arrow-type vector only makes sense in the context of a manifold)

Next post in the Poincaré Project, we'll look at another type of linear space that is geometric (the one I promised I'd talk about last time) — the stack-type vector.

The original post was in the category: poincare_project but I'm still in the process of migrating categories over.

The original post had 1 comment I'm in the process of migrating over.