////This is for simple modules for u_r,s(sl3) (meaning the double parameter quantum groups, r=q^y, s=q^z, where q is an l-th root of unity  ////
//// More modules are obtained: Modules for the Drinfeld Double D(b), where b is the Borel subalgebra of u_r,s.
/////// ////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////

////////one has to input l, y, z and the name of the output file.
/////// In this example, l=4, y=0, z=1 and the output files is called u_1q_4

LIB "linalg.lib";
LIB "matrix.lib";
LIB "nctools.lib";
LIB "qhmoduli.lib";

/////////////INPUT here
link u = ":w u_1q_4";
ring r0= 0,x,dp;

//////INPUT//////////
int l= 4;
int y = 0;
int z= 1;
/////////////////////
ring R = (0,Q),(F(1), F(21), F(2), L(1), L(2)),Dp;
        minpoly = rootofUnity(l);
        matrix C[5][5];
        matrix D[5][5];
        C[1,2] = Q^(y); C[1,3] = Q^(z); C[1,4] = Q^(y-(z)); C[1,5] = Q^(z);
        C[2,3] = Q^(y); C[2,4] = Q^(-(z)); C[2,5] = Q^(y);
        C[3,4] = Q^(-(y)); C[3,5] = Q^(y-(z));
        C[4,5] = 1;
        D[1,3] = F(21);
ncalgebra(C,D);
option(redSB);
option(redTail);

ideal I=  F(1)^l, F(2)^l, L(1)^l - 1 , L(2)^l - 1, (F(21))^l;
qring B = twostd(I);


///////////// to have Plural do opereations in the quotient we need to ///////
///////////// reduce mod std(0) /////////////////////////////////////////////

///////////////////////////////////////////////////////////////////////////
///////////////////////DEFINITION OF THE BETA ACTION///////////////////////
///////////////////////////////////////////////////////////////////////////

///////////// Betai is the action of Fi///////////////////////////////
////// the integers j and k are such that beta(L(1))=Q^j, beta(L(2))=Q^k //////


proc Beta1( int a, poly g)
{
 poly X;
 X= reduce((- g) * F(1)*L(1)^(l-1) +  Q^a* F(1)* g * L(1)^(l-1), std(0));
 return(X);
}



proc Beta2(int b, poly g) 
{
 poly X;
 X= reduce((- g) * F(2)*L(2)^(l-1)  +  Q^b* F(2)* g * L(2)^(l-1), std(0));
 return(X);
}




proc Beta21(int a, int b, poly g)
{
 return(Beta2(b, Beta1(a,g)) - Q^((z)) * Beta1(a,Beta2(b,g))); 
}	
	

//////////////////////////////////////////////////////////////////////////////
//////////////// PBetai(a, g, k) = the beta action of F(i)^k on g/////////////


proc PBeta1(int a, poly g, int k) 
{
poly Y = g;
for(int n=1;n<=k;n++)
{
Y= Beta1( a, Y);
}
return(Y);
}



proc PBeta2(int b, poly g, int j) 
{
poly Y = g;
for(int n=1;n<=j;n++)
{
Y= Beta2( b, Y);
}
return(Y);
}



proc PBeta21(int a, int b,  poly g, int l) 
{
poly Y = g;
for(int n=1;n<=l;n++)
{
Y= Beta21( a, b, Y);
}
return(Y);
}


//////////////////////////////////////////////////////////////////////////////
//////    the following defines the beta(a,b) action of     //////////////////
//////    F(1)^k * F(21) ^t * F(2) ^ m                      //////////////////
//////////////////////////////////////////////////////////////////////////////


proc Beta( int a , int b, int k, int t, int m, poly g)
{
return( PBeta1( a, PBeta21( a, b, PBeta2(b,g,m) , t), k)) ;
}


/////////////////////////////////////////////////////////////////////////////
/////////////////// DIMENSION and BASIS OF u (\dot beta) g  /////////////////
//////////////////////////////////////////////////////////////////////////////


///// Now we construct the modules H_{c,d,a,b} 
//// where beta(L1)=q^a, beta(L2)= q^b, g= L(1)^c L(2)^d 
////(a,b) gives the beta and (c,d)s give the group element.



proc Submod(int a, int b, int c, int d, int x, int y)
{
list L;
ideal J;
ideal T;
list e = x-(l-1),y-(l-1),0;
int n= Max(e);
list f= x,y, l-1;
int m= Min(f);
for(int i= n; i<= m; i++)
{
J[i+1-n] = Beta( a, b, x-i, i, y-i , L(1)^c * L(2)^d);

T[i+1-n] = F(1)^(x-i) * F(21)^i * F(2)^(y-i) * L(1)^(((l-1)*x+c) mod l) * L(2)^(((l-1)*y+d) mod l);
}
matrix M = coeffs(J,T);
matrix N= gauss_col(M);
matrix K[1][m-n+1] = T;
matrix S= K*N;
L[1]=compress(S);
L[2]=mat_rk(N);
return(L);
}

////each Fi adds Li^(l-1) thats why such definition of T////


proc Totalbasis(int a, int b, int c , int d)
{
list B;
list A;
int t;
t=0;
for(int x= 0; x<=2*(l-1); x++)
{
list e= 0, x-(l-1);
list f= x+(l-1), 2*(l-1);
for(int y= Max(e); y<= Min(f); y++)
{
list M= Submod(a, b, c,d, x,y);
A= insert(A, M[1]);
t= t + M[2];
}}
B[2]= A;
B[1]= t;
return(B);
}


open(u);
//////////CHANGE the following for different parameters///////////////////////

write(u, "Modules for D(H_{1,q}(sl3)). g=(w_1')^c(w_2')^d and beta(w_1')= q^a, beta(w_2')= q^b, q= primitive 4th root of unity");



////////////CHANGE the name of the file for different parameters:

proc BETA
{
for(int v=1; v<=l; v++)
{
for(int w=1; w<=l; w++)
{
for(int s=1; s<=l; s++)
{
for(int t=1; t<=l; t++)
{
string r=string("a=", v-1, "b=", w-1, "c=", s-1, " d=", t-1);
write("u_1q_4",r);
list M= Totalbasis(v-1, w-1,s-1, t-1);
write("u_1q_4", "dimension = ", M[1]);
write("u_1q_4", "basis =");
fprintf("u_1q_4", "%p", list(M[2]));
}}}}
}
///////// To get only the dimensions of the modules, erase "write("u_1q_4", "basis =");
///////fprintf("u_1q_4", "%p", list(M[2])); from the lasr Procedure
BETA();

close(u);
quit;