# Basic Operations

## Accessing Group Information

The functions in this group provide access to basic information stored for a group $G$.

### `G . i: Grp, RngIntElt -> GrpElt`

The $i$-th defining generator for $G$, if $i>0$. If $i<0$, then the inverse of the $-i$-th defining generator is returned. The generator `G.0` is equivalent to `Identity(G)`.

### `Generators(G): Grp -> { GrpFinElt }`

A set containing the defining generators for $G$.

### `NumberOfGenerators(G): Grp -> RngIntElt`

### `Ngens(G): Grp -> RngIntElt`

The number of defining generators for $G$.

### `SmallestGeneratingSet(G: parameters): Grp -> SetIndx`

```magma
Print     : RngIntElt                    Default: 0
QuickTries: RngIntElt                    Default: 250
```

A generating set of minimal cardinality for the finite group $G$. The algorithm is from [[Lucchini and Thakkar, 2024](../../references.md#cite-luctha)].

### `Generic(G): Grp -> Grp`

Given a group $G$ in the category `GrpPerm` or `GrpMat`, return the generic group containing $G$, i.e., the largest group in which $G$ is naturally embedded. The precise definition of generic group depends upon the category to which $G$ belongs.

### `Parent(g): GrpElt -> Grp`

The parent group $G$ for the group element $g$.

### `Example: Generators (ex-a47283)`

The Suzuki simple group $G={\operatorname{Sz}}(8)$ is constructed. Its generic group is ${\operatorname{GL}}(4, K)$, where $K$ is the finite field with 8 elements. The field $K$ is constructed first, so that its generator may be given the printname $z$. Then the three generators of $G$ are printed, in the standard order of indexing.

```magma
> K<z> := GF(2, 3);
> G := SuzukiGroup(8);
> Generic(G);
GL(4, GF(2, 3))
> Ngens(G);
3
> for i in [1..3] do
>    print "generator", i, G.i;
>    print "order", Order(G.i), "\\r";
> end for;
generator 1
[  0   0   0   1]
[  0   0   1   0]
[  0   1   0   0]
[  1   0   0   0]
order 2

generator 2
[z^2   0   0   0]
[  0 z^6   0   0]
[  0   0   z   0]
[  0   0   0 z^5]
order 7

generator 3
[  1   0   0   0]
[z^2   1   0   0]
[  0   z   1   0]
[z^5 z^3 z^2   1]
order 4

```

### `Orbit(G, M, x): Grp, Any, Any -> {Any}`

Given a finitely generated group $G$ that acts on the parent structure of $x$ through the map (or user defined function) $M$, compute the orbit of $x$ under $G$. Thus, for every generator $g$ of $G$, $M(g)$ must return a function that can be applied to $x$ or any other element in the parent of $x$.

If the orbit is infinite, this process will eventually run out of memory.

### `OrbitClosure(G, M, S): Grp, Any, {Any} -> Any`

Given a finitely generated group $G$ acting on the universe of $S$ through the map or user defined function $M$, compute the smallest subset $T$ containing $S$ that is $G$-invariant. Thus, for every generator $g$ of $G$, $M(g)$ must return a function that can be applied to an arbitrary element in the universe of $S$.

If the orbit closure is infinite, this process will eventually run out of memory.

## Names of Finite Groups

### `GroupName(G): Grp -> MonStgElt`

```magma
TeX: BoolElt                    Default: false
```

Short name of a finite group $G$, as an abstract group.

### `Example: Grp Groupname (ex-7a2387)`

```magma
> [GroupName(G): G in SmallGroups(24)];
[ C3:C8, C24, SL(2,3), C3:Q8, C4*S3, D12, C2*C3:C4, C3:D4, C2*C12, C3*D4,
   C3*Q8, S4, C2*A4, C2^2*S3, C2^2*C6 ]
> GroupName(AlternatingGroup(10): TeX:=true);
A_{10}

```

Small groups (of order $<512$, not divisible by $128$) have a unique name each, and `Group(GroupName(G))` always returns a group isomorphic to $G$. For larger groups, Magma attempts to recognize direct products, wreath products and split extensions, and uses chief series if that fails. With `TeX:=true`, the returned string is in LaTeX format. Note that for such larger groups the name returned is not canonical: isomorphic groups may be given different names.

Here is a list of notation used by `GroupName`. See also example below.

```
        Basic groups

Cn      Cyclic group of order n
Dn      Dihedral group of order 2n
Sn      Symmetric group on n letters
An      Alternating group on n letters

        Operators, high to low precedence

^       power, e.g C2^2 is the non-cyclic group of order 4
wr      wreath product, e.g. C2wrC2=C2^2:C2=D4
:       semidirect product, i.e. a split extension
.       (generally) non-split extension
*       direct product

        Other standard groups

Fq      Frobenius group of order q(q-1)
Hep     Heisenberg group of order p^3
Qn      Generalized quaternion group, n=2^k
SDn     Semi-dihedral group C2^(k-1):C2 (n=2^k) with C2
        acting as 2^(k-2)-1
ODn     Other-dihedral group C2^(k-1):C2 (n=2^k) with C2
        acting as 2^(k-2)+1

        Simple, almost-simple and linear groups

Mn      Matthieu group (n in {11,12,21,22,23,24})
GL(n,q) General linear group; also SL,AGL,ASL,AGammaL,ASigmaL,PGL,
        PSL (=L),PGammaL,PSigmaL,SU,PSU,PGammaU,PSigmaU,O (=GO),SO,
        PSO,PGO,PGO+,PGO-,POmega,POmega+,POmega-,Sp,PSp,PSigmaSp
B(n,q)  Simple group of Lie type, also C,D,E,F,G,2A,2B,2D,2E,2F,2G,3D
J1      Sporadic simple group; also Mn (see above),J2,J3,J4,HS,McL,Suz,
        Co1,Co2,Co3,HE,Fi22,Fi23,Fi24,Ly,Ru,ON,TH,HN,BM,M

```

### `Group(s): MonStgElt -> Grp`

A finite group from its name. See `GroupName` and the example below.

### `Example: Grp Group (ex-06353f)`

```magma
> G0:=Group("C10^2*C3");    // cyclic and abelian
> G1:=Group("D5");          // dihedral Dn of order 2n
> G2:=Group("A5");          // alternating
> G3:=Group("S5");          // symmetric
>
> G4:=Group("SL(2,3)");     // linear: GL, SL, AGL, ASL, AGammaL, ASigmaL, PGL,
> G5:=Group("SL(2,F3)");    //   PSL (=L), PGammaL, PSigmaL, SU, PSU, PGammaU,
> G6:=Group("SL_2(3)");     //   PSigmaU, O (=GO), SO, PSO, PGO, PGO+, PGO-,
> G7:=Group("SL2(3)");      //   POmega, POmega+, POmega-, Sp, PSp, PSigmaSp
>
> G8:=Group("S3*GL(4,2)");  // Products
> G9:=Group("C41:C40");     // Split extensions that are not direct products,
>                           // [usually with largest action of the quotient group]
> G10:=Group("A5wrC2");     // Wreath products
>
> G11:=Group("C2^3.C4");             // unique names returned by GroupName
>                                    // when |G|<512, not multiple of 128
> G12:=Group("A5*A_5*A_{5}*Alt(5)"); // name variations
> G13:=Group("D10:C8.C2*C3");        // operator order ^ > wr > : > . > *
>                                    // (so read left to right in this example)
>
> G14:=Group("<12,1>");        // Small group database (C3:C4)
> G14:=Group("g12n1");         //   same group
> G15:=Group("T<12,48>");      // Transitive group database (C2^2*S4)
> G15:=Group("t12n48");        //   same group
>                              // Simple groups: Lie Type A,B,C,D,E,F,G, returned
> G16:=Group("C(4,2)");        //   as matrix groups via standard representation
Warning: Projective representation
> G17:=Group("Sz(32)");        // Simple groups: Suzuki
> G18:=Group("J1*Co3*M11");    // Simple groups: sporadic
> G19:=Group("PGL(4,3)`2");    // Names from the almost simple group database
>
> G20:=Group("He11");          // Heisenberg
> G21:=Group("F13");           // Frobenius group Fn of order n(n-1)
> G22:=Group("Q8");            // Quasi-cyclic groups of normal 2-rank one:
> G23:=Group("SD16");          //   Dihedral, (generalized) quaternion,
> G24:=Group("OD16");          //   semi-dihedral, the `other-dihedral' one.
>
> [GroupName(eval "G"*Sprint(n)): n in [1..24]];     // back to names
[ D5, A5, S5, SL(2,3), SL(2,3), SL(2,3), SL(2,3), S3*A8, F41, A5wrC2, C2^3.C4,
   A5^4, C3*D10:C8.C2, C3:C4, C2^2*S4, C(4,2), 2B(2,32), J1*Co3*M11,
   PSL(4,3).C2^2, He11, F13, Q8, SD16, OD16 ]

```