# PermutationGroup SΒΆ

- S: SetCategory

PermutationGroup implements permutation groups acting on a set `S`

, i.e. all subgroups of the symmetric group of `S`

, represented as a list of permutations (generators). Note that therefore the objects are not members of the Language category Group. Using the idea of base and strong generators by Sims, basic routines and algorithms are implemented so that the word problem for permutation groups can be solved.

- <: (%, %) -> Boolean
`gp1 < gp2`

returns`true`

if and only if*gp1*is a proper subgroup of*gp2*.

- <=: (%, %) -> Boolean
`gp1 <= gp2`

returns`true`

if and only if*gp1*is a subgroup of*gp2*. Note: because of a bug in the parser you have to call this function explicitly by*gp1 <=$(PERMGRP S) gp2*.- =: (%, %) -> Boolean
- from BasicType
- ~=: (%, %) -> Boolean
- from BasicType

- base: % -> List S
`base(gp)`

returns a base for the group*gp*.

- coerce: % -> List Permutation S
`coerce(gp)`

returns the generators of the group*gp*.- coerce: % -> OutputForm
- from CoercibleTo OutputForm

- coerce: List Permutation S -> %
`coerce(ls)`

coerces a list of permutations*ls*to the group generated by this list.

- degree: % -> NonNegativeInteger
`degree(gp)`

returns the number of points moved by all permutations of the group*gp*.

- elt: (%, NonNegativeInteger) -> Permutation S
`elt(gp, i)`

returns the`i`

-th generator of the group*gp*.

- generators: % -> List Permutation S
`generators(gp)`

returns the generators of the group*gp*.- hash: % -> SingleInteger
- from SetCategory
- hashUpdate!: (HashState, %) -> HashState
- from SetCategory

- initializeGroupForWordProblem: % -> Void
`initializeGroupForWordProblem(gp)`

initializes the group*gp*for the word problem. Notes: it calls the other function of this name with parameters 0 and 1:*initializeGroupForWordProblem(gp, 0, 1)*. Notes: (1) be careful: invoking this routine will destroy the possibly information about your group (but will recompute it again) (2) users need not call this function normally for the soultion of the word problem.

- initializeGroupForWordProblem: (%, Integer, Integer) -> Void
`initializeGroupForWordProblem(gp, m, n)`

initializes the group*gp*for the word problem. Notes: (1) with a small integer you get shorter words, but the routine takes longer than the standard routine for longer words. (2) be careful: invoking this routine will destroy the possibly stored information about your group (but will recompute it again). (3) users need not call this function normally for the soultion of the word problem.- latex: % -> String
- from SetCategory

- member?: (Permutation S, %) -> Boolean
`member?(pp, gp)`

answers the question, whether the permutation*pp*is in the group*gp*or not.

- movedPoints: % -> Set S
`movedPoints(gp)`

returns the points moved by the group*gp*.

- orbit: (%, List S) -> Set List S
`orbit(gp, ls)`

returns the orbit of the ordered list*ls*under the group*gp*. Note: return type is`L`

`L`

`S`

temporarily because FSET`L`

`S`

has an error.

- orbit: (%, S) -> Set S
`orbit(gp, el)`

returns the orbit of the element*el*under the group*gp*, i.e. the set of all points gained by applying each group element to*el*.

- orbit: (%, Set S) -> Set Set S
`orbit(gp, els)`

returns the orbit of the unordered set*els*under the group*gp*.

- orbits: % -> Set Set S
`orbits(gp)`

returns the orbits of the group*gp*, i.e. it partitions the (finite) of all moved points.

- order: % -> NonNegativeInteger
`order(gp)`

returns the order of the group*gp*.

- perm_to_vec: (List S, Permutation S, NonNegativeInteger) -> Vector NonNegativeInteger
`perm_to_vec(supp, p, degree)`

should be local but conditional

- permutationGroup: List Permutation S -> %
`permutationGroup(ls)`

coerces a list of permutations*ls*to the group generated by this list.

- pointList: % -> List S
`pointList(gp)`

should be local but conditional

- random: % -> Permutation S
`random(gp)`

returns a random product of maximal 20 generators of the group*gp*. Note:*random(gp)=random(gp, 20)*.

- random: (%, Integer) -> Permutation S
`random(gp, i)`

returns a random product of maximal`i`

generators of the group*gp*.

- relationsInGenerators: % -> List List Integer
`relationsInGenerators(gp)`

computes relations between generators.

- relationsInStrongGenerators: % -> List List Integer
`relationsInStrongGenerators(gp)`

computes relations between strong generators.

- strongGenerators: % -> List Permutation S
`strongGenerators(gp)`

returns strong generators for the group*gp*.

- wordInGenerators: (Permutation S, %) -> List NonNegativeInteger
`wordInGenerators(p, gp)`

returns the word for the permutation`p`

in the original generators of the group*gp*, represented by the indices of the list, given by*generators*.

- wordInStrongGenerators: (Permutation S, %) -> List NonNegativeInteger
`wordInStrongGenerators(p, gp)`

returns the word for the permutation`p`

in the strong generators of the group*gp*, represented by the indices of the list, given by*strongGenerators*.

- wordsForStrongGenerators: % -> List List NonNegativeInteger
`wordsForStrongGenerators(gp)`

returns the words for the strong generators of the group*gp*in the original generators of*gp*, represented by their indices in the list, given by*generators*.