/* =======================================================================================================
This file contains the main routine to classify product quotient threefolds X with canonical singularities 
such that K^3 <= c, where c is a constant serving as the input value. 
======================================================================================================== /*

/* To run the implementation we load the following files: */

load "Singular/MainSing/MainGorenstein.magma";

/*  The script "AdNumSmallVol" is used to determine the set of admissible numerical data of product quotient 
threefolds with K^3 <= c (see Chapter 6). The strategy is the following:  

1)  we construct the set of ordered triples [g1,g2,g3] of integers gi>=2 fulfilling the inequality  
   (g1-1)(g2-1)(g3-1)<= 7/8 √(7 c^3)

2)  we run through the admissible group orders 48/c <= GOrd <= 42 √(7 c) and through the set of triples 
   [g1,g2,g3] constructed above. For those combinations, where 

   i)  the function "Conder(GOrd,gi)" returns true for all 1 <= i <= 3 and the inequality 
   
   ii) 48(g1-1)(g2-1)(g3-1) <= GOrd c holds,
	
    we save the 4-tuple (GOrd,g1,g2,g3) in the set "FourTup". Condition i) ensures that GOrd is less or equal 
    to the maximum order of the automorphism group of a curve of genus gi.  
	
3)  for every 4-tuple in the set "FourTup" we construct the set of 4-tuples of the form [GOrd,T1,T2,T3], 
    where Ti are the admissible types. The computation is the same as for threefolds isogenous to a product 
	of unmixed type, except that we are not allowed to assume that the entries mij of Ti are divisors of 
	(g[i+1]-1)(g[i+2]-1). 
*/

AdNumSmallVol:=function(c)
SetAdN:={};
b:=(7/8)*Sqrt(7*c^3); Generas:={}; gmax:=IntegerRing()!(Floor(b +1));
	for g1 in [2..gmax] do for g2 in [g1..gmax] do for g3 in [g2..gmax] do
				if (g1-1)*(g2-1)*(g3-1) le b then
					Include(~Generas,[g1,g2,g3]);
				end if;
	end for; end for; end for;

FourTup:={}; lb:=Ceiling(48/c); ub:=Floor(42*Sqrt(7*c)); 
	for GOrd in [lb..ub] do
		for gens in Generas do  
			g1:=gens[1];g2:=gens[2];g3:=gens[3];
				if Conder(GOrd,g1) and Conder(GOrd,g2) and Conder(GOrd,g3) 
					and 48*(g1-1)*(g2-1)*(g3-1) le (GOrd*c) then
					Include(~FourTup,[GOrd,g1,g2,g3]);
				end if;
		end for;
	end for;

for Tup in FourTup do
	GOrd:=Tup[1]; g1:=Tup[2]; g2:=Tup[3]; g3:=Tup[4]; 
	Vol:=48*(g1-1)*(g2-1)*(g3-1)/GOrd;
	maxh1:=Floor(1+Vol/((g2-1)*(g3-1)*48));  
	maxh2:=Floor(1+Vol/((g1-1)*(g3-1)*48));
	maxh3:=Floor(1+Vol/((g1-1)*(g2-1)*48));
		for h1 in [0..maxh1] do for h2 in [0..maxh2] do for h3 in [0..maxh3] do
			if GOrd^2 le Vol/(6*ThetaMin(h1)*ThetaMin(h2)*ThetaMin(h3)) then   			    
				for T1 in ListOfTypes(GOrd,g1,GOrd,h1) do   
				for T2 in ListOfTypes(GOrd,g2,GOrd,h2) do
				for T3 in ListOfTypes(GOrd,g3,GOrd,h3) do
					D:=[[GOrd]] cat OrderedSeq([T1,T2,T3]);			
							Include(~SetAdN,D);
				end for; end for; end for; 
			end if;
		end for; end for; end for;
end for;
return OrderedSeq(SetAdN); end function;

/* The script "ClassifySmallVol" is used to perform Step 2 of the algorithm in Chapter 6. It classifies for a 
given positive number "c" all product quotient threefolds X with  K^3 <= c. The strategy is the following: 

1)  we call the function "AdNumSmallVol(c)" which creates the set of admissible numerical data: [GOrd,T1,T2,T3].

2)  for each [GOrd,T1,T2,T3], we run through the groups G of order GOrd and verify if G admits a generating vector 
    Vi of type Ti for all i=1,2 and 3. For those groups passing this test, we determine a set of representatives 
    of generating vectors Vi of type Ti calling the function "GenVecRep(G,Ti)". 

3)  we run through all generating vectors Vi contained in GenVecRep(G,Ti) and consider the tuples (G,V1,V2,V3). 
    Each tuple (G,V1,V2,V3) yields a product quotient threefold X with  K^3 <= c.

4)  we compute the basket of singularities of X from (G,V1,V2,V3). If it consists of canonical singularities only, 
    then we compute the invariants pg, q2, q1, e and the basket of a crepant terminalisation. The script "Contained" 
    (see "Singular/MainRoutines/MainGorenstein.magma") checks if a threefold with the same data already occurred. 
    If not, we save the group, the types, the invariants and the Basket of Xhat in the file "SmallVol c.txt". */	
	
ClassifySmallVol:=function(c)
F:="SmallVol" cat IntegerToString(c) cat ".txt";
fprintf F, "Product quotient threefolds with K^3 <= %o
\n\n\n\n\n", c;
count:=1;
AdNum:=AdNumSmallVol(c);
for D in AdNum do
	GOrd:=D[1][1];T1:=D[2];T2:=D[3];T3:=D[4];
		Vol:=Theta(T1)*Theta(T2)*Theta(T3)*6*GOrd^2;
			for G in SmallGroups(GOrd: Warning:=false) do
				if ExistVectGens(G,T1) and ExistVectGens(G,T2) and ExistVectGens(G,T3) then	
					Sings:=[]; Invariants:=[];	
						for V1 in GenVecRep(G,T1) do for V2 in GenVecRep(G,T2) do for V3 in GenVecRep(G,T3) do
							Basket:=Basket_of_Sing(G,V1,V2,V3,T1,T2,T3);
								if Test_Basket(Basket) then 
									BaskTer, BaskGor, BaskTypeIII:=Split_up_Basket(Basket);
										invar:=InvProductQuotient(G,V1,V2,V3,T1,T2,T3,BaskTer,BaskGor,BaskTypeIII,Vol);
											BaskXhat:=Xhat_Basket(BaskTer,BaskTypeIII);
												if not Contained(BaskXhat,invar,Sings,Invariants) then  
													Append(~Sings,BaskXhat); Append(~Invariants,invar); 
													chi:=1-invar[3]+invar[2]-invar[1];
													fprintf F, "%o) Group: G= %o\n",count, IdentifyGroup(G);
													fprintf F, "\n Types: \n";
													fprintf F, "\n T1=%o \n T2=%o \n T3=%o \n", T1, T2, T3;
													fprintf F, "\n Invariants:  pg=%o, q2=%o, q1=%o, e=%o, K^3=%o and chi=%o \n", 
													invar[1],invar[2], invar[3], invar[4], Vol, chi;		
													fprintf F, "\n Singularities: %o\n",BaskXhat; 
													fprintf F, "\n\n\n\n\n";
													count:=count+1;
												end if; 
								end if;
						end for; end for; end for;
				end if;
			end for;
end for;
return "Classification_accomplished"; end function;