3. Details of implementation
  
  In  this  chapter we describe the approach used to store the normalized unit
  group  of  the  group  algebra  in the library, and to reconstruct the group
  V(KG) from the stored information.
  
  
  3.1 Saving the data
  
  To  compute  the pc-presentation of the normalized unit group of the modular
  group algebra of a finite p-group we used the function PcNormalizedUnitGroup
  from  the  LAGUNA  package. It uses the algorithm descibed in [B98]. See the
  LAGUNA manual [BK+] for more details.
  
  When  this  group  is  computed,  the  main  idea  is  to  use  GAP function
  CodePcGroup  that returns the code for the polycyclic generating sequence of
  the  group,  and  then  to  create  the  group  from this code using the GAP
  function PcGroupCode.
  
  The  resulting  code  could be very long, and to compress it we used the GAP
  function  HexStringInt  than  returns a string that represents the code with
  hexa-decimal  digits  (using  A-F  as digits 10-15). The inverse translation
  then  can  be  performed with the GAP function IntHexString. This allowed to
  save  almost 20 MB of space on groups of order 128 and reduce the total size
  of their database to 90 MB.
  
  For  groups  of  order  128 we decided to compress the library with the gzip
  program,  and  then uncompress each file "on fly" when it is requested. This
  allowed us to reduce the size of their part in the library from 90 to 12 MB,
  which  is already quite reasonable. Of course, there is some little overhead
  arising  from the uncompression and subsequent translation from hexa-decimal
  notation,  but  it  is  neglectible comparatively with the total time of the
  computation of V(KG) from scratch.
  
  There  is  one more thing that needs to be stored together with this code to
  make  it sure that we will correctly indentify the underlying group G of the
  group  algebra  KG  with  its image in the pc-presentation of the normalized
  unit group V(KG).
  
  The  group G is extracted from the GAP Small Groups Library, so it is always
  the same, unless its description in the library will be changed (and it will
  be  an  important  task  of  UnitLib maintaner to update the package in this
  case!), and here we are safe from inconsistencies.
  
  But  the  next stage is the computation of generators of the normalized unit
  group  V(KG), and the first step is the dimension basis of the group G, that
  can  be  computed  using  the  LAGUNA  function DimensionBasis. To avoid the
  influence  of  possible  changes in GAP or usage of random methods, we store
  (in  compacted  form)  the information about the dimension basis of G in the
  UnitLib.
  
  All  further procedures are implemented inside the LAGUNA package, and their
  result is uniquely determined and predictable.
  
  For most groups all information is stored in a single file. However, this is
  not  the case for groups of order 243, where we have about 30 MB of data for
  67  groups.  For  these  groups  we  provide  a  solution  on  the  base  of
  Web-services.  The  information about the dimension basis is stored locally,
  while  the  codes for polycyclic generating sequences are available from the
  UnitLib  homepage,  and the package will access them using the Curl function
  from the Qaos package [FP].
  
  For  the  reader  interested  in more details, the package contains the file
  unitlib/lib/genlib.g  with the function CreatePcNormalizedUnitGroupsLibrary,
  that  creates library files for groups of a given prime power order, and the
  file          unitlib/lib/genpar.g         with         the         function
  ParCreatePcNormalizedUnitGroupsLibrary, which is the parallel version of the
  previous function and must be used with the ParGAP package [C].
  
  
  3.2 Reading the data
  
  To  reconstruct  the  normalized  unit group V(KG) from the library, we need
  only to know the catalogue number of the underlying group G in the GAP Small
  Groups Library.
  
  We  use  the  same  numbering  as in the GAP Small Group Library, so UnitLib
  finds  the  appropriate  library  file(s) and reads from it the code for the
  polycyclic  generating  sequence  of  V(KG)  and  the  information about the
  dimension basis of G used for the computation of this code.
  
  Then  V(KG)  is created from the code using the GAP function PcGroupCode. We
  also create G using the GAP Small Groups Library.
  
  Now  to  "glue" V(KG) with the underlying group G properly, the value of the
  attribute  DimensionBasis  of  G  is  setted  in  accordance  with  the data
  retrieved  from the library. This will guarantee the correct construction of
  NaturalBijectionToPcNormalizedUnitGroup                                  and
  NaturalBijectionToNormalizedUnitGroup by the LAGUNA package.
  
  It  remains  now  to make only several technical steps, such as constructing
  the  group  algebra  KG  over the appropriate field K, and storing KG in the
  attribute   UnderlyingGroupRing   of   V(KG)  and  V(KG)  in  the  attribute
  PcNormalizedUnitGroup of KG.