> < ^ Date: Wed, 19 Jul 1995 11:33:00 +0200
> ^ From: Richard Rossmanith <richard@maxp03.mathe.uni-jena.de >
^ Subject: Bug in Gap?

Dear Gap-Forum,

in one of my Gap-Sessions I encountered the following error messages:

---------------------------- Gap-Session: ---------------------------------
                 ########            Lehrstuhl D fuer Mathematik
               ###    ####           RWTH Aachen
              ##         ##
             ##          #             #######            #########
            ##                        #      ##          ## #     ##
            ##           #           #       ##             #      ##
            ####        ##           ##       #             #      ##
             #####     ###           ##      ##             ##    ##
               ######### #            #########             #######
                         #                                  #
                        ##           Version 3              #
                       ###           Release 4              #
                      ## #           18 May 95              #
                     ##  #
                    ##   #  Alice Niemeyer, Werner Nickel,  Martin Schoenert
                   ##    #  Johannes Meier, Alex Wegner,    Thomas Bischops
                  ##     #  Frank Celler,   Juergen Mnich,  Udo Polis
                  ###   ##  Thomas Breuer,  Goetz Pfeiffer, Hans U. Besche
                   ######   Volkmar Felsch, Heiko Theissen, Alexander Hulpke
                            Ansgar Kaup,    Akos Seress,    Erzsebet Horvath
                            Bettina Eick
                            For help enter: ?<return>
Lag: Liealgebren von Gruppenringen ueber dem Koerper F_2
gap> SizeScreen([ 0080, 0044 ]);;
gap> GASMAN("collect");
gap> for i in [2,4,8,16,32,64,128,256] do
>       Print(i,":  ",NilpotenzListe(i),"\n\n");
>    od;
Error, user interrupt at
while not found and i <= Length( path ) + 1 ... in
ReadPath( LIBNAME, name, ".g", "ReadLib" ) called from
ReadLib( "grpprods" ) called from
main loop
brk> quit;
2:  gap>
gap> NilpotenzListe(32);
Syntax error: warning, undefined global variable in /usr/llocal/lib/gap3r4p2/l\
ib/agctbl.g line 74
        InfoCharTable2("by GaloisImage");
                      ^
Syntax error: warning, undefined global variable in /usr/llocal/lib/gap3r4p2/l\
ib/agctbl.g line 80
    InfoCharTable2(Length(T[1])," instead of ",D.conjugacyClasses[r].size);
                  ^
Syntax error: warning, undefined global variable in /usr/llocal/lib/gap3r4p2/l\
ib/agctbl.g line 234
    InfoCharTable1("#I Calculating ElementaryAbelianSeries\n");
                  ^
[ 2, 2, 2, 3, 3, 3, 3, 3, 3, 2, 3, 3, 3, 2, 4, 4, 4, 2, 2, 2, 2, 2, 2, 2, 2,
  2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 2, 2, 2, 2, 2 ]
gap> quit;
------------------- End of Session -------------------------------

My .gaprc consists of the line:

----------------- file .gaprc: --------------------------
Read("/home/malg/richard/gap/Lag");
----------------- End of File ------------------------------

and the file "gap/Lag" has the following content:

------------------------------file gap/Lag:-------------------------------
Print(
"Lag: Liealgebren von Gruppenringen ueber dem Koerper F_2 \n");
########################################################
# programmiert am 5.7.95, modifiziert am 5.7.95 und 17.7.95
# Zum Studium der Liering-Struktur eines Gruppenringes F[g], wobei g eine
# Gruppe und F=F_2=GF(2) der Koerper mit zwei Elementen ist.
# Die Datei besteht aus den Teilen:
# 1. Mengentheoretische Funktionen
# 2. Vektorraumfunktionen
# 3. Gruppenringfunktionen
#
# In Teil 2 werden Vektoren ueber F als Gap-Listen dargestellt: Die Liste
# [x1,...,xn] mit Gap-Objekten x1,...,xn steht hier fuer den Vektor
# x1+...+xn im Vektorraum V=F[m] der formalen Summen ueber F mit Basis m;
# dabei ist m eine Gap-Menge (die x1,...,xn enthaelt). Die Summe zweier
# Vektoren v und w kann also durch die Vereinigung der v und w
# repraesentierenden Listen dargestellt werden, und zwei Vektoren v und w
# sind genau dann gleich, wenn fuer alle x aus m die Haeufigkeit von x in
# v gleich der Haeufigkeit von x in w ist (mod 2). In einer minimalen
# Darstellung eines Vektors tritt also jedes Element hoechstens einmal auf,
# und die Liste kann mit der Gap-Funktion Set() geordnet werden, so dass
# wir eine kanonische Darstellung erhalten (mit der zwei Vektoren leicht
# auf Gleichheit untersucht werden koennen). Es stehen Funktionen zur
# kanonischen Darstellung und Summenbildung zur Verfuegung (siehe
# Programmcode).
#
# Ist m=g eine Gruppe in Gap, so ist F[g]=F[m]=V eine Gruppenalgebra und
# die Funktionen aus Teil 3 koennen angewendet werden (Multiplikation von
# Vektoren, Lieklammern, etc. Siehe im Programmcode unten).

#
# Teil 1: Mengen- und gruppentheoretische Funktionen und sonstige Funktionen.
# Definiert die Funktionen Println, Vereinigung, Abelix, HatAbelix2
# und NilpotenzKlasse.
#

Println:= function(a)
  Print(a,"\n");
end;


Vereinigung:=function(ls) # Eingabe: Eine GAP-Liste ls von GAP-Mengen
  local m,v;              # Ausgabe: Die Vereinigungsmenge der Mengen aus ls
  v:=[];
  for m in ls do
    UniteSet(v,m);
  od;
  return v;
end;


Abelix := function(g,i)
  local cs, kc, k, a;
  Print("Abelsche Untergruppen vom Index ", i, ":");
  a:=0;
  cs:=ConjugacyClassesSubgroups(g);
  for kc in cs do
    k:=Representative(kc);
    if Index(g,k)=i then
      if IsAbelian(k) then
        Print("\n", k);
        a:=1;
      fi;
    fi;
  od;
  if a=0 then
    Print(" Keine.");
  fi;
  Print("\n");
end;

HatAbelix2:= function(g)
local kkm, k, h;
kkm:=ConjugacyClassesMaximalSubgroups(g);
for k in kkm do
h:=Representative(k);
if Index(g,h)=2 and IsAbelian(h) then
return true;
fi;
od;
return false;
end;

NilpotenzKlasse:= function(g)
if IsNilpotent(g) then
return Length(LowerCentralSeries(g))-1;
else
return "infinity";
fi;
end;

#
# Teil 2: Vektorraumfunktionen. Definiert die Funktionen Kanonisch, Summe,
# Basis und ImAufspann.
#

Kanonisch:=function(c)    # Berechnet die kanonische Darstellung
                          # eines Vektors.
  local i,ii,j,n,innen;   # Eingabe: Vektor c (als Gap-Liste),
                          # Ausgabe: gleicher Vektor in kanonischer
                          #          Darstellung (als Gap-Menge)
  innen:=function()
    for j in [i+1..n] do  # Hilfsfunktion: innere Schleife (s.u.)
      if c[i]=c[j] then
        Unbind(ii[i]);    # Loeschen der doppelten Eintraege
        Unbind(ii[j]);    # aus der Indexmenge
        return;           # Abbruch der inneren Schleife
      fi;
    od;
  end;                    # Ende innere Schleife
  n:=Length(c);
  ii:=[1..n];             # Indexmenge der Liste
  for i in ii do          # aeussere Schleife
    innen();                # innere Schleife
  od;
  return Set(c{Set(ii)}); # Umwandlung von c in kanonische Form
end;


Summe:=function(a,b)   # Berechnet die Summe zweier Vektoren
  local c;             # Eingabe: Vektoren a und b
  c:=[];               # Ausgabe: Vektor a+b in kanonischer Form
  Append(c,a);
  Append(c,b);         # c:= Haenge Liste b hinter Liste a
  return Kanonisch(c); # Ausgabe des Ergebnisses in kanonischer Form.
end;


Basis:=function(y)               # Berechnet eine Basis eines Aufspanns
  local x,b,v,ii,i,jj,innen;     # von Vektoren mit dem Gauss-Algorithmus.
                                 # Eingabe: Eine Liste y=[y1,y2...] von
                                 #          Vektoren.
                                 # Ausgabe: Eine Liste von Basisvektoren
                                 #          fuer den Aufspann von y.
  innen:=function()
    local j,k;                   # Hilfsfunktion: Bearbeite Spalte i
    for j in jj do               # Durchlaufe alle Zeilen/Vektoren
      if v[i] in x[j] then       # Nichttriv. Eintrag in Spalte i gefunden
        Add(b,x[j]);             # Nimm entspr. Vektor in Basis auf
        Unbind(jj[j]);           # Loesche Zeile aus Indexliste
        for k in jj do           # Untersuche alle anderen Zeilen
          if v[i] in x[k] then   # Mache Eintrag i aller anderen Zeilen...
            x[k]:=Summe(x[k],x[j]);  # zu Null.
            if x[k]=[] then
              Unbind(jj[k]);     # Loesche Nullzeilen aus Indexliste
            fi;
          fi;
        od;
        return;                  # Abbruch um naechste Spalte zu bearbeiten
      fi;
    od;
  end;

  x:=[];                         # x: Arbeitskopie von y
  for i in y do                  # Kanonische Darstellung der
    i:=Kanonisch(i);             # Vektoren aus y und
    if i<>[] then                # Streichen von Nullvektoren;
      Add(x,i);                  # Ablage des Ergebnisses in x.
    fi;
  od;
  b:=[];                         # leere Basisliste zu Beginn
  v:=Vereinigung(x);             # v: Liste der "Spalten" fuer den Gauss-Alg.
  ii:=[1..Length(v)];            # ii: Indexmenge fuer Spalten
  jj:=[1..Length(x)];            # jj: Indexmenge fuer Zeilen (=Vektoren)
  for i in ii do                 # Fuer jede "Spalte" i
    innen();                     # durchlaufe die innere Schleife (s.o.)
  od;
  return b;
end;


ImAufspann:=function(e,v)   # Testet, ob ein Vektor v im Aufspann
                            # einer Liste e anderer Vektoren liegt
  local b,c;                # Eingabe: e Liste von Vektoren, v Vektor
  b:=Basis(e);              # Ausgabe: true/false
  c:=Copy(b);
  Add(c,v);
  if Length(b)=Length(Basis(c)) then
    return true;
  else
    return false;
  fi;
end;

#
# Teil 3: Gruppenringfunktionen. Definiert die Funktionen Produkt, Lie,
# FG1 und FG2.
#

Produkt:=function(a,b) # Berechnet das Produkt a*b im Gruppenring.
  local c,h;
  c:=[];
  for h in b do        # Mit Distributivgesetz: c:= (a1+..+an)*(b1+..+br) =
    c:=Summe(c,a*h);   # = (a1+..+an)*b1 +...+ (a1+..+an)*br.
  od;
  return c;            # c kommt aus Summe, hat also kanonische Form.
end;


Lie:=function(a,b) # Berechnet die Lie-Klammer Lie(a,b):= a*b+b*a
                   # fuer Gruppenringelemente a und b.
  return(Summe(Produkt(a,b),Produkt(b,a)));
end;

Zentrum:=function(g) # Berechnet das Zentrum einer Gruppenalgebra
                     # Eingabe: g Gruppe
                     # Ausgabe: Basis von ZF[g] (Liste von Vektoren)
  return List(ConjugacyClasses(g),Elements);
end;                 # Liste der Elementlisten der Konjugationsklassen:
                     # Elementlisten der Konj.kln. =
                     #  = Klassensummen = Basisvektoren von ZF[g]


paar1i:=function(ls) # Hilfsfunktion fuer FG1 und FG2:
  local paare,i;     # Berechnet alle Paare der Form [ ls[1],ls[i] ]
  paare:=[];         # (i=2,3,..) von Listenelementen einer Liste ls
  for i in [2..Length(ls)] do    # (entspricht den Vektoren ls[1]+ls[i])
    Add(paare,[ ls[1],ls[i] ]);  # Eingabe: Liste ls
  od;                            # Ausgabe: Liste der Paare
  return paare;
end;


FG1:=function(g)  # Berechnet eine Basis von F[g]';
                  # Eingabe: g Gruppe
                  # Ausgabe: Liste von Basisvektoren
  local b,kk,k,ke,u,v;
  b:=[];          # Lie-Kommutatoren von Gruppenelementen
  kk:=ConjugacyClasses(g);
  for k in kk do  # sind von der Form h+x mit konjugierten
    Append(b,paar1i(Elements(k)));
  od;             # Elem. h und x. Fuer jede Konjugationsklasse wird eine
  return(b);      # Liste der resultierenden Kommutatoren erzeugt;
end;              # anschliessend werden alle solche Listen vereinigt.

FG2:=function(g)
# wie FG1, nur fuer F[g]".
# Eingabe: g Gruppe
# Ausgabe: Eine Liste [b2, b2h] mit 2 Eintraegen:
# * b2 ist eine Liste, die Vektoren enthaelt, welche F[g]"
# aufspannen. (Wie ueblich sind diese Vektoren auch GAP-Listen).
# Diese Vektoren sind moeglicherweise nicht linear unabhaengig (im
# Gegensatz zur Ausgabe der Funktion FG1).
# * b2h ist eine Liste, die fuer jeden Eintrag x in b1 an der
# gleichen Position wie x eine zweielementige Liste [y,z] mit
# wie in FG1 berechneten Basisvektoren y und z von F[g]' enthaelt,
# so dass x = Lie(y,z) ist. Die urspruenglichen Gruppenelemente
# sind dabei leicht zu konstruieren, da y (bzw. z) stets die
# Gestalt y=u+v (=[u,v] als GAP-Liste) mit konjugierten Elementen
# u und v von g hat.
# Bemerkung: Zwischenergebnisse werden schon vor dem Ende des
# Funktionsaufrufs auf dem Bildschirm ausgedruckt.

local b1,b2,b2h,kk,k,n,t,i,j;

Print("Funktion FG2:\n");
Print("Berechne Konjugationsklassen...\n");
kk:=ConjugacyClasses(g);
Print("fertig: ",Length(kk)," Stueck.\n");
Print("Beginne ersten Schritt...\n");

  b1:=[];                    # ERSTER SCHRITT: Berechnung derselben Liste
  for k in kk do             # wie in FG1, ausser zentrale Elemente.
    if Size(k)>2 then        # Ignoriere zu kleine Konjugationsklassen,
      Append(b1, paar1i(Elements(k)));  # denn Kln.summen sind zentral.
    fi;
  od;
  n:=Length(b1);             # Ende Erster Schritt
  Print("fertig: ",n," Elemente.\n");
  Print("Berechne jetzt ",n*(n-1)/2," Kombinationen in ",n-1," Schleifen.\n");
  b2:=[];
  b2h:=[];
  for i in [1..n-1] do
    Print(i,"\n");           # Lebenszeichen
    for j in [i+1..n] do
      t:=Lie(b1[i],b1[j]);   # Berechnen aller Lieklammern von b1[i] mit
      if t<>[] then          # b1[j], wobei 1 <= i < j <= n
        Add(b2,t);           # Speichern der nichttrivialen Ergebnisse
        Add(b2h,[b1[i],b1[j]]);
        Print("Lie( ",b1[i]," , ",b1[j]," ) = ",t,"\n");
      fi;                    # Bildschirmausgabe vor Programmende
    od;
  od;
  Print("Ende FG2\n\n");
  return [b2,b2h];
end;


IstZentral:= function(g,x)  # Testet ob der Vektor x im Zentrum der
                            # Gruppenalgebra ist.
                            # Eingabe: g Gruppe, x Vektor der
                            #          Gruppenalgebra
                            # Ausgabe: true/false
  local xi, ks;
  for xi in x do
    ks:= Orbit(g,xi);       # Klassensumme der xi enthaltenden Konj.klasse
    if not Length(Summe(x,ks)) = Length(x)-Length(ks) then
      return false;         # Falls fuer einen Summanden von x nicht die
    fi;                     # gesamte Klassensumme in x ist, ist x nicht
  od;                       # zentral.
  return true;              # Andernfalls schon.
end;

IstLZMi:=function(g)
# Testet, ob F[g] Lie-zentral-metabelsch (LZM) ist. Struktur aehnlich FG2.
# Das kleine "i" bedeutet, dass waehrend des Programmlaufs Meldungen auf dem
# Bildschirm ausgegeben werden. Eine "stille" Variante ist "IstLZM" unten.
# Eingabe: g Gruppe
# Ausgabe: true/false
# Bemerkung: Wie in FG2 wird eine Basis von F[g]" berechnet; fuer jedes
# berechnete Basiselement wird sofort getestet, ob es zentral
# ist. Falls nicht, wird es in aehnlicher Form wie in FG2 auf
# dem Bildschirm mit dem Vermerk "nicht zentral" ausgegeben
# (zentrale Basiselemente werden ohne Vermerk auf dem Bildschirm
# ausgedruckt) und die Funktion mit dem return-Wert false
# beendet. Andernfalls werden alle Schleifen bis zum Ende
# durchlaufen und true ausgegeben.

local b1,b2,b2h,kk,k,n,t,i,j;

Print("Funktion IstLZM:\n");
Print("Berechne Konjugationsklassen...\n");
kk:=ConjugacyClasses(g);
Print("fertig: ",Length(kk)," Stueck.\n");
Print("Beginne ersten Schritt...\n");

  b1:=[];                    # ERSTER SCHRITT: Berechnung derselben Liste
  for k in kk do             # wie in FG1, ausser zentrale Elemente.
    if Size(k)>2 then        # Ignoriere zu kleine Konjugationsklassen,
      Append(b1, paar1i(Elements(k)));  # denn Kln.summen sind zentral.
    fi;
  od;
  n:=Length(b1);             # Ende Erster Schritt
  Print("fertig: ",n," Elemente.\n");
  Print("Berechne jetzt ",n*(n-1)/2," Kombinationen in bis zu ",n-1,"
Schleifen.\n");
  b2:=[];
  b2h:=[];
  for i in [1..n-1] do
    Print(i,"\n");           # Lebenszeichen
    for j in [i+1..n] do
      t:=Lie(b1[i],b1[j]);
      if not IstZentral(g,t) then
        Print("** nicht zentral: **\n");
        Print("Lie( ",b1[i]," , ",b1[j]," ) = ",t,"\n");
        Print("Ende IstLZM\n\n");
        return false;        # Bildsch.ausg. der nicht-zentralen Elemente
      fi;
    od;
  od;
  Print("Ende IstLZM\n\n");
  return true;
end;

IstLZM:=function(g)
# Wie IstLZMi, nur ohne Bildschirmausdruck

  local b1,b2,b2h,kk,k,n,t,i,j;
  kk:=ConjugacyClasses(g);
  b1:=[];                    # ERSTER SCHRITT: Berechnung derselben Liste
  for k in kk do             # wie in FG1, ausser zentrale Elemente.
    if Size(k)>2 then        # Ignoriere zu kleine Konjugationsklassen,
      Append(b1, paar1i(Elements(k)));  # denn Kln.summen sind zentral.
    fi;
  od;
  n:=Length(b1);             # Ende Erster Schritt
  b2:=[];
  b2h:=[];
  for i in [1..n-1] do
    for j in [i+1..n] do
      t:=Lie(b1[i],b1[j]);
      if not IstZentral(g,t) then
        return false;        # Bildsch.ausg. der nicht-zentralen Elemente
      fi;
    od;
  od;
  return true;
end;


IstGgbsp:= function(g)
  local h;
  h:=DerivedSubgroup(g);
  if (Size(h) in [1,2,4])
  or (NilpotenzKlasse(g)=2 and Size(h)=8 and Exponent(h)=2)
  or (not IstLZM(g))
  or HatAbelix2(g) then
    return false;
  else
    return true;
  fi;
end;


Katalogi:= function(i)
  local ls, g, h, n, j, ausgabe;
  ausgabe:=[];
  ls:=AllTwoGroups(Size, i, IsAbelian, false);
  n:=Length(ls);
  Print(i, ": 1...", n, "\n");
  for j in [1..n] do
    Print("  :",j,"\n");
    g:=ls[j];
    if IstGgbsp(g) then
      Add(ausgabe, j);
      Print(g,"\n Size: ", Size(g), ", Nummer: ", i,":", j, "\n");
      h:=DerivedSubgroup(g);
      Print("Ableitung: ", h, "\n");
      Print("Size: ", Size(h), ", Exponent: ", Exponent(h), "\n");
    fi;
  od;
  return ausgabe;
end;


Katalog:= function(i)
  local ls, j, ausgabe;
  ausgabe:=[];
  ls:=AllTwoGroups(Size, i, IsAbelian, false);
  for j in [1..Length(ls)] do
    if IstGgbsp(ls[j]) then
      Add(ausgabe, j);
    fi;
  od;
  return ausgabe;
end;

NilpotenzListe:= function(i)
local ls, g, ausgabe;
ausgabe:=[];
ls:=AllTwoGroups(Size, i, IsAbelian, false);
for g in ls do
if IstLZM(g) then
Add(ausgabe, NilpotenzKlasse(g));
fi;
od;
return ausgabe;
end;

------------------- End of File ---------------------------------

Maybe the error messages are due to some "bug". I am working on a digital Alpha
Station 250 4/266 under digital UNIX 3.2.

Regards,

Richard Rossmanith


> < [top]