# Finite Permutation Groups¶

class sage.categories.finite_permutation_groups.FinitePermutationGroups(base_category)

The category of finite permutation groups, i.e. groups concretely represented as groups of permutations acting on a finite set.

It is currently assumed that any finite permutation group comes endowed with a distinguished finite set of generators (method group_generators); this is the case for all the existing implementations in Sage.

EXAMPLES:

sage: C = PermutationGroups().Finite(); C
Category of finite enumerated permutation groups
sage: C.super_categories()
[Category of permutation groups,
Category of finite groups,
Category of finite finitely generated semigroups]

sage: C.example()
Dihedral group of order 6 as a permutation group

class ElementMethods
class ParentMethods
cycle_index(parent=None)

Return the cycle index of self.

INPUT:

• self - a permutation group $$G$$
• parent – a free module with basis indexed by partitions, or behave as such, with a term and sum method (default: the symmetric functions over the rational field in the $$p$$ basis)

The cycle index of a permutation group $$G$$ (Wikipedia article Cycle_index) is a gadget counting the elements of $$G$$ by cycle type, averaged over the group:

$P = \frac{1}{|G|} \sum_{g\in G} p_{ \operatorname{cycle\ type}(g) }$

EXAMPLES:

Among the permutations of the symmetric group $$S_4$$, there is the identity, 6 cycles of length 2, 3 products of two cycles of length 2, 8 cycles of length 3, and 6 cycles of length 4:

sage: S4 = SymmetricGroup(4)
sage: P = S4.cycle_index()
sage: 24 * P
p[1, 1, 1, 1] + 6*p[2, 1, 1] + 3*p[2, 2] + 8*p[3, 1] + 6*p


If $$l = (l_1,\dots,l_k)$$ is a partition, |G| P[l] is the number of elements of $$G$$ with cycles of length $$(p_1,\dots,p_k)$$:

sage: 24 * P[ Partition([3,1]) ]
8


The cycle index plays an important role in the enumeration of objects modulo the action of a group (Pólya enumeration), via the use of symmetric functions and plethysms. It is therefore encoded as a symmetric function, expressed in the powersum basis:

sage: P.parent()
Symmetric Functions over Rational Field in the powersum basis


This symmetric function can have some nice properties; for example, for the symmetric group $$S_n$$, we get the complete symmetric function $$h_n$$:

sage: S = SymmetricFunctions(QQ); h = S.h()
sage: h( P )
h


Todo

Add some simple examples of Pólya enumeration, once it will be easy to expand symmetric functions on any alphabet.

Here are the cycle indices of some permutation groups:

sage: 6 * CyclicPermutationGroup(6).cycle_index()
p[1, 1, 1, 1, 1, 1] + p[2, 2, 2] + 2*p[3, 3] + 2*p

sage: 60 * AlternatingGroup(5).cycle_index()
p[1, 1, 1, 1, 1] + 15*p[2, 2, 1] + 20*p[3, 1, 1] + 24*p

sage: for G in TransitiveGroups(5):               # long time
....:     G.cardinality() * G.cycle_index()
p[1, 1, 1, 1, 1] + 4*p
p[1, 1, 1, 1, 1] + 5*p[2, 2, 1] + 4*p
p[1, 1, 1, 1, 1] + 5*p[2, 2, 1] + 10*p[4, 1] + 4*p
p[1, 1, 1, 1, 1] + 15*p[2, 2, 1] + 20*p[3, 1, 1] + 24*p
p[1, 1, 1, 1, 1] + 10*p[2, 1, 1, 1] + 15*p[2, 2, 1] + 20*p[3, 1, 1] + 20*p[3, 2] + 30*p[4, 1] + 24*p


Permutation groups with arbitrary domains are supported (see trac ticket #22765):

sage: G = PermutationGroup([['b','c','a']], domain=['a','b','c'])
sage: G.cycle_index()
1/3*p[1, 1, 1] + 2/3*p


One may specify another parent for the result:

sage: F = CombinatorialFreeModule(QQ, Partitions())
sage: P = CyclicPermutationGroup(6).cycle_index(parent = F)
sage: 6 * P
B[[1, 1, 1, 1, 1, 1]] + B[[2, 2, 2]] + 2*B[[3, 3]] + 2*B[]
sage: P.parent() is F
True


This parent should be a module with basis indexed by partitions:

sage: CyclicPermutationGroup(6).cycle_index(parent = QQ)
Traceback (most recent call last):
...
ValueError: parent should be a module with basis indexed by partitions


REFERENCES:

AUTHORS:

• Nicolas Borie and Nicolas M. Thiéry
example()

Returns an example of finite permutation group, as per Category.example().

EXAMPLES:

sage: G = FinitePermutationGroups().example(); G
Dihedral group of order 6 as a permutation group

extra_super_categories()

Any permutation group is assumed to be endowed with a finite set of generators.