help links subscribe changes refresh edit

	SandBox
SandBoxNijenhuis ←	↑	→ SandBoxNonZeroInteger

SandBoxNonAssociativeAlgebra

last edited 16 years ago by Bill Page

Edit detail for SandBoxNonAssociativeAlgebra revision 12 of 25

	1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25
Editor: Bill Page Time: 2008/04/24 18:53:09 GMT-7
Note: structural constants

changed:
-test(e**e=e)
-test(i**i=e)
-test(j**j=e)
-test(k**k=e)
-test(e**i=i)
-test(e**j=j)
-test(e**k=k)
-test(i**e=-i)
-test(j**e=-j)
-test(k**e=-k)
-test(i**j=k)
-test(j**i=-k)
-test(k**i=j)
-test(i**k=-j)
-test(j**k=i)
test(e**e=e)  and _
test(i**i=e)  and _
test(j**j=e)  and _
test(k**k=e)  and _
test(e**i=i)  and _
test(e**j=j)  and _
test(e**k=k)  and _
test(i**e=-i) and _
test(j**e=-j) and _
test(k**e=-k) and _
test(i**j=k)  and _
test(j**i=-k) and _
test(k**i=j)  and _
test(i**k=-j) and _
test(j**k=i)  and _

changed:
- [-1, 0, 0, 0]]]
 [-1, 0, 0, 0]]];

changed:
-[[a.i * a.j for i in 1..4] for j in 1..4]
-noncommutativeJordanAlgebra?()$V
matrix([[(a.i * a.j)::OutputForm for j in 1..4] for i in 1..4])$OutputForm
leftUnit()$V
rightUnit()$V
alternative?()$V
leftAlternative?()$V
rightAlternative?()$V
associative?()$V

changed:
-alternative?()$V
-associative?()$V
--powerAssociative?()$V

removed:
-jacobiIdentity?()$V

added:
noncommutativeJordanAlgebra?()$V

added:
jacobiIdentity?()$V

Ref: http://arxiv.org/abs/0711.3220

Fourvector algebra

Author: Diego Saa (Submitted on 20 Nov 2007)

Abstract: The algebra of fourvectors is described. The fourvectors are more appropriate than the Hamilton quaternions for its use in Physics and the sciences in general. The fourvectors embrace the 3D vectors in a natural form. It is shown the excellent ability to perform rotations with the use of fourvectors, as well as their use in relativity for producing Lorentz boosts, which are understood as simple rotations.

axiom
_*_*(x,y)==concat(x(1) * y(1) + dot(x(2..), y(2..)), x(1) * y(2..) - x(2..) * y(1) + cross(x(2..), y(2..)))

Type: Void

axiom
e:Vector INT:=[1,0,0,0]

(1)

Type: Vector Integer

axiom
i:Vector INT:=[0,1,0,0]

(2)

Type: Vector Integer

axiom
j:Vector INT:=[0,0,1,0]

(3)

Type: Vector Integer

axiom
k:Vector INT:=[0,0,0,1]

(4)

Type: Vector Integer

axiomtest(e**e=e)  and _
test(i**i=e)  and _
test(j**j=e)  and _
test(k**k=e)  and _
test(e**i=i)  and _
test(e**j=j)  and _
test(e**k=k)  and _
test(i**e=-i) and _
test(j**e=-j) and _
test(k**e=-k) and _
test(i**j=k)  and _
test(j**i=-k) and _
test(k**i=j)  and _
test(i**k=-j) and _
test(j**k=i)  and _
test(k**j=-i)

axiom

Compiling function ** with type (Vector Integer,Vector Integer) -> 
      Vector Integer

(5)

Type: Boolean

Axiom has a domain for NonAssociative? Algebra

This is documented in the article: Computations in Algebras of Fixed Rank by Johannes Grabmeir and Robert Wisbauer, from the book "Computational Algebra" By Klaus G. Fischer, Philippe Loustaunau, Jay Shapiro.

The algebra above can be given by structural constants.

axiom)clear all
   All user variables and function definitions have been cleared.
sc:Vector Matrix Fraction Integer := [ _
[[ 1, 0, 0, 0], _
 [ 0, 1, 0, 0], _
 [ 0, 0, 1, 0], _
 [ 0, 0, 0, 1]], _
[[ 0, 1, 0, 0], _
 [-1, 0, 0, 0], _
 [ 0, 0, 0, 1], _
 [ 0, 0,-1, 0]], _
[[ 0, 0, 1, 0], _
 [ 0, 0, 0,-1], _
 [-1, 0, 0, 0], _
 [ 0, 1, 0, 0]], _
[[ 0, 0, 0, 1], _
 [ 0, 0, 1, 0], _
 [ 0,-1, 0, 0], _
 [-1, 0, 0, 0]]];

Type: Vector Matrix Fraction Integer

axiom
V:=AlgebraGivenByStructuralConstants(Fraction Integer, 4, [e,i,j,k],sc)

(6)

Type: Domain

axiom)show V
 AlgebraGivenByStructuralConstants(Fraction Integer,4,[e,i,j,k],[MATRIX,MATRIX,MATRIX,MATRIX]) is a domain constructor.
 Abbreviation for AlgebraGivenByStructuralConstants is ALGSC 
 This constructor is exposed in this frame.
 Issue )edit /usr/local/lib/axiom/target/x86_64-unknown-linux/../../src/algebra/ALGSC.spad to see algebra source code for ALGSC 
------------------------------- Operations --------------------------------
 ?*? : (Fraction Integer,%) -> %       ?*? : (Integer,%) -> %
 ?*? : (PositiveInteger,%) -> %        ?*? : (%,Fraction Integer) -> %
 ?*? : (%,%) -> %                      ?**? : (%,PositiveInteger) -> %
 ?+? : (%,%) -> %                      ?-? : (%,%) -> %
 -? : % -> %                           ?=? : (%,%) -> Boolean
 0 : () -> %                           alternative? : () -> Boolean
 antiAssociative? : () -> Boolean      antiCommutative? : () -> Boolean
 antiCommutator : (%,%) -> %           associative? : () -> Boolean
 associator : (%,%,%) -> %             basis : () -> Vector %
 coerce : % -> OutputForm              commutative? : () -> Boolean
 commutator : (%,%) -> %               flexible? : () -> Boolean
 hash : % -> SingleInteger             jacobiIdentity? : () -> Boolean
 jordanAdmissible? : () -> Boolean     jordanAlgebra? : () -> Boolean
 latex : % -> String                   leftAlternative? : () -> Boolean
 leftNorm : % -> Fraction Integer      leftTrace : % -> Fraction Integer
 lieAdmissible? : () -> Boolean        lieAlgebra? : () -> Boolean
 powerAssociative? : () -> Boolean     rank : () -> PositiveInteger
 recip : % -> Union(%,"failed")        rightAlternative? : () -> Boolean
 rightNorm : % -> Fraction Integer     sample : () -> %
 someBasis : () -> Vector %            unit : () -> Union(%,"failed")
 zero? : % -> Boolean                  ?~=? : (%,%) -> Boolean
 ?*? : (NonNegativeInteger,%) -> %
 ?*? : (SquareMatrix(4,Fraction Integer),%) -> %
 apply : (Matrix Fraction Integer,%) -> %
 associatorDependence : () -> List Vector Fraction Integer
 coerce : Vector Fraction Integer -> %
 conditionsForIdempotents : Vector % -> List Polynomial Fraction Integer
 conditionsForIdempotents : () -> List Polynomial Fraction Integer
 convert : % -> Vector Fraction Integer
 convert : Vector Fraction Integer -> %
 coordinates : (Vector %,Vector %) -> Matrix Fraction Integer
 coordinates : Vector % -> Matrix Fraction Integer
 coordinates : (%,Vector %) -> Vector Fraction Integer
 coordinates : % -> Vector Fraction Integer
 ?.? : (%,Integer) -> Fraction Integer
 leftCharacteristicPolynomial : % -> SparseUnivariatePolynomial Fraction Integer
 leftDiscriminant : Vector % -> Fraction Integer
 leftDiscriminant : () -> Fraction Integer
 leftMinimalPolynomial : % -> SparseUnivariatePolynomial Fraction Integer
 leftPower : (%,PositiveInteger) -> %
 leftRankPolynomial : () -> SparseUnivariatePolynomial Polynomial Fraction Integer
 leftRecip : % -> Union(%,"failed")
 leftRegularRepresentation : (%,Vector %) -> Matrix Fraction Integer
 leftRegularRepresentation : % -> Matrix Fraction Integer
 leftTraceMatrix : Vector % -> Matrix Fraction Integer
 leftTraceMatrix : () -> Matrix Fraction Integer
 leftUnit : () -> Union(%,"failed")
 leftUnits : () -> Union(Record(particular: %,basis: List %),"failed")
 noncommutativeJordanAlgebra? : () -> Boolean
 plenaryPower : (%,PositiveInteger) -> %
 represents : (Vector Fraction Integer,Vector %) -> %
 represents : Vector Fraction Integer -> %
 rightCharacteristicPolynomial : % -> SparseUnivariatePolynomial Fraction Integer
 rightDiscriminant : Vector % -> Fraction Integer
 rightDiscriminant : () -> Fraction Integer
 rightMinimalPolynomial : % -> SparseUnivariatePolynomial Fraction Integer
 rightPower : (%,PositiveInteger) -> %
 rightRankPolynomial : () -> SparseUnivariatePolynomial Polynomial Fraction Integer
 rightRecip : % -> Union(%,"failed")
 rightRegularRepresentation : (%,Vector %) -> Matrix Fraction Integer
 rightRegularRepresentation : % -> Matrix Fraction Integer
 rightTrace : % -> Fraction Integer
 rightTraceMatrix : Vector % -> Matrix Fraction Integer
 rightTraceMatrix : () -> Matrix Fraction Integer
 rightUnit : () -> Union(%,"failed")
 rightUnits : () -> Union(Record(particular: %,basis: List %),"failed")
 structuralConstants : Vector % -> Vector Matrix Fraction Integer
 structuralConstants : () -> Vector Matrix Fraction Integer
 subtractIfCan : (%,%) -> Union(%,"failed")

axiom
a:=basis()$V

(7)

Type: Vector AlgebraGivenByStructuralConstants?(Fraction Integer,4,[e,i,j,k]?,[MATRIX,MATRIX,MATRIX,MATRIX]?)

axiom
matrix([[(a.i * a.j)::OutputForm for j in 1..4] for i in 1..4])$OutputForm

(8)

Type: OutputForm?

axiom
leftUnit()$V

(9)

Type: Union(AlgebraGivenByStructuralConstants?(Fraction Integer,4,[e,i,j,k]?,[MATRIX,MATRIX,MATRIX,MATRIX]?),...)

axiomrightUnit()$V
   this algebra has no right unit

(10)

Type: Union("failed",...)

axiomalternative?()$V
   algebra is not left alternative

(11)

Type: Boolean

axiomleftAlternative?()$V
   algebra is not left alternative

(12)

Type: Boolean

axiomrightAlternative?()$V
   algebra is not right alternative

(13)

Type: Boolean

axiomassociative?()$V
   algebra is not associative

(14)

Type: Boolean

axiomantiAssociative?()$V
   algebra is not anti-associative

(15)

Type: Boolean

axiom--powerAssociative?()$V
commutative?()$V
   algebra is not commutative

(16)

Type: Boolean

axiomjordanAlgebra?()$V
   algebra is not commutative
   this is not a Jordan algebra

(17)

Type: Boolean

axiomjordanAdmissible?()$V
   algebra is not Jordan admissible

(18)

Type: Boolean

axiomnoncommutativeJordanAlgebra?()$V
   algebra is not flexible
   this is not a noncommutative Jordan algebra, as it is not flexible

(19)

Type: Boolean

axiomlieAlgebra?()$V
   algebra is not anti-commutative
   this is not a Lie algebra

(20)

Type: Boolean

axiomlieAdmissible?()$V
   algebra is not Lie admissible

(21)

Type: Boolean

axiomjacobiIdentity?()$V
   Jacobi identity does not hold

(22)

Type: Boolean

(ee=e)$V (ii=e)$V (jj=e)$V (kk=e)$V (ei=i)$V (ej=j)$V (ek=k)$V (ie=-i)$V (je=-j)$V (ke=-k)$V (ij=k)$V (ji=-k)$V (ki=j)$V (ik=-j)$V (jk=i)$V (kj=-i)$V