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