What is geometric algebra? And how is it different from algebraic geometry?
The basic observation of GA is this: in R^3 we've got scalars and vectors — but a vector is really a 1D subspace of R^3; so, the question is: why aren't there 0-, 2-, and 3- dimensional subspaces of the "usual" R^3 vector space 'in the algebra'? The answer to that question is a new thing called a Clifford algebra (the basis of GA), which we write like "CL(R^3)".
David Hestenes noticed that CL(R^3) has a lot of physically-useful properties (although, he used CL(R^3;3,1) — the "3,1" describe the underlying metric/inner-product of the space; and sometimes, a conformal 5D space, instead).
The basic object of GA is a "multivector": it is a "polynomial" of different subspaces: `A + BV + CV^V + DV^V^V ... ZV^...^V`. GA defines a special "multiplication" of the "polynomials" which is called the geometric product. The geometric product has a bunch of useful properties.
However, as opposed to what the a sibling comment implies, the dimensionality of Clifford algebras is 2^N for an N-dimensional carrier. Thus, CL(R^3) is eight dimensional. The "nice" 5D conformal Clifford algebra is 32 dimensional. The inner-product is a square matrix with sides equal to the dimensionality of the Clifford algebra. Thus, what you might call a "dot product" in R^3 is an 8x8 matrix multiply in CL(R^3); for physically interesting algebras, it is a 32x32 matrix multiply.
Indeed you are correct -- I should have used the word "degree of freedom" to describe it more accurately in the sense of dimensional constraints, as opposed to "dimensions" which are the individual members.
To elaborate, the 3D space have the following possible members:
scalar component (3 choose 0): ()
vector components (3 choose 1): x | y | z
bivector components (3 choose 2): xx | yy | zz | xy=-yx | yz=-zy | zx=-xz
trivector components (3 choose 3): xyz=yzx=zxy=-zyx=-xzy=-yxz
If you don't know what any of those words mean, then it's a way to represent n-dimensional geometric objects and operations on them all within an algebraically closed environment. Moreover, (at least in the specific algebras I'm familiar with) you can view a lot of transformations/operations as reflections or compositions of reflections of one object with respect to another.
It's quite beautiful really. Transformations compose nicely and produce new (uniquely represented [1]) objects. You can work in a way that mirrors your geometric intuition instead of getting lost in the mire of representational details.
[1] One of the real sticking points of trying to embed everything in a vector space is that a lot of the representations overlap, and you have to operate on them specially. Planes are represented as normal vectors, and so are regular vectors.
For example in a 3D space:
* 0D: scalars
* 1D: regular vectors, representing a point.
* 2D: 'rotors', representing an oriented surface. These are equivalent to quaternions, in a generalized elegant manner. We use quaternions in 3D engines to have rotations that don't have a special axis like Euler's.
* 3D: representing an oriented volume.
Here's a link if you want to know more:
Then also adds the notion of describing them in terms of "how many dimensions are excluded from your embedding dimension to describe them (m-pseudovector)
Example in 3D:
scale: requires no vector dimensions <-> quantity (pseudovolume)
line: requires one vector dimension <-> plane family (pseudoplane)
plane: requires two vector dimensions <-> plane normal (pseudovector)
volume: requires three vector dimension <-> metric (pseudoscalar)
Two Dimensions (n+1=3):
scalar = pseudobivector
vector = pseudovector
bivector = pseudoscalar
Three Dimensions (n+1=4):
scalar = pseudotrivector
vector = pseudobivector
bivector = pseudovector
trivector = pseudoscalar
Four Dimensions (n+1=5):
scalar = pseudotetravector
vector = pseudotrivector
bivector = pseudobivector
trivector = pseudovector
tetravector = pseudoscalarThis means that "multiplying" apples and oranges is possible by having appapple components, ororange components, and apporange components, and they're just described the same way as you do with distributing multiplication in brackets, so just sum of incomparable objects.
So ultimately, in terms of calculations they fundamentally use the same number of operations. The main advantage is a cohesive framework of Types, rather than arbitrary exceptions defining different product rules. You just have *one* vector product, whose output have all of those as components.
From my limited understanding the idea is that instead of having vectors, quaternions, planes and so forth, these are all represented pretty much the same way. But as a working programmer is there a benefit to that? At the type level I'd definitely like those concepts to be separate.
The concepts may or may not be useful for your aims. One pragmatic benefit could be e.g. you can automatically generate optimally-performant code for different algebraic operations, all just from the spec.
It is a unified description of certain kinds of spaces. The greatest conceptual advantage over "regular linear algebra" (the quotes are there because you are still doing regular linear algebra, but with a different spaces and operations than R^n) is that it allows a very nice description of Euclidean space. Where e.g. points and rotations are the same type of object.
I think the best example are complex numbers. Complex numbers are just 2D vectors where multiplication is rotation. (Defining i as the square root of -1 is probably the worst way to think about complex numbers). The way they are doing it (the right way IMO) is actually as a 2^1 dimensional Vectorspace, with one multiplication (fully described by the product of all basis vectprs with one another) which describes the geometric properties of 2D euclidean space.
You can see more here: https://bivector.net/index.html
>Can you create better neural nets or faster graph search algorithms? What is the draw, computationally?
In one talk they claimed this is the case for graphical applications, where they contrasted it with Quarternions.
It is useless for neural nets, which need fast high dimensional matrix multiplication.