Please note, that throughout this package it is assumed that the group G is finite.
‣ BasicGroup( KG ) | ( function ) |
Let \(G\) be a group and \(F\) a field. Then the group algebra \(FG\) consists of the set of formal linear combinations of the form
\[ \sum_{g \in G} \alpha_g g, \quad \alpha_g \in F \]
where all but finitely many of the \(\alpha_g\) are zero [Lee73][Bov98].
For the group ring KG the function BasicGroup returns the basic group of KG as a subgroup of the group of units of KG.
gap> G:=CyclicGroup(IsFpGroup,4); <fp group of size 4 on the generators [ a ]> gap> Elements(G); [ <identity ...>, a, a^2, a^3 ] gap> KG:=GroupRing(GF(2),G); <algebra-with-one over GF(2), with 1 generators> gap> BasicGroup(KG); <group with 4 generators> gap> Elements(last); [ (Z(2)^0)*<identity ...>, (Z(2)^0)*a, (Z(2)^0)*a^2, (Z(2)^0)*a^3 ]
‣ IsLienEngel( KG ) | ( function ) |
On any associative ring \(R\) the Lie bracket is defined as \([x,y] = xy-yx.\). For any positive integer \(n\), a subset \(\Lambda\) of \(R\) is said to be Lie \(n\)-Engel if for any \(x,y \in \Lambda\), \([x,y,\ldots,y]=0\) (\(y\) is taken \(n\) times) [Lee00][Seh78] .
For the group ring KG the function IsLienEngel returns true if KG is Lie \(n\)-Engel and false otherwise.
gap> G:=CyclicGroup(4); <pc group of size 4 with 2 generators> gap> KG:=GroupRing(GF(2),G); <algebra-with-one over GF(2), with 2 generators> gap> IsLienEngel(KG); false gap> G:=DihedralGroup(16); <pc group of size 16 with 4 generators> gap> KG:=GroupRing(GF(2),G); <algebra-with-one over GF(2), with 4 generators> gap> IsLienEngel(KG); true
‣ GetRandomUnit( KG ) | ( function ) |
For the group ring KG the function GetRandomUnit returns an unit (i.e. an invertible element) by a random way.
gap> G:=CyclicGroup(4); <pc group of size 4 with 2 generators> gap> KG:=GroupRing(GF(7),G); <algebra-with-one over GF(7), with 2 generators> gap> u:=GetRandomUnit(KG);; gap> Augmentation(u); Z(7)^4 gap> u*u^-1; (Z(7)^0)*<identity> of ...
‣ GetRandomNormalizedUnit( KG ) | ( function ) |
Let \(U(KG)\) be the multiplicative group of the group algebra \(KG\) of the \(p\)-group \(G\) over a field \(K\) of characteristic \(p\). The subgroup
\[ V(KG)=\{ \sum_{g \in G} \alpha_g g \in U(KG) \mid \sum_{g \in G} \alpha_g = 1 \} \]
is called the group of normalized units of the group algebra \(KG\) [BS89].
For the group ring KG the function GetRandomNormalizedUnit returns a normalized unit (i.e. an invertible element with augmentation 1, \(u \in V(KG)\)) by a random way.
gap> G:=DihedralGroup(IsFpGroup,16);; gap> KG:=GroupRing(GF(2),G);; gap> u:=GetRandomNormalizedUnit(KG);; gap> Augmentation(u); Z(2)^0 gap> u*u^-1; (Z(2)^0)*<identity ...>
‣ GetRandomNormalizedUnitaryUnit( KG[, eta] ) | ( function ) |
Let \(p\) be a prime, \(K\) the field of characteristic \(p\), \(G\) a finite abelian \(p\)-group with an arbitrary antiautomorphism \(\eta\) of order 2 and \(G_{\eta}=\{g \in G \mid \eta(g)=g\}\). Extending the antiautomorphism \(\eta\) to the group algebra \(KG\) we obtain the involution
\[ x = \sum_{g \in G} \alpha_g g \mapsto x^{*}= \sum_{g \in G} \alpha_g \eta(g) \]
of KG which is called as \(\eta\)-involution. If \(\eta(g)=g^{-1}\) for all \(g \in G\) then this involution is called canonical. Then, if \(V(KG)\) is the group of normalized units of \(KG\), the subgroup of unitary units is defined as [BS06]
\[ V_*(KG)=\{x \in V(FG) \mid x^* = x^{-1} \}. \]
For the group algebra KG the function GetRandomNormalizedUnitaryUnit returns a normalized unitary unit (i.e. such an invertible element with augmentation 1, that \(u\cdot u^{*}=1\)) by a random way. Also, there exists a two-parametrical version of this method, where the second parameter \(\eta\) is an arbitrary antiautomorphism of \(G\). In this case, the function GetRandomNormalizedUnitaryUnit returns a normalized unitary unit (i.e. such an invertible element with augmentation 1, that \(u\cdot u^{*}=1\)) by a random way for the group algebra KG and an arbitrary antiautomorphism eta.
gap> G:=CyclicGroup(4);; gap> KG:=GroupRing(GF(2),G);; gap> u:=GetRandomNormalizedUnitaryUnit(KG);; gap> u*Involution(u); (Z(2)^0)*<identity> of ... gap> Augmentation(u); Z(2)^0 gap> Aut:=AutomorphismGroup(G);; gap> KG:=GroupRing(GF(2),G);; gap> Aut2:=Filtered(Aut,i->Order(i)=2);; gap> Aut2; [ [ f1*f3 ] -> [ f1*f2*f4 ], [ f1*f3 ] -> [ f1*f3*f4 ], [ f1*f3 ] -> [ f1*f2 ] ] gap> eta:=Aut2[2]; [ f1*f3 ] -> [ f1*f3*f4 ] gap> u:=GetRandomNormalizedUnitaryUnit(KG,eta);; gap> u*RAMEGA_InvolutionKG(u, eta, KG); (Z(2)^0)*<identity> of ...
‣ GetRandomCentralNormalizedUnit( KG ) | ( function ) |
For the group ring KG the function GetRandomCentralNormalizedUnit returns a central normalized unit (i.e. such an invertible element with augmentation 1, that \(u\cdot x=x \cdot u\), \(\forall x \in KG\)) by a random way.
gap> G:=CyclicGroup(IsFpGroup,4);; gap> KG:=GroupRing(GF(2),G);; gap> u:=GetRandomCentralNormalizedUnit(KG);; gap> Augmentation(u); Z(2)^0 gap> bool:=true; true gap> for x in Elements(KG) do > if x*u<>u*x then bool:=false; break; fi; > od; gap> bool; true
‣ GetRandomElementFromAugmentationIdeal( KG ) | ( function ) |
If \(KG\) is a modular group ring then its augmentation ideal \(A\) is generated by all elements of the form \(g-1\) where \(g \in G \setminus \{1 \}\). The augmentation ideal consists of all elements with augmentation 0, i.e.
\[ A(KG)=\{ \sum_{g \in G} \alpha_g g \in KG \mid \sum_{g \in G} \alpha_g = 0 \}. \]
For the modular group ring KG the function GetRandomElementFromAugmentationIdeal returns an element from the augmentation ideal of \(KG\) by a random way.
gap> G:=QuaternionGroup(16); <pc group of size 16 with 4 generators> gap> KG:=GroupRing(GF(2),G); <algebra-with-one over GF(2), with 4 generators> gap> u:=GetRandomElementFromAugmentationIdeal(KG);; gap> Augmentation(u); 0*Z(2)
‣ RandomLienEngelLength( KG, num ) | ( function ) |
Let KG be a Lie n-Engel group ring and let \([x,y,y,\ldots,y]=0\) for all \(x, y \in KG \). Then the number of \(y\)'s in the last equation is called the Lie \(n\)-Engel length [BK77][Kur96][Kur98].
For the Lie n-Engel group ring KG and the maximal number of iterations num the function RandomLienEngelLength returns the Lie \(n\)-Engel length of \(KG\) by a random way.
gap> G:=DihedralGroup(16);; gap> KG:=GroupRing(GF(2),G);; gap> RandomLienEngelLength(KG,100); 4
‣ RandomExponent( KG, num ) | ( function ) |
For the group ring KG (where \(G\) is a finite \(p\)-group and the characteristic of \(K\) is \(p\)) and the maximal number of iterations num the function RandomExponent returns the exponent of V(KG) [BL93] [BS18] [Sha91] by a random way.
gap> G:=DihedralGroup(16);; gap> KG:=GroupRing(GF(2),G);; gap> RandomExponent(KG,100); 8
‣ RandomExponentOfNormalizedUnitsCenter( KG, num ) | ( function ) |
For the group ring KG (where \(G\) is a finite \(p\)-group and the characteristic of \(K\) is \(p\)) and the maximal number of iterations num the function RandomExponentOfNormalizedUnitsCenter returns the exponent of the center of the group of normalized units of KG by a random way.
gap> G:=DihedralGroup(16);; gap> KG:=GroupRing(GF(2),G);; gap> RandomExponentOfNormalizedUnitsCenter(KG,100); 4
‣ RandomNilpotencyClass( KG, num ) | ( function ) |
Let \(G\) be a group and let \(g_1,\ldots,g_n \in G \). By the symbol \((g_1,\ldots,g_n)\) we denote the commutator of the elements \(g_1,\ldots,g_n\) which is defined inductively as
\[ (g_1,\ldots,g_n)=((g_1,\ldots,g_{n-1}),g_n), \quad (g_1,g_2)=g_1^{-1}g_2^{-1}g_1 g_2. \]
As usual, for the subsets \(X, Y\) of G we will denote by \((X,Y)\) the subgroup generated by all commutators \((x,y)\) with \(x \in X\), \(y \in Y\).
This allows us to define the lower central series of a nonempty subset \(H\) of \(G\): let \(\gamma_{n+1}(H)=(\gamma_{n}(H),H)\) with \(\gamma_1(H)=H\). We say that \(H\) is nilpotent if \(\gamma_{n}(H)=1\) for some \(n\). For a nilpotent subset \(H \subseteq G\) the number
\[ cl(H) = \min\{n \in \mathbb{N}_0: \gamma_{n+1}(H)=1\} \]
is called the nilpotency class of \(H\) [BJ11][Sha93][Sha91][MS90] [Sha90b][Sha90a].
For the Lie nilpotent group ring KG and the maximal number of iterations num the function RandomNilpotencyClass returns the nilpotency class of the group of normalized units of KG by a random way.
gap> G:=DihedralGroup(16);; gap> KG:=GroupRing(GF(2),G);; gap> RandomNilpotencyClass(KG,100); 4
‣ RandomDerivedLength( KG, n ) | ( function ) |
\(KG\) is called Lie solvable, if some of the terms of the Lie derived series \(\delta^{[n]}(KG)=[\delta^{[n-1]}(KG),\delta^{[n-1]}(KG)]\) with \(\delta^{[0]}(KG)=KG\) are equal to zero.
Denote by \(dl_L(KG)\) the minimal element of the set \(\{m\in\mathbb N\;\vert\; \delta^{[m]}(KG)=0\}\), which is said to be the Lie derived length of \(KG\) [Bal12] [BT08][Spi08][CS10].
For the modular group ring KG and a positive integer n the function RandomDerivedLength returns the Lie derived length by a random way.
gap> D:=DihedralGroup(IsFpGroup,8);; gap> KG:=GroupRing(GF(2),D);; gap> RandomDerivedLength(KG,100); 2
‣ RandomCommutatorSubgroup( KG, n ) | ( function ) |
For the group ring KG and a positive integer n the function RandomCommutatorSubgroup returns the commutator subgroup of the unit group of \(KG\) using \(n\) iterations by a random way. There is also an overloaded version of this method for finding the commutator subgroup of an arbitrary group \(G\) using \(n\) iterations by a random way.
gap> G:=DihedralGroup(IsFpGroup,8);; gap> KG:=GroupRing(GF(2),G);; gap> SG:=RandomCommutatorSubgroup(KG,100); gap> StructureDescription(SG); "C2 x C2 x C2"
‣ RandomCommutatorSubgroupOfNormalizedUnits( KG, n ) | ( function ) |
For the modular group ring KG and a positive integer n the function RandomCommutatorSubgroupOfNormalizedUnits returns the commutator subgroup of normalized units by a random way.
gap> G:=DihedralGroup(8);; gap> KG:=GroupRing(GF(2),G);; gap> SG:=RandomCommutatorSubgroupOfNormalizedUnits(KG,100);; gap> u:=Random(Elements(SG));; gap> Augmentation(u); Z(2)^0
‣ RandomNormalizedUnitGroup( KG, n ) | ( function ) |
For a group ring KG, where G is a finite p-group and K has characteristic p and a positive integer n, where n is the number of iterations, the function RandomNormalizedUnitGroup returns the normalized unit group of KG by a random way.
gap> G:=DihedralGroup(8);; gap> KG:=GroupRing(GF(2),G);; gap> SG:=RandomNormalizedUnitGroup(KG); <group with 4 generators> gap> Size(SG); 128 gap> u:=Random(Elements(SG));; gap> Augmentation(u); Z(2)^0
‣ RandomUnitarySubgroup( KG, n ) | ( function ) |
For a modular group ring KG and a positive integer n, where n is the number of iterations, the function RandomUnitarySubgroup returns the subgroup generated by the normalized unitary units (see GetRandomNormalizedUnitaryUnit (2.2-3)) by a random way.
gap> G:=DihedralGroup(8);; gap> KG:=GroupRing(GF(2),G);; gap> SG:=RandomUnitarySubgroup(KG,100);; gap> u:=Random(Elements(SG));; gap> Augmentation(u); Z(2)^0 gap> u*u^-1; (Z(2)^0)*<identity> of ...
‣ RandomCommutatorSeries( KG, n ) | ( function ) |
For a modular group ring KG, where G is a p-group, and a positive integer n, where n is the number of iterations, the function RandomCommutatorSeries returns the commutator series of the group of normalized units in \(KG\) by a random way.
gap> G:=DihedralGroup(8);; gap> KG:=GroupRing(GF(2),G);; gap> CS:=RandomCommutatorSeries(KG,100); [ <group of size 128 with 4 generators>, <group of size 8 with 8 generators>, <group of size 1 with 1 generators> ]
‣ RandomLowerCentralSeries( KG, n ) | ( function ) |
The lower central series of a group \(G\) is the descending series of groups
\[ G=G_1 \trianglerighteq G_2 \trianglerighteq \ldots \trianglerighteq G_n \trianglerighteq \ldots, \]
where each \(G_{n+1}=[G_n,G]\), the subgroup generated by all commutators \([x,y]\) with \(x\) in \(G_n\) and \(y\) in \(G\). Thus, \(G_2=[G,G]=G^{(1)}\), the derived subgroup of \(G\); \(G_3=[[G,G],G]\), etc. The lower central series is often denoted \(y_n(G)\).
For a group ring KG, for which \(V(KG)\) is nilpotent, and a positive integer n, where n is the number of iterations, the function RandomLowerCentralSeries returns the lower central series of the group of normalized units of \(KG\) by a random way.
gap> G:=DihedralGroup(8);; gap> KG:=GroupRing(GF(2),G);; gap> CS:=RandomLowerCentralSeries(KG,100); [ <group of size 128 with 4 generators>, <group of size 8 with 8 generators>, <group of size 1 with 1 generators> ]
‣ RandomUnitaryOrder( KG, n[, sigma] ) | ( function ) |
For the group ring KG, where G is a finite p-group and K has characteristic p, and a positive integer n, where n is the number of iterations, the function RandomUnitaryOrder returns the order of the unitary subgroup of \(KG\) [CG09] by a random way. Also, there exists a three-parametrical version of this method, where the third parameter sigma is an arbitrary anti-automorphism of \(G\).
gap> G:=DihedralGroup(8);; gap> KG:=GroupRing(GF(2),G);; gap> ord:=RandomUnitaryOrder(KG,100); 64
‣ RandomOmega( G, m, n ) | ( function ) |
For the p group G and a positive integers m and n (number of iterations) the function RandomOmega returns the subgroup of \(G\), that is generated by the elements \(g\) for which \(g^{p^m}=1\), by random search.
gap> G:=CyclicGroup(8);; gap> KG:=GroupRing(GF(2),G);; gap> RO:=RandomOmega(KG,2,50);; gap> u:=Random(Elements(RO));; gap> (u^2)^2; (Z(2)^0)*<identity> of ... gap> ## Let h be a group. gap> h:=SmallGroup(16,10);; gap> RO:=RandomOmega(h,2,50);; gap> u:=Random(Elements(RO));; gap> (u^2)^2; <identity> of ...
‣ RandomAgemo( G, m, n ) | ( function ) |
For the p-group G and a positive integers m and n (number of iterations) the function RandomOmega returns the subgroup of \(G\), that is generated by the elements \(g^{p^m}\) by random search.
gap> G:=CyclicGroup(8);; gap> KG:=GroupRing(GF(2),G);; gap> RA:=RandomAgemo(KG,2,50);; gap> Elements(RA); [ (Z(2)^0)*<identity> of ..., (Z(2)^0)*f3 ] gap> u:=Random(Elements(RA));; gap> (u^2)^2; (Z(2)^0)*<identity> of ... gap> ## Let h be a group. gap> h:=SmallGroup(16,10);; gap> RA:=RandomAgemo(h,2,50);; gap> Elements(RA); [ <identity> of ... ]
‣ RandomDihedralDepth( G, n ) | ( function ) |
For a non abelian finite 2-group G and a positive integer n, where n is the number of iterations, the function RandomDihedralDepth returns the dihedral depth of G, which is defined to be the maximal number d such that G contains a subgroup isomorphic to the dihedral group of order \(2^{(d+1)}\).
gap> G:=SmallGroup([64,6]); <pc group of size 64 with 6 generators> gap> StructureDescription(G); "(C8 x C4) : C2" gap> RandomDihedralDepth(G,1000); 2
‣ RandomQuaternionDepth( G, n ) | ( function ) |
For a non abelian finite 2-group G and a positive integer n, where n is the number of iterations, the function RandomQuaternionDepth returns the quaternion depth of G, which is defined to be the maximal number d such that G contains a subgroup isomorphic to the generalized quaternion group of order \(2^{(d+1)}\).
gap> G:=SmallGroup([64,10]); <pc group of size 64 with 6 generators> gap> StructureDescription(G); "(C8 : C4) : C2" gap> RandomQuaternionDepth(G,1000); 2
‣ GetRandomSubgroupOfNormalizedUnitGroup( KG, n ) | ( function ) |
For a group ring KG and a positive integer n, the function GetRandomSubgroupOfNormalizedUnitGroup returns a subgroup of the normalized group of units generated by n random normalized units.
gap> KG:=GroupRing(GF(2),DihedralGroup(8));; gap> G:=GetRandomSubgroupOfNormalizedUnitGroup(KG,2); <group with 2 generators> gap> StructureDescription(G); "(C4 x C2) : C2"
‣ RandomConjugacyClass( KG, n ) | ( function ) |
For a group ring KG and a positive integer n (number of iterations), the function RandomConjugacyClass returns the random conjugacy class of a random element of the group of normalized units.
gap> KG:=GroupRing(GF(2),DihedralGroup(8));; gap> cc:=RandomConjugacyClass(KG,4);; gap> List(cc,i->Order(i)); [ 4, 4, 4 ]
‣ RandomConjugacyClasses( KG, n ) | ( function ) |
For a modular group algebra KG and a positive integer n (number of iterations), the function RandomConjugacyClasses returns the conjugacy classes of the group of normalized units.
gap> KG:=GroupRing(GF(2),SmallGroup(8,3));; gap> cc:=RandomConjugacyClasses(KG,100);; gap> Size(Union(cc)); 128 gap> Collected(List(cc,x->Number(x))); [ [ 1, 16 ], [ 4, 28 ] ] gap> vkg:=RandomNormalizedUnitGroup(KG);; gap> Size(vkg); 128
‣ RandomIsCentralElement( KG, u, n ) | ( function ) |
For a group ring KG, element \(u \in KG\), and a positive integer n (number of iterations), the function RandomIsCentralElement returns true if u is a central element by random way.
gap> KG:=GroupRing(GF(2),CyclicGroup(16));; gap> u:=Random(Elements(KG));; gap> RandomIsCentralElement(KG,u,100); true
‣ RandomIsNormal( KG, N, n ) | ( function ) |
For a group ring KG, subgroup N, and a positive integer n (number of iterations), the function RandomIsNormal returns true if N is normal in the normalized group of units by random way.
gap> KG:=GroupRing(GF(2),CyclicGroup(4));; gap> u:=Elements(KG)[16]; (Z(2)^0)*f1*f2 gap> G:=Group(u);; gap> StructureDescription(G); "C4" gap> RandomIsNormal(KG,G,100); true
‣ RandomCenterOfCommutatorSubgroup( KG, n ) | ( function ) |
For a group ring KG, and a positive integer n (number of iterations), the function RandomCenterOfCommutatorSubgroup returns the center of the commutator subgroup of the normalized unit group using random method.
gap> RANDOM_SEED(1); gap> KG:=GroupRing(GF(2),DihedralGroup(8));; gap> cc:=RandomCenterOfCommutatorSubgroup(KG,100); <group with 8 generators> gap> StructureDescription(cc); "C2 x C2 x C2"
‣ RandomConjugacyClassByElement( KG, u, n ) | ( function ) |
For a group ring KG, normalized unit \(u \in KG\), and a positive integer n (number of iterations), the function RandomConjugacyClassByElement returns the random conjugacy class of the normalized unit u.
gap> KG:=GroupRing(GF(2),DihedralGroup(8));; gap> u:=Random(Elements(KG));; gap> rcc: = RandomConjugacyClassByElement(KG,u,100); gap> rcc[1]*u*rcc[1]^-1; true
generated by GAPDoc2HTML