Re: [Axiom-developer] RE: learning in public

[William Sit]

Hi Bertfried:

You may already be aware of this, but that is not obvious from your discussions.
So, just in case.

Regarding Clifford Algebra etc, Axiom already has some built in packages (unless
otherwise indicated, all done by Stephen Watt before 1991).

QFORM    QuadraticForm in clifford.spad
CLIF     Clifford Algebra in clifford.spad 
         (over any field K and quadratic form on K^n)
GRMOD    Graded Module in carten.spad
GRALG    Graded Algebra in carten.spad
CARTEN   CartesianTensor in carten.spad (tensor algebra)
CARTEN2  CartesianTensorFunction2 in carten.spad
SYMFUNC  SymmetricFunctions in efstruc.spad (by Manuel Bronstein)
PRTITION Partition in prtition.spd (by William Burge)
SYMPOLY  SymmetryPolynomial in prtition.spad (by Wiliam Burge)
BMODULE  BiModule in catdef.spad (probably by Watt also)

Granted, this may not be enough for your purpose, but surely they point to the
way this WAS done and may make additional structures easier to build.


It is also possible that other people may have unpublished implementation of
structures like Hopf algebra, Shuffle Algebra, Grassmann Algebra or Spin Algebra
already (perhaps Larry Lambe or Michel Petitot? I am fairly sure Petitot has
implemented Shuffle Algebra, which is close to Hopf algebra).

> Formal definition
> 
> ... bla bla ...
>
> such that the following diagram commutes:
> 
>                V ----> C(q)
>                |     /
>                |    / Exists and is unique
>                |   /
>                 v  v
>                A
> 
> 
>> Indeed, this construction is categorial, but not algorithmic. Hence almost
>> useless for computer algebra.

On the contrary, such universal objects are the key to construction of free
objects and morphisms in the category (examples are vector spaces where you can
define morphisms by specifying only values on a basis; but also works for higher
algebras such as free shuffle algebra) and the non-free ones are done by forming
quotients.

> Look at the (anti)commutation of two grade one elements, its symmetric by
> construction, so
> 
>         a (x) b + b (x) a = 2g(a,b)
> 
> has to have a symmetric bilinear form. To generalize this, you need an
> _order relation_ on the grade one elements, to decide if you expand for
> a (x) b (or for b (x) a), say we take lexicographic order and lets assume
> e_i < e_j if i<j. Then one can generalize. However, one has to deal with
> the effects with the linear ordering of teh bases (grade one space), this
> is quite a peculiar and problemetic thing to do!

CliffordAlgebra(n,K,Q) in Axiom is a domain constructor, where n is dimension of
V= K^n, K a field, and Q a quadratic form on V, is defined using the canonical
basis e(i), i=1..n on V (but it should be easy to modify the source to let this
basis be a parameter linked to Q) with identities: e(i)*e(j) = - e(j)*e(i) and
e(i)*e(i) = Q(e(i)). This gives rise to a corresponding canonical basis for the
Clifford Algebra, which has dimension 2^n (all products formed from any subset
of the vector space basis).

To have different order relation or grading (filtration), it would be best to
modify the source to allow an additional parameter or two. For example, in
polynomial algebra, different term ordering can be done in GDMP (Generalized
Distributed Multivariate Polynomial), which is a domain constructor by modifying
DMP or HDMP. A CliffordAlgebra CATEGORY is needed if the REPRESENTATION of the
SAME (mathematically) algebra changes (or when the code for the basic operations
will be changed; for example if there are more efficient algortihms when the
points are ordered). For polynomial algebra, a category is created so that
different representations (DMP, POLY, SMP) can be used.

> My Problem:

> Still I am not able to envision a data structure complex enough to hold
> the problem and simple enough not to make everything totally unmanagable.
> A good start would be to write an AXIOM package for supersymmetric
> bi-commutative Hopf algebras, if thats done, cliffordization is relatively
> easy to implement.

I suggest starting with generalizing the present CliffordAlgebra to include in
order:
(1) arbitrary symmetric bilinear form (may need SymmetricAlgebra, but may be not
by using SYMPOLY)
(2) grading (and/or order) (using GRALG and GRMOD)
(3) bimodule structure using BIMODULE

Then when needed, create Hopf Algebra based on this experience.

BTW, I am also "learning in public" (but not as diligent as Tim).

William
-- 
William Sit
Department of Mathematics..............Email: address@hidden
City College of New York..........................Tel: 212-650-5179
Convent Ave at West 138th Street..................Fax: 212-862-0004
New York, NY 10031............Axiom, A Scientific Computation Sytem
USA..........................http://www.nongnu.org/axiom/index.html