
//////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////
// Basic algebras test file
//////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////

// Quivers (Apr 16)

G := AlternatingGroup(7);
A := BasicAlgebraOfPrincipalBlock(G,GF(2));
A;
x,y,z := QuiverAndRelations(A);
_<[T]> := Universe(y);
x;
y;
z;
q := quo<Universe(y)|y>;
M := RModule(MatrixAlgebra(q));
assert Dimension(M) eq 17;
assert [Dimension(x): x in SocleSeries(M)] eq [ 3, 8, 12, 16, 17 ];

A := BasicAlgebraOfPrincipalBlock(G,GF(7));
A;
x,y,z := QuiverAndRelations(A);
_<[T]> := Universe(y);
x;
y;
z;
q := quo<Universe(y)|y>;
M := RModule(MatrixAlgebra(q));
assert Dimension(M) eq 9;
assert [Dimension(x): x in SocleSeries(M)] eq [ 3, 8, 9 ];

A := BasicAlgebraOfPrincipalBlock(G,GF(3));
A;
x,y,z := QuiverAndRelations(A);
x;
y;
z;
q := quo<Universe(y)|y>;
M := RModule(MatrixAlgebra(q));
assert Dimension(M) eq 33;
assert [Dimension(x): x in SocleSeries(M)] eq [ 4, 12, 24, 32, 33 ];

//////////////////////////////////////////////////////////////////////////////

// Inner automorphisms (Apr 16)

G := AlternatingGroup(6);
A := BasicAlgebraOfPrincipalBlock(G,GF(2));
A;
U := InnerAutomorphismGroup(A);
#U;
assert #U eq 2^27;
assert #Centre(U) eq 2^4;

A := BasicAlgebraOfPrincipalBlock(G,GF(4));
A;
U := InnerAutomorphismGroup(A);
#U;
assert #U eq 2^54*3^2;
assert #Centre(U) eq 1;

A := BasicAlgebraOfPrincipalBlock(G,GF(3));
A;
U := InnerAutomorphismGroup(A);
#U;
Factorization(#U);
assert #U eq 2^9*3^54;
//assert #Centre(U) eq 1; // too slow [12.7secs]

A := BasicAlgebraOfPrincipalBlock(G,GF(5));
A;
U := InnerAutomorphismGroup(A);
#U;
Factorization(#U);
assert #U eq 2^2*5^2;
assert #Centre(U) eq 1;

G := PSU(3, 3);
A := BasicAlgebraOfPrincipalBlock(G,GF(7));
A;
U := InnerAutomorphismGroup(A);
#U;
assert #U eq 2^2*3^2*7^7;
assert #Centre(U) eq 1;


//////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////

"ex1";

ff := GF(7);
// FF:= FreeMonoid(6);
FA<e1,e2,e3,a,b,c> := FreeAlgebra(ff,6);
rrr := [a*b*a*b*a*b];
D := BasicAlgebra(FA,rrr,3,[<1,2>,<2,1>,<2,3>]);
D;
DimensionsOfProjectiveModules(D);
DimensionsOfInjectiveModules(D);
S := NonIdempotentGenerators(D);
S;
S2 := [x*y:x in S,y in S|x*y ne 0];
#S2;
S3 := [x*y:x in S2,y in S|x*y ne 0];
#S3;
S4 := [x*y:x in S3,y in S|x*y ne 0];
#S4;
S5 := [x*y:x in S4,y in S|x*y ne 0];
#S5;
S6 := [x*y:x in S5,y in S|x*y ne 0];
#S6;
S7 := [x*y:x in S6,y in S|x*y ne 0];
#S7;
S8 := [x*y:x in S7,y in S|x*y ne 0];
#S8;





"ex2";

// FF := FreeMonoid(4);
FA<e1,e2,a,b> := FreeAlgebra(GF(3),4);
MM:= [a*b*a, b*a*b];
BS3 := BasicAlgebra(FA, MM, 2, [<1,2>,<2,1>]);

BS3;
DimensionsOfProjectiveModules(BS3);
gg := CyclicGroup(3);
BC3 := BasicAlgebra(gg,GF(3));

BC3;
// We create the basic algebra for the direct product C_3 x S_3.
A := TensorProduct(BS3,BC3);
A;
DimensionsOfProjectiveModules(A);


"ex3";

ff := GF(2);
VV6 := VectorSpace(ff,6);
BB6 := Basis(VV6);
MM6 := MatrixAlgebra(ff,6);
e11 := MM6!0;
e12 := MM6!0;
e11[1]  := BB6[1];
e11[3]  := BB6[3];
e11[4]  := BB6[4];
e11[6]  := BB6[6];
e12[2]  := BB6[2];
e12[5]  := BB6[5];
a1 := MM6!0;
b1 := MM6!0;
c1 := MM6!0;
d1 := MM6!0;
a1[1] := BB6[2];
b1[1] := BB6[3];
c1[2] := BB6[4];
a1[3] := BB6[5];
b1[4] := BB6[6];
c1[5] := BB6[6];
A1 := sub< MM6 | [e11, e12, a1, b1, c1, d1] >;
T1 := [ <1,1>, <1,3>, <1,4>, <2,5>, <3,3>, <4,4>];

VV5 := VectorSpace(ff,5);
BB5 := Basis(VV5);
MM5 := MatrixAlgebra(ff,5);
e21 := MM5!0;
e22 := MM5!0;
e22[1]  := BB5[1];
e22[3]  := BB5[3];
e22[5]  := BB5[5];
e21[2]  := BB5[2];
e21[4]  := BB5[4];
a2 := MM5!0;
b2 := MM5!0;
c2 := MM5!0;
d2 := MM5!0;
f2 := MM5!0;
g2 := MM5!0;
c2[1] := BB5[2];
d2[1] := BB5[3];
b2[2] := BB5[4];
d2[3] := BB5[5];
a2[4] := BB5[5];
A2 := sub< MM5 | [e21, e22, a2, b2, c2, d2] >;
T2 := [<1,2>, <1,5>, <1,6>, <2,4>, <3,6>];

C := BasicAlgebra( [<A1, T1>, <A2, T2>] );
C;
DimensionsOfProjectiveModules(C);
DimensionsOfInjectiveModules(C);

"ex8";

ff := GF(8);
// FF:= FreeMonoid(5);
FA<e1,e2,a,b,c> := FreeAlgebra(ff,5);
rrr := [a*b*a*b*a, c*c*c*c, a*b*c - c*a*b];
B := BasicAlgebra(FA,rrr,2,[<1,2>,<2,1>,<1,1>]);
B;
DimensionsOfProjectiveModules(B);
DimensionsOfInjectiveModules(B);
P1 := ProjectiveModule(B,1);
Socle(P1);
time in1 := CompactInjectiveResolution(P1,10);
SimpleCohomologyDimensions(P1);
M := InjectiveSyzygyModule(P1,5);
M;
hh := AHom(M,M);
hh;
[Rank(hh.i): i in [1 .. Dimension(hh)]];
vv := Random(hh);
Rank(vv);
vv*vv eq vv;
[Rank(vv*vv-u*vv):u in ff];
[u:u in ff];
Rank(vv*vv - vv);
U := vv*vv - vv;
Rank(U);
T := U*U*U*U;
N1 := Kernel(T);
N2 := Image(T);
Dimension(N1);
Dimension(N2);
Dimension(N1+N2);

"ex9";

ff := GF(8);
//FF:= FreeMonoid(6);
FA<e1,e2,e3,a,b,c> := FreeAlgebra(ff,6);
rrr := [a*b*a*b*a*b*a];
D := BasicAlgebra(FA,rrr,3,[<1,2>,<2,1>,<2,3>]);
D;
DimensionsOfProjectiveModules(D);
DimensionsOfInjectiveModules(D);
OD := OppositeAlgebra(D);
OD;
s1 := SimpleModule(D,1);
P,mu := ProjectiveResolution(s1,7);
P;
Q,nu := InjectiveResolution(s1,7);
Q;
theta := MapToMatrix(hom<Term(P,0)-> Term(Q,0)|mu*nu>);
E := Complex(theta,0);
R := Splice(P,E);
S := Splice(R,Q);
S;


"ex10";

// FF := FreeMonoid(4);
FA<e1,e2,a,b> := FreeAlgebra(GF(3),4);
MM:= [a*b*a, b*a*b];
BS3 := BasicAlgebra(FA, MM, 2, [<1,2>,<2,1>]);
gg := CyclicGroup(3);
BC3 := BasicAlgebra(gg,GF(3));
A := TensorProduct(BS3,BC3);
A;
PR := ProjectiveResolution(SimpleModule(A,2),12);
PR;
PR := Prune(PR);
PR := Prune(PR);
PR := Prune(PR);
PR;
PR := Prune(PR);
PR := Prune(PR);
PR;
PR := ZeroExtension(PR);
PR;
PR := Shift(PR,-4);
PR;
S := [* *];
for i := 1 to 10 do
    S[i] := [Random(Term(PR,10-i)),Random(Term(PR,10-i))];
end for;
C,mu := Subcomplex(PR,S);
C;
Homology(C);

/*
D := Cokernel(mu);
D;
Homology(D);
*/

"ex12";

ff := GF(2);
VV8 := VectorSpace(ff,8);
BB8 := Basis(VV8);
MM8 := MatrixAlgebra(ff,8);
e11 := MM8!0;
e12 := MM8!0;
e13 := MM8!0;
e11[1]  := BB8[1];
e11[4]  := BB8[4];
e11[5]  := BB8[5];
e11[8]  := BB8[8];
e12[2]  := BB8[2];
e12[7]  := BB8[7];
e13[3]  := BB8[3];
e13[6]  := BB8[6];
a1 := MM8!0;
b1 := MM8!0;
c1 := MM8!0;
d1 := MM8!0;
e1 := MM8!0;
f1 := MM8!0;
a1[1] :=  BB8[2];
a1[5] :=  BB8[7];
b1[1] :=  BB8[3];
b1[4] :=  BB8[6];
c1[2] :=  BB8[4];
c1[7] :=  BB8[8];
e1[3] :=  BB8[5];
e1[6] :=  BB8[8];
f1[3] :=  BB8[6];
A1 := sub< MM8 | [e11, e12, e13, a1, b1, c1, d1, e1, f1] >;
T1 := [ <1,1>,<1,4>,<1,5>,<2,6>,<3,8>,<4,5>,<5,4>,<6,8>];
VV6 := VectorSpace(ff,6);
BB6 := Basis(VV6);
MM6 := MatrixAlgebra(ff,6);
e21 := MM6!0;
e22 := MM6!0;
e23 := MM6!0;
e22[1]  := BB6[1];
e22[5]  := BB6[5];
e22[6]  := BB6[6];
e21[2]  := BB6[2];
e21[4]  := BB6[4];
e23[3]  := BB6[3];
a2 := MM6!0;
b2 := MM6!0;
c2 := MM6!0;
d2 := MM6!0;
e2 := MM6!0;
f2 := MM6!0;
a2[4] := BB6[6];
b2[2] := BB6[3];
c2[1] := BB6[2];
d2[1] := BB6[5];
d2[5] := BB6[6];
e2[3] := BB6[4];
A2 := sub< MM6 | [e21, e22, e23, a2, b2, c2, d2, e2, f2]>;
T2 := [ <1,2>, <1,6>, <2,5>, <3,8>, <1,7>, <5,7> ];
VV8 := VectorSpace(ff,8);
BB8 := Basis(VV8);
MM8 := MatrixAlgebra(ff,8);
e31 := MM8!0;
e32 := MM8!0;
e33 := MM8!0;
e31[2]  := BB8[2];
e31[6]  := BB8[6];
e32[4]  := BB8[4];
e33[1]  := BB8[1];
e33[3]  := BB8[3];
e33[5]  := BB8[5];
e33[7]  := BB8[7];
e33[8]  := BB8[8];
a3 := MM8!0;
b3 := MM8!0;
c3 := MM8!0;
d3 := MM8!0;
e3 := MM8!0;
f3 := MM8!0;a3[2] :=  BB8[4];
b3[6] :=  BB8[8];
b3[2] :=  BB8[7];
c3[4] :=  BB8[6];
e3[1] :=  BB8[2];
e3[3] :=  BB8[6];
f3[1] :=  BB8[3];
f3[3] :=  BB8[5];
f3[5] :=  BB8[7];
f3[7] :=  BB8[8];
A3 := sub< MM8 | [e31, e32, e33, a3, b3, c3, d3, e3, f3] >;
T3 := [ <1,3>,<1,8>,<1,9>,<2,4>,<3,9>,<4,6>,<5,9>,<6,5>];
m11 := BasicAlgebra( [<A1, T1>, <A2, T2>, <A3, T3>] );
m11;
s1 := SimpleModule(m11,1);
s2 := SimpleModule(m11,2);
prj1 := CompactProjectiveResolution(s1,20);
prj2 := CompactProjectiveResolution(s2,20);
CR1 := CohomologyRingGenerators(prj1);
CR2 := CohomologyRingGenerators(prj2);
DegreesOfCohomologyGenerators(CR1);
DegreesOfCohomologyGenerators(CR2);
CR12 := CohomologyLeftModuleGenerators(prj1,CR1,prj2);
DegreesOfCohomologyGenerators(CR12);
CR12 := CohomologyRightModuleGenerators(prj1,prj2,CR2);
DegreesOfCohomologyGenerators(CR12);

//////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////

"ex13";

//load m11;
G := PermutationGroup<11 |  
    \[ 10, 8, 11, 4, 7, 6, 5, 2, 9, 1, 3 ],
    \[ 4, 11, 3, 7, 5, 1, 6, 8, 2, 9, 10 ]: Order := 7920 >;
H := Normalizer(G,Sylow(G,2));
M := PermutationModule(G,H,GF(2));
B := BasicAlgebra(Action(M));
print B;
C := BasicAlgebraOfEndomorphismAlgebra(DirectSum([ProjectiveModule(B,i): i in 
	[1 .. NumberOfProjectives(B)]]));
C;
A:= BasicAlgebraOfEndomorphismAlgebra(M);
A;
assert Dimension(A) eq 22;
// print "     Should have dimension 22";
SumOfBettiNumbersOfSimpleModules(A,10);
SumOfBettiNumbersOfSimpleModules(A,13);

"ex14";

A := BasicAlgebraOfSchurAlgebra(3,7,GF(2));
A;
B := BasicAlgebraOfExtAlgebra(A,12);
B;
s := 0;
for i := 4 to 8 do
  t := SumOfBettiNumbersOfSimpleModules(B,i);
  if i gt 4 then assert Abs(t-2*s)/t lt 0.02; end if;
  s := t;
end for;
// print "     each of these numbers should be approximately double the previous one";

"ex15";

A := BasicAlgebraOfSchurAlgebra(3,6,GF(3));
A;
B := BasicAlgebraOfExtAlgebra(A,12);
B;
C := BasicAlgebraOfExtAlgebra(B,12);
C;
// print "     A and C should look alike";
assert Dimension(A) eq Dimension(C);
assert NumberOfGenerators(A) eq NumberOfGenerators(C);
assert NumberOfProjectives(A) eq NumberOfProjectives(C);

D := BasicAlgebraOfExtAlgebra(C,12);
D;
// print "     B and D should look alike";
assert Dimension(B) eq Dimension(D);
assert NumberOfGenerators(B) eq NumberOfGenerators(D);
assert NumberOfProjectives(B) eq NumberOfProjectives(D);

A := BasicAlgebraOfSchurAlgebra(4,5,GF(5));
A;
B := BasicAlgebraOfExtAlgebra(A,12);
B;
C := BasicAlgebraOfExtAlgebra(B,12);
C;
// print "     A and C should look alike";
assert Dimension(A) eq Dimension(C);
assert NumberOfGenerators(A) eq NumberOfGenerators(C);
assert NumberOfProjectives(A) eq NumberOfProjectives(C);
D := BasicAlgebraOfExtAlgebra(C,12);
D;
// print "     B and D should look alike";
assert Dimension(B) eq Dimension(D);
assert NumberOfGenerators(B) eq NumberOfGenerators(D);
assert NumberOfProjectives(B) eq NumberOfProjectives(D);

"ex16";
G := Sym(8);
H := Normalizer(G,Sylow(G,2));
M := PermutationModule(G,H,GF(3));
N := JacobsonRadical(JacobsonRadical(M));
A := Action(N);
A;
W := RModule(A);
B := BasicAlgebraOfEndomorphismAlgebra(W);
B;
C := BasicAlgebra(A);
C;
D := BasicAlgebraOfEndomorphismAlgebra(DirectSum([ProjectiveModule(C,i): 
	i in [1 .. NumberOfProjectives(C)]]));
D;
// print "        C and D should be the same.";
assert Dimension(C) eq Dimension(D);
assert NumberOfGenerators(C) eq NumberOfGenerators(D);
assert NumberOfProjectives(C) eq NumberOfProjectives(D);


print "ex17";
g := Sym(9);
h := YoungSubgroup([5,4]);
M := PermutationModule(g,h,GF(3));
A:= Action(M);
A;     
time B := BasicAlgebra(A);
print B;
assert Dimension(B) eq 13 and NumberOfGenerators(B) eq 11;
// print "    This should be a basic algebra of dimension 13 and 11 generators.";

print "ex18";

g := SmallGroup(49,2);
M := PermutationModule(g,sub<g|>, GF(7));
d := 0;
for i := 1 to 6 do
    M := JacobsonRadical(Dual(JacobsonRadical(M)));
    B := BasicAlgebraOfEndomorphismAlgebra(M);
    B;
    e :=  Dimension(B);
    if i gt 1 then assert (e eq d) eq (i lt 6); end if;
    d := e;
// print "The dimension of B is ", Dimension(B);
end for;
// print "           These should be local algebras of the same dimension
// up to the last one. ";
// print "";

"ex19";
A := BasicAlgebra(SmallGroup(49,2));
A;
k := SimpleModule(A,1);
o5 := SyzygyModule(k,5);
o5;
M := JacobsonRadical(Dual(JacobsonRadical(o5)));
B := BasicAlgebraOfEndomorphismAlgebra(M);
// print "           This should be a local ring ";
C := ExtAlgebra(A,7);
C;
// print "";


"ex20";
F<e1,e2,a,b,c> := FreeAlgebra(GF(8),5);
RR:= [a*b*a*b*a,c*c*c*c,a*b*c-c*a*b];
A := BasicAlgebra(F,RR, 2,[<1,2>,<2,1>,<1,1>]);
B := ExtAlgebra(A,10);
print A;
// C := BasicAlgebraOfExtAlgebra(A,10);
// print "      this should give an immediate error message. 

////// Sambale

G:=AlternatingGroup(7);
A:=BasicAlgebraOfGroupAlgebra(G,GF(2));
P:=ProjectiveModule(A,1);
B:=BasicAlgebraOfEndomorphismAlgebra(P);
assert Dimension(B) eq 4;
assert NumberOfProjectives(B) eq 1;

