Permutation groups¶
A permutation group is a finite group \(G\) whose elements are permutations of a given finite set \(X\) (i.e., bijections \(X \longrightarrow X\)) and whose group operation is the composition of permutations. The number of elements of \(X\) is called the degree of \(G\).
In Sage, a permutation is represented as either a string that defines a permutation using disjoint cycle notation, or a list of tuples, which represent disjoint cycles. That is:
(a,...,b)(c,...,d)...(e,...,f) <> [(a,...,b), (c,...,d),..., (e,...,f)]
() = identity <> []
You can make the “named” permutation groups (see
permgp_named.py
) and use the following
constructions:
 permutation group generated by elements,
direct_product_permgroups
, which takes a list of permutation groups and returns their direct product.
JOKE: Q: What’s hot, chunky, and acts on a polygon? A: Dihedral soup. Renteln, P. and Dundes, A. “Foolproof: A Sampling of Mathematical Folk Humor.” Notices Amer. Math. Soc. 52, 2434, 2005.
Index of methods¶
Here are the method of a PermutationGroup()
as_finitely_presented_group() 
Return a finitely presented group isomorphic to self . 
blocks_all() 
Returns the list of block systems of imprimitivity. 
cardinality() 
Return the number of elements of this group. See also: G.degree() 
center() 
Return the subgroup of elements that commute with every element of this group. 
centralizer() 
Returns the centralizer of g in self . 
character() 
Returns a group character from values , where values is a list of the values of the character evaluated on the conjugacy classes. 
character_table() 
Returns the matrix of values of the irreducible characters of a permutation group \(G\) at the conjugacy classes of \(G\). 
cohomology() 
Computes the group cohomology \(H^n(G, F)\), where \(F = \ZZ\) if \(p=0\) and \(F = \ZZ / p \ZZ\) if \(p > 0\) is a prime. 
cohomology_part() 
Compute the ppart of the group cohomology \(H^n(G, F)\), where \(F = \ZZ\) if \(p=0\) and \(F = \ZZ / p \ZZ\) if \(p > 0\) is a prime. 
commutator() 
Returns the commutator subgroup of a group, or of a pair of groups. 
composition_series() 
Return the composition series of this group as a list of permutation groups. 
conjugacy_class() 
Return the conjugacy class of g inside the group self . 
conjugacy_classes() 
Return a list with all the conjugacy classes of self . 
conjugacy_classes_representatives() 
Returns a complete list of representatives of conjugacy classes in a permutation group \(G\). 
conjugacy_classes_subgroups() 
Returns a complete list of representatives of conjugacy classes of subgroups in a permutation group \(G\). 
conjugate() 
Returns the group formed by conjugating self with g . 
construction() 
Return the construction of self . 
cosets() 
Returns a list of the cosets of S in self . 
degree() 
Returns the degree of this permutation group. 
derived_series() 
Return the derived series of this group as a list of permutation groups. 
direct_product() 
Wraps GAP’s DirectProduct , Embedding , and Projection . 
domain() 
Returns the underlying set that this permutation group acts on. 
exponent() 
Computes the exponent of the group. 
fitting_subgroup() 
Returns the Fitting subgroup of self . 
fixed_points() 
Return the list of points fixed by self , i.e., the subset of .domain() not moved by any element of self . 
frattini_subgroup() 
Returns the Frattini subgroup of self . 
gen() 
Returns the ith generator of self ; that is, the ith element of the list self.gens() . 
gens() 
Return tuple of generators of this group. These need not be minimal, as they are the generators used in defining this group. 
gens_small() 
For this group, returns a generating set which has few elements. As neither irredundancy nor minimal length is proven, it is fast. 
group_id() 
Return the ID code of this group, which is a list of two integers. 
group_primitive_id() 
Return the index of this group in the GAP database of primitive groups. 
has_element() 
Returns boolean value of item in self  however ignores parentage. 
holomorph() 
The holomorph of a group as a permutation group. 
homology() 
Computes the group homology \(H_n(G, F)\), where \(F = \ZZ\) if \(p=0\) and \(F = \ZZ / p \ZZ\) if \(p > 0\) is a prime. Wraps HAP’s GroupHomology function, written by Graham Ellis. 
homology_part() 
Computes the \(p\)part of the group homology \(H_n(G, F)\), where \(F = \ZZ\) if \(p=0\) and \(F = \ZZ / p \ZZ\) if \(p > 0\) is a prime. Wraps HAP’s Homology function, written by Graham Ellis, applied to the \(p\)Sylow subgroup of \(G\). 
id() 
(Same as self.group_id() .) Return the ID code of this group, which is a list of two integers. 
identity() 
Return the identity element of this group. 
intersection() 
Returns the permutation group that is the intersection of self and other . 
irreducible_characters() 
Returns a list of the irreducible characters of self . 
is_cyclic() 
Return True if this group is cyclic. 
is_elementary_abelian() 
Return True if this group is elementary abelian. An elementary abelian group is a finite abelian group, where every nontrivial element has order \(p\), where \(p\) is a prime. 
is_isomorphic() 
Return True if the groups are isomorphic. 
is_monomial() 
Returns True if the group is monomial. A finite group is monomial if every irreducible complex character is induced from a linear character of a subgroup. 
is_nilpotent() 
Return True if this group is nilpotent. 
is_normal() 
Return True if this group is a normal subgroup of other . 
is_perfect() 
Return True if this group is perfect. A group is perfect if it equals its derived subgroup. 
is_pgroup() 
Returns True if this group is a \(p\)group. A finite group is a \(p\)group if its order is of the form \(p^n\) for a prime integer \(p\) and a nonnegative integer \(n\). 
is_polycyclic() 
Return True if this group is polycyclic. A group is polycyclic if it has a subnormal series with cyclic factors. (For finite groups, this is the same as if the group is solvable  see is_solvable .) 
is_primitive() 
Returns True if self acts primitively on domain . A group $G$ acts primitively on a set $S$ if 
is_regular() 
Returns True if self acts regularly on domain . A group $G$ acts regularly on a set $S$ if 
is_semi_regular() 
Returns True if self acts semiregularly on domain . A group $G$ acts semiregularly on a set $S$ if the point stabilizers of $S$ in $G$ are trivial. 
is_simple() 
Returns True if the group is simple. A group is simple if it has no proper normal subgroups. 
is_solvable() 
Returns True if the group is solvable. 
is_subgroup() 
Returns True if self is a subgroup of other . 
is_supersolvable() 
Returns True if the group is supersolvable. A finite group is supersolvable if it has a normal series with cyclic factors. 
is_transitive() 
Returns True if self acts transitively on domain . A group $G$ acts transitively on set $S$ if for all \(x,y\in S\) there is some \(g\in G\) such that \(x^g=y\). 
isomorphism_to() 
Return an isomorphism from self to right if the groups are isomorphic, otherwise None . 
isomorphism_type_info_simple_group() 
If the group is simple, then this returns the name of the group. 
iteration() 
Return an iterator over the elements of this group. 
largest_moved_point() 
Return the largest point moved by a permutation in this group. 
list() 
Return list of all elements of this group. 
lower_central_series() 
Return the lower central series of this group as a list of permutation groups. 
minimal_generating_set() 
Return a minimal generating set 
molien_series() 
Return the Molien series of a permutation group. The function 
ngens() 
Return the number of generators of self . 
non_fixed_points() 
Return the list of points not fixed by self , i.e., the subset of self.domain() moved by some element of self . 
normal_subgroups() 
Return the normal subgroups of this group as a (sorted in increasing order) list of permutation groups. 
normalizer() 
Returns the normalizer of g in self . 
normalizes() 
Returns True if the group other is normalized by self . Wraps GAP’s IsNormal function. 
poincare_series() 
Return the Poincaré series of \(G \mod p\) (\(p \geq 2\) must be a prime), for \(n\) large. 
random_element() 
Return a random element of this group. 
representative_action() 
Return an element of self that maps \(x\) to \(y\) if it exists. 
semidirect_product() 
The semidirect product of self with N . 
socle() 
Returns the socle of self . The socle of a group $G$ is the subgroup generated by all minimal normal subgroups. 
solvable_radical() 
Returns the solvable radical of self . The solvable radical (or just radical) of a group $G$ is the largest solvable normal subgroup of $G$. 
stabilizer() 
Return the subgroup of self which stabilize the given position. self and its stabilizers must have same degree. 
strong_generating_system() 
Return a Strong Generating System of self according the given base for the right action of self on itself. 
structure_description() 
Return a string that tries to describe the structure of G . 
subgroup() 
Wraps the PermutationGroup_subgroup constructor. The argument gens is a list of elements of self . 
subgroups() 
Returns a list of all the subgroups of self . 
sylow_subgroup() 
Returns a Sylow \(p\)subgroup of the finite group \(G\), where \(p\) is a prime. This is a \(p\)subgroup of \(G\) whose index in \(G\) is coprime to \(p\). 
transversals() 
If G is a permutation group acting on the set \(X = \{1, 2, ...., n\}\) and H is the stabilizer subgroup of <integer>, a right (respectively left) transversal is a set containing exactly one element from each right (respectively left) coset of H. This method returns a right transversal of self by the stabilizer of self on <integer> position. 
trivial_character() 
Returns the trivial character of self . 
upper_central_series() 
Return the upper central series of this group as a list of permutation groups. 
AUTHORS:
 David Joyner (20051014): first version
 David Joyner (20051117)
 William Stein (20051126): rewrite to better wrap Gap
 David Joyner (20051221)
 William Stein and David Joyner (20060104): added conjugacy_class_representatives
 David Joyner (200603): reorganization into subdirectory perm_gps; added __contains__, has_element; fixed _cmp_; added subgroup class+methods, PGL,PSL,PSp, PSU classes,
 David Joyner (200606): added PGU, functionality to SymmetricGroup, AlternatingGroup, direct_product_permgroups
 David Joyner (200608): added degree, ramification_module_decomposition_modular_curve and ramification_module_decomposition_hurwitz_curve methods to PSL(2,q), MathieuGroup, is_isomorphic
 Bobby Moretti (2006)10): Added KleinFourGroup, fixed bug in DihedralGroup
 David Joyner (200610): added is_subgroup (fixing a bug found by Kiran Kedlaya), is_solvable, normalizer, is_normal_subgroup, Suzuki
 David Kohel (200702): fixed __contains__ to not enumerate group elements, following the convention for __call__
 David Harvey, Mike Hansen, Nick Alexander, William Stein (200702,03,04,05): Various patches
 Nathan Dunfield (200705): added orbits
 David Joyner (200706): added subgroup method (suggested by David Kohel), composition_series, lower_central_series, upper_central_series, cayley_table, quotient_group, sylow_subgroup, is_cyclic, homology, homology_part, cohomology, cohomology_part, poincare_series, molien_series, is_simple, is_monomial, is_supersolvable, is_nilpotent, is_perfect, is_polycyclic, is_elementary_abelian, is_pgroup, gens_small, isomorphism_type_info_simple_group. moved all the”named” groups to a new file.
 Nick Alexander (200707): move is_isomorphic to isomorphism_to, add from_gap_list
 William Stein (200707): put is_isomorphic back (and make it better)
 David Joyner (200708): fixed bugs in composition_series, upper/lower_central_series, derived_series,
 David Joyner (200806): modified is_normal (reported by W. J. Palenstijn), and added normalizes
 David Joyner (200808): Added example to docstring of cohomology.
 Simon King (200904): __cmp__ methods for PermutationGroup_generic and PermutationGroup_subgroup
 Nicolas Borie (2009): Added orbit, transversals, stabiliser and strong_generating_system methods
 Christopher Swenson (2012): Added a special case to compute the order efficiently. (This patch Copyright 2012 Google Inc. All Rights Reserved. )
 Javier Lopez Pena (2013): Added conjugacy classes.
 Sebastian Oehms (2018): added _coerce_map_from_ in order to use isomorphism coming up with as_permutation_group method (Trac #25706)
 Christian Stump (2018): Added alternative implementation of strong_generating_system directly using GAP.
 Sebastian Oehms (2018): Added
PermutationGroup_generic._Hom_()
to usesage.groups.libgap_morphism.GroupHomset_libgap
andPermutationGroup_generic.gap()
andPermutationGroup_generic._subgroup_constructor()
(for compatibility to libgap framework, see trac ticket #26750
REFERENCES:
 Cameron, P., Permutation Groups. New York: Cambridge University Press, 1999.
 Wielandt, H., Finite Permutation Groups. New York: Academic Press, 1964.
 Dixon, J. and Mortimer, B., Permutation Groups, SpringerVerlag, Berlin/New York, 1996.
Note
Though Suzuki groups are okay, Ree groups should not be wrapped as permutation groups  the construction is too slow  unless (for small values or the parameter) they are made using explicit generators.

sage.groups.perm_gps.permgroup.
PermutationGroup
(gens=None, gap_group=None, domain=None, canonicalize=True, category=None)¶ Return the permutation group associated to \(x\) (typically a list of generators).
INPUT:
gens
 list of generators (default:None
)gap_group
 a gap permutation group (default:None
)canonicalize
 bool (default:True
); ifTrue
, sort generators and remove duplicates
OUTPUT:
 A permutation group.
EXAMPLES:
sage: G = PermutationGroup([[(1,2,3),(4,5)],[(3,4)]]) sage: G Permutation Group with generators [(3,4), (1,2,3)(4,5)]
We can also make permutation groups from PARI groups:
sage: H = pari('x^4  2*x^3  2*x + 1').polgalois() sage: G = PariGroup(H, 4); G PARI group [8, 1, 3, "D(4)"] of degree 4 sage: H = PermutationGroup(G); H Transitive group number 3 of degree 4 sage: H.gens() [(1,2,3,4), (1,3)]
We can also create permutation groups whose generators are Gap permutation objects:
sage: p = gap('(1,2)(3,7)(4,6)(5,8)'); p (1,2)(3,7)(4,6)(5,8) sage: PermutationGroup([p]) Permutation Group with generators [(1,2)(3,7)(4,6)(5,8)]
Permutation groups can work on any domain. In the following examples, the permutations are specified in list notation, according to the order of the elements of the domain:
sage: list(PermutationGroup([['b','c','a']], domain=['a','b','c'])) [(), ('a','c','b'), ('a','b','c')] sage: list(PermutationGroup([['b','c','a']], domain=['b','c','a'])) [()] sage: list(PermutationGroup([['b','c','a']], domain=['a','c','b'])) [(), ('a','b')]
There is an underlying gap object that implements each permutation group:
sage: G = PermutationGroup([[(1,2,3,4)]]) sage: G._gap_() Group( [ (1,2,3,4) ] ) sage: gap(G) Group( [ (1,2,3,4) ] ) sage: gap(G) is G._gap_() True sage: G = PermutationGroup([[(1,2,3),(4,5)],[(3,4)]]) sage: current_randstate().set_seed_gap() sage: G._gap_().DerivedSeries() [ Group( [ (3,4), (1,2,3)(4,5) ] ), Group( [ (1,5)(3,4), (1,5)(2,4), (1,3,5) ] ) ]

class
sage.groups.perm_gps.permgroup.
PermutationGroup_generic
(gens=None, gap_group=None, canonicalize=True, domain=None, category=None)¶ Bases:
sage.groups.group.FiniteGroup
A generic permutation group.
EXAMPLES:
sage: G = PermutationGroup([[(1,2,3),(4,5)],[(3,4)]]) sage: G Permutation Group with generators [(3,4), (1,2,3)(4,5)] sage: G.center() Subgroup generated by [()] of (Permutation Group with generators [(3,4), (1,2,3)(4,5)]) sage: G.group_id() [120, 34] sage: n = G.order(); n 120 sage: G = PermutationGroup([[(1,2,3),(4,5)],[(3,4)]]) sage: TestSuite(G).run()

Element
¶ alias of
sage.groups.perm_gps.permgroup_element.PermutationGroupElement

as_finitely_presented_group
(reduced=False)¶ Return a finitely presented group isomorphic to
self
.This method acts as wrapper for the GAP function
IsomorphismFpGroupByGenerators
, which yields an isomorphism from a given group to a finitely presented group.INPUT:
reduced
– DefaultFalse
, ifTrue
FinitelyPresentedGroup.simplified
is called, attempting to simplify the presentation of the finitely presented group to be returned.
OUTPUT:
Finite presentation of self, obtained by taking the image of the isomorphism returned by the GAP function,
IsomorphismFpGroupByGenerators
.ALGORITHM:
Uses GAP.
EXAMPLES:
sage: CyclicPermutationGroup(50).as_finitely_presented_group() Finitely presented group < a  a^50 > sage: DihedralGroup(4).as_finitely_presented_group() Finitely presented group < a, b  b^2, a^4, (b*a)^2 > sage: GeneralDihedralGroup([2,2]).as_finitely_presented_group() Finitely presented group < a, b, c  a^2, b^2, c^2, (c*b)^2, (c*a)^2, (b*a)^2 >
GAP algorithm is not guaranteed to produce minimal or canonical presentation:
sage: G = PermutationGroup(['(1,2,3,4,5)', '(1,5)(2,4)']) sage: G.is_isomorphic(DihedralGroup(5)) True sage: K = G.as_finitely_presented_group(); K Finitely presented group < a, b  b^2, (b*a)^2, b*a^3*b*a^2 > sage: K.as_permutation_group().is_isomorphic(DihedralGroup(5)) True
We can attempt to reduce the output presentation:
sage: PermutationGroup(['(1,2,3,4,5)','(1,3,5,2,4)']).as_finitely_presented_group() Finitely presented group < a, b  b^2*a^1, b*a^2 > sage: PermutationGroup(['(1,2,3,4,5)','(1,3,5,2,4)']).as_finitely_presented_group(reduced=True) Finitely presented group < a  a^5 >
AUTHORS:
 Davis Shurbert (20130621): initial version

base
(seed=None)¶ Returns a (minimum) base of this permutation group. A base \(B\) of a permutation group is a subset of the domain of the group such that the only group element stabilizing all of \(B\) is the identity.
The argument \(seed\) is optional and must be a subset of the domain of \(base\). When used, an attempt to create a base containing all or part of \(seed\) will be made.
EXAMPLES:
sage: G = PermutationGroup([(1,2,3),(6,7,8)]) sage: G.base() [1, 6] sage: G.base([2]) [2, 6] sage: H = PermutationGroup([('a','b','c'),('a','y')]) sage: H.base() ['a', 'b', 'c'] sage: S = SymmetricGroup(13) sage: S.base() [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12] sage: S = MathieuGroup(12) sage: S.base() [1, 2, 3, 4, 5] sage: S.base([1,3,5,7,9,11]) # create a base for M12 with only odd integers [1, 3, 5, 7, 9]

blocks_all
(representatives=True)¶ Returns the list of block systems of imprimitivity.
For more information on primitivity, see the Wikipedia article on primitive group actions.
INPUT:
representative
(boolean) – whether to return all possible block systems of imprimitivity or only one of their representatives (the block can be obtained from its representative set \(S\) by computing the orbit of \(S\) underself
).This parameter is set to
True
by default (as it is GAP’s default behaviour).
OUTPUT:
This method returns a description of all block systems. Hence, the output is a “list of lists of lists” or a “list of lists” depending on the value of
representatives
. A bit more clearly, output is :A list of length (#number of different block systems) of
block systems, each of them being defined as
 If
representatives = True
: a list of representatives of each set of the block system  If
representatives = False
: a partition of the elements defining an imprimitivity block.
 If
See also
EXAMPLES:
Picking an interesting group:
sage: g = graphs.DodecahedralGraph() sage: g.is_vertex_transitive() True sage: ag = g.automorphism_group() sage: ag.is_primitive() False
Computing its blocks representatives:
sage: ag.blocks_all() [[0, 15]]
Now the full block:
sage: sorted(ag.blocks_all(representatives = False)[0]) [[0, 15], [1, 16], [2, 12], [3, 13], [4, 9], [5, 10], [6, 11], [7, 18], [8, 17], [14, 19]]

cardinality
()¶ Return the number of elements of this group. See also: G.degree()
EXAMPLES:
sage: G = PermutationGroup([[(1,2,3),(4,5)], [(1,2)]]) sage: G.order() 12 sage: G = PermutationGroup([()]) sage: G.order() 1 sage: G = PermutationGroup([]) sage: G.order() 1
cardinality
is just an alias:sage: PermutationGroup([(1,2,3)]).cardinality() 3

center
()¶ Return the subgroup of elements that commute with every element of this group.
EXAMPLES:
sage: G = PermutationGroup([[(1,2,3,4)]]) sage: G.center() Subgroup generated by [(1,2,3,4)] of (Permutation Group with generators [(1,2,3,4)]) sage: G = PermutationGroup([[(1,2,3,4)], [(1,2)]]) sage: G.center() Subgroup generated by [()] of (Permutation Group with generators [(1,2), (1,2,3,4)])

centralizer
(g)¶ Returns the centralizer of
g
inself
.EXAMPLES:
sage: G = PermutationGroup([[(1,2),(3,4)], [(1,2,3,4)]]) sage: g = G([(1,3)]) sage: G.centralizer(g) Subgroup generated by [(2,4), (1,3)] of (Permutation Group with generators [(1,2)(3,4), (1,2,3,4)]) sage: g = G([(1,2,3,4)]) sage: G.centralizer(g) Subgroup generated by [(1,2,3,4)] of (Permutation Group with generators [(1,2)(3,4), (1,2,3,4)]) sage: H = G.subgroup([G([(1,2,3,4)])]) sage: G.centralizer(H) Subgroup generated by [(1,2,3,4)] of (Permutation Group with generators [(1,2)(3,4), (1,2,3,4)])

character
(values)¶ Returns a group character from
values
, wherevalues
is a list of the values of the character evaluated on the conjugacy classes.EXAMPLES:
sage: G = AlternatingGroup(4) sage: n = len(G.conjugacy_classes_representatives()) sage: G.character([1]*n) Character of Alternating group of order 4!/2 as a permutation group

character_table
()¶ Returns the matrix of values of the irreducible characters of a permutation group \(G\) at the conjugacy classes of \(G\).
The columns represent the conjugacy classes of \(G\) and the rows represent the different irreducible characters in the ordering given by GAP.
EXAMPLES:
sage: G = PermutationGroup([[(1,2),(3,4)], [(1,2,3)]]) sage: G.order() 12 sage: G.character_table() [ 1 1 1 1] [ 1 zeta3  1 zeta3 1] [ 1 zeta3 zeta3  1 1] [ 3 0 0 1] sage: G = PermutationGroup([[(1,2),(3,4)], [(1,2,3)]]) sage: CT = gap(G).CharacterTable()
Type
print(gap.eval("Display(%s)"%CT.name()))
to display this nicely.sage: G = PermutationGroup([[(1,2),(3,4)], [(1,2,3,4)]]) sage: G.order() 8 sage: G.character_table() [ 1 1 1 1 1] [ 1 1 1 1 1] [ 1 1 1 1 1] [ 1 1 1 1 1] [ 2 0 0 0 2] sage: CT = gap(G).CharacterTable()
Again, type
print(gap.eval("Display(%s)"%CT.name()))
to display this nicely.sage: SymmetricGroup(2).character_table() [ 1 1] [ 1 1] sage: SymmetricGroup(3).character_table() [ 1 1 1] [ 2 0 1] [ 1 1 1] sage: SymmetricGroup(5).character_table() [ 1 1 1 1 1 1 1] [ 4 2 0 1 1 0 1] [ 5 1 1 1 1 1 0] [ 6 0 2 0 0 0 1] [ 5 1 1 1 1 1 0] [ 4 2 0 1 1 0 1] [ 1 1 1 1 1 1 1] sage: list(AlternatingGroup(6).character_table()) [(1, 1, 1, 1, 1, 1, 1), (5, 1, 2, 1, 1, 0, 0), (5, 1, 1, 2, 1, 0, 0), (8, 0, 1, 1, 0, zeta5^3 + zeta5^2 + 1, zeta5^3  zeta5^2), (8, 0, 1, 1, 0, zeta5^3  zeta5^2, zeta5^3 + zeta5^2 + 1), (9, 1, 0, 0, 1, 1, 1), (10, 2, 1, 1, 0, 0, 0)]
Suppose that you have a class function \(f(g)\) on \(G\) and you know the values \(v_1, \ldots, v_n\) on the conjugacy class elements in
conjugacy_classes_representatives(G)
= \([g_1, \ldots, g_n]\). Since the irreducible characters \(\rho_1, \ldots, \rho_n\) of \(G\) form an \(E\)basis of the space of all class functions (\(E\) a “sufficiently large” cyclotomic field), such a class function is a linear combination of these basis elements, \(f = c_1 \rho_1 + \cdots + c_n \rho_n\). To find the coefficients \(c_i\), you simply solve the linear systemcharacter_table_values(G)
\([v_1, ..., v_n] = [c_1, ..., c_n]\), where \([v_1, \ldots, v_n]\) =character_table_values(G)
\(^{(1)}[c_1, ..., c_n]\).AUTHORS:
 David Joyner and William Stein (20060104)

cohomology
(n, p=0)¶ Computes the group cohomology \(H^n(G, F)\), where \(F = \ZZ\) if \(p=0\) and \(F = \ZZ / p \ZZ\) if \(p > 0\) is a prime.
Wraps HAP’s
GroupHomology
function, written by Graham Ellis.REQUIRES: GAP package HAP (in gap_packages*.spkg).
EXAMPLES:
sage: G = SymmetricGroup(4) sage: G.cohomology(1,2) # optional  gap_packages Multiplicative Abelian group isomorphic to C2 sage: G = SymmetricGroup(3) sage: G.cohomology(5) # optional  gap_packages Trivial Abelian group sage: G.cohomology(5,2) # optional  gap_packages Multiplicative Abelian group isomorphic to C2 sage: G.homology(5,3) # optional  gap_packages Trivial Abelian group sage: G.homology(5,4) # optional  gap_packages Traceback (most recent call last): ... ValueError: p must be 0 or prime
This computes \(H^4(S_3, \ZZ)\) and \(H^4(S_3, \ZZ / 2 \ZZ)\), respectively.
AUTHORS:
 David Joyner and Graham Ellis
REFERENCES:
 G. Ellis, ‘Computing group resolutions’, J. Symbolic Computation. Vol.38, (2004)10771118 (Available at http://hamilton.nuigalway.ie/).
 D. Joyner, ‘A primer on computational group homology and cohomology’, http://front.math.ucdavis.edu/0706.0549.

cohomology_part
(n, p=0)¶ Compute the ppart of the group cohomology \(H^n(G, F)\), where \(F = \ZZ\) if \(p=0\) and \(F = \ZZ / p \ZZ\) if \(p > 0\) is a prime.
Wraps HAP’s Homology function, written by Graham Ellis, applied to the \(p\)Sylow subgroup of \(G\).
REQUIRES: GAP package HAP (in gap_packages*.spkg).
EXAMPLES:
sage: G = SymmetricGroup(5) sage: G.cohomology_part(7,2) # optional  gap_packages Multiplicative Abelian group isomorphic to C2 x C2 x C2 sage: G = SymmetricGroup(3) sage: G.cohomology_part(2,3) # optional  gap_packages Multiplicative Abelian group isomorphic to C3
AUTHORS:
 David Joyner and Graham Ellis

commutator
(other=None)¶ Returns the commutator subgroup of a group, or of a pair of groups.
INPUT:
other
 default:None
 a permutation group.
OUTPUT:
Let \(G\) denote
self
. Ifother
isNone
then this method returns the subgroup of \(G\) generated by the set of commutators,\[\{[g_1,g_2]\vert g_1, g_2\in G\} = \{g_1^{1}g_2^{1}g_1g_2\vert g_1, g_2\in G\}\]Let \(H\) denote
other
, in the case that it is notNone
. Then this method returns the group generated by the set of commutators,\[\{[g,h]\vert g\in G\, h\in H\} = \{g^{1}h^{1}gh\vert g\in G\, h\in H\}\]The two groups need only be permutation groups, there is no notion of requiring them to explicitly be subgroups of some other group.
Note
For the identical statement, the generators of the returned group can vary from one execution to the next.
EXAMPLES:
sage: G = DiCyclicGroup(4) sage: G.commutator() Permutation Group with generators [(1,3,5,7)(2,4,6,8)(9,11,13,15)(10,12,14,16)] sage: G = SymmetricGroup(5) sage: H = CyclicPermutationGroup(5) sage: C = G.commutator(H) sage: C.is_isomorphic(AlternatingGroup(5)) True
An abelian group will have a trivial commutator.
sage: G = CyclicPermutationGroup(10) sage: G.commutator() Permutation Group with generators [()]
The quotient of a group by its commutator is always abelian.
sage: G = DihedralGroup(20) sage: C = G.commutator() sage: Q = G.quotient(C) sage: Q.is_abelian() True
When forming commutators from two groups, the order of the groups does not matter.
sage: D = DihedralGroup(3) sage: S = SymmetricGroup(2) sage: C1 = D.commutator(S); C1 Permutation Group with generators [(1,2,3)] sage: C2 = S.commutator(D); C2 Permutation Group with generators [(1,3,2)] sage: C1 == C2 True
This method calls two different functions in GAP, so this tests that their results are consistent. The commutator groups may have different generators, but the groups are equal.
sage: G = DiCyclicGroup(3) sage: C = G.commutator(); C Permutation Group with generators [(5,7,6)] sage: CC = G.commutator(G); CC Permutation Group with generators [(5,6,7)] sage: C == CC True
The second group is checked.
sage: G = SymmetricGroup(2) sage: G.commutator('junk') Traceback (most recent call last): ... TypeError: junk is not a permutation group

composition_series
()¶ Return the composition series of this group as a list of permutation groups.
EXAMPLES:
These computations use pseudorandom numbers, so we set the seed for reproducible testing.
sage: set_random_seed(0) sage: G = PermutationGroup([[(1,2,3),(4,5)],[(3,4)]]) sage: G.composition_series() [Subgroup generated by [(3,4), (1,2,3)(4,5)] of (Permutation Group with generators [(3,4), (1,2,3)(4,5)]), Subgroup generated by [(1,3,5), (1,5)(3,4), (1,5)(2,4)] of (Permutation Group with generators [(3,4), (1,2,3)(4,5)]), Subgroup generated by [()] of (Permutation Group with generators [(3,4), (1,2,3)(4,5)])] sage: G = PermutationGroup([[(1,2,3),(4,5)], [(1,2)]]) sage: CS = G.composition_series() sage: CS[3] Subgroup generated by [()] of (Permutation Group with generators [(1,2), (1,2,3)(4,5)])

conjugacy_class
(g)¶ Return the conjugacy class of
g
inside the groupself
.INPUT:
g
– an element of the permutation groupself
OUTPUT:
The conjugacy class of
g
in the groupself
. Ifself
is the group denoted by \(G\), this method computes the set \(\{x^{1}gx\ \vert\ x \in G \}\)EXAMPLES:
sage: G = DihedralGroup(3) sage: g = G.gen(0) sage: G.conjugacy_class(g) Conjugacy class of (1,2,3) in Dihedral group of order 6 as a permutation group

conjugacy_classes
()¶ Return a list with all the conjugacy classes of
self
.EXAMPLES:
sage: G = DihedralGroup(3) sage: G.conjugacy_classes() [Conjugacy class of () in Dihedral group of order 6 as a permutation group, Conjugacy class of (2,3) in Dihedral group of order 6 as a permutation group, Conjugacy class of (1,2,3) in Dihedral group of order 6 as a permutation group]

conjugacy_classes_representatives
()¶ Returns a complete list of representatives of conjugacy classes in a permutation group \(G\).
The ordering is that given by GAP.
EXAMPLES:
sage: G = PermutationGroup([[(1,2),(3,4)], [(1,2,3,4)]]) sage: cl = G.conjugacy_classes_representatives(); cl [(), (2,4), (1,2)(3,4), (1,2,3,4), (1,3)(2,4)] sage: cl[3] in G True
sage: G = SymmetricGroup(5) sage: G.conjugacy_classes_representatives() [(), (1,2), (1,2)(3,4), (1,2,3), (1,2,3)(4,5), (1,2,3,4), (1,2,3,4,5)]
sage: S = SymmetricGroup(['a','b','c']) sage: S.conjugacy_classes_representatives() [(), ('a','b'), ('a','b','c')]
AUTHORS:
 David Joyner and William Stein (20060104)

conjugacy_classes_subgroups
()¶ Returns a complete list of representatives of conjugacy classes of subgroups in a permutation group \(G\).
The ordering is that given by GAP.
EXAMPLES:
sage: G = PermutationGroup([[(1,2),(3,4)], [(1,2,3,4)]]) sage: cl = G.conjugacy_classes_subgroups() sage: cl [Subgroup generated by [()] of (Permutation Group with generators [(1,2)(3,4), (1,2,3,4)]), Subgroup generated by [(1,2)(3,4)] of (Permutation Group with generators [(1,2)(3,4), (1,2,3,4)]), Subgroup generated by [(1,3)(2,4)] of (Permutation Group with generators [(1,2)(3,4), (1,2,3,4)]), Subgroup generated by [(2,4)] of (Permutation Group with generators [(1,2)(3,4), (1,2,3,4)]), Subgroup generated by [(1,2)(3,4), (1,4)(2,3)] of (Permutation Group with generators [(1,2)(3,4), (1,2,3,4)]), Subgroup generated by [(2,4), (1,3)(2,4)] of (Permutation Group with generators [(1,2)(3,4), (1,2,3,4)]), Subgroup generated by [(1,2,3,4), (1,3)(2,4)] of (Permutation Group with generators [(1,2)(3,4), (1,2,3,4)]), Subgroup generated by [(2,4), (1,2)(3,4), (1,4)(2,3)] of (Permutation Group with generators [(1,2)(3,4), (1,2,3,4)])]
sage: G = SymmetricGroup(3) sage: G.conjugacy_classes_subgroups() [Subgroup generated by [()] of (Symmetric group of order 3! as a permutation group), Subgroup generated by [(2,3)] of (Symmetric group of order 3! as a permutation group), Subgroup generated by [(1,2,3)] of (Symmetric group of order 3! as a permutation group), Subgroup generated by [(2,3), (1,2,3)] of (Symmetric group of order 3! as a permutation group)]
AUTHORS:
 David Joyner (200610)

conjugate
(g)¶ Returns the group formed by conjugating
self
withg
.INPUT:
g
 a permutation group element, or an object that converts to a permutation group element, such as a list of integers or a string of cycles.
OUTPUT:
If
self
is the group denoted by \(H\), then this method computes the group\[g^{1}Hg = \{g^{1}hg\vert h\in H\}\]which is the group \(H\) conjugated by \(g\).
There are no restrictions on
self
andg
belonging to a common permutation group, and correspondingly, there is no relationship (such as a common parent) betweenself
and the output group.EXAMPLES:
sage: G = DihedralGroup(6) sage: a = PermutationGroupElement("(1,2,3,4)") sage: G.conjugate(a) Permutation Group with generators [(1,4)(2,6)(3,5), (1,5,6,2,3,4)]
The element performing the conjugation can be specified in several ways.
sage: G = DihedralGroup(6) sage: strng = "(1,2,3,4)" sage: G.conjugate(strng) Permutation Group with generators [(1,4)(2,6)(3,5), (1,5,6,2,3,4)] sage: G = DihedralGroup(6) sage: lst = [2,3,4,1] sage: G.conjugate(lst) Permutation Group with generators [(1,4)(2,6)(3,5), (1,5,6,2,3,4)] sage: G = DihedralGroup(6) sage: cycles = [(1,2,3,4)] sage: G.conjugate(cycles) Permutation Group with generators [(1,4)(2,6)(3,5), (1,5,6,2,3,4)]
Conjugation is a group automorphism, so conjugate groups will be isomorphic.
sage: G = DiCyclicGroup(6) sage: G.degree() 11 sage: cycle = [i+1 for i in range(1,11)] + [1] sage: C = G.conjugate(cycle) sage: G.is_isomorphic(C) True
The conjugating element may be from a symmetric group with larger degree than the group being conjugated.
sage: G = AlternatingGroup(5) sage: G.degree() 5 sage: g = "(1,3)(5,6,7)" sage: H = G.conjugate(g); H Permutation Group with generators [(1,4,6,3,2), (1,4,6)] sage: H.degree() 6
The conjugating element is checked.
sage: G = SymmetricGroup(3) sage: G.conjugate("junk") Traceback (most recent call last): ... TypeError: junk does not convert to a permutation group element

construction
()¶ Return the construction of
self
.EXAMPLES:
sage: P1 = PermutationGroup([[(1,2)]]) sage: P1.construction() (PermutationGroupFunctor[(1,2)], Permutation Group with generators [()]) sage: PermutationGroup([]).construction() is None True
This allows us to perform computations like the following:
sage: P1 = PermutationGroup([[(1,2)]]); p1 = P1.gen() sage: P2 = PermutationGroup([[(1,3)]]); p2 = P2.gen() sage: p = p1*p2; p (1,2,3) sage: p.parent() Permutation Group with generators [(1,2), (1,3)] sage: p.parent().domain() {1, 2, 3}
Note that this will merge permutation groups with different domains:
sage: g1 = PermutationGroupElement([(1,2),(3,4,5)]) sage: g2 = PermutationGroup([('a','b')], domain=['a', 'b']).gens()[0] sage: g2 ('a','b') sage: p = g1*g2; p (1,2)(3,4,5)('a','b') sage: P = parent(p) sage: P Permutation Group with generators [('a','b'), (1,2), (1,2,3,4,5)]

cosets
(S, side='right')¶ Returns a list of the cosets of
S
inself
.INPUT:
S
 a subgroup ofself
. An error is raised ifS
is not a subgroup.side
 default: ‘right’  determines if right cosets or left cosets are returned.side
refers to where the representative is placed in the products forming the cosets and thus allowable values are only ‘right’ and ‘left’.
OUTPUT:
A list of lists. Each inner list is a coset of the subgroup in the group. The first element of each coset is the smallest element (based on the ordering of the elements of
self
) of all the group elements that have not yet appeared in a previous coset. The elements of each coset are in the same order as the subgroup elements used to build the coset’s elements.As a consequence, the subgroup itself is the first coset, and its first element is the identity element. For each coset, the first element listed is the element used as a representative to build the coset. These representatives form an increasing sequence across the list of cosets, and within a coset the representative is the smallest element of its coset (both orderings are based on of the ordering of elements of
self
).In the case of a normal subgroup, left and right cosets should appear in the same order as part of the outer list. However, the list of the elements of a particular coset may be in a different order for the right coset versus the order in the left coset. So, if you check to see if a subgroup is normal, it is necessary to sort each individual coset first (but not the list of cosets, due to the ordering of the representatives). See below for examples of this.
Note
This is a naive implementation intended for instructional purposes, and hence is slow for larger groups. Sage and GAP provide more sophisticated functions for working quickly with cosets of larger groups.
EXAMPLES:
The default is to build right cosets. This example works with the symmetry group of an 8gon and a normal subgroup. Notice that a straight check on the equality of the output is not sufficient to check normality, while sorting the individual cosets is sufficient to then simply test equality of the list of lists. Study the second coset in each list to understand the need for sorting the elements of the cosets.
sage: G = DihedralGroup(8) sage: quarter_turn = G('(1,3,5,7)(2,4,6,8)'); quarter_turn (1,3,5,7)(2,4,6,8) sage: S = G.subgroup([quarter_turn]) sage: rc = G.cosets(S); rc [[(), (1,3,5,7)(2,4,6,8), (1,5)(2,6)(3,7)(4,8), (1,7,5,3)(2,8,6,4)], [(2,8)(3,7)(4,6), (1,7)(2,6)(3,5), (1,5)(2,4)(6,8), (1,3)(4,8)(5,7)], [(1,2)(3,8)(4,7)(5,6), (1,8)(2,7)(3,6)(4,5), (1,6)(2,5)(3,4)(7,8), (1,4)(2,3)(5,8)(6,7)], [(1,2,3,4,5,6,7,8), (1,4,7,2,5,8,3,6), (1,6,3,8,5,2,7,4), (1,8,7,6,5,4,3,2)]] sage: lc = G.cosets(S, side='left'); lc [[(), (1,3,5,7)(2,4,6,8), (1,5)(2,6)(3,7)(4,8), (1,7,5,3)(2,8,6,4)], [(2,8)(3,7)(4,6), (1,3)(4,8)(5,7), (1,5)(2,4)(6,8), (1,7)(2,6)(3,5)], [(1,2)(3,8)(4,7)(5,6), (1,4)(2,3)(5,8)(6,7), (1,6)(2,5)(3,4)(7,8), (1,8)(2,7)(3,6)(4,5)], [(1,2,3,4,5,6,7,8), (1,4,7,2,5,8,3,6), (1,6,3,8,5,2,7,4), (1,8,7,6,5,4,3,2)]] sage: S.is_normal(G) True sage: rc == lc False sage: rc_sorted = [sorted(c) for c in rc] sage: lc_sorted = [sorted(c) for c in lc] sage: rc_sorted == lc_sorted True
An example with the symmetry group of a regular tetrahedron and a subgroup that is not normal. Thus, the right and left cosets are different (and so are the representatives). With each individual coset sorted, a naive test of normality is possible.
sage: A = AlternatingGroup(4) sage: face_turn = A('(1,2,3)'); face_turn (1,2,3) sage: stabilizer = A.subgroup([face_turn]) sage: rc = A.cosets(stabilizer, side='right'); rc [[(), (1,2,3), (1,3,2)], [(2,3,4), (1,3)(2,4), (1,4,2)], [(2,4,3), (1,4,3), (1,2)(3,4)], [(1,2,4), (1,4)(2,3), (1,3,4)]] sage: lc = A.cosets(stabilizer, side='left'); lc [[(), (1,2,3), (1,3,2)], [(2,3,4), (1,2)(3,4), (1,3,4)], [(2,4,3), (1,2,4), (1,3)(2,4)], [(1,4,2), (1,4,3), (1,4)(2,3)]] sage: stabilizer.is_normal(A) False sage: rc_sorted = [sorted(c) for c in rc] sage: lc_sorted = [sorted(c) for c in lc] sage: rc_sorted == lc_sorted False
AUTHOR:
 Rob Beezer (20110131)

degree
()¶ Returns the degree of this permutation group.
EXAMPLES:
sage: S = SymmetricGroup(['a','b','c']) sage: S.degree() 3 sage: G = PermutationGroup([(1,3),(4,5)]) sage: G.degree() 5
Note that you can explicitly specify the domain to get a permutation group of smaller degree:
sage: G = PermutationGroup([(1,3),(4,5)], domain=[1,3,4,5]) sage: G.degree() 4

derived_series
()¶ Return the derived series of this group as a list of permutation groups.
EXAMPLES:
These computations use pseudorandom numbers, so we set the seed for reproducible testing.
sage: set_random_seed(0) sage: G = PermutationGroup([[(1,2,3),(4,5)],[(3,4)]]) sage: G.derived_series() [Subgroup generated by [(3,4), (1,2,3)(4,5)] of (Permutation Group with generators [(3,4), (1,2,3)(4,5)]), Subgroup generated by [(1,3,5), (1,5)(3,4), (1,5)(2,4)] of (Permutation Group with generators [(3,4), (1,2,3)(4,5)])]

direct_product
(other, maps=True)¶ Wraps GAP’s
DirectProduct
,Embedding
, andProjection
.Sage calls GAP’s
DirectProduct
, which chooses an efficient representation for the direct product. The direct product of permutation groups will be a permutation group again. For a direct productD
, the GAP operationEmbedding(D,i)
returns the homomorphism embedding the ith factor intoD
. The GAP operationProjection(D,i)
gives the projection ofD
onto the ith factor. This method returns a 5tuple: a permutation group and 4 morphisms.INPUT:
self, other
 permutation groups
OUTPUT:
D
 a direct product of the inputs, returned as a permutation group as welliota1
 an embedding ofself
intoD
iota2
 an embedding ofother
intoD
pr1
 the projection ofD
ontoself
(giving a splitting 1  other  D  self  1)pr2
 the projection ofD
ontoother
(giving a splitting 1  self  D  other  1)
EXAMPLES:
sage: G = CyclicPermutationGroup(4) sage: D = G.direct_product(G,False) sage: D Permutation Group with generators [(5,6,7,8), (1,2,3,4)] sage: D,iota1,iota2,pr1,pr2 = G.direct_product(G) sage: D; iota1; iota2; pr1; pr2 Permutation Group with generators [(5,6,7,8), (1,2,3,4)] Permutation group morphism: From: Cyclic group of order 4 as a permutation group To: Permutation Group with generators [(5,6,7,8), (1,2,3,4)] Defn: Embedding( Group( [ (1,2,3,4), (5,6,7,8) ] ), 1 ) Permutation group morphism: From: Cyclic group of order 4 as a permutation group To: Permutation Group with generators [(5,6,7,8), (1,2,3,4)] Defn: Embedding( Group( [ (1,2,3,4), (5,6,7,8) ] ), 2 ) Permutation group morphism: From: Permutation Group with generators [(5,6,7,8), (1,2,3,4)] To: Cyclic group of order 4 as a permutation group Defn: Projection( Group( [ (1,2,3,4), (5,6,7,8) ] ), 1 ) Permutation group morphism: From: Permutation Group with generators [(5,6,7,8), (1,2,3,4)] To: Cyclic group of order 4 as a permutation group Defn: Projection( Group( [ (1,2,3,4), (5,6,7,8) ] ), 2 ) sage: g=D([(1,3),(2,4)]); g (1,3)(2,4) sage: d=D([(1,4,3,2),(5,7),(6,8)]); d (1,4,3,2)(5,7)(6,8) sage: iota1(g); iota2(g); pr1(d); pr2(d) (1,3)(2,4) (5,7)(6,8) (1,4,3,2) (1,3)(2,4)

domain
()¶ Returns the underlying set that this permutation group acts on.
EXAMPLES:
sage: P = PermutationGroup([(1,2),(3,5)]) sage: P.domain() {1, 2, 3, 4, 5} sage: S = SymmetricGroup(['a', 'b', 'c']) sage: S.domain() {'a', 'b', 'c'}

exponent
()¶ Computes the exponent of the group.
The exponent \(e\) of a group \(G\) is the LCM of the orders of its elements, that is, \(e\) is the smallest integer such that \(g^e=1\) for all \(g \in G\).
EXAMPLES:
sage: G = AlternatingGroup(4) sage: G.exponent() 6

fitting_subgroup
()¶ Returns the Fitting subgroup of
self
.The Fitting subgroup of a group \(G\) is the largest nilpotent normal subgroup of \(G\).
EXAMPLES:
sage: G=PermutationGroup([[(1,2,3,4)],[(2,4)]]) sage: G.fitting_subgroup() Subgroup generated by [(2,4), (1,2,3,4), (1,3)] of (Permutation Group with generators [(2,4), (1,2,3,4)]) sage: G=PermutationGroup([[(1,2,3,4)],[(1,2)]]) sage: G.fitting_subgroup() Subgroup generated by [(1,2)(3,4), (1,3)(2,4)] of (Permutation Group with generators [(1,2), (1,2,3,4)])

fixed_points
()¶ Return the list of points fixed by
self
, i.e., the subset of.domain()
not moved by any element ofself
.EXAMPLES:
sage: G = PermutationGroup([(1,2,3)]) sage: G.fixed_points() [] sage: G = PermutationGroup([(1,2,3),(5,6)]) sage: G.fixed_points() [4] sage: G = PermutationGroup([[(1,4,7)],[(4,3),(6,7)]]) sage: G.fixed_points() [2, 5]

frattini_subgroup
()¶ Returns the Frattini subgroup of
self
.The Frattini subgroup of a group \(G\) is the intersection of all maximal subgroups of \(G\).
EXAMPLES:
sage: G=PermutationGroup([[(1,2,3,4)],[(2,4)]]) sage: G.frattini_subgroup() Subgroup generated by [(1,3)(2,4)] of (Permutation Group with generators [(2,4), (1,2,3,4)]) sage: G=SymmetricGroup(4) sage: G.frattini_subgroup() Subgroup generated by [()] of (Symmetric group of order 4! as a permutation group)

gap
()¶ this method from
sage.groups.libgap_wrapper.ParentLibGAP
is added in order to achieve compatibility and havesage.groups.libgap_morphism.GroupHomset_libgap
work for permutation groups, as wellOUTPUT:
an instance of
sage.libs.gap.element.GapElement
representing this groupEXAMPLES:
sage: P8=PSp(8,3) sage: P8.gap() <permutation group of size 65784756654489600 with 2 generators> sage: gap(P8) == P8.gap() False sage: S3 = SymmetricGroup(3) sage: S3.gap() Sym( [ 1 .. 3 ] ) sage: gap(S3) == S3.gap() False

gen
(i=None)¶ Returns the ith generator of
self
; that is, the ith element of the listself.gens()
.The argument \(i\) may be omitted if there is only one generator (but this will raise an error otherwise).
EXAMPLES:
We explicitly construct the alternating group on four elements:
sage: A4 = PermutationGroup([[(1,2,3)],[(2,3,4)]]); A4 Permutation Group with generators [(2,3,4), (1,2,3)] sage: A4.gens() [(2,3,4), (1,2,3)] sage: A4.gen(0) (2,3,4) sage: A4.gen(1) (1,2,3) sage: A4.gens()[0]; A4.gens()[1] (2,3,4) (1,2,3) sage: P1 = PermutationGroup([[(1,2)]]); P1.gen() (1,2)

gens
()¶ Return tuple of generators of this group. These need not be minimal, as they are the generators used in defining this group.
EXAMPLES:
sage: G = PermutationGroup([[(1,2,3)], [(1,2)]]) sage: G.gens() [(1,2), (1,2,3)]
Note that the generators need not be minimal, though duplicates are removed:
sage: G = PermutationGroup([[(1,2)], [(1,3)], [(2,3)], [(1,2)]]) sage: G.gens() [(2,3), (1,2), (1,3)]
We can use index notation to access the generators returned by
self.gens
:sage: G = PermutationGroup([[(1,2,3,4), (5,6)], [(1,2)]]) sage: g = G.gens() sage: g[0] (1,2) sage: g[1] (1,2,3,4)(5,6)

gens_small
()¶ For this group, returns a generating set which has few elements. As neither irredundancy nor minimal length is proven, it is fast.
EXAMPLES:
sage: R = "(25,27,32,30)(26,29,31,28)( 3,38,43,19)( 5,36,45,21)( 8,33,48,24)" ## R = right sage: U = "( 1, 3, 8, 6)( 2, 5, 7, 4)( 9,33,25,17)(10,34,26,18)(11,35,27,19)" ## U = top sage: L = "( 9,11,16,14)(10,13,15,12)( 1,17,41,40)( 4,20,44,37)( 6,22,46,35)" ## L = left sage: F = "(17,19,24,22)(18,21,23,20)( 6,25,43,16)( 7,28,42,13)( 8,30,41,11)" ## F = front sage: B = "(33,35,40,38)(34,37,39,36)( 3, 9,46,32)( 2,12,47,29)( 1,14,48,27)" ## B = back or rear sage: D = "(41,43,48,46)(42,45,47,44)(14,22,30,38)(15,23,31,39)(16,24,32,40)" ## D = down or bottom sage: G = PermutationGroup([R,L,U,F,B,D]) sage: len(G.gens_small()) 2
The output may be unpredictable, due to the use of randomized algorithms in GAP. Note that both the following answers are equally valid.
sage: G = PermutationGroup([[('a','b')], [('b', 'c')], [('a', 'c')]]) sage: G.gens_small() # random [('b','c'), ('a','c','b')] ## (on 64bit Linux) [('a','b'), ('a','c','b')] ## (on Solaris) sage: len(G.gens_small()) == 2 True

group_id
()¶ Return the ID code of this group, which is a list of two integers.
EXAMPLES:
sage: G = PermutationGroup([[(1,2,3),(4,5)], [(1,2)]]) sage: G.group_id() [12, 4]

group_primitive_id
()¶ Return the index of this group in the GAP database of primitive groups.
OUTPUT:
A positive integer, following GAP’s conventions. A
ValueError
is raised if the group is not primitive.EXAMPLES:
sage: G = PermutationGroup([[(1,2,3,4,5)], [(1,5),(2,4)]]) sage: G.group_primitive_id() 2 sage: G.degree() 5
From the information of the degree and the identification number, you can recover the isomorphism class of your group in the GAP database:
sage: H = PrimitiveGroup(5,2) sage: G == H False sage: G.is_isomorphic(H) True

has_element
(item)¶ Returns boolean value of
item in self
 however ignores parentage.EXAMPLES:
sage: G = CyclicPermutationGroup(4) sage: gens = G.gens() sage: H = DihedralGroup(4) sage: g = G([(1,2,3,4)]); g (1,2,3,4) sage: G.has_element(g) True sage: h = H([(1,2),(3,4)]); h (1,2)(3,4) sage: G.has_element(h) False

has_regular_subgroup
(return_group=False)¶ Return whether the group contains a regular subgroup.
INPUT:
return_group
(boolean) – Ifreturn_group = True
, a regular subgroup is returned if there is one, andNone
if there isn’t. Whenreturn_group = False
(default), only a boolean indicating whether such a group exists is returned instead.
EXAMPLES:
The symmetric group on 4 elements has a regular subgroup:
sage: S4 = groups.permutation.Symmetric(4) sage: S4.has_regular_subgroup() True sage: S4.has_regular_subgroup(return_group = True) # random Subgroup of (Symmetric group of order 4! as a permutation group) generated by [(1,3)(2,4), (1,4)(2,3)]
But the automorphism group of Petersen’s graph does not:
sage: G = graphs.PetersenGraph().automorphism_group() sage: G.has_regular_subgroup() False

holomorph
()¶ The holomorph of a group as a permutation group.
The holomorph of a group \(G\) is the semidirect product \(G \rtimes_{id} Aut(G)\), where \(id\) is the identity function on \(Aut(G)\), the automorphism group of \(G\).
See Wikipedia article Holomorph (mathematics)
OUTPUT:
Returns the holomorph of a given group as permutation group via a wrapping of GAP’s semidirect product function.
EXAMPLES:
Thomas and Wood’s ‘Group Tables’ (Shiva Publishing, 1980) tells us that the holomorph of \(C_5\) is the unique group of order 20 with a trivial center.
sage: C5 = CyclicPermutationGroup(5) sage: A = C5.holomorph() sage: A.order() 20 sage: A.is_abelian() False sage: A.center() Subgroup generated by [()] of (Permutation Group with generators [(5,6,7,8,9), (1,2,4,3)(6,7,9,8)]) sage: A Permutation Group with generators [(5,6,7,8,9), (1,2,4,3)(6,7,9,8)]
Noting that the automorphism group of \(D_4\) is itself \(D_4\), it can easily be shown that the holomorph is indeed an internal semidirect product of these two groups.
sage: D4 = DihedralGroup(4) sage: H = D4.holomorph() sage: H.gens() [(3,8)(4,7), (2,3,5,8), (2,5)(3,8), (1,4,6,7)(2,3,5,8), (1,8)(2,7)(3,6)(4,5)] sage: G = H.subgroup([H.gens()[0],H.gens()[1],H.gens()[2]]) sage: N = H.subgroup([H.gens()[3],H.gens()[4]]) sage: N.is_normal(H) True sage: G.is_isomorphic(D4) True sage: N.is_isomorphic(D4) True sage: G.intersection(N) Permutation Group with generators [()] sage: L = [H(x)*H(y) for x in G for y in N]; L.sort() sage: L1 = H.list(); L1.sort() sage: L == L1 True
Author:
 Kevin Halasz (20120814)

homology
(n, p=0)¶ Computes the group homology \(H_n(G, F)\), where \(F = \ZZ\) if \(p=0\) and \(F = \ZZ / p \ZZ\) if \(p > 0\) is a prime. Wraps HAP’s
GroupHomology
function, written by Graham Ellis.REQUIRES: GAP package HAP (in gap_packages*.spkg).
AUTHORS:
 David Joyner and Graham Ellis
The example below computes \(H_7(S_5, \ZZ)\), \(H_7(S_5, \ZZ / 2 \ZZ)\), \(H_7(S_5, \ZZ / 3 \ZZ)\), and \(H_7(S_5, \ZZ / 5 \ZZ)\), respectively. To compute the \(2\)part of \(H_7(S_5, \ZZ)\), use the
homology_part
function.EXAMPLES:
sage: G = SymmetricGroup(5) sage: G.homology(7) # optional  gap_packages Multiplicative Abelian group isomorphic to C2 x C2 x C4 x C3 x C5 sage: G.homology(7,2) # optional  gap_packages Multiplicative Abelian group isomorphic to C2 x C2 x C2 x C2 x C2 sage: G.homology(7,3) # optional  gap_packages Multiplicative Abelian group isomorphic to C3 sage: G.homology(7,5) # optional  gap_packages Multiplicative Abelian group isomorphic to C5
REFERENCES:
 G. Ellis, “Computing group resolutions”, J. Symbolic Computation. Vol.38, (2004)10771118 (Available at http://hamilton.nuigalway.ie/.
 D. Joyner, “A primer on computational group homology and cohomology”, http://front.math.ucdavis.edu/0706.0549

homology_part
(n, p=0)¶ Computes the \(p\)part of the group homology \(H_n(G, F)\), where \(F = \ZZ\) if \(p=0\) and \(F = \ZZ / p \ZZ\) if \(p > 0\) is a prime. Wraps HAP’s
Homology
function, written by Graham Ellis, applied to the \(p\)Sylow subgroup of \(G\).REQUIRES: GAP package HAP (in gap_packages*.spkg).
EXAMPLES:
sage: G = SymmetricGroup(5) sage: G.homology_part(7,2) # optional  gap_packages Multiplicative Abelian group isomorphic to C2 x C2 x C2 x C2 x C4
AUTHORS:
 David Joyner and Graham Ellis

id
()¶ (Same as
self.group_id()
.) Return the ID code of this group, which is a list of two integers.EXAMPLES:
sage: G = PermutationGroup([[(1,2,3),(4,5)], [(1,2)]]) sage: G.group_id() [12, 4]

identity
()¶ Return the identity element of this group.
EXAMPLES:
sage: G = PermutationGroup([[(1,2,3),(4,5)]]) sage: e = G.identity() sage: e () sage: g = G.gen(0) sage: g*e (1,2,3)(4,5) sage: e*g (1,2,3)(4,5) sage: S = SymmetricGroup(['a','b','c']) sage: S.identity() ()

intersection
(other)¶ Returns the permutation group that is the intersection of
self
andother
.INPUT:
other
 a permutation group.
OUTPUT:
A permutation group that is the settheoretic intersection of
self
withother
. The groups are viewed as subgroups of a symmetric group big enough to contain both group’s symbol sets. So there is no strict notion of the two groups being subgroups of a common parent.EXAMPLES:
sage: H = DihedralGroup(4) sage: K = CyclicPermutationGroup(4) sage: H.intersection(K) Permutation Group with generators [(1,2,3,4)] sage: L = DihedralGroup(5) sage: H.intersection(L) Permutation Group with generators [(1,4)(2,3)] sage: M = PermutationGroup(["()"]) sage: H.intersection(M) Permutation Group with generators [()]
Some basic properties.
sage: H = DihedralGroup(4) sage: L = DihedralGroup(5) sage: H.intersection(L) == L.intersection(H) True sage: H.intersection(H) == H True
The group
other
is verified as such.sage: H = DihedralGroup(4) sage: H.intersection('junk') Traceback (most recent call last): ... TypeError: junk is not a permutation group

irreducible_characters
()¶ Returns a list of the irreducible characters of
self
.EXAMPLES:
sage: irr = SymmetricGroup(3).irreducible_characters() sage: [x.values() for x in irr] [[1, 1, 1], [2, 0, 1], [1, 1, 1]]

is_abelian
()¶ Return
True
if this group is abelian.EXAMPLES:
sage: G = PermutationGroup(['(1,2,3)(4,5)', '(1,2,3,4,5)']) sage: G.is_abelian() False sage: G = PermutationGroup(['(1,2,3)(4,5)']) sage: G.is_abelian() True

is_commutative
()¶ Return
True
if this group is commutative.EXAMPLES:
sage: G = PermutationGroup(['(1,2,3)(4,5)', '(1,2,3,4,5)']) sage: G.is_commutative() False sage: G = PermutationGroup(['(1,2,3)(4,5)']) sage: G.is_commutative() True

is_cyclic
()¶ Return
True
if this group is cyclic.EXAMPLES:
sage: G = PermutationGroup(['(1,2,3)(4,5)', '(1,2,3,4,5)']) sage: G.is_cyclic() False sage: G = PermutationGroup(['(1,2,3)(4,5)']) sage: G.is_cyclic() True

is_elementary_abelian
()¶ Return
True
if this group is elementary abelian. An elementary abelian group is a finite abelian group, where every nontrivial element has order \(p\), where \(p\) is a prime.EXAMPLES:
sage: G = PermutationGroup(['(1,2,3)(4,5)', '(1,2,3,4,5)']) sage: G.is_elementary_abelian() False sage: G = PermutationGroup(['(1,2,3)','(4,5,6)']) sage: G.is_elementary_abelian() True

is_isomorphic
(right)¶ Return
True
if the groups are isomorphic.INPUT:
self
 this groupright
 a permutation group
OUTPUT:
 boolean;
True
ifself
andright
are isomorphic groups;False
otherwise.
EXAMPLES:
sage: v = ['(1,2,3)(4,5)', '(1,2,3,4,5)'] sage: G = PermutationGroup(v) sage: H = PermutationGroup(['(1,2,3)(4,5)']) sage: G.is_isomorphic(H) False sage: G.is_isomorphic(G) True sage: G.is_isomorphic(PermutationGroup(list(reversed(v)))) True

is_monomial
()¶ Returns
True
if the group is monomial. A finite group is monomial if every irreducible complex character is induced from a linear character of a subgroup.EXAMPLES:
sage: G = PermutationGroup(['(1,2,3)(4,5)']) sage: G.is_monomial() True

is_nilpotent
()¶ Return
True
if this group is nilpotent.EXAMPLES:
sage: G = PermutationGroup(['(1,2,3)(4,5)', '(1,2,3,4,5)']) sage: G.is_nilpotent() False sage: G = PermutationGroup(['(1,2,3)(4,5)']) sage: G.is_nilpotent() True

is_normal
(other)¶ Return
True
if this group is a normal subgroup ofother
.EXAMPLES:
sage: AlternatingGroup(4).is_normal(SymmetricGroup(4)) True sage: H = PermutationGroup(['(1,2,3)(4,5)']) sage: G = PermutationGroup(['(1,2,3)(4,5)', '(1,2,3,4,5)']) sage: H.is_normal(G) False

is_perfect
()¶ Return
True
if this group is perfect. A group is perfect if it equals its derived subgroup.EXAMPLES:
sage: G = PermutationGroup(['(1,2,3)(4,5)', '(1,2,3,4,5)']) sage: G.is_perfect() False sage: G = PermutationGroup(['(1,2,3)(4,5)']) sage: G.is_perfect() False

is_pgroup
()¶ Returns
True
if this group is a \(p\)group. A finite group is a \(p\)group if its order is of the form \(p^n\) for a prime integer \(p\) and a nonnegative integer \(n\).EXAMPLES:
sage: G = PermutationGroup(['(1,2,3,4,5)']) sage: G.is_pgroup() True

is_polycyclic
()¶ Return
True
if this group is polycyclic. A group is polycyclic if it has a subnormal series with cyclic factors. (For finite groups, this is the same as if the group is solvable  seeis_solvable
.)EXAMPLES:
sage: G = PermutationGroup(['(1,2,3)(4,5)', '(1,2,3,4,5)']) sage: G.is_polycyclic() False sage: G = PermutationGroup(['(1,2,3)(4,5)']) sage: G.is_polycyclic() True

is_primitive
(domain=None)¶ Returns
True
ifself
acts primitively ondomain
. A group \(G\) acts primitively on a set \(S\) if \(G\) acts transitively on \(S\) and
 the action induces no nontrivial block system on \(S\).
INPUT:
domain
(optional)
See also
EXAMPLES:
By default, test for primitivity of
self
on its domain:sage: G = PermutationGroup([[(1,2,3,4)],[(1,2)]]) sage: G.is_primitive() True sage: G = PermutationGroup([[(1,2,3,4)],[(2,4)]]) sage: G.is_primitive() False
You can specify a domain on which to test primitivity:
sage: G = PermutationGroup([[(1,2,3,4)],[(2,4)]]) sage: G.is_primitive([1..4]) False sage: G.is_primitive([1,2,3]) True sage: G = PermutationGroup([[(3,4,5,6)],[(3,4)]]) #S_4 on [3..6] sage: G.is_primitive(G.non_fixed_points()) True

is_regular
(domain=None)¶ Returns
True
ifself
acts regularly ondomain
. A group \(G\) acts regularly on a set \(S\) if \(G\) acts transitively on \(S\) and
 \(G\) acts semiregularly on \(S\).
EXAMPLES:
sage: G = PermutationGroup([[(1,2,3,4)]]) sage: G.is_regular() True sage: G = PermutationGroup([[(1,2,3,4)],[(5,6)]]) sage: G.is_regular() False
You can pass in a domain on which to test regularity:
sage: G = PermutationGroup([[(1,2,3,4)],[(5,6)]]) sage: G.is_regular([1..4]) True sage: G.is_regular(G.non_fixed_points()) False

is_semi_regular
(domain=None)¶ Returns
True
ifself
acts semiregularly ondomain
. A group \(G\) acts semiregularly on a set \(S\) if the point stabilizers of \(S\) in \(G\) are trivial.domain
is optional and may take several forms. See examples.EXAMPLES:
sage: G = PermutationGroup([[(1,2,3,4)]]) sage: G.is_semi_regular() True sage: G = PermutationGroup([[(1,2,3,4)],[(5,6)]]) sage: G.is_semi_regular() False
You can pass in a domain to test semiregularity:
sage: G = PermutationGroup([[(1,2,3,4)],[(5,6)]]) sage: G.is_semi_regular([1..4]) True sage: G.is_semi_regular(G.non_fixed_points()) False

is_simple
()¶ Returns
True
if the group is simple. A group is simple if it has no proper normal subgroups.EXAMPLES:
sage: G = PermutationGroup(['(1,2,3)(4,5)']) sage: G.is_simple() False

is_solvable
()¶ Returns
True
if the group is solvable.EXAMPLES:
sage: G = PermutationGroup(['(1,2,3)(4,5)']) sage: G.is_solvable() True

is_subgroup
(other)¶ Returns
True
ifself
is a subgroup ofother
.EXAMPLES:
sage: G = AlternatingGroup(5) sage: H = SymmetricGroup(5) sage: G.is_subgroup(H) True

is_supersolvable
()¶ Returns
True
if the group is supersolvable. A finite group is supersolvable if it has a normal series with cyclic factors.EXAMPLES:
sage: G = PermutationGroup(['(1,2,3)(4,5)']) sage: G.is_supersolvable() True

is_transitive
(domain=None)¶ Returns
True
ifself
acts transitively ondomain
. A group \(G\) acts transitively on set \(S\) if for all \(x,y\in S\) there is some \(g\in G\) such that \(x^g=y\).EXAMPLES:
sage: G = SymmetricGroup(5) sage: G.is_transitive() True sage: G = PermutationGroup(['(1,2)(3,4)(5,6)']) sage: G.is_transitive() False
sage: G = PermutationGroup([[(1,2,3,4,5)],[(1,2)]]) #S_5 on [1..5] sage: G.is_transitive([1,4,5]) True sage: G.is_transitive([2..6]) False sage: G.is_transitive(G.non_fixed_points()) True sage: H = PermutationGroup([[(1,2,3)],[(4,5,6)]]) sage: H.is_transitive(H.non_fixed_points()) False
Note that this differs from the definition in GAP, where
IsTransitive
returns whether the group is transitive on the set of points moved by the group.sage: G = PermutationGroup([(2,3)]) sage: G.is_transitive() False sage: gap(G).IsTransitive() true

isomorphism_to
(right)¶ Return an isomorphism from
self
toright
if the groups are isomorphic, otherwiseNone
.INPUT:
self
 this groupright
 a permutation group
OUTPUT:
None
or a morphism of permutation groups.
EXAMPLES:
sage: G = PermutationGroup(['(1,2,3)(4,5)', '(1,2,3,4,5)']) sage: H = PermutationGroup(['(1,2,3)(4,5)']) sage: G.isomorphism_to(H) is None True sage: G = PermutationGroup([(1,2,3), (2,3)]) sage: H = PermutationGroup([(1,2,4), (1,4)]) sage: G.isomorphism_to(H) # not tested, see below Permutation group morphism: From: Permutation Group with generators [(2,3), (1,2,3)] To: Permutation Group with generators [(1,2,4), (1,4)] Defn: [(2,3), (1,2,3)] > [(2,4), (1,2,4)]

isomorphism_type_info_simple_group
()¶ If the group is simple, then this returns the name of the group.
EXAMPLES:
sage: G = CyclicPermutationGroup(5) sage: G.isomorphism_type_info_simple_group() rec( name := "Z(5)", parameter := 5, series := "Z", shortname := "C5" )

iteration
(algorithm='SGS')¶ Return an iterator over the elements of this group.
INPUT:
algorithm
– (default:"SGS"
) either"SGS"
 using strong generating system"BFS"
 a breadth first search on the Cayley graph with respect to
self.gens()
"DFS"
 a depth first search on the Cayley graph with respect to
self.gens()
Note
In general, the algorithm
"SGS"
is faster. Yet, for small groups,"BFS"
and"DFS"
might be faster.Note
The order in which the iterator visits the elements differs in the algorithms.
EXAMPLES:
sage: G = PermutationGroup([[(1,2)], [(2,3)]]) sage: list(G.iteration()) [(), (1,2,3), (1,3,2), (2,3), (1,2), (1,3)] sage: list(G.iteration(algorithm="BFS")) [(), (2,3), (1,2), (1,3,2), (1,2,3), (1,3)] sage: list(G.iteration(algorithm="DFS")) [(), (1,2), (1,3,2), (1,3), (1,2,3), (2,3)]

largest_moved_point
()¶ Return the largest point moved by a permutation in this group.
EXAMPLES:
sage: G = PermutationGroup([[(1,2),(3,4)], [(1,2,3,4)]]) sage: G.largest_moved_point() 4 sage: G = PermutationGroup([[(1,2),(3,4)], [(1,2,3,4,10)]]) sage: G.largest_moved_point() 10
sage: G = PermutationGroup([[('a','b','c'),('d','e')]]) sage: G.largest_moved_point() 'e'
Warning
The name of this function is not good; this function should be deprecated in term of degree:
sage: P = PermutationGroup([[1,2,3,4]]) sage: P.largest_moved_point() 4 sage: P.cardinality() 1

list
()¶ Return list of all elements of this group.
EXAMPLES:
sage: G = PermutationGroup([[(1,2,3,4)], [(1,2)]]) sage: G.list() [(), (1,4)(2,3), (1,2)(3,4), (1,3)(2,4), (2,4,3), (1,4,2), (1,2,3), (1,3,4), (2,3,4), (1,4,3), (1,2,4), (1,3,2), (3,4), (1,4,2,3), (1,2), (1,3,2,4), (2,4), (1,4,3,2), (1,2,3,4), (1,3), (2,3), (1,4), (1,2,4,3), (1,3,4,2)] sage: G = PermutationGroup([[('a','b')]], domain=('a', 'b')); G Permutation Group with generators [('a','b')] sage: G.list() [(), ('a','b')]

lower_central_series
()¶ Return the lower central series of this group as a list of permutation groups.
EXAMPLES:
These computations use pseudorandom numbers, so we set the seed for reproducible testing.
sage: set_random_seed(0) sage: G = PermutationGroup([[(1,2,3),(4,5)],[(3,4)]]) sage: G.lower_central_series() [Subgroup generated by [(3,4), (1,2,3)(4,5)] of (Permutation Group with generators [(3,4), (1,2,3)(4,5)]), Subgroup generated by [(1,3,5), (1,5)(3,4), (1,5)(2,4)] of (Permutation Group with generators [(3,4), (1,2,3)(4,5)])]

minimal_generating_set
()¶ Return a minimal generating set
EXAMPLES:
sage: g = graphs.CompleteGraph(4) sage: g.relabel(['a','b','c','d']) sage: mgs = g.automorphism_group().minimal_generating_set(); len(mgs) 2 sage: mgs # random [('b','d','c'), ('a','c','b','d')]

molien_series
()¶ Return the Molien series of a permutation group. The function
\[M(x) = (1/G)\sum_{g\in G} \det(1x*g)^{1}\]is sometimes called the “Molien series” of \(G\). GAP’s
MolienSeries
is associated to a character of a group \(G\). How are these related? A group \(G\), given as a permutation group on \(n\) points, has a “natural” representation of dimension \(n\), given by permutation matrices. The Molien series of \(G\) is the one associated to that permutation representation of \(G\) using the above formula. Character values then count fixed points of the corresponding permutations.EXAMPLES:
sage: G = SymmetricGroup(5) sage: G.molien_series() 1/(x^15  x^14  x^13 + x^10 + x^9 + x^8  x^7  x^6  x^5 + x^2 + x  1) sage: G = SymmetricGroup(3) sage: G.molien_series() 1/(x^6  x^5  x^4 + x^2 + x  1)
Some further tests (after trac ticket #15817):
sage: G = PermutationGroup([[(1,2,3,4)]]) sage: S4ms = SymmetricGroup(4).molien_series() sage: G.molien_series() / S4ms x^5 + 2*x^4 + x^3 + x^2 + 1
This works for nottransitive groups:
sage: G = PermutationGroup([[(1,2)],[(3,4)]]) sage: G.molien_series() / S4ms x^4 + x^3 + 2*x^2 + x + 1
This works for groups with fixed points:
sage: G = PermutationGroup([[(2,)]]) sage: G.molien_series() 1/(x^2  2*x + 1)

ngens
()¶ Return the number of generators of
self
.EXAMPLES:
sage: A4 = PermutationGroup([[(1,2,3)], [(2,3,4)]]); A4 Permutation Group with generators [(2,3,4), (1,2,3)] sage: A4.ngens() 2

non_fixed_points
()¶ Return the list of points not fixed by
self
, i.e., the subset ofself.domain()
moved by some element ofself
.EXAMPLES:
sage: G = PermutationGroup([[(3,4,5)],[(7,10)]]) sage: G.non_fixed_points() [3, 4, 5, 7, 10] sage: G = PermutationGroup([[(2,3,6)],[(9,)]]) # note: 9 is fixed sage: G.non_fixed_points() [2, 3, 6]

normal_subgroups
()¶ Return the normal subgroups of this group as a (sorted in increasing order) list of permutation groups.
The normal subgroups of \(H = PSL(2,7) \times PSL(2,7)\) are \(1\), two copies of \(PSL(2,7)\) and \(H\) itself, as the following example shows.
EXAMPLES:
sage: G = PSL(2,7) sage: D = G.direct_product(G) sage: H = D[0] sage: NH = H.normal_subgroups() sage: len(NH) 4 sage: NH[1].is_isomorphic(G) True sage: NH[2].is_isomorphic(G) True

normalizer
(g)¶ Returns the normalizer of
g
inself
.EXAMPLES:
sage: G = PermutationGroup([[(1,2),(3,4)], [(1,2,3,4)]]) sage: g = G([(1,3)]) sage: G.normalizer(g) Subgroup generated by [(2,4), (1,3)] of (Permutation Group with generators [(1,2)(3,4), (1,2,3,4)]) sage: g = G([(1,2,3,4)]) sage: G.normalizer(g) Subgroup generated by [(2,4), (1,2,3,4), (1,3)(2,4)] of (Permutation Group with generators [(1,2)(3,4), (1,2,3,4)]) sage: H = G.subgroup([G([(1,2,3,4)])]) sage: G.normalizer(H) Subgroup generated by [(2,4), (1,2,3,4), (1,3)(2,4)] of (Permutation Group with generators [(1,2)(3,4), (1,2,3,4)])

normalizes
(other)¶ Returns
True
if the groupother
is normalized byself
. Wraps GAP’sIsNormal
function.A group \(G\) normalizes a group \(U\) if and only if for every \(g \in G\) and \(u \in U\) the element \(u^g\) is a member of \(U\). Note that \(U\) need not be a subgroup of \(G\).
EXAMPLES:
sage: G = PermutationGroup(['(1,2,3)(4,5)']) sage: H = PermutationGroup(['(1,2,3)(4,5)', '(1,2,3,4,5)']) sage: H.normalizes(G) False sage: G = SymmetricGroup(3) sage: H = PermutationGroup( [ (4,5,6) ] ) sage: G.normalizes(H) True sage: H.normalizes(G) True
In the last example, \(G\) and \(H\) are disjoint, so each normalizes the other.

orbit
(point, action='OnPoints')¶ Return the orbit of a point under a group action.
INPUT:
point
– can be a point or any of the list above, depending on the action to be considered.action
– string. ifpoint
is an element from the domain, a tuple of elements of the domain, a tuple of tuples […], this variable describes how the group is acting.The actions currently available through this method are
"OnPoints"
,"OnTuples"
,"OnSets"
,"OnPairs"
,"OnSetsSets"
,"OnSetsDisjointSets"
,"OnSetsTuples"
,"OnTuplesSets"
,"OnTuplesTuples"
. They are taken from GAP’s list of group actions, seegap.help('Group Actions')
.It is set to
"OnPoints"
by default. See below for examples.
OUTPUT:
The orbit of
point
as a tuple. Each entry is an image under the action of the permutation group, if necessary converted to the corresponding container. That is, ifaction='OnSets'
then each entry will be a set even ifpoint
was given by a list/tuple/iterable.EXAMPLES:
sage: G = PermutationGroup([ [(3,4)], [(1,3)] ]) sage: G.orbit(3) (3, 4, 1) sage: G = PermutationGroup([[(1,2),(3,4)], [(1,2,3,4,10)]]) sage: G.orbit(3) (3, 4, 10, 1, 2) sage: G = PermutationGroup([ [('c','d')], [('a','c')] ]) sage: G.orbit('a') ('a', 'c', 'd')
Action of \(S_3\) on sets:
sage: S3 = groups.permutation.Symmetric(3) sage: S3.orbit((1,2), action = "OnSets") ({1, 2}, {2, 3}, {1, 3})
On tuples:
sage: S3.orbit((1,2), action = "OnTuples") ((1, 2), (2, 3), (2, 1), (3, 1), (1, 3), (3, 2))
Action of \(S_4\) on sets of disjoint sets:
sage: S4 = groups.permutation.Symmetric(4) sage: O = S4.orbit(((1,2),(3,4)), action = "OnSetsDisjointSets") sage: {1, 2} in O[0] and {3, 4} in O[0] True sage: {1, 4} in O[1] and {2, 3} in O[1] True sage: all(set(union(*x)) == {1,2,3,4} for x in O) True
Action of \(S_4\) (on a nonstandard domain) on tuples of sets:
sage: S4 = PermutationGroup([ [('c','d')], [('a','c')], [('a','b')] ]) sage: S4.orbit((('a','c'),('b','d')),"OnTuplesSets") # py2 (({'a', 'c'}, {'b', 'd'}), ({'a', 'd'}, {'c', 'b'}), ({'c', 'b'}, {'a', 'd'}), ({'b', 'd'}, {'a', 'c'}), ({'c', 'd'}, {'a', 'b'}), ({'a', 'b'}, {'c', 'd'}))
Action of \(S_4\) (on a very nonstandard domain) on tuples of sets:
sage: S4 = PermutationGroup([ [((11,(12,13)),'d')], ....: [((12,(12,11)),(11,(12,13)))], [((12,(12,11)),'b')] ]) sage: S4.orbit((( (11,(12,13)), (12,(12,11))),('b','d')),"OnTuplesSets") # py2 (({(11, (12, 13)), (12, (12, 11))}, {'b', 'd'}), ({'d', (12, (12, 11))}, {(11, (12, 13)), 'b'}), ({(11, (12, 13)), 'b'}, {'d', (12, (12, 11))}), ({(11, (12, 13)), 'd'}, {'b', (12, (12, 11))}), ({'b', 'd'}, {(11, (12, 13)), (12, (12, 11))}), ({'b', (12, (12, 11))}, {(11, (12, 13)), 'd'}))

orbits
()¶ Returns the orbits of the elements of the domain under the default group action.
EXAMPLES:
sage: G = PermutationGroup([ [(3,4)], [(1,3)] ]) sage: G.orbits() [[1, 3, 4], [2]] sage: G = PermutationGroup([[(1,2),(3,4)], [(1,2,3,4,10)]]) sage: G.orbits() [[1, 2, 3, 4, 10], [5], [6], [7], [8], [9]] sage: G = PermutationGroup([ [('c','d')], [('a','c')],[('b',)]]) sage: G.orbits() [['a', 'c', 'd'], ['b']]
The answer is cached:
sage: G.orbits() is G.orbits() True
AUTHORS:
 Nathan Dunfield

order
()¶ Return the number of elements of this group. See also: G.degree()
EXAMPLES:
sage: G = PermutationGroup([[(1,2,3),(4,5)], [(1,2)]]) sage: G.order() 12 sage: G = PermutationGroup([()]) sage: G.order() 1 sage: G = PermutationGroup([]) sage: G.order() 1
cardinality
is just an alias:sage: PermutationGroup([(1,2,3)]).cardinality() 3

poincare_series
(p=2, n=10)¶ Return the Poincaré series of \(G \mod p\) (\(p \geq 2\) must be a prime), for \(n\) large.
In other words, if you input a finite group \(G\), a prime \(p\), and a positive integer \(n\), it returns a quotient of polynomials \(f(x) = P(x) / Q(x)\) whose coefficient of \(x^k\) equals the rank of the vector space \(H_k(G, \ZZ / p \ZZ)\), for all \(k\) in the range \(1 \leq k \leq n\).
REQUIRES: GAP package HAP (in gap_packages*.spkg).
EXAMPLES:
sage: G = SymmetricGroup(5) sage: G.poincare_series(2,10) # optional  gap_packages (x^2 + 1)/(x^4  x^3  x + 1) sage: G = SymmetricGroup(3) sage: G.poincare_series(2,10) # optional  gap_packages 1/(x  1)
AUTHORS:
 David Joyner and Graham Ellis

quotient
(N)¶ Returns the quotient of this permutation group by the normal subgroup \(N\), as a permutation group.
Wraps the GAP operator “/”.
EXAMPLES:
sage: G = PermutationGroup([(1,2,3), (2,3)]) sage: N = PermutationGroup([(1,2,3)]) sage: G.quotient(N) Permutation Group with generators [(1,2)] sage: G.quotient(G) Permutation Group with generators [()]

random_element
()¶ Return a random element of this group.
EXAMPLES:
sage: G = PermutationGroup([[(1,2,3),(4,5)], [(1,2)]]) sage: a = G.random_element() sage: a in G True sage: a.parent() is G True sage: a^6 ()

representative_action
(x, y)¶ Return an element of self that maps \(x\) to \(y\) if it exists.
This method wraps the gap function
RepresentativeAction
, which can also return elements that map a given set of points on another set of points.INPUT:
x,y
– two elements of the domain.
EXAMPLES:
sage: G = groups.permutation.Cyclic(14) sage: g = G.representative_action(1,10) sage: all(g(x) == 1+((x+91)%14) for x in G.domain()) True

semidirect_product
(N, mapping, check=True)¶ The semidirect product of
self
withN
.INPUT:
N
 A group which is acted on byself
and naturally embeds as a normal subgroup of the returned semidirect product.mapping
 A pair of lists that together define a homomorphism, \(\phi :\) self \(\rightarrow\) Aut(N), by giving, in the second list, the images of the generators ofself
in the order given in the first list.check
 A boolean that, if set to False, will skip the initial tests which are made onmapping
. This may be beneficial for largeN
, since in such cases the injectivity test can be expensive. Set to True by default.
OUTPUT:
The semidirect product of
self
andN
defined by the action ofself
onN
given inmapping
(note that a homomorphism from A to the automorphism group of B is equivalent to an action of A on the B’s underlying set). The semidirect product of two groups, \(H\) and \(N\), is a construct similar to the direct product in so far as the elements are the Cartesian product of the elements of \(H\) and the elements of \(N\). The operation, however, is built upon an action of \(H\) on \(N\), and is defined as such:\[(h_1,n_1)(h_2,n_2) = (h_{1}h_{2}, n_{1}^{h_2}n_2)\]This function is a wrapper for GAP’s
SemidirectProduct
command. The permutation group returned is built upon a permutation representation of the semidirect product ofself
andN
on a set of size \(\mid N \mid\). The generators ofN
are given as their right regular representations, while the generators ofself
are defined by the underlying action ofself
onN
. It should be noted that the defining action is not always faithful, and in this case the inputted representations of the generators ofself
are placed on additional letters and adjoined to the output’s generators ofself
.EXAMPLES:
Perhaps the most common example of a semidirect product comes from the family of dihedral groups. Each dihedral group is the semidirect product of \(C_2\) with \(C_n\), where, by convention, \(3 \leq n\). In this case, the nontrivial element of \(C_2\) acts on \(C_n\) so as to send each element to its inverse.
sage: C2 = CyclicPermutationGroup(2) sage: C8 = CyclicPermutationGroup(8) sage: alpha = PermutationGroupMorphism_im_gens(C8,C8,[(1,8,7,6,5,4,3,2)]) sage: S = C2.semidirect_product(C8,[[(1,2)],[alpha]]) sage: S == DihedralGroup(8) False sage: S.is_isomorphic(DihedralGroup(8)) True sage: S.gens() [(3,4,5,6,7,8,9,10), (1,2)(4,10)(5,9)(6,8)]
A more complicated example can be drawn from [TW1980]. It is there given that a semidirect product of \(D_4\) and \(C_3\) is isomorphic to one of \(C_2\) and the dicyclic group of order 12. This nonabelian group of order 24 has very similar structure to the dicyclic and dihedral groups of order 24, the three being the only groups of order 24 with a twoelement center and 9 conjugacy classes.
sage: D4 = DihedralGroup(4) sage: C3 = CyclicPermutationGroup(3) sage: alpha1 = PermutationGroupMorphism_im_gens(C3,C3,[(1,3,2)]) sage: alpha2 = PermutationGroupMorphism_im_gens(C3,C3,[(1,2,3)]) sage: S1 = D4.semidirect_product(C3,[[(1,2,3,4),(1,3)],[alpha1,alpha2]]) sage: C2 = CyclicPermutationGroup(2) sage: Q = DiCyclicGroup(3) sage: a = Q.gens()[0]; b=Q.gens()[1].inverse() sage: alpha = PermutationGroupMorphism_im_gens(Q,Q,[a,b]) sage: S2 = C2.semidirect_product(Q,[[(1,2)],[alpha]]) sage: S1.is_isomorphic(S2) True sage: S1.is_isomorphic(DihedralGroup(12)) False sage: S1.is_isomorphic(DiCyclicGroup(6)) False sage: S1.center() Subgroup generated by [(1,3)(2,4)] of (Permutation Group with generators [(5,6,7), (1,2,3,4)(6,7), (1,3)]) sage: len(S1.conjugacy_classes_representatives()) 9
If your normal subgroup is large, and you are confident that your inputs will successfully create a semidirect product, then it is beneficial, for the sake of time efficiency, to set the
check
parameter toFalse
.sage: C2 = CyclicPermutationGroup(2) sage: C2000 = CyclicPermutationGroup(500) sage: alpha = PermutationGroupMorphism(C2000,C2000,[C2000.gen().inverse()]) sage: S = C2.semidirect_product(C2000,[[(1,2)],[alpha]],check=False)
AUTHOR:
 Kevin Halasz (2012812)

smallest_moved_point
()¶ Return the smallest point moved by a permutation in this group.
EXAMPLES:
sage: G = PermutationGroup([[(3,4)], [(2,3,4)]]) sage: G.smallest_moved_point() 2 sage: G = PermutationGroup([[(1,2),(3,4)], [(1,2,3,4,10)]]) sage: G.smallest_moved_point() 1
Note that this function uses the ordering from the domain:
sage: S = SymmetricGroup(['a','b','c']) sage: S.smallest_moved_point() 'a'

socle
()¶ Returns the socle of
self
. The socle of a group \(G\) is the subgroup generated by all minimal normal subgroups.EXAMPLES:
sage: G=SymmetricGroup(4) sage: G.socle() Subgroup generated by [(1,2)(3,4), (1,4)(2,3)] of (Symmetric group of order 4! as a permutation group) sage: G.socle().socle() Subgroup generated by [(1,2)(3,4), (1,4)(2,3)] of (Subgroup generated by [(1,2)(3,4), (1,4)(2,3)] of (Symmetric group of order 4! as a permutation group))

solvable_radical
()¶ Returns the solvable radical of
self
. The solvable radical (or just radical) of a group \(G\) is the largest solvable normal subgroup of \(G\).EXAMPLES:
sage: G=SymmetricGroup(4) sage: G.solvable_radical() Subgroup generated by [(1,2), (1,2,3,4)] of (Symmetric group of order 4! as a permutation group) sage: G=SymmetricGroup(5) sage: G.solvable_radical() Subgroup generated by [()] of (Symmetric group of order 5! as a permutation group)

stabilizer
(point, action='OnPoints')¶ Return the subgroup of
self
which stabilize the given position.self
and its stabilizers must have same degree.INPUT:
point
– a point of thedomain()
, or a set of points depending on the value ofaction
.action
(string; default"OnPoints"
) – should the group be considered to act on points (action="OnPoints"
) or on sets of points (action="OnSets"
) ? In the latter case, the first argument must be a subset ofdomain()
.
EXAMPLES:
sage: G = PermutationGroup([ [(3,4)], [(1,3)] ]) sage: G.stabilizer(1) Subgroup generated by [(3,4)] of (Permutation Group with generators [(3,4), (1,3)]) sage: G.stabilizer(3) Subgroup generated by [(1,4)] of (Permutation Group with generators [(3,4), (1,3)])
The stabilizer of a set of points:
sage: s10 = groups.permutation.Symmetric(10) sage: s10.stabilizer([1..3],"OnSets").cardinality() 30240 sage: factorial(3)*factorial(7) 30240
sage: G = PermutationGroup([[(1,2),(3,4)], [(1,2,3,4,10)]]) sage: G.stabilizer(10) Subgroup generated by [(2,3,4), (1,2)(3,4)] of (Permutation Group with generators [(1,2)(3,4), (1,2,3,4,10)]) sage: G.stabilizer(1) Subgroup generated by [(2,3)(4,10), (2,10,3)] of (Permutation Group with generators [(1,2)(3,4), (1,2,3,4,10)]) sage: G = PermutationGroup([[(2,3,4)],[(6,7)]]) sage: G.stabilizer(1) Subgroup generated by [(6,7), (2,3,4)] of (Permutation Group with generators [(6,7), (2,3,4)]) sage: G.stabilizer(2) Subgroup generated by [(6,7)] of (Permutation Group with generators [(6,7), (2,3,4)]) sage: G.stabilizer(3) Subgroup generated by [(6,7)] of (Permutation Group with generators [(6,7), (2,3,4)]) sage: G.stabilizer(4) Subgroup generated by [(6,7)] of (Permutation Group with generators [(6,7), (2,3,4)]) sage: G.stabilizer(5) Subgroup generated by [(6,7), (2,3,4)] of (Permutation Group with generators [(6,7), (2,3,4)]) sage: G.stabilizer(6) Subgroup generated by [(2,3,4)] of (Permutation Group with generators [(6,7), (2,3,4)]) sage: G.stabilizer(7) Subgroup generated by [(2,3,4)] of (Permutation Group with generators [(6,7), (2,3,4)]) sage: G.stabilizer(8) Traceback (most recent call last): ... ValueError: 8 does not belong to the domain
sage: G = PermutationGroup([ [('c','d')], [('a','c')] ], domain='abcd') sage: G.stabilizer('a') Subgroup generated by [('c','d')] of (Permutation Group with generators [('c','d'), ('a','c')]) sage: G.stabilizer('b') Subgroup generated by [('c','d'), ('a','c')] of (Permutation Group with generators [('c','d'), ('a','c')]) sage: G.stabilizer('c') Subgroup generated by [('a','d')] of (Permutation Group with generators [('c','d'), ('a','c')]) sage: G.stabilizer('d') Subgroup generated by [('a','c')] of (Permutation Group with generators [('c','d'), ('a','c')])

strong_generating_system
(base_of_group=None, implementation='sage')¶ Return a Strong Generating System of
self
according the given base for the right action ofself
on itself.base_of_group
is a list of the positions on whichself
acts, in any order. The algorithm returns a list of transversals and each transversal is a list of permutations. By default,base_of_group
is[1, 2, 3, ..., d]
where \(d\) is the degree of the group.For
base_of_group
= \([ \mathrm{pos}_1, \mathrm{pos}_2, \dots , \mathrm{pos}_d]\) let \(G_i\) be the subgroup of \(G\) =self
which stabilizes \(\mathrm{pos}_1, \mathrm{pos}_2, \dots , \mathrm{pos}_i\), so\[G = G_0 \supset G_1 \supset G_2 \supset \dots \supset G_n = \{e\}\]Then the algorithm returns \([ G_i.\mathrm{transversals}(\mathrm{pos}_{i+1})]_{1 \leq i \leq n}\)
INPUT:
base_of_group
(optional) – (default:[1, 2, 3, ..., d]
) a list containing the integers \(1, 2, \ldots , d\) in any order, where \(d\) is the degree ofself
implementation
– (default:"sage"
) either"sage"
 use the direct implementation in Sage"gap"
 if used, thebase_of_group
must beNone
 and the computation is directly performed in GAP
OUTPUT:
A list of lists of permutations from the group, which form a strong generating system.
Warning
The outputs for implementations
"sage"
and"gap"
differ: First, the output is reversed, and second, it might be that"sage"
does not contain the trivial subgroup while"gap"
does.Also, both algorithms might yield different results based on the order in which
base_of_group
is given in the first situation.EXAMPLES:
sage: G = PermutationGroup([[(7,8)],[(3,4)],[(4,5)]]) sage: G.strong_generating_system() [[()], [()], [(), (3,4), (3,5,4)], [(), (4,5)], [()], [()], [(), (7,8)], [()]] sage: G = PermutationGroup([[(1,2,3,4)],[(1,2)]]) sage: G.strong_generating_system() [[(), (1,2)(3,4), (1,3)(2,4), (1,4)(2,3)], [(), (2,4), (2,3,4)], [(), (3,4)], [()]] sage: G = PermutationGroup([[(1,2,3)],[(4,5,7)],[(1,4,6)]]) sage: G.strong_generating_system() [[(), (1,2,3), (1,4,6), (1,3,2), (1,5,7,4,6), (1,6,4), (1,7,5,4,6)], [(), (2,3,6), (2,6,3), (2,7,5,6,3), (2,5,6,3)(4,7), (2,4,5,6,3)], [(), (3,5,6), (3,4,7,5,6), (3,6)(5,7), (3,7,4,5,6)], [(), (4,7,5), (4,5,7), (4,6,7)], [(), (5,6,7), (5,7,6)], [()], [()]] sage: G = PermutationGroup([[(1,2,3)],[(2,3,4)],[(3,4,5)]]) sage: G.strong_generating_system([5,4,3,2,1]) [[(), (1,5,3,4,2), (1,5,4,3,2), (1,5)(2,3), (1,5,2)], [(1,4)(2,3), (1,4,3), (1,4,2), ()], [(1,2,3), (1,3,2), ()], [()], [()]] sage: G = PermutationGroup([[(3,4)]]) sage: G.strong_generating_system() [[()], [()], [(), (3,4)], [()]] sage: G.strong_generating_system(base_of_group=[3,1,2,4]) [[(), (3,4)], [()], [()], [()]] sage: G = TransitiveGroup(12,17) sage: G.strong_generating_system() [[(), (1,4,11,2)(3,6,5,8)(7,10,9,12), (1,8,3,2)(4,11,10,9)(5,12,7,6), (1,7)(2,8)(3,9)(4,10)(5,11)(6,12), (1,12,7,2)(3,10,9,8)(4,11,6,5), (1,11)(2,8)(3,5)(4,10)(6,12)(7,9), (1,10,11,8)(2,3,12,5)(4,9,6,7), (1,3)(2,8)(4,10)(5,7)(6,12)(9,11), (1,2,3,8)(4,9,10,11)(5,6,7,12), (1,6,7,8)(2,3,4,9)(5,10,11,12), (1,5,9)(3,11,7), (1,9,5)(3,7,11)], [(), (2,6,10)(4,12,8), (2,10,6)(4,8,12)], [()], [()], [()], [()], [()], [()], [()], [()], [()], [()]] sage: A = PermutationGroup([(1,2),(1,2,3,4,5,6,7,8,9)]) sage: X = A.strong_generating_system() sage: Y = A.strong_generating_system(implementation="gap") sage: [len(x) for x in X] [9, 8, 7, 6, 5, 4, 3, 2, 1] sage: [len(y) for y in Y] [1, 2, 3, 4, 5, 6, 7, 8, 9]

structure_description
(G, latex=False)¶ Return a string that tries to describe the structure of
G
.This methods wraps GAP’s
StructureDescription
method.For full details, including the form of the returned string and the algorithm to build it, see GAP’s documentation.
INPUT:
latex
– a boolean (default:False
). IfTrue
return a LaTeX formatted string.
OUTPUT:
 string
Warning
From GAP’s documentation: The string returned by
StructureDescription
is not an isomorphism invariant: nonisomorphic groups can have the same string value, and two isomorphic groups in different representations can produce different strings.EXAMPLES:
sage: G = CyclicPermutationGroup(6) sage: G.structure_description() 'C6' sage: G.structure_description(latex=True) 'C_{6}' sage: G2 = G.direct_product(G, maps=False) sage: LatexExpr(G2.structure_description(latex=True)) C_{6} \times C_{6}
This method is mainly intended for small groups or groups with few normal subgroups. Even then there are some surprises:
sage: D3 = DihedralGroup(3) sage: D3.structure_description() 'S3'
We use the Sage notation for the degree of dihedral groups:
sage: D4 = DihedralGroup(4) sage: D4.structure_description() 'D4'
Works for finitely presented groups (trac ticket #17573):
sage: F.<x, y> = FreeGroup() sage: G=F / [x^2*y^1, x^3*y^2, x*y*x^1*y^1] sage: G.structure_description() 'C7'
And matrix groups (trac ticket #17573):
sage: groups.matrix.GL(4,2).structure_description() 'A8'

subgroup
(gens=None, gap_group=None, domain=None, category=None, canonicalize=True, check=True)¶ Wraps the
PermutationGroup_subgroup
constructor. The argumentgens
is a list of elements ofself
.EXAMPLES:
sage: G = PermutationGroup([(1,2,3),(3,4,5)]) sage: g = G((1,2,3)) sage: G.subgroup([g]) Subgroup generated by [(1,2,3)] of (Permutation Group with generators [(3,4,5), (1,2,3)])

subgroups
()¶ Returns a list of all the subgroups of
self
.OUTPUT:
Each possible subgroup of
self
is contained once in the returned list. The list is in order, according to the size of the subgroups, from the trivial subgroup with one element on through up to the whole group. Conjugacy classes of subgroups are contiguous in the list.Warning
For even relatively small groups this method can take a very long time to execute, or create vast amounts of output. Likely both. Its purpose is instructional, as it can be useful for studying small groups. The 156 subgroups of the full symmetric group on 5 symbols of order 120, \(S_5\), can be computed in about a minute on commodity hardware in 2011. The 64 subgroups of the cyclic group of order \(30030 = 2\cdot 3\cdot 5\cdot 7\cdot 11\cdot 13\) takes about twice as long.
For faster results, which still exhibit the structure of the possible subgroups, use
conjugacy_classes_subgroups()
.EXAMPLES:
sage: G = SymmetricGroup(3) sage: G.subgroups() [Subgroup generated by [()] of (Symmetric group of order 3! as a permutation group), Subgroup generated by [(2,3)] of (Symmetric group of order 3! as a permutation group), Subgroup generated by [(1,2)] of (Symmetric group of order 3! as a permutation group), Subgroup generated by [(1,3)] of (Symmetric group of order 3! as a permutation group), Subgroup generated by [(1,2,3)] of (Symmetric group of order 3! as a permutation group), Subgroup generated by [(2,3), (1,2,3)] of (Symmetric group of order 3! as a permutation group)] sage: G = CyclicPermutationGroup(14) sage: G.subgroups() [Subgroup generated by [()] of (Cyclic group of order 14 as a permutation group), Subgroup generated by [(1,8)(2,9)(3,10)(4,11)(5,12)(6,13)(7,14)] of (Cyclic group of order 14 as a permutation group), Subgroup generated by [(1,3,5,7,9,11,13)(2,4,6,8,10,12,14)] of (Cyclic group of order 14 as a permutation group), Subgroup generated by [(1,2,3,4,5,6,7,8,9,10,11,12,13,14), (1,3,5,7,9,11,13)(2,4,6,8,10,12,14)] of (Cyclic group of order 14 as a permutation group)]
AUTHOR:
 Rob Beezer (20110124)

sylow_subgroup
(p)¶ Returns a Sylow \(p\)subgroup of the finite group \(G\), where \(p\) is a prime. This is a \(p\)subgroup of \(G\) whose index in \(G\) is coprime to \(p\).
Wraps the GAP function
SylowSubgroup
.EXAMPLES:
sage: G = PermutationGroup(['(1,2,3)', '(2,3)']) sage: G.sylow_subgroup(2) Subgroup generated by [(2,3)] of (Permutation Group with generators [(2,3), (1,2,3)]) sage: G.sylow_subgroup(5) Subgroup generated by [()] of (Permutation Group with generators [(2,3), (1,2,3)])

transversals
(point)¶ If G is a permutation group acting on the set \(X = \{1, 2, ...., n\}\) and H is the stabilizer subgroup of <integer>, a right (respectively left) transversal is a set containing exactly one element from each right (respectively left) coset of H. This method returns a right transversal of
self
by the stabilizer ofself
on <integer> position.EXAMPLES:
sage: G = PermutationGroup([ [(3,4)], [(1,3)] ]) sage: G.transversals(1) [(), (1,3,4), (1,4,3)] sage: G = PermutationGroup([[(1,2),(3,4)], [(1,2,3,4,10)]]) sage: G.transversals(1) [(), (1,2)(3,4), (1,3,2,10,4), (1,4,2,10,3), (1,10,4,3,2)] sage: G = PermutationGroup([ [('c','d')], [('a','c')] ]) sage: G.transversals('a') [(), ('a','c','d'), ('a','d','c')]

trivial_character
()¶ Returns the trivial character of
self
.EXAMPLES:
sage: SymmetricGroup(3).trivial_character() Character of Symmetric group of order 3! as a permutation group

upper_central_series
()¶ Return the upper central series of this group as a list of permutation groups.
EXAMPLES:
These computations use pseudorandom numbers, so we set the seed for reproducible testing:
sage: G = PermutationGroup([[(1,2,3),(4,5)],[(3,4)]]) sage: G.upper_central_series() [Subgroup generated by [()] of (Permutation Group with generators [(3,4), (1,2,3)(4,5)])]


class
sage.groups.perm_gps.permgroup.
PermutationGroup_subgroup
(ambient, gens=None, gap_group=None, domain=None, category=None, canonicalize=True, check=True)¶ Bases:
sage.groups.perm_gps.permgroup.PermutationGroup_generic
Subgroup subclass of
PermutationGroup_generic
, so instance methods are inherited.EXAMPLES:
sage: G = CyclicPermutationGroup(4) sage: gens = G.gens() sage: H = DihedralGroup(4) sage: H.subgroup(gens) Subgroup generated by [(1,2,3,4)] of (Dihedral group of order 8 as a permutation group) sage: K = H.subgroup(gens) sage: K.list() [(), (1,3)(2,4), (1,4,3,2), (1,2,3,4)] sage: K.ambient_group() Dihedral group of order 8 as a permutation group sage: K.gens() [(1,2,3,4)]

ambient_group
()¶ Return the ambient group related to
self
.EXAMPLES:
An example involving the dihedral group on four elements, \(D_8\):
sage: G = DihedralGroup(4) sage: H = CyclicPermutationGroup(4) sage: gens = H.gens() sage: S = PermutationGroup_subgroup(G, list(gens)) sage: S.ambient_group() Dihedral group of order 8 as a permutation group sage: S.ambient_group() == G True

is_normal
(other=None)¶ Return
True
if this group is a normal subgroup ofother
. Ifother
is not specified, then it is assumed to be the ambient group.EXAMPLES:
sage: S = SymmetricGroup(['a','b','c']) sage: H = S.subgroup([('a', 'b', 'c')]); H Subgroup generated by [('a','b','c')] of (Symmetric group of order 3! as a permutation group) sage: H.is_normal() True


sage.groups.perm_gps.permgroup.
direct_product_permgroups
(P)¶ Takes the direct product of the permutation groups listed in
P
.EXAMPLES:
sage: G1 = AlternatingGroup([1,2,4,5]) sage: G2 = AlternatingGroup([3,4,6,7]) sage: D = direct_product_permgroups([G1,G2,G1]) sage: D.order() 1728 sage: D = direct_product_permgroups([G1]) sage: D==G1 True sage: direct_product_permgroups([]) Symmetric group of order 0! as a permutation group

sage.groups.perm_gps.permgroup.
from_gap_list
(G, src)¶ Convert a string giving a list of GAP permutations into a list of elements of
G
.EXAMPLES:
sage: from sage.groups.perm_gps.permgroup import from_gap_list sage: G = PermutationGroup([[(1,2,3),(4,5)],[(3,4)]]) sage: L = from_gap_list(G, "[(1,2,3)(4,5), (3,4)]"); L [(1,2,3)(4,5), (3,4)] sage: L[0].parent() is G True sage: L[1].parent() is G True

sage.groups.perm_gps.permgroup.
hap_decorator
(f)¶ A decorator for permutation group methods that require HAP. It checks to see that HAP is installed as well as checks that the argument
p
is either 0 or prime.EXAMPLES:
sage: from sage.groups.perm_gps.permgroup import hap_decorator sage: def foo(self, n, p=0): print("Done") sage: foo = hap_decorator(foo) sage: foo(None, 3) #optional  gap_packages Done sage: foo(None, 3, 0) # optional  gap_packages Done sage: foo(None, 3, 5) # optional  gap_packages Done sage: foo(None, 3, 4) #optional  gap_packages Traceback (most recent call last): ... ValueError: p must be 0 or prime

sage.groups.perm_gps.permgroup.
load_hap
()¶ Load the GAP hap package into the default GAP interpreter interface.
EXAMPLES:
sage: sage.groups.perm_gps.permgroup.load_hap() # optional  gap_packages