% generated by GAPDoc2LaTeX from XML source (Frank Luebeck)
\documentclass[11pt]{report}
\usepackage{a4wide}
\sloppy
\pagestyle{myheadings}
\usepackage{amssymb}
\usepackage[latin1]{inputenc}
\usepackage{makeidx}
\makeindex
\usepackage{color}
\definecolor{DarkOlive}{rgb}{0.1047,0.2412,0.0064}
\definecolor{FireBrick}{rgb}{0.5812,0.0074,0.0083}
\definecolor{RoyalBlue}{rgb}{0.0236,0.0894,0.6179}
\definecolor{RoyalGreen}{rgb}{0.0236,0.6179,0.0894}
\definecolor{RoyalRed}{rgb}{0.6179,0.0236,0.0894}
\definecolor{LightBlue}{rgb}{0.8544,0.9511,1.0000}
\definecolor{Black}{rgb}{0.0,0.0,0.0}
\definecolor{FuncColor}{rgb}{1.0,0.0,0.0}
%% strange name because of pdflatex bug:
\definecolor{Chapter }{rgb}{0.0,0.0,1.0}
\usepackage{fancyvrb}
\usepackage{pslatex}
\usepackage[
a4paper=true,bookmarks=false,pdftitle={Written with GAPDoc},
pdfcreator={LaTeX with hyperref package / GAPDoc},
colorlinks=true,backref=page,breaklinks=true,linkcolor=RoyalBlue,
citecolor=RoyalGreen,filecolor=RoyalRed,
urlcolor=RoyalRed,pagecolor=RoyalBlue]{hyperref}
% write page numbers to a .pnr log file for online help
\newwrite\pagenrlog
\immediate\openout\pagenrlog =\jobname.pnr
\immediate\write\pagenrlog{PAGENRS := [}
\newcommand{\logpage}[1]{\protect\write\pagenrlog{#1, \thepage,}}
\newcommand{\Q}{\mathbb{Q}}
\newcommand{\R}{\mathbb{R}}
\newcommand{\C}{\mathbb{C}}
\newcommand{\Z}{\mathbb{Z}}
\newcommand{\N}{\mathbb{N}}
\newcommand{\F}{\mathbb{F}}
\newcommand{\GAP}{\textsf{GAP}}
\newsavebox{\backslashbox}
\sbox{\backslashbox}{\texttt{\symbol{92}}}
\newcommand{\bs}{\usebox{\backslashbox}}
\begin{document}
\logpage{[ 0, 0, 0 ]}
\begin{titlepage}
\begin{center}{\Huge \textbf{\textsf{LAGUNA}}}\\[1cm]
\hypersetup{pdftitle=\textsf{LAGUNA}}
\markright{\scriptsize \mbox{}\hfill \textsf{LAGUNA} \hfill\mbox{}}
{\Large \textbf{Lie AlGebras and UNits of group Algebras}}\\[1cm]
{Version 3.4}\\[1cm]
{February 2007}\\[1cm]
\mbox{}\\[2cm]
{\large \textbf{Victor Bovdi }}\\
{\large \textbf{Alexander Konovalov }}\\
{\large \textbf{Richard Rossmanith }}\\
{\large \textbf{ Csaba Schneider }}\\
\hypersetup{pdfauthor=Victor Bovdi ; Alexander Konovalov ; Richard Rossmanith ; Csaba Schneider }
\end{center}\vfill
\mbox{}\\
{\mbox{}\\
\small \noindent \textbf{Victor Bovdi } --- Email: \href{mailto://vbovdi@math.klte.hu}{\texttt{vbovdi@math.klte.hu}}\\
--- Address: \begin{minipage}[t]{8cm}\noindent
Institute of Mathematics and Informatics\\
University of Debrecen\\
P.O.Box 12, Debrecen, H-4010 Hungary \end{minipage}
}\\
{\mbox{}\\
\small \noindent \textbf{Alexander Konovalov } --- Email: \href{mailto://konovalov@member.ams.org}{\texttt{konovalov@member.ams.org}}\\
--- Homepage: \href{http://www.cs.st-andrews.ac.uk/~alexk/}{\texttt{http://www.cs.st-andrews.ac.uk/\~{}alexk/}}\\
--- Address: \begin{minipage}[t]{8cm}\noindent
School of Computer Science\\
University of St Andrews\\
Jack Cole Building, North Haugh,\\
St Andrews, Fife, KY16 9SX, Scotland \end{minipage}
}\\
{\mbox{}\\
\small \noindent \textbf{Richard Rossmanith } --- Email: \href{mailto://richard.rossmanith@d-fine.de}{\texttt{richard.rossmanith@d-fine.de}}\\
--- Address: \begin{minipage}[t]{8cm}\noindent
d-fine GmbH\\
Mergenthalerallee 55 65760 Eschborn/Frankfurt\\
Germany \end{minipage}
}\\
{\mbox{}\\
\small \noindent \textbf{ Csaba Schneider } --- Email: \href{mailto://csaba.schneider@sztaki.hu}{\texttt{csaba.schneider@sztaki.hu}}\\
--- Homepage: \href{http://www.sztaki.hu/~schneider}{\texttt{http://www.sztaki.hu/\~{}schneider}}\\
--- Address: \begin{minipage}[t]{8cm}\noindent
Informatics Laboratory\\
Computer and Automation Research Institute\\
The Hungarian Academy of Sciences\\
1111 Budapest, Lagymanyosi u. 11, Hungary \end{minipage}
}\\
\end{titlepage}
\newpage\setcounter{page}{2}
{\small
\section*{Abstract}
\logpage{[ 0, 0, 1 ]}
\index{LAGUNA package@\textsf{LAGUNA} package} The title ``\textsf{LAGUNA}'' stands for ``\textsc{L}ie \textsc{A}l\textsc{G}ebras and \textsc{UN}its of group \textsc{A}lgebras''. This is the new name of the \textsf{GAP}4 package \textsf{LAG}, which is thus replaced by \textsf{LAGUNA}.
\textsf{LAGUNA} extends the \textsf{GAP} functionality for computations in group rings. Besides computing some general
properties and attributes of group rings and their elements, \textsf{LAGUNA} is able to perform two main kinds of computations. Namely, it can verify
whether a group algebra of a finite group satisfies certain Lie properties;
and it can calculate the structure of the normalized unit group of a group
algebra of a finite $p$-group over the field of $p$ elements.
}\\[1cm]
{\small
\section*{Copyright}
\logpage{[ 0, 0, 2 ]}
{\copyright} 2003-2007 by Victor Bovdi, Alexander Konovalov, Richard Rossmanith, and Csaba
Schneider
\textsf{LAGUNA} is free software; you can redistribute it and/or modify it under the terms of
the GNU General Public License as published by the Free Software Foundation;
either version 2 of the License, or (at your option) any later version. For
details, see the FSF's own site \href{http://www.gnu.org/licenses/gpl.html}{\texttt{http://www.gnu.org/licenses/gpl.html}}.
If you obtained \textsf{LAGUNA}, we would be grateful for a short notification sent to one of the authors.
If you publish a result which was partially obtained with the usage of \textsf{LAGUNA}, please cite it in the following form:
V. Bovdi, A. Konovalov, R. Rossmanith and C. Schneider. \emph{LAGUNA --- Lie AlGebras and UNits of group Algebras, Version 3.4;} 2007 (\href{http://www.cs.st-andrews.ac.uk/~alexk/laguna.htm}{\texttt{http://www.cs.st-andrews.ac.uk/\~{}alexk/laguna.htm}}). }\\[1cm]
{\small
\section*{Acknowledgements}
\logpage{[ 0, 0, 3 ]}
Some of the features of \textsf{LAGUNA} were already included in the \textsf{GAP}4 package \textsf{LAG} written by the third author, Richard Rossmanith. The three other authors first would like to thank Greg Gamble for maintaining \textsf{LAG} and for upgrading it from version 2.0 to version 2.1, and Richard Rossmanith
for allowing them to update and extend the \textsf{LAG} package. We are also grateful to Wolfgang Kimmerle for organizing the workshop
``Computational Group and Group Ring Theory'' (University of Stuttgart, 28--29
November, 2002), which allowed us to meet and have fruitful discussions that
led towards the final \textsf{LAGUNA} release.
We are all very grateful to the members of the \textsf{GAP} team: Thomas Breuer, Willem de Graaf, Alexander Hulpke, Stefan Kohl, Steve
Linton, Frank Lübeck, Max Neunhöffer and many other colleagues for helpful
comments and advise. We acknowledge very much Herbert Pahlings for
communicating the package and the referee for careful testing \textsf{LAGUNA} and useful suggestions.
A part of the work on upgrading \textsf{LAG} to \textsf{LAGUNA} was done in 2002 during Alexander Konovalov's visits to Debrecen, St Andrews
and Stuttgart Universities. He would like to express his gratitude to Adalbert
Bovdi and Victor Bovdi, Colin Campbell, Edmund Robertson and Steve Linton,
Wolfgang Kimmerle, Martin Hertweck and Stefan Kohl for their warm hospitality,
and to the NATO Science Fellowship Program, to the London Mathematical Society
and to the DAAD for the support of these visits.
}\\[1cm]
\newpage
\def\contentsname{Contents\logpage{[ 0, 0, 4 ]}}
\tableofcontents
\newpage
\chapter{\textcolor{Chapter }{Introduction}}\label{Intro}
\logpage{[ 1, 0, 0 ]}
{
\section{\textcolor{Chapter }{General aims}}\label{IntroFirst}
\logpage{[ 1, 1, 0 ]}
{
\textsf{LAGUNA} -- \textsc{L}ie \textsc{A}l\textsc{G}ebras and \textsc{UN}its of group \textsc{A}lgebras -- is the new name of the \textsf{GAP}4 package \textsf{LAG}. The \textsf{LAG} package arose as a byproduct of the third author's PhD thesis \cite{Ros97}. Its first version was ported to \textsf{GAP}4 and was brought into the standard \textsf{GAP}4 package format during his visit to St Andrews in September 1998.
The main objective of \textsf{LAG} is to deal with Lie algebras associated with some associative algebras, and,
in particular, Lie algebras of group algebras. Using \textsf{LAG} it is possible to verify some properties or calculate certain Lie ideals of
such Lie algebras very efficiently, due to their special structure. In the
current version of \textsf{LAGUNA} the main part of the Lie algebra functionality is heavily built on the
previous \textsf{LAG} releases.
The \textsf{GAP}4 package \textsf{LAGUNA} also extends the \textsf{GAP} functionality for calculations with units of modular group algebras. In
particular, using this package, one can check whether an element of such a
group algebra is invertible. \textsf{LAGUNA} also contains an implementation of an efficient algorithm to calculate the
(normalized) unit group of the group algebra of a finite $p$-group over the field of $p$ elements. \index{SISYPHOS package@\textsf{SISYPHOS} package} Thus, the present version of \textsf{LAGUNA} provides a part of the functionality of the \textsf{SISYPHOS} program, which was developed by Martin Wursthorn to study the modular
isomorphism problem; see \cite{Wursthorn}.
The corresponding functions of \textsf{LAGUNA} use the same algorithmic and theoretical approach as those in \textsf{SISYPHOS}. The reason why we reimplemented the normalised unit group algorithms in the \textsf{LAGUNA} package is that \textsf{SISYPHOS} has no interface to \textsf{GAP}4, and, even in \textsf{GAP}3, it is cumbersome to use the \textsf{SISYPHOS} output for further computation with the normalised unit group. For instance,
using \textsf{SISYPHOS} with its \textsf{GAP}3 interface, it is difficult to embed a finite $p$-group into the normalized unit group of its group algebra over the field of $p$ elements, but this can easily be done with \textsf{LAGUNA}. }
\section{\textcolor{Chapter }{General computations in group rings}}\label{IntroFirstAndaHalf}
\logpage{[ 1, 2, 0 ]}
{
The \textsf{LAGUNA} package provides a set of functions to carry out some basic computations with
a group ring and its elements. Among other things, \textsf{LAGUNA} provides elementary functions to compute such basic notions as support,
length, trace and augmentation of an element. For modular group algebras of
finite $p$-groups \textsf{LAGUNA} is able to calculate the power-structure of the augmentation ideal, which is
useful for the construction of the normalised unit group; see Sections \ref{GenSec}--\ref{Ideals} for more details. }
\section{\textcolor{Chapter }{Computations in the normalized unit group}}\label{IntroSecond}
\logpage{[ 1, 3, 0 ]}
{
One of the aims of the \textsf{LAGUNA} package is to carry out efficient computations in the normalised unit group of
the group algebra $FG$ of a finite $p$-group $G$ over the field $F$ of $p$ elements. If $U$ is the unit group of $FG$ then it is easy to see that $U$ is the direct product of $F^*$ and $V(FG)$, where $F^*$ is the multiplicative group of $F$, and $V(FG)$ is the group of normalised units. A unit of $FG$ of the form $\alpha_1 \cdot g_1 + \alpha_2 \cdot g_2 + \cdots + \alpha_k \cdot g_k$ with $\alpha_i \in F$ and $g_i \in G$ is said to be normalised if the sum $\alpha_1 + \alpha_2 + \cdots + \alpha_k$ is equal to $1$.
It is well-known that the normalised unit group $V$ has order $|F|^{|G|-1}$, and so $V$ is a finite $p$-group. Thus computing $V$ efficiently means to compute a polycyclic presentation for $V$. For the theory of polycyclic presentations refer to \cite[Chapter 9]{Sims}. For this computation we use an algorithm that was also used in the \textsf{SISYPHOS} package. For a brief description see Chapter \ref{Theory}. The functions that compute the structure of the normalised unit group are
described in Section \ref{UnitGroup}. }
\section{\textcolor{Chapter }{Computing Lie properties of the group algebra }}\label{IntroThird}
\logpage{[ 1, 4, 0 ]}
{
The functions that are used to compute Lie properties of $p$-modular group algebras were already included in the previous versions of \textsf{LAG}. The bracket operation $[\cdot,\cdot]$ on a $p$-modular group algebra $FG$ is defined by $[a,b]=ab-ba$. It is well-known and very easy to check that $(FG, +, [\cdot,\cdot])$ is a Lie algebra. Then we may ask what kind of Lie algebra properties are
satisfied by $FG$. The results in \cite{LR86}, \cite{PPS73}, and \cite{Ros00} give fast, practical algorithms to check whether the Lie algebra $FG$ is abelian, nilpotent, soluble, centre-by-metabelian, etc. The functions that
implement these algorithms are described in Section \ref{LieAlgebra}. }
\section{\textcolor{Chapter }{Installation and system requirements}}\label{IntroFourth}
\logpage{[ 1, 5, 0 ]}
{
\textsf{LAGUNA} does not use external binaries and, therefore, works without restrictions on
the type of the operating system. It is designed for \textsf{GAP}4.4 and no compatibility with previous releases of \textsf{GAP}4 is guaranteed.
To use the \textsf{LAGUNA} online help it is necessary to install the \textsf{GAP}4 package \textsf{GAPDoc} by Frank L\"ubeck and Max Neunh\"offer, which is available from the \textsf{GAP} site or from \href{http://www.math.rwth-aachen.de/~Frank.Luebeck/GAPDoc/}{\texttt{http://www.math.rwth-aachen.de/\~{}Frank.Luebeck/GAPDoc/}}.
\textsf{LAGUNA} is distributed in standard formats (\texttt{zoo}, \texttt{tar.gz}, \texttt{tar.bz2}, \texttt{-win.zip}) and can be obtained from \href{http://www.cs.st-andrews.ac.uk/~alexk/laguna.htm}{\texttt{http://www.cs.st-andrews.ac.uk/\~{}alexk/laguna.htm}}. To unpack the archive \texttt{laguna-3.4.zoo} you need the program \texttt{unzoo}, which can be obtained from the \textsf{GAP} homepage \href{http://www.gap-system.org/}{\texttt{http://www.gap-system.org/}} (see section `Distribution'). To install \textsf{LAGUNA}, copy this archive into the \texttt{pkg} subdirectory of your \textsf{GAP}4.4 installation. The subdirectory \texttt{laguna} will be created in the \texttt{pkg} directory after the following command:
\texttt{unzoo -x laguna-3.4.zoo}
}
}
\chapter{\textcolor{Chapter }{A sample calculation with \textsf{LAGUNA}}}\label{Example}
\logpage{[ 2, 0, 0 ]}
{
Before explaining the theory behind the \textsf{LAGUNA} package we present a sample calculation to show the reader what \textsf{LAGUNA} is able to compute. We will carry out some calculations in the group algebra
of the dihedral group of order 16 over the field of two elements. First we
create this modular group algebra.
\begin{Verbatim}[fontsize=\small,frame=single,label=Example]
gap> K := GF( 2 );
GF(2)
gap> G := DihedralGroup( 16 );
<pc group of size 16 with 4 generators>
gap> KG := GroupRing( K, G );
<algebra-with-one over GF(2), with 4 generators>
\end{Verbatim}
The group algebra \texttt{KG} has some properties and attributes that are direct consequences of its
definition. These can be checked very quickly.
\begin{Verbatim}[fontsize=\small,frame=single,label=Example]
gap> IsGroupAlgebra( KG );
true
gap> IsPModularGroupAlgebra( KG );
true
gap> IsFModularGroupAlgebra( KG );
true
gap> UnderlyingGroup( KG );
<pc group of size 16 with 4 generators>
gap> LeftActingDomain( KG );
GF(2)
\end{Verbatim}
Since \texttt{KG} is naturally a group algebra, the information provided by \texttt{LeftActingDomain} can also be obtained using two other functions as follows.
\begin{Verbatim}[fontsize=\small,frame=single,label=Example]
gap> UnderlyingRing( KG );
GF(2)
gap> UnderlyingField( KG );
GF(2)
\end{Verbatim}
Let us construct a certain element of the group algebra. For example, we take
a minimal generating system of the group \texttt{G} and find the corresponding elements in \texttt{KG}.
\begin{Verbatim}[fontsize=\small,frame=single,label=Example]
gap> MinimalGeneratingSet( G );
[ f1, f2 ]
gap> l := List( last, g -> g^Embedding( G, KG ) );
[ (Z(2)^0)*f1, (Z(2)^0)*f2 ]
\end{Verbatim}
Now we construct an element \texttt{x} as follows.
\begin{Verbatim}[fontsize=\small,frame=single,label=Example]
gap> a :=l[1]; b:=l[2]; # a and b are images of group generators in KG
(Z(2)^0)*f1
(Z(2)^0)*f2
gap> e := One( KG ); # for convenience, we denote the identity by e
(Z(2)^0)*<identity> of ...
gap> x := ( e + a ) * ( e + b );
(Z(2)^0)*<identity> of ...+(Z(2)^0)*f1+(Z(2)^0)*f2+(Z(2)^0)*f1*f2
\end{Verbatim}
We may investigate some of the basic properties of our element.
\begin{Verbatim}[fontsize=\small,frame=single,label=Example]
gap> Support( x );
[ <identity> of ..., f1, f2, f1*f2 ]
gap> CoefficientsBySupport( x );
[ Z(2)^0, Z(2)^0, Z(2)^0, Z(2)^0 ]
gap> Length( x );
4
gap> TraceOfMagmaRingElement( x );
Z(2)^0
\end{Verbatim}
We can also calculate the augmentation of \texttt{x}, which is defined as the sum of its coefficients.
\begin{Verbatim}[fontsize=\small,frame=single,label=Example]
gap> Augmentation( x );
0*Z(2)
gap> IsUnit( KG, x );
false
\end{Verbatim}
Since the augmentation of \texttt{x} is zero, \texttt{x} is not invertible, but \texttt{1+x} is. This is again very easy to check.
\begin{Verbatim}[fontsize=\small,frame=single,label=Example]
gap> y := e + x;
(Z(2)^0)*f1+(Z(2)^0)*f2+(Z(2)^0)*f1*f2
gap> IsUnit( KG, y );
true
\end{Verbatim}
\textsf{LAGUNA} can calculate the inverse of \texttt{1+x} very quickly.
\begin{Verbatim}[fontsize=\small,frame=single,label=Example]
gap> y^-1;
(Z(2)^0)*f1+(Z(2)^0)*f2+(Z(2)^0)*f3+(Z(2)^0)*f4+(Z(2)^0)*f1*f2+(Z(2)^
0)*f1*f3+(Z(2)^0)*f1*f4+(Z(2)^0)*f2*f4+(Z(2)^0)*f1*f2*f4+(Z(2)^0)*f2*f3*f4+(
Z(2)^0)*f1*f2*f3*f4
gap> y * y^-1;
(Z(2)^0)*<identity> of ...
\end{Verbatim}
We may also want to check whether \texttt{y} is symmetric, that is, whether it is invariant under the classical involution;
or whether it is unitary, that is, whether the classical involution inverts \texttt{y}. We find that \texttt{y} is neither.
\begin{Verbatim}[fontsize=\small,frame=single,label=Example]
gap> Involution( y );
(Z(2)^0)*f1+(Z(2)^0)*f1*f2+(Z(2)^0)*f2*f3*f4
gap> y = Involution( y );
false
gap> IsSymmetric( y );
false
gap> y * Involution( y );
(Z(2)^0)*<identity> of ...+(Z(2)^0)*f2+(Z(2)^0)*f2*f3*f4
gap> IsUnitary( y );
false
\end{Verbatim}
Now we calculate some important ideals of \texttt{KG}. First we obtain the augmentation ideal which is the set of elements with
augmentation zero. In our case the augmentation ideal of \texttt{KG} coincides with the radical of \texttt{KG}, and this is taken into account in \textsf{LAGUNA}.
\begin{Verbatim}[fontsize=\small,frame=single,label=Example]
gap> AugmentationIdeal( KG );
<two-sided ideal in <algebra-with-one over GF(2), with 4 generators>,
(dimension 15)>
gap> RadicalOfAlgebra( KG ) = AugmentationIdeal( KG );
true
\end{Verbatim}
It is well-known that the augmentation ideal of \texttt{KG} is a nilpotent ideal. Using Jennings' theory on dimension subgroups, we can
obtain its nilpotency index without immediate calculation of its powers. This
is implemented in \textsf{LAGUNA}.
\begin{Verbatim}[fontsize=\small,frame=single,label=Example]
gap> AugmentationIdealNilpotencyIndex( KG );
9
\end{Verbatim}
\newpage On the other hand, we can also calculate the powers of the augmentation ideal.
\begin{Verbatim}[fontsize=\small,frame=single,label=Example]
gap> AugmentationIdealPowerSeries( KG );
[ <algebra of dimension 15 over GF(2)>, <algebra of dimension 13 over GF(2)>,
<algebra of dimension 11 over GF(2)>, <algebra of dimension 9 over GF(2)>,
<algebra of dimension 7 over GF(2)>, <algebra of dimension 5 over GF(2)>,
<algebra of dimension 3 over GF(2)>, <algebra of dimension 1 over GF(2)>,
<algebra over GF(2)> ]
\end{Verbatim}
We see that the length of this list is exactly the nilpotency index of the
augmentation ideal of \texttt{KG}.
Now let's work with the unit group of \texttt{KG}. First we calculate the normalized unit group, which is the set of elements
with augmentation one. The generators of the unit group are obtained as
explained in Chapter \ref{Theory}. This can be computed very quickly, but further computation with this group
is very inefficient.
\begin{Verbatim}[fontsize=\small,frame=single,label=Example]
gap> V := NormalizedUnitGroup( KG );
<group of size 32768 with 15 generators>
\end{Verbatim}
In order to make our computation in the normalised unit group efficient, we
calculate a power-commutator presentation for this group.
\begin{Verbatim}[fontsize=\small,frame=single,label=Example]
gap> W := PcNormalizedUnitGroup( KG );
<pc group of size 32768 with 15 generators>
\end{Verbatim}
\textsf{GAP} has many efficient and practical algorithms for groups given by a
power-commutator presentation. In order to use these algorithms to carry out
computation in the normalised unit group, we need to set up isomorphisms
between the outputs of \texttt{NormalizedUnitGroup} and \texttt{PcNormalizedUnitGroup}.
The first isomorphism maps \texttt{NormalizedUnitGroup(KG)} onto the polycyclically presented \texttt{PcNormalizedUnitGroup(PC)}. Let's find the images of the elements of the group \texttt{G} in \texttt{W}.
\begin{Verbatim}[fontsize=\small,frame=single,label=Example]
gap> t := NaturalBijectionToPcNormalizedUnitGroup( KG );
MappingByFunction( <group of size 32768 with
15 generators>, <pc group of size 32768 with
15 generators>, function( x ) ... end )
gap> List( AsList( G ), x -> ( x^Embedding( G, KG ) )^t );
[ <identity> of ..., f2, f1, f3, f7, f1*f2*f3, f2*f3, f2*f7, f1*f3, f1*f7,
f3*f7, f1*f2*f7, f1*f2*f3*f7, f2*f3*f7, f1*f3*f7, f1*f2 ]
\end{Verbatim}
\newpage The second isomorphism is the inverse of the first.
\begin{Verbatim}[fontsize=\small,frame=single,label=Example]
gap> f := NaturalBijectionToNormalizedUnitGroup( KG );
[ f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12, f13, f14, f15 ] ->
[ (Z(2)^0)*f2, (Z(2)^0)*f1, (Z(2)^0)*f3,
(Z(2)^0)*f1+(Z(2)^0)*f2+(Z(2)^0)*f1*f2,
(Z(2)^0)*f2+(Z(2)^0)*f3+(Z(2)^0)*f2*f3,
(Z(2)^0)*f1+(Z(2)^0)*f3+(Z(2)^0)*f1*f3, (Z(2)^0)*f4,
(Z(2)^0)*f1+(Z(2)^0)*f2+(Z(2)^0)*f3+(Z(2)^0)*f1*f2+(Z(2)^0)*f1*f3+(Z(2)^
0)*f2*f3+(Z(2)^0)*f1*f2*f3, (Z(2)^0)*f2+(Z(2)^0)*f4+(Z(2)^0)*f2*f4,
(Z(2)^0)*f1+(Z(2)^0)*f4+(Z(2)^0)*f1*f4,
(Z(2)^0)*f3+(Z(2)^0)*f4+(Z(2)^0)*f3*f4,
(Z(2)^0)*f1+(Z(2)^0)*f2+(Z(2)^0)*f4+(Z(2)^0)*f1*f2+(Z(2)^0)*f1*f4+(Z(2)^
0)*f2*f4+(Z(2)^0)*f1*f2*f4, (Z(2)^0)*f2+(Z(2)^0)*f3+(Z(2)^0)*f4+(Z(2)^
0)*f2*f3+(Z(2)^0)*f2*f4+(Z(2)^0)*f3*f4+(Z(2)^0)*f2*f3*f4,
(Z(2)^0)*f1+(Z(2)^0)*f3+(Z(2)^0)*f4+(Z(2)^0)*f1*f3+(Z(2)^0)*f1*f4+(Z(2)^
0)*f3*f4+(Z(2)^0)*f1*f3*f4, (Z(2)^0)*f1+(Z(2)^0)*f2+(Z(2)^0)*f3+(Z(2)^
0)*f4+(Z(2)^0)*f1*f2+(Z(2)^0)*f1*f3+(Z(2)^0)*f1*f4+(Z(2)^0)*f2*f3+(Z(2)^
0)*f2*f4+(Z(2)^0)*f3*f4+(Z(2)^0)*f1*f2*f3+(Z(2)^0)*f1*f2*f4+(Z(2)^
0)*f1*f3*f4+(Z(2)^0)*f2*f3*f4+(Z(2)^0)*f1*f2*f3*f4 ]
\end{Verbatim}
For example, we may calculate the conjugacy classes of the group \texttt{W}, and then map their representatives back into the group algebra.
\begin{Verbatim}[fontsize=\small,frame=single,label=Example]
gap> cc := ConjugacyClasses( W );;
gap> Length( cc );
848
gap> Representative( cc[ Length( cc ) ] );
f1*f2*f4*f6*f12*f15
gap> last^f;
(Z(2)^0)*<identity> of ...+(Z(2)^0)*f2+(Z(2)^0)*f4+(Z(2)^0)*f1*f2+(Z(2)^
0)*f1*f3+(Z(2)^0)*f1*f4+(Z(2)^0)*f2*f3+(Z(2)^0)*f2*f4+(Z(2)^0)*f3*f4+(Z(2)^
0)*f1*f2*f3+(Z(2)^0)*f1*f3*f4
\end{Verbatim}
Having a power-commutator presentation of the normalised unit group, we may
use the full power of the \textsf{GAP} functionality for such groups. For example, the lower central series can be
calculated very quickly.
\begin{Verbatim}[fontsize=\small,frame=single,label=Example]
gap> LowerCentralSeries( W );
[ <pc group of size 32768 with 15 generators>,
Group([ f3, f5*f8*f10*f12*f13*f14*f15, f6*f8*f12*f14*f15, f7, f9*f12,
f10*f14, f11*f13, f13*f14, f14*f15 ]),
Group([ f7, f9*f12, f10*f15, f11*f15, f13*f15, f14*f15 ]),
Group([ f11*f15, f13*f15, f14*f15 ]), Group([ <identity> of ... ]) ]
\end{Verbatim}
\newpage Let's now compute, for instance, a minimal system of generators of the centre
of the normalised unit group. First we carry out the computation in the group
which is determined by the power-commutator presentation, then we map the
result into our group algebra.
\begin{Verbatim}[fontsize=\small,frame=single,label=Example]
gap> C := Centre( W );
Group([ f3*f5*f13*f15, f7, f15, f13*f15, f14*f15, f11*f13*f14*f15 ])
gap> m := MinimalGeneratingSet( C );
[ f7*f13*f14*f15, f13*f14*f15, f7*f11*f14*f15, f15, f3*f5*f14 ]
gap> List( m, g -> g^f );
[ (Z(2)^0)*<identity> of ...+(Z(2)^0)*f3+(Z(2)^0)*f1*f2+(Z(2)^0)*f3*f4+(Z(2)^
0)*f1*f2*f3+(Z(2)^0)*f1*f2*f4+(Z(2)^0)*f1*f2*f3*f4,
(Z(2)^0)*f3+(Z(2)^0)*f4+(Z(2)^0)*f1*f2+(Z(2)^0)*f3*f4+(Z(2)^0)*f1*f2*f3+(
Z(2)^0)*f1*f2*f4+(Z(2)^0)*f1*f2*f3*f4, (Z(2)^0)*<identity> of ...+(Z(2)^
0)*f2+(Z(2)^0)*f3+(Z(2)^0)*f1*f2+(Z(2)^0)*f2*f3+(Z(2)^0)*f2*f4+(Z(2)^
0)*f3*f4+(Z(2)^0)*f1*f2*f3+(Z(2)^0)*f1*f2*f4+(Z(2)^0)*f2*f3*f4+(Z(2)^
0)*f1*f2*f3*f4, (Z(2)^0)*f1+(Z(2)^0)*f2+(Z(2)^0)*f3+(Z(2)^0)*f4+(Z(2)^
0)*f1*f2+(Z(2)^0)*f1*f3+(Z(2)^0)*f1*f4+(Z(2)^0)*f2*f3+(Z(2)^0)*f2*f4+(
Z(2)^0)*f3*f4+(Z(2)^0)*f1*f2*f3+(Z(2)^0)*f1*f2*f4+(Z(2)^0)*f1*f3*f4+(Z(2)^
0)*f2*f3*f4+(Z(2)^0)*f1*f2*f3*f4, (Z(2)^0)*<identity> of ...+(Z(2)^0)*f1+(
Z(2)^0)*f3+(Z(2)^0)*f1*f3+(Z(2)^0)*f1*f4+(Z(2)^0)*f2*f3+(Z(2)^0)*f2*f4+(
Z(2)^0)*f3*f4+(Z(2)^0)*f1*f3*f4 ]
\end{Verbatim}
We finish our example by calculating some properties of the Lie algebra
associated with \texttt{KG}. This example needs no further explanation.
\begin{Verbatim}[fontsize=\small,frame=single,label=Example]
gap> L := LieAlgebra( KG );
#I LAGUNA package: Constructing Lie algebra ...
<Lie algebra over GF(2)>
gap> D := LieDerivedSubalgebra( L );
#I LAGUNA package: Computing the Lie derived subalgebra ...
<Lie algebra of dimension 9 over GF(2)>
gap> LC := LieCentre( L );
<Lie algebra of dimension 7 over GF(2)>
gap> LieLowerNilpotencyIndex( KG );
5
gap> LieUpperNilpotencyIndex( KG );
5
gap> IsLieAbelian( L );
false
gap> IsLieSolvable( L );
#I LAGUNA package: Checking Lie solvability ...
true
gap> IsLieMetabelian( L );
false
gap> IsLieCentreByMetabelian( L );
true
\end{Verbatim}
}
\chapter{\textcolor{Chapter }{The basic theory behind \textsf{LAGUNA}}}\label{Theory}
\logpage{[ 3, 0, 0 ]}
{
In this chapter we describe the theory that is behind the algorithms used by \textsf{LAGUNA}.
\section{\textcolor{Chapter }{Notation and definitions}}\label{TheoryFirst}
\logpage{[ 3, 1, 0 ]}
{
\index{group algebra} Let $G$ be a group and $F$ a field. Then the \emph{group algebra} $FG$ consists of the set of formal linear combinations of the form
\[ \sum_{g \in G}\alpha_g g,\qquad \alpha_g \in F \]
where all but finitely many of the $\alpha_g$ are zero. The group algebra $FG$ is an $F$-algebra with the obvious operations. Clearly, $\dim FG=|G|$.
\index{augmentation homomorphism} \index{augmentation ideal} The \emph{augmentation homomorphism} $ \chi : FG \rightarrow F$ is defined by
\[ \chi\left(\sum_{g \in G}\alpha_g g\right)=\sum_{g \in G}\alpha_g. \]
It is easy to see that $\chi$ is indeed a homomorphism onto $F$. The kernel of $\chi$ is called the \emph{augmentation ideal} of $FG$. The augmentation ideal is denoted $A(FG)$, or simply $A$ when there is no danger of confusion. It follows from the isomorphism theorems
that $\dim A(FG)=\dim FG-1=|G|-1$. Another way to write the augmentation ideal is
\[ A(FG)=\left\{\sum_{g \in G}\alpha_g g\ |\ \sum_{g \in G}\alpha_g=0\right\}. \]
\index{unit} \index{unit group} \index{normalised unit} \index{normalised unit group} An invertible element of $FG$ is said to be a \emph{unit}. Clearly the elements of $G$ and the non-zero elements of $F$ are units. The set of units in $FG$ is a group with respect to the multiplication of $FG$. The \emph{unit group} of $FG$ is denoted $U(FG)$ or simply $U$ when there is no risk of confusion. A unit $u$ is said to be \emph{normalised} if $\chi(u)=1$. The set of normalised units forms a subgroup of the unit group, and is
referred to as the \emph{normalised unit group}. The normalised unit group of $FG$ is denoted $V(FG)$, or simply $V$. It is easy to prove that $U(FG) = F^* \times V(FG)$ where $F^*$ denotes the multiplicative group of $F$. }
\section{\textcolor{Chapter }{$p$-modular group algebras}}\label{TheorySecond}
\logpage{[ 3, 2, 0 ]}
{
\index{p-modular group algebra@$p$-modular group algebra} A group algebra $FG$ is said to be $p$-modular if $F$ is the field of characteristic $p$, and $G$ is a finite $p$-group. A lot of information about the structure of $p$-modular group algebras can be found in \cite[Chapter VIII]{HB}. In a $p$-modular group algebra we have that an element $u$ is a unit if and only if $\chi(u)\neq 0$. Hence the normalised unit group $V$ consists of all elements of $FG$ with augmentation $1$. In other words $V$ is a coset of the augmentation ideal, namely $V=1+A$. This also implies that $|V|=|A|=|F|^{|G|-1}$, and so $V$ is a finite $p$-group.
\index{power-commutator presentation} One of the aims of the \textsf{LAGUNA} package is to compute a power-commutator presentation for the normalised unit
group in the case when $G$ is a finite $p$-group and $F$ is a field of $p$ elements. Such a presentation is given by generators $y_1, \ldots, y_{|G|-1} $ and two types of relations: $y_i^p=(y_{i+1})^{\alpha_{i,i+1}} \cdots (y_{|G|-1})^{\alpha_{i,|G|-1}}$ for $ 1 \leq i \leq |G|-1 $, and $ [y_j,y_i]=(y_{j+1})^{\alpha_{j,i,j+1}} \cdots (y_{|G|-1})^{\alpha_{j,i,|G|-1}} $ for $ 1 \leq i{\textless}j \leq |G|-1$, where the exponents $\alpha_{i,k}$ and $\alpha_{i,j,k}$ are elements of the set $\{0,\ldots,p-1\}$. Having such a presentation, it is possible to carry out efficient
computations in the finite $p$-group $V$; see \cite[Chapter 9]{Sims}. }
\section{\textcolor{Chapter }{Polycyclic generating set for $V$}}\label{TheoryThird}
\logpage{[ 3, 3, 0 ]}
{
Let $G$ be a finite $p$-group and $F$ the field of $p$ elements. Our aim is to construct a power-commutator presentation for $V=V(FG)$. We noted earlier that $V=1+A$, where $A$ is the augmentation ideal. We use this piece of information and construct a
polycyclic generating set for $V$ using a suitable basis for $A$. Before constructing this generating set, we note that $A$ is a nilpotent ideal in $FG$. In other words there is some $c$ such that $A^c\neq 0$ but $A^{c+1}=0$. Hence we can consider the following series of ideals in $A$:
\[ A\rhd A^2\rhd\cdots\rhd A^{c}\rhd A^{c+1}=0. \]
It is clear that a quotient $A^i/A^{i+1}$of this chain has trivial multiplication, that is, such a quotient is a
nil-ring. The chain $A^i$ gives rise to a series of normal subgroups in $V$:
\[ V=1+A\rhd 1+A^2\rhd\cdots\rhd 1+A^c\rhd 1+A^{c+1}=1. \]
It is easy to see that the chain $1+A^i$ is central, that is, $(1+A^i)/(1+A^{i+1})\leq Z((1+A)/(1+A^{i+1}))$.
\index{Jennings series} \index{dimension basis} \index{weight, of dimension basis element} Now we show how to compute a basis for $A^i$ that gives a polycyclic generating set for $1+A^i$. Let
\[ G=G_1 \rhd G_2\rhd\cdots\rhd G_{k}\rhd G_{k+1}=1 \]
be the \emph{Jennings series} of $G$. That is, $G_{i+1}=[G_i,G]G_{j^p}$ where $j$ is the smallest non-negative integer such that $j\geq i/p$. For all $i\leq k$ select elements $x_{i,1},\ldots,x_{i,l_i}$ of $G_i$ such that $\{x_{i,1}G_{i+1},\ldots,x_{i,l_i}G_{i+1}\}$ is a minimal generating set for the elementary abelian group $G_i/G_{i+1}$. For the Jennings series it may happen that $G_i=G_{i+1}$ for some $i$. In this case we choose an empty generating set for the quotient $G_i/G_{i+1}$ and $l_i=0$. Then the set $x_{1,1},\ldots,x_{1,l_1},\ldots,x_{k,1},\ldots,x_{k,l_k}$ is said to be a \emph{dimension basis} for $G$. The \emph{weight} of a dimension basis element $x_{i,j}$ is $i$.
\index{standard product} A non-empty product
\[ u=(x_{1,1}-1)^{\alpha_{1,1}}\cdots(x_{1,l_1}-1)^{\alpha_{1,l_1}}\cdots
(x_{k,1}-1)^{\alpha_{k,1}}\cdots(x_{k,l_k}-1)^{\alpha_{k,l_k}} \]
where $0\leq \alpha_{i,j}\leq p-1$ is said to be \emph{standard}. Clearly, a standard product is an element of the augmentation ideal $A$. The weight of the standard product $u$ is
\[ \sum_{i=1}^k i(\alpha_{i,1}+\cdots+\alpha_{i,l_i}). \]
The total number of standard products is $|G|-1$ .
\textsc{Lemma (}\cite[Theorem VIII.2.6]{HB}\textsc{).} For $i\leq c$, the set $S_i$ of standard products of weight at least $i$ forms a basis for $A^i$. Moreover, the set $1+S_i=\{1+s\ |\ s \in S_i\}$ is a polycyclic generating set for $1+A^i$. In particular $1+S_1$ is a polycyclic generating set for $V$.
A basis for $A$ consisting of the standard products is referred to as a \emph{weighted basis}. Note that a weighted basis is a basis for the augmentation ideal, and not
for the whole group algebra.
Let $x_1,\ldots,x_{{|G|}-1}$ denote the standard products where we choose the indices so that the weight of $x_i$ is not larger than the weight of $x_{i+1}$ for all $i$, and set $y_i=1+x_i$. Then every element $v$ of $V$ can be uniquely written in the form
\[ v=y_1^{\alpha_1}\cdots (y_{|G|-1})^{\alpha_{|G|-1}}, \quad
\alpha_1,\ldots,\alpha_{|G|-1} \in \{0,\ldots,p-1\}. \]
This expression is called the \emph{canonical form} of $v$. We note that by adding a generator of $F^*$ to the set $y_1,\ldots,y_{|G|-1|}$ we can obtain a polycyclic generating set for the unit group $U$. }
\section{\textcolor{Chapter }{Computing the canonical form}}\label{TheoryFourth}
\logpage{[ 3, 4, 0 ]}
{
We show how to compute the canonical form of a normalised unit with respect to
the polycyclic generating set $y_1,\ldots,y_{|G|-1}$. We use the following elementary lemma.
\textsc{Lemma.} Let $i\leq c$ and suppose that $w \in A^i$. Assume that $x_{s_i},x_{s_i+1}\ldots,x_{r_i}$ are the standard products with weight $i$ and for $s_i\leq j\leq r_i$ set $y_j=1+x_j$. Then for all $\alpha_{s_i},\ldots,\alpha_{r_i}\in\{0,\ldots,p-1\}$ we have that
\[ w\equiv \alpha_{s_i}x_{s_i}+\cdots+\alpha_{r_i}x_{r_i}\quad \bmod \quad
A^{i+1} \]
if an only if
\[ 1+w\equiv (y_{s_i})^{\alpha_{s_i}}\cdots (y_{r_i})^{\alpha_{r_i}}\quad \bmod
\quad 1+A^{i+1}. \]
Suppose that $w$ is an element of the augmentation ideal $A$ and $1+w$ is a normalised unit. Let $x_1,\ldots,x_{r_1}$ be the standard products of weight 1, and let $y_1,\ldots,y_{r_1}$ be the corresponding elements in the polycyclic generating set. Then using the
previous lemma, we find $\alpha_1,\ldots,\alpha_{r_1}$ such that
\[ w\equiv \alpha_{1}x_{1}+\cdots+\alpha_{r_1}x_{r_1}\quad \bmod \quad A^{2}, \]
and so
\[ 1+w\equiv (y_{1})^{\alpha_{1}}\cdots (y_{r_1})^{\alpha_{r_1}}\quad \bmod \quad
1+A^{2}. \]
Now we have that $1+w=(y_{1})^{\alpha_{1}}\cdots (y_{r_1})^{\alpha_{r_1}}(1+w_2)$ for some $w_2 \in A^2$. Then suppose that $x_{s_2},x_{s_2+1},\ldots,x_{r_2}$ are the standard products of weight 2. We find $\alpha_{s_2},\ldots,\alpha_{r_2}$ such that
\[ w_2\equiv \alpha_{s_2}x_{s_2}+\cdots+\alpha_{r_2}x_{r_2}\quad \bmod \quad
A^{3}. \]
Then the lemma above implies that
\[ 1+w_2\equiv (y_{s_2})^{\alpha_{s_2}}\cdots (y_{r_2})^{\alpha_{r_2}}\quad \bmod
\quad 1+A^{3}. \]
Thus $1+w_2=(y_{s_2})^{\alpha_{s_2}}\cdots (y_{r_2})^{\alpha_{r_2}}(1+w_3)$ for some $w_3 \in A^3$, and so $1+w=(y_{1})^{\alpha_{1}}\cdots
(y_{r_1})^{\alpha_{r_1}}(y_{s_2})^{\alpha_{s_2}}\cdots
(y_{r_2})^{\alpha_{r_2}}(1+w_3)$. We repeat this process, and after $c$ steps we obtain the canonical form for the element $1+w$. }
\section{\textcolor{Chapter }{Computing a power commutator presentation for $V$}}\label{TheoryFifth}
\logpage{[ 3, 5, 0 ]}
{
Using the procedure in the previous section, it is easy to compute a power
commutator presentation for the normalized unit group $V$ of a $p$-modular group algebra over the field of $p$ elements. First we compute the polycyclic generating sequence $y_1,\ldots,y_{|G|-1}$ as in Section \ref{TheoryThird}. Then for each $y_i$ and for each $y_j,\ y_i$ such that $i{\textless}j$ we compute the canonical form for $y_i^p$ and $[y_j,y_i]$ as described in Section \ref{TheoryFourth}.
Once a power-commutator presentation for $V$ is constructed, it is easy to obtain a polycyclic presentation for the unit
group $U$ by adding an extra central generator $y$ corresponding to a generator of the cyclic group $F^*$ and enforcing that $y^{p-1}=1$. }
\section{\textcolor{Chapter }{Verifying Lie properties of $FG$}}\label{TheorySixth}
\logpage{[ 3, 6, 0 ]}
{
If $FG$ is a group algebra then one can consider the Lie bracket operation defined by $[a,b]=ab-ba$. Then it is well-known that $FG$ with respect to the scalar multiplication, the addition, and the bracket
operation becomes a Lie algebra over $F$. This Lie algebra is also denoted $FG$. Some Lie properties of such Lie algebras can be computed very efficiently.
In particular, it can be verified whether the Lie algebra $FG$ is nilpotent, soluble, metabelian, centre-by-metabelian. Fast algorithms that
achieve these goals are described in \cite{LR86}, \cite{PPS73}, and \cite{Ros00}. }
}
\chapter{\textcolor{Chapter }{\textsf{LAGUNA} functions}}\label{Funct}
\logpage{[ 4, 0, 0 ]}
{
\section{\textcolor{Chapter }{General functions for group algebras}}\label{GenSec}
\logpage{[ 4, 1, 0 ]}
{
\subsection{\textcolor{Chapter }{IsGroupAlgebra}}
\logpage{[ 4, 1, 1 ]}\nobreak
{\noindent\textcolor{FuncColor}{$\Diamond$\ \texttt{IsGroupAlgebra( KG )\index{IsGroupAlgebra@\texttt{IsGroupAlgebra}}
\label{IsGroupAlgebra}
}\hfill{\scriptsize (property)}}\\
A group ring over a field is called a group algebra. For a group ring \mbox{\texttt{KG}}, \texttt{IsGroupAlgebra} returns \texttt{true}, if the underlying ring of \mbox{\texttt{KG}} is a field; \texttt{false} is returned otherwise. This property will be set automatically for every group
ring created by the function \texttt{GroupRing}. }
\begin{Verbatim}[fontsize=\small,frame=single,label=Example]
gap> IsGroupAlgebra( GroupRing( GF( 2 ), DihedralGroup( 16 ) ) );
true
gap> IsGroupAlgebra( GroupRing( Integers, DihedralGroup( 16 ) ) );
false
\end{Verbatim}
\subsection{\textcolor{Chapter }{IsFModularGroupAlgebra}}
\logpage{[ 4, 1, 2 ]}\nobreak
{\noindent\textcolor{FuncColor}{$\Diamond$\ \texttt{IsFModularGroupAlgebra( KG )\index{IsFModularGroupAlgebra@\texttt{IsFModularGroupAlgebra}}
\label{IsFModularGroupAlgebra}
}\hfill{\scriptsize (property)}}\\
\index{modular group algebra} A group algebra $KG$ over a field $K$ is called \emph{modular}, if the characteristic of the field $K$ divides the order of some element in $G$. For a group algebra \mbox{\texttt{KG}} of a finite group $G$, \texttt{IsModularGroupAlgebra} returns \texttt{true}, if \mbox{\texttt{KG}} is modular according to this definition; \texttt{false} is returned otherwise. This property will be set automatically for every group
algebra, created by the function \texttt{GroupRing}. }
\begin{Verbatim}[fontsize=\small,frame=single,label=Example]
gap> IsFModularGroupAlgebra( GroupRing( GF( 2 ), SymmetricGroup( 6 ) ) );
true
gap> IsFModularGroupAlgebra( GroupRing( GF( 2 ), CyclicGroup( 3 ) ) );
false
\end{Verbatim}
\subsection{\textcolor{Chapter }{IsPModularGroupAlgebra}}
\logpage{[ 4, 1, 3 ]}\nobreak
{\noindent\textcolor{FuncColor}{$\Diamond$\ \texttt{IsPModularGroupAlgebra( KG )\index{IsPModularGroupAlgebra@\texttt{IsPModularGroupAlgebra}}
\label{IsPModularGroupAlgebra}
}\hfill{\scriptsize (property)}}\\
A group algebra $KG$ is said to be $p$-modular, if $K$ is a field of characteristic $p$ and $G$ is a finite $p$-group for the same prime $p$. For a group algebra \mbox{\texttt{KG}} of a finite group $G$, \texttt{IsPModularGroupAlgebra} returns \texttt{true}, if \mbox{\texttt{KG}} is $p$-modular according to this definition; \texttt{false} is returned otherwise. This property will be set automatically for every group
algebra, created by the function \texttt{GroupRing}. }
\begin{Verbatim}[fontsize=\small,frame=single,label=Example]
gap> IsPModularGroupAlgebra( GroupRing( GF( 2 ), DihedralGroup( 16 ) ) );
true
gap> IsPModularGroupAlgebra( GroupRing( GF( 2 ), SymmetricGroup( 6 ) ) );
false
\end{Verbatim}
\subsection{\textcolor{Chapter }{UnderlyingGroup (of a group ring)}}
\logpage{[ 4, 1, 4 ]}\nobreak
{\noindent\textcolor{FuncColor}{$\Diamond$\ \texttt{UnderlyingGroup( KG )\index{UnderlyingGroup@\texttt{UnderlyingGroup}!of a group ring}
\label{UnderlyingGroup:of a group ring}
}\hfill{\scriptsize (attribute)}}\\
\textbf{\indent Returns:\ }
the underlying group of a group ring
This attribute stores the underlying group of a group ring \mbox{\texttt{KG}}. In fact, it refers to the attribute \texttt{UnderlyingMagma} which returns the same result, and was introduced for group rings for
convenience, and for teaching purposes. }
\begin{Verbatim}[fontsize=\small,frame=single,label=Example]
gap> KG := GroupRing( GF ( 2 ), DihedralGroup( 16 ) );
<algebra-with-one over GF(2), with 4 generators>
gap> G := UnderlyingGroup( KG );
<pc group of size 16 with 4 generators>
\end{Verbatim}
\subsection{\textcolor{Chapter }{UnderlyingRing}}
\logpage{[ 4, 1, 5 ]}\nobreak
{\noindent\textcolor{FuncColor}{$\Diamond$\ \texttt{UnderlyingRing( KG )\index{UnderlyingRing@\texttt{UnderlyingRing}}
\label{UnderlyingRing}
}\hfill{\scriptsize (attribute)}}\\
\textbf{\indent Returns:\ }
the underlying ring of a group ring
This attribute stores the underlying ring of a group ring \mbox{\texttt{KG}}. In fact, it refers to the attribute \texttt{LeftActingDomain} which returns the same result, and was introduced for group rings for
convenience, and for teaching purposes. }
\begin{Verbatim}[fontsize=\small,frame=single,label=Example]
gap> KG := GroupRing( GF( 2 ), DihedralGroup( 16 ) );
<algebra-with-one over GF(2), with 4 generators>
gap> UnderlyingRing( KG );
GF(2)
\end{Verbatim}
\subsection{\textcolor{Chapter }{UnderlyingField}}
\logpage{[ 4, 1, 6 ]}\nobreak
{\noindent\textcolor{FuncColor}{$\Diamond$\ \texttt{UnderlyingField( KG )\index{UnderlyingField@\texttt{UnderlyingField}}
\label{UnderlyingField}
}\hfill{\scriptsize (attribute)}}\\
\textbf{\indent Returns:\ }
the underlying field of a group algebra
This attribute stores the underlying field of a group algebra \mbox{\texttt{KG}}. In fact, it refers to the attribute \texttt{LeftActingDomain} which returns the same result, and was introduced for group algebras for
convenience, and for teaching purposes. }
\begin{Verbatim}[fontsize=\small,frame=single,label=Example]
gap> KG := GroupRing( GF( 2 ), DihedralGroup( 16 ) );
<algebra-with-one over GF(2), with 4 generators>
gap> UnderlyingField( KG );
GF(2)
\end{Verbatim}
}
\section{\textcolor{Chapter }{Operations with group algebra elements}}\label{ElemFunctions}
\logpage{[ 4, 2, 0 ]}
{
\subsection{\textcolor{Chapter }{Support}}
\logpage{[ 4, 2, 1 ]}\nobreak
{\noindent\textcolor{FuncColor}{$\Diamond$\ \texttt{Support( x )\index{Support@\texttt{Support}}
\label{Support}
}\hfill{\scriptsize (attribute)}}\\
\textbf{\indent Returns:\ }
support of x as a list of elements of the underlying group
Returns the support of a group ring element \mbox{\texttt{x}}. The support of a non-zero element $ x = \alpha_1 \cdot g_1 + \alpha_2 \cdot g_2 + \cdots + \alpha_k \cdot g_k$ of a group ring is the list of elements $g_i \in G$ for which the coefficient $\alpha_i$ is non-zero. The support of the zero element of a group ring is defined to be
the empty list. This method is also applicable to elements of magma rings. }
\begin{Verbatim}[fontsize=\small,frame=single,label=Example]
# First we create an element x to use in in the series of examples.
# We map the minimal generating system of the group G to its group algebra
# and denote their images as a and b
gap> G:=DihedralGroup(16);; KG:=GroupRing(GF(2),G);;
gap> l := List( MinimalGeneratingSet( G ), g -> g^Embedding( G, KG ) );
[ (Z(2)^0)*f1, (Z(2)^0)*f2 ]
gap> a := l[1]; b := l[2]; e := One( KG ); # we denote the identity by e
(Z(2)^0)*f1
(Z(2)^0)*f2
(Z(2)^0)*<identity> of ...
gap> x := ( e + a ) * ( e + b );
(Z(2)^0)*<identity> of ...+(Z(2)^0)*f1+(Z(2)^0)*f2+(Z(2)^0)*f1*f2
gap> Support( x );
[ <identity> of ..., f1, f2, f1*f2 ]
\end{Verbatim}
\subsection{\textcolor{Chapter }{CoefficientsBySupport}}
\logpage{[ 4, 2, 2 ]}\nobreak
{\noindent\textcolor{FuncColor}{$\Diamond$\ \texttt{CoefficientsBySupport( x )\index{CoefficientsBySupport@\texttt{CoefficientsBySupport}}
\label{CoefficientsBySupport}
}\hfill{\scriptsize (attribute)}}\\
\textbf{\indent Returns:\ }
coefficients of support elements as list of elements of the underlying ring
Returns a list that contains the coefficients corresponding to the elements of \texttt{Support( x )} in the same order as the elements appear in \texttt{Support( x )}. This method is also applicable to elements of magma rings. }
\begin{Verbatim}[fontsize=\small,frame=single,label=Example]
gap> x;
(Z(2)^0)*<identity> of ...+(Z(2)^0)*f1+(Z(2)^0)*f2+(Z(2)^0)*f1*f2
gap> CoefficientsBySupport( x );
[ Z(2)^0, Z(2)^0, Z(2)^0, Z(2)^0 ]
\end{Verbatim}
\subsection{\textcolor{Chapter }{TraceOfMagmaRingElement}}
\logpage{[ 4, 2, 3 ]}\nobreak
{\noindent\textcolor{FuncColor}{$\Diamond$\ \texttt{TraceOfMagmaRingElement( x )\index{TraceOfMagmaRingElement@\texttt{TraceOfMagmaRingElement}}
\label{TraceOfMagmaRingElement}
}\hfill{\scriptsize (attribute)}}\\
\textbf{\indent Returns:\ }
an element of the underlying ring
Returns the trace of a group ring element \mbox{\texttt{x}}. By definition, the trace of an element $ x = \alpha_1 \cdot 1 + \alpha_2 \cdot g_2 + \cdots + \alpha_k \cdot g_k $ is equal to $\alpha_1$, that is, the coefficient of the identity element in $G$. The trace of the zero element is zero. This method is also applicable to
elements of magma rings. }
\begin{Verbatim}[fontsize=\small,frame=single,label=Example]
gap> x;
(Z(2)^0)*<identity> of ...+(Z(2)^0)*f1+(Z(2)^0)*f2+(Z(2)^0)*f1*f2
gap> TraceOfMagmaRingElement( x );
Z(2)^0
\end{Verbatim}
\subsection{\textcolor{Chapter }{Length}}
\logpage{[ 4, 2, 4 ]}\nobreak
{\noindent\textcolor{FuncColor}{$\Diamond$\ \texttt{Length( x )\index{Length@\texttt{Length}}
\label{Length}
}\hfill{\scriptsize (attribute)}}\\
The length of an element of a group ring \mbox{\texttt{x}} is defined as the number of elements in its support. This method is also
applicable to elements of magma rings. }
\begin{Verbatim}[fontsize=\small,frame=single,label=Example]
gap> x;
(Z(2)^0)*<identity> of ...+(Z(2)^0)*f1+(Z(2)^0)*f2+(Z(2)^0)*f1*f2
gap> Length( x );
4
\end{Verbatim}
\subsection{\textcolor{Chapter }{Augmentation}}
\logpage{[ 4, 2, 5 ]}\nobreak
{\noindent\textcolor{FuncColor}{$\Diamond$\ \texttt{Augmentation( x )\index{Augmentation@\texttt{Augmentation}}
\label{Augmentation}
}\hfill{\scriptsize (attribute)}}\\
\textbf{\indent Returns:\ }
the sum of coefficients of a group ring element
The augmentation of a group ring element $ x = \alpha_1 \cdot g_1 + \alpha_2 \cdot g_2 + \cdots + \alpha_k \cdot g_k$ is the sum of its coefficients $ \alpha_1 + \alpha_2 + \cdots + \alpha_k $. The method is also applicable to elements of magma rings. }
\begin{Verbatim}[fontsize=\small,frame=single,label=Example]
gap> x;
(Z(2)^0)*<identity> of ...+(Z(2)^0)*f1+(Z(2)^0)*f2+(Z(2)^0)*f1*f2
gap> Augmentation( x );
0*Z(2)
\end{Verbatim}
\subsection{\textcolor{Chapter }{PartialAugmentations}}
\logpage{[ 4, 2, 6 ]}\nobreak
{\noindent\textcolor{FuncColor}{$\Diamond$\ \texttt{PartialAugmentations( KG, x )\index{PartialAugmentations@\texttt{PartialAugmentations}}
\label{PartialAugmentations}
}\hfill{\scriptsize (operation)}}\\
\textbf{\indent Returns:\ }
a list of partial augmentations and a list of conjugacy class representatives
\index{partial augmentation} The partial augmentation of an element $ x = \alpha_1 \cdot g_1 + \alpha_2 \cdot g_2 + \cdots + \alpha_k \cdot g_k$ of the group ring $KG$, corresponding to the conjugacy class of an element $g$ from the underlying group $G$ is the sum of coefficients $\alpha_i$ taken over all $g_i$ such that $g_i$ is conjugated to $g$. The function returns a list of two lists, the first one is a list of partial
augmentations, and the second is a list of representatives of appropriate
conjugacy classes of elements of the group $G$. }
\begin{Verbatim}[fontsize=\small,frame=single,label=Example]
gap> y := x + a*b^2;
(Z(2)^0)*<identity> of ...+(Z(2)^0)*f1+(Z(2)^0)*f2+(Z(2)^0)*f1*f2+(Z(2)^
0)*f1*f3
gap> PartialAugmentations( KG, y );
[ [ Z(2)^0, 0*Z(2), Z(2)^0, Z(2)^0 ], [ <identity> of ..., f1, f2, f1*f2 ] ]
\end{Verbatim}
\subsection{\textcolor{Chapter }{Involution}}
\logpage{[ 4, 2, 7 ]}\nobreak
{\noindent\textcolor{FuncColor}{$\Diamond$\ \texttt{Involution( x, f )\index{Involution@\texttt{Involution}}
\label{Involution}
}\hfill{\scriptsize (operation)}}\\
\noindent\textcolor{FuncColor}{$\Diamond$\ \texttt{Involution( x )\index{Involution@\texttt{Involution}}
\label{Involution}
}\hfill{\scriptsize (operation)}}\\
\textbf{\indent Returns:\ }
an element of a group ring
Let $KG$ be a group ring and let $f$ be a mapping $ G \rightarrow G $, such that $f^2$ is the identity mapping on $G$. Then the involution of $KG$ induced by $f$ is defined by $ \alpha_1 \cdot g_1 + \alpha_2 \cdot g_2 + \cdots + \alpha_k \cdot g_k \mapsto
\alpha_1 \cdot f(g_1) + \alpha_2 \cdot f(g_2) + \cdots + \alpha_k \cdot f(g_k)$. This method returns the image of \mbox{\texttt{x}} under the involution of $KG$ with respect to \mbox{\texttt{f}}.
In the second form the function returns the result of the so-called classical
involution, which is the involution induced by the map $ x \mapsto x^{-1}$. }
\begin{Verbatim}[fontsize=\small,frame=single,label=Example]
gap> x;
(Z(2)^0)*<identity> of ...+(Z(2)^0)*f1+(Z(2)^0)*f2+(Z(2)^0)*f1*f2
gap> Involution( x );
(Z(2)^0)*<identity> of ...+(Z(2)^0)*f1+(Z(2)^0)*f1*f2+(Z(2)^0)*f2*f3*f4
# let's check the action of involution on elements from the group G
gap> l := List( MinimalGeneratingSet( G ), g -> g^Embedding( G, KG ) );
[ (Z(2)^0)*f1, (Z(2)^0)*f2 ]
gap> List( l, Involution );
[ (Z(2)^0)*f1, (Z(2)^0)*f2*f3*f4 ]
gap> List( l, g -> g^-1 );
[ (Z(2)^0)*f1, (Z(2)^0)*f2*f3*f4 ]
\end{Verbatim}
\subsection{\textcolor{Chapter }{IsSymmetric}}
\logpage{[ 4, 2, 8 ]}\nobreak
{\noindent\textcolor{FuncColor}{$\Diamond$\ \texttt{IsSymmetric( x )\index{IsSymmetric@\texttt{IsSymmetric}}
\label{IsSymmetric}
}\hfill{\scriptsize (attribute)}}\\
\index{symmetric element} An element of a group ring is called \emph{symmetric} if it is fixed under the classical involution. This property is checked here. }
\begin{Verbatim}[fontsize=\small,frame=single,label=Example]
gap> IsSymmetric( x );
false
gap> IsSymmetric( x * Involution( x ) );
true
\end{Verbatim}
\subsection{\textcolor{Chapter }{IsUnitary}}
\logpage{[ 4, 2, 9 ]}\nobreak
{\noindent\textcolor{FuncColor}{$\Diamond$\ \texttt{IsUnitary( x )\index{IsUnitary@\texttt{IsUnitary}}
\label{IsUnitary}
}\hfill{\scriptsize (attribute)}}\\
\index{unitary element} A unit of a group ring is called unitary if the classical involution inverts
it. This property is checked here. }
\begin{Verbatim}[fontsize=\small,frame=single,label=Example]
gap> IsUnitary(x);
false
# let's check that elements of the group G are unitary
gap> l:=List(MinimalGeneratingSet(G),g -> g^Embedding(G,KG));
[ (Z(2)^0)*f1, (Z(2)^0)*f2 ]
gap> List(l,IsUnitary);
[ true, true ]
\end{Verbatim}
\subsection{\textcolor{Chapter }{IsUnit}}
\logpage{[ 4, 2, 10 ]}\nobreak
{\noindent\textcolor{FuncColor}{$\Diamond$\ \texttt{IsUnit( KG, x )\index{IsUnit@\texttt{IsUnit}}
\label{IsUnit}
}\hfill{\scriptsize (method)}}\\
\noindent\textcolor{FuncColor}{$\Diamond$\ \texttt{IsUnit( x )\index{IsUnit@\texttt{IsUnit}}
\label{IsUnit}
}\hfill{\scriptsize (method)}}\\
This method improves a standard \textsf{GAP} functionality for modular group algebras.
In the first form the method returns \texttt{true} if \mbox{\texttt{x}} is an invertible element of the modular group algebra \mbox{\texttt{KG}} and \texttt{false} otherwise. This can be done very quickly by checking whether the augmentation
of the element \mbox{\texttt{x}} is non-zero.
In the second form \textsf{LAGUNA} first constructs the group $H$ generated by the support of \mbox{\texttt{x}}, and, if this group is a finite $p$-group, then checks whether the coefficients of \mbox{\texttt{x}} belong to a field $F$ of characteristic $p$. If this is the case, then \texttt{IsUnit( FH, x )} is called; otherwise, standard \textsf{GAP} method is used. }
\begin{Verbatim}[fontsize=\small,frame=single,label=Example]
gap> x;
(Z(2)^0)*<identity> of ...+(Z(2)^0)*f1+(Z(2)^0)*f2+(Z(2)^0)*f1*f2
gap> IsUnit( KG, x ); # clearly, is not a unit due to augmentation zero
false
gap> y := One( KG ) + x; # this should give a unit
(Z(2)^0)*f1+(Z(2)^0)*f2+(Z(2)^0)*f1*f2
gap> IsUnit( KG, y );
true
\end{Verbatim}
\subsection{\textcolor{Chapter }{InverseOp}}
\logpage{[ 4, 2, 11 ]}\nobreak
{\noindent\textcolor{FuncColor}{$\Diamond$\ \texttt{InverseOp( x )\index{InverseOp@\texttt{InverseOp}}
\label{InverseOp}
}\hfill{\scriptsize (method)}}\\
\textbf{\indent Returns:\ }
the inverse element of an element of a group ring
This method improves a standard \textsf{GAP} functionality for modular group algebras. It calculates the inverse of a group
algebra element. The user can also invoke this function by typing \texttt{ x{\textasciicircum}-1 }. }
\begin{Verbatim}[fontsize=\small,frame=single,label=Example]
gap> y;
(Z(2)^0)*f1+(Z(2)^0)*f2+(Z(2)^0)*f1*f2
gap> y^-1;
(Z(2)^0)*f1+(Z(2)^0)*f2+(Z(2)^0)*f3+(Z(2)^0)*f4+(Z(2)^0)*f1*f2+(Z(2)^
0)*f1*f3+(Z(2)^0)*f1*f4+(Z(2)^0)*f2*f4+(Z(2)^0)*f1*f2*f4+(Z(2)^0)*f2*f3*f4+(
Z(2)^0)*f1*f2*f3*f4
gap> y * y^-1;
(Z(2)^0)*<identity> of ...
\end{Verbatim}
\subsection{\textcolor{Chapter }{BicyclicUnitOfType1}}
\logpage{[ 4, 2, 12 ]}\nobreak
{\noindent\textcolor{FuncColor}{$\Diamond$\ \texttt{BicyclicUnitOfType1( KG, a, g )\index{BicyclicUnitOfType1@\texttt{BicyclicUnitOfType1}}
\label{BicyclicUnitOfType1}
}\hfill{\scriptsize (operation)}}\\
\noindent\textcolor{FuncColor}{$\Diamond$\ \texttt{BicyclicUnitOfType1( a, g )\index{BicyclicUnitOfType1@\texttt{BicyclicUnitOfType1}}
\label{BicyclicUnitOfType1}
}\hfill{\scriptsize (operation)}}\\
\noindent\textcolor{FuncColor}{$\Diamond$\ \texttt{BicyclicUnitOfType2( KG, a, g )\index{BicyclicUnitOfType2@\texttt{BicyclicUnitOfType2}}
\label{BicyclicUnitOfType2}
}\hfill{\scriptsize (operation)}}\\
\noindent\textcolor{FuncColor}{$\Diamond$\ \texttt{BicyclicUnitOfType2( a, g )\index{BicyclicUnitOfType2@\texttt{BicyclicUnitOfType2}}
\label{BicyclicUnitOfType2}
}\hfill{\scriptsize (operation)}}\\
\textbf{\indent Returns:\ }
an element of a group ring
\index{bicyclic unit} let $a$ be an element of order $n$ of a group $G$. We put $\alpha = 1 + a + a^2 + ... +a^{n-1} $. Then $(a-1)*g*\alpha$ and $\alpha*g*(a-1)$ are nilpotent of index two for any element $g$ of the group $G$ not containing in the normalizer $N_G(\langle a \rangle)$, and the units $u_{a,g} = 1 + (a-1) * g * \alpha $ and $v_{a,g} = 1 + \alpha * g * (a-1) $ are called bicyclic units. Note that $u_{a,g}$ and $v_{a,g}$ may coincide for some $a$ and $g$, but in general this does not hold. In the three-argument version these
methods construct bicyclic units of both types when \mbox{\texttt{a}} and \mbox{\texttt{g}} are elements of the underlying group $G$ of a group ring \mbox{\texttt{KG}}. The two-argument version accepts images of elements \mbox{\texttt{a}} and \mbox{\texttt{g}} from the underlying group in the group ring $KG$ obtained using the mapping \texttt{Embedding( G, KG )}. Note that it is not actually checked that $g$ is not contained in $N_G(\langle a \rangle)$, because this is verified in \texttt{BicyclicUnitGroup} (\ref{BicyclicUnitGroup}). }
\begin{Verbatim}[fontsize=\small,frame=single,label=Example]
gap> G := SmallGroup(32,6);
<pc group of size 32 with 5 generators>
gap> KG := GroupRing( GF(2), G );
<algebra-with-one over GF(2), with 5 generators>
gap> g := MinimalGeneratingSet( G );
[ f1, f2 ]
gap> g[1] in Normalizer( G, Subgroup( G, [g[2]] ) );
false
gap> g[2] in Normalizer( G, Subgroup( G, [g[1]] ) );
false
gap> g := List( g, x -> x^Embedding( G, KG ) );
[ (Z(2)^0)*f1, (Z(2)^0)*f2 ]
gap> BicyclicUnitOfType1(g[1],g[2]) = BicyclicUnitOfType2(g[1],g[2]);
false
\end{Verbatim}
}
\section{\textcolor{Chapter }{Important attributes of group algebras}}\label{Ideals}
\logpage{[ 4, 3, 0 ]}
{
\subsection{\textcolor{Chapter }{AugmentationHomomorphism}}
\logpage{[ 4, 3, 1 ]}\nobreak
{\noindent\textcolor{FuncColor}{$\Diamond$\ \texttt{AugmentationHomomorphism( KG )\index{AugmentationHomomorphism@\texttt{AugmentationHomomorphism}}
\label{AugmentationHomomorphism}
}\hfill{\scriptsize (attribute)}}\\
\textbf{\indent Returns:\ }
a homomorphism from a group ring to the underlying ring
The mapping which maps an element of a group ring $KG$ to its augmentation is a homomorphism from $KG$ onto the ring $K$; see \texttt{Augmentation} (\ref{Augmentation}). This attribute stores this homomorphism for the group ring \mbox{\texttt{KG}}.
Please note that for calculation of the augmentation of an element of a group
ring the user is strongly recommended to use \texttt{Augmentation} (\ref{Augmentation}) which works much faster than \texttt{AugmentationHomomorphism}. }
\begin{Verbatim}[fontsize=\small,frame=single,label=Example]
gap> F := GF( 2 ); G := SymmetricGroup( 3 ); FG := GroupRing( F, G );
GF(2)
Sym( [ 1 .. 3 ] )
<algebra-with-one over GF(2), with 2 generators>
gap> e := Embedding( G,FG );
<mapping: SymmetricGroup( [ 1 .. 3 ] ) -> AlgebraWithOne( GF(2), ... ) >
gap> x := (1,2)^e; y := (1,3)^e;
(Z(2)^0)*(1,2)
(Z(2)^0)*(1,3)
gap> a := AugmentationHomomorphism( FG );
[ (Z(2)^0)*(1,2,3), (Z(2)^0)*(1,2) ] -> [ Z(2)^0, Z(2)^0 ]
gap> x^a; y^a; ( x + y )^a; # this is slower
Z(2)^0
Z(2)^0
0*Z(2)
gap> Augmentation(x); Augmentation(y); Augmentation( x + y ); # this is faster
Z(2)^0
Z(2)^0
0*Z(2)
\end{Verbatim}
\subsection{\textcolor{Chapter }{AugmentationIdeal}}
\logpage{[ 4, 3, 2 ]}\nobreak
{\noindent\textcolor{FuncColor}{$\Diamond$\ \texttt{AugmentationIdeal( KG )\index{AugmentationIdeal@\texttt{AugmentationIdeal}}
\label{AugmentationIdeal}
}\hfill{\scriptsize (attribute)}}\\
\textbf{\indent Returns:\ }
an ideal of a group ring
If $KG$ is a group ring, then its augmentation ideal $A$ is generated by all elements of the form $g-1$, where $g \in G$ {\textbackslash} \{ $1$ \}. The augmentation ideal consists of all elements of $FG$ with augmentation $0$; see \texttt{Augmentation} (\ref{Augmentation}). This method changes a standard \textsf{GAP} functionality for modular group algebras and returns the augmentation ideal of
a modular group algebra \mbox{\texttt{KG}}. }
\begin{Verbatim}[fontsize=\small,frame=single,label=Example]
gap> KG := GroupRing( GF( 2 ), DihedralGroup( 16 ) );
<algebra-with-one over GF(2), with 4 generators>
gap> AugmentationIdeal( KG );
<two-sided ideal in <algebra-with-one over GF(2), with 4 generators>,
(dimension 15)>
\end{Verbatim}
\subsection{\textcolor{Chapter }{RadicalOfAlgebra}}
\logpage{[ 4, 3, 3 ]}\nobreak
{\noindent\textcolor{FuncColor}{$\Diamond$\ \texttt{RadicalOfAlgebra( KG )\index{RadicalOfAlgebra@\texttt{RadicalOfAlgebra}}
\label{RadicalOfAlgebra}
}\hfill{\scriptsize (attribute)}}\\
\textbf{\indent Returns:\ }
an ideal of a group algebra
This method improves a standard \textsf{GAP} functionality for modular group algebras of finite $p$-groups. Since in this case the radical of the group algebra coincides with
its augmentation ideal, this method simply checks if the algebra \mbox{\texttt{KG}} is a $p$-modular group algebra, and, if yes, it returns the augmentation ideal;
otherwise, the standard \textsf{GAP} method will be used. }
\begin{Verbatim}[fontsize=\small,frame=single,label=Example]
gap> KG := GroupRing( GF( 2 ), DihedralGroup( 16 ) );
<algebra-with-one over GF(2), with 4 generators>
gap> RadicalOfAlgebra( KG );
<two-sided ideal in <algebra-with-one over GF(2), with 4 generators>,
(dimension 15)>
gap> RadicalOfAlgebra( KG ) = AugmentationIdeal( KG );
true
\end{Verbatim}
\subsection{\textcolor{Chapter }{WeightedBasis}}
\logpage{[ 4, 3, 4 ]}\nobreak
{\noindent\textcolor{FuncColor}{$\Diamond$\ \texttt{WeightedBasis( KG )\index{WeightedBasis@\texttt{WeightedBasis}}
\label{WeightedBasis}
}\hfill{\scriptsize (attribute)}}\\
\textbf{\indent Returns:\ }
a record of two components: weighted basis elements and their weights
The argument \mbox{\texttt{KG}} must be a $p$-modular group algebra.
For a group algebra $KG$, let $A$ denote the augmentation ideal, and assume that $c$ is the smallest number such that $A^c=0$. Then a weighted basis of $KG$ is some basis $ b_1, \ldots, b_n $ for the augmentation ideal $A$, for which there are indices $ i_1=1, \ldots, i_{c-1} $ such that $ b_{i_k}, \ldots, b_n $ is a basis for $A^k$. The weight of an element $b_i$ of a weighted basis is the unique integer $w$ such that $b_i$ belongs to $w$-th power of $A$ but does not belong to its $(w+1)$-th power.
Note that this function actually constructs a basis for the \emph{augmentation ideal} of \mbox{\texttt{KG}} and not for \mbox{\texttt{KG}} itself. Since the augmentation ideal has co-dimension 1 in \texttt{KG}, a basis for \texttt{KG} can be easily obtained by adjoining the identity element of the group.
The method returns a record whose basis entry is the basis and the weights
entry is a list of the corresponding weights the of basis elements. See
Section \ref{TheoryThird} for more details. }
\begin{Verbatim}[fontsize=\small,frame=single,label=Example]
gap> KG := GroupRing( GF( 2 ), ElementaryAbelianGroup( 4 ) );
<algebra-with-one over GF(2), with 2 generators>
gap> WeightedBasis( KG );
rec(
weightedBasis := [ (Z(2)^0)*<identity> of ...+(Z(2)^0)*f2, (Z(2)^0)*<identity>
of ...+(Z(2)^0)*f1, (Z(2)^0)*<identity> of ...+(Z(2)^0)*f1+(Z(2)^0)*f2+(
Z(2)^0)*f1*f2 ], weights := [ 1, 1, 2 ] )
\end{Verbatim}
\subsection{\textcolor{Chapter }{AugmentationIdealPowerSeries}}
\logpage{[ 4, 3, 5 ]}\nobreak
{\noindent\textcolor{FuncColor}{$\Diamond$\ \texttt{AugmentationIdealPowerSeries( KG )\index{AugmentationIdealPowerSeries@\texttt{AugmentationIdealPowerSeries}}
\label{AugmentationIdealPowerSeries}
}\hfill{\scriptsize (attribute)}}\\
\textbf{\indent Returns:\ }
a list of ideals of a group algebra
The argument \mbox{\texttt{KG}} is a $p$-modular group algebra. The method returns a list whose elements are the terms
of the augmentation ideal filtration of \mbox{\texttt{KG}}, that is \texttt{AugmentationIdealPowerSeries(A)[i]} is the $i$-th power of the augmentation ideal of \mbox{\texttt{KG}}. }
\begin{Verbatim}[fontsize=\small,frame=single,label=Example]
gap> KG := GroupRing( GF( 2 ), DihedralGroup( 16 ) );
<algebra-with-one over GF(2), with 4 generators>
gap> AugmentationIdealPowerSeries( KG );
[ <algebra of dimension 15 over GF(2)>, <algebra of dimension 13 over GF(2)>,
<algebra of dimension 11 over GF(2)>, <algebra of dimension 9 over GF(2)>,
<algebra of dimension 7 over GF(2)>, <algebra of dimension 5 over GF(2)>,
<algebra of dimension 3 over GF(2)>, <algebra of dimension 1 over GF(2)>,
<algebra over GF(2)> ]
gap> Length(last);
9
\end{Verbatim}
\subsection{\textcolor{Chapter }{AugmentationIdealNilpotencyIndex}}
\logpage{[ 4, 3, 6 ]}\nobreak
{\noindent\textcolor{FuncColor}{$\Diamond$\ \texttt{AugmentationIdealNilpotencyIndex( KG )\index{AugmentationIdealNilpotencyIndex@\texttt{AugmentationIdealNilpotencyIndex}}
\label{AugmentationIdealNilpotencyIndex}
}\hfill{\scriptsize (attribute)}}\\
For the $p$-modular group algebra \mbox{\texttt{KG}} the method returns the smallest number $n$ such that $A^n=0$, where $A$ is the augmentation ideal of \mbox{\texttt{KG}}. This can be done using Jenning's theory without the explicit calculations of
the powers of the augmentation ideal. }
\begin{Verbatim}[fontsize=\small,frame=single,label=Example]
gap> KG := GroupRing( GF( 2 ), DihedralGroup( 16 ) );
<algebra-with-one over GF(2), with 4 generators>
gap> AugmentationIdealNilpotencyIndex( KG );
9
\end{Verbatim}
\subsection{\textcolor{Chapter }{AugmentationIdealOfDerivedSubgroupNilpotencyIndex}}
\logpage{[ 4, 3, 7 ]}\nobreak
{\noindent\textcolor{FuncColor}{$\Diamond$\ \texttt{AugmentationIdealOfDerivedSubgroupNilpotencyIndex( KG )\index{AugmentationIdealOfDerivedSubgroupNilpotencyIndex@\texttt{AugmentationIdealOfDerivedSubgroupNilpotencyIndex}}
\label{AugmentationIdealOfDerivedSubgroupNilpotencyIndex}
}\hfill{\scriptsize (attribute)}}\\
For the $p$-modular group algebra \mbox{\texttt{KG}} this attribute stores the nilpotency index of the augmentation ideal of $KG'$ where $G'$ denotes the derived subgroup of $G$. }
\begin{Verbatim}[fontsize=\small,frame=single,label=Example]
gap> KG := GroupRing( GF( 2 ), DihedralGroup( 16 ) );
<algebra-with-one over GF(2), with 4 generators>
gap> AugmentationIdealOfDerivedSubgroupNilpotencyIndex( KG );
4
gap> D := DerivedSubgroup( UnderlyingGroup( KG ) );
Group([ f3, f4 ])
gap> KD := GroupRing( GF( 2 ), D );
<algebra-with-one over GF(2), with 2 generators>
gap> AugmentationIdealNilpotencyIndex( KD );
4
\end{Verbatim}
\subsection{\textcolor{Chapter }{LeftIdealBySubgroup}}
\logpage{[ 4, 3, 8 ]}\nobreak
{\noindent\textcolor{FuncColor}{$\Diamond$\ \texttt{LeftIdealBySubgroup( KG, H )\index{LeftIdealBySubgroup@\texttt{LeftIdealBySubgroup}}
\label{LeftIdealBySubgroup}
}\hfill{\scriptsize (operation)}}\\
\noindent\textcolor{FuncColor}{$\Diamond$\ \texttt{RightIdealBySubgroup( KG, H )\index{RightIdealBySubgroup@\texttt{RightIdealBySubgroup}}
\label{RightIdealBySubgroup}
}\hfill{\scriptsize (operation)}}\\
\noindent\textcolor{FuncColor}{$\Diamond$\ \texttt{TwoSidedIdalBySubgroup( KG, H )\index{TwoSidedIdalBySubgroup@\texttt{TwoSidedIdalBySubgroup}}
\label{TwoSidedIdalBySubgroup}
}\hfill{\scriptsize (operation)}}\\
\noindent\textcolor{FuncColor}{$\Diamond$\ \texttt{LeftIdealBySubgroup( KG, H )\index{LeftIdealBySubgroup@\texttt{LeftIdealBySubgroup}}
\label{LeftIdealBySubgroup}
}\hfill{\scriptsize (operation)}}\\
\textbf{\indent Returns:\ }
an ideal of a group ring
Let \mbox{\texttt{KG}} be a group ring of a group $G$ over the ring $K$, and \mbox{\texttt{H}} be a subgroup of $G$. Then the set $J_l(H)$ of all elements of \mbox{\texttt{KG}} of the form
\[ \sum_{h \in H} x_h(h-1) \]
is the left ideal in \mbox{\texttt{KG}} generated by all elements $h-1$ with $h$ in $H$. The right ideal $J_r(H)$ is defined analogously. These operations are used to consrtuct such ideals,
taking into account the fact, that the ideal $J_l(H)$ is two-sided if and only if \mbox{\texttt{H}} is normal in $G$. An attempt of constructing two-sided ideal for a non-normal subgroup \mbox{\texttt{H}} will lead to an error message. }
\begin{Verbatim}[fontsize=\small,frame=single,label=Example]
gap> KG := GroupRing( GF(2), DihedralGroup(16) );
<algebra-with-one over GF(2), with 4 generators>
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> D := DerivedSubgroup( G );
Group([ f3, f4 ])
gap> LeftIdealBySubgroup( KG, D );
<two-sided ideal in <algebra-with-one over GF(2), with 4 generators>,
(dimension 12)>
gap> H := Subgroup( G, [ GeneratorsOfGroup(G)[1] ]);
Group([ f1 ])
gap> IsNormal( G, H );
false
gap> LeftIdealBySubgroup( KG, H );
<left ideal in <algebra-with-one over GF(2), with 4 generators>,
(dimension 8)>
\end{Verbatim}
}
\section{\textcolor{Chapter }{Computations with the unit group}}\label{UnitGroup}
\logpage{[ 4, 4, 0 ]}
{
\subsection{\textcolor{Chapter }{NormalizedUnitGroup}}
\logpage{[ 4, 4, 1 ]}\nobreak
{\noindent\textcolor{FuncColor}{$\Diamond$\ \texttt{NormalizedUnitGroup( KG )\index{NormalizedUnitGroup@\texttt{NormalizedUnitGroup}}
\label{NormalizedUnitGroup}
}\hfill{\scriptsize (attribute)}}\\
\textbf{\indent Returns:\ }
a group generated by group algebra elements
Determines the normalized unit group of a $p$-modular group algebra \mbox{\texttt{KG}} over the field of $p$ elements. Returns the normalized unit group as the group generated by certain
elements of \mbox{\texttt{KG}}; see Section \ref{TheoryThird} for more details.
For efficient computations the user is recommended to use \texttt{PcNormalizedUnitGroup} (\ref{PcNormalizedUnitGroup}). }
\begin{Verbatim}[fontsize=\small,frame=single,label=Example]
gap> KG := GroupRing( GF( 2 ), DihedralGroup( 16 ) );
<algebra-with-one over GF(2), with 4 generators>
gap> V := NormalizedUnitGroup( KG );
<group of size 32768 with 15 generators>
gap> u := GeneratorsOfGroup( V )[4];
(Z(2)^0)*f1+(Z(2)^0)*f2+(Z(2)^0)*f1*f2
\end{Verbatim}
\subsection{\textcolor{Chapter }{PcNormalizedUnitGroup}}
\logpage{[ 4, 4, 2 ]}\nobreak
{\noindent\textcolor{FuncColor}{$\Diamond$\ \texttt{PcNormalizedUnitGroup( KG )\index{PcNormalizedUnitGroup@\texttt{PcNormalizedUnitGroup}}
\label{PcNormalizedUnitGroup}
}\hfill{\scriptsize (attribute)}}\\
\textbf{\indent Returns:\ }
a group given by power-commutator presentation
The argument \mbox{\texttt{KG}} is a $p$-modular group algebra over the field of $p$ elements. \texttt{PcNormalizedUnitGroup} returns the normalized unit group of \mbox{\texttt{KG}} given by a power-commutator presentation. The generators in this polycyclic
presentation correspond to the weighted basis elements of \mbox{\texttt{KG}}. For more details, see Section \ref{TheoryThird}. }
\begin{Verbatim}[fontsize=\small,frame=single,label=Example]
gap> W := PcNormalizedUnitGroup( KG );
<pc group of size 32768 with 15 generators>
gap> w := GeneratorsOfGroup( W )[4];
f4
\end{Verbatim}
\subsection{\textcolor{Chapter }{NaturalBijectionToPcNormalizedUnitGroup}}
\logpage{[ 4, 4, 3 ]}\nobreak
{\noindent\textcolor{FuncColor}{$\Diamond$\ \texttt{NaturalBijectionToPcNormalizedUnitGroup( KG )\index{NaturalBijectionToPcNormalizedUnitGroup@\texttt{NaturalBijectionToPcNormalizedUnitGroup}}
\label{NaturalBijectionToPcNormalizedUnitGroup}
}\hfill{\scriptsize (attribute)}}\\
\textbf{\indent Returns:\ }
a homomorphism of groups
The normalised unit group of a $p$-modular group algebra $KG$ over the field of $p$ elements can be computed using two methods, namely \texttt{NormalizedUnitGroup} (\ref{NormalizedUnitGroup}) and \texttt{PcNormalizedUnitGroup} (\ref{PcNormalizedUnitGroup}). These two methods return two different objects, and they can be used for
different types of computations. The elements of \texttt{NormalizedUnitGroup(KG)} are represented in their natural group algebra representation, and hence they
can easily be identified in the group algebra. However, the more quickly
constructed \texttt{NormalizedUnitGroup(KG)} is often not suitable for further fast calculations. Hence one will have to
use \texttt{PcNormalizedUnitGroup(KG)} if one wants to find some group theoretic properties of the normalized unit
group. This method returns the bijection from \texttt{NormalizedUnitGroup(\mbox{\texttt{KG}})} onto \texttt{PcNormalizedUnitGroup(\mbox{\texttt{KG}})}. This bijection can be used to map the result of a computation in \texttt{PcNormalizedUnitGroup(\mbox{\texttt{KG}})} into \texttt{NormalizedUnitGroup(\mbox{\texttt{KG}})}. }
\begin{Verbatim}[fontsize=\small,frame=single,label=Example]
gap> f := NaturalBijectionToPcNormalizedUnitGroup( KG );
MappingByFunction( <group of size 32768 with
15 generators>, <pc group of size 32768 with
15 generators>, function( x ) ... end )
gap> u := GeneratorsOfGroup( V )[4];;
gap> u^f;
f4
gap> GeneratorsOfGroup( V )[4]^f = GeneratorsOfGroup( W )[4];
true
\end{Verbatim}
\subsection{\textcolor{Chapter }{NaturalBijectionToNormalizedUnitGroup}}
\logpage{[ 4, 4, 4 ]}\nobreak
{\noindent\textcolor{FuncColor}{$\Diamond$\ \texttt{NaturalBijectionToNormalizedUnitGroup( KG )\index{NaturalBijectionToNormalizedUnitGroup@\texttt{NaturalBijectionToNormalizedUnitGroup}}
\label{NaturalBijectionToNormalizedUnitGroup}
}\hfill{\scriptsize (attribute)}}\\
\textbf{\indent Returns:\ }
a homomorphism of groups
For a $p$-modular group algebra \mbox{\texttt{KG}} over the field of $p$ elements this function returns the inverse of the mapping \texttt{NaturalBijectionToPcNormalizedUnitGroup} (\ref{NaturalBijectionToPcNormalizedUnitGroup}) }
\begin{Verbatim}[fontsize=\small,frame=single,label=Example]
gap> t := NaturalBijectionToNormalizedUnitGroup(KG);;
gap> w := GeneratorsOfGroup(W)[4];;
gap> w^t;
(Z(2)^0)*f1+(Z(2)^0)*f2+(Z(2)^0)*f1*f2
gap> GeneratorsOfGroup( W )[4]^t = GeneratorsOfGroup( V )[4];
true
\end{Verbatim}
\subsection{\textcolor{Chapter }{Embedding}}
\logpage{[ 4, 4, 5 ]}\nobreak
{\noindent\textcolor{FuncColor}{$\Diamond$\ \texttt{Embedding( H, V )\index{Embedding@\texttt{Embedding}}
\label{Embedding}
}\hfill{\scriptsize (operation)}}\\
\textbf{\indent Returns:\ }
a homomorphism from an underlying group to a normalized unit group in
pc-presentation
Let \mbox{\texttt{H}} be a subgroup of a group $G$ and \mbox{\texttt{V}} be the normalized unit group of the group algebra $KG$ given by the power-commutator presentation (see \texttt{PcNormalizedUnitGroup} (\ref{PcNormalizedUnitGroup}). Then \texttt{Embedding( H, V )} returns the homomorphism from \mbox{\texttt{H}} to \mbox{\texttt{V}}, which is the composition of \texttt{Embedding( H, KG )} and \texttt{NaturalBijectionToPcNormalizedUnitGroup( KG )}. }
\begin{Verbatim}[fontsize=\small,frame=single,label=Example]
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> V:=PcNormalizedUnitGroup( KG );
<pc group of size 32768 with 15 generators>
gap> ucs := UpperCentralSeries( V );
[ <pc group of size 32768 with 15 generators>,
<pc group of size 4096 with 12 generators>,
Group([ f3*f5*f13*f15, f7, f15, f13*f15, f14*f15, f11*f13*f14*f15, f12,
f9*f12, f10 ]),
Group([ f3*f5*f13*f15, f7, f15, f13*f15, f14*f15, f11*f13*f14*f15 ]),
Group([ ]) ]
gap> f := Embedding( G, V );
[ f1, f2, f3, f4 ] -> [ f2, f1, f3, f7 ]
gap> G1 := Image( f, G );
Group([ f2, f1, f3, f7 ])
gap> H := Intersection( ucs[2], G1 );
Group([ f3, f7, f3*f7 ])
# H is the intersection of G and the 3rd centre of V(KG)
gap> T:=PreImage( f, H );
Group([ f3, f4, f3*f4 ])
# and T is its preimage in G
gap> IdGroup( T );
[ 4, 1 ]
\end{Verbatim}
\subsection{\textcolor{Chapter }{Units}}
\logpage{[ 4, 4, 6 ]}\nobreak
{\noindent\textcolor{FuncColor}{$\Diamond$\ \texttt{Units( KG )\index{Units@\texttt{Units}}
\label{Units}
}\hfill{\scriptsize (attribute)}}\\
\textbf{\indent Returns:\ }
the unit group of a group ring
This improves a standard \textsf{GAP} functionality for modular group algebras of finite $p$-groups over the field of $p$ elements. It returns the unit group of \mbox{\texttt{KG}} as a direct product of \texttt{Units(K)} and \texttt{NormalizedUnitGroup(KG)}, where the latter is generated by certain elements of \mbox{\texttt{KG}}; see Chapter \ref{Theory} for more details. }
\begin{Verbatim}[fontsize=\small,frame=single,label=Example]
gap> U := Units( KG );
#I LAGUNA package: Computing the unit group ...
<group of size 32768 with 15 generators>
# now elements of U are already in KG
gap> GeneratorsOfGroup( U )[5];
(Z(2)^0)*f2+(Z(2)^0)*f3+(Z(2)^0)*f2*f3
# in the next example the direct product structure is more clear
gap> FH := GroupRing( GF(3), SmallGroup(27,3) );
<algebra-with-one over GF(3), with 3 generators>
gap> T := Units( FH );
#I LAGUNA package: Computing the unit group ...
<group of size 5083731656658 with 27 generators>
gap> x := GeneratorsOfGroup( T )[1];
Tuple( [ Z(3), (Z(3)^0)*<identity> of ... ] )
gap> x in FH;
false
gap> x[1] * x[2] in FH;
true # this is the way to get the corresponding element of FH
\end{Verbatim}
\subsection{\textcolor{Chapter }{PcUnits}}
\logpage{[ 4, 4, 7 ]}\nobreak
{\noindent\textcolor{FuncColor}{$\Diamond$\ \texttt{PcUnits( KG )\index{PcUnits@\texttt{PcUnits}}
\label{PcUnits}
}\hfill{\scriptsize (attribute)}}\\
\textbf{\indent Returns:\ }
a group given by power-commutator presentation
Returns the unit group of \mbox{\texttt{KG}} as a direct product of \texttt{Units(K)} and \texttt{PcNormalizedUnitGroup(KG)}, where the latter is a group given by a polycyclic presentation. See Section \ref{TheoryFourth} for more details. }
\begin{Verbatim}[fontsize=\small,frame=single,label=Example]
gap> W := PcUnits( KG );
<pc group of size 32768 with 15 generators>
gap> GeneratorsOfGroup( W )[5];
f5
# in the next example the direct product structure is more clear
gap> FH := GroupRing( GF(3), SmallGroup(27,3) );
<algebra-with-one over GF(3), with 3 generators>
gap> T := PcUnits(FH);
<group of size 5083731656658 with 27 generators>
gap> x := GeneratorsOfGroup( T )[2];
Tuple( [ Z(3)^0, f1 ] )
\end{Verbatim}
\subsection{\textcolor{Chapter }{IsGroupOfUnitsOfMagmaRing}}
\logpage{[ 4, 4, 8 ]}\nobreak
{\noindent\textcolor{FuncColor}{$\Diamond$\ \texttt{IsGroupOfUnitsOfMagmaRing( U )\index{IsGroupOfUnitsOfMagmaRing@\texttt{IsGroupOfUnitsOfMagmaRing}}
\label{IsGroupOfUnitsOfMagmaRing}
}\hfill{\scriptsize (property)}}\\
This property will be automatically set \texttt{true}, if \mbox{\texttt{U}} is a group generated by some units of a magma ring, including \texttt{Units(KG)} and \texttt{NormalizedUnitgroup(KG)}. Otherwise this property will not be bound. }
\begin{Verbatim}[fontsize=\small,frame=single,label=Example]
gap> IsGroupOfUnitsOfMagmaRing( NormalizedUnitGroup( KG ) );
true
gap> IsGroupOfUnitsOfMagmaRing( Units( KG ) );
true
\end{Verbatim}
\subsection{\textcolor{Chapter }{IsUnitGroupOfGroupRing}}
\logpage{[ 4, 4, 9 ]}\nobreak
{\noindent\textcolor{FuncColor}{$\Diamond$\ \texttt{IsUnitGroupOfGroupRing( U )\index{IsUnitGroupOfGroupRing@\texttt{IsUnitGroupOfGroupRing}}
\label{IsUnitGroupOfGroupRing}
}\hfill{\scriptsize (property)}}\\
This property will be automatically set \texttt{true}, if \mbox{\texttt{U}} is the unit group of a $p$-modular group algebra, obtained either by \texttt{Units(KG)} or by \texttt{PcUnits(KG)}. Otherwise this property will not be bound. }
\begin{Verbatim}[fontsize=\small,frame=single,label=Example]
gap> IsUnitGroupOfGroupRing( Units( KG ) );
true
gap> IsUnitGroupOfGroupRing( PcUnits( KG ) );
true
\end{Verbatim}
\subsection{\textcolor{Chapter }{IsNormalizedUnitGroupOfGroupRing}}
\logpage{[ 4, 4, 10 ]}\nobreak
{\noindent\textcolor{FuncColor}{$\Diamond$\ \texttt{IsNormalizedUnitGroupOfGroupRing( U )\index{IsNormalizedUnitGroupOfGroupRing@\texttt{IsNormalizedUnitGroupOfGroupRing}}
\label{IsNormalizedUnitGroupOfGroupRing}
}\hfill{\scriptsize (property)}}\\
This property will be automatically set \texttt{true}, if \mbox{\texttt{U}} is the normalized unit group of a $p$-modular group algebra, obtained either by \texttt{NormalizedUnitGroup(KG)} or by \texttt{PcNormalizedUnitGroup(KG)}. Otherwise this property will not be bound. }
\begin{Verbatim}[fontsize=\small,frame=single,label=Example]
gap> IsNormalizedUnitGroupOfGroupRing( NormalizedUnitGroup( KG ) );
true
gap> IsNormalizedUnitGroupOfGroupRing( PcNormalizedUnitGroup( KG ) );
true
\end{Verbatim}
\subsection{\textcolor{Chapter }{UnderlyingGroupRing}}
\logpage{[ 4, 4, 11 ]}\nobreak
{\noindent\textcolor{FuncColor}{$\Diamond$\ \texttt{UnderlyingGroupRing( U )\index{UnderlyingGroupRing@\texttt{UnderlyingGroupRing}}
\label{UnderlyingGroupRing}
}\hfill{\scriptsize (attribute)}}\\
\textbf{\indent Returns:\ }
a group ring
If \mbox{\texttt{U}} is the (normalized) unit group of a $p$-modular group algebra $KG$ obtained using one of the functions \texttt{Units(KG)}, \texttt{PcUnits(KG)}, \texttt{NormalizedUnitGroup(KG)} or \texttt{PcNormalizedUnitGroup(KG)}, then the attribute \texttt{UnderlyingGroupRing} stores $KG$. }
\begin{Verbatim}[fontsize=\small,frame=single,label=Example]
gap> UnderlyingGroupRing( Units( KG ) );
<algebra-with-one over GF(2), with 4 generators>
gap> UnderlyingGroupRing( PcUnits( KG ) );
<algebra-with-one over GF(2), with 4 generators>
gap> UnderlyingGroupRing( NormalizedUnitGroup( KG ) );
<algebra-with-one over GF(2), with 4 generators>
gap> UnderlyingGroupRing( PcNormalizedUnitGroup( KG ) );
<algebra-with-one over GF(2), with 4 generators>
\end{Verbatim}
\subsection{\textcolor{Chapter }{UnitarySubgroup}}
\logpage{[ 4, 4, 12 ]}\nobreak
{\noindent\textcolor{FuncColor}{$\Diamond$\ \texttt{UnitarySubgroup( U )\index{UnitarySubgroup@\texttt{UnitarySubgroup}}
\label{UnitarySubgroup}
}\hfill{\scriptsize (attribute)}}\\
\textbf{\indent Returns:\ }
the subgroup of the unit group
Let \mbox{\texttt{U}} be the normalized unit group of a group ring in either natural (see \texttt{NormalizedUnitGroup} (\ref{NormalizedUnitGroup})) or power-commutator (see \texttt{PcNormalizedUnitGroup} (\ref{PcNormalizedUnitGroup})) presentation. The attribute stores the unitary subgroup of \mbox{\texttt{U}}, generated by all unitary units of \mbox{\texttt{U}} (see \texttt{IsUnitary} (\ref{IsUnitary})). The method is straightforward, so it is not recommended to run it for large
groups. }
\begin{Verbatim}[fontsize=\small,frame=single,label=Example]
gap> KG := GroupRing( GF( 2 ), DihedralGroup( 8 ) );
<algebra-with-one over GF(2), with 3 generators>
gap> U := NormalizedUnitGroup( KG );
<group of size 128 with 7 generators>
gap> HU := UnitarySubgroup( U );
<group with 5 generators>
gap> IdGroup( HU );
[ 64, 261 ]
gap> V := PcNormalizedUnitGroup( KG );
<pc group of size 128 with 7 generators>
gap> HV := UnitarySubgroup( V );
Group([ f1, f2, f5, f6, f7 ])
gap> IdGroup( HV );
[ 64, 261 ]
gap> Image(NaturalBijectionToPcNormalizedUnitGroup( KG ), HU ) = HV;
true
\end{Verbatim}
\subsection{\textcolor{Chapter }{BicyclicUnitGroup}}
\logpage{[ 4, 4, 13 ]}\nobreak
{\noindent\textcolor{FuncColor}{$\Diamond$\ \texttt{BicyclicUnitGroup( U )\index{BicyclicUnitGroup@\texttt{BicyclicUnitGroup}}
\label{BicyclicUnitGroup}
}\hfill{\scriptsize (attribute)}}\\
\textbf{\indent Returns:\ }
the subgroup of the unit group, generated by bicyclic units
Let \mbox{\texttt{U}} be the normalized unit group of a group ring in either natural (see \texttt{NormalizedUnitGroup} (\ref{NormalizedUnitGroup})) or power-commutator (see \texttt{PcNormalizedUnitGroup} (\ref{PcNormalizedUnitGroup})) presentation. The attribute stores the subgroup of \mbox{\texttt{U}}, generated by all bicyclic units $u_{g,h}$ and $v_{g,h}$ (see \texttt{BicyclicUnitOfType1} (\ref{BicyclicUnitOfType1}) and \texttt{BicyclicUnitOfType1} (\ref{BicyclicUnitOfType1})), where $g$ and $h$ run over the elements of the underlying group, and $h$ do not belongs to the normalizer of $ \langle g \rangle $ in $G$. }
\begin{Verbatim}[fontsize=\small,frame=single,label=Example]
gap> KG := GroupRing( GF( 2 ), DihedralGroup( 8 ) );
<algebra-with-one over GF(2), with 3 generators>
gap> U := NormalizedUnitGroup( KG );
<group of size 128 with 7 generators>
gap> BU := BicyclicUnitGroup( U );
<group with 2 generators>
gap> IdGroup( BU );
[ 4, 2 ]
gap> V := PcNormalizedUnitGroup( KG );
<pc group of size 128 with 7 generators>
gap> BV := BicyclicUnitGroup( V );
Group([ f5*f6, f6*f7 ])
gap> IdGroup( BV );
[ 4, 2 ]
gap> Image( NaturalBijectionToPcNormalizedUnitGroup( KG ), BU ) = BV;
true
\end{Verbatim}
\subsection{\textcolor{Chapter }{AugmentationIdealPowerFactorGroup}}
\logpage{[ 4, 4, 14 ]}\nobreak
{\noindent\textcolor{FuncColor}{$\Diamond$\ \texttt{AugmentationIdealPowerFactorGroup( KG, n )\index{AugmentationIdealPowerFactorGroup@\texttt{AugmentationIdealPowerFactorGroup}}
\label{AugmentationIdealPowerFactorGroup}
}\hfill{\scriptsize (operation)}}\\
\textbf{\indent Returns:\ }
PcGroup
???????????????????????????????????????? }
\begin{Verbatim}[fontsize=\small,frame=single,label=Example]
\end{Verbatim}
\subsection{\textcolor{Chapter }{GroupBases}}
\logpage{[ 4, 4, 15 ]}\nobreak
{\noindent\textcolor{FuncColor}{$\Diamond$\ \texttt{GroupBases( KG )\index{GroupBases@\texttt{GroupBases}}
\label{GroupBases}
}\hfill{\scriptsize (attribute)}}\\
\textbf{\indent Returns:\ }
a list of lists of group rings elements
The subgroup $B$ of the normalized unit group of the group algebra $KG$ is called a \emph{group basis}, if the elements of $B$ are linearly independent over the field $K$ and $ KB=KG $. If \mbox{\texttt{KG}} is a $p$-modular group algebra, then \texttt{GroupBases} returns a list of representatives of the conjugacy classes of the group bases
of the group algebra \mbox{\texttt{KG}} in its normalised unit group. }
\begin{Verbatim}[fontsize=\small,frame=single,label=Example]
gap> D8 := DihedralGroup( 8 );
<pc group of size 8 with 3 generators>
gap> K := GF(2);
GF(2)
gap> KD8 := GroupRing( GF( 2 ), D8 );
<algebra-with-one over GF(2), with 3 generators>
gap> gb := GroupBases( KD8 );;
gap> Length( gb );
32
gap> gb[1];
[ (Z(2)^0)*<identity> of ..., (Z(2)^0)*f3,
(Z(2)^0)*f1*f2+(Z(2)^0)*f2*f3+(Z(2)^0)*f1*f2*f3,
(Z(2)^0)*f2+(Z(2)^0)*f1*f2+(Z(2)^0)*f1*f2*f3,
(Z(2)^0)*<identity> of ...+(Z(2)^0)*f2+(Z(2)^0)*f3+(Z(2)^0)*f2*f3+(Z(2)^
0)*f1*f2*f3, (Z(2)^0)*f2+(Z(2)^0)*f1*f3+(Z(2)^0)*f2*f3,
(Z(2)^0)*<identity> of ...+(Z(2)^0)*f2+(Z(2)^0)*f3+(Z(2)^0)*f1*f2+(Z(2)^
0)*f2*f3, (Z(2)^0)*f1+(Z(2)^0)*f2+(Z(2)^0)*f2*f3 ]
gap> Length( last );
8
\end{Verbatim}
}
\section{\textcolor{Chapter }{The Lie algebra of a group algebra}}\label{LieAlgebra}
\logpage{[ 4, 5, 0 ]}
{
\subsection{\textcolor{Chapter }{LieAlgebraByDomain}}
\logpage{[ 4, 5, 1 ]}\nobreak
{\noindent\textcolor{FuncColor}{$\Diamond$\ \texttt{LieAlgebraByDomain( A )\index{LieAlgebraByDomain@\texttt{LieAlgebraByDomain}}
\label{LieAlgebraByDomain}
}\hfill{\scriptsize (method)}}\\
This method takes a group algebra as its argument, and constructs its
associated Lie algebra in which the product is the bracket operation: $[a,b]=ab-ba$. It is recommended that the user never calls this method. The Lie algebra for
an associative algebra should normally be created using \texttt{LieAlgebra( A )}. When \texttt{LieAlgebra} is first invoked, it constructs the Lie algebra for \mbox{\texttt{A}} using \texttt{LieAlgebraByDomain}. After that it stores this Lie algebra and simply returns it if \texttt{LieAlgebra} is called again. }
\begin{Verbatim}[fontsize=\small,frame=single,label=Example]
gap> G := SymmetricGroup(3);; FG := GroupRing( GF( 2 ), G );
<algebra-with-one over GF(2), with 2 generators>
gap> L := LieAlgebra( FG );
#I LAGUNA package: Constructing Lie algebra ...
<Lie algebra over GF(2)>
\end{Verbatim}
\subsection{\textcolor{Chapter }{IsLieAlgebraByAssociativeAlgebra}}
\logpage{[ 4, 5, 2 ]}\nobreak
{\noindent\textcolor{FuncColor}{$\Diamond$\ \texttt{IsLieAlgebraByAssociativeAlgebra( L )\index{IsLieAlgebraByAssociativeAlgebra@\texttt{IsLieAlgebraByAssociativeAlgebra}}
\label{IsLieAlgebraByAssociativeAlgebra}
}\hfill{\scriptsize (Category)}}\\
This category signifies that the Lie algebra \mbox{\texttt{L}} was constructed as the Lie algebra associated with an associative algebra
(this piece of information cannot be obtained later). }
\begin{Verbatim}[fontsize=\small,frame=single,label=Example]
gap> KG := GroupRing( GF(3), DihedralGroup(16) );
<algebra-with-one over GF(3), with 4 generators>
gap> L := LieAlgebra ( KG );
#I LAGUNA package: Constructing Lie algebra ...
<Lie algebra over GF(3)>
gap> IsLieAlgebraByAssociativeAlgebra( L );
true
\end{Verbatim}
\subsection{\textcolor{Chapter }{UnderlyingAssociativeAlgebra}}
\logpage{[ 4, 5, 3 ]}\nobreak
{\noindent\textcolor{FuncColor}{$\Diamond$\ \texttt{UnderlyingAssociativeAlgebra( L )\index{UnderlyingAssociativeAlgebra@\texttt{UnderlyingAssociativeAlgebra}}
\label{UnderlyingAssociativeAlgebra}
}\hfill{\scriptsize (attribute)}}\\
\textbf{\indent Returns:\ }
the underlying associative algebra of a Lie algebra
If a Lie algebra \mbox{\texttt{L}} is constructed from an associative algebra, then it remembers this underlying
associative algebra as one of its attributes. }
\begin{Verbatim}[fontsize=\small,frame=single,label=Example]
gap> KG := GroupRing( GF(2), DihedralGroup(16) );
<algebra-with-one over GF(2), with 4 generators>
gap> L := LieAlgebra ( KG );
#I LAGUNA package: Constructing Lie algebra ...
<Lie algebra over GF(2)>
gap> UnderlyingAssociativeAlgebra( L );
<algebra-with-one over GF(2), with 4 generators>
gap> last = KG;
true
\end{Verbatim}
\subsection{\textcolor{Chapter }{NaturalBijectionToLieAlgebra}}
\logpage{[ 4, 5, 4 ]}\nobreak
{\noindent\textcolor{FuncColor}{$\Diamond$\ \texttt{NaturalBijectionToLieAlgebra( A )\index{NaturalBijectionToLieAlgebra@\texttt{NaturalBijectionToLieAlgebra}}
\label{NaturalBijectionToLieAlgebra}
}\hfill{\scriptsize (attribute)}}\\
\textbf{\indent Returns:\ }
a mapping
The natural linear bijection between the (isomorphic, but not equal)
underlying vector spaces of an associative algebra \mbox{\texttt{A}} and its associated Lie algebra is stored as an attribute of \mbox{\texttt{A}}. Note that this is a vector space isomorphism between two algebras, but not
an algebra isomorphism. }
\begin{Verbatim}[fontsize=\small,frame=single,label=Example]
gap> F := GF( 2 ); G := SymmetricGroup( 3 ); FG := GroupRing( F, G );
GF(2)
Sym( [ 1 .. 3 ] )
<algebra-with-one over GF(2), with 2 generators>
gap> t := NaturalBijectionToLieAlgebra( FG );
MappingByFunction( <algebra-with-one over GF(2), with
2 generators>, <Lie algebra over GF(
2)>, <Operation "LieObject">, function( y ) ... end )
gap> a := Random( FG );
(Z(2)^0)*(1,2,3)+(Z(2)^0)*(1,3,2)+(Z(2)^0)*(1,3)
gap> a * a; # product in the associative algebra
(Z(2)^0)*()+(Z(2)^0)*(1,2,3)+(Z(2)^0)*(1,3,2)
gap> b := a^t;
LieObject( (Z(2)^0)*(1,2,3)+(Z(2)^0)*(1,3,2)+(Z(2)^0)*(1,3) )
gap> b * b; # product in the Lie algebra (commutator) ...
LieObject( <zero> of ... ) # ... must be zero!
\end{Verbatim}
\subsection{\textcolor{Chapter }{NaturalBijectionToAssociativeAlgebra}}
\logpage{[ 4, 5, 5 ]}\nobreak
{\noindent\textcolor{FuncColor}{$\Diamond$\ \texttt{NaturalBijectionToAssociativeAlgebra( L )\index{NaturalBijectionToAssociativeAlgebra@\texttt{NaturalBijectionToAssociativeAlgebra}}
\label{NaturalBijectionToAssociativeAlgebra}
}\hfill{\scriptsize (attribute)}}\\
This is the inverse of the previous linear bijection, stored as an attribute
of the Lie algebra \mbox{\texttt{L}}. }
\begin{Verbatim}[fontsize=\small,frame=single,label=Example]
gap> G := SymmetricGroup(3); FG := GroupRing( GF( 2 ), G );
Sym( [ 1 .. 3 ] )
<algebra-with-one over GF(2), with 2 generators>
gap> L := LieAlgebra( FG );
#I LAGUNA package: Constructing Lie algebra ...
<Lie algebra over GF(2)>
gap> s := NaturalBijectionToAssociativeAlgebra( L );
MappingByFunction( <Lie algebra over GF(2)>, <algebra-with-one over GF(
2), with 2 generators>, function( y ) ... end, <Operation "LieObject"> )
gap> InverseGeneralMapping( s ) = NaturalBijectionToLieAlgebra( FG );
true
\end{Verbatim}
\subsection{\textcolor{Chapter }{IsLieAlgebraOfGroupRing}}
\logpage{[ 4, 5, 6 ]}\nobreak
{\noindent\textcolor{FuncColor}{$\Diamond$\ \texttt{IsLieAlgebraOfGroupRing( L )\index{IsLieAlgebraOfGroupRing@\texttt{IsLieAlgebraOfGroupRing}}
\label{IsLieAlgebraOfGroupRing}
}\hfill{\scriptsize (property)}}\\
If a Lie algebra \mbox{\texttt{L}} is constructed from an associative algebra which happens to be in fact a group
ring, it has many nice properties that can be used for fast algorithms, so
this information is stored as a property. }
\begin{Verbatim}[fontsize=\small,frame=single,label=Example]
gap> F := GF( 2 ); G := SymmetricGroup( 3 ); FG := GroupRing( F, G );
GF(2)
Sym( [ 1 .. 3 ] )
<algebra-with-one over GF(2), with 2 generators>
gap> L := LieAlgebra( FG );
#I LAGUNA package: Constructing Lie algebra ...
<Lie algebra over GF(2)>
gap> IsLieAlgebraOfGroupRing( L );
true
\end{Verbatim}
\subsection{\textcolor{Chapter }{UnderlyingGroup (of Lie algebra of a group ring)}}
\logpage{[ 4, 5, 7 ]}\nobreak
{\noindent\textcolor{FuncColor}{$\Diamond$\ \texttt{UnderlyingGroup( L )\index{UnderlyingGroup@\texttt{UnderlyingGroup}!of Lie algebra of a group ring}
\label{UnderlyingGroup:of Lie algebra of a group ring}
}\hfill{\scriptsize (attribute)}}\\
\textbf{\indent Returns:\ }
the underlying group
The underlying group of a Lie algebra \mbox{\texttt{L}} that is constructed from a group ring is defined as the underlying group of
this group ring; see \texttt{UnderlyingGroup} (\ref{UnderlyingGroup:of a group ring}). }
\begin{Verbatim}[fontsize=\small,frame=single,label=Example]
gap> F := GF( 2 ); G := SymmetricGroup( 3 ); FG := GroupRing( F, G );
GF(2)
Sym( [ 1 .. 3 ] )
<algebra-with-one over GF(2), with 2 generators>
gap> L := LieAlgebra( FG );
#I LAGUNA package: Constructing Lie algebra ...
<Lie algebra over GF(2)>
gap> UnderlyingGroup( L );
Sym( [ 1 .. 3 ] )
gap> LeftActingDomain( L );
GF(2)
\end{Verbatim}
\subsection{\textcolor{Chapter }{Embedding}}
\logpage{[ 4, 5, 8 ]}\nobreak
{\noindent\textcolor{FuncColor}{$\Diamond$\ \texttt{Embedding( U, L )\index{Embedding@\texttt{Embedding}}
\label{Embedding}
}\hfill{\scriptsize (operation)}}\\
\textbf{\indent Returns:\ }
a mapping, which is a composition of two mappings
Let $FG$ be a group ring, let \mbox{\texttt{U}} be a submagma of $G$, and let \mbox{\texttt{L}} be the Lie algebra associated with $FG$. Then \texttt{Embedding(\mbox{\texttt{U}}, \mbox{\texttt{L}} )} returns the obvious mapping from \mbox{\texttt{U}} to \mbox{\texttt{L}} (as the composition of the mappings \texttt{Embedding( \mbox{\texttt{U}}, FG )} and \texttt{NaturalBijectionToLieAlgebra( FG )}). }
\begin{Verbatim}[fontsize=\small,frame=single,label=Example]
gap> F := GF( 2 ); G := SymmetricGroup( 3 ); FG := GroupRing( F, G );
GF(2)
Sym( [ 1 .. 3 ] )
<algebra-with-one over GF(2), with 2 generators>
gap> L := LieAlgebra( FG );
#I LAGUNA package: Constructing Lie algebra ...
<Lie algebra over GF(2)>
gap> f := Embedding( G, L );
CompositionMapping( MappingByFunction( <algebra-with-one over GF(2), with
2 generators>, <Lie algebra over GF(
2)>, <Operation "LieObject">, function( y ) ... end ), <mapping: SymmetricGrou\
p( [ 1 .. 3 ] ) -> AlgebraWithOne( GF(2), ... ) > )
gap> (1,2)^f + (1,3)^f;
LieObject( (Z(2)^0)*(1,2)+(Z(2)^0)*(1,3) )
\end{Verbatim}
\subsection{\textcolor{Chapter }{LieCentre}}
\logpage{[ 4, 5, 9 ]}\nobreak
{\noindent\textcolor{FuncColor}{$\Diamond$\ \texttt{LieCentre( L )\index{LieCentre@\texttt{LieCentre}}
\label{LieCentre}
}\hfill{\scriptsize (method)}}\\
\textbf{\indent Returns:\ }
a Lie algebra
The centre of the Lie algebra associated with a group ring corresponds to the
centre of the underlying group ring, and it can be calculated very fast by
considering the conjugacy classes of the group. This method returns the centre
of \mbox{\texttt{L}} using this idea. }
\begin{Verbatim}[fontsize=\small,frame=single,label=Example]
gap> G := SmallGroup( 256, 400 ); FG := GroupRing( GF( 2 ), G );
<pc group of size 256 with 8 generators>
<algebra-with-one over GF(2), with 8 generators>
gap> L := LieAlgebra( FG );
#I LAGUNA package: Constructing Lie algebra ...
<Lie algebra over GF(2)>
gap> C := LieCentre( L );
<Lie algebra of dimension 28 over GF(2)>
gap> D := LieDerivedSubalgebra( L );
#I LAGUNA package: Computing the Lie derived subalgebra ...
<Lie algebra of dimension 228 over GF(2)>
gap> c := Dimension( C ); d := Dimension( D ); l := Dimension( L );
28
228
256
gap> c + d = l;
true # This is always the case for Lie algebras of group algebras!
\end{Verbatim}
\subsection{\textcolor{Chapter }{LieDerivedSubalgebra}}
\logpage{[ 4, 5, 10 ]}\nobreak
{\noindent\textcolor{FuncColor}{$\Diamond$\ \texttt{LieDerivedSubalgebra( L )\index{LieDerivedSubalgebra@\texttt{LieDerivedSubalgebra}}
\label{LieDerivedSubalgebra}
}\hfill{\scriptsize (method)}}\\
\textbf{\indent Returns:\ }
a Lie algebra
If \mbox{\texttt{L}} is the Lie algebra associated with a group ring, then this method returns the
Lie derived subalgebra of \mbox{\texttt{L}}. This can be done very fast using the conjugacy classes of the underlying
group. }
\begin{Verbatim}[fontsize=\small,frame=single,label=Example]
gap> G := SmallGroup( 256, 400 ); FG := GroupRing( GF( 2 ), G );
<pc group of size 256 with 8 generators>
<algebra-with-one over GF(2), with 8 generators>
gap> L := LieAlgebra( FG );
#I LAGUNA package: Constructing Lie algebra ...
<Lie algebra over GF(2)>
gap> C := LieCentre( L );
<Lie algebra of dimension 28 over GF(2)>
gap> D := LieDerivedSubalgebra( L );
#I LAGUNA package: Computing the Lie derived subalgebra ...
<Lie algebra of dimension 228 over GF(2)>
gap> l := Dimension( L ); c := Dimension( C ); d := Dimension( D );
256
28
228
gap> c + d = l;
true # This is always the case for Lie algebras of group algebras!
\end{Verbatim}
\subsection{\textcolor{Chapter }{IsLieAbelian}}
\logpage{[ 4, 5, 11 ]}\nobreak
{\noindent\textcolor{FuncColor}{$\Diamond$\ \texttt{IsLieAbelian( L )\index{IsLieAbelian@\texttt{IsLieAbelian}}
\label{IsLieAbelian}
}\hfill{\scriptsize (method)}}\\
The Lie algebra \mbox{\texttt{L}} of an associative algebra $A$ is Lie abelian, if and only if $A$ is abelian, so this method refers to \texttt{IsAbelian( A )}. }
\begin{Verbatim}[fontsize=\small,frame=single,label=Example]
gap> G := SymmetricGroup( 3 ); FG := GroupRing( GF( 2 ), G);
Sym( [ 1 .. 3 ] )
<algebra-with-one over GF(2), with 2 generators>
gap> L := LieAlgebra( FG );
#I LAGUNA package: Constructing Lie algebra ...
<Lie algebra over GF(2)>
gap> IsAbelian( G );
false
gap> IsAbelian( L ); # This command should never be used for Lie algebras!
true # It gives a result, but (probably) not the desired one.
gap> IsLieAbelian( L ); # Instead, IsLieAbelian is the correct command.
false
\end{Verbatim}
\subsection{\textcolor{Chapter }{IsLieSolvable}}
\logpage{[ 4, 5, 12 ]}\nobreak
{\noindent\textcolor{FuncColor}{$\Diamond$\ \texttt{IsLieSolvable( L )\index{IsLieSolvable@\texttt{IsLieSolvable}}
\label{IsLieSolvable}
}\hfill{\scriptsize (method)}}\\
In \cite{PPS73} Passi, Passman, and Sehgal have classified all groups $G$ such that the Lie algebra associated with the group ring is solvable. This
method uses their classification, making it considerably faster than the more
elementary method which just calculates Lie commutators. }
\begin{Verbatim}[fontsize=\small,frame=single,label=Example]
gap> G := SmallGroup( 256, 400 ); FG := GroupRing( GF( 2 ), G );
<pc group of size 256 with 8 generators>
<algebra-with-one over GF(2), with 8 generators>
gap> L := LieAlgebra( FG );
#I LAGUNA package: Constructing Lie algebra ...
<Lie algebra over GF(2)>
gap> IsLieSolvable( L ); # This is very fast.
true
gap> List( LieDerivedSeries( L ), Dimension ); # This is very slow.
[ 256, 228, 189, 71, 0 ]
\end{Verbatim}
\subsection{\textcolor{Chapter }{IsLieNilpotent}}
\logpage{[ 4, 5, 13 ]}\nobreak
{\noindent\textcolor{FuncColor}{$\Diamond$\ \texttt{IsLieNilpotent( L )\index{IsLieNilpotent@\texttt{IsLieNilpotent}}
\label{IsLieNilpotent}
}\hfill{\scriptsize (method)}}\\
In \cite{PPS73} Passi, Passman, and Sehgal have classified all groups $G$ such that the Lie algebra associated with the group ring is Lie nilpotent.
This method uses their classification, making it considerably faster than the
more elementary method which just calculates Lie commutators. }
\begin{Verbatim}[fontsize=\small,frame=single,label=Example]
gap> G := SmallGroup( 256, 400 ); FG := GroupRing( GF( 2 ), G );
<pc group of size 256 with 8 generators>
<algebra-with-one over GF(2), with 8 generators>
gap> L := LieAlgebra( FG );
#I LAGUNA package: Constructing Lie algebra ...
<Lie algebra over GF(2)>
gap> IsLieNilpotent( L ); # This is very fast.
true
gap> List( LieLowerCentralSeries( L ), Dimension ); # This is very slow.
[ 256, 228, 222, 210, 191, 167, 138, 107, 76, 54, 29, 15, 6, 0 ]
\end{Verbatim}
\subsection{\textcolor{Chapter }{IsLieMetabelian}}
\logpage{[ 4, 5, 14 ]}\nobreak
{\noindent\textcolor{FuncColor}{$\Diamond$\ \texttt{IsLieMetabelian( L )\index{IsLieMetabelian@\texttt{IsLieMetabelian}}
\label{IsLieMetabelian}
}\hfill{\scriptsize (property)}}\\
In \cite{LR86} Levin and Rosenberger have classified all groups $G$ such that the Lie algebra associated with the group ring is Lie metabelian.
This method uses their classification, making it considerably faster than the
more elementary method which just calculates Lie commutators. }
\begin{Verbatim}[fontsize=\small,frame=single,label=Example]
gap> G := SmallGroup( 256, 400 ); FG := GroupRing( GF( 2 ), G );
<pc group of size 256 with 8 generators>
<algebra-with-one over GF(2), with 8 generators>
gap> L := LieAlgebra( FG );
#I LAGUNA package: Constructing Lie algebra ...
<Lie algebra over GF(2)>
gap> IsLieMetabelian( L );
false
\end{Verbatim}
\subsection{\textcolor{Chapter }{IsLieCentreByMetabelian}}
\logpage{[ 4, 5, 15 ]}\nobreak
{\noindent\textcolor{FuncColor}{$\Diamond$\ \texttt{IsLieCentreByMetabelian( L )\index{IsLieCentreByMetabelian@\texttt{IsLieCentreByMetabelian}}
\label{IsLieCentreByMetabelian}
}\hfill{\scriptsize (property)}}\\
In \cite{Ross} the third author of this package classified all groups $G$ such that the Lie algebra associated with the group ring is Lie
centre-by-metabelian. This method uses the classification, making it
considerably faster than the more elementary method which just calculates Lie
commutators. }
\begin{Verbatim}[fontsize=\small,frame=single,label=Example]
gap> G := SymmetricGroup( 3 ); FG := GroupRing( GF( 2 ), G );
Sym( [ 1 .. 3 ] )
<algebra-with-one over GF(2), with 2 generators>
gap> L := LieAlgebra( FG );
#I LAGUNA package: Constructing Lie algebra ...
<Lie algebra over GF(2)>
gap> IsLieMetabelian( L );
false
gap> IsLieCentreByMetabelian( L );
true
\end{Verbatim}
\subsection{\textcolor{Chapter }{CanonicalBasis}}
\logpage{[ 4, 5, 16 ]}\nobreak
{\noindent\textcolor{FuncColor}{$\Diamond$\ \texttt{CanonicalBasis( L )\index{CanonicalBasis@\texttt{CanonicalBasis}}
\label{CanonicalBasis}
}\hfill{\scriptsize (method)}}\\
\textbf{\indent Returns:\ }
basis of a Lie algebra
The canonical basis of a group algebra $FG$ is formed by the elements of $G$. Here \mbox{\texttt{L}} is the Lie algebra associated with $FG$, and the method returns the images of the elements of $G$ in \mbox{\texttt{L}}. }
\begin{Verbatim}[fontsize=\small,frame=single,label=Example]
gap> G := SymmetricGroup( 3 ); FG := GroupRing( GF( 2 ), G );
Sym( [ 1 .. 3 ] )
<algebra-with-one over GF(2), with 2 generators>
gap> L := LieAlgebra( FG );
#I LAGUNA package: Constructing Lie algebra ...
<Lie algebra over GF(2)>
gap> B := CanonicalBasis( L );
CanonicalBasis( <Lie algebra of dimension 6 over GF(2)> )
gap> Elements( B );
[ LieObject( (Z(2)^0)*() ), LieObject( (Z(2)^0)*(2,3) ),
LieObject( (Z(2)^0)*(1,2) ), LieObject( (Z(2)^0)*(1,2,3) ),
LieObject( (Z(2)^0)*(1,3,2) ), LieObject( (Z(2)^0)*(1,3) ) ]
\end{Verbatim}
\subsection{\textcolor{Chapter }{IsBasisOfLieAlgebraOfGroupRing}}
\logpage{[ 4, 5, 17 ]}\nobreak
{\noindent\textcolor{FuncColor}{$\Diamond$\ \texttt{IsBasisOfLieAlgebraOfGroupRing( B )\index{IsBasisOfLieAlgebraOfGroupRing@\texttt{IsBasisOfLieAlgebraOfGroupRing}}
\label{IsBasisOfLieAlgebraOfGroupRing}
}\hfill{\scriptsize (property)}}\\
A basis \mbox{\texttt{B}} has this property if the preimages of the basis vectors in the group algebra
form a group. It can be verified if a basis has this property. This is
important for the speed of the calculation of the structure constants table;
see \texttt{StructureConstantsTable} (\ref{StructureConstantsTable}). }
\begin{Verbatim}[fontsize=\small,frame=single,label=Example]
gap> G := SymmetricGroup( 3 ); FG := GroupRing( GF( 2 ), G );
Sym( [ 1 .. 3 ] )
<algebra-with-one over GF(2), with 2 generators>
gap> L := LieAlgebra( FG );
#I LAGUNA package: Constructing Lie algebra ...
<Lie algebra over GF(2)>
gap> B := CanonicalBasis( L );
CanonicalBasis( <Lie algebra of dimension 6 over GF(2)> )
gap> IsBasisOfLieAlgebraOfGroupRing( B );
true
\end{Verbatim}
\subsection{\textcolor{Chapter }{StructureConstantsTable}}
\logpage{[ 4, 5, 18 ]}\nobreak
{\noindent\textcolor{FuncColor}{$\Diamond$\ \texttt{StructureConstantsTable( B )\index{StructureConstantsTable@\texttt{StructureConstantsTable}}
\label{StructureConstantsTable}
}\hfill{\scriptsize (method)}}\\
A very fast implementation for calculating the structure constants table for
the Lie algebra \texttt{L} associated with a group ring with respect to its canonical basis \mbox{\texttt{B}} using its special structure; see \texttt{CanonicalBasis} (\ref{CanonicalBasis}). }
\begin{Verbatim}[fontsize=\small,frame=single,label=Example]
gap> G := CyclicGroup( 2 ); FG := GroupRing( GF( 2 ), G );
<pc group of size 2 with 1 generators>
<algebra-with-one over GF(2), with 1 generators>
gap> L := LieAlgebra( FG );
#I LAGUNA package: Constructing Lie algebra ...
<Lie algebra over GF(2)>
gap> B := CanonicalBasis( L );
CanonicalBasis( <Lie algebra of dimension 2 over GF(2)> )
gap> StructureConstantsTable( B );
[ [ [ [ ], [ ] ], [ [ ], [ ] ] ], [ [ [ ], [ ] ], [ [ ], [ ] ] ], -1,
0*Z(2) ]
\end{Verbatim}
\subsection{\textcolor{Chapter }{LieUpperNilpotencyIndex}}
\logpage{[ 4, 5, 19 ]}\nobreak
{\noindent\textcolor{FuncColor}{$\Diamond$\ \texttt{LieUpperNilpotencyIndex( KG )\index{LieUpperNilpotencyIndex@\texttt{LieUpperNilpotencyIndex}}
\label{LieUpperNilpotencyIndex}
}\hfill{\scriptsize (attribute)}}\\
\index{upper Lie power series} In a modular group algebra $KG$ the \emph{upper Lie power series} is defined as follows: $KG^{(1)}=KG$, $KG^{(n+1)}$ is the associative ideal, generated by $[KG^{(n)},KG]$. The upper Lie nilpotency index $t^L(G)$ of the group algebra $KG$ is defined to be the smallest number $n$ such that $KG^{(n)}=0$. It can be calculated very fast using Lie dimension subgroups \cite{Shalev91}, that is, using only information about the underlying group; see \texttt{LieDimensionSubgroups} (\ref{LieDimensionSubgroups}). This is why it is stored as an attribute of the group algebra \mbox{\texttt{KG}} rather than that of its associated Lie algebra. }
\begin{Verbatim}[fontsize=\small,frame=single,label=Example]
gap> KG := GroupRing( GF( 2 ), DihedralGroup( 16 ) );
<algebra-with-one over GF(2), with 4 generators>
gap> LieUpperNilpotencyIndex( KG );
5
\end{Verbatim}
\subsection{\textcolor{Chapter }{LieLowerNilpotencyIndex}}
\logpage{[ 4, 5, 20 ]}\nobreak
{\noindent\textcolor{FuncColor}{$\Diamond$\ \texttt{LieLowerNilpotencyIndex( KG )\index{LieLowerNilpotencyIndex@\texttt{LieLowerNilpotencyIndex}}
\label{LieLowerNilpotencyIndex}
}\hfill{\scriptsize (attribute)}}\\
\index{lower Lie power series} In a modular group algebra $KG$ the \emph{lower Lie power series} is defined as follows: $KG^{[n]}$ is the associative ideal, generated by all (left-normed) Lie-products $[x_1, x_2, \dots, x_n]$, $ x_i \in KG $. The lower Lie nilpotency index $t_L(G)$ of the group algebra $KG$ is defined to be the minimal smallest $n$ such that $KG^{[n]}=0$. In \cite{Du} the Jennings' conjecture was proved, which means that the nilpotency class of
the normalized unit group of the modular group algebra $KG$ is equal to $t_L(G)-1$.
This allows to express lower Lie nilpotency index via the nilpotency class of
the normalized unit group, and with its polycyclic presentation, provided by \textsf{LAGUNA}, this will be faster than elementary calculations with Lie commutators. As
the previous attribute, this index is also stored as an attribute of the group
algebra \mbox{\texttt{KG}}. }
\begin{Verbatim}[fontsize=\small,frame=single,label=Example]
gap> KG := GroupRing( GF( 2 ), DihedralGroup( 16 ) );
<algebra-with-one over GF(2), with 4 generators>
gap> LieLowerNilpotencyIndex( KG );
5
\end{Verbatim}
\subsection{\textcolor{Chapter }{LieDerivedLength}}
\logpage{[ 4, 5, 21 ]}\nobreak
{\noindent\textcolor{FuncColor}{$\Diamond$\ \texttt{LieDerivedLength( L )\index{LieDerivedLength@\texttt{LieDerivedLength}}
\label{LieDerivedLength}
}\hfill{\scriptsize (attribute)}}\\
\index{Lie derived series} \index{Lie derived length} Let $L$ be a Lie algebra. The \emph{Lie derived series} of $L$ is defined as follows: $\delta^{[0]}(L) = L$ and $\delta^{[n]}(L) = [\delta^{[n-1]}(L), \delta^{[n-1]}(L)]$. $L$ is called Lie solvable if there exists an integer $m$ such that $ \delta^{[m]}(L) = 0 $. In this case the integer $m$ is called the \emph{Lie derived length} of $L$, and it is returned by this function. }
\begin{Verbatim}[fontsize=\small,frame=single,label=Example]
gap> KG := GroupRing( GF ( 2 ), DihedralGroup( 16 ) );;
gap> L := LieAlgebra( KG );
#I LAGUNA package: Constructing Lie algebra ...
<Lie algebra over GF(2)>
gap> LieDerivedLength( L );
#I LAGUNA package: Computing the Lie derived subalgebra ...
3
\end{Verbatim}
}
\section{\textcolor{Chapter }{Other commands}}\label{Other}
\logpage{[ 4, 6, 0 ]}
{
\subsection{\textcolor{Chapter }{SubgroupsOfIndexTwo}}
\logpage{[ 4, 6, 1 ]}\nobreak
{\noindent\textcolor{FuncColor}{$\Diamond$\ \texttt{SubgroupsOfIndexTwo( G )\index{SubgroupsOfIndexTwo@\texttt{SubgroupsOfIndexTwo}}
\label{SubgroupsOfIndexTwo}
}\hfill{\scriptsize (attribute)}}\\
Returns a list of subgroups of $G$ with index two. Such subgroups are important for the investigation of the Lie
structure of the group algebra $KG$ in the case of characteristic 2. }
\begin{Verbatim}[fontsize=\small,frame=single,label=Example]
gap> SubgroupsOfIndexTwo( DihedralGroup( 16) );
[ Group([ f1, f1*f3, f1*f4, f1*f3*f4 ]), Group([ f2, f2*f3, f2*f4, f2*f3*f4 ]),
Group([ f1*f2, f1*f2*f3, f1*f2*f4, f1*f2*f3*f4 ]) ]
\end{Verbatim}
\subsection{\textcolor{Chapter }{DihedralDepth}}
\logpage{[ 4, 6, 2 ]}\nobreak
{\noindent\textcolor{FuncColor}{$\Diamond$\ \texttt{DihedralDepth( U )\index{DihedralDepth@\texttt{DihedralDepth}}
\label{DihedralDepth}
}\hfill{\scriptsize (method)}}\\
For a finite 2-group \mbox{\texttt{U}}, the function returns its \emph{dihedral depth}, which is defined to be the maximal number $d$ such that \mbox{\texttt{U}} contains a subgroup isomorphic to the dihedral group of order $2^{d+1}$. }
\begin{Verbatim}[fontsize=\small,frame=single,label=Example]
gap> KD8 := GroupRing( GF(2), DihedralGroup( 8 ) );
<algebra-with-one over GF(2), with 3 generators>
gap> UD8 := PcNormalizedUnitGroup( KD8 );
<pc group of size 128 with 7 generators>
gap> DihedralDepth( UD8 );
2
\end{Verbatim}
\subsection{\textcolor{Chapter }{DimensionBasis}}
\logpage{[ 4, 6, 3 ]}\nobreak
{\noindent\textcolor{FuncColor}{$\Diamond$\ \texttt{DimensionBasis( G )\index{DimensionBasis@\texttt{DimensionBasis}}
\label{DimensionBasis}
}\hfill{\scriptsize (method)}}\\
\textbf{\indent Returns:\ }
record with two components: `dimensionBasis' (list of group elements) and
`weights' (list of weights)
For a finite $p$-group \mbox{\texttt{G}}, returns its Jennings basis as it was described in Section \ref{TheoryThird}. }
\begin{Verbatim}[fontsize=\small,frame=single,label=Example]
gap> G := DihedralGroup( 16 );
<pc group of size 16 with 4 generators>
gap> DimensionBasis( G );
rec( dimensionBasis := [ f1, f2, f3, f4 ], weights := [ 1, 1, 2, 4 ] )
\end{Verbatim}
\subsection{\textcolor{Chapter }{LieDimensionSubgroups}}
\logpage{[ 4, 6, 4 ]}\nobreak
{\noindent\textcolor{FuncColor}{$\Diamond$\ \texttt{LieDimensionSubgroups( G )\index{LieDimensionSubgroups@\texttt{LieDimensionSubgroups}}
\label{LieDimensionSubgroups}
}\hfill{\scriptsize (attribute)}}\\
\textbf{\indent Returns:\ }
list of subgroups
For a finite $p$-group \mbox{\texttt{G}}, returns the series of its Lie dimension subgroups. The $m$-th Lie dimension subgroup $ D_{(m)} $ is the intersection of the group $G$ and $ 1+KG^{(m)} $, where $KG^{(m)}$ is the $m$-th term of the upper Lie power series of $KG$; see \texttt{LieUpperNilpotencyIndex} (\ref{LieUpperNilpotencyIndex}) }
\begin{Verbatim}[fontsize=\small,frame=single,label=Example]
gap> G := DihedralGroup( 16 );
<pc group of size 16 with 4 generators>
gap> LieDimensionSubgroups( G );
[ <pc group of size 16 with 4 generators>, Group([ f3, f4 ]), Group([ f4 ]),
Group([ <identity> of ... ]) ]
\end{Verbatim}
\subsection{\textcolor{Chapter }{LieUpperCodimensionSeries}}
\logpage{[ 4, 6, 5 ]}\nobreak
{\noindent\textcolor{FuncColor}{$\Diamond$\ \texttt{LieUpperCodimensionSeries( KG )\index{LieUpperCodimensionSeries@\texttt{LieUpperCodimensionSeries}}
\label{LieUpperCodimensionSeries}
}\hfill{\scriptsize (attribute)}}\\
\noindent\textcolor{FuncColor}{$\Diamond$\ \texttt{LieUpperCodimensionSeries( G )\index{LieUpperCodimensionSeries@\texttt{LieUpperCodimensionSeries}}
\label{LieUpperCodimensionSeries}
}\hfill{\scriptsize (attribute)}}\\
\textbf{\indent Returns:\ }
list of subgroups
A notion of upper Lie codimension subgroups was introduced in \cite{CS}. For a finite $p$-group \mbox{\texttt{G}}, $C_i$ is the set of all elements $g$ in \mbox{\texttt{G}}, such that the Lie commutator $[ g, g_1, ..., g_i ]$ of the length $i+1$ is equal to zero for all $g_1, ..., g_i$ from \mbox{\texttt{G}}, and $ C_0 = {1} $. By Du's theorem (see \cite{Du}), $C_i$ coincides with the intersection of $G$ and the i-th term of the upper central series ${1}=Z_0 < Z_1 < Z_2 < ... < Z_n = V(KG)$ of the normalized unit group $V(KG)$. This fact is used in \textsf{LAGUNA} to speed up computation of this series. Since $V(KG)$ is involved in computation, for the first time the argiment should be the
group ring \mbox{\texttt{KG}}, but later you can also apply it to the group \mbox{\texttt{G}} itself. }
\begin{Verbatim}[fontsize=\small,frame=single,label=Example]
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> LieUpperCodimensionSeries( KG );
[ Group([ f1, f2, f3, f4 ]), Group([ f3, f4, f3*f4 ]), Group([ f4 ]),
Group([ f4 ]), Group([ ]) ]
gap> LieUpperCodimensionSeries( G );
[ Group([ f1, f2, f3, f4 ]), Group([ f3, f4, f3*f4 ]), Group([ f4 ]),
Group([ f4 ]), Group([ ]) ]
\end{Verbatim}
\subsection{\textcolor{Chapter }{LAGInfo}}
\logpage{[ 4, 6, 6 ]}\nobreak
{\noindent\textcolor{FuncColor}{$\Diamond$\ \texttt{LAGInfo\index{LAGInfo@\texttt{LAGInfo}}
\label{LAGInfo}
}\hfill{\scriptsize (info class)}}\\
\texttt{LAGInfo} is a special Info class for \textsf{LAGUNA} algorithms. It has 5 levels: 0, 1 (default), 2, 3 and 4. To change info level
to \texttt{k}, use command \texttt{SetInfoLevel(LAGInfo, k)}. }
\begin{Verbatim}[fontsize=\small,frame=single,label=Example]
gap> SetInfoLevel( LAGInfo, 2 );
gap> KD8 := GroupRing( GF( 2 ), DihedralGroup( 8 ) );
<algebra-with-one over GF(2), with 3 generators>
gap> UD8 := PcNormalizedUnitGroup( KD8 );
#I LAGInfo: Computing the pc normalized unit group ...
#I LAGInfo: Calculating weighted basis ...
#I LAGInfo: Calculating dimension basis ...
#I LAGInfo: dimension basis finished !
#I LAGInfo: Weighted basis finished !
#I LAGInfo: Computing the augmentation ideal filtration...
#I LAGInfo: Filtration finished !
#I LAGInfo: finished, converting to PcGroup
<pc group of size 128 with 7 generators>
\end{Verbatim}
\subsection{\textcolor{Chapter }{LAGUNABuildManual}}
\logpage{[ 4, 6, 7 ]}\nobreak
{\noindent\textcolor{FuncColor}{$\Diamond$\ \texttt{LAGUNABuildManual( )\index{LAGUNABuildManual@\texttt{LAGUNABuildManual}}
\label{LAGUNABuildManual}
}\hfill{\scriptsize (function)}}\\
This function is used to build the manual in the following formats: DVI, PDF,
PS, HTML and text for online help. We recommend that the user should have a
recent and fairly complete {\TeX} distribution. Since \textsf{LAGUNA} is distributed together with its manual, it is not necessary for the user to
use this function. Normally it is intended to be used by the developers only.
This is the only function of \textsf{LAGUNA} which requires UNIX/Linux environment. }
\subsection{\textcolor{Chapter }{LAGUNABuildManualHTML}}
\logpage{[ 4, 6, 8 ]}\nobreak
{\noindent\textcolor{FuncColor}{$\Diamond$\ \texttt{LAGUNABuildManualHTML( )\index{LAGUNABuildManualHTML@\texttt{LAGUNABuildManualHTML}}
\label{LAGUNABuildManualHTML}
}\hfill{\scriptsize (function)}}\\
This fuction is used to build the manual only in HTML format. This does not
depend on the availability of the {\TeX} installation and works under Windows and MacOS as well. Since \textsf{LAGUNA} is distributed together with its manual, it is not necessary for the user to
use this function. Normally it is intended to be used by the developers only. }
}
}
\def\bibname{References\logpage{[ "Bib", 0, 0 ]}}
\bibliographystyle{alpha}
\bibliography{manual}
\def\indexname{Index\logpage{[ "Ind", 0, 0 ]}}
\printindex
\newpage
\immediate\write\pagenrlog{["End"], \arabic{page}];}
\immediate\closeout\pagenrlog
\end{document}
distrib
>
Mandriva
>
2010.0
>
i586
>
media
>
contrib-release
>
by-pkgid
>
5e1854624d3bc613bdd0dd13d1ef9ac7
>
files
>
2162
