Maths - Example in 1D Euclidean Space

Since conformal space is 2 dimensions higher than the space we are working in, that means to model 1D Euclidean space, we need 3D Conformal space.

Representing Points

The point 'u' in Euclidean space corresponds to the following in conformal space:

-n0+ ½ u² n + u n1

where:

The way that these dimension basis vectors combine is derived below and represented as a multiplication table.

This representation of a point has the property that it is a null vector, that is, if we square it we will get zero.

Representing Translations

Transformations are represented as the even sub-algebra, that is scalar and bivector components, like a quaternion. Since we are representing a one dimensional Euclidean space we can't have rotations, the only transform that we can sensibly make is a translation, this is defined as:

1 + t n∞1

where:

Calculating Translations

Translations are applied to points by using the 'sandwich' product, that is we pre-multiply by the transform and post multiply by the conjugate of the transform (similar to the way we transform points using quaternions or Clifford algebra).

The translation is represented by: 1 + ½ na

and its conjugate is: 1 - ½ na

where 'a' is a vector in the euclidean space, in this one dimensional case a = t n1 so the translation is:

1 + ½ nt n1

which gives a term consisting of a real component '1' and a bivector component:

1 + ½ t n∞1

so applying this to a general point 'u' using the sandwich product gives:

(1 + ½ t n∞1)*(-n0+ ½ u² n + u n1)*(1 - ½ t n∞1)

We can multiply out each term using the multiplication table below, since this is tedous to do be hand I have used a free symbolic algebra program called Axiom (described on this page):

C1 := CliffordAlgebra(3,Expression(Fraction(Integer)),[[0,1,0],[1,0,0],[0,0,1]])
 
   (1)
   CliffordAlgebra(3,Expression(Fraction(Integer)),[[0,1,0],[1,0,0],[0,0,1]])
                                                                   Type: Type
pin := multivector([0,-1,u*u/2,0,u,0,0,0])$C1

               1  2
   (2)  - e  + - u e  + u e
           1   2    2      3
Type: CliffordAlgebra(3,Expression(Fraction(Integer)),[[0,1,0],[1,0,0],[0,0,1]])
tr := multivector([1,0,0,0,0,0,t/2,0])$C1

            1
   (3)  1 + - t e e
            2    2 3
Type: CliffordAlgebra(3,Expression(Fraction(Integer)),[[0,1,0],[1,0,0],[0,0,1]])
revtr := reverse(tr)$C1

            1
   (4)  1 - - t e e
            2    2 3
Type: CliffordAlgebra(3,Expression(Fraction(Integer)),[[0,1,0],[1,0,0],[0,0,1]])
pout := tr * pin * revtr

                1  2         1  2
   (5)  - e  + (- u  + t u + - t )e  + (u + t)e
           1    2            2     2           3
Type: CliffordAlgebra(3,Expression(Fraction(Integer)),[[0,1,0],[1,0,0],[0,0,1]])

so this rotor represents a point at u + t.

Concatenating Transforms

When using quaternions and matricies we can combine translations by multiplying them together, we can do the same in conformal space:

If we first apply a translation of t1:

(1 + ½ t1 n∞1)

Then we apply a subsequent translation of t2:

(1 + ½ t2 n∞1)

The equivalent translation will be:

(1 + ½ t1 n∞1) *(1 + ½ t2 n∞1)
=(1 + ½ t1n∞1 + ½ t2 n∞1+ ¼ t1t2 n∞1∞1)

The last product is zero (see table at bottom) so the result is:

=1 + (t1+ t2) n∞1

which is what we would expect.

Derivation of the Algebra

We will start by taking the original Euclidean dimension (e3) and then add another dimension that squares to positive (e1) and another dimension that squares to negative (e2) we will then rotate these additional dimensions by 45° to give: n0 and n which are null vectors (square to zero). After this we will apply constraints so we get back to one degree of freedom and we will use this to prove the results above.

As with all Clifford algebras, this algebra is defined by its inner product and we will start with the inner product of two vectors. From this we can derive the higher order products.

So the inner product is:

0 1 0
1 0 0
0 0 1

This is derived from two dimensions which square to +1 and one dimension which squares to -1:

1 0 0
0 -1 0
0 0 1

We rotate (for explanation of quadratic forms and rotating diagonal matrix see this page) this matrix by using a rotation matrix to represent 45° rotation in two dimensions and contra-rotated the axies by 45° to give the inner product in terms of the new axies:

QF =
cos 45° sin 45° 0
-sin 45° cos 45° 0
0 0 1
1 0 0
0 -1 0
0 0 1
cos 45° sin 45° 0
-sin 45° cos 45° 0
0 0 1
=
0 1 0
1 0 0
0 0 1

So this inner product:

0 1 0
1 0 0
0 0 1

gives the part of the

The outer product anti-coomutes as usual so we get:

0 n0∞ n01
- n0∞ 0 n∞1
- n01 - n∞1 0

So the geometric product a*b = a \/ b + a /\ b:

0 1 + n0∞ n01
1 - n0∞ 0 n∞1
- n01 - n∞1 1

These rules apply to multiplication of the vector components only, calculation of the higher order products is more complicated, we need to break down into vector products. We want to calculate the geometric product of vectors and higher order products. Since this is tedous to do be hand I have used a free symbolic algebra program called Axiom (described on this page):

C1 := CliffordAlgebra(3,Fraction(Integer),[[0,1,0],[1,0,0],[0,0,1]])
toTable(*)$C1

This produced the following multiplication table:

a*b b.1 b.n0 b.n b.n0∞ b.n1 b.n01 b.n∞1 b.n0∞1
a.1 1 n0 n n0∞ n1 n01 n∞1 n0∞1
a.n0 n0 0 1 + n0∞ - n0 n01 0 n1 + n0∞1 - n01
a.n n 1 - n0∞ 0 n n∞1 n1 - n0∞1 0 n∞1
a.n0∞ n0∞ n0 - n 1 n0∞1 n01 -n∞1 n1
a.n1 n1 - n01 - n∞1 n0∞1 1 - n0 - n n0∞
a.n01 n01 0 - n1 - n0∞1 - n01 n0 0 -1 - n0∞ - n0
a.n∞1 n∞1 - n1 + n0∞1 0 n∞1 n -1 + n0∞ 0 n
a.n0∞1 n0∞1 - n01 n∞1 n1 n0∞ - n0 n 1

Where:

We could have calculated this table by hand by using:
n0= (e1 + e2)/√2
n= (e1 - e2)/√2
n1= e3

We can then calculate the higher order terms like this:

n0 /\ n= (e1 + e2) /\ (e1 - e2)/2 = -e12

and

n0 * n= (e1 + e2) * (e1 - e2)/2 = 1-e12

combining these gives:

n0 * n= 1 + n0 /\ n= 1 + n0∞

and we could have calculated the other terms in this way. We could not use the multiplication rules defined here to directly calculate the table because this basis does not obey the rules we have used up to now, n0 and n don't anticommute. However the multiplication is reasonably well behaved in that the geometric and outer (but not inner) products are associative.

Inverse

With geometric algebra we cannot guarantee that the inverse of any multivector exists. So here we will concentrate on the even subalgebra, to do this we will follow the usual trick of multiplying numerator and denominator by the reversal (similar concept to conjugate). See this page for explanation of these terms.

So we want to find the inverse of:

an an+an0∞ an0∞+an01 an01+an∞1 an∞1

the result is:

a-1= (an an-an0∞ an0∞-an01 an01-an∞1 an∞1)/(an² + an*an0∞ + an∞1*an01)

This result is derived on this page.

Example Pure Displacement (no rotation)

Since we are representing 1D Euclidean space we don't need to model rotation since only displacement is applicable.

The representation of a point is given by:

n0
n
n1
=
-1
½u²
u

So if we are initially at point (u=3) this will be represented by the vector:

n0
n
n1
=
-1
½u²
u
=
-1
4.5
3

We now want to displace this by (x=4) this will be represented by the even multivector (scalar + bivector) where the displacement is twice the displacement:

s
n∞1
=
1
4/2 = 2

So to combine these, to give the resulting position, we multiply together their representations using sandwich product:

=(1 + 2 n∞1)*(-1 n0 + 4.5 n +6 n1)*(1 - 2 n∞1)
=-1 n0 + 0.5*7² n + 7 n1

So we have added 4 to 3 to give 7

Multivector Calculator

The following calculator allows you to calculate the multivector arithmetic of our rotated basis. The terms are calculated on this page.

Enter the values into the top two multivectors and then press "+ - or * " to display the result in the bottom multivector:

scalar n    
vector n0 n∞ n1
bivector n0∞ n01 n∞1
tri-vector n0∞1    
scalar n    
vector n0 n n1
bivector n0∞ n01 n∞1
tri-vector n0∞1    
=
scalar n    
vector n0 n n1
bivector n0∞ n01 n∞1
tri-vector n0∞1    

metadata block
see also:

 

Correspondence about this page

Book Shop - Further reading.

Where I can, I have put links to Amazon for books that are relevant to the subject, click on the appropriate country flag to get more details of the book or to buy it from them.

flag flag flag flag flag flag Geometric Algebra for Computer Science: An Object-oriented Approach to Geometry. This book stresses the Geometry in Geometric Algebra, although it is still very mathematically orientated. Programmers using this book will need to have a lot of mathematical knowledge. Its good to have a Geometric Algebra book aimed at computer scientists rather than physicists. There is more information about this book here.

 

This site may have errors. Don't use for critical systems.

Copyright (c) 1998-2017 Martin John Baker - All rights reserved - privacy policy.