Group Algebras

This module implements the category of group algebras for arbitrary groups over arbitrary commutative rings. For details, see sage.categories.algebra_functor.

AUTHOR:

• David Loeffler (2008-08-24): initial version

• Martin Raum (2009-08): update to use new coercion model – see github issue #6670.

• John Palmieri (2011-07): more updates to coercion, categories, etc., group algebras constructed using CombinatorialFreeModule – see github issue #6670.

• Nicolas M. Thiéry (2010-2017), Travis Scrimshaw (2017): generalization to a covariant functorial construction for monoid algebras, and beyond – see e.g. github issue #18700.

class sage.categories.group_algebras.GroupAlgebras(category, *args)

Bases: AlgebrasCategory

The category of group algebras over a given base ring.

EXAMPLES:

sage: C = Groups().Algebras(ZZ); C
Category of group algebras over Integer Ring
sage: C.super_categories()
[Category of hopf algebras with basis over Integer Ring,
 Category of monoid algebras over Integer Ring]

We can also construct this category with:

sage: C is GroupAlgebras(ZZ)
True

Here is how to create the group algebra of a group \(G\):

sage: G = DihedralGroup(5)                                                      # optional - sage.groups
sage: QG = G.algebra(QQ); QG                                                    # optional - sage.groups sage.modules
Algebra of
 Dihedral group of order 10 as a permutation group over Rational Field

and an example of computation:

sage: g = G.an_element(); g                                                     # optional - sage.groups sage.modules
(1,4)(2,3)
sage: (QG.term(g) + 1)**3                                                       # optional - sage.groups sage.modules
4*() + 4*(1,4)(2,3)

Todo

• Check which methods would be better located in Monoid.Algebras or Groups.Finite.Algebras.

class ElementMethods

Bases: object

central_form()

Return self expressed in the canonical basis of the center of the group algebra.

INPUT:

• self – an element of the center of the group algebra

OUTPUT:

• A formal linear combination of the conjugacy class representatives representing its coordinates in the canonical basis of the center. See Groups.Algebras.ParentMethods.center_basis() for details.

Warning

• This method requires the underlying group to have a method conjugacy_classes_representatives (every permutation group has one, thanks GAP!).

• This method does not check that the element is indeed central. Use the method Monoids.Algebras.ElementMethods.is_central() for this purpose.

• This function has a complexity linear in the number of conjugacy classes of the group. One could easily implement a function whose complexity is linear in the size of the support of self.

EXAMPLES:

sage: QS3 = SymmetricGroup(3).algebra(QQ)                               # optional - sage.groups sage.modules
sage: A = QS3([2,3,1]) + QS3([3,1,2])                                   # optional - sage.groups sage.modules
sage: A.central_form()                                                  # optional - sage.groups sage.modules
B[(1,2,3)]
sage: QS4 = SymmetricGroup(4).algebra(QQ)                               # optional - sage.groups sage.modules
sage: B = sum(len(s.cycle_type()) * QS4(s) for s in Permutations(4))    # optional - sage.groups sage.modules
sage: B.central_form()                                                  # optional - sage.groups sage.modules
4*B[()] + 3*B[(1,2)] + 2*B[(1,2)(3,4)] + 2*B[(1,2,3)] + B[(1,2,3,4)]

The following test fails due to a bug involving combinatorial free modules and the coercion system (see github issue #28544):

sage: G = PermutationGroup([[(1,2,3),(4,5)], [(3,4)]])                  # optional - sage.groups sage.modules
sage: QG = GroupAlgebras(QQ).example(G)                                 # optional - sage.groups sage.modules
sage: s = sum(QG.basis())                                               # optional - sage.groups sage.modules
sage: s.central_form()   # not tested                                   # optional - sage.groups sage.modules
B[()] + B[(4,5)] + B[(3,4,5)] + B[(2,3)(4,5)]
+ B[(2,3,4,5)] + B[(1,2)(3,4,5)] + B[(1,2,3,4,5)]

See also

• Groups.Algebras.ParentMethods.center_basis()

• Monoids.Algebras.ElementMethods.is_central()

class ParentMethods

Bases: object

antipode_on_basis(g)

Return the antipode of the element g of the basis.

Each basis element g is group-like, and so has antipode \(g^{-1}\). This method is used to compute the antipode of any element.

EXAMPLES:

sage: A = CyclicPermutationGroup(6).algebra(ZZ); A                      # optional - sage.groups sage.modules
Algebra of
 Cyclic group of order 6 as a permutation group over Integer Ring
sage: g = CyclicPermutationGroup(6).an_element(); g                     # optional - sage.groups sage.modules
(1,2,3,4,5,6)
sage: A.antipode_on_basis(g)                                            # optional - sage.groups sage.modules
(1,6,5,4,3,2)
sage: a = A.an_element(); a                                             # optional - sage.groups sage.modules
() + 3*(1,2,3,4,5,6) + 3*(1,3,5)(2,4,6)
sage: a.antipode()                                                      # optional - sage.groups sage.modules
() + 3*(1,5,3)(2,6,4) + 3*(1,6,5,4,3,2)

center_basis()

Return a basis of the center of the group algebra.

The canonical basis of the center of the group algebra is the family \((f_\sigma)_{\sigma\in C}\), where \(C\) is any collection of representatives of the conjugacy classes of the group, and \(f_\sigma\) is the sum of the elements in the conjugacy class of \(\sigma\).

OUTPUT:

• tuple of elements of self

Warning

• This method requires the underlying group to have a method conjugacy_classes (every permutation group has one, thanks GAP!).

EXAMPLES:

sage: SymmetricGroup(3).algebra(QQ).center_basis()                      # optional - sage.groups sage.modules
((), (2,3) + (1,2) + (1,3), (1,2,3) + (1,3,2))

See also

• Groups.Algebras.ElementMethods.central_form()

• Monoids.Algebras.ElementMethods.is_central()

coproduct_on_basis(g)

Return the coproduct of the element g of the basis.

Each basis element g is group-like. This method is used to compute the coproduct of any element.

EXAMPLES:

sage: A = CyclicPermutationGroup(6).algebra(ZZ); A                      # optional - sage.groups sage.modules
Algebra of
 Cyclic group of order 6 as a permutation group over Integer Ring
sage: g = CyclicPermutationGroup(6).an_element(); g                     # optional - sage.groups sage.modules
(1,2,3,4,5,6)
sage: A.coproduct_on_basis(g)                                           # optional - sage.groups sage.modules
(1,2,3,4,5,6) # (1,2,3,4,5,6)
sage: a = A.an_element(); a                                             # optional - sage.groups sage.modules
() + 3*(1,2,3,4,5,6) + 3*(1,3,5)(2,4,6)
sage: a.coproduct()                                                     # optional - sage.groups sage.modules
() # () + 3*(1,2,3,4,5,6) # (1,2,3,4,5,6) + 3*(1,3,5)(2,4,6) # (1,3,5)(2,4,6)

counit(x)

Return the counit of the element x of the group algebra.

This is the sum of all coefficients of x with respect to the standard basis of the group algebra.

EXAMPLES:

sage: A = CyclicPermutationGroup(6).algebra(ZZ); A                      # optional - sage.groups sage.modules
Algebra of
 Cyclic group of order 6 as a permutation group over Integer Ring
sage: a = A.an_element(); a                                             # optional - sage.groups sage.modules
() + 3*(1,2,3,4,5,6) + 3*(1,3,5)(2,4,6)
sage: a.counit()                                                        # optional - sage.groups sage.modules
7

counit_on_basis(g)

Return the counit of the element g of the basis.

Each basis element g is group-like, and so has counit \(1\). This method is used to compute the counit of any element.

EXAMPLES:

sage: A = CyclicPermutationGroup(6).algebra(ZZ); A                      # optional - sage.groups sage.modules
Algebra of
 Cyclic group of order 6 as a permutation group over Integer Ring
sage: g = CyclicPermutationGroup(6).an_element(); g                     # optional - sage.groups sage.modules
(1,2,3,4,5,6)
sage: A.counit_on_basis(g)                                              # optional - sage.groups sage.modules
1

group()

Return the underlying group of the group algebra.

EXAMPLES:

sage: GroupAlgebras(QQ).example(GL(3, GF(11))).group()                  # optional - sage.groups sage.modules sage.rings.finite_rings
General Linear Group of degree 3 over Finite Field of size 11
sage: SymmetricGroup(10).algebra(QQ).group()                            # optional - sage.groups sage.modules
Symmetric group of order 10! as a permutation group

is_integral_domain(proof=True)

Return True if self is an integral domain.

This is false unless self.base_ring() is an integral domain, and even then it is false unless self.group() has no nontrivial elements of finite order. I don’t know if this condition suffices, but it obviously does if the group is abelian and finitely generated.

EXAMPLES:

sage: S2 = SymmetricGroup(2)                                            # optional - sage.groups
sage: GroupAlgebra(S2).is_integral_domain()                             # optional - sage.groups sage.modules
False
sage: S1 = SymmetricGroup(1)                                            # optional - sage.groups
sage: GroupAlgebra(S1).is_integral_domain()                             # optional - sage.groups sage.modules
True
sage: GroupAlgebra(S1, IntegerModRing(4)).is_integral_domain()          # optional - sage.groups sage.modules
False
sage: GroupAlgebra(AbelianGroup(1)).is_integral_domain()                # optional - sage.groups sage.modules
True
sage: GroupAlgebra(AbelianGroup(2, [0,2])).is_integral_domain()         # optional - sage.groups sage.modules
False
sage: GroupAlgebra(GL(2, ZZ)).is_integral_domain()  # not implemented   # optional - sage.groups sage.modules
False

example(G=None)

Return an example of group algebra.

EXAMPLES:

sage: GroupAlgebras(QQ['x']).example()                                      # optional - sage.groups sage.modules
Algebra of Dihedral group of order 8 as a permutation group
 over Univariate Polynomial Ring in x over Rational Field

An other group can be specified as optional argument:

sage: GroupAlgebras(QQ).example(AlternatingGroup(4))                        # optional - sage.groups sage.modules
Algebra of
 Alternating group of order 4!/2 as a permutation group over Rational Field

extra_super_categories()

Implement the fact that the algebra of a group is a Hopf algebra.

EXAMPLES:

sage: C = Groups().Algebras(QQ)
sage: C.extra_super_categories()
[Category of hopf algebras over Rational Field]
sage: sorted(C.super_categories(), key=str)
[Category of hopf algebras with basis over Rational Field,
 Category of monoid algebras over Rational Field]