//load "D:\\magmadoc\\MonomialConstituents.mag";

uu:=ATLASGroupNames();

for nam in uu do
    G:=ATLASGroup(nam);
    prk:=PermRepKeys(G);
    str:="";
    for p in prk do
        if Degree(p) lt 1590 then
                grp:=PermutationGroup(p);
                subg:=Stabilizer(grp,1);
                ChiefFactors(subg);
                linh:=LinearCharacters(subg);
                lam:=linh[#linh];
                ord:=Order(lam);
                if ord ne 1 then
                    time mult,mat:=MonomialConstituents(grp,subg,lam);
                    tmp:="{\\rm " cat nam cat "}&" cat Sprint(#subg)
                    cat "&" cat Sprint(Degree(grp)) cat "&" cat Sprint(ord) cat "&" cat Sprint(#mat)
                    cat "&" cat "\\\\\\hline" cat "\n";
                    str cat:=tmp;
                end if;
        end if;
    end for;
    str;
end for;

nam:="J1";
G:=ATLASGroup(nam);
prk:=PermRepKeys(G);
grp:=PermutationGroup(prk[2]);
subg:=Stabilizer(grp,1);
linh:=LinearCharacters(subg);
lam:=linh[3];
ord:=Order(lam);
time mult,mat:=MonomialConstituents(grp,subg,lam);
tmp:="{\\rm " cat nam cat "}&" cat Sprint(#subg)
cat "&" cat Sprint(Degree(grp)) cat "&" cat Sprint(ord) cat "&" cat Sprint(#mat)
cat "&" cat "\\\\\\hline" cat "\n";
str cat:=tmp;

nam:="G24";
G:=ATLASGroup(nam);
prk:=PermRepKeys(G);
grp:=PermutationGroup(prk[2]);
subg:=Stabilizer(grp,1);
linh:=LinearCharacters(subg);
lam:=linh[2];
ord:=Order(lam);
time mult,mat:=MonomialConstituents(grp,subg,lam);
tmp:="{\\rm " cat nam cat "}&" cat Sprint(#subg)
cat "&" cat Sprint(Degree(grp)) cat "&" cat Sprint(ord) cat "&" cat Sprint(#mat)
cat "&" cat "\\\\\\hline" cat "\n";
str cat:=tmp;

nam:="HS";
G:=ATLASGroup(nam);
prk:=PermRepKeys(G);
grp:=PermutationGroup(prk[1]);
subg:=Stabilizer(grp,1);
linh:=LinearCharacters(subg);
lam:=linh[2];
ord:=Order(lam);
time mult,mat:=MonomialConstituents(grp,subg,lam);
tmp:="{\\rm " cat nam cat "}&" cat Sprint(#subg)
cat "&" cat Sprint(Degree(grp)) cat "&" cat Sprint(ord) cat "&" cat Sprint(#mat)
cat "&" cat "\\\\\\hline" cat "\n";
str cat:=tmp;

nam:="DB(122)";
DB:=PerfectGroupDatabase();
T:=Group(DB,122);
H:=sub<T|[T.1,T.2]>;
ca:=CosetAction(T,H);
grp:=ca(T);
maxt:=MaximalSubgroups(grp);
subg:=maxt[1]`subgroup;
linh:=LinearCharacters(subg);
lam:=linh[2];
ord:=Order(lam);
time mult,mat:=MonomialConstituents(grp,subg,lam);
tmp:="{\\rm " cat nam cat "}&" cat Sprint(#subg)
cat "&" cat Sprint(Degree(grp)) cat "&" cat Sprint(ord) cat "&" cat Sprint(#mat)
cat "&" cat "\\\\\\hline" cat "\n";
str cat:=tmp;

subg:=maxt[2]`subgroup;
linh:=LinearCharacters(subg);
lam:=linh[2];
ord:=Order(lam);
time mult,mat:=MonomialConstituents(grp,subg,lam);
tmp:="{\\rm " cat nam cat "}&" cat Sprint(#subg)
cat "&" cat Sprint(Degree(grp)) cat "&" cat Sprint(ord) cat "&" cat Sprint(#mat)
cat "&" cat "\\\\\\hline" cat "\n";
str cat:=tmp;

nam:="DB(98)";
DB:=AlmostSimpleGroupDatabase();
T:=GroupData(DB,98);//PGL(2,73)
grp:=T`permrep;
maxt:=MaximalSubgroups(grp);
subg:=maxt[1]`subgroup;
linh:=LinearCharacters(subg);
lam:=linh[2];
ord:=Order(lam);
time mult,mat:=MonomialConstituents(grp,subg,lam);
tmp:="{\\rm " cat nam cat "}&" cat Sprint(#subg)
cat "&" cat Sprint(Degree(grp)) cat "&" cat Sprint(ord) cat "&" cat Sprint(#mat)
cat "&" cat "\\\\\\hline" cat "\n";
str cat:=tmp;

lam:=linh[3];
ord:=Order(lam);
time mult,mat:=MonomialConstituents(grp,subg,lam);
tmp:="{\\rm " cat nam cat "}&" cat Sprint(#subg)
cat "&" cat Sprint(Degree(grp)) cat "&" cat Sprint(ord) cat "&" cat Sprint(#mat)
cat "&" cat "\\\\\\hline" cat "\n";
str cat:=tmp;

///////////////////////////////////////////////////////////////////////
//we prove that the structure constants are preserved under
//(i,j,k)->(j',i',k'), where dcr[i]^-1\in orbs[i] and these are the only
//elements of C_2 wr Sym(3) with such property
////////////////////////////////////////////////////////////////////////

grp:=PrimitiveGroup(125,34);
maxt:=MaximalSubgroups(grp);
subg:=maxt[1]`subgroup;
linh:=LinearCharacters(subg);
lam:=linh[2];

ca:=CosetAction(grp,subg);
G1:=ca(grp);

base := Base( G1 );
if base[1] ne 1 then
    ChangeBase( ~G1,[1] );
    base := Base( G1 );
end if;
Gf,fG:=FPGroupStrong(G1);

H1:=ca(subg);
orbset:=Orbits(H1);
orbs:=[Sort([x:x in o]):o in orbset];
minreps:=[Min(x):x in orbs];

dcr:=[];
for m in minreps do
    b,x:=IsConjugate(G1,1,m);
    dcr:=Append(dcr,x@@fG);
end for;
ndcr:=#dcr;
Hf,fH:=FPGroupStrong(H1);

Hf,fH:=FPGroupStrong(H1);
orbs:=Orbits(H1);
orbs:=[Sort([x:x in o]):o in orbs];
minreps:=[Min(x):x in orbs];

dcr:=[];
for m in minreps do
    b,x:=IsConjugate(G1,1,m);
    dcr:=Append(dcr,x@@fG);
end for;
ndcr:=#dcr;

K:=Kernel(lam);
eta:=Exponent(subg/K);
F<z>:=CyclotomicField(eta);

Hlis:=[subg meet subg^(fG(d)@@ca):d in dcr];
centdcr:=[d:d in [1..#dcr]|&and[(h,(fG(dcr[d])@@ca)^-1) in K:h in Generators(Hlis[d])]];
ncentdcr:=#centdcr;
noncentdcr:=[x:x in [1..#dcr]|x notin centdcr];
lis:=centdcr cat noncentdcr;
perm:=Sym(#dcr)!lis;
orbs:=[orbs[i^perm]:i in [1..#dcr]];
minreps:=[minreps[i^perm]:i in [1..#dcr]];
dcr:=[dcr[i^perm]:i in [1..#dcr]];

tr:=[];
for i in [1..#orbs] do
    o:=orbs[i];
    m:=minreps[i];
    tot:=[];
    for j in o do
        b,h:=IsConjugate(H1,m,j);
        tot:=Append(tot,h@@fH);
    end for;
    tr:=Append(tr,tot);
end for;

dcd := [ 0 : i in [1..Degree(G1)] ];
for dcn in [1..#orbs] do
    for p in orbs[dcn] do
        dcd[p] := dcn;
    end for;
end for;

////////////////////////////////////////////////////////////////////////////////
//We get a regular representation D for C=End_G(V).
//We exploit the shape of the first row to speed up this calculation avoiding the calculation of
//some generalized intersection matrices.
//Use it to get Z(D) and its regular representation.
//Finally we build a cyclic generator for Z.
////////////////////////////////////////////////////////////////////////////////

invo:=Sym(#orbs)![dcd[1^fG(dcr[j]^-1)]:j in [1..#dcr]];
R:=MatrixAlgebra(F,ncentdcr);
GenIntersectionMatrix:=function(j)
    local mat,xj,mj,j1,xi,rightmul,b,h,lis;
    mat:=R![0:i,j in [1..ncentdcr]];
    xj:=fG(dcr[j]);
    mj:=minreps[j];
    mat[1,j]:=1;
    j1:=j^invo;
    b,h:=IsConjugate(H1,mj,1^(fG(dcr[j1])^-1));
    mat[j1,1]:=#orbs[j]*lam((fG(dcr[j])*h*fG(dcr[j1])*h^-1)@@ca);
    for i in [2..ncentdcr] do
        xi:=fG(dcr[i]);
        rightmul:=tr[i];
        for r in rightmul do
            lis:=[k:k in [2..ncentdcr]|minreps[k] in (mj^H1)^(xi*fH(r))];
            for k in lis do
                b,h:=IsConjugate(H1,mj,minreps[k]^((xi*fH(r))^-1));
                mat[i,k] +:=lam((((xj*h*xi)^fH(r))*(h*fG(dcr[k]))^-1)@@ca);
            end for;
        end for;
    end for;
    return R!mat;
end function;

V:=RSpace(F,ncentdcr);
bv:=Basis(V);
Dlis:=[R!1];
D:=sub<R|Dlis>;
VD:=sub<V|V.1>;
poslis:=[2..ncentdcr];
repeat
    bvd:=Basis(VD);
    poslis:=[i:i in poslis|not bv[i] in VD];
    minpos:=Minimum(poslis);
    Dlis:=Append(Dlis,R!GenIntersectionMatrix(minpos));
    D:=sub<R|Dlis>;
    repeat
        U:=VD;
        VD:=sub<V|[b*d:b in bvd, d in Dlis]>;
        bvd:=Basis(VD);
    until U eq VD;
    dim:=Dimension(VD);
    dim;
until dim eq ncentdcr;

///////////////////////////////////////////////
//Improving the determination of the center.
//We obtain as the kernel of the linear map
//obtained annihilating only the first row of elements in D
////////////////////////////////////////////////

bd:=Basis(D);
Orbs:=Orbits(H1);
C:=CartesianPower([1..#Orbs],3);
B:=CartesianPower([0..1],3);
SS:=Sym(3);
[<e,ss>:e in B,ss in SS|&and[bd[l[1^ss]^(invo^e[1]),l[2^ss]^(invo^e[2]),
l[3^ss]^(invo^e[3])] eq bd[l[1],l[2],l[3]]:l in C]];