Subsections

• Order and Index Functions
• Membership and Equality
• Set Operations
• Action on a Coset Space

# G : GrpFin -> RngIntElt

The order of the group G as an integer. If the order is not currently known, it will be computed.

The order of the group G returned as a factored integer. The factorization is returned in the form of a sequence Q which is defined as follows: If #G = p_1^(e_1) ... p_n^(e_n), e_i>0, then Q will be the integer sequence [ < p_1, e_1 >, ..., < p_n, e_n > ]. If the orders of G is not known, it will be computed.

The index of the subgroup H in the group G. The index is returned as an integer. If the orders of G and H are not known, they will be computed.

The index of the subgroup H in the group G. The index is returned as a factored integer. The format is the same as for FactoredOrder. If the orders of G and H are not known, they will be computed.

> Q<s,t,u>, h := Group< s, t, u |
>     t^2, u^17, s^2 = t^s = t, u^s = u^16, u^t = u >;
> Order(Q);
68
> FactoredOrder(Q); 
[ <2, 2>, <17, 1> ]
> S := sub< Q | t*s^2, u^4 >;
> Index(Q, S);
4
> #S;
17

Given a group element g and a group G, return true if g is an element of G, false otherwise.

Given a group element g and a group G, return true if g is not an element of G, false otherwise.

Given a group G and a set S of group elements belonging to a group H, where G and H belong the same generic group, return true if S is a subset of G, false otherwise.

Given a group G and a set S of group elements belonging to a group H, where G and H belong the same generic group, return true if S is not a subset of G, false otherwise.

Given groups G and H belonging to the same generic group, return true if H is a subgroup of G, false otherwise.

Given groups G and H belonging to the same generic group, return true if H is not a subgroup of G, false otherwise.

Given groups G and H belonging to the same generic group, return true if G and H are the same group, false otherwise.

Given groups G and H belonging to the same generic group, return true if G and H are distinct groups, false otherwise.

A bijective mapping from the group G onto the set of integers { 1 ... |G| }. The actual mapping depends upon the particular representation chosen for the carrier set of G.

    Slots: RngIntElt                    Default: 10

    Scramble: RngIntElt                 Default: 20

Create a process to generate randomly chosen elements from the finite group G. The process uses an `expansion' procedure to construct a set of elements corresponding to fairly long words in the generators of G. At all times, N elements are stored where N is the maximum of the specified value for Slots and Ngens(G) + 1. Initially, these are just the generators of G and products of pairs of generators of G. Random elements are now produced by successive calls to Random(P), where P is the process created by this function. Each such call chooses an element from the process and returns it, replacing it with the product of it and another random element (on the left or the right). Setting Scramble := m causes m such operations to be performed before the process is returned.

The use of this function on a finitely-presented group G is not recommended, since there is no reduction of words; the random elements generated may be extremely long.

Given a random element process P created by the function RandomProcess(G) for the finite group G, construct a random element of G by forming a random product over the expanded generating set constructed when the process was created. For large permutation or matrix groups for which a BSGS is not known, this function should be used in preference to Random(G).

Random(G: parameters) : GrpFin -> GrpFinElt

    Short: BoolElt                      Default: false

A randomly chosen element for the group G. If a representation of the carrier set of G has already been created, then the element chosen will be genuinely random. If such a representation has not yet been created, then the random element is chosen by multiplying out a random word in the generators. Since it is not usually practical to choose words long enough to properly sample the elements of G, the element returned will usually be biased. The boolean-valued parameter Short is used in this situation to indicate that a short word will suffice. Thus, if Random is invoked with Short assigned the value true then the element is constructed using a short word.

Rep(G) : GrpFin -> GrpFinElt

An element chosen from the group G.

• We use the function NumberingMap to construct the multiplication table for the dihedral group of order 12.

> G := DihedralGroup(6);
> f := NumberingMap(G);
> [ [ f(x*y) : y in G ] : x in G ];
[
    [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 ],
    [ 2, 3, 4, 5, 6, 1, 12, 7, 8, 9, 10, 11 ],
    [ 3, 4, 5, 6, 1, 2, 11, 12, 7, 8, 9, 10 ],
    [ 4, 5, 6, 1, 2, 3, 10, 11, 12, 7, 8, 9 ],
    [ 5, 6, 1, 2, 3, 4, 9, 10, 11, 12, 7, 8 ],
    [ 6, 1, 2, 3, 4, 5, 8, 9, 10, 11, 12, 7 ],
    [ 7, 8, 9, 10, 11, 12, 1, 2, 3, 4, 5, 6 ],
    [ 8, 9, 10, 11, 12, 7, 6, 1, 2, 3, 4, 5 ],
    [ 9, 10, 11, 12, 7, 8, 5, 6, 1, 2, 3, 4 ],
    [ 10, 11, 12, 7, 8, 9, 4, 5, 6, 1, 2, 3 ],
    [ 11, 12, 7, 8, 9, 10, 3, 4, 5, 6, 1, 2 ],
    [ 12, 7, 8, 9, 10, 11, 2, 3, 4, 5, 6, 1 ]
]

• We illustrate the use of the function Random using the wreath product of the symmetric group of degree 4 and the cyclic group of order 6.

> G := WreathProduct(Sym(4), CyclicGroup(6));
> G;
Permutation group G acting on a set of cardinality 24
    (1, 5, 9, 13, 17, 21)(2, 6, 10, 14, 18, 22) (3, 7, 11, 15, 19, 23)
        (4, 8, 12, 16, 20, 24)
    (1, 2, 3, 4)
    (1, 2)
> Order(G);
1146617856
> Random(G);
(1, 17, 12, 4, 18, 10, 3, 20, 9, 2, 19, 11)(5, 22, 13, 6, 21, 15)
    (7, 24, 16)(8, 23, 14)
// We display the cycle structures of 10 random elements of G
> R := [ CycleStructure(Random(G)) : i in [1..10] ];
> R;
[
    [ <6, 1>, <3, 6> ],
    [ <9, 1>, <6, 2>, <3, 1> ],
    [ <9, 2>, <3, 2> ],
    [ <12, 1>, <9, 1>, <3, 1> ],
    [ <18, 1>, <6, 1> ],
    [ <18, 1>, <6, 1> ],
    [ <12, 1>, <6, 2> ],
    [ <6, 3>, <2, 3> ],
    [ <6, 1>, <4, 3>, <2, 3> ],
    [ <6, 3>, <3, 2> ]
]

The (right) coset table for G over subgroup H relative to its defining generators.

[Future release] CosetTable(G, f) : GrpFin, Hom(GrpFin) -> Hom(GrpFin)

The coset table for G corresponding to the permutation representation f of G, where f is a homomorphism of G onto a transitive permutation group.

RightTransversal(G, H) : Grp, Grp -> {@ GrpElt @}, Map

Given a group G and a subgroup H of G, this function returns

• An indexed set of elements T of G forming a right transversal for G over H; and
• The corresponding transversal mapping phi: G -> T. If T = [t_1, ..., t_r] and g in G, phi is defined by phi(g) = t_i, where g in Ht_i.

and the corresponding transversal mapping.

Given a subgroup H of the group G, construct the permutation representation of G given by the action of G on the (right) coset space cos(G, H). The function returns:

• The natural homomorphism f: G -> L;
• The induced group L;
• The kernel K of the action (a subgroup of G).

Note that G may be any type of group. If G is a finitely presented group, then K may be returned undefined.

Given a subgroup H of the group G, construct the image L of G given by the action of G on the (right) coset space cos(G, H).

Given a subgroup H of the group G, construct the kernel of the action of G on the (right) coset space cos(G, H).