4.15.1.2 A generic Clifford algebra

A generic Clifford algebra, i.e. a 2^n dimensional algebra with generators e_k satisfying the identities e~i e~j + e~j e~i = M(i, j) + M(j, i) for some bilinear form (metric) M(i, j), which may be non-symmetric (see arXiv:math.QA/9911180) and contain symbolic entries. Such generators are created by the function

    ex clifford_unit(const ex & mu, const ex & metr, unsigned char rl = 0);    

where mu should be a idx (or descendant) class object indexing the generators. Parameter metr defines the metric M(i, j) and can be represented by a square matrix, tensormetric or indexed class object. In fact, any expression either with two free indices or without indices at all is admitted as metr. In the later case an indexed object with two newly created indices with metr as its op(0) will be used. Optional parameter rl allows to distinguish different Clifford algebras, which will commute with each other.

Note that the call clifford_unit(mu, minkmetric()) creates something very close to dirac_gamma(mu), although dirac_gamma have more efficient simplification mechanism. The method clifford::get_metric() returns a metric defining this Clifford number.

If the matrix M(i, j) is in fact symmetric you may prefer to create the Clifford algebra units with a call like that

    ex e = clifford_unit(mu, indexed(M, sy_symm(), i, j));

since this may yield some further automatic simplifications. Again, for a metric defined through a matrix such a symmetry is detected automatically.

Individual generators of a Clifford algebra can be accessed in several ways. For example

{
    ... 
    idx i(symbol("i"), 4);
    realsymbol s("s");
    ex M = diag_matrix(lst(1, -1, 0, s));
    ex e = clifford_unit(i, M);
    ex e0 = e.subs(i == 0);
    ex e1 = e.subs(i == 1);
    ex e2 = e.subs(i == 2);
    ex e3 = e.subs(i == 3);
    ...
}

will produce four anti-commuting generators of a Clifford algebra with properties pow(e0, 2) = 1, pow(e1, 2) = -1, pow(e2, 2) = 0 and pow(e3, 2) = s.

A similar effect can be achieved from the function

    ex lst_to_clifford(const ex & v, const ex & mu,  const ex & metr,
                       unsigned char rl = 0);
    ex lst_to_clifford(const ex & v, const ex & e);

which converts a list or vector ‘v = (v~0, v~1, ..., v~n)’ into the Clifford number ‘v~0 e.0 + v~1 e.1 + ... + v~n e.n’ with ‘e.k’ directly supplied in the second form of the procedure. In the first form the Clifford unit ‘e.k’ is generated by the call of clifford_unit(mu, metr, rl). If the number of components supplied by v exceeds the dimensionality of the Clifford unit e by 1 then function lst_to_clifford() uses the following pseudo-vector representation: ‘v~0 ONE + v~1 e.0 + v~2 e.1 + ... + v~[n+1] e.n’

The previous code may be rewritten with the help of lst_to_clifford() as follows

{
    ...
    idx i(symbol("i"), 4);
    realsymbol s("s");
    ex M = diag_matrix(lst(1, -1, 0, s));
    ex e0 = lst_to_clifford(lst(1, 0, 0, 0), i, M);
    ex e1 = lst_to_clifford(lst(0, 1, 0, 0), i, M);
    ex e2 = lst_to_clifford(lst(0, 0, 1, 0), i, M);
    ex e3 = lst_to_clifford(lst(0, 0, 0, 1), i, M);
  ...
}

There is the inverse function

    lst clifford_to_lst(const ex & e, const ex & c, bool algebraic = true);

which takes an expression e and tries to find a list ‘v = (v~0, v~1, ..., v~n)’ such that the expression is either vector ‘e = v~0 c.0 + v~1 c.1 + ... + v~n c.n’ or pseudo-vector ‘v~0 ONE + v~1 e.0 + v~2 e.1 + ... + v~[n+1] e.n’ with respect to the given Clifford units c. Here none of the ‘v~k’ should contain Clifford units c (of course, this may be impossible). This function can use an algebraic method (default) or a symbolic one. With the algebraic method the ‘v~k’ are calculated as ‘(e c.k + c.k e)/pow(c.k, 2)’. If ‘pow(c.k, 2)’ is zero or is not numeric for some ‘k’ then the method will be automatically changed to symbolic. The same effect is obtained by the assignment (algebraic = false) in the procedure call.

There are several functions for (anti-)automorphisms of Clifford algebras:

    ex clifford_prime(const ex & e)
    inline ex clifford_star(const ex & e) { return e.conjugate(); }
    inline ex clifford_bar(const ex & e) { return clifford_prime(e.conjugate()); }

The automorphism of a Clifford algebra clifford_prime() simply changes signs of all Clifford units in the expression. The reversion of a Clifford algebra clifford_star() coincides with the conjugate() method and effectively reverses the order of Clifford units in any product. Finally the main anti-automorphism of a Clifford algebra clifford_bar() is the composition of the previous two, i.e. it makes the reversion and changes signs of all Clifford units in a product. These functions correspond to the notations e', e* and \bar{e} used in Clifford algebra textbooks.

The function

    ex clifford_norm(const ex & e);

calculates the norm of a Clifford number from the expression ||e||^2 = e \bar{e} The inverse of a Clifford expression is returned by the function

    ex clifford_inverse(const ex & e);

which calculates it as e^{-1} = \bar{e}/||e||^2 If ||e||=0 then an exception is raised.

If a Clifford number happens to be a factor of dirac_ONE() then we can convert it to a “real” (non-Clifford) expression by the function

    ex remove_dirac_ONE(const ex & e);

The function canonicalize_clifford() works for a generic Clifford algebra in a similar way as for Dirac gammas.

The next provided function is

    ex clifford_moebius_map(const ex & a, const ex & b, const ex & c,
                            const ex & d, const ex & v, const ex & G,
                            unsigned char rl = 0);
    ex clifford_moebius_map(const ex & M, const ex & v, const ex & G,
                            unsigned char rl = 0);

It takes a list or vector v and makes the Moebius (conformal or linear-fractional) transformation ‘v -> (av+b)/(cv+d)’ defined by the matrix ‘M = [[a, b], [c, d]]’. The parameter G defines the metric of the surrounding (pseudo-)Euclidean space. This can be an indexed object, tensormetric, matrix or a Clifford unit, in the later case the optional parameter rl is ignored even if supplied. Depending from the type of v the returned value of this function is either a vector or a list holding vector's components.

Finally the function

char clifford_max_label(const ex & e, bool ignore_ONE = false);

can detect a presence of Clifford objects in the expression e: if such objects are found it returns the maximal representation_label of them, otherwise -1. The optional parameter ignore_ONE indicates if dirac_ONE objects should be ignored during the search.

LaTeX output for Clifford units looks like \clifford[1]{e}^{{\nu}}, where 1 is the representation_label and \nu is the index of the corresponding unit. This provides a flexible typesetting with a suitable definition of the \clifford command. For example, the definition

    \newcommand{\clifford}[1][]{}

typesets all Clifford units identically, while the alternative definition

    \newcommand{\clifford}[2][]{\ifcase #1 #2\or \tilde{#2} \or \breve{#2} \fi}

prints units with representation_label=0 as e, with representation_label=1 as \tilde{e} and with representation_label=2 as \breve{e}.