Help For:

This package allows the user to perform a variety of algebraic computations in the Clifford algebra Cl(V,B) on a real vector space V endowed with a bilinear form B. The dimension of V is must be between 1 and 9, while the bilinear form B may be undefined, numeric, symbolic, symmetric, or antisymmetric. In fact, in most computations the form B doesn't even have to be assigned in which case coefficients of B appear in the Maple output. To use any function from the package, load the package using the command with(Cliff5).

Upon loading the package, default dimension of V is set to 9 (maximum) by assigning value of 9 to the global variable dim_V in the initialization procedure Cliff5[init] . Then, computations can be immediately performed in Cl(V,B) where B is unspecified and dim(V) = 9. This and other environmental variables can be displayed by the procedure Cliff5[CLIFFORD_ENV] . User can change the value of dim_V by assigning a square matrix to B of size n by n, in which case dim_V is assigned value of n and 'CLIFFORD' performs computations in Cl(V,B) assuming that dim(V) = n. Another way to change value of dim_V is to simply assign a positive integer p to dim_V such that 1 <= p <= 9. The value of dim_V is used to determine whether an index larger than dim_V has been entered by the user with parsing done by a procedure Cliff5[cliparse] . Also, when symbolic or mixed, symbolic and numeric, indices are used in Grassmann basis monomials, procedure wedge, which computes the wedge product, suppresses monomial terms in the output of grade higher than dim_V.

In this version, user can select one of two procedures that compute Clifford product of any two multivectors p1, p2 in Cl(B): cmulRS and cmulNUM . Both procedures require that an additional parameter K of type 'name', 'symbol' that is passed on to them from cmul as in cmul(p1,p2,K). Then, the contraction is internally computed with respect to this parameter. Procedure 'cmulRS' uses Rota-Stein cliffordization and is faster for symbolic B. Procedure 'cmulNUM' uses Chevalley's recursice definition of the Clifford product in Cl(B) and is faster when B is numeric. In addition, user can supply his/her own procedure in place of these two under a generic name cmul_user_defined. The current choice is displayed by Cliff5[CLIFFORD_ENV] and is stored in a global variable _default_Clifford_product. See also procedure Cliff5[use] which is used to select the internal Clifford product.

In comparison with release 4, several procedures in this release have been revised to achieve greater speed. Some have obtained new optional features, and some have been revised to save memory. In addition, a new package 'Bigebra' has been added to supplement 'CLIFFORD'. Other supplementary packages that extend abilities of 'CLIFFORD' are 'Cli5plus', 'GTP', and 'Octonion'.

'CLIFFORD' performs computations in Cl(V,B) using Grassmann basis monomials written as Id, e1, e1we2, e1we3we5, etc., with Id denoting the identity element in Cl(V,B). Thus, the fundamental types include Cliff5[`type/cliscalar`] , Cliff5[`type/clibasmon`] , Cliff5[`type/climon'] and Cliff5[`type/clipolynom`] . Computations in Clifford basis with Clifford monomials written as Id, e1, e2, e1 &C e2, &C(e1,e2,e3), etc. can be performed upon loading the supplementary package 'Cli5plus'. Note that the indices of basis monomials range from 1 to 9; symbolic indices as strings of length 1 are also allowed, and can be mixed with numeric indices.

Clifford product in Cl(V,B) is given by the procedure Cliff5[cmul] , while the wedge product is given by the procedure Cliff5[wedge] . For example, to multiply two (Grassmann) monomials or polynomials in Cl(V,B) enter cmul(p1,p2) or p1 &c p2, where p1, p2 are of one of these types: Cliff5[`type/clibasmon`] , Cliff5[`type/climon'] or Cliff5[`type/clipolynom`] . Likewise, the wedge product is entered as wedge(p1,p2) or p1 &w p2. Multiple inputs are also allowed, e.g., cmul(p1,p2,p3,p4), or, &c(p1,p2,p3,p4), or, wedge(p1,p2,p3,p4), or &w(p1,p2,p3,p4). It is also possible to compute with Clifford matrices of Cliff5[`type/climatrix`] and apply various products to the matrix elements. See procedure Cliff5[rmulm] for more help.

'CLIFFORD' uses Claude Chevalley's definition of the Clifford product or one based on Rota-Stein cliffordization technique. For more information, see page for Cliff5[cmul] . All computations performed internally by 'CLIFFORD' are purely symbolic, that is, they do not involve any matrices. While matrices in the regular or spinor representations of Cl(V,B) could be used, 'CLIFFORD' performes operations on strings such as e1we2, e1we3we4, etc. that is, on Grassmann monomials whose type is Cliff5[`type/clibasmon`] .

For more information on a particular 'function' see its help page. In a Maple worksheet, type ?Cliff5,function, or, ?function, at the Maple prompt. It is also possible to access all help pages for 'CLIFFORD' via the Maple browser by typing ?Cliff5 and following links in the browser.

This version includes a global variable _prolevel which is set to its default value of 'false' by the 'CLIFFORD' initialization file Cliff5[init] . When _prolevel=false, all type checking is done and user's input is parsed for errors. This can take considerable time though. User can set _prolevel to 'true' in which case procedure 'cliparse' (see Cliff5[cliparse] ) always returns 'true' and no parsing of user input is done.

There are additional packages available below which extend the 'CLIFFORD' package. They need to be loaded separately and each requires that 'CLIFFORD' be loaded first. Help pages for these packages are available also. For example:

- 'Cli5plus' is a collection of additional procedures; it allows, for example, to use a Clifford basis instead of a Grassmann basis,
- 'Bigebra' is a collection of procedures to compute with coproducts,
- 'GTP' - Graded Tensor Package allows for certain computations in graded tensor products of Clifford algebras,
- 'Octonion' allows for computations with octonions considered as para-vectors in Cl(0,7),

This is how to load the main package and the supplementary packages:

> restart:with(Cliff5);

> version();

To load 'CLIFFORD' and the 'GTP' package type:

> restart:with(Cliff5):with(GTP);

Warning, new definition for init

To load 'CLIFFORD' and the 'Octonion' package, type:

> restart:with(Cliff5):with(Octonion);

Warning, new definition for init

To load 'CLIFFORD' and the 'Cli5plus' package, type:

> restart:with(Cliff5):with(Cli5plus);

Warning, new definition for init

Warning, definitions for type/climon and type/clipolynom now include &C and &C[K]. Type ?cliprod for help.

To load 'CLIFFORD' and the 'Bigebra' package, type:

> restart:with(Cliff5):with(Bigebra);

Warning, new definition for init

Warning, new definition for drop_t

Warning, new definition for gco_d_monom

Warning, new definition for gco_monom

> CLIFFORD_ENV();

>>> Global variables defined in Cliff5[init] are now available and have these values: <<<

************* Start *************

dim_V = 9

_default_Clifford_product = cmulRS

_prolevel = false

_shortcut_in_minimalideal = true

_shortcut_in_Kfield = true

_shortcut_in_spinorKbasis = true

_shortcut_in_spinorKrepr = true

_warnings_flag = true

_scalartypes = {numeric, indexed, complex, RootOf, `^`, rational, function, constant, mathfunc}

_quatbasis = [[Id, e3we2, e1we3, e2we1], {`Maple has assigned qi:=-e2we3, qj:=e1we3, qk:=-e1we2`}]

************* End *************

>>> Global variables defined in Bigebra[init] are now available and have these values:  <<<

_CLIENV[_SILENT] = false

_CLIENV[_QDEF_PREFACTOR] = -1

************* End *************

>

Listing of available procedures in 'CLIFFORD':

&c - infix form of Clifford product
Bsignature - to display signature of the current form Q
CLIFFORD_ENV - to display current values of environmental variables in the worksheet
Kfield - to find a field K of the spinor representation of Cl(Q)
LC - left contraction in Cl(B)
LCQ - left contraction in CL(Q)
RC - right contraction in Cl(B)
RCQ - right contrcation in Cl(Q)
RHnumber - Radon-Hurwitz function
adfmatrix - add matrices over double fields
all_sigs - display all signatures of Clifford algebras
beta_minus - scalar product in S = Cl(Q)f related to reversion
beta_plus - scalar product in S = Cl(Q)f related to conjugation
buildm - finding a left-regular representation
bygrade - sorting by grade
c_conjug - complex conjugation in complexified Cl(B)
cbasis - create a canonical (Grassmann) basis in Cl(B)
cdfmatrix - create a matrix over a double field from two matrices in a list
cexp - Clifford exponentiation in Cl(B)
cexpQ - Clifford exponentiation in Cl(Q)
cinv - inverse in Clifford algebra Cl(B)
clibilinear - making a user-defined procedure bilinear or multilinear
clicollect - collecting with respect to Clifford basis monomials
clidata - to find basis information about Cl(Q) for the given signature
clilinear - making a user-defined procedure linear
climinpoly - finding minimal polynomial of any Clifford polynomial
cliparse - checking user input for syntax errors
cliremove - deleting some parts of a string (internal use mostly)
clisolve - solves equations in Cl(V,B)
clisort - sorting with respect to Clifford basis monomials
cliterms - finding Clifford basis monomials in the given polynomial
cmulNUM - Clifford multiplication of two multivectors using Chevalley's recursive definition
cmulQ - Clifford multiplication in Cl(Q) with ampersand form &cQ
cmulRS - Clifford multiplication of two multivectors using Rota-Stein cliffordization technique
cmul - Clifford multiplication in Cl(B) with ampersand form &c
cmulgen - generic (dummy) Clifford product
cmul_user_defined - dummy (user defined) Clifford product
cocycle - finding element x in Cl(V,B) that connects two given polynomials
commutingelements - finding commuting basis monomials that square to 1
conjugation - conjugation in Cl(B)
convert/dfmatrix - converts a list of two matrices into a matrix with entries in a double field
convert/mlist - converting matrix entries to a list
convert/str_to_int - converting numerical strings to digits
ddfmatrix - decompose a matrix over a double field into a list of two matrices
diagonalize - procedure to diagonalize a matrix
displayid - display algebra unit as Id in the given polynomial
extract - extract indices from the given basis monomial (mostly internal use)
factoridempotent - factor an idempotent into a product of simple idempotents
find1str - finds locations of string of length one in another string (mostly internal use)
findbasis - finding a basis in a linear span
gradeinv - grade involution in Cl(B)
init - initialization procedure for the 'CLIFFORD' package
intro - this help page
isVahlenmatrix - procedure checking if a 2 x 2 matrix is a Vahlen matrix
isproduct - checking if the given polynomial is a product of 1-vectors
makealiases - alias basis monomials for faster entry
makeclibasmon - makes a Grassmann monomial with the given indices
matKrepr - matrix representation of Cl(Q) using pre-stored matrices
maxgrade - finding the largest grade in the given polynomial
maxindex - finding the largest index in the given polynomial
mdfmatrix - multiply two matrices over a double field
minimalideal - finding a real basis in a left or right minimal ideal
ord - finding location of indices in a monomial string (internal use)
permsign - computes sign of a permutation
pseudodet - computing a pseudodeterminant of a martix
q_conjug - quaternion conjugation
qdisplay - displaying quaternion in the standard basis {1, qi, qj, qk}
qinv - quaternionic inverse
qmul - quaternionic multiplication with the infix form &q
&qm - unfix form to multiply quaternionic matrices
qnorm - quaternionic norm
reorder - reorder monomial indices in a polynomial or monomial
reversion - reversion in Cl(B)
rmulm - various ways to multiply matrices with entries in Cl(B)
&cm - multiplication of Clifford matrices with the Clifford product &c applied to matrix entries
&cQm - multiplication of Clifford matrices with the Clifford product &cQ applied to matrix entries
&om - multiplication of Clifford matrices with the octonionic product omul (ampersand form &om ) applied to matrix entries
&qm - multiplication of quaternionic matrices with the quaternion product &q applied to matrix entries
&rm - multiplication of Clifford matrices with a user-defined product &r applied to matrix entries
&r - a possibly non-commutative user-defined product applied to entries in Cl(B)
&wm - multiplication of matrices with the wedge product &w applied to matrix entries
rot3d - rotation in 3 dimensions with quaternions
scalarpart - finding the scalar part in a polynomial
sexp - exponentiation in Cl(B) modulo minimal polynomial
specify_constants - to specify new constants by the user
spinorKbasis - finding a basis in a minimal (spinor) ideal over a field K
spinorKrepr - finding a matrix over K in spinor representation of Cl(Q)
squaremodf - computing the square of an element in an ideal Cl(Q)f or fCl(Q) modulo f
subs_clipolynom - substitution of a Clifford polynomial into a polynomial in one variable
useproduct - procedure that allows user to switch between these Clifford products: cmulRS , cmulNUM , cmulgen , or cmul_user_defined
vectorpart - finding a k-vector part in a polynomial
version - display current version of the package and copyrights
wedge - wedge/exterior multiplication in Cl(B)
&w - infix form of the exterior product
wexp - wedge/exterior exponentiation in Cl(B)

To see code of any of these procedures, follow the example below.

Types in 'CLIFFORD':

type/antisymmatrix - an antisymmetric matrix
type/clibasmon - a basis monomial in Cl(B)
type/climatrix - matrix of with entries in Cl(B)
type/climon - a monomial in Cl(B)
type/clipolynom - a polynomial in Cl(B)
type/cliprod - basis monomial in a Clifford basis, used in the 'Cli5plus' package described below
type/cliscalar - a scalar in Cl(B)
type/dfmatrix - matrix over a double field
type/diagmatrix - a diagonal matrix
type/evenelement - even element in Cl(B)
type/fieldelement - a basis element in Cl(Q)f or fCl(Q) which is in some field K
type/gencomplex - a generalized complex number
type/genquatbasis - a generalized quaternion basis
type/genquaternion - a generalized quaternion
type/idempotent - an idempotent element in Cl(B)
type/nilpotent - a nilpotent element in Cl(B)
type/oddelement - an odd element in Cl(B)
type/primitiveidemp - a primitive idempotent in Cl(B)
type/purequatbasis - a basis for pure quaternions
type/quaternion - quaternion type
type/symmatrix - a symmetric matrix
type/tensorprod - place holders of tensor products

'GTP' - Graded Tensor Product of Clifford Algebras

Procedures in 'GTP':

cmulB - Clifford product in Cl(B) when B is specified as the third argument (may be also used in the package 'CLIFFORD' upon reading in the 'GTP' package)
gbasis - standard basis in a graded tensor product
gcollect - collection or terms in a graded tensor product
gprod - product of basis monomials in a graded tensor product
grade - grade of an element in a graded tensor product
gradedprod - product of polynomials in a graded tensor product
init - initialization procedure for 'GTP' (no help page)
tensorrank - gives rank of a tensor
&t - tensor product

Types in 'GTP':

type/gradedeven - even element in GTP
type/gradedodd - odd element in GTP
type/gradedmonom - basis monomial in GTP
type/gradedpolynom - a polynomial in GTP

'Octonion' - Package for Computations with Octonions

Procedures in 'Octonion':

Phi - associative 3-form

&om - octonionic multiplication applied to matrix entries (procedure from 'CLIFFORD')
associator - associator of three octonions
commutator - commutator of two octonions
def_omultable - procedure to define an octonion multiplication table different than a default one
init - initialization procedure for 'Octonion'
o_conjug - octonionic conjugation
oinv - octonionic inverse
omul - octonionic non-associative multiplication with infix form `&o`
omultable - procedure that displays current octonionic multiplication table
onorm - octonionic norm
oversion - displays current version of the package
purevectorpart - pure vector part of an octonion
realpart - real part of an octonion

Types in 'Octonion':

type/Fano_triples - type Fano triples [needed to define octonionic multiplication using the Fano plane concepts]
type/octonion - type 'octonion'

'Cli5plus' - Package that extends certain functions from 'CLIFFORD'

Procedures in 'Cli5plus':

&dw - dotted wedge
LCbig - procedure that extends left contraction LC from 'CLIFFORD'
RCbig - procedure that extends right contraction procedure RC from 'CLIFFORD'

clibasis - procedure that defines a Clifford basis consisting of Clifford monomials, e.g., e1 &C e2, &C(e1,e2,e3), etc.
clieval - procedure that converts polynomials in Cl(B) from the Clifford basis to the Grassmann basis
cliexpand - procedure that converts polynomials in Cl(B) from the Grassmann basis to the Clifford basis
climul - procedure that extends Clifford product cmul to polynomials expressed in terms of the Clifford basis
clirev - procedure that extends reversion to polynomials expressed in terms of the Clifford basis
convert/dwedge_to_wedge - procedure that converts from the undotted wedge basis to the dotted wedge basis
convert/wedge_to_dwedge - procedure that converts from the dotted wedge basis to the undotted wedge basis
dottedcbasis - procedure that returns a dotted wedge basis for Cl(B)
dwedge - dotted wedge procedure
init - initialization procedure for 'Cli5plus'
makeclialiases - defines aliases for Clifford basis monomials, for example, e1 &C e2 will be aliased as e12, etc.

'Bigebra' - Package for computations with products and co-prodocts:

Procedures in 'Bigebra':

&cco - Clifford co-product
&gco - Grassmann co-product
&gpl_co -- Grassmann-Plücker co-product acting on hyperplanes in Plücker coordinatization.
&map - maps a product onto a tensor polynomial
&v - the vee (meet) product
EV - the evaluation map
VERSION - displays version of 'Bigebra'
bracket - the bracket of Peano space
contract - contraction of adjacent slots in tensor
define - partially patched version of Maple V Rel. 5.1 'define'
drop_t - drops the tensor symbol from tensors of rank one
gantipode - the antipode map for Grassmann Hopf algebra
gco_unit - Grassmann co-unit
gswitch - graded switch of tensor slots
help - the main help page for 'Bigebra'
init - 'Bigebra' initialization procedure
linop - defines a linear operator on /\ V
linop2 - defines a linear operator on /\V x /\V
make_BI_Id - initialize Clifford co-product
mapop - maps a linear operator from End /\V onto tensor slots
mapop2 - maps a linear operator from End (/\ V &t /\ V) onto two tensor slots
meet - the meet (vee) product
pairing - computes pairing w.r.t. a bilinear form B
peek - picks elements from tensor slots
poke - puts elements into tensor slots
remove_eq - helper function that removes tautologies from equation sets
switch - switch tensor slots
tcollect - collects coefficients of a tensor polynomial
tsolve1 - solves n --> 1 equations for endomorphisms

Types in 'Bigebra':

type/tensorbasmonom - new type
type/tensormonom - new type
type/tensorpolynom - new type

Sample code:

> restart:with(Cliff5):
interface(verboseproc=3):

> print(`type/clipolynom`);

>

See Also: Cliff5[makealiases] , Cliff5[init] , Cliff5[cbasis] , Cliff5[version]

(c) Copyright October 8, 1995, by Rafal Ablamowicz & Bertfried Fauser, all rights reserved.
Last modified: December 26, 2001, RA/BF.