Application Center - Maplesoft

# The CayleyDickson Algebra from 4D to 256D

You can switch back to the summary page by clicking here.

Cayley-Dickson Algebra of the Quaternions, Octonions, Sedenions, Pathions, Chingons, Routons, and Voudons

by Michael Tyrone Carter

Purdue University, West Lafayette

April 18, 2010

Description

Disclaimer

Feel free to utilize this package for academic, business, or personal use according to Maplesoft's license agreement. However, neither Maplesoft nor I are liable for any errors that may come from this package.  All I ask is that you give me credit.  Please do not reverse engineer this package, because it is the unethical to reverse engineer others work.  If you perhaps do find errors, please feel free to email me so that  I may correct the errors as soon as possible.

Introduction

Could the universe be so large that space appears to be flat?  On earth when one looks at the horizon of the ocean it appears flat.  Only when we escape the atmosphere of the earth does one sees its curvature.  Jupiter is about 300 times the size of the earth.  If we lived on Jupiter, we most likely never will be able to fly, including escape from Jupiter's atmosphere.  It may even be impossible to explore the entire planet.  We could easily make the mistake and believe that Jupiter is flat.    It is so easy to ask questions, but can one produce the answers?  The answers can be found with our mathematics, observations, and experiments.  We used mathematics just as effectively as a seeing-eye-dog for the blind, because without mathematics we are blind.  We cannot see beyond the horizon of the universe; nor, can we escape the universe and see it from the outside.  Therefore, we need to go back to kindergarten and learn once again the concept of a number.   We used numbers for counting, order, measure, position, direction, orientation, angle, and duration; but now we also used numbers for twist, rotation, spin, and/or state.  Extending one of the operands, in a product, as a composite operator, for example, an operand multiplied by a negative operand may be seen as a 180-degree rotation.  Furthermore, an operand multiplied by an imaginary operand may be seen as a 90-degree rotation.    We must move away from only having interest in our mathematics for application purposes only.  Michael Faraday was once asked, of his invention, what good was a wire spinning around by an electric current.  His reply was, "What good is a new born baby?"   Today we have Faraday's motor which has countless applications today.   We do pure mathematics for the same reason that one climbs a mountain, because it is just there.   It is unfortunately that even in our Modern Algebra textbooks that quaternions may only get a page within the entire textbook.  It is very common that we do not discuss, within our Modern Algebra textbooks higher hypercomplex algebras.  William Hamilton, the discoverer of the quaternion is also the father of Modern Algebra.  Then why is he no more than a footnote in our textbooks?In conclusion, we must ask the silly questions, for without the silly questions, we can never get the serious answers.  However, the questions are not enough.  We must take our mathematics or our seeing-eye-dog and begin trying to work out a theory.  We must play by the rules and learn the game as we play.  It all begins with algebra and geometry.   Let the games begin.  Cheers.

Functions

 `*`,  `+`,  `-`,  `^`,  Cadd,  Calgebra,  Cconjugate,  Cdefine,  Cdot,  Ceval,  Cinverse,  Cmult,  Crand,  Cscalar,  Csubtract,  CtoMatrix,  CunitVector,  Cvector,  Oadd,  Oalgebra,  Oconjugate,  Odefine,  OdivLeft,  OdivRight,  Odot,  Oeval,  Oinverse,  Omult,    Orand,  Oscalar,  Osubtract,  OtoMatrices,  OtoMatrix,  OunitVector,  Ovector,  Padd,  Palgebra,  Pconjugate,  Pdefine,  Pdot,  Peval,  Pinverse,  Pmult,  Prand,  Pscalar,  Psubtract,  PtoMatrix,  PunitVector,  Pvector Qabs,  Qadd,  Qalgebra,  Qaxial,  Qceil,  Qconjugate,  QconvertToFrac,  Qdefine,  QdivLeft,  QdivRight,  Qdot,  Qeval,  Qexp,  Qfloor,  Qfrac,  Qicoeff,  Qinverse,  QisCommutable,  QisEqual,  QisNZscalar,  QisNZscalarOne,  QisPure,  QisScalar,  Qjcoeff,  Qkcoeff,  Qlength,  Qln,  Qmagnitude,  Qmodulus,  Qmult,  Qnorm,  Qnormalize,  Qpower,     Qrand,  Qround,  Qscalar,  Qsignum,  Qsqrt,  Qsubtract,  QtoMatrices,  QtoMatrix,  Qtrunc,  Qunit,  QunitVector,  Qvector Radd, Ralgebra, Rconjugate, Rdefine, Rdot, Reval, Rinverse, Rmult, Rrand, Rscalar, Rsubtract, RtoMatrix, RunitVector, Rvector, Sadd, Salgebra, Sconjugate, Sdefine, Sdot, Seval, Sinverse, Smult, Srand, Sscalar, Ssubtract, StoMatrix, SunitVector, Svector, Vadd, Valgebra, Vconjugate, Vdefine, Vdot, Veval, Vinverse, Vmult, Vrand, Vscalar, Vsubtract, VtoMatrix, VunitVector, Vvector, getHypercomplex, setHypercomplex;

Getting Started

There are higher dimensional numbers besides complex numbers.  There are also hypercomplex numbers, such as, quaternions (4 D), octonions (8 D), sedenions (16 D), pathions (32 D), chingons (64 D), routons (128 D), voudons (256 D), and so on, without end.  These names were coined by Robert P.C. de Marrais and Tony Smith.  It is an alternate naming system providing relief from the difficult Latin names, such as:

trigintaduonions (32 D),  sexagintaquatronions (64 D), centumduodetrigintanions (128 D), and ducentiquinquagintasexions (256 D).

Getting Started

Here is one way to tell Maple where the package library is located.  This does not affect Maple's system library.  If you have an apple you will not have a C: drive.

In addition, you will use the forward slash and not two double back-slashes.

 > restart;

 >

 > hypercomplex_lib := "/Users/michaelcarter/Desktop/CayleyDickson/CayleyDickson.mla";

 >

 > libname := hypercomplex_lib, libname;

 (1)

Here we load the package.  Notice that the semi-colon is on the end of the command. The semi-colon forces the command to be verbosed.  If you do not want the verbose mode then use a colon for quiet mode for the command.

The package is displaying all functions available to the user.  In addition, the operators *, +, -, and ^ are overloaded by the package.  The user will know this by seeing the operators being displayed.

 > with(CayleyDickson);

 (2)

Quaternion Lesson

Quaternions Lesson

The quaternions have four components. u, i, j, and k.  These components are protected by the package so that the package can properly work.

You will get an error message if you try to assign values to these components.

Be advised that you will lose the values to your variables if you have values assigned to these components when you load the Hypercomplex package.

 > u := 5;

 >

 > i := 5;

 >

 > j := 5;

 >

 > k := 5;

The u component is the scalar component.  The i, j, and k components are the imaginary components.

You do not have to use the u component.  You may just use the Reals, instead.

 > setHypercomplex(quaternion);

 (3)

 > getHypercomplex(quaternion);

 (4)

 > u*u;

 > i*i;

 (5)

 > j*j;

 (6)

 > k*k;

 (7)

The u, scalar, component is always multiplicative commutative with the other components.  However, all three imaginary components are not multiplicative commutative.  In fact, they are anti-commutative.  Anti-commutative means when we transposed the order of multiplication the sign will change.

In addition, noticed that the imaginary components are cyclic.  When we multiply i*j we get k.  When we multiply j*k we get i.  And, when we multiply k*i we get j.

 > u*i;

 (8)

 > i*u;

 (9)

 > i*j;

 (10)

 > j*i;

 (11)

 > j*k;

 (12)

 > k*j;

 (13)

 > k*i;

 (14)

 > i*k;

 (15)

 > QisCommutable(2,-5);

 (16)

 > QisCommutable(i,-17);

 (17)

 > QisCommutable(i,j);

 (18)

 > QisCommutable(u,k);

 (19)

 > qx := Qdefine(4,5,6,10);

 (20)

 > qxc := Qconjugate(qx);

 (21)

 > qx*qxc;

 (22)

 > qxc*qx;

 (23)

 > Qaxial(qx,qxc);

 (24)

 > QisCommutable(qx, qxc);

 (25)

Another way to see that the imaginary components are cyclic, is to raise then each to an increased power.  The scalar component behaves like the number one.  Raisng one to any power is still one. We can interchange the u component with the number one, even though the calculations do not show it. The u remains there.  The pretty print is just converting it to number one.

When we are working only with one imaginary component at a time notice, that when you raised the imaginary component to zero it is equal to one, but, for every mutiple of 4*n power it will also be one.  For ever 4*n + 1 power we will always get the positve imaginary component back.  For ever 4*n+2 power we will get aways get the -1 back.  Finally, for evey power 4*n+3 we will always get the negative imaginary component back.

 > u^0; i^0; j^0; k^0;

 (26)

 > u^1; i^1; j^1; k^1;

 (27)

 > u^2; i^2; j^2; k^2;

 (28)

 > u^3; i^3; j^3; k^3;

 (29)

 > u^4; i^4; j^4; k^4;

 (30)

 > u^5; i^5; j^5; k^5;

 (31)

 > u^6; i^6; j^6; k^6;

 (32)

 > u^7; i^7; j^7; k^7;

 (33)

 > u^8; i^8; j^8; k^8;

 (34)

We can take any quaternion and make our own special component.  This is called the unit vector.  The unit vector is also cyclic.  Except for the precision error, we are also getting a similar cyclic behavior that we were receiving with the indiviual imaginary components.

 > q  := 1 + 2*i + 3*j + 4*k;

 (35)

 > qu := QunitVector(q);

 (36)

 > qu^0;

 (37)

 (38)

 > qu^1;

 (39)

 > qu^2;

 (40)

 > qu^3;

 (41)

 > qu^4;

 (42)

 > qu^5;

 (43)

Here is an example of a interesting behavior on how the unit vector works.

 > q  := 1 + 2*i + 3*j + 4*k;

 (44)

 > qu := QunitVector(q);

 (45)

 > i*qu;

 (46)

 (47)

 > qu*i;

 (48)

Here, we are only testing the Qln and Qexp functions.  We are checking to see if the results make sense.  Remember that the argument for the Qexp must be a modulus that is not less than -1 and is not greater than +1.

 > iy := 0.5 + 0.3*I;

 (49)

 > evalf(exp(ln(iy)));

 (50)

 > evalf(ln(exp(iy)));

 (51)

 > ix := -21/8 + (5/8)*I;

 (52)

 > evalf(exp(ln(ix)));

 (53)

 > evalf(ln(exp(ix)));

 (54)

 >

 > q := Qdefine(1/2,1/3,1/4,1/5);

 (55)

 > evalf(q);

 (56)

 > evalf(Qexp(Qln(q)));

 (57)

 >

 > evalf(Qln(Qexp(q)));

 (58)

 >

If we used only one scalar and one imaginary unit,   these components will behave like the ordinary complex numbers.  The ordinary complex numbers are comutative.

However, if we used more than one imaginary unit, we cannot use the division symbol.  Left division is different from right division for quaternions.  It is this way because quaternions are not commutative.

 > complexI := 1/(23.5 + 15*I);

 (59)

 > complexi := 1/(23.5 + 15*i);

 (60)

 > complexj := 1/(23.5 + 15*j);

 (61)

 > complexk := 1/(23.5 + 15*k);

 (62)

 > QdivLeft(complexi,complexj);

 (63)

 > QdivRight(complexi,complexj);

 (64)

 > Qinverse(complexi)*complexj;

 (65)

 > complexi*Qinverse(complexj);

 (66)

Here, we are testing to see if the imaginary components make sense.

 > i*j*k;

 (67)

 > (i*j)*k;

 (68)

 > i*(j*k);

 (69)

 > j*k*i;

 (70)

 > k*i*j;

 (71)

 > (2+i+j)*(3-j+k)*(-4+i+25*j+12*k);

 (72)

 > ((2+i+j)*(3-j+k))*(-4+i+25*j+12*k);

 (73)

 > (2+i+j)*((3+j+k)*(-4+i+25*j+12*k));

 (74)

 > i*j*k;

 (75)

 > k*j*i;

 (76)

In maple you can test to see what type an element is.

Here,we test to see what a quaternion is.

 > type(2,complex);

 (77)

 > type(I,complex);

 (78)

 > type(2+I,complex);

 (79)

 > type(2, quaternion);

 (80)

 > type(I, quaternion);

 (81)

 > type(2+I, quaternion);

 (82)

 > type(2+i+j+k, quaternion);

 (83)

 > type(2+i+j+k, complex);

 (84)

 > type([1,2,3],quaternion);

 (85)

 > type({1,2,3}, quaternion);

 (86)

 > type(2*u, quaternion);

 (87)

 > type(2, quaternion);

 (88)

 > type(i, complex);

 (89)

 > type(j, complex);

 (90)

 > type(1-k, complex);

 (91)

 > type(VARIABLE, quaternion);

 (92)

 > type(QtoMatrix(i), quaternion);

 (93)

 > type( Qeval(QtoMatrix(i)), quaternion);

 (94)

 > variable := Qln(1 + 15*i + 23.5*j + 16*k);

 (95)

 > type(variable,quaternion);

 (96)

 > is(5-i+2*j-8*k, quaternion);

 (97)

 > is(5+i+2*j+8*k, quaternion);

 (98)

Here is an example on how we construct a quaterion in matrix form.

 > q := Qrand(-50,100);

 (99)

 > qm := QtoMatrix(q);

 (100)

 > Qeval(qm);

 (101)

 > Qconjugate(q);

 (102)

 > QtoMatrix( Qconjugate(q));

 (103)

 > Qeval( QtoMatrix( Qconjugate(q)));

 (104)

 > q;

 (105)

 > QtoMatrices(q);

 (106)

Here is a test to see if the Qsqrt function makes sense.

 > q := Qdefine(23.45, 72.45, 98.3, 0.5);

 (107)

 > q := QconvertToFrac(q);

 (108)

 >

 > Qsqrt(q);

 (109)

 > evalf(Qsqrt(q)*Qsqrt(q));

 (110)

 > evalf(q);

 (111)

We can isolate the components for quaternions.

 > q := Qrand(-10,10);

 (112)

 > Qscalar(q);

 (113)

 > Qvector(q);

 (114)

 > Qicoeff(q);

 (115)

 > Qjcoeff(q);

 (116)

 > Qkcoeff(q);

 (117)

We can construct proofs with the Qalgebra function.

 > qx := Qalgebra(0,3);

 (118)

 > qx*Qinverse(qx);

 (119)

 > simplify(%);

 (120)

 > qx*Qconjugate(qx);

 (121)

 > Qconjugate(qx)*qx;

 (122)

 > qu := QunitVector(qx);

 (123)

 > qu*qu;

 (124)

 > simplify(qu*qu);

 (125)

 > Qdot(qu,qu);

 (126)

 > simplify(Qdot(qu,qu));

 (127)

 > QtoMatrix(qu);

 (128)

 > QtoMatrix(qx);

 (129)

 > Qeval( QtoMatrix(qx) );

 (130)

Octonions

Octonion Lesson

We have components that are protected.  These components are:

i0, i1, i2, i3, i4, i5, i6, and i7.

These are the components that represent the octonions' units.

 > i0 := 2;

 > i0 := 2;

 > i1 := 2;

 > i7 := 2;

You must be in octonion mode before you can caculate with octonions.

 > i2*i7;

 > setHypercomplex(octonion);

 (131)

 > i2*i7;

 (132)

 > 3*i0;

 (133)

 > i0;

 (134)

 > 5*4*i0;

 (135)

 > 5*4;

 (136)

 >

Notice that the octonions imaginary components are also cyclic, just like the quaternions.  By being cyclic, it assures that the algebra is a closed system.

 > i1*i2; i2*i1;

 (137)

 > i2*i3; i3*i2;

 (138)

 > i3*i1; i1*i3;

 (139)

 > i1*i2; -i1*i2; i1*(-i2);

 (140)

 > i4*i5; i5*i4;

 (141)

It is a requirement that all Cayley-Dickson imaginary units are equal to -1 when squared.

 > i0*i0;

 (142)

 > i1*i1;

 (143)

 > i2*i2;

 (144)

 > i3*i3;

 (145)

 > i4*i4;

 (146)

 > i5*i5;

 (147)

 > i6*i6;

 (148)

 > i7*i7;

 (149)

Just like the Reals, ordinary complex numbers, quaternions, and the octonions are all division algebras.

When you multiply an octonion by its inverse you will get a positive one.

However, because octonion division is also non-commuative, we have both a left and right division.

 > i2*Oinverse(i2);

 (150)

 > Oinverse(i2)*i2;

 (151)

 > OdivLeft(i2,i2);

 (152)

 > OdivRight(i2,i2);

 (153)

 > OdivRight(i2,i3);

 (154)

 > OdivLeft(i2,i3);

 (155)

 > OdivLeft(2,3);

 (156)

 > OdivRight(2,3);

 (157)

 > 4*Oinverse(5);

 (158)

 > Oinverse(5)*4;

 (159)

Here, we are testing the Odot product.  The Odot product is made from multiplication, addition and conjugate operators.??

The dot product has a longer processing time.

 > Odot(2,3);

 (160)

 > Odot(i2,i3);

 (161)

 > Odot(i2,i2);

 (162)

 > o1 := Orand(-100,100);

 (163)

 > Odot(o1,o1);

 (164)

 > evalf( Odot(o1,o1) );

 (165)

 > o2 := Orand(1,1);

 (166)

 > Odot(o2,o2);

 (167)

In this package the octonions are defined as a hypermatrix. The members are not scalars, but are quaternions.

 > o3 := Odefine(1,2,3,4, 5,6,7,8);

 (168)

 > OtoMatrix(o3);

 (169)

 > OtoMatrices(o3);

 (170)

 > o4 := Orand(-10,10);

 (171)

 > OtoMatrix(o4);

 (172)

 > OtoMatrices(o4);

 (173)

 > OtoMatrices( Oconjugate(o4) );

 (174)

Octonions also have a type.

 > type(4,octonion);

 (175)

 > type(i2, octonion);

 (176)

 > type(-3*i7, octonion);

 (177)

 > type(j, octonion);

 (178)

 > type(i8, octonion);

 (179)

 > type(e15, octonion);

 (180)

 > type(I, octonion);

 (181)

Octonions are not generally commutative like the quaternions, but, they are also not generally associative unlike the quaternions.  Notice, that it is possible to get a different value based on how we group our multiplication operations.

 > i1*i2*i3;

 (182)

 > i1*(i2*i3);

 (183)

 > (i1*i2)*i3;

 (184)

 > i1*(i4*i7);

 (185)

 > (i1*i4)*i7;

 (186)

 > i1*i4*i7;

 (187)

We have the ability to isolate the scalar value and vector value from an octonion.  The quaternion has means to isolate all components.  In this package, we can only isolate the scalar value and vector value for octonions, sedenions, pathions, chingons, routons, and voudons.

 > ox := Orand(-10000,10000);

 (188)

 > Oscalar(ox);

 (189)

 > Ovector(ox);

 (190)

We can construct proofs with the Oalgebra function.  Note, that an octonion multiplied by its inverse is here proved to be one.

 > ox := Oalgebra(0,7);

 (191)

 > ox*Oinverse(ox);

 (192)

 > simplify(%);

 (193)

 > ox*Oconjugate(ox);

 (194)

 > Oconjugate(ox)*ox;

 (195)

 > ou := OunitVector(ox);

 (196)

 > ou*ou;

 (197)

 > simplify(%);

 (198)

 > Odot(ou,ou);

 (199)

 > simplify(%);

 (200)

 > OtoMatrix(ou);

 (201)

 > OtoMatrix(ox);

 (202)

 > Oeval( OtoMatrix(ox) );

 (203)

Sedenions

Sedenion Lesson

Components e0 to e15 and O are protected.

 > O := 2;

 > e0 := 4;

 > e7 := 15;

 > e15 := 23;

You must be in sedenion mode before you can caculate with the sedenions.

 > e3*e7;

 > setHypercomplex(sedenion);

 (204)

 > e3*e7;

 (205)

 > e7*e3; -e7*(-e3);

 (206)

 > -e7*e3; e7*(-e3);

 (207)

 > e1*e2*e3;

 (208)

 > e3*e2*e1;

 (209)

 > s1 := Srand(-5,5);

 (210)

 > s1 + (1/5)*e15;

 (211)

e0 is the component that represents 1, however, it is in hypermatrix form.  Hence, e0 is the same as 1 and 5*e0 is the same as 5.

The square of an imaginary unit is equal to negative one.  This is a requirement of the Cayley-Dickson algebra.

 > 5*e0*e0;

 (212)

 > e1*e1;

 (213)

 > e2*e2;

 (214)

 > e3*e3;

 (215)

 > e4*e4;

 (216)

 > e5*e5;

 (217)

 > e6*e6;

 (218)

 > e7*e7;

 (219)

 > e8*e8;

 (220)

 > e9*e9;

 (221)

 > e10*e10;

 (222)

 > e11*e11;

 (223)

 > e12*e12;

 (224)

 > e13*e13;

 (225)

 > e14*e14;

 (226)

 > e15*e15;

 (227)

The sedenion is not a divsion algebra.  It is that way because it has zero-divisors.  A zero divsior  is when both a and b are not equal to zero; yet, a times b is equal to zero.  See the two trivial examples.

 > (e2+e7)*(e4-e14);

 (228)

 > (e3 + e10)*(e6 - e15);

 (229)

 > (e1 + e10)*(e13 - e6);

 (230)

 > a := e3 + e10;

 (231)

 > b := e6 - e15;

 (232)

 > evalb(a = 0);

 (233)

 > evalb(b = 0);

 (234)

 > evalb(a*b = 0);

 (235)

Here, we are testing the dot product function.

The dot product has a longer processing time.

 > sx := Srand(1,1);

 (236)

 > sconj := Sconjugate(sx);

 (237)

 > Sdot(sx,sx);

 (238)

 > Sdot(sconj,sconj);

 (239)

Here, we are testing the scalar function and the vector function.

 > sx := Srand(-100,100);

 (240)

 > Sscalar(sx);

 (241)

 > Svector(sx);

 (242)

Here, we see that hypermatrices are the elements of the sedenions' hypermatrix.  Actually, we are using octonions for the elements.

 > sx := Srand(-100,100);

 (243)

 > StoMatrix(sx);

 (244)

 > sx := Srand(1,1);

 (245)

 > StoMatrix(sx);

 (246)

Yes, the sedenion has a type as well.

 > sx := Srand(1,1);

 (247)

 > type(sx,sedenion);

 (248)

 > type(5,sedenion);

 (249)

 > type(5*e0, sedenion);

 (250)

 > type(4*e1 - 18*e15,sedenion);

 (251)

 >

We can construct proofs with the Salgebra function.  Note, that a sedenion multiplied by its inverse is here proved to be one.

 > sx := Salgebra(0,3);

 (252)

 > sx*Sinverse(sx);

 (253)

 > simplify(%);

 (254)

 > sx*Sconjugate(sx);

 (255)

 > Sconjugate(sx)*sx;

 (256)

 > su := SunitVector(sx);

 (257)

 > su*su;

 (258)

 > simplify(%);

 (259)

 > Sdot(su,su);

 (260)

 > simplify(%);

 (261)

 > StoMatrix(su);

 (262)

 > StoMatrix(sx);

 (263)

 > Seval( StoMatrix(sx) );

 (264)

Pathion

Pathion Lesson

Components p0 to p31 and O are protected.

 > O := 2;

 > p0 := 4;

 > p7 := 15;

 > p15 := 23;

You must be in pathion mode before you can caculate with the pathions.

 > p3*p7;

 > setHypercomplex(pathion);

 (265)

 > p3*p7;

 (266)

 > p7*p3; -p7*(-p3);

 (267)

 > -p7*p3; p7*(-p3);

 (268)

 > p1*p2*p3;

 (269)

 > p3*p2*p1;

 (270)

 > px := Prand(-5,5);

 (271)

 > px + (1/5)*p15;

 (272)

p0 is the component that represents 1, however, it is in hypermatrix form.  Hence, p0 is the same as 1 and 5*p0 is the same as 5.

The square of the imaginary units are equal to negative one.

 > p0*p0;

 (273)

 > p1*p1;

 (274)

 > p2*p2;

 (275)

 > p3*p3;

 (276)

 > p4*p4;

 (277)

 > p5*p5;

 (278)

 > p6*p6;

 (279)

 > p7*p7;

 (280)

 > p8*p8;

 (281)

 > p12*p12;

 (282)

 > p15*p15;

 (283)

 > p19*p19;

 (284)

 > p21*p21;

 (285)

 > p25*p25;

 (286)

 > p27*p27;

 (287)

 > p31*p31;

 (288)

The pathions are not a divsion algebra.  They are that way because they have zero-divisors.  A zero divsior  is when a does not equal zero and b does not equal zero; however, a times b may be equal to zero.  See the two trivial examples.

 > (p2+p7)*(p4-p14);

 (289)

 > (p3 + p10)*(p6 - p15);

 (290)

 > (p1 + p10)*(p13 - p6);

 (291)

 > a := p3 + p10;

 (292)

 > b := p6 - p15;

 (293)

 > evalb(a = 0);

 (294)

 > evalb(b = 0);

 (295)

 > evalb(a*b = 0);

 (296)

Here, we are testing the dot product function.

The dot product has a longer processing time.

 > px := Prand(1,1);

 (297)

 > pconj := Pconjugate(px);

 (298)

 > Pdot(px,px);

 (299)

 > Pdot(pconj,pconj);

 (300)

Here, we are testing the scalar function and the vector function.

 > px := Prand(-100,100);

 (301)

 > Pscalar(px);

 (302)

 > Pvector(px);

 (303)

Here, we see that hypermatrices are the elements of the pathions' hypermatrix.  Actually, we are using sedenions for the elements.

 > px := Prand(-100,100);

 (304)

 > PtoMatrix(p3);

 (305)

 > px := Prand(1,1);

 (306)

 > PtoMatrix(px);

 (307)

The pathions have a type.

 > px := Prand(1,1);

 (308)

 > type(px,pathion);

 (309)

 > type(5,pathion);

 (310)

 > type(5*p0, pathion);

 (311)

 > type(4*p1 - 18*p15,pathion);

 (312)

 >

We can construct proofs with the Palgebra function.  Note, that a sedenion multiplied by its inverse is here proved to be one.

 > px := Palgebra(0,3);

 (313)

 > px*Pinverse(px);

 (314)

 > simplify(%);

 (315)

 > px*Pconjugate(px);

 (316)

 > Pconjugate(px)*px;

 (317)

 > pu := PunitVector(px);

 (318)

 > pu*pu;

 (319)

 > simplify(%);

 (320)

 > Pdot(pu,pu);

 (321)

 > simplify(Pdot(pu,pu));

 (322)

 > PtoMatrix(pu);

 (323)

 > PtoMatrix(px);

 (324)

 > Peval( PtoMatrix(px) );

 (325)

Chingon

Chingon Lesson

Components c0 to e63 and O are protected.

 > O := 2;

 > c0 := 4;

 > c7 := 15;

 > c63 := 23;

You must be in chingon mode before you can caculate with the chingons.

 > c3*c7;

 > setHypercomplex(chingon);

 (326)

 > c3*c7;

 (327)

 > c7*c3; -c7*(-c3);

 (328)

 > -c7*c3; c7*(-c3);

 (329)

 > c1*c2*c3;

 (330)

 > c3*c2*c1;

 (331)

 > cx := Crand(-5,5,31);

 (332)

 > cx + (1/5)*c15;

 (333)

c0 is the component that represents 1, however, it is in hypermatrix form.  Hence, c0 is the same as 1 and 5*c0 is the same as 5.

The imaginary units squared are equal to negative one.

 > c0*c0;

 (334)

 > c1*c1;

 (335)

 > c2*c2;

 (336)

 > c3*c3;

 (337)

 > c4*c4;

 (338)

 > c5*c5;

 (339)

 > c6*c6;

 (340)

 > c7*c7;

 (341)

 > c8*c8;

 (342)

 > c15*c15;

 (343)

 > c19*c19;

 (344)

 > c30*c30;

 (345)

 > c45*c45;

 (346)

 > c50*c50;

 (347)

 > c60*c60;

 (348)

 > c63*c63;

 (349)

A chingon is not a divsion algebra.  It is that way because it has zero-divisors.   See the two trivial examples.

 > (c2+c7)*(c4-c14);

 (350)

 > (c3 + c10)*(c6 - c15);

 (351)

 > (c1 + c10)*(c13 - c6);

 (352)

 > a := c3 + c10;

 (353)

 > b := c6 - c15;

 (354)

 > evalb(a = 0);

 (355)

 > evalb(b = 0);

 (356)

 > evalb(a*b = 0);

 (357)

Here, we are testing the dot product function.

The dot product has a longer processing time.

 > cx := Crand(1,1,10);

 (358)

 > cconj := Cconjugate(cx);

 (359)

 > Cdot(cx,cx);

 (360)

 > Cdot(cconj,cconj);

 (361)

Here, we are testing the scalar function and the vector function.

 > cx := Crand(-100,100, 63);

 (362)

 > Cscalar(cx);

 (363)

 > Cvector(cx);

 (364)

Here, we see that hypermatrices are the elements of the chingons' hypermatrix.  Actually, we are using pathions for the elements.

 > cx := Crand(-100,100);

 (365)

 > CtoMatrix(cx);

 (366)

 > cx := Crand(1,1);

 (367)

 > CtoMatrix(cx);

 (368)

We can construct proofs with the Calgebra function.  Note, that a chingon multiplied by its inverse is here proved to be positive one.

 > cx := Calgebra(0,3);

 (369)

 > cx*Cinverse(cx);

 (370)

 > simplify(%);

 (371)

 > cx*Cconjugate(cx);

 (372)

 > Cconjugate(cx)*cx;

 (373)

 > cu := CunitVector(cx);

 (374)

 > cu*cu;

 (375)

 > simplify(%);

 (376)

 > Cdot(cu,cu);

 (377)

 > simplify(%);

 (378)

 > CtoMatrix(cu);

 (379)

 > CtoMatrix(cx);

 (380)

 > Ceval( CtoMatrix(cx) );

 (381)

The chingons have a type.

 > cx := Crand(1,1);

 (382)

 > type(cx,chingon);

 (383)

 > type(5,chingon);

 (384)

 > type(5*c0, chingon);

 (385)

 > type(4*c1 - 18*c15,chingon);

 (386)

 >

Routon

Routon Lesson

Components u0 to u127 and O are protected.

 > O := 2;

 > u0 := 4;

 > u7 := 15;

 > u15 := 23;

You must be in routon mode before you can caculate with the routons.

 > u3*u7;

 > setHypercomplex(routon);

 (387)

 > u3*u7;

 (388)

 > u7*u3; -u7*(-u3);

 (389)

 > -u7*u3; u7*(-u3);

 (390)

 > u1*u2*u3;

 (391)

 > u3*u2*u1;

 (392)

 > rx := Rrand(-5,5);

 (393)

 > rx + (1/5)*u15;

 (394)

u0 is the component that represents 1, however, it is in hypermatrix form.  Hence, u0 is the same as 1 and 5*u0 is the same as 5.

The imaginary units squared are equal to negative one.

 > u0*u0;

 (395)

 > u1*u1;

 (396)

 > u2*u2;

 (397)

 > u3*u3;

 (398)

 > u4*u4;

 (399)

 > u5*u5;

 (400)

 > u6*u6;

 (401)

 > u7*u7;

 (402)

 > u8*u8;

 (403)

 > u9*u9;

 (404)

 > u10*u10;

 (405)

 > u11*u11;

 (406)

 > u15*u15;

 (407)

 > u31*u31;

 (408)

 > u63*u63;

 (409)

 > u127*u127;

 (410)

The routons are not a divsion algebra.  They are that way because they have zero-divisors.  See the two trivial examples.

 > (u2+u7)*(u4-u14);

 (411)

 > (u3 + u10)*(u6 - u15);

 (412)

 > (u1 + u10)*(u13 - u6);

 (413)

 > a := u3 + u10;

 (414)

 > b := u6 - u15;

 (415)

 > evalb(a = 0);

 (416)

 > evalb(b = 0);

 (417)

 > evalb(a*b = 0);

 (418)

Here, we are testing the dot product function.

The dot product has a longer processing time.

 > rx := Rrand(1,1,7);

 (419)

 > rconj := Rconjugate(rx);

 (420)

 > Rdot(rx,rx);

 (421)

 > Rdot(rconj,rconj);

 (422)

Here, we are testing the scalar function and vector function.

 > rx := Rrand(-100,100,17);

 (423)

 > Rscalar(rx);

 (424)

 > Rvector(rx);

 (425)

Here, we see that hypermatrices are the elements of the routons' hypermatrix.  Actually, we are using chingons for the elements.

Note: One may used the Vrand function.  The Vrand functions has two or three arguments.   The third argument is for how many counts of the elements.

 > rx := Rrand(-100,100,7);

 (426)

 > RtoMatrix(rx);

 (427)

 > rx := Rrand(1,1,15);

 (428)

 > RtoMatrix(rx);

 (429)

We can make proofs with the Ralgebra function.  Note, that a routon multiplied by its inverse is here proven to be positive one.

 > rx := Ralgebra(0,3);

 (430)

 > rx*Rinverse(rx);

 (431)

 > simplify(%);

 (432)

 > rx*Rconjugate(rx);

 (433)

 > Rconjugate(rx)*rx;

 (434)

 > ru := RunitVector(rx);

 (435)

 > ru*ru;

 (436)

 > simplify(%);

 (437)

 > Rdot(ru,ru);

 (438)

 > simplify(%);

 (439)

 > RtoMatrix(ru);

 (440)

 > RtoMatrix(rx);

 (441)

 > Reval( RtoMatrix(rx) );

 (442)

The routons have a type.

 > rx := Rrand(1,1,15);

 (443)

 > type(rx,routon);

 (444)

 > type(5,routon);

 (445)

 > type(5*u0,routon);

 (446)

 > type(4*u1 - 18*u15,routon);

 (447)

 >

Voudon

Voudon Lesson

Components v0 to v255 and O are protected.

 > O := 2;

 > v0 := 4;

 > v7 := 15;

 > v15 := 23;

You must be in voudon mode before you can caculate with the voudons.

 > v3*v7;

 > setHypercomplex(voudon);

 (448)

 > v3*v7;

 (449)

 > v7*v3; -v7*(-v3);

 (450)

 > -v7*v3; v7*(-v3);

 (451)

 > v1*v2*v3;

 (452)

 > v3*v2*v1;

 (453)

 > vx := Vrand(-5,5, 7);

 (454)

 > vx + (1/5)*v15;

 (455)

v0 is the component that represents 1, however, it is in hypermatrix form.  Hence, v0 is the same as 1 and 5*v0 is the same as 5.

The square of the imaginary units are equal to negative one.

 > v0*v0;

 (456)

 > v1*v1;

 (457)

 > v2*v2;

 (458)

 > v3*v3;

 (459)

 > v4*v4;

 (460)

 > v5*v5;

 (461)

 > v6*v6;

 (462)

 > v7*v7;

 (463)

 > v8*v8;

 (464)

 > v9*v9;

 (465)

 > v10*v10;

 (466)

 > v15*v15;

 (467)

 > v31*v31;

 (468)

 > v63*v63;

 (469)

 > v127*v127;

 (470)

 > v255*v255;

 (471)

The voudons are not a divsion algebra.  They are that way because it has zero-divisors. See the two trivial examples.

 > (v2+v7)*(v4-v14);

 (472)

 > (v3 + v10)*(v6 - v15);

 (473)

 > (v1 + v10)*(v13 - v6);

 (474)

 > a := v3 + v10;

 (475)

 > b := v6 - v15;

 (476)

 > evalb(a = 0);

 (477)

 > evalb(b = 0);

 (478)

 > evalb(a*b = 0);

 (479)

Here, we are testing the dot product function.

The dot product has a longer delay.

 > vx := Vrand(1,1,7);

 (480)

 > vconj := Vconjugate(vx);

 (481)

 > Vdot(vx,vx);

 (482)

 > Vdot(vconj,vconj);

 (483)

Here, we are testing the scalar function and vector function.

Note: One may used the Vrand function.  The Vrand functions has two or three arguments.   The third argument is for how many counts of the elements.

 > vx := Vrand(-100,100, 25);

 (484)

 > Vscalar(vx);

 (485)

 > Vvector(vx);

 (486)

Here, we see that hypermatrices are the elements of the voudons' hypermatrix.  Actually, we are using routons for the elements.

 > vx := Vrand(-100,100,15);

 (487)

 > VtoMatrix(vx);

 (488)

 > vx := Vrand(1,1, 10);

 (489)

 > VtoMatrix(vx);

 (490)

The voudons have a type.

 > vx := Vrand(1,1, 15);

 (491)

 > type(vx,voudon);

 (492)

 > type(5,voudon);

 (493)

 > type(5*v0,voudon);

 (494)

 > type(4*v0 - 18*v15,voudon);

 (495)

 >

We can construct proofs with the Valgebra function.  Note, that a vouton multiplied by its inverse is here proven to be postive one.

 > vx := Valgebra(7,10);

 (496)

 > vx*Vinverse(vx);

 (497)

 > simplify(%);

 (498)

 > vx*Vconjugate(vx);

 (499)

 > Vconjugate(vx)*vx;

 (500)

 > vu := VunitVector(vx);

 (501)

 > vu*vu;

 (502)

 > simplify(%);

 (503)

 > Vdot(vu,vu);

 (504)

 > simplify(%);

 (505)

 > VtoMatrix(vu);

 (506)

 > VtoMatrix(vx);

 (507)

 > Veval( VtoMatrix(vx) );

 (508)

 >

References

Maxfield, John E., and Maxfield, Margaret W.  Abstract Algebra and Solution by Radicals.  New York:  Dover, 1971.

Meserve, Bruce E.  Fundamental Concepts Of Algebra.  New York:  Dover, 1981.

Parker, Sybil P.  Dictionary of Mathematics.  New York:  McGraw, 1997.

Rucker, Rudy.  The Fourth Dimension:  A Guided Tour of the Higher Universes.   Boston:          Houghton, 1984.

Russell, Bertrand.  Introduction to Mathematical Philosophy.  New York:  Dover, 1933.

Sanchez, Julio, and Maria Canton.  DirectX 3D Graphics Programming Bible.  Foster City, CA:  IDG Books Worldwide, 2000.

Shapiro, Max S.  Mathematics Encyclopedia.  Garden City:  Doubleday, 1977.

Smith, D. E.  History of Mathematics.  2 vols.  New York:  Dover, 1958.

Sweetser, Doug.  Doing Physics with Quaternions.  n.p., n.d.  Online.  Internet.  12 December 2000.
Available http://world.std.com/~sweetester/quarternions/qindex.html.

Taylor, Edwin F., and John Archibald Wheeler.  Spacetime Physics:  Introduction to Special Relativity.  2nd ed.  New York:  W. H. Freeman, 1996.

Wright, Richard S., Jr., and Sweet, Michael.  OpenGL Super Bible.  2nd ed.  Indianapolis:  Waite Group, 2000.

Wunsch, David A.  Complex Variables with Applications.  2nd ed.  Massachusetts: Addison-Wesley, 1994.

Culbert, Craig.  Cayley-Dickson algebras and loops.  Journal of Generalized Lie Theory and Applications.  Vo1. 1, No. 1, 1-17, 2007.

de Marrais, Robert P. C.  Flying Higher Than a Box-Kite:

Kite-Chain Middens, Sand Mandalas, and Zero-Divisor Patterns in the 2n-ions Beyond the Sedenions. 0207003.pdf

School:.........................Purdue University, West Lafayette

Department:.................Computer Science

Course:........................CS-590 - Visualization of Cayley-Dickson Hypercomplex Numbers

Professor:....................Xavier Tricoche, PhD

Student:........................Michael Tyrone Carter

Project:........................Hypercomplex Package

Computer Algebra:......Maple 13

Date:............................Monday, January 18, 2010

Purpose:......................To gain more knowledge on hypercomlex algebra

Email:..........................Laureice@wideopenwest.com

I received a bachelor of science in biology (minor in chemistry) from Lewis University and a bachelor of science in computer science from Purudue University.  I am now pursuing a PhD. in Mathematical Physics.  Years ago, I received a certificate in computer programming from the College of Automation in Chicago.  In addition, I received a post-bachelor certificate in information systems, with the programming option, at Purdue University.  I have completed several projects.  To name a few, I designed an assembler language computer emulator as two applications--one in C/C++ and the other in C#`.  Here, I coded both the assembler and the emulator. Next, I designed an animated mechanical man in Java3D (using quaternions).  Finally, in two of my courses, I had to design a linear programming package and a grammar analyzer package, both of which were written in C#.  I was exposed to quaternions, octonions, and sedenions at the University of Aalborg, in Denmark, a few years back.  My favorite languages are Microsoft Macro Assembler, C#, Java, Python, C/C++ with OpenGL, and the Maple programming language.  My current Cayley-Dickson package is the first of two projects for a visualization course, which is an independent study that lasted over a year.  It is now completed.