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