[Next] [Contents]

## `Dom::AlgebraWithBasis_Table` -- Algebra on a basis

#### Introduction

`Dom::AlgebraWithBasis_Table``(Ring, Basis, <, BasisMonoidMult=mult> <, BasisMult=mult>) <BasisOne=one>`

Creates a domain for the algebra over the ring `Ring` with linear basis elements in the domain `Basis` and product defined by the procedure `mult`.

This domain is deprecated, and will be removed in the near future; please use instead `Dom::FreeModule` in combination with `Cat::AlgebraWithBasis`, as described in the `demonstration`.

#### Details

- Internally, an element `e` of this domain is represented by a table of the form `table(b1=c1, b2=c2, ... )`, where `c1` is the is the coefficient of `e` on the basis element `b`. The advantage of this representation is that the basis can consist of any MuPAD object; on the other hand it is not very fast.

#### Categories

`Cat::Module(Ring)` `Cat::Module(Ring)`

#### Related Domains

`Dom::FreeModuleTable`

#### Entries

one

the identity of the algebra

#### Method _mult: product

- `_mult(dom a1...)`

- Returns the product of `a1`
- This method overloads the function `_mult`.

#### Method _invert: inverse

- `_invert(dom a)`

- Returns the inverse of a or `FAIL`.
- This method overloads the function `_invert`.

#### Method expr: conversion into expressions

- `expr(dom a)`

- Returns an expression representing `a`.

#### Example 1

We construct the algebra of the symmetric group on `4` elements:

    >> S4 := Dom::SymmetricGroup(4):
       A4 := Dom::AlgebraWithBasis_Table(Dom::Rational, S4)

          Dom::AlgebraWithBasis_Table(Dom::Rational,

             Dom::SymmetricGroup(4))

Now, we create some elements of `A4`, and do some computations with them:

    >> a := A4::one;
       a + a;
       A4(S4([1,2,3,4])) - A4::one;
       a := A4(S4([2,3,4,1]));
       a^2;
       a^4;
       a := 3 * a + 4/5 * A4(S4([1,3,2,4]))

                                  B([1, 2, 3, 4])

                                 2 B([1, 2, 3, 4])

                                         0

                                  B([2, 3, 4, 1])

                                  B([3, 4, 1, 2])

                                  B([1, 2, 3, 4])

                      3 B([2, 3, 4, 1]) + 4/5 B([1, 3, 2, 4])

Now we demonstrate how to do some basic linear algebra, say to find the minimal polynomial of an element:

    >> A4 := Dom::AlgebraWithBasis_Table(Dom::ExpressionField(), S4):
       a := A4(S4([2,3,1,4])):
       x * a;
       b := a^0 + x1*a^1 + x2*a^2 + x3*a^3 + x4*a^4;
       solve([coeff(b)], [x1,x2,x3,x4])

                                 x B([2, 3, 1, 4])

          (x3 + 1) B([1, 2, 3, 4]) + (x1 + x4) B([2, 3, 1, 4]) +

             x2 B([3, 1, 2, 4])

                           {[x1 = -x4, x2 = 0, x3 = -1]}

#### Example 2

Here is another direct construction for the algebra of the symmetric group on `4` elements:

    >> SymmetricGroupAlgebra :=
       proc(n: Type::PosInt)
       begin
           Dom::AlgebraWithBasis_Table
           (Dom::ExpressionField(),
            combinat::permutations,
            BasisOne = [$1..n],
            BasisMonoidMult = combinat::permutations::_mult):
       end_proc:
       A4 := SymmetricGroupAlgebra(4):

We can use it as the previous one:

    >> a := A4([2,1,3,4]);
       a^2 * x + (a*y)^3 + A4::one + A4([3,2,1,4]) * z

                                  B([2, 1, 3, 4])

                                     3
          (x + 1) B([1, 2, 3, 4]) + y  B([2, 1, 3, 4]) +

             z B([3, 2, 1, 4])

#### Example 3

This domain is deprecated, so here is the recommended way for defining the algebra of the symmetric group on `4` elements:

    >> domain SymmetricGroupAlgebra(n: Type::NonNegInt)
           inherits Dom::FreeModule(Dom::ExpressionField(), combinat::permutations);
           category Cat::AlgebraWithBasis(Dom::ExpressionField());

           one := dom::term([$1..n]);
           mult2Basis := dom::term @ combinat::permutations::_mult;
       end_domain;
       A4 := SymmetricGroupAlgebra(4):

We can use it as the previous one:

    >> a := A4([2,1,3,4]);
       a^2 * x + (a*y)^3 + A4::one + A4([3,2,1,4]) * z

                                  B([2, 1, 3, 4])

                               3
          z B([3, 2, 1, 4]) + y  B([2, 1, 3, 4]) +

             (x + 1) B([1, 2, 3, 4])

#### Super-Domain

`Dom::FreeModuleTable`

[Next] [Contents]

MuPAD Combinat, an open source algebraic combinatorics package