Re: [Axiom-developer] GrassmannAlgebra domain

[Martin Baker]

On Thursday 10 Dec 2009 20:03:34 Tim Daly wrote:
> Well Axiom is all about organizing the algebra into hierarchical
> categories where
> each category build on prior ones.
> 
> Is there a natural hierarchy of these algebras? If so, I think it is
> important to
> extract that hierarchy, define the operations at the category level even
> if they
> do not have an implementation there, and layer the categories naturally.
> 
> I would start by just writing the Cayley-Dickson, Spinor, Hopf, and Tensor
> domain definitions (without implementations), find the common operations,
> collect them into a category, and inherit from that category.
> 
> I know a little bit about Clifford algebra and I'm reading the Grassman
> algebra book now but I do not know enough to say anything about what
> would be common among the various algebras.
> 
> Tim
> 

Tim,

I've been thinking about this although I'm not sure I've had any great 
insights? I don't claim to have any great expertise in the the deeper level 
mathematics myself so I thought I would just write down all the issues that 
occurred to me in case you or anyone had any ideas.

By the way, I'm still working on Grassman/Clifford algebra code here:
file:///home/master/euclid/maths/standards/program/clifford/

Although these algebras have common operations like addition, multiplication 
(exterior, inner...) and their inverses, they would be coded differently so I 
can't see now they would make use of common code in categories, or inherit 
from categories, in such a way to simplify the relationships between these 
related algebras.

In many cases we might want the algebra to be a module over algebras with one 
of the multiplications which is:

    * associative.
    * possibly commutative or non-commutative.
    * distributive over addition.

Although not all the multiplications in a given algebra/structure would have 
these properties.  We may want to have a module over an algebra with multiple 
multiplications, such as Grassmann/Clifford algebra itself, so we need a way 
to choose the multiplication which forms the module.

In addition to these requirements we can't take this algebra family in 
isolation but they need to interwork with related algebra families, It would 
be good if these algebra families need to appear on the category and domain 
graph here:
http://www.axiom-developer.org/axiom-website/dotabb.html
(its not complicated enough yet!)

Relationship to Other Algebras
-----------------------------------------
Since there are many accidental and not so accidental isomorphisms between 
Clifford algebras and Cayley-Dickson (complex, quaternion and octonion), 
spinor, Hopf and tensor Algebras, for instance: see tables in [Pertti 
Lounesto, Clifford Algebras and Spinors, Second Edition].

Do we need lots of coerce functions? Or can we represent some of these by 
choosing a suitable category hierarchy?

Are there common functions between these algebras that could be separated out 
into categories?

How to Choose a Hierarchy
--------------------------------------
How do we go about designing a category hierarchy structure? How does this 
relate to the way that algebras are created in mathematics?

By applying constraints?
--------------------------------
We could start with tensor algebra and represent these as a subalgebra by 
applying some constraint (like Pauli matrices). Is there a way to get a 
subalgebra in SPAD by applying constraints?

There is already an issue with working with sparse Clifford algebras and this 
approach would seem to make the issue of efficient coding and storage of 
variables even worse.

Also this would seem to go away from point of having a separate Clifford 
algebra implementation and so I don't think this approach is really practical?

By using isomorphisms?
----------------------------------
There are lots of isomorphisms between the algebra families, is it practical 
to treat say complex numbers or quaternions as special cases of a Clifford 
algebra? Probably not as complex numbers are used widely and need to be 
efficient.

Generating using semidirect product and so on?
-----------------------------------------------------------------
Since it does not seem very efficient to use the category hierarchy to create 
subalgebras from more general algebras, can we do the reverse and build up 
more complex algebras from simpler ones?

For instance could we generate the quaternions from complex numbers whose 
elements were themselves complex numbers? Or could we generate quaternions 
from a semidirect product of two complex number algebras?

As SPAD stands at the moment I can't see how this is possible? We cant even 
create complex numbers whose elements are themselves complex numbers:

(1) -> a:= complex(complex(1,2),complex(3,4))
   There are 1 exposed and 0 unexposed library operations named complex
      having 2 argument(s) but none was determined to be applicable.
      Use HyperDoc Browse, or issue
                             )display op complex
      to learn more about the available operations. Perhaps
      package-calling the operation or using coercions on the arguments
      will allow you to apply the operation.

   Cannot find a definition or applicable library operation named
      complex with argument type(s)
                              Complex(Integer)
                              Complex(Integer)

      Perhaps you should use "@" to indicate the required return type,
      or "$" to specify which version of the function you need.
(1) -> 

What seems to be required is a way to allow the inner and outer complex 
numbers to define a different imaginary operator and to define how they 
interact:

a: Quaternion := complex(%i,complex(%j,1,2),complex(%j,3,4), %k=%i*%j)

Anyhow, at this stage I cannot see how to generate algebras in this way?

Common Functions on these Algebras
----------------------------------------------------
Although I can't see how to how to design a category hierarchy to usefully 
relate these algebra families I can think of some common functions that could 
be applied to these algebras.

This does not concern operations on instances of elements of these algebras 
but operations on the whole algebras, examples of the sort of things that I 
would like to be able to do is:

    * Create a Type consisting of a complex number whose elements are complex 
numbers whose elements are complex numbers, run a function to check if this 
algebra is associative.
    * run a function to check if the above algebra is isomorphic to octonions.
    * Start with a Clifford algebra based on 3 dimensional space, add another 
dimension that squares to +ve, add another dimension that squares to -ve, in 
the plane of these extra dimensions rotate by 45 degrees.
    * Orthogonalise a basis.
    * Take a semidirect product of two complex number algebras, check if this 
is isomorphic to quaternions.
    * Take an even subalgebra of a Clifford algebra based on 3D Euclidean 
space, check if this is isomorphic to quaternions.
    * Convert to reciprocal basis
    * Convert between Clifford and Grassmann basis.

So none of these operations involves creating an element (a representation) in 
these algebras, they are all functions which operate on the algebra (Type) as 
a whole. So what I was thinking of is an interface (category) that could be 
applied to many algebras (domains) to provide a common set of functions like:

    * addDimension(squaresTo)
    * isAssociative?()
    * isIsomorphic?(Type)
    * rotateDimensions(plane)
    * directProduct(Type,Type)
    * semidirectProduct(Type,Type,function)
    * evenSubalgebra()
    * constrainToOrthogonal()

In the case of Clifford algebras these functions would be implemented to 
operate purely on the bilinear form, in the case of other algebras they would 
be implemented to operate on what determines that algebra.

Martin Baker