December update

PackageInfo.g

@@ -8,7 +8,7 @@ SetPackageInfo( rec(
 
   PackageName := "HAP",
   Subtitle  := "Homological Algebra Programming",
-  Version := "1.66",
+  Version := "1.67",
   Date    := "24/10/2024",
   License := "GPL-2.0-or-later",
 

lib/CohomologyOperations/steenrod.gi

@@ -148,9 +148,15 @@ mx:=ModPRingGenerators(A);;
 mx:=List(mx,A!.degree);;
 mx:=Maximum(mx)+1;
 mx:=Minimum(mx,N);
-if Length(arg)>3 then S:=arg[4]; 
+if Length(arg)>3 then S:=arg[4];                #Should delete this option
 else
-S:=ResolutionGenericGroup(G,mx+2); fi;
+   if IsOddInt(p) then
+         S:=ResolutionGenericGroup(G,mx+2);          #November 2024
+   else
+         if mx<N then S:=R; else
+         S:=ResolutionPrimePowerGroup(G,mx+2); fi;       #Wasteful!
+   fi;
+fi;
 
 x:=(1,2,3,4);;
 x:=[1..p^2];

lib/FpGmodules/fpgbasics.gi

@@ -131,6 +131,7 @@ end);
 InstallGlobalFunction(RadicalOfFpGModule,
 function(M)
 local  G, B, prime, g,radB, gens;
+#WARNING: This will only work forG a p-group
 
 if M!.matrix=[] then return M; fi;
 
@@ -142,9 +143,10 @@ ConvertToMatrixRepNC(B,prime);
 
 radB:=[];
 gens:=GeneratorsOfGroup(SylowSubgroup(G,prime));
-#gens:=ReduceGenerators(gens,G);
+gens:=ReduceGenerators(gens,G);
 
 for g in gens do
+#for g in G do
 Append(radB,SemiEchelonMat(B-M!.action(g,B)).vectors);
 od;
 

lib/Functors/bianchiHomogeneousPolys.gi

@@ -103,11 +103,7 @@ m:=arg[3];
 ispsl:=Name(G){[1,2,3]} = "PSL";
 d:=G!.bianchiInteger;
 
-if d<0 then
-if d mod 4 =1 then R:=Field((1+Sqrt(d))/2); fi;
-if d mod 4 =2 or d mod 4 = 3 then R:=Field(Sqrt(d)); fi;
-fi;
-if d>0 then R:=Field(Sqrt(d)); fi;
+R:=Field(Sqrt(d)); 
 
 x:=Indeterminate(R,1);;
 y:=Indeterminate(R,2);;

lib/Functors/equiChainMap.gi

@@ -22,6 +22,7 @@ QisFinite:=false;
 if IsFinite(S!.group) then
 	if Order(S!.group)=Length(S!.elts) then QisFinite:=true; fi;
 fi;
+#QisFinite:=false;  #November 2024
 if QisFinite then
 	for g in S!.group do
 	if not g in EltsQ then Add(EltsQ,g);fi;
@@ -39,6 +40,7 @@ mapgensRec[m+1][i]:=[];
 od;
 od;
 
+#if false then      
 if QisFinite then
 #####################################################################
 GhomQ:=function(i);

lib/Perturbations/freeRes.gi

@@ -73,8 +73,9 @@ res:=ResolutionAbelianGroup(G,n);
 return res;
 fi;
 if IsAbelian(G) and not bool then   #NOT SURE WHY I NEED TO DO THIS
-
+#if false then
 res:=ResolutionAbelianGroup_alt(G,n);
+
 return res;
 fi;
 ###

lib/Perturbations/resFiniteExt.gi

@@ -25,6 +25,7 @@ G:=R!.group;
 EltsG:=R!.elts;
 E:=Group(GensE);
 EltsE:=Elements(E);
+#EltsE:=Enumerator(E);     #Added November 2024
 
 #####################################################################
 Mult:=function(i,j);

lib/Perturbations/resNormalSer.gi

@@ -16,7 +16,8 @@ local
 
 	############################ INPUT DATA #####################
 if IsGroup(arg[1][1]) then
-GensSeries:=List(arg[1],x->ReduceGenerators(GeneratorsOfGroup(x),x));
+#GensSeries:=List(arg[1],x->ReduceGenerators(GeneratorsOfGroup(x),x));
+GensSeries:=List(arg[1],x->SmallGeneratingSet(x));   #Modified November 2024
 	if Length(GensSeries[Length(GensSeries)])=0 then
 	GensSeries[Length(GensSeries)]:=[Identity(arg[1][1])]; fi;
 else GensSeries:=StructuralCopy(arg[1]);
@@ -57,6 +58,7 @@ if nohomotopy then Res[2]!.homotopy:=fail; fi;
 
 for i in [3..L] do
 Res[i]:=ResolutionFiniteExtension(GensQ[i],GensQ[i-1],Res[i-1],n,tietze);
+Res[i]!.group:=Group(GensQ[i]);  #Added November 2024
 od;
 
 return Res[Length(Res)];

lib/Perturbations/resSubNormSeries.gi

@@ -4,7 +4,7 @@
 InstallGlobalFunction(ResolutionSubnormalSeries,
 function(arg)
 local  
-	L,Ltrunc,K,RN,RQ,N,E,Q,EhomQ,gensE,gensQ;
+	L,Ltrunc,K,RN,RQ,N,E,Q,EhomQ,gensE,gensQ,R;
 
 L:=arg[1];
 K:=arg[2];
@@ -26,9 +26,12 @@ gensE:=GeneratorsOfGroup(E);
 gensQ:=List(gensE,x->Image(EhomQ,x));
 
 RQ:=ResolutionFiniteGroup(gensQ,K);
+RQ!.group:=Q;   #November 2024
 
 
-return ResolutionFiniteExtension(gensE,gensQ,RQ,K,false,RN);
+R:= ResolutionFiniteExtension(gensE,gensQ,RQ,K,false,RN);
+R!.group:=E;   #November 2024
+return R;
 end);
 #####################################################################
 

lib/Resolutions/resBianchi.gi

@@ -11,11 +11,8 @@ Print("PSL(O-d) is implemented for d= \"-26+I\", \"-22+I\", \"-21+I2\", \"-21+I3
 return fail;
 fi;
 
-if IsInt(d) then
+if IsString(d) then d:=EvalString(d); fi;
 name:=Concatenation("SL(2,O", String(d), ")");
-else
-name:=Concatenation("SLO",d,")");
-fi;
 if name="SL(2,O-2)" then 
 K:=ContractibleGcomplex("SL2O-2_a");
 Kgroup:=K!.group; Kgroup!.bianchiInteger:=-2;
@@ -25,13 +22,13 @@ Kgroup:=K!.group;
 fi;
 D:=Group( -Identity(K!.group) );;
 PK:=QuotientOfContractibleGcomplex(K,D);;
+Rgroup:=PK!.group;
+Rgroup!.bianchiInteger:=d;
+PK!.group:=Rgroup;
+
 R:=FreeGResolution(PK,n);
 Rgroup:=R!.group;
-if IsInt(d) then
 Rgroup!.bianchiInteger:=d;
-else
-Rgroup!.bianchiInteger:=fail;
-fi;
 R!.group:=Rgroup;
 
 if not '(' in name then
@@ -50,7 +47,7 @@ end);
 ################################################
 InstallGlobalFunction(ResolutionSL2QuadraticIntegers,
 function(arg)
-local d,n,K, PK, R, S, D, name, ints,x, gens, Q,OQ,I,G,i,k;
+local d,n,K, PK, R, S, D, name, ints,x, gens, Rgroup,Q,OQ,I,G,i,k;
 
 d:=arg[1];
 n:=arg[2];
@@ -76,6 +73,12 @@ fi;
 #K:=QuotientOfContractibleGcomplex(K,D);;
 R:=FreeGResolution(K,n);
 
+Rgroup:=R!.group;
+if IsString(d) then d:=EvalString(d); fi;
+Rgroup!.bianchiInteger:=d;
+R!.group:=Rgroup;
+
+
 if not '(' in name then
 name:=SplitString(name,['O']);
 name:=Concatenation(name[1],"(2,O",name[2],")");