Set-Theoretic Operations

Functions Relating to Group Order

Order(G): GrpAb -> RngIntElt

# G: GrpAb -> RngIntElt

The order of the group \(G\), returned as an ordinary integer. If \(G\) is an infinite group, the value zero is returned. Note that if \(G\) is a generic group then determining the order will require the structure of \(G\) to be determined.

FactoredOrder(G): GrpAb -> [<RngIntElt, RngIntElt>]

The factored order of the group \(G\), returned as a sequence of prime-exponent pairs. If \(G\) is an infinite group, the empty sequence is returned. Note that if \(G\) is a generic group then determining the order will require the structure of \(G\) to be determined.

Exponent(G): GrpAb -> RngIntElt

The exponent of the group \(G\). If the group is infinite, the value zero is returned. Note that if \(G\) is a generic group then determining the exponent will require the structure of \(G\) to be determined.

IsFinite(G): GrpAb -> BoolElt

Return true if the group \(G\) is finite.

IsInfinite(G): GrpAb -> BoolElt

Return true if \(G\) is infinite, false otherwise.

Membership and Equality

g in G: GrpAbElt, GrpAb -> BoolElt

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

g notin G: GrpAbElt, GrpAb -> BoolElt

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

S subset G: { GrpAbElt}, GrpAb -> BoolElt

Given a group \(G\) and a set \(S\) of elements belonging to a group \(H\), where \(G\) and \(H\) have some covering group, return true if \(S\) is a subset of \(G\), false otherwise.

S notsubset G: { GrpAbElt}, GrpAb -> BoolElt

Given a group \(G\) and a set \(S\) of elements belonging to a group \(H\), where \(G\) and \(H\) have some covering group, return true if \(S\) is not a subset of \(G\), false otherwise.

H subset G: GrpAb, GrpAb -> BoolElt

IsSubgroup(H, G): GrpAb, GrpAb -> BoolElt

Given groups \(G\) and \(H\), subgroups of some common overgroup, return true if \(H\) is a subgroup of \(G\), and false otherwise.

H notsubset G: GrpAb, GrpAb -> BoolElt

Given groups \(G\) and \(H\), subgroups of some common overgroup, return true if \(H\) is not a subgroup of \(G\), and false otherwise.

G eq H: GrpAb, GrpAb -> BoolElt

Given groups \(G\) and \(H\), subgroups of some common overgroup, return true if \(G\) and \(H\) are identical, and false otherwise.

G ne H: GrpAb, GrpAb -> BoolElt

Given groups \(G\) and \(H\), subgroups of some common overgroup, return true if \(G\) and \(H\) are distinct groups, and false otherwise.

Set Operations

NumberingMap(G): GrpAb -> Map

A bijective mapping from the finite group \(G\) onto the set of integers \(\{ 1 \ldots |G| \rbrace\). The actual mapping depends upon choice of standard generators for \(G\).

RandomProcess(G): GrpAb -> Process

Slots   : RngIntElt                    Default: 10
Scramble: RngIntElt                    Default: 100

Create a process to generate randomly chosen elements from the finite group \(G\). The process is based on the product-replacement algorithm of [Celler et al., 1995], modified by the use of an accumulator. 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\). As well, one extra group element is stored, the accumulator. Initially, this is the identity. Random elements are now produced by successive calls to Random(P), where \(P\) is the process created by this function. Each such call chooses one of the elements in the slots and adds it into the accumulator. The element in that slot is replaced by the sum of it and another randomly chosen slot. The random value returned is the new accumulator value. Setting Scramble := m causes \(m\) such sum-replacement operations to be performed before the process is returned. Note that this algorithm cannot produce well-distributed random elements of an infinite group.

Random(P): Process -> GrpAbElt

Given a random element process \(P\) created by the function RandomProcess(G) for the finite abelian group \(G\), return the next random element of \(G\) defined by the process.

Random(G): GrpAb -> GrpAbElt

Random(G, n): GrpAb, RngIntElt -> GrpAbElt

An element chosen at random from the abelian group \(G\). The argument \(n\) gives the maximum exponent for infinite generators, and defaults to 10 if not supplied.

Rep(G): GrpAb -> GrpAbElt

Representative(G): GrpAb -> GrpAbElt

A representative element of \(G\).