The following code is meant for GAP and uses the AtlasRep package in GAP. Note that in order for the following programs to work in GAP, a package called "basic'" is needed. 


#The program AbsIrredReps takes in two parameters. The first parameter is a string corresponding to a group in the AtlasRep package. The second parameter is the (positive) characteristic. AbsIrredReps takes the list of representations in the AtlasRep, removes all the representations that are not absolutely reducible, and returns the remaining list (a list of all the absolutely irreducible representations stored in the Atlas).

AbsIrredReps:= function(gapname,p)
local gp, i, k, m, rep, reps, list;
gp := AllAtlasGeneratingSetInfos(gapname);
list := [];
reps := AllAtlasGeneratingSetInfos(gapname,Characteristic,p);
k := Length(reps);
for i in [1..k] do
    rep := AtlasGenerators(gp[reps[i].repnr].identifier);
    m := GModuleByMats(rep.generators,rep.ring);
    if MTX.IsAbsolutelyIrreducible(m) then
        Add(list, reps[i]);
    fi;
od;
return list;
end;


#The program IrrChar takes in three parameters. The first parameter is a string corresponding to a group in the AtlasRep package. The second parameter is the (positive) characteristic. The third parameter is a number corresponding to a specific representation in the AtlasRep. The output is the Atlas character name of the representation (as a string).

IrrChar := function(g,p,n)
local gp, a, b, c, d, traces, ct, pos;
gp := AllAtlasGeneratingSetInfos(g);
a := AtlasStraightLineProgram(g,"classes");
    if a = fail then
        a := LocalClasses(g);
            if a = fail then
                return fail;
                fi;
    fi;
b := AtlasGenerators(gp[n].identifier);
c := ResultOfStraightLineProgram(a.program, b.generators);
d := Filtered(c, x -> Order(x) mod p > 0);
traces := List(d, x -> BrauerCharacterValue(x));
ct := CharacterTable(g) mod p;
pos := Position(Irr(ct), traces);
    if pos = fail then 
        return fail;
        else
        return AtlasCharacterNames(ct)[pos];
    fi;
end;


#The program charreps takes in two parameters. The first parameter is a string corresponding to a group in the AtlasRep package. The second parameter is the (positive) characteristic. The output is a list of numbers of which characters in the character table have representations in the AtlasRep. 

charreps := function(G, p)
local charnames, chars, i;
charnames := [];
chars := AbsIrredReps(G,p);
for i in [1..Size(chars)] do
    if IsBound(chars[i].charactername) = true then
        Add(charnames, chars[i].charactername);
    else 
        Add(charnames, IrrChar(G, p, chars[i].repnr));
    fi;
od;
return charnames;
end;


#The program gapchars takes in two parameters. The first parameter is a string corresponding to a group in the AtlasRep package. The second parameter is the (positive) characteristic. The output is a list of numbers which indicate which characters have corresponding representations stored in the AtlasRep package. 

gapchars := function(G,p)
local nums, names, ct,i;
nums := [];
names := charreps(G,p);
ct := CharacterTable(G) mod p;
for i in [1..Size(names)] do
    Add(nums, Position(AtlasCharacterNames(ct),names[i]));
od;
return nums;
end;


#The program incompletechars takes in two parameters. The first parameter is a string corresponding to a group in the AtlasRep package. The second parameter is the (positive) characteristic. The output is a list of numbers which correspond to the characters in the character table which do not have corresponding representations in the AtlasRep.

incompletechars := function(G,p)
local completechars,ct,ichars,i;
completechars := [1];
Append(completechars, gapchars(G,p));
ct:= CharacterTable(G) mod p;
ichars :=[];
for i in [1..Size(Irr(ct))] do
    if Position(completechars, i) = fail then
        Add(ichars, i);
    fi;
od;
return ichars;
end;


#The program finishgroup takes in one parameter, a string corresponding to a group in the AtlasRep package. The program prints out whether the group has representations for all prime characteristics dividing the order of the group. If the group is missing certain characteristics, it prints a list of these characteristics. The program also prints out which characteristics do not have any matrix representations stored in the AtlasRep.

finishgroup := function(g)
local l, i, p, primes, m,j,none;
l := Collected(Factors(Size(CharacterTable(g))));
primes := [];
m := [];
    for i in [1..Length(l)] do
        p := l[i][1];
        if Length(incompletechars(g,p)) >0 then
            Add(primes,p);
        fi;
    od;
if primes = [] then
    Print(g);
    Print(" has all representations for all primes dividing the order.");
    else
        Print(g);
        Print(" needs representations for ");
        Print(primes);
        none := [];
        for j in primes do
            if AbsIrredReps(g,j) = [] then
                Add(none,j);
            fi;
        od;
        if Length(none) >0 then
            Print(" but the group has no representations 
            in the Atlas for ");
            Print(none);
        fi;
fi;
end;


#The program smallest takes in three parameters. The first parameter is a string corresponding to a group in the AtlasRep package. The second parameter is the (positive) characteristic. The third parameter is a list in the form [n, [k_1, k_2], [k_3,k_4], \dots, [k_{r}, k_{r+1}] where n is a number corresponding to a specific representation in the AtlasRep and each [k_i, k_{i+1}] is a pair of numbers corresponding to specific representations in the AtlasRep and the representation corresponding to n is a constituent of the tensor of the representations corresponding to k_i and k_{i+1}. The output is a list in the form [n, [k_i, k_{i+1}]] where [k_i, k_{i+1}] is the smallest dimensional tensor in the list. 

smallest:= function(G,p,l)
local ct, irr, list, small, sc, nc, i;
ct := CharacterTable(G) mod p;
irr := Irr(ct);
list := l;
if Length(l)>1 then
    small := l[2];
    for i in [2..Length(l)] do
        sc := Tensored([irr[small[1]]],[irr[small[2]]]);
        nc := Tensored([irr[l[i][1]]],[irr[l[i][2]]]);
        if nc[1][1] < sc[1][1] then
            small := l[i];
        fi;
        od;
    list := [l[1],[AtlasCharacterNames(ct)[small[1]],
    AtlasCharacterNames(ct)[small[2]]]];
fi;
return list;
end;


#The program bplan takes in three parameters. The first parameter is a string corresponding to a group in the AtlasRep package. The second parameter is the (positive) characteristic. The third parameter is a list of numbers corresponding to the characters in the character table which have associated representations in the AtlasRep. The output is a list in the form [[n_1, [k_1, k_2]], [n_2, [k_3, k_4]], \dots where n_i is a number corresponding to the representations characters in the character table, all k_i are strings of Atlas character names, and [k_i, k_{i+1}] corresponds to the smallest tensor (using representations in the list) of which the associated n_i is a constituent. 

bplan := function(G, p, l)
local ct, irr, list, listb, tensor, decomp, i, j, k, m, n;
ct := CharacterTable(G) mod p;
irr := Irr(ct);
list := [];
listb := [];
for k in [1..Size(Irr(ct))] do
    Add(listb,[k]);
od;
for i in l do
    for j in l do
    if j>i-1 then
        tensor := Tensored([irr[i]],[irr[j]]);
        decomp := Decomposition(irr, tensor, 5);
        for n in [2..Size(Irr(ct))] do
            if n in l then
                listb:= listb;
                else if decomp[1][n] > 0 then
                    Add(listb[n],[i,j]);
                fi;
            fi;			
        od;
    fi;
    od;
od;
for m in [1..Length(listb)] do
    Add(list,smallest(G,p,listb[m]));
od;
return list;
end;


#The program newlist takes in three parameters. The first parameter is a string corresponding to a group in the AtlasRep package. The second parameter is the (positive) characteristic. The third parameter is a list of numbers corresponding to characters with associated representations in the AtlasRep. The output is a list of numbers corresponding to characters in the character table which can be built by tensoring characters from the original list. Note that this program does not record how to build these new representations, just which ones can be built. 

newlist:= function(G,p,l)
local list,blist,i;
list := l;
blist := bplan(G,p,l);
for i in [1..Length(blist)] do
    if Length(blist[i])> 1 then
        Add(list, blist[i][1]);
    fi;
od;
return list;
end;


#The program nplan takes in two parameters. The first parameter is a string corresponding to a group in the AtlasRep package. The second parameter is the (positive) characteristic. The output is a list in the form [[n_1, [k_1, k_2]], [n_2, [k_3, k_4]], \dots where n_i is a number corresponding to the representations characters in the character table, all k_i are strings of Atlas character names, and [k_i, k_{i+1}] corresponds to the smallest tensor (using representations in the list) of which the associated n_i is a constituent. 
Input: group, prime. Recursively does bplan until you construct all the characters. Returns list of lists. Output i the form [...,n,[a,b],..] where n is the number (in the character table) of the character you don't have a rep for and a and b are the Atlas names of the reps you should tensor to get n. This program recursively does bplan until all characters have been constructed. 

nplan:= function(G,p)
local l,ct,irr,blist,list,i;
l:= gapchars(G,p);
ct := CharacterTable(G) mod p;
irr := Irr(ct);
list := [];
while Length(l)< Size(irr)-1 do
    blist := bplan(G,p,l);
    for i in [1..Length(blist)] do
        if Length(blist[i])>1  then
            Append(list,blist[i]);
        fi;
    od;
    l := newlist(G,p,l);
od;
return list;
end;


#The program buildrep takes in three parameters. The first parameter is a string corresponding to a group in the AtlasRep package. The second parameter is a number corresponding to a representation in the AtlasRep. The third parameter is the field you wish to build the representation over. buildrep creates the GModule representation from the generating information stored in the AtlasRep.

buildrep := function(g,n,field)
local gp,rep,m;
gp := AllAtlasGeneratingSetInfos(g);
rep := AtlasGenerators(gp[n].identifier);
m := GModuleByMats(rep.generators, field);
return m;
end;


#The program charval takes in three parameters. The first parameter is a string corresponding to a group in the AtlasRep package. The second parameter is a number corresponding to a representation in the AtlasRep. The third parameter is the generators for the GModule representation. The output is the character of the representation (as a list of values). 

charval := function(g,p,gens)
local a,c,d,traces;
a:= AtlasStraightLineProgram(g,"classes");
    if a = fail then
        a := LocalClasses(g);
            if a = fail then
                return fail;
            fi;
    fi;
c:= ResultOfStraightLineProgram(a.program,gens);
d:= Filtered(c, x -> Order(x) mod p > 0);
traces:= List(d, x -> BrauerCharacterValue(x));
return traces;
end;


#The program minfield takes in two parameters. The first parameter is a string corresponding to a group in the AtlasRep package. The second parameter is the (positive) characteristic. The output is the smallest field that all of the representations (for the given group and characteristic) can be realized over. 

minfield := function(G,p)
local list, fields, ct, irr, l, i, j;
list := [];
fields := [];
ct := CharacterTable(G) mod p;
irr := Irr(ct);
l := [1..Size(irr)];
for i in l do
    Add(list, List(irr[i],x->FrobeniusCharacterValue(x,p)));
od;
for j in [1..Length(l)] do
    Add(fields, Field(list[j]));
od;
return Maximum(fields);
end;


#The program namechars takes in two parameters. The first parameter is a string corresponding to a group in the AtlasRep package. The second parameter is the (positive) characteristic. The output is a list of the Atlas character names (as a string) of the irreducible representations for the given group and characteristic. 

namechars := function(G,p)
local abs, names, i;
abs := AbsIrredReps(G,p);
names := [];
for i in [1..Length(abs)] do
    if IsBound(abs[i].charactername) = true then
        Add(names, abs[i].charactername);
    else 
        Add(names, IrrChar(G,p,abs[i].repnr));
    fi;
od;
return names;
end;


#The program elrep takes in three parameters. The first parameter is a string corresponding to a group in the AtlasRep package. The second parameter is the (positive) characteristic. The third parameter is a list of two strings. The strings are the Atlas character names of the characters corresponding to two representations you want to tensor. Note that the AtlasRep must have representations corresponding to these two characters in order for the program to function properly. The output is a list where all the odd entries are numbers corresponding to the characters of the representations that the program built and all the even entries are the generating matrices for the representation. 

elrep := function(G,p,rl)
local field, ic, ct, irr, abs, j, names, i, r, s, rep1, rep2, tensor, 
factors, k, num, brep;
field := minfield(G,p);
ic := incompletechars(G,p);
ct := CharacterTable(G) mod p;
irr := Irr(ct);
abs := AbsIrredReps(G,p);
names := [];
brep := [];
for i in [1..Length(abs)] do
    if IsBound(abs[i].charactername) = true then
        Add(names, abs[i].charactername);
    else 
        Add(names, IrrChar(G,p,abs[i].repnr));
    fi;
od;
    r := Position(names, rl[1]);
    s := Position(names, rl[2]);
    rep1 := buildrep(G,abs[r].repnr,field);
    rep2 := buildrep(G,abs[s].repnr,field);
    tensor := TensorProductGModule(rep1,rep2);
    factors := MTX.CollectedFactors(tensor);
    for k in [1..Length(factors)] do
        num := Position(irr, charval(G,p,factors[k][1].generators));
        for j in ic do
            if num = j then
                Append(brep,[j,factors[k][1]]);
            fi;
        od;
    od;
return brep;
end;


 Once representations are created, the following programs can be used to store the representations into a private database:

#The program StoreRep takes in six parameters. The first parameter is a string corresponding to a group in the AtlasRep package. The second parameter is a string of the directory name. The third parameter is the (positive) characteristic. The fourth parameter is a list of the generating matrices for the representation you wish to store. The fifth parameter is a string of a single letter corresponding to the letter in the Atlas character name of the character of the representation. The sixth parameter is a number which corresponds to the character of the represenetation. The program has no output, but it creates a file in the directory with the generating matrices for the representation. 

StoreRep := function(G,g,p,rep,a,n)
local prv, q, name, gens, i, rng, cn, char;
prv := Directory(g);
q:= "\"";
name := Concatenation([g,"G1-f",String(Size(rep.field)),"r",String(rep.dimension),a,"B0"]);
gens := rep.generators;
	for i in [1..Size(gens)] do
	FileString(Filename(prv,Concatenation([name,".m",String(i)])),MeatAxeString(gens[i],Size(rep.field)));
	od;
rng:= Concatenation(["AGR.RNG","\(",q,name,q,",",q,String(rep.field),q,"\)",";\n"]);
cn := Concatenation([String(rep.dimension),a]);
char := Concatenation(["AGR.CHAR","\(",q,G,q,",",q,name,q,",",String(p),",",String(n),",",q,cn,q,"\);\n"]);
AppendTo(Concatenation(g,"/toc.g"),Concatenation([rng,char]));
end;

#The program StoreRepe takes in five parameters. The first parameter is a string corresponding to a group in the AtlasRep package. The second parameter is a string of the directory name. The third parameter is the (positive) characteristic. The fourth parameter is a list where the odd entries are numbers (corresponding to character of the representation) and the even entries are a list of the generating matrices for a representation you wish to store. The fifth parameter is a list of strings, each string a single letter corresponding to the letter in the Atlas character name of the character of the representation. The program has no output, but it creates a file in the directory with the generating matrices for the representations. 

StoreRepe := function(G,g,p,rl,list2)
local i,rep;
for i in [1..Size(rl)/2] do
    rep := rl[2*i];
    StoreRep(G,g,p,rep,list2[rl[2*i-1]],rl[2*i-1]);
od;
end;


#The program StoreChar takes in five parameters. The first parameter is a string corresponding to a group in the AtlasRep package. The second parameter is a string of the directory name. The third parameter is the (positive) characteristic. The fourth parameter is a number which corresponds to the dimension of the representation. The fifth parameter is a number which corresponds to the character in the character table. The program has no output, but it stores the character name of an existing representation in the AtlasRep into the private directory.

StoreChar := function(G,g,p,n,rn)
local prv, q, cnam, cnum, char;
prv := Directory(g);
q:= "\"";
cnam := IrrChar(G,p,n);
cnum := Position(AtlasCharacterNames(CharacterTable(G) mod p),cnam);
char := Concatenation(["AGR.CHAR","\(",q,G,q,",",q,rn,q,",",String(p),",",String(cnum),",",q,cnam,q,"\);\n"]);
AppendTo(Concatenation(g,"/toc.g"),Concatenation([char]));
end;