Compute2 Source Code

Read("modatlasgroups"); #reads in modatlasgroupsstring
Read("ReadAlgebras"); #read in algebra lists

# Missing L2(25) and L3(9)
Remove(modatlasgroupsstring, 46);
Remove(modatlasgroupsstring, 13);

#############################################################################
#
#F  Function compute2(  )
#
# <#GAPDoc Label="compute2Header">
#   
#     
#     
#
#     
#      file(s) containing the computed socle and radical series
#               for the given algebra records.
#     
#     compute2 uses function srCheckBasicAlgebra
#                  from GAPssrsCheck, computes one after another, the 
#                  socle and radical series for the read in algebras.
#     
#   
# <#/GAPDoc>
#
# METHOD: Run through list of filenames, read in algebra record,
#         compute socle and radical series, then print to file.
#
#############################################################################

compute2 := function(index, filenames, pathname)
  local x,y, path, algRec, alglist;
  path := pathname;
  y := index;
  if y = 0 then;
  else
    alglist:= algebraList[y];
    filenames:= algebraNames[y];
    for x in [1..Length(alglist)] do
      # Create path name for the algebra record
      # Example: string:= "/scratch/rbaumann/basicAlgebras/basicalgebras";
      path := Concatenation(path, algebraStrings[y]);
      path := Concatenation(path, alglist[x]);
      # Read in algebra record
      algRec:=ReadAlgebraRecord(path);
      # Compute the socle and radical series in listPIMs
      srCheckBasicAlgebra(algRec, algRec.group, algRec.prime);
      # Print the computed socle and radical series to file
      PrintTo(filenames[x], "list:=");
      AppendTo(filenames[x], listPIMs);
      AppendTo(filenames[x], ";");
    od;
  fi;
end;


#############################################################################
#
#F  Function compute22(  )
#
# <#GAPDoc Label="compute22Header">
#   
#     
#     
#
#     
#      file(s) containing the computed socle and radical series
#               for the given algebra records.
#     
#     compute22 uses function srCheckBasicAlgebra
#                  from GAPssrsCheck, computes one after another, the 
#                  socle and radical series for the read in algebras.
#     
#   
# <#/GAPDoc>
#
# METHOD: Run through list of filenames, read in algebra record,
#         compute socle and radical series, then print to file.
#
#############################################################################

compute22 := function(algebraList, pathname)
  local x, path, algRec, name;
  path := pathname;
    for x in [1..Length(algebraList)] do
      # Create path name for the algebra record
      # Example: path:= "/scratch/rbaumann/basicAlgebras/basicalgebras.aldebaran/";
      path := Concatenation(path, algebraList[x]);
      # Read in algebra record
      algRec:=ReadAlgebraRecord(path);
      # Compute the socle and radical series in listPIMs
      srCheckBasicAlgebra(algRec, algRec.group, algRec.prime);
      name := Concatenation(Concatenation(algRec.group, "p"), String(algRec.prime));
      # Add algebra name to list of ones computed
      Add(computedNames, name);
      # Print the computed socle and radical series to file
      PrintTo(name, "list:=");
      AppendTo(name, listPIMs);
      AppendTo(name, ";");
    od;
end;


# Global list of algebra records and factors
groupOrders:=[];

#############################################################################
#
#F  Function algebraPrimes(  )
#
# <#GAPDoc Label="algebraPrimesHeader">
#   
#     
#     
#
#     
#      list of algebras with corresponding list of factors.
#     
#     algebraPrimes computes factors of gorup order.
#     
#   
# <#/GAPDoc>
#
# METHOD: Create group, factor order to get factors.
#
#############################################################################

algebraPrimes := function()
  local x, string, algRec, groupRec, group, factors;
  groupOrders:=[];
  for x in [1..Length(modatlasgroupsstring)] do
      group := AtlasGroup(modatlasgroupsstring[x]);
      factors:= PrimeDivisors(Size(group));
      groupRec:= rec(group := modatlasgroupsstring[x], factors:= factors);
      Add(groupOrders, groupRec);
    od;
end;


path:=""; string:="";

#############################################################################
#
#F  Function computeAlgebras(  )
#
# <#GAPDoc Label="computeAlgebrasHeader">
#   
#     
#     
#
#     
#      file(s) containing the computed basic algebra for specified
#               group in specified characteristic. Written to set folder.
#     
#     computeAlgebras uses function AutoCalcBasic
#                  to compute the basic algebra. 
#     
#   
# <#/GAPDoc>
#
# METHOD: Run through list of groups and characteristics, compute basic
#         algebras using AutoCalcBasic and write algebras to file.
#
#############################################################################

computeAlgebras := function( groupRec, groupNames)
  local i,j, algebra, path1;
  # path to put files of algebra records
  path:="/u4/rbaumann/gap/Fixed/AlgebraRecords/";
  for i in [1..Length(groupRec)] do
    for j in [1..Length(groupRec[i].factors)] do
      # Initialize algebra
      algebra:=InitializeRecordAtlasGroup(groupRec[i].group, groupRec[i].factors[j], 1);
      # Run AutoCalcBasic
      AutoCalcBasic(algebra);
      string := Concatenation(Concatenation(Concatenation(groupNames[i], "p"), String(groupRec[i].factors[j])), "b1basicalg.gap");
      path1:= Concatenation(path, string);
      WriteAlgebraRecord( algebra, path1);
    od;
  od; 
end;