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;   Error, attempting to assign to `u` which is protected     >     > i := 5;   Error, attempting to assign to `i` which is protected     >     > j := 5;   Error, attempting to assign to `j` which is protected     >     > k := 5;   Error, attempting to assign to `k` which is protected
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;   Error, attempting to assign to `i0` which is protected     > i0 := 2;   Error, attempting to assign to `i0` which is protected     > i1 := 2;   Error, attempting to assign to `i1` which is protected     > i7 := 2;   Error, attempting to assign to `i7` which is protected
You must be in octonion mode before you can caculate with octonions.	> i2*i7;   Error, (in *) Trying to multiply an (octonion or sedenion or pathion or chingon or routon or voudon) in quaternion mode.     > 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;   Error, attempting to assign to `O` which is protected     > e0 := 4;   Error, attempting to assign to `e0` which is protected     > e7 := 15;   Error, attempting to assign to `e7` which is protected     > e15 := 23;   Error, attempting to assign to `e15` which is protected
You must be in sedenion mode before you can caculate with the sedenions.	> e3*e7;   Error, (in *) Trying to multiply a (quaternion or sedenion or pathion or chingon or routon or voudon) in octonion mode.     > 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;   Error, attempting to assign to `O` which is protected     > p0 := 4;   Error, attempting to assign to `p0` which is protected     > p7 := 15;   Error, attempting to assign to `p7` which is protected     > p15 := 23;   Error, attempting to assign to `p15` which is protected
You must be in pathion mode before you can caculate with the pathions.	> p3*p7;   Error, (in *) Trying to multiply a (quaternion or sedenion or pathion or chingon or routon or voudon) in octonion mode.     > 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;   Error, attempting to assign to `O` which is protected     > c0 := 4;   Error, attempting to assign to `c0` which is protected     > c7 := 15;   Error, attempting to assign to `c7` which is protected     > c63 := 23;   Error, attempting to assign to `c63` which is protected
You must be in chingon mode before you can caculate with the chingons.	> c3*c7;   Error, (in *) Trying to multiply a (quaternion or sedenion or pathion or chingon or routon or voudon) in octonion mode.     > 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)   >