Generic Eight-Squared Numbers (Octs)




The eight-squared identity is the next generalization of quaternions. The eight-squared was first reported by Ferdinand Degen in 1818. It was then mentioned by John T. Graves (1843), and became widely known after publication by Arthur Cayley (1845).

It shows the same behavior as the quaternion and complex numbers, where given one working relationship, by sign changes in sources and destinations, and relabelling of components, a large number of alternative working formulas can be found. In the case of octonions, we have 2^19 = 512K different forms.

The sign matrix in this instance is called T[8][8] rather than S[8][8] to avoid a conflicting name in ginac.

The computation runs as follows. First, assign free variables, using the gamma pattern. (Other patterns work, as long as you don't overspecify four related elements.)

                a b c d e f g h
                i x x x p x s x
                j x x x q x x x
 T[row][col] =  k x x x r x x x
                l x x x x x x x
                m x x x x x x x
                n x x x x x x x
                o x x x x x x x
The nineteen free variables are a-s. The dependent variables are the 'x's, which are determined using the four-term relationship.
	col = rr^row^cc;
	T[rr][cc] = -T[row][cc]*T[row][col]*T[rr][col];
The program OctsViaMult.cp is developed and run in stages. Initially, we only define our independent variables. We then evaluate all definitions for the dependent variables. All discovered definitions are simplified (squared factors reduce to one), and the definitions added to the program. After four rounds, all cells are consistently defined. As a consistency check, each dictionary row for each cell is divided by the first column entry, and the resulting ratios evaluated with square terms reduced to one. All 64 entries prove consistent.

Definitions

	T[0][0] = a;
	T[0][1] = b;
	T[0][2] = c;
	T[0][3] = d;
	T[0][4] = e;
	T[0][5] = f;
	T[0][6] = g;
	T[0][7] = h;

	T[1][0] = i;
	T[1][1] = -i*b*a;		// S11 = -i*b*a 
	T[1][2] = -r*k*q*g*j*s*c;	// S12 = -l^2*r*e^2*h^2*k*q*g*j*s*c = -r*k*q*g*j*s*c
	T[1][3] =  r*k*q*d*g*j*s;	// S13 =  l^2*r*e^2*k*q*d*g*j*s = r*k*q*d*g*j*s
	T[1][4] = p;
	T[1][5] = -f*e*p;		// S15 = -f*e*p
	T[1][6] = s;
  	T[1][7] = -h*g*s;		// S17 = -h*g*s 
	
	T[2][0] = j;
	T[2][1] =  r*b*k*q*g*s*i;	// S21 =  l^2*r*b*e^2*h^2*k*q*g*p^2*s*i = r*b*k*q*g*s*i
 	T[2][2] = -a*j*c;		// S22 = -a*j*c
	T[2][3] = -r*k*q*d*g*s*i;	// S23 = -l^2*r*e^2*k*q*d*g*p^2*s*f^2*i = -r*k*q*d*g*s*i
 	T[2][4] = q;
	T[2][5] = -q*g*p*s*f;		// S25 = -e^2*q*g*p*s*f =  -q*g*p*s*f
	T[2][6] = -e*q*g;		// S26 = -e*q*g
	T[2][7] =  h*q*g*p*s;		// S27 =  h*q*g*p*s 

	T[3][0] = k;
	T[3][1] = -r*b*q*g*j*s*i;	// S31 = -l^2*r*b*e^2*q*g*j*p^2*s*i = -r*b*q*g*j*s*i
	T[3][2] =  r*q*g*j*s*c*i;	// S32 =  l^2*r*e^2*q*g*j*p^2*s*c*f^2*i = r*q*g*j*s*c*i
 	T[3][3] = -k*a*d;		// S33 = -k*a*d 
	T[3][4] = r;
 	T[3][5] =  g*p*s*f*r;		// S35 =  g*p*s*f*r
	T[3][6] = -r*p*s;		// S36 = -r*p*s  
 	T[3][7] = -r*e*h;		// S37 = -r*e*h 

	T[4][0] = l;
	T[4][1] = -e*p*i*l*b;		// S41 = -e*a^2*p*i*l*b =  -e*p*i*l*b
	T[4][2] = -e*q*j*c*l;		// S42 = -e*q*a^2*j*c*l = -e*q*j*c*l
	T[4][3] = -e*k*d*l*r;		// S43 = -e*k*a^2*d*l*r = -e*k*d*l*r
 	T[4][4] = -l*e*a;		// S44 = -l*e*a 
	T[4][5] =  e*p*f*i*l;		// S45 =  e*p*f*i*l
	T[4][6] =  e*q*g*j*l;		// S46 =  e*q*g*j*l
	T[4][7] =  e*h*k*l*r;		// S47 =  e*h*k*l*r
 
	T[5][0] = m;
	T[5][1] =  e*m*p*i*b;		// S51 =  e*m*p*i*b 
	T[5][2] =  q*g*j*m*p*s*c;	// S52 =  q*a^2*g*j*m*p*s*c*f^2 = q*g*j*m*p*s*c
	T[5][3] = -r*k*d*g*m*p*s;	// S53 = -r*k*d*g*m*p*s
 	T[5][4] = -i*m*p;		// S54 = -i*m*p 
	T[5][5] = -f*a*m;		// S55 = -f*a*m 
	T[5][6] =  k*m*p*s*r;		// S56 =  k*m*p*s*r
	T[5][7] = -h*q*g*j*m*p*s;	// S57 = -h*q*g*j*m*p*s

	T[6][0] = n;
	T[6][1] = -n*g*s*i*b;		// S61 = -n*a^2*g*s*i*b = -n*g*s*i*b
	T[6][2] =  e*n*q*j*c;		// S62 =  e*n*q*j*c 
	T[6][3] =  k*n*d*g*p*s*r;	// S63 =  k*n*a^2*d*g*p*s*r = k*n*d*g*p*s*r
 	T[6][4] = -n*q*j;		// S64 = -n*q*j 
	T[6][5] = -r*k*n*g*p*s*f;	// S65 =  -r*k*n*g*p*s*f
 	T[6][6] = -n*a*g;		// S66 = -n*a*g 
	T[6][7] =  h*n*g*s*i;		// S67 =  h*n*g*s*i 

	T[7][0] = o;
 	T[7][1] =  g*s*i*o*b;		// S71 =  g*s*i*o*b 
	T[7][2] = -o*q*g*j*p*s*c;	// S72 = -o*h^2*q*a^2*g*j*p*s*c = -o*q*g*j*p*s*c
	T[7][3] =  e*k*d*o*r;		// S73 =  e*k*d*o*r
	T[7][4] = -o*r*k;		// S74 = -o*r*k
	T[7][5] =  o*q*g*j*p*s*f;	// S75 =  o*q*g*j*p*s*f
 	T[7][6] = -i*o*s;		// S76 = -i*o*s
 	T[7][7] = -o*h*a;		// S77 = -o*h*a 

The output of the OctsViaMult program is OctsViaMult.txt.


Having defined the sign matrix, in terms of a-s, we can now define our generic octs product. Due to lack of alphabet characters, I will be reusing the letters a-h in this next code snippet as working variables for the multiplications. These a-h are not part of the code from above.

	a = u.t;	// Get components of pre-factor
	b = u.x;
	c = u.y;
	d = u.z;
	e = u.E;
	f = u.X;
	g = u.Y;
	h = u.Z;

	A = v.t;	// Get components of post-factor
	B = v.x;
	C = v.y;
	D = v.z;
	E = v.E;
	F = v.X;
	G = v.Y;
	H = v.Z;

	// calculate product components

	w.t  = +T[0][0]*a*A+T[0][1]*b*B+T[0][2]*c*C+T[0][3]*d*D+T[0][4]*e*E+T[0][5]*f*F+T[0][6]*g*G+T[0][7]*h*H; 	
	w.x  = +T[1][0]*a*B+T[1][1]*b*A+T[1][2]*c*D+T[1][3]*d*C+T[1][4]*e*F+T[1][5]*f*E+T[1][6]*g*H+T[1][7]*h*G;  
	w.y  = +T[2][0]*a*C+T[2][1]*b*D+T[2][2]*c*A+T[2][3]*d*B+T[2][4]*e*G+T[2][5]*f*H+T[2][6]*g*E+T[2][7]*h*F;  
	w.z  = +T[3][0]*a*D+T[3][1]*b*C+T[3][2]*c*B+T[3][3]*d*A+T[3][4]*e*H+T[3][5]*f*G+T[3][6]*g*F+T[3][7]*h*E;  
	w.E  = +T[4][0]*a*E+T[4][1]*b*F+T[4][2]*c*G+T[4][3]*d*H+T[4][4]*e*A+T[4][5]*f*B+T[4][6]*g*C+T[4][7]*h*D; 
	w.X  = +T[5][0]*a*F+T[5][1]*b*E+T[5][2]*c*H+T[5][3]*d*G+T[5][4]*e*B+T[5][5]*f*A+T[5][6]*g*D+T[5][7]*h*C; 
	w.Y  = +T[6][0]*a*G+T[6][1]*b*H+T[6][2]*c*E+T[6][3]*d*F+T[6][4]*e*C+T[6][5]*f*D+T[6][6]*g*A+T[6][7]*h*B;  
	w.Z  = +T[7][0]*a*H+T[7][1]*b*G+T[7][2]*c*F+T[7][3]*d*E+T[7][4]*e*D+T[7][5]*f*C+T[7][6]*g*B+T[7][7]*h*A;  

OctsVerified.cp is a simple program to generate all 512K multiplicative laws, and verify that the magnitude squared of the oct product is the product of the squares of the input product terms. (To test the tester program, remove one of the variables, such as a *q term, in one the FillSign defining routines. See commented out code for example.)