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 Issue #6670.

  • John Palmieri (2011-07): more updates to coercion, categories, etc., group algebras constructed using CombinatorialFreeModule – see 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. Issue #18700.

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

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]

>>> from sage.all import *
>>> C = Groups().Algebras(ZZ); C
Category of group algebras over Integer Ring
>>> 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

>>> from sage.all import *
>>> C is GroupAlgebras(ZZ)
True

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

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

>>> from sage.all import *
>>> G = DihedralGroup(Integer(5))                                                      # needs sage.groups
>>> QG = G.algebra(QQ); QG                                                    # needs 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                                                     # needs sage.groups sage.modules
(1,4)(2,3)
sage: (QG.term(g) + 1)**3                                                       # needs sage.groups sage.modules
4*() + 4*(1,4)(2,3)

>>> from sage.all import *
>>> g = G.an_element(); g                                                     # needs sage.groups sage.modules
(1,4)(2,3)
>>> (QG.term(g) + Integer(1))**Integer(3)                                                       # needs 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[source]

Bases: object

central_form()[source]

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: # needs sage.combinat sage.groups sage.modules
sage: QS3 = SymmetricGroup(3).algebra(QQ)
sage: A = QS3([2,3,1]) + QS3([3,1,2])
sage: A.central_form()
B[(1,2,3)]
sage: QS4 = SymmetricGroup(4).algebra(QQ)
sage: B = sum(len(s.cycle_type()) * QS4(s) for s in Permutations(4))
sage: B.central_form()
4*B[()] + 3*B[(1,2)] + 2*B[(1,2)(3,4)] + 2*B[(1,2,3)] + B[(1,2,3,4)]

>>> from sage.all import *
>>> # needs sage.combinat sage.groups sage.modules
>>> QS3 = SymmetricGroup(Integer(3)).algebra(QQ)
>>> A = QS3([Integer(2),Integer(3),Integer(1)]) + QS3([Integer(3),Integer(1),Integer(2)])
>>> A.central_form()
B[(1,2,3)]
>>> QS4 = SymmetricGroup(Integer(4)).algebra(QQ)
>>> B = sum(len(s.cycle_type()) * QS4(s) for s in Permutations(Integer(4)))
>>> B.central_form()
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 Issue #28544):

sage: # needs sage.groups sage.modules
sage: G = PermutationGroup([[(1,2,3),(4,5)], [(3,4)]])
sage: QG = GroupAlgebras(QQ).example(G)
sage: s = sum(QG.basis())
sage: s.central_form()          # not tested
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)]

>>> from sage.all import *
>>> # needs sage.groups sage.modules
>>> G = PermutationGroup([[(Integer(1),Integer(2),Integer(3)),(Integer(4),Integer(5))], [(Integer(3),Integer(4))]])
>>> QG = GroupAlgebras(QQ).example(G)
>>> s = sum(QG.basis())
>>> s.central_form()          # not tested
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

class ParentMethods[source]

Bases: object

antipode_on_basis(g)[source]

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

>>> from sage.all import *
>>> # needs sage.groups sage.modules
>>> A = CyclicPermutationGroup(Integer(6)).algebra(ZZ); A
Algebra of
 Cyclic group of order 6 as a permutation group over Integer Ring
>>> g = CyclicPermutationGroup(Integer(6)).an_element(); g
(1,2,3,4,5,6)
>>> A.antipode_on_basis(g)
(1,6,5,4,3,2)
>>> a = A.an_element(); a
() + 3*(1,2,3,4,5,6) + 3*(1,3,5)(2,4,6)
>>> a.antipode()
() + 3*(1,5,3)(2,6,4) + 3*(1,6,5,4,3,2)
center_basis()[source]

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()                      # needs sage.combinat sage.groups sage.modules
((), (2,3) + (1,2) + (1,3), (1,2,3) + (1,3,2))

>>> from sage.all import *
>>> SymmetricGroup(Integer(3)).algebra(QQ).center_basis()                      # needs sage.combinat sage.groups sage.modules
((), (2,3) + (1,2) + (1,3), (1,2,3) + (1,3,2))

See also

coproduct_on_basis(g)[source]

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

>>> from sage.all import *
>>> # needs sage.groups sage.modules
>>> A = CyclicPermutationGroup(Integer(6)).algebra(ZZ); A
Algebra of
 Cyclic group of order 6 as a permutation group over Integer Ring
>>> g = CyclicPermutationGroup(Integer(6)).an_element(); g
(1,2,3,4,5,6)
>>> A.coproduct_on_basis(g)
(1,2,3,4,5,6) # (1,2,3,4,5,6)
>>> a = A.an_element(); a
() + 3*(1,2,3,4,5,6) + 3*(1,3,5)(2,4,6)
>>> a.coproduct()
() # () + 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)[source]

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                      # needs sage.groups sage.modules
Algebra of
 Cyclic group of order 6 as a permutation group over Integer Ring
sage: a = A.an_element(); a                                             # needs sage.groups sage.modules
() + 3*(1,2,3,4,5,6) + 3*(1,3,5)(2,4,6)
sage: a.counit()                                                        # needs sage.groups sage.modules
7

>>> from sage.all import *
>>> A = CyclicPermutationGroup(Integer(6)).algebra(ZZ); A                      # needs sage.groups sage.modules
Algebra of
 Cyclic group of order 6 as a permutation group over Integer Ring
>>> a = A.an_element(); a                                             # needs sage.groups sage.modules
() + 3*(1,2,3,4,5,6) + 3*(1,3,5)(2,4,6)
>>> a.counit()                                                        # needs sage.groups sage.modules
7
counit_on_basis(g)[source]

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                      # needs 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                     # needs sage.groups sage.modules
(1,2,3,4,5,6)
sage: A.counit_on_basis(g)                                              # needs sage.groups sage.modules
1

>>> from sage.all import *
>>> A = CyclicPermutationGroup(Integer(6)).algebra(ZZ); A                      # needs sage.groups sage.modules
Algebra of
 Cyclic group of order 6 as a permutation group over Integer Ring
>>> g = CyclicPermutationGroup(Integer(6)).an_element(); g                     # needs sage.groups sage.modules
(1,2,3,4,5,6)
>>> A.counit_on_basis(g)                                              # needs sage.groups sage.modules
1
group()[source]

Return the underlying group of the group algebra.

EXAMPLES:

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

>>> from sage.all import *
>>> GroupAlgebras(QQ).example(GL(Integer(3), GF(Integer(11)))).group()                  # needs sage.groups sage.modules
General Linear Group of degree 3 over Finite Field of size 11
>>> SymmetricGroup(Integer(10)).algebra(QQ).group()                            # needs sage.combinat sage.groups sage.modules
Symmetric group of order 10! as a permutation group
is_integral_domain(proof=True)[source]

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: # needs sage.groups sage.modules
sage: S2 = SymmetricGroup(2)
sage: GroupAlgebra(S2).is_integral_domain()                             # needs sage.combinat
False
sage: S1 = SymmetricGroup(1)
sage: GroupAlgebra(S1).is_integral_domain()                             # needs sage.combinat
True
sage: GroupAlgebra(S1, IntegerModRing(4)).is_integral_domain()          # needs sage.combinat
False
sage: GroupAlgebra(AbelianGroup(1)).is_integral_domain()
True
sage: GroupAlgebra(AbelianGroup(2, [0,2])).is_integral_domain()
False
sage: GroupAlgebra(GL(2, ZZ)).is_integral_domain()      # not implemented
False

>>> from sage.all import *
>>> # needs sage.groups sage.modules
>>> S2 = SymmetricGroup(Integer(2))
>>> GroupAlgebra(S2).is_integral_domain()                             # needs sage.combinat
False
>>> S1 = SymmetricGroup(Integer(1))
>>> GroupAlgebra(S1).is_integral_domain()                             # needs sage.combinat
True
>>> GroupAlgebra(S1, IntegerModRing(Integer(4))).is_integral_domain()          # needs sage.combinat
False
>>> GroupAlgebra(AbelianGroup(Integer(1))).is_integral_domain()
True
>>> GroupAlgebra(AbelianGroup(Integer(2), [Integer(0),Integer(2)])).is_integral_domain()
False
>>> GroupAlgebra(GL(Integer(2), ZZ)).is_integral_domain()      # not implemented
False
example(G=None)[source]

Return an example of group algebra.

EXAMPLES:

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

>>> from sage.all import *
>>> GroupAlgebras(QQ['x']).example()                                      # needs 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))                        # needs sage.groups sage.modules
Algebra of
 Alternating group of order 4!/2 as a permutation group over Rational Field

>>> from sage.all import *
>>> GroupAlgebras(QQ).example(AlternatingGroup(Integer(4)))                        # needs sage.groups sage.modules
Algebra of
 Alternating group of order 4!/2 as a permutation group over Rational Field
extra_super_categories()[source]

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]

>>> from sage.all import *
>>> C = Groups().Algebras(QQ)
>>> C.extra_super_categories()
[Category of Hopf algebras over Rational Field]
>>> sorted(C.super_categories(), key=str)
[Category of Hopf algebras with basis over Rational Field,
 Category of monoid algebras over Rational Field]