Application Center - Maplesoft
Our website is currently undergoing maintenance, which may result in occasional errors while browsing. We apologize for any inconvenience this may cause and are working swiftly to restore full functionality. Thank you for your patience.

App Preview:

The CayleyDickson Algebra from 4D to 256D

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

Learn about Maple
Download Application


 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;

 

 

 

/Users/michaelcarter/Desktop/CayleyDickson/CayleyDickson.mla
/Users/michaelcarter/Desktop/CayleyDickson/CayleyDickson.mla (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);

 

[`*`, `+`, `-`, Cadd, Calgebra, Cconjugate, Cdefine, Cdot, Ceval, Cinverse, Cmult, Crand, Cscalar, Csubtract, CtoMatrix, CunitVector, Cvector, Oadd, Oalgebra, Oconjugate, Odefine, OdivLeft, OdivRight,...
[`*`, `+`, `-`, Cadd, Calgebra, Cconjugate, Cdefine, Cdot, Ceval, Cinverse, Cmult, Crand, Cscalar, Csubtract, CtoMatrix, CunitVector, Cvector, Oadd, Oalgebra, Oconjugate, Odefine, OdivLeft, OdivRight,...
[`*`, `+`, `-`, Cadd, Calgebra, Cconjugate, Cdefine, Cdot, Ceval, Cinverse, Cmult, Crand, Cscalar, Csubtract, CtoMatrix, CunitVector, Cvector, Oadd, Oalgebra, Oconjugate, Odefine, OdivLeft, OdivRight,...
[`*`, `+`, `-`, Cadd, Calgebra, Cconjugate, Cdefine, Cdot, Ceval, Cinverse, Cmult, Crand, Cscalar, Csubtract, CtoMatrix, CunitVector, Cvector, Oadd, Oalgebra, Oconjugate, Odefine, OdivLeft, OdivRight,...
[`*`, `+`, `-`, Cadd, Calgebra, Cconjugate, Cdefine, Cdot, Ceval, Cinverse, Cmult, Crand, Cscalar, Csubtract, CtoMatrix, CunitVector, Cvector, Oadd, Oalgebra, Oconjugate, Odefine, OdivLeft, OdivRight,...
[`*`, `+`, `-`, Cadd, Calgebra, Cconjugate, Cdefine, Cdot, Ceval, Cinverse, Cmult, Crand, Cscalar, Csubtract, CtoMatrix, CunitVector, Cvector, Oadd, Oalgebra, Oconjugate, Odefine, OdivLeft, OdivRight,...
[`*`, `+`, `-`, Cadd, Calgebra, Cconjugate, Cdefine, Cdot, Ceval, Cinverse, Cmult, Crand, Cscalar, Csubtract, CtoMatrix, CunitVector, Cvector, Oadd, Oalgebra, Oconjugate, Odefine, OdivLeft, OdivRight,...
[`*`, `+`, `-`, Cadd, Calgebra, Cconjugate, Cdefine, Cdot, Ceval, Cinverse, Cmult, Crand, Cscalar, Csubtract, CtoMatrix, CunitVector, Cvector, Oadd, Oalgebra, Oconjugate, Odefine, OdivLeft, OdivRight,...
[`*`, `+`, `-`, Cadd, Calgebra, Cconjugate, Cdefine, Cdot, Ceval, Cinverse, Cmult, Crand, Cscalar, Csubtract, CtoMatrix, CunitVector, Cvector, Oadd, Oalgebra, Oconjugate, Odefine, OdivLeft, OdivRight,...
[`*`, `+`, `-`, Cadd, Calgebra, Cconjugate, Cdefine, Cdot, Ceval, Cinverse, Cmult, Crand, Cscalar, Csubtract, CtoMatrix, CunitVector, Cvector, Oadd, Oalgebra, Oconjugate, Odefine, OdivLeft, OdivRight,...
(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);

 

quaternion (3)

 

> getHypercomplex(quaternion);

 

quaternion (4)

 

> u*u;

 

> i*i;

 

-1 (5)

 

> j*j;

 

-1 (6)

 

> k*k;

 

-1 (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;

 

i (8)

 

> i*u;

 

i (9)

 

> i*j;

 

k (10)

 

> j*i;

 

`+`(`-`(k)) (11)

 

> j*k;

 

i (12)

 

> k*j;

 

`+`(`-`(i)) (13)

 

> k*i;

 

j (14)

 

> i*k;

 

`+`(`-`(j)) (15)

 

> QisCommutable(2,-5);

 

true (16)

 

> QisCommutable(i,-17);

 

true (17)

 

> QisCommutable(i,j);

 

false (18)

 

> QisCommutable(u,k);

 

true (19)

 

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

 

`+`(4, `*`(5, `*`(i)), `*`(6, `*`(j)), `*`(10, `*`(k))) (20)

 

> qxc := Qconjugate(qx);

 

`+`(`*`(4, `*`(u)), `-`(`*`(5, `*`(i))), `-`(`*`(6, `*`(j))), `-`(`*`(10, `*`(k)))) (21)

 

> qx*qxc;

 

177 (22)

 

> qxc*qx;

 

177 (23)

 

> Qaxial(qx,qxc);

 

0 (24)

 

> QisCommutable(qx, qxc);

 

true (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;

 

 

 

 

 

 

 

1
1
1
1 (26)

 

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

 

 

 

 

 

 

 

u
i
j
k (27)

 

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

 

 

 

 

 

 

 

1
-1
-1
-1 (28)

 

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

 

 

 

 

 

 

 

1
`+`(`-`(i))
`+`(`-`(j))
`+`(`-`(k)) (29)

 

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

 

 

 

 

 

 

 

1
1
1
1 (30)

 

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

 

 

 

 

 

 

 

1
i
j
k (31)

 

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

 

 

 

 

 

 

 

1
-1
-1
-1 (32)

 

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

 

 

 

 

 

 

 

1
`+`(`-`(i))
`+`(`-`(j))
`+`(`-`(k)) (33)

 

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

 

 

 

 

 

 

 

1
1
1
1 (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;

 

`+`(1, `*`(2, `*`(i)), `*`(3, `*`(j)), `*`(4, `*`(k))) (35)

 

> qu := QunitVector(q);

 

`+`(`*`(`/`(2, 29), `*`(`^`(29, `/`(1, 2)), `*`(i))), `*`(`/`(3, 29), `*`(`^`(29, `/`(1, 2)), `*`(j))), `*`(`/`(4, 29), `*`(`^`(29, `/`(1, 2)), `*`(k)))) (36)

 

> qu^0;

 

1 (37)

 

  (38)

 

> qu^1;

 

`+`(`*`(`/`(2, 29), `*`(`^`(29, `/`(1, 2)), `*`(i))), `*`(`/`(3, 29), `*`(`^`(29, `/`(1, 2)), `*`(j))), `*`(`/`(4, 29), `*`(`^`(29, `/`(1, 2)), `*`(k)))) (39)

 

> qu^2;

 

-1 (40)

 

> qu^3;

 

`+`(`-`(`*`(`/`(17081, 45992), `*`(i))), `-`(`*`(`/`(54883, 98518), `*`(j))), `-`(`*`(`/`(17081, 22996), `*`(k)))) (41)

 

> qu^4;

 

1 (42)

 

> qu^5;

 

`+`(`*`(`/`(17081, 45992), `*`(i)), `*`(`/`(54883, 98518), `*`(j)), `*`(`/`(17081, 22996), `*`(k))) (43)

 

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

  

  

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

 

`+`(1, `*`(2, `*`(i)), `*`(3, `*`(j)), `*`(4, `*`(k))) (44)

 

> qu := QunitVector(q);

 

`+`(`*`(`/`(2, 29), `*`(`^`(29, `/`(1, 2)), `*`(i))), `*`(`/`(3, 29), `*`(`^`(29, `/`(1, 2)), `*`(j))), `*`(`/`(4, 29), `*`(`^`(29, `/`(1, 2)), `*`(k)))) (45)

 

> i*qu;

 

`+`(`-`(`*`(`/`(2, 29), `*`(`^`(29, `/`(1, 2))))), `-`(`*`(`/`(4, 29), `*`(`^`(29, `/`(1, 2)), `*`(j)))), `*`(`/`(3, 29), `*`(`^`(29, `/`(1, 2)), `*`(k)))) (46)

 

  (47)

 

> qu*i;

 

`+`(`-`(`*`(`/`(2, 29), `*`(`^`(29, `/`(1, 2))))), `*`(`/`(4, 29), `*`(`^`(29, `/`(1, 2)), `*`(j))), `-`(`*`(`/`(3, 29), `*`(`^`(29, `/`(1, 2)), `*`(k))))) (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;

 

`+`(.5, `*`(.3, `*`(I))) (49)

 

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

 

`+`(.5000000000, `*`(.3000000000, `*`(I))) (50)

 

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

 

`+`(.4999999998, `*`(.3000000000, `*`(I))) (51)

 

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

 

`+`(`-`(`/`(21, 8)), `*`(`/`(5, 8), `*`(I))) (52)

 

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

 

`+`(`-`(2.625000000), `*`(.6250000000, `*`(I))) (53)

 

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

 

`+`(`-`(2.625000000), `*`(.6250000000, `*`(I))) (54)

 

>  

 

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

 

`+`(`/`(1, 2), `*`(`/`(1, 3), `*`(i)), `*`(`/`(1, 4), `*`(j)), `*`(`/`(1, 5), `*`(k))) (55)

 

> evalf(q);

 

`+`(.5000000000, `*`(.3333333333, `*`(i)), `*`(.2500000000, `*`(j)), `*`(.2000000000, `*`(k))) (56)

 

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

 

`+`(.5000000000, `*`(.3333333337, `*`(i)), `*`(.2500000004, `*`(j)), `*`(.2000000000, `*`(k))) (57)

 

>  

 

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

 

`+`(.4999999994, `*`(.3333333337, `*`(i)), `*`(.2500000000, `*`(j)), `*`(.2000000002, `*`(k))) (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);

 

`+`(0.3023480219e-1, `-`(`*`(0.1929880991e-1, `*`(I)))) (59)

 

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

 

`+`(`/`(94, 3109), `-`(`*`(`/`(60, 3109), `*`(i)))) (60)

 

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

 

`+`(`/`(94, 3109), `-`(`*`(`/`(60, 3109), `*`(j)))) (61)

 

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

 

`+`(`/`(94, 3109), `-`(`*`(`/`(60, 3109), `*`(k)))) (62)

 

> QdivLeft(complexi,complexj);

 

`+`(`*`(`/`(2209, 3109), `*`(u)), `*`(`/`(1410, 3109), `*`(i)), `-`(`*`(`/`(1410, 3109), `*`(j))), `-`(`*`(`/`(900, 3109), `*`(k)))) (63)

 

> QdivRight(complexi,complexj);

 

`+`(`*`(`/`(2209, 3109), `*`(u)), `-`(`*`(`/`(1410, 3109), `*`(i))), `*`(`/`(1410, 3109), `*`(j)), `-`(`*`(`/`(900, 3109), `*`(k)))) (64)

 

> Qinverse(complexi)*complexj;

 

`+`(`/`(2209, 3109), `*`(`/`(1410, 3109), `*`(i)), `-`(`*`(`/`(1410, 3109), `*`(j))), `-`(`*`(`/`(900, 3109), `*`(k)))) (65)

 

> complexi*Qinverse(complexj);

 

`+`(`/`(2209, 3109), `-`(`*`(`/`(1410, 3109), `*`(i))), `*`(`/`(1410, 3109), `*`(j)), `-`(`*`(`/`(900, 3109), `*`(k)))) (66)

 

 

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

 

> i*j*k;

 

-1 (67)

 

> (i*j)*k;

 

-1 (68)

 

> i*(j*k);

 

-1 (69)

 

> j*k*i;

 

-1 (70)

 

> k*i*j;

 

-1 (71)

 

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

 

`+`(`-`(44), `-`(`*`(34, `*`(i))), `*`(128, `*`(j)), `*`(180, `*`(k))) (72)

 

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

 

`+`(`-`(44), `-`(`*`(34, `*`(i))), `*`(128, `*`(j)), `*`(180, `*`(k))) (73)

 

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

 

`+`(`-`(160), `-`(`*`(38, `*`(i))), `*`(64, `*`(j)), `*`(144, `*`(k))) (74)

 

> i*j*k;

 

-1 (75)

 

> k*j*i;

 

1 (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);

 

true (77)

 

> type(I,complex);

 

true (78)

 

> type(2+I,complex);

 

true (79)

 

> type(2, quaternion);

 

true (80)

 

> type(I, quaternion);

 

false (81)

 

> type(2+I, quaternion);

 

false (82)

 

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

 

true (83)

 

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

 

false (84)

 

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

 

false (85)

 

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

 

false (86)

 

> type(2*u, quaternion);

 

true (87)

 

> type(2, quaternion);

 

true (88)

 

> type(i, complex);

 

false (89)

 

> type(j, complex);

 

false (90)

 

> type(1-k, complex);

 

false (91)

 

> type(VARIABLE, quaternion);

 

false (92)

 

> type(QtoMatrix(i), quaternion);

 

true (93)

 

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

 

true (94)

 

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

 

`+`(`/`(111941, 32253), `*`(`/`(65572, 91263), `*`(i)), `*`(`/`(14684, 13045), `*`(j)), `*`(`/`(70319, 91753), `*`(k))) (95)

 

> type(variable,quaternion);

 

true (96)

 

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

 

true (97)

 

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

 

true (98)

 

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

 

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

 

`+`(`/`(71, 42), `-`(`*`(`/`(1, 7), `*`(i))), `-`(`*`(`/`(15, 14), `*`(j))), `-`(`*`(`/`(1, 6), `*`(k)))) (99)

 

> qm := QtoMatrix(q);

 

(100)

 

> Qeval(qm);

 

`+`(`*`(`/`(71, 42), `*`(u)), `-`(`*`(`/`(1, 7), `*`(i))), `-`(`*`(`/`(15, 14), `*`(j))), `-`(`*`(`/`(1, 6), `*`(k)))) (101)

 

> Qconjugate(q);

 

`+`(`*`(`/`(71, 42), `*`(u)), `*`(`/`(1, 7), `*`(i)), `*`(`/`(15, 14), `*`(j)), `*`(`/`(1, 6), `*`(k))) (102)

 

> QtoMatrix( Qconjugate(q));

 

(103)

 

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

 

`+`(`*`(`/`(71, 42), `*`(u)), `*`(`/`(1, 7), `*`(i)), `*`(`/`(15, 14), `*`(j)), `*`(`/`(1, 6), `*`(k))) (104)

 

> q;

 

`+`(`/`(71, 42), `-`(`*`(`/`(1, 7), `*`(i))), `-`(`*`(`/`(15, 14), `*`(j))), `-`(`*`(`/`(1, 6), `*`(k)))) (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);

 

`+`(23.45, `*`(72.45, `*`(i)), `*`(98.3, `*`(j)), `*`(.5, `*`(k))) (107)

 

> q := QconvertToFrac(q);

 

`+`(`/`(469, 20), `*`(`/`(1449, 20), `*`(i)), `*`(`/`(983, 10), `*`(j)), `*`(`/`(1, 2), `*`(k))) (108)

 

>  

 

> Qsqrt(q);

 

`+`(`/`(643828, 74895), `*`(`/`(36139, 8576), `*`(i)), `*`(`/`(45174, 7901), `*`(j)), `*`(`/`(529, 18190), `*`(k))) (109)

 

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

 

`+`(23.45000014, `*`(72.44999994, `*`(i)), `*`(98.29999969, `*`(j)), `*`(.4999999993, `*`(k))) (110)

 

> evalf(q);

 

`+`(23.45000000, `*`(72.45000000, `*`(i)), `*`(98.30000000, `*`(j)), `*`(.5000000000, `*`(k))) (111)

 

We can isolate the components for quaternions. 

 

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

 

`+`(`-`(10), `*`(2, `*`(i)), `*`(5, `*`(j)), `*`(4, `*`(k))) (112)

 

> Qscalar(q);

 

-10 (113)

 

> Qvector(q);

 

`+`(`*`(2, `*`(i)), `*`(5, `*`(j)), `*`(4, `*`(k))) (114)

 

> Qicoeff(q);

 

2 (115)

 

> Qjcoeff(q);

 

5 (116)

 

> Qkcoeff(q);

 

4 (117)

 

We can construct proofs with the Qalgebra function. 

 

 

> qx := Qalgebra(0,3);

 

`+`(`*`(w, `*`(u)), `*`(x, `*`(i)), `*`(y, `*`(j)), `*`(z, `*`(k))) (118)

 

> qx*Qinverse(qx);

 

`+`(`/`(`*`(`^`(w, 2)), `*`(`+`(`*`(`^`(w, 2)), `*`(`^`(x, 2)), `*`(`^`(z, 2)), `*`(`^`(y, 2))))), `/`(`*`(`^`(x, 2)), `*`(`+`(`*`(`^`(w, 2)), `*`(`^`(x, 2)), `*`(`^`(z, 2)), `*`(`^`(y, 2))))), `/`(`*... (119)

 

> simplify(%);

 

1 (120)

 

> qx*Qconjugate(qx);

 

`+`(`*`(`^`(w, 2)), `*`(`^`(x, 2)), `*`(`^`(z, 2)), `*`(`^`(y, 2))) (121)

 

> Qconjugate(qx)*qx;

 

`+`(`*`(`^`(w, 2)), `*`(`^`(x, 2)), `*`(`^`(z, 2)), `*`(`^`(y, 2))) (122)

 

> qu := QunitVector(qx);

 

`+`(`/`(`*`(x, `*`(i)), `*`(`^`(`+`(`*`(`^`(x, 2)), `*`(`^`(z, 2)), `*`(`^`(y, 2))), `/`(1, 2)))), `/`(`*`(y, `*`(j)), `*`(`^`(`+`(`*`(`^`(x, 2)), `*`(`^`(z, 2)), `*`(`^`(y, 2))), `/`(1, 2)))), `/`(`*... (123)

 

> qu*qu;

 

`+`(`-`(`/`(`*`(`^`(x, 2)), `*`(`+`(`*`(`^`(x, 2)), `*`(`^`(z, 2)), `*`(`^`(y, 2)))))), `-`(`/`(`*`(`^`(z, 2)), `*`(`+`(`*`(`^`(x, 2)), `*`(`^`(z, 2)), `*`(`^`(y, 2)))))), `-`(`/`(`*`(`^`(y, 2)), `*`(... (124)

 

> simplify(qu*qu);

 

-1 (125)

 

> Qdot(qu,qu);

 

`+`(`/`(`*`(`^`(x, 2)), `*`(`+`(`*`(`^`(x, 2)), `*`(`^`(z, 2)), `*`(`^`(y, 2))))), `/`(`*`(`^`(z, 2)), `*`(`+`(`*`(`^`(x, 2)), `*`(`^`(z, 2)), `*`(`^`(y, 2))))), `/`(`*`(`^`(y, 2)), `*`(`+`(`*`(`^`(x,... (126)

 

> simplify(Qdot(qu,qu));

 

1 (127)

 

> QtoMatrix(qu);

 

(128)

 

> QtoMatrix(qx);

 

(129)

 

> Qeval( QtoMatrix(qx) );

 

`+`(`*`(w, `*`(u)), `*`(x, `*`(i)), `*`(y, `*`(j)), `*`(z, `*`(k))) (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);

 

octonion (131)

 

> i2*i7;

 

`+`(`-`(i5)) (132)

 

> 3*i0;

 

3 (133)

 

> i0;

 

i0 (134)

 

> 5*4*i0;

 

20 (135)

 

> 5*4;

 

20 (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;

 

 

 

i3
`+`(`-`(i3)) (137)

 

> i2*i3; i3*i2;

 

 

 

i1
`+`(`-`(i1)) (138)

 

> i3*i1; i1*i3;

 

 

 

i2
`+`(`-`(i2)) (139)

 

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

 

 

 

 

 

i3
`+`(`-`(i3))
`+`(`-`(i3)) (140)

 

> i4*i5; i5*i4;

 

 

 

i1
`+`(`-`(i1)) (141)

 

 

 

 

 

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

> i0*i0;

 

1 (142)

 

> i1*i1;

 

-1 (143)

 

> i2*i2;

 

-1 (144)

 

> i3*i3;

 

-1 (145)

 

> i4*i4;

 

-1 (146)

 

> i5*i5;

 

-1 (147)

 

> i6*i6;

 

-1 (148)

 

> i7*i7;

 

-1 (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);

 

1 (150)

 

> Oinverse(i2)*i2;

 

1 (151)

 

> OdivLeft(i2,i2);

 

1 (152)

 

> OdivRight(i2,i2);

 

1 (153)

 

> OdivRight(i2,i3);

 

`+`(`-`(i1)) (154)

 

> OdivLeft(i2,i3);

 

`+`(`-`(i1)) (155)

 

> OdivLeft(2,3);

 

`/`(3, 2) (156)

 

> OdivRight(2,3);

 

`/`(2, 3) (157)

 

> 4*Oinverse(5);

 

`/`(4, 5) (158)

 

> Oinverse(5)*4;

 

`/`(4, 5) (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);

 

6 (160)

 

> Odot(i2,i3);

 

-1 (161)

 

> Odot(i2,i2);

 

1 (162)

 

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

 

`+`(`-`(`*`(`/`(37, 48), `*`(i0))), `-`(`*`(`/`(5, 96), `*`(i1))), `-`(`*`(`/`(7, 8), `*`(i2))), `-`(`*`(`/`(11, 96), `*`(i3))), `*`(`/`(61, 96), `*`(i4)), `-`(`*`(`/`(83, 96), `*`(i5))), `*`(`/`(79, ... (163)

 

> Odot(o1,o1);

 

`/`(1753, 512) (164)

 

> evalf( Odot(o1,o1) );

 

3.423828125 (165)

 

> o2 := Orand(1,1);

 

`+`(i0, i1, i2, i3, i4, i5, i6, i7) (166)

 

> Odot(o2,o2);

 

8 (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);

 

`+`(i0, `*`(2, `*`(i1)), `*`(3, `*`(i2)), `*`(4, `*`(i3)), `*`(5, `*`(i4)), `*`(6, `*`(i5)), `*`(7, `*`(i6)), `*`(8, `*`(i7))) (168)

 

> OtoMatrix(o3);

 

(169)

 

> OtoMatrices(o3);

 

(170)

 

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

 

`+`(`*`(8, `*`(i0)), `*`(3, `*`(i1)), `*`(7, `*`(i2)), `*`(4, `*`(i3)), `-`(`*`(3, `*`(i4))), `-`(i5), `*`(3, `*`(i6)), i7) (171)

 

> OtoMatrix(o4);

 

(172)

 

> OtoMatrices(o4);

 

(173)

 

> OtoMatrices( Oconjugate(o4) );

 

(174)

 

Octonions also have a type. 

> type(4,octonion);

 

true (175)

 

> type(i2, octonion);

 

true (176)

 

> type(-3*i7, octonion);

 

true (177)

 

> type(j, octonion);

 

false (178)

 

> type(i8, octonion);

 

false (179)

 

> type(e15, octonion);

 

false (180)

 

> type(I, octonion);

 

false (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;

 

-1 (182)

 

> i1*(i2*i3);

 

-1 (183)

 

> (i1*i2)*i3;

 

-1 (184)

 

> i1*(i4*i7);

 

`+`(`-`(i2)) (185)

 

> (i1*i4)*i7;

 

i2 (186)

 

> i1*i4*i7;

 

i2 (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);

 

`+`(`*`(`/`(9778, 6157), `*`(i0)), `-`(`*`(`/`(3610, 6157), `*`(i1))), `-`(`*`(`/`(8466, 6157), `*`(i2))), `*`(`/`(7710, 6157), `*`(i3)), `*`(`/`(76, 47), `*`(i4)), `-`(`*`(`/`(4099, 6157), `*`(i5))),... (188)

 

> Oscalar(ox);

 

`/`(9778, 6157) (189)

 

> Ovector(ox);

 

`+`(`-`(`*`(`/`(3610, 6157), `*`(i1))), `-`(`*`(`/`(8466, 6157), `*`(i2))), `*`(`/`(7710, 6157), `*`(i3)), `*`(`/`(76, 47), `*`(i4)), `-`(`*`(`/`(4099, 6157), `*`(i5))), `*`(`/`(307, 6157), `*`(i6)), ... (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);

 

`+`(`*`(w1, `*`(i0)), `*`(x1, `*`(i1)), `*`(y1, `*`(i2)), `*`(z1, `*`(i3)), `*`(w2, `*`(i4)), `*`(x2, `*`(i5)), `*`(y2, `*`(i6)), `*`(z2, `*`(i7))) (191)

 

> ox*Oinverse(ox);

 

`+`(`/`(`*`(`^`(w1, 2)), `*`(`+`(`*`(`^`(w1, 2)), `*`(`^`(x1, 2)), `*`(`^`(z1, 2)), `*`(`^`(y1, 2)), `*`(`^`(w2, 2)), `*`(`^`(x2, 2)), `*`(`^`(z2, 2)), `*`(`^`(y2, 2))))), `/`(`*`(`^`(x1, 2)), `*`(`+`...
`+`(`/`(`*`(`^`(w1, 2)), `*`(`+`(`*`(`^`(w1, 2)), `*`(`^`(x1, 2)), `*`(`^`(z1, 2)), `*`(`^`(y1, 2)), `*`(`^`(w2, 2)), `*`(`^`(x2, 2)), `*`(`^`(z2, 2)), `*`(`^`(y2, 2))))), `/`(`*`(`^`(x1, 2)), `*`(`+`...
`+`(`/`(`*`(`^`(w1, 2)), `*`(`+`(`*`(`^`(w1, 2)), `*`(`^`(x1, 2)), `*`(`^`(z1, 2)), `*`(`^`(y1, 2)), `*`(`^`(w2, 2)), `*`(`^`(x2, 2)), `*`(`^`(z2, 2)), `*`(`^`(y2, 2))))), `/`(`*`(`^`(x1, 2)), `*`(`+`...
`+`(`/`(`*`(`^`(w1, 2)), `*`(`+`(`*`(`^`(w1, 2)), `*`(`^`(x1, 2)), `*`(`^`(z1, 2)), `*`(`^`(y1, 2)), `*`(`^`(w2, 2)), `*`(`^`(x2, 2)), `*`(`^`(z2, 2)), `*`(`^`(y2, 2))))), `/`(`*`(`^`(x1, 2)), `*`(`+`...
(192)

 

> simplify(%);

 

1 (193)

 

> ox*Oconjugate(ox);

 

`+`(`*`(`^`(w1, 2)), `*`(`^`(x1, 2)), `*`(`^`(z1, 2)), `*`(`^`(y1, 2)), `*`(`^`(w2, 2)), `*`(`^`(x2, 2)), `*`(`^`(z2, 2)), `*`(`^`(y2, 2))) (194)

 

> Oconjugate(ox)*ox;

 

`+`(`*`(`^`(w1, 2)), `*`(`^`(x1, 2)), `*`(`^`(z1, 2)), `*`(`^`(y1, 2)), `*`(`^`(w2, 2)), `*`(`^`(x2, 2)), `*`(`^`(z2, 2)), `*`(`^`(y2, 2))) (195)

 

> ou := OunitVector(ox);

 

`+`(`/`(`*`(x1, `*`(i1)), `*`(`^`(`+`(`*`(`^`(x1, 2)), `*`(`^`(z1, 2)), `*`(`^`(y1, 2)), `*`(`^`(w2, 2)), `*`(`^`(x2, 2)), `*`(`^`(z2, 2)), `*`(`^`(y2, 2))), `/`(1, 2)))), `/`(`*`(y1, `*`(i2)), `*`(`^...
`+`(`/`(`*`(x1, `*`(i1)), `*`(`^`(`+`(`*`(`^`(x1, 2)), `*`(`^`(z1, 2)), `*`(`^`(y1, 2)), `*`(`^`(w2, 2)), `*`(`^`(x2, 2)), `*`(`^`(z2, 2)), `*`(`^`(y2, 2))), `/`(1, 2)))), `/`(`*`(y1, `*`(i2)), `*`(`^...
`+`(`/`(`*`(x1, `*`(i1)), `*`(`^`(`+`(`*`(`^`(x1, 2)), `*`(`^`(z1, 2)), `*`(`^`(y1, 2)), `*`(`^`(w2, 2)), `*`(`^`(x2, 2)), `*`(`^`(z2, 2)), `*`(`^`(y2, 2))), `/`(1, 2)))), `/`(`*`(y1, `*`(i2)), `*`(`^...
`+`(`/`(`*`(x1, `*`(i1)), `*`(`^`(`+`(`*`(`^`(x1, 2)), `*`(`^`(z1, 2)), `*`(`^`(y1, 2)), `*`(`^`(w2, 2)), `*`(`^`(x2, 2)), `*`(`^`(z2, 2)), `*`(`^`(y2, 2))), `/`(1, 2)))), `/`(`*`(y1, `*`(i2)), `*`(`^...
(196)

 

> ou*ou;

 

`+`(`-`(`/`(`*`(`^`(x1, 2)), `*`(`+`(`*`(`^`(x1, 2)), `*`(`^`(z1, 2)), `*`(`^`(y1, 2)), `*`(`^`(w2, 2)), `*`(`^`(x2, 2)), `*`(`^`(z2, 2)), `*`(`^`(y2, 2)))))), `-`(`/`(`*`(`^`(z1, 2)), `*`(`+`(`*`(`^`...
`+`(`-`(`/`(`*`(`^`(x1, 2)), `*`(`+`(`*`(`^`(x1, 2)), `*`(`^`(z1, 2)), `*`(`^`(y1, 2)), `*`(`^`(w2, 2)), `*`(`^`(x2, 2)), `*`(`^`(z2, 2)), `*`(`^`(y2, 2)))))), `-`(`/`(`*`(`^`(z1, 2)), `*`(`+`(`*`(`^`...
`+`(`-`(`/`(`*`(`^`(x1, 2)), `*`(`+`(`*`(`^`(x1, 2)), `*`(`^`(z1, 2)), `*`(`^`(y1, 2)), `*`(`^`(w2, 2)), `*`(`^`(x2, 2)), `*`(`^`(z2, 2)), `*`(`^`(y2, 2)))))), `-`(`/`(`*`(`^`(z1, 2)), `*`(`+`(`*`(`^`...
`+`(`-`(`/`(`*`(`^`(x1, 2)), `*`(`+`(`*`(`^`(x1, 2)), `*`(`^`(z1, 2)), `*`(`^`(y1, 2)), `*`(`^`(w2, 2)), `*`(`^`(x2, 2)), `*`(`^`(z2, 2)), `*`(`^`(y2, 2)))))), `-`(`/`(`*`(`^`(z1, 2)), `*`(`+`(`*`(`^`...
(197)

 

> simplify(%);

 

-1 (198)

 

> Odot(ou,ou);

 

`+`(`/`(`*`(`^`(x1, 2)), `*`(`+`(`*`(`^`(x1, 2)), `*`(`^`(z1, 2)), `*`(`^`(y1, 2)), `*`(`^`(w2, 2)), `*`(`^`(x2, 2)), `*`(`^`(z2, 2)), `*`(`^`(y2, 2))))), `/`(`*`(`^`(z1, 2)), `*`(`+`(`*`(`^`(x1, 2)),...
`+`(`/`(`*`(`^`(x1, 2)), `*`(`+`(`*`(`^`(x1, 2)), `*`(`^`(z1, 2)), `*`(`^`(y1, 2)), `*`(`^`(w2, 2)), `*`(`^`(x2, 2)), `*`(`^`(z2, 2)), `*`(`^`(y2, 2))))), `/`(`*`(`^`(z1, 2)), `*`(`+`(`*`(`^`(x1, 2)),...
`+`(`/`(`*`(`^`(x1, 2)), `*`(`+`(`*`(`^`(x1, 2)), `*`(`^`(z1, 2)), `*`(`^`(y1, 2)), `*`(`^`(w2, 2)), `*`(`^`(x2, 2)), `*`(`^`(z2, 2)), `*`(`^`(y2, 2))))), `/`(`*`(`^`(z1, 2)), `*`(`+`(`*`(`^`(x1, 2)),...
`+`(`/`(`*`(`^`(x1, 2)), `*`(`+`(`*`(`^`(x1, 2)), `*`(`^`(z1, 2)), `*`(`^`(y1, 2)), `*`(`^`(w2, 2)), `*`(`^`(x2, 2)), `*`(`^`(z2, 2)), `*`(`^`(y2, 2))))), `/`(`*`(`^`(z1, 2)), `*`(`+`(`*`(`^`(x1, 2)),...
(199)

 

> simplify(%);

 

1 (200)

 

> OtoMatrix(ou);

 








(201)

 

> OtoMatrix(ox);

 

(202)

 

> Oeval( OtoMatrix(ox) );

 

`+`(`*`(w1, `*`(i0)), `*`(x1, `*`(i1)), `*`(y1, `*`(i2)), `*`(z1, `*`(i3)), `*`(w2, `*`(i4)), `*`(x2, `*`(i5)), `*`(y2, `*`(i6)), `*`(z2, `*`(i7))) (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);

 

sedenion (204)

 

> e3*e7;

 

`+`(`-`(e4)) (205)

 

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

 

 

 

e4
e4 (206)

 

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

 

 

 

`+`(`-`(e4))
`+`(`-`(e4)) (207)

 

> e1*e2*e3;

 

-1 (208)

 

> e3*e2*e1;

 

1 (209)

 

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

 

`+`(`-`(`*`(3, `*`(e0))), `-`(`*`(3, `*`(e1))), `-`(e2), `-`(`*`(3, `*`(e3))), `*`(2, `*`(e4)), `*`(4, `*`(e5)), `-`(`*`(3, `*`(e6))), `-`(`*`(5, `*`(e7))), `-`(`*`(5, `*`(e8))), `-`(`*`(3, `*`(e9))),... (210)

 

> s1 + (1/5)*e15;

 

`+`(`-`(3), `-`(`*`(3, `*`(e1))), `-`(e2), `-`(`*`(3, `*`(e3))), `*`(2, `*`(e4)), `*`(4, `*`(e5)), `-`(`*`(3, `*`(e6))), `-`(`*`(5, `*`(e7))), `-`(`*`(5, `*`(e8))), `-`(`*`(3, `*`(e9))), `-`(e10), `-`... (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;

 

5 (212)

 

> e1*e1;

 

-1 (213)

 

> e2*e2;

 

-1 (214)

 

> e3*e3;

 

-1 (215)

 

> e4*e4;

 

-1 (216)

 

> e5*e5;

 

-1 (217)

 

> e6*e6;

 

-1 (218)

 

> e7*e7;

 

-1 (219)

 

> e8*e8;

 

-1 (220)

 

> e9*e9;

 

-1 (221)

 

> e10*e10;

 

-1 (222)

 

> e11*e11;

 

-1 (223)

 

> e12*e12;

 

-1 (224)

 

> e13*e13;

 

-1 (225)

 

> e14*e14;

 

-1 (226)

 

> e15*e15;

 

-1 (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);

 

`+`(`-`(e3), e6, e9, `-`(e12)) (228)

 

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

 

0 (229)

 

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

 

0 (230)

 

> a := e3 + e10;

 

`+`(e3, e10) (231)

 

> b := e6 - e15;

 

`+`(e6, `-`(e15)) (232)

 

> evalb(a = 0);

 

false (233)

 

> evalb(b = 0);

 

false (234)

 

> evalb(a*b = 0);

 

true (235)

 

Here, we are testing the dot product function. 

 

The dot product has a longer processing time. 

 

> sx := Srand(1,1);

 

`+`(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15) (236)

 

> sconj := Sconjugate(sx);

 

`+`(e0, `-`(e1), `-`(e2), `-`(e3), `-`(e4), `-`(e5), `-`(e6), `-`(e7), `-`(e8), `-`(e9), `-`(e10), `-`(e11), `-`(e12), `-`(e13), `-`(e14), `-`(e15)) (237)

 

> Sdot(sx,sx);

 

16 (238)

 

> Sdot(sconj,sconj);

 

16 (239)

 

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

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

 

`+`(`*`(`/`(17, 18), `*`(e0)), `*`(`/`(10, 27), `*`(e1)), `*`(`/`(79, 54), `*`(e2)), `-`(`*`(`/`(1, 27), `*`(e3))), `-`(`*`(`/`(49, 27), `*`(e4))), `*`(`/`(7, 6), `*`(e5)), `-`(`*`(`/`(17, 27), `*`(e6...
`+`(`*`(`/`(17, 18), `*`(e0)), `*`(`/`(10, 27), `*`(e1)), `*`(`/`(79, 54), `*`(e2)), `-`(`*`(`/`(1, 27), `*`(e3))), `-`(`*`(`/`(49, 27), `*`(e4))), `*`(`/`(7, 6), `*`(e5)), `-`(`*`(`/`(17, 27), `*`(e6...
(240)

 

> Sscalar(sx);

 

`/`(17, 18) (241)

 

> Svector(sx);

 

`+`(`*`(`/`(10, 27), `*`(e1)), `*`(`/`(79, 54), `*`(e2)), `-`(`*`(`/`(1, 27), `*`(e3))), `-`(`*`(`/`(49, 27), `*`(e4))), `*`(`/`(7, 6), `*`(e5)), `-`(`*`(`/`(17, 27), `*`(e6))), `-`(`*`(`/`(7, 9), `*`...
`+`(`*`(`/`(10, 27), `*`(e1)), `*`(`/`(79, 54), `*`(e2)), `-`(`*`(`/`(1, 27), `*`(e3))), `-`(`*`(`/`(49, 27), `*`(e4))), `*`(`/`(7, 6), `*`(e5)), `-`(`*`(`/`(17, 27), `*`(e6))), `-`(`*`(`/`(7, 9), `*`...
(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);

 

`+`(`-`(`*`(`/`(52, 71), `*`(e0))), `*`(`/`(79, 71), `*`(e1)), `-`(`*`(`/`(99, 71), `*`(e2))), `*`(`/`(9, 71), `*`(e3)), `-`(`*`(`/`(96, 71), `*`(e4))), `*`(`/`(74, 71), `*`(e5)), `*`(`/`(48, 71), `*`...
`+`(`-`(`*`(`/`(52, 71), `*`(e0))), `*`(`/`(79, 71), `*`(e1)), `-`(`*`(`/`(99, 71), `*`(e2))), `*`(`/`(9, 71), `*`(e3)), `-`(`*`(`/`(96, 71), `*`(e4))), `*`(`/`(74, 71), `*`(e5)), `*`(`/`(48, 71), `*`...
(243)

 

> StoMatrix(sx);

 




(244)

 

> sx := Srand(1,1);

 

`+`(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15) (245)

 

> StoMatrix(sx);

 

(246)

 

Yes, the sedenion has a type as well. 

> sx := Srand(1,1);

 

`+`(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15) (247)

 

> type(sx,sedenion);

 

true (248)

 

> type(5,sedenion);

 

true (249)

 

> type(5*e0, sedenion);

 

true (250)

 

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

 

true (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);

 

`+`(`*`(w1, `*`(e0)), `*`(x1, `*`(e1)), `*`(y1, `*`(e2)), `*`(z1, `*`(e3))) (252)

 

> sx*Sinverse(sx);

 

`+`(`/`(`*`(`^`(w1, 2)), `*`(`+`(`*`(`^`(w1, 2)), `*`(`^`(x1, 2)), `*`(`^`(z1, 2)), `*`(`^`(y1, 2))))), `/`(`*`(`^`(x1, 2)), `*`(`+`(`*`(`^`(w1, 2)), `*`(`^`(x1, 2)), `*`(`^`(z1, 2)), `*`(`^`(y1, 2)))... (253)

 

> simplify(%);

 

1 (254)

 

> sx*Sconjugate(sx);

 

`+`(`*`(`^`(w1, 2)), `*`(`^`(x1, 2)), `*`(`^`(z1, 2)), `*`(`^`(y1, 2))) (255)

 

> Sconjugate(sx)*sx;

 

`+`(`*`(`^`(w1, 2)), `*`(`^`(x1, 2)), `*`(`^`(z1, 2)), `*`(`^`(y1, 2))) (256)

 

> su := SunitVector(sx);

 

`+`(`/`(`*`(x1, `*`(e1)), `*`(`^`(`+`(`*`(`^`(x1, 2)), `*`(`^`(z1, 2)), `*`(`^`(y1, 2))), `/`(1, 2)))), `/`(`*`(y1, `*`(e2)), `*`(`^`(`+`(`*`(`^`(x1, 2)), `*`(`^`(z1, 2)), `*`(`^`(y1, 2))), `/`(1, 2))... (257)

 

> su*su;

 

`+`(`-`(`/`(`*`(`^`(x1, 2)), `*`(`+`(`*`(`^`(x1, 2)), `*`(`^`(z1, 2)), `*`(`^`(y1, 2)))))), `-`(`/`(`*`(`^`(z1, 2)), `*`(`+`(`*`(`^`(x1, 2)), `*`(`^`(z1, 2)), `*`(`^`(y1, 2)))))), `-`(`/`(`*`(`^`(y1, ... (258)

 

> simplify(%);

 

-1 (259)

 

> Sdot(su,su);

 

`+`(`/`(`*`(`^`(x1, 2)), `*`(`+`(`*`(`^`(x1, 2)), `*`(`^`(z1, 2)), `*`(`^`(y1, 2))))), `/`(`*`(`^`(z1, 2)), `*`(`+`(`*`(`^`(x1, 2)), `*`(`^`(z1, 2)), `*`(`^`(y1, 2))))), `/`(`*`(`^`(y1, 2)), `*`(`+`(`... (260)

 

> simplify(%);

 

1 (261)

 

> StoMatrix(su);

 


(262)

 

> StoMatrix(sx);

 

(263)

 

> Seval( StoMatrix(sx) );

 

`+`(`*`(w1, `*`(e0)), `*`(x1, `*`(e1)), `*`(y1, `*`(e2)), `*`(z1, `*`(e3))) (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);

 

pathion (265)

 

> p3*p7;

 

`+`(`-`(p4)) (266)

 

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

 

 

 

p4
p4 (267)

 

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

 

 

 

`+`(`-`(p4))
`+`(`-`(p4)) (268)

 

> p1*p2*p3;

 

-1 (269)

 

> p3*p2*p1;

 

1 (270)

 

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

 

`+`(`*`(2, `*`(p0)), `*`(2, `*`(p1)), `*`(`/`(3, 2), `*`(p2)), `*`(2, `*`(p3)), p5, `-`(`*`(2, `*`(p6))), p7, p8, `-`(`*`(`/`(1, 2), `*`(p9))), `*`(`/`(1, 2), `*`(p10)), `*`(`/`(5, 2), `*`(p11)), `*`(...
`+`(`*`(2, `*`(p0)), `*`(2, `*`(p1)), `*`(`/`(3, 2), `*`(p2)), `*`(2, `*`(p3)), p5, `-`(`*`(2, `*`(p6))), p7, p8, `-`(`*`(`/`(1, 2), `*`(p9))), `*`(`/`(1, 2), `*`(p10)), `*`(`/`(5, 2), `*`(p11)), `*`(...
(271)

 

> px + (1/5)*p15;

 

`+`(2, `*`(2, `*`(p1)), `*`(`/`(3, 2), `*`(p2)), `*`(2, `*`(p3)), p5, `-`(`*`(2, `*`(p6))), p7, p8, `-`(`*`(`/`(1, 2), `*`(p9))), `*`(`/`(1, 2), `*`(p10)), `*`(`/`(5, 2), `*`(p11)), `*`(`/`(1, 2), `*`...
`+`(2, `*`(2, `*`(p1)), `*`(`/`(3, 2), `*`(p2)), `*`(2, `*`(p3)), p5, `-`(`*`(2, `*`(p6))), p7, p8, `-`(`*`(`/`(1, 2), `*`(p9))), `*`(`/`(1, 2), `*`(p10)), `*`(`/`(5, 2), `*`(p11)), `*`(`/`(1, 2), `*`...
(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;

 

1 (273)

 

> p1*p1;

 

-1 (274)

 

> p2*p2;

 

-1 (275)

 

> p3*p3;

 

-1 (276)

 

> p4*p4;

 

-1 (277)

 

> p5*p5;

 

-1 (278)

 

> p6*p6;

 

-1 (279)

 

> p7*p7;

 

-1 (280)

 

> p8*p8;

 

-1 (281)

 

> p12*p12;

 

-1 (282)

 

> p15*p15;

 

-1 (283)

 

> p19*p19;

 

-1 (284)

 

> p21*p21;

 

-1 (285)

 

> p25*p25;

 

-1 (286)

 

> p27*p27;

 

-1 (287)

 

> p31*p31;

 

-1 (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);

 

`+`(`-`(p3), p6, p9, `-`(p12)) (289)

 

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

 

0 (290)

 

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

 

0 (291)

 

> a := p3 + p10;

 

`+`(p3, p10) (292)

 

> b := p6 - p15;

 

`+`(p6, `-`(p15)) (293)

 

> evalb(a = 0);

 

false (294)

 

> evalb(b = 0);

 

false (295)

 

> evalb(a*b = 0);

 

true (296)

 

Here, we are testing the dot product function. 

 

The dot product has a longer processing time. 

 

> px := Prand(1,1);

 

`+`(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31)
`+`(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31)
(297)

 

> pconj := Pconjugate(px);

 

`+`(p0, `-`(p1), `-`(p2), `-`(p3), `-`(p4), `-`(p5), `-`(p6), `-`(p7), `-`(p8), `-`(p9), `-`(p10), `-`(p11), `-`(p12), `-`(p13), `-`(p14), `-`(p15), `-`(p16), `-`(p17), `-`(p18), `-`(p19), `-`(p20), `...
`+`(p0, `-`(p1), `-`(p2), `-`(p3), `-`(p4), `-`(p5), `-`(p6), `-`(p7), `-`(p8), `-`(p9), `-`(p10), `-`(p11), `-`(p12), `-`(p13), `-`(p14), `-`(p15), `-`(p16), `-`(p17), `-`(p18), `-`(p19), `-`(p20), `...
(298)

 

> Pdot(px,px);

 

32 (299)

 

> Pdot(pconj,pconj);

 

32 (300)

 

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

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

 

`+`(`*`(`/`(77, 86), `*`(p0)), `-`(`*`(`/`(37, 43), `*`(p1))), `*`(`/`(21, 43), `*`(p2)), `*`(`/`(1, 86), `*`(p3)), `*`(`/`(85, 86), `*`(p4)), `*`(`/`(37, 43), `*`(p5)), `*`(`/`(13, 43), `*`(p6)), `-`...
`+`(`*`(`/`(77, 86), `*`(p0)), `-`(`*`(`/`(37, 43), `*`(p1))), `*`(`/`(21, 43), `*`(p2)), `*`(`/`(1, 86), `*`(p3)), `*`(`/`(85, 86), `*`(p4)), `*`(`/`(37, 43), `*`(p5)), `*`(`/`(13, 43), `*`(p6)), `-`...
`+`(`*`(`/`(77, 86), `*`(p0)), `-`(`*`(`/`(37, 43), `*`(p1))), `*`(`/`(21, 43), `*`(p2)), `*`(`/`(1, 86), `*`(p3)), `*`(`/`(85, 86), `*`(p4)), `*`(`/`(37, 43), `*`(p5)), `*`(`/`(13, 43), `*`(p6)), `-`...
(301)

 

> Pscalar(px);

 

`/`(77, 86) (302)

 

> Pvector(px);

 

`+`(`-`(`*`(`/`(37, 43), `*`(p1))), `*`(`/`(21, 43), `*`(p2)), `*`(`/`(1, 86), `*`(p3)), `*`(`/`(85, 86), `*`(p4)), `*`(`/`(37, 43), `*`(p5)), `*`(`/`(13, 43), `*`(p6)), `-`(`*`(`/`(42, 43), `*`(p7)))...
`+`(`-`(`*`(`/`(37, 43), `*`(p1))), `*`(`/`(21, 43), `*`(p2)), `*`(`/`(1, 86), `*`(p3)), `*`(`/`(85, 86), `*`(p4)), `*`(`/`(37, 43), `*`(p5)), `*`(`/`(13, 43), `*`(p6)), `-`(`*`(`/`(42, 43), `*`(p7)))...
`+`(`-`(`*`(`/`(37, 43), `*`(p1))), `*`(`/`(21, 43), `*`(p2)), `*`(`/`(1, 86), `*`(p3)), `*`(`/`(85, 86), `*`(p4)), `*`(`/`(37, 43), `*`(p5)), `*`(`/`(13, 43), `*`(p6)), `-`(`*`(`/`(42, 43), `*`(p7)))...
(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);

 

`+`(`-`(`*`(`/`(29, 4), `*`(p0))), `-`(`*`(`/`(31, 4), `*`(p1))), `-`(`*`(`/`(5, 12), `*`(p2))), `-`(`*`(`/`(5, 3), `*`(p3))), `-`(`*`(`/`(17, 12), `*`(p4))), `-`(`*`(`/`(37, 6), `*`(p5))), `-`(`*`(`/...
`+`(`-`(`*`(`/`(29, 4), `*`(p0))), `-`(`*`(`/`(31, 4), `*`(p1))), `-`(`*`(`/`(5, 12), `*`(p2))), `-`(`*`(`/`(5, 3), `*`(p3))), `-`(`*`(`/`(17, 12), `*`(p4))), `-`(`*`(`/`(37, 6), `*`(p5))), `-`(`*`(`/...
`+`(`-`(`*`(`/`(29, 4), `*`(p0))), `-`(`*`(`/`(31, 4), `*`(p1))), `-`(`*`(`/`(5, 12), `*`(p2))), `-`(`*`(`/`(5, 3), `*`(p3))), `-`(`*`(`/`(17, 12), `*`(p4))), `-`(`*`(`/`(37, 6), `*`(p5))), `-`(`*`(`/...
(304)

 

> PtoMatrix(p3);

 

(305)

 

> px := Prand(1,1);

 

`+`(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31)
`+`(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31)
(306)

 

> PtoMatrix(px);

 




(307)

 

The pathions have a type. 

> px := Prand(1,1);

 

`+`(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31)
`+`(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31)
(308)

 

> type(px,pathion);

 

true (309)

 

> type(5,pathion);

 

true (310)

 

> type(5*p0, pathion);

 

true (311)

 

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

 

true (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);

 

`+`(`*`(w1, `*`(p0)), `*`(x1, `*`(p1)), `*`(y1, `*`(p2)), `*`(z1, `*`(p3))) (313)

 

> px*Pinverse(px);

 

`+`(`/`(`*`(`^`(w1, 2)), `*`(`+`(`*`(`^`(w1, 2)), `*`(`^`(x1, 2)), `*`(`^`(z1, 2)), `*`(`^`(y1, 2))))), `/`(`*`(`^`(x1, 2)), `*`(`+`(`*`(`^`(w1, 2)), `*`(`^`(x1, 2)), `*`(`^`(z1, 2)), `*`(`^`(y1, 2)))... (314)

 

> simplify(%);

 

1 (315)

 

> px*Pconjugate(px);

 

`+`(`*`(`^`(w1, 2)), `*`(`^`(x1, 2)), `*`(`^`(z1, 2)), `*`(`^`(y1, 2))) (316)

 

> Pconjugate(px)*px;

 

`+`(`*`(`^`(w1, 2)), `*`(`^`(x1, 2)), `*`(`^`(z1, 2)), `*`(`^`(y1, 2))) (317)

 

> pu := PunitVector(px);

 

`+`(`/`(`*`(x1, `*`(p1)), `*`(`^`(`+`(`*`(`^`(x1, 2)), `*`(`^`(z1, 2)), `*`(`^`(y1, 2))), `/`(1, 2)))), `/`(`*`(y1, `*`(p2)), `*`(`^`(`+`(`*`(`^`(x1, 2)), `*`(`^`(z1, 2)), `*`(`^`(y1, 2))), `/`(1, 2))... (318)

 

> pu*pu;

 

`+`(`-`(`/`(`*`(`^`(x1, 2)), `*`(`+`(`*`(`^`(x1, 2)), `*`(`^`(z1, 2)), `*`(`^`(y1, 2)))))), `-`(`/`(`*`(`^`(z1, 2)), `*`(`+`(`*`(`^`(x1, 2)), `*`(`^`(z1, 2)), `*`(`^`(y1, 2)))))), `-`(`/`(`*`(`^`(y1, ... (319)

 

> simplify(%);

 

-1 (320)

 

> Pdot(pu,pu);

 

`+`(`/`(`*`(`^`(x1, 2)), `*`(`+`(`*`(`^`(x1, 2)), `*`(`^`(z1, 2)), `*`(`^`(y1, 2))))), `/`(`*`(`^`(z1, 2)), `*`(`+`(`*`(`^`(x1, 2)), `*`(`^`(z1, 2)), `*`(`^`(y1, 2))))), `/`(`*`(`^`(y1, 2)), `*`(`+`(`... (321)

 

> simplify(Pdot(pu,pu));

 

1 (322)

 

> PtoMatrix(pu);

 


(323)

 

> PtoMatrix(px);

 

(324)

 

> Peval( PtoMatrix(px) );

 

`+`(`*`(w1, `*`(p0)), `*`(x1, `*`(p1)), `*`(y1, `*`(p2)), `*`(z1, `*`(p3))) (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);

 

chingon (326)

 

> c3*c7;

 

`+`(`-`(c4)) (327)

 

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

 

 

 

c4
c4 (328)

 

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

 

 

 

`+`(`-`(c4))
`+`(`-`(c4)) (329)

 

> c1*c2*c3;

 

-1 (330)

 

> c3*c2*c1;

 

1 (331)

 

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

 

`+`(`*`(9, `*`(c7)), `-`(`*`(3, `*`(c52))), `-`(`*`(5, `*`(c42))), c8, `*`(4, `*`(c17)), `-`(`*`(2, `*`(c38))), c43, `*`(11, `*`(c30)), `-`(c33), `-`(`*`(2, `*`(c5))), `-`(c31), `*`(4, `*`(c19)), `-`(...
`+`(`*`(9, `*`(c7)), `-`(`*`(3, `*`(c52))), `-`(`*`(5, `*`(c42))), c8, `*`(4, `*`(c17)), `-`(`*`(2, `*`(c38))), c43, `*`(11, `*`(c30)), `-`(c33), `-`(`*`(2, `*`(c5))), `-`(c31), `*`(4, `*`(c19)), `-`(...
(332)

 

> cx + (1/5)*c15;

 

`+`(`-`(`*`(5, `*`(c1))), `-`(`*`(2, `*`(c5))), `*`(9, `*`(c7)), c8, `-`(`*`(2, `*`(c14))), `*`(`/`(1, 5), `*`(c15)), `*`(4, `*`(c17)), `*`(4, `*`(c19)), `-`(`*`(2, `*`(c20))), `-`(`*`(5, `*`(c21))), ...
`+`(`-`(`*`(5, `*`(c1))), `-`(`*`(2, `*`(c5))), `*`(9, `*`(c7)), c8, `-`(`*`(2, `*`(c14))), `*`(`/`(1, 5), `*`(c15)), `*`(4, `*`(c17)), `*`(4, `*`(c19)), `-`(`*`(2, `*`(c20))), `-`(`*`(5, `*`(c21))), ...
(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;

 

1 (334)

 

> c1*c1;

 

-1 (335)

 

> c2*c2;

 

-1 (336)

 

> c3*c3;

 

-1 (337)

 

> c4*c4;

 

-1 (338)

 

> c5*c5;

 

-1 (339)

 

> c6*c6;

 

-1 (340)

 

> c7*c7;

 

-1 (341)

 

> c8*c8;

 

-1 (342)

 

> c15*c15;

 

-1 (343)

 

> c19*c19;

 

-1 (344)

 

> c30*c30;

 

-1 (345)

 

> c45*c45;

 

-1 (346)

 

> c50*c50;

 

-1 (347)

 

> c60*c60;

 

-1 (348)

 

> c63*c63;

 

-1 (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);

 

`+`(`-`(c3), c6, c9, `-`(c12)) (350)

 

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

 

0 (351)

 

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

 

0 (352)

 

> a := c3 + c10;

 

`+`(c3, c10) (353)

 

> b := c6 - c15;

 

`+`(c6, `-`(c15)) (354)

 

> evalb(a = 0);

 

false (355)

 

> evalb(b = 0);

 

false (356)

 

> evalb(a*b = 0);

 

true (357)

 

Here, we are testing the dot product function. 

 

The dot product has a longer processing time. 

 

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

 

`+`(c8, `*`(2, `*`(c49)), c55, c0, c61, c1, c43, c48, c3) (358)

 

> cconj := Cconjugate(cx);

 

`+`(c0, `-`(c1), `-`(c3), `-`(c8), `-`(c43), `-`(c48), `-`(`*`(2, `*`(c49))), `-`(c55), `-`(c61)) (359)

 

> Cdot(cx,cx);

 

12 (360)

 

> Cdot(cconj,cconj);

 

12 (361)

 

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

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

 

`+`(`*`(`/`(65, 24), `*`(c0)), `*`(`/`(7, 3), `*`(c2)), `-`(`*`(`/`(11, 8), `*`(c3))), `*`(`/`(23, 12), `*`(c4)), `-`(`*`(`/`(115, 24), `*`(c6))), `*`(`/`(41, 24), `*`(c8)), `*`(`/`(41, 12), `*`(c11))...
`+`(`*`(`/`(65, 24), `*`(c0)), `*`(`/`(7, 3), `*`(c2)), `-`(`*`(`/`(11, 8), `*`(c3))), `*`(`/`(23, 12), `*`(c4)), `-`(`*`(`/`(115, 24), `*`(c6))), `*`(`/`(41, 24), `*`(c8)), `*`(`/`(41, 12), `*`(c11))...
`+`(`*`(`/`(65, 24), `*`(c0)), `*`(`/`(7, 3), `*`(c2)), `-`(`*`(`/`(11, 8), `*`(c3))), `*`(`/`(23, 12), `*`(c4)), `-`(`*`(`/`(115, 24), `*`(c6))), `*`(`/`(41, 24), `*`(c8)), `*`(`/`(41, 12), `*`(c11))...
`+`(`*`(`/`(65, 24), `*`(c0)), `*`(`/`(7, 3), `*`(c2)), `-`(`*`(`/`(11, 8), `*`(c3))), `*`(`/`(23, 12), `*`(c4)), `-`(`*`(`/`(115, 24), `*`(c6))), `*`(`/`(41, 24), `*`(c8)), `*`(`/`(41, 12), `*`(c11))...
(362)

 

> Cscalar(cx);

 

`/`(65, 24) (363)

 

> Cvector(cx);

 

`+`(`*`(`/`(7, 3), `*`(c2)), `-`(`*`(`/`(11, 8), `*`(c3))), `*`(`/`(23, 12), `*`(c4)), `-`(`*`(`/`(115, 24), `*`(c6))), `*`(`/`(41, 24), `*`(c8)), `*`(`/`(41, 12), `*`(c11)), `*`(`/`(43, 12), `*`(c13)...
`+`(`*`(`/`(7, 3), `*`(c2)), `-`(`*`(`/`(11, 8), `*`(c3))), `*`(`/`(23, 12), `*`(c4)), `-`(`*`(`/`(115, 24), `*`(c6))), `*`(`/`(41, 24), `*`(c8)), `*`(`/`(41, 12), `*`(c11)), `*`(`/`(43, 12), `*`(c13)...
`+`(`*`(`/`(7, 3), `*`(c2)), `-`(`*`(`/`(11, 8), `*`(c3))), `*`(`/`(23, 12), `*`(c4)), `-`(`*`(`/`(115, 24), `*`(c6))), `*`(`/`(41, 24), `*`(c8)), `*`(`/`(41, 12), `*`(c11)), `*`(`/`(43, 12), `*`(c13)...
`+`(`*`(`/`(7, 3), `*`(c2)), `-`(`*`(`/`(11, 8), `*`(c3))), `*`(`/`(23, 12), `*`(c4)), `-`(`*`(`/`(115, 24), `*`(c6))), `*`(`/`(41, 24), `*`(c8)), `*`(`/`(41, 12), `*`(c11)), `*`(`/`(43, 12), `*`(c13)...
(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);

 

`+`(`*`(`/`(36, 67), `*`(c0)), `*`(`/`(25, 67), `*`(c1)), `-`(`*`(`/`(9, 67), `*`(c2))), `-`(`*`(`/`(26, 67), `*`(c3))), `*`(`/`(56, 67), `*`(c4)), `*`(`/`(37, 67), `*`(c5)), `*`(`/`(77, 67), `*`(c6))...
`+`(`*`(`/`(36, 67), `*`(c0)), `*`(`/`(25, 67), `*`(c1)), `-`(`*`(`/`(9, 67), `*`(c2))), `-`(`*`(`/`(26, 67), `*`(c3))), `*`(`/`(56, 67), `*`(c4)), `*`(`/`(37, 67), `*`(c5)), `*`(`/`(77, 67), `*`(c6))...
`+`(`*`(`/`(36, 67), `*`(c0)), `*`(`/`(25, 67), `*`(c1)), `-`(`*`(`/`(9, 67), `*`(c2))), `-`(`*`(`/`(26, 67), `*`(c3))), `*`(`/`(56, 67), `*`(c4)), `*`(`/`(37, 67), `*`(c5)), `*`(`/`(77, 67), `*`(c6))...
`+`(`*`(`/`(36, 67), `*`(c0)), `*`(`/`(25, 67), `*`(c1)), `-`(`*`(`/`(9, 67), `*`(c2))), `-`(`*`(`/`(26, 67), `*`(c3))), `*`(`/`(56, 67), `*`(c4)), `*`(`/`(37, 67), `*`(c5)), `*`(`/`(77, 67), `*`(c6))...
`+`(`*`(`/`(36, 67), `*`(c0)), `*`(`/`(25, 67), `*`(c1)), `-`(`*`(`/`(9, 67), `*`(c2))), `-`(`*`(`/`(26, 67), `*`(c3))), `*`(`/`(56, 67), `*`(c4)), `*`(`/`(37, 67), `*`(c5)), `*`(`/`(77, 67), `*`(c6))...
`+`(`*`(`/`(36, 67), `*`(c0)), `*`(`/`(25, 67), `*`(c1)), `-`(`*`(`/`(9, 67), `*`(c2))), `-`(`*`(`/`(26, 67), `*`(c3))), `*`(`/`(56, 67), `*`(c4)), `*`(`/`(37, 67), `*`(c5)), `*`(`/`(77, 67), `*`(c6))...
(365)

 

> CtoMatrix(cx);

 












(366)

 

> cx := Crand(1,1);

 

`+`(c0, c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c...
`+`(c0, c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c...
`+`(c0, c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c...
(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);

 

`+`(`*`(w1, `*`(c0)), `*`(x1, `*`(c1)), `*`(y1, `*`(c2)), `*`(z1, `*`(c3))) (369)

 

> cx*Cinverse(cx);

 

`+`(`/`(`*`(`^`(w1, 2)), `*`(`+`(`*`(`^`(w1, 2)), `*`(`^`(x1, 2)), `*`(`^`(z1, 2)), `*`(`^`(y1, 2))))), `/`(`*`(`^`(x1, 2)), `*`(`+`(`*`(`^`(w1, 2)), `*`(`^`(x1, 2)), `*`(`^`(z1, 2)), `*`(`^`(y1, 2)))... (370)

 

> simplify(%);

 

1 (371)

 

> cx*Cconjugate(cx);

 

`+`(`*`(`^`(w1, 2)), `*`(`^`(x1, 2)), `*`(`^`(z1, 2)), `*`(`^`(y1, 2))) (372)

 

> Cconjugate(cx)*cx;

 

`+`(`*`(`^`(w1, 2)), `*`(`^`(x1, 2)), `*`(`^`(z1, 2)), `*`(`^`(y1, 2))) (373)

 

> cu := CunitVector(cx);

 

`+`(`/`(`*`(x1, `*`(c1)), `*`(`^`(`+`(`*`(`^`(x1, 2)), `*`(`^`(z1, 2)), `*`(`^`(y1, 2))), `/`(1, 2)))), `/`(`*`(y1, `*`(c2)), `*`(`^`(`+`(`*`(`^`(x1, 2)), `*`(`^`(z1, 2)), `*`(`^`(y1, 2))), `/`(1, 2))... (374)

 

> cu*cu;

 

`+`(`-`(`/`(`*`(`^`(x1, 2)), `*`(`+`(`*`(`^`(x1, 2)), `*`(`^`(z1, 2)), `*`(`^`(y1, 2)))))), `-`(`/`(`*`(`^`(z1, 2)), `*`(`+`(`*`(`^`(x1, 2)), `*`(`^`(z1, 2)), `*`(`^`(y1, 2)))))), `-`(`/`(`*`(`^`(y1, ... (375)

 

> simplify(%);

 

-1 (376)

 

> Cdot(cu,cu);

 

`+`(`/`(`*`(`^`(x1, 2)), `*`(`+`(`*`(`^`(x1, 2)), `*`(`^`(z1, 2)), `*`(`^`(y1, 2))))), `/`(`*`(`^`(z1, 2)), `*`(`+`(`*`(`^`(x1, 2)), `*`(`^`(z1, 2)), `*`(`^`(y1, 2))))), `/`(`*`(`^`(y1, 2)), `*`(`+`(`... (377)

 

> simplify(%);

 

1 (378)

 

> CtoMatrix(cu);

 


(379)

 

> CtoMatrix(cx);

 

(380)

 

> Ceval( CtoMatrix(cx) );

 

`+`(`*`(w1, `*`(c0)), `*`(x1, `*`(c1)), `*`(y1, `*`(c2)), `*`(z1, `*`(c3))) (381)

 

The chingons have a type. 

> cx := Crand(1,1);

 

`+`(c0, c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c...
`+`(c0, c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c...
`+`(c0, c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c...
(382)

 

> type(cx,chingon);

 

true (383)

 

> type(5,chingon);

 

true (384)

 

> type(5*c0, chingon);

 

true (385)

 

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

 

true (386)

 

>  

 

 

Routon 

Routon Lesson 

Components u0 to u127 and O are protected.   

> O := 2;

 

Error, attempting to assign to `O` which is protected  

 

> u0 := 4;

 

Error, attempting to assign to `u0` which is protected  

 

> u7 := 15;

 

Error, attempting to assign to `u7` which is protected  

 

> u15 := 23;

 

Error, attempting to assign to `u15` which is protected  

 

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

> u3*u7;

 

Error, (in *) Trying to multiply a (quaternion or octonion or sedenion or pathion or routon or voudon) in chingon mode.  

 

> setHypercomplex(routon);

 

routon (387)

 

> u3*u7;

 

`+`(`-`(u4)) (388)

 

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

 

 

 

u4
u4 (389)

 

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

 

 

 

`+`(`-`(u4))
`+`(`-`(u4)) (390)

 

> u1*u2*u3;

 

-1 (391)

 

> u3*u2*u1;

 

1 (392)

 

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

 

`+`(`-`(`*`(2, `*`(u0))), `-`(`*`(4, `*`(u1))), `*`(3, `*`(u2)), `*`(3, `*`(u3)), `*`(2, `*`(u4)), `-`(`*`(4, `*`(u5))), `-`(u6), `*`(4, `*`(u7)), `-`(`*`(5, `*`(u10))), `-`(u11), `*`(4, `*`(u12)), `-...
`+`(`-`(`*`(2, `*`(u0))), `-`(`*`(4, `*`(u1))), `*`(3, `*`(u2)), `*`(3, `*`(u3)), `*`(2, `*`(u4)), `-`(`*`(4, `*`(u5))), `-`(u6), `*`(4, `*`(u7)), `-`(`*`(5, `*`(u10))), `-`(u11), `*`(4, `*`(u12)), `-...
`+`(`-`(`*`(2, `*`(u0))), `-`(`*`(4, `*`(u1))), `*`(3, `*`(u2)), `*`(3, `*`(u3)), `*`(2, `*`(u4)), `-`(`*`(4, `*`(u5))), `-`(u6), `*`(4, `*`(u7)), `-`(`*`(5, `*`(u10))), `-`(u11), `*`(4, `*`(u12)), `-...
`+`(`-`(`*`(2, `*`(u0))), `-`(`*`(4, `*`(u1))), `*`(3, `*`(u2)), `*`(3, `*`(u3)), `*`(2, `*`(u4)), `-`(`*`(4, `*`(u5))), `-`(u6), `*`(4, `*`(u7)), `-`(`*`(5, `*`(u10))), `-`(u11), `*`(4, `*`(u12)), `-...
`+`(`-`(`*`(2, `*`(u0))), `-`(`*`(4, `*`(u1))), `*`(3, `*`(u2)), `*`(3, `*`(u3)), `*`(2, `*`(u4)), `-`(`*`(4, `*`(u5))), `-`(u6), `*`(4, `*`(u7)), `-`(`*`(5, `*`(u10))), `-`(u11), `*`(4, `*`(u12)), `-...
`+`(`-`(`*`(2, `*`(u0))), `-`(`*`(4, `*`(u1))), `*`(3, `*`(u2)), `*`(3, `*`(u3)), `*`(2, `*`(u4)), `-`(`*`(4, `*`(u5))), `-`(u6), `*`(4, `*`(u7)), `-`(`*`(5, `*`(u10))), `-`(u11), `*`(4, `*`(u12)), `-...
`+`(`-`(`*`(2, `*`(u0))), `-`(`*`(4, `*`(u1))), `*`(3, `*`(u2)), `*`(3, `*`(u3)), `*`(2, `*`(u4)), `-`(`*`(4, `*`(u5))), `-`(u6), `*`(4, `*`(u7)), `-`(`*`(5, `*`(u10))), `-`(u11), `*`(4, `*`(u12)), `-...
(393)

 

> rx + (1/5)*u15;

 

`+`(`-`(2), `-`(`*`(4, `*`(u1))), `*`(3, `*`(u2)), `*`(3, `*`(u3)), `*`(2, `*`(u4)), `-`(`*`(4, `*`(u5))), `-`(u6), `*`(4, `*`(u7)), `-`(`*`(5, `*`(u10))), `-`(u11), `*`(4, `*`(u12)), `-`(`*`(4, `*`(u...
`+`(`-`(2), `-`(`*`(4, `*`(u1))), `*`(3, `*`(u2)), `*`(3, `*`(u3)), `*`(2, `*`(u4)), `-`(`*`(4, `*`(u5))), `-`(u6), `*`(4, `*`(u7)), `-`(`*`(5, `*`(u10))), `-`(u11), `*`(4, `*`(u12)), `-`(`*`(4, `*`(u...
`+`(`-`(2), `-`(`*`(4, `*`(u1))), `*`(3, `*`(u2)), `*`(3, `*`(u3)), `*`(2, `*`(u4)), `-`(`*`(4, `*`(u5))), `-`(u6), `*`(4, `*`(u7)), `-`(`*`(5, `*`(u10))), `-`(u11), `*`(4, `*`(u12)), `-`(`*`(4, `*`(u...
`+`(`-`(2), `-`(`*`(4, `*`(u1))), `*`(3, `*`(u2)), `*`(3, `*`(u3)), `*`(2, `*`(u4)), `-`(`*`(4, `*`(u5))), `-`(u6), `*`(4, `*`(u7)), `-`(`*`(5, `*`(u10))), `-`(u11), `*`(4, `*`(u12)), `-`(`*`(4, `*`(u...
`+`(`-`(2), `-`(`*`(4, `*`(u1))), `*`(3, `*`(u2)), `*`(3, `*`(u3)), `*`(2, `*`(u4)), `-`(`*`(4, `*`(u5))), `-`(u6), `*`(4, `*`(u7)), `-`(`*`(5, `*`(u10))), `-`(u11), `*`(4, `*`(u12)), `-`(`*`(4, `*`(u...
`+`(`-`(2), `-`(`*`(4, `*`(u1))), `*`(3, `*`(u2)), `*`(3, `*`(u3)), `*`(2, `*`(u4)), `-`(`*`(4, `*`(u5))), `-`(u6), `*`(4, `*`(u7)), `-`(`*`(5, `*`(u10))), `-`(u11), `*`(4, `*`(u12)), `-`(`*`(4, `*`(u...
`+`(`-`(2), `-`(`*`(4, `*`(u1))), `*`(3, `*`(u2)), `*`(3, `*`(u3)), `*`(2, `*`(u4)), `-`(`*`(4, `*`(u5))), `-`(u6), `*`(4, `*`(u7)), `-`(`*`(5, `*`(u10))), `-`(u11), `*`(4, `*`(u12)), `-`(`*`(4, `*`(u...
(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;

 

1 (395)

 

> u1*u1;

 

-1 (396)

 

> u2*u2;

 

-1 (397)

 

> u3*u3;

 

-1 (398)

 

> u4*u4;

 

-1 (399)

 

> u5*u5;

 

-1 (400)

 

> u6*u6;

 

-1 (401)

 

> u7*u7;

 

-1 (402)

 

> u8*u8;

 

-1 (403)

 

> u9*u9;

 

-1 (404)

 

> u10*u10;

 

-1 (405)

 

> u11*u11;

 

-1 (406)

 

> u15*u15;

 

-1 (407)

 

> u31*u31;

 

-1 (408)

 

> u63*u63;

 

-1 (409)

 

> u127*u127;

 

-1 (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);

 

`+`(`-`(u3), u6, u9, `-`(u12)) (411)

 

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

 

0 (412)

 

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

 

0 (413)

 

> a := u3 + u10;

 

`+`(u3, u10) (414)

 

> b := u6 - u15;

 

`+`(u6, `-`(u15)) (415)

 

> evalb(a = 0);

 

false (416)

 

> evalb(b = 0);

 

false (417)

 

> evalb(a*b = 0);

 

true (418)

 

Here, we are testing the dot product function. 

 

The dot product has a longer processing time. 

 

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

 

`+`(u127, u54, u15, u29, u17, `*`(2, `*`(u83))) (419)

 

> rconj := Rconjugate(rx);

 

`+`(`-`(u15), `-`(u17), `-`(u29), `-`(u54), `-`(`*`(2, `*`(u83))), `-`(u127)) (420)

 

> Rdot(rx,rx);

 

9 (421)

 

> Rdot(rconj,rconj);

 

9 (422)

 

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

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

 

`+`(`*`(`/`(31, 19), `*`(u28)), `-`(`*`(`/`(122, 57), `*`(u11))), `*`(`/`(26, 19), `*`(u42)), `*`(`/`(56, 57), `*`(u44)), `*`(`/`(74, 57), `*`(u125)), `-`(`*`(`/`(59, 57), `*`(u38))), `*`(`/`(25, 19),...
`+`(`*`(`/`(31, 19), `*`(u28)), `-`(`*`(`/`(122, 57), `*`(u11))), `*`(`/`(26, 19), `*`(u42)), `*`(`/`(56, 57), `*`(u44)), `*`(`/`(74, 57), `*`(u125)), `-`(`*`(`/`(59, 57), `*`(u38))), `*`(`/`(25, 19),...
(423)

 

> Rscalar(rx);

 

0 (424)

 

> Rvector(rx);

 

`+`(`*`(`/`(31, 19), `*`(u28)), `-`(`*`(`/`(122, 57), `*`(u11))), `*`(`/`(26, 19), `*`(u42)), `*`(`/`(56, 57), `*`(u44)), `*`(`/`(74, 57), `*`(u125)), `-`(`*`(`/`(59, 57), `*`(u38))), `*`(`/`(25, 19),...
`+`(`*`(`/`(31, 19), `*`(u28)), `-`(`*`(`/`(122, 57), `*`(u11))), `*`(`/`(26, 19), `*`(u42)), `*`(`/`(56, 57), `*`(u44)), `*`(`/`(74, 57), `*`(u125)), `-`(`*`(`/`(59, 57), `*`(u38))), `*`(`/`(25, 19),...
(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);

 

`+`(`-`(`*`(`/`(13, 23), `*`(u57))), `-`(`*`(`/`(50, 23), `*`(u9))), `*`(`/`(29, 23), `*`(u37)), `-`(`*`(`/`(62, 23), `*`(u120))), `-`(`*`(`/`(93, 23), `*`(u126))), `*`(`/`(54, 23), `*`(u60)), `-`(`*`... (426)

 

> RtoMatrix(rx);

 

(427)

 

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

 

`+`(`*`(2, `*`(u108)), `*`(2, `*`(u23)), u96, u114, u115, u59, u41, u90, u65, u0, u89, u42, u123) (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);

 

`+`(`*`(w1, `*`(u0)), `*`(x1, `*`(u1)), `*`(y1, `*`(u2)), `*`(z1, `*`(u3))) (430)

 

> rx*Rinverse(rx);

 

`+`(`/`(`*`(`^`(w1, 2)), `*`(`+`(`*`(`^`(w1, 2)), `*`(`^`(x1, 2)), `*`(`^`(z1, 2)), `*`(`^`(y1, 2))))), `/`(`*`(`^`(x1, 2)), `*`(`+`(`*`(`^`(w1, 2)), `*`(`^`(x1, 2)), `*`(`^`(z1, 2)), `*`(`^`(y1, 2)))... (431)

 

> simplify(%);

 

1 (432)

 

> rx*Rconjugate(rx);

 

`+`(`*`(`^`(w1, 2)), `*`(`^`(x1, 2)), `*`(`^`(z1, 2)), `*`(`^`(y1, 2))) (433)

 

> Rconjugate(rx)*rx;

 

`+`(`*`(`^`(w1, 2)), `*`(`^`(x1, 2)), `*`(`^`(z1, 2)), `*`(`^`(y1, 2))) (434)

 

> ru := RunitVector(rx);

 

`+`(`/`(`*`(y1, `*`(u2)), `*`(`^`(`+`(`*`(`^`(x1, 2)), `*`(`^`(z1, 2)), `*`(`^`(y1, 2))), `/`(1, 2)))), `/`(`*`(z1, `*`(u3)), `*`(`^`(`+`(`*`(`^`(x1, 2)), `*`(`^`(z1, 2)), `*`(`^`(y1, 2))), `/`(1, 2))... (435)

 

> ru*ru;

 

`+`(`-`(`/`(`*`(`^`(x1, 2)), `*`(`+`(`*`(`^`(x1, 2)), `*`(`^`(z1, 2)), `*`(`^`(y1, 2)))))), `-`(`/`(`*`(`^`(z1, 2)), `*`(`+`(`*`(`^`(x1, 2)), `*`(`^`(z1, 2)), `*`(`^`(y1, 2)))))), `-`(`/`(`*`(`^`(y1, ... (436)

 

> simplify(%);

 

-1 (437)

 

> Rdot(ru,ru);

 

`+`(`/`(`*`(`^`(x1, 2)), `*`(`+`(`*`(`^`(x1, 2)), `*`(`^`(z1, 2)), `*`(`^`(y1, 2))))), `/`(`*`(`^`(z1, 2)), `*`(`+`(`*`(`^`(x1, 2)), `*`(`^`(z1, 2)), `*`(`^`(y1, 2))))), `/`(`*`(`^`(y1, 2)), `*`(`+`(`... (438)

 

> simplify(%);

 

1 (439)

 

> RtoMatrix(ru);

 


(440)

 

> RtoMatrix(rx);

 

(441)

 

> Reval( RtoMatrix(rx) );

 

`+`(`*`(w1, `*`(u0)), `*`(x1, `*`(u1)), `*`(y1, `*`(u2)), `*`(z1, `*`(u3))) (442)

 

The routons have a type. 

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

 

`+`(u24, u6, u98, u96, u90, u81, u117, u62, u11, u32, u17, u26, u78, u76, u1) (443)

 

> type(rx,routon);

 

true (444)

 

> type(5,routon);

 

true (445)

 

> type(5*u0,routon);

 

true (446)

 

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

 

true (447)

 

>  

 

 

Voudon 

Voudon Lesson 

Components v0 to v255 and O are protected.   

> O := 2;

 

Error, attempting to assign to `O` which is protected  

 

> v0 := 4;

 

Error, attempting to assign to `v0` which is protected  

 

> v7 := 15;

 

Error, attempting to assign to `v7` which is protected  

 

> v15 := 23;

 

Error, attempting to assign to `v15` which is protected  

 

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

> v3*v7;

 

Error, (in *) Trying to multiply a (quaternion or octonion or sedenion or pathion or voudon) in routon mode.  

 

> setHypercomplex(voudon);

 

voudon (448)

 

> v3*v7;

 

`+`(`-`(v4)) (449)

 

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

 

 

 

v4
v4 (450)

 

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

 

 

 

`+`(`-`(v4))
`+`(`-`(v4)) (451)

 

> v1*v2*v3;

 

-1 (452)

 

> v3*v2*v1;

 

1 (453)

 

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

 

`+`(`-`(`*`(`/`(5, 3), `*`(v217))), `-`(v128), `-`(`*`(`/`(5, 3), `*`(v68))), `-`(`*`(`/`(4, 3), `*`(v99))), `*`(`/`(2, 3), `*`(v145)), `-`(`*`(`/`(5, 3), `*`(v160))), `*`(`/`(1, 3), `*`(v207))) (454)

 

> vx + (1/5)*v15;

 

`+`(`*`(`/`(1, 3), `*`(v207)), `-`(`*`(`/`(5, 3), `*`(v217))), `*`(`/`(1, 5), `*`(v15)), `-`(`*`(`/`(5, 3), `*`(v68))), `-`(`*`(`/`(4, 3), `*`(v99))), `-`(v128), `*`(`/`(2, 3), `*`(v145)), `-`(`*`(`/`... (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;

 

1 (456)

 

> v1*v1;

 

-1 (457)

 

> v2*v2;

 

-1 (458)

 

> v3*v3;

 

-1 (459)

 

> v4*v4;

 

-1 (460)

 

> v5*v5;

 

-1 (461)

 

> v6*v6;

 

-1 (462)

 

> v7*v7;

 

-1 (463)

 

> v8*v8;

 

-1 (464)

 

> v9*v9;

 

-1 (465)

 

> v10*v10;

 

-1 (466)

 

> v15*v15;

 

-1 (467)

 

> v31*v31;

 

-1 (468)

 

> v63*v63;

 

-1 (469)

 

> v127*v127;

 

-1 (470)

 

> v255*v255;

 

-1 (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);

 

`+`(`-`(v3), v6, v9, `-`(v12)) (472)

 

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

 

0 (473)

 

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

 

0 (474)

 

> a := v3 + v10;

 

`+`(v3, v10) (475)

 

> b := v6 - v15;

 

`+`(v6, `-`(v15)) (476)

 

> evalb(a = 0);

 

false (477)

 

> evalb(b = 0);

 

false (478)

 

> evalb(a*b = 0);

 

true (479)

 

Here, we are testing the dot product function. 

 

The dot product has a longer delay. 

 

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

 

`+`(v134, v203, v50, v213, v87, v33, v196) (480)

 

> vconj := Vconjugate(vx);

 

`+`(`-`(v196), `-`(v203), `-`(v213), `-`(v33), `-`(v50), `-`(v87), `-`(v134)) (481)

 

> Vdot(vx,vx);

 

7 (482)

 

> Vdot(vconj,vconj);

 

7 (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);

 

`+`(`*`(`/`(15, 8), `*`(v203)), `-`(`*`(`/`(9, 2), `*`(v206))), `*`(`/`(1, 2), `*`(v216)), `*`(`/`(45, 8), `*`(v224)), `*`(`/`(25, 8), `*`(v226)), `*`(`/`(71, 16), `*`(v233)), `-`(`*`(`/`(73, 16), `*`...
`+`(`*`(`/`(15, 8), `*`(v203)), `-`(`*`(`/`(9, 2), `*`(v206))), `*`(`/`(1, 2), `*`(v216)), `*`(`/`(45, 8), `*`(v224)), `*`(`/`(25, 8), `*`(v226)), `*`(`/`(71, 16), `*`(v233)), `-`(`*`(`/`(73, 16), `*`...
`+`(`*`(`/`(15, 8), `*`(v203)), `-`(`*`(`/`(9, 2), `*`(v206))), `*`(`/`(1, 2), `*`(v216)), `*`(`/`(45, 8), `*`(v224)), `*`(`/`(25, 8), `*`(v226)), `*`(`/`(71, 16), `*`(v233)), `-`(`*`(`/`(73, 16), `*`...
(484)

 

> Vscalar(vx);

 

0 (485)

 

> Vvector(vx);

 

`+`(`*`(`/`(15, 8), `*`(v203)), `-`(`*`(`/`(9, 2), `*`(v206))), `*`(`/`(1, 2), `*`(v216)), `*`(`/`(45, 8), `*`(v224)), `*`(`/`(25, 8), `*`(v226)), `*`(`/`(71, 16), `*`(v233)), `-`(`*`(`/`(73, 16), `*`...
`+`(`*`(`/`(15, 8), `*`(v203)), `-`(`*`(`/`(9, 2), `*`(v206))), `*`(`/`(1, 2), `*`(v216)), `*`(`/`(45, 8), `*`(v224)), `*`(`/`(25, 8), `*`(v226)), `*`(`/`(71, 16), `*`(v233)), `-`(`*`(`/`(73, 16), `*`...
`+`(`*`(`/`(15, 8), `*`(v203)), `-`(`*`(`/`(9, 2), `*`(v206))), `*`(`/`(1, 2), `*`(v216)), `*`(`/`(45, 8), `*`(v224)), `*`(`/`(25, 8), `*`(v226)), `*`(`/`(71, 16), `*`(v233)), `-`(`*`(`/`(73, 16), `*`...
(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);

 

`+`(`*`(`/`(37, 34), `*`(v218)), `-`(`*`(`/`(15, 68), `*`(v6))), `*`(`/`(7, 68), `*`(v160)), `-`(`*`(`/`(5, 4), `*`(v17))), `-`(`*`(`/`(2, 17), `*`(v172))), `*`(`/`(29, 34), `*`(v201)), `-`(`*`(`/`(14...
`+`(`*`(`/`(37, 34), `*`(v218)), `-`(`*`(`/`(15, 68), `*`(v6))), `*`(`/`(7, 68), `*`(v160)), `-`(`*`(`/`(5, 4), `*`(v17))), `-`(`*`(`/`(2, 17), `*`(v172))), `*`(`/`(29, 34), `*`(v201)), `-`(`*`(`/`(14...
(487)

 

> VtoMatrix(vx);

 




(488)

 

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

 

`+`(v88, v229, v80, v84, v216, v102, v182, v35, v175, v7) (489)

 

> VtoMatrix(vx);

 

(490)

 

The voudons have a type. 

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

 

`+`(v231, v195, v155, v7, v40, v209, `*`(2, `*`(v253)), v252, v20, v186, v121, v91, v131, v65) (491)

 

> type(vx,voudon);

 

true (492)

 

> type(5,voudon);

 

true (493)

 

> type(5*v0,voudon);

 

true (494)

 

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

 

true (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);

 

`+`(`*`(w8, `*`(v7)), `*`(x8, `*`(v8)), `*`(y8, `*`(v9)), `*`(z8, `*`(v10))) (496)

 

> vx*Vinverse(vx);

 

`+`(`/`(`*`(`^`(w8, 2)), `*`(`+`(`*`(`^`(w8, 2)), `*`(`^`(x8, 2)), `*`(`^`(y8, 2)), `*`(`^`(z8, 2))))), `/`(`*`(`^`(x8, 2)), `*`(`+`(`*`(`^`(w8, 2)), `*`(`^`(x8, 2)), `*`(`^`(y8, 2)), `*`(`^`(z8, 2)))... (497)

 

> simplify(%);

 

1 (498)

 

> vx*Vconjugate(vx);

 

`+`(`*`(`^`(w8, 2)), `*`(`^`(x8, 2)), `*`(`^`(y8, 2)), `*`(`^`(z8, 2))) (499)

 

> Vconjugate(vx)*vx;

 

`+`(`*`(`^`(w8, 2)), `*`(`^`(x8, 2)), `*`(`^`(y8, 2)), `*`(`^`(z8, 2))) (500)

 

> vu := VunitVector(vx);

 

`+`(`/`(`*`(y8, `*`(v9)), `*`(`^`(`+`(`*`(`^`(w8, 2)), `*`(`^`(x8, 2)), `*`(`^`(y8, 2)), `*`(`^`(z8, 2))), `/`(1, 2)))), `/`(`*`(x8, `*`(v8)), `*`(`^`(`+`(`*`(`^`(w8, 2)), `*`(`^`(x8, 2)), `*`(`^`(y8,...
`+`(`/`(`*`(y8, `*`(v9)), `*`(`^`(`+`(`*`(`^`(w8, 2)), `*`(`^`(x8, 2)), `*`(`^`(y8, 2)), `*`(`^`(z8, 2))), `/`(1, 2)))), `/`(`*`(x8, `*`(v8)), `*`(`^`(`+`(`*`(`^`(w8, 2)), `*`(`^`(x8, 2)), `*`(`^`(y8,...
(501)

 

> vu*vu;

 

`+`(`-`(`/`(`*`(`^`(w8, 2)), `*`(`+`(`*`(`^`(w8, 2)), `*`(`^`(x8, 2)), `*`(`^`(y8, 2)), `*`(`^`(z8, 2)))))), `-`(`/`(`*`(`^`(x8, 2)), `*`(`+`(`*`(`^`(w8, 2)), `*`(`^`(x8, 2)), `*`(`^`(y8, 2)), `*`(`^`... (502)

 

> simplify(%);

 

-1 (503)

 

> Vdot(vu,vu);

 

`+`(`/`(`*`(`^`(w8, 2)), `*`(`+`(`*`(`^`(w8, 2)), `*`(`^`(x8, 2)), `*`(`^`(y8, 2)), `*`(`^`(z8, 2))))), `/`(`*`(`^`(x8, 2)), `*`(`+`(`*`(`^`(w8, 2)), `*`(`^`(x8, 2)), `*`(`^`(y8, 2)), `*`(`^`(z8, 2)))... (504)

 

> simplify(%);

 

1 (505)

 

> VtoMatrix(vu);

 




(506)

 

> VtoMatrix(vx);

 

(507)

 

> Veval( VtoMatrix(vx) );

 

`+`(`*`(w8, `*`(v7)), `*`(x8, `*`(v8)), `*`(y8, `*`(v9)), `*`(z8, `*`(v10))) (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 

 

About the Author 

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 

 

Image 

 

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.