/* =====================================================================================================
This file contains the main routine to classify threefolds isogenous to a product in the unmixed case,
under the assumption that the G-action is absolutely faithful.
===================================================================================================== /*

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

load "Isogenous/SubIso/Types.magma";
load "Isogenous/SubIso/HodgeDiamond.magma";
load "Isogenous/SubIso/GenVectors.magma";
load "Isogenous/SubIso/FreenessCond.magma";
load "Isogenous/SubIso/Deformations.magma";

/* The script "AdNDunmixed" is used to determine the set of admissible numerical data for a given negative 
integer "chi" (see the algorithm in Chapter 3). The strategy is the following:   

1)  we run through the admissible group orders GOrd, they are bounded according to Corollary 3.0.7. 

2)  for each GOrd we determine the triples of the form [g1,g2,g3], where gi>=2 are integers (g1 <= g2 <=g3) 
    such that: 
	
    i) (g1-1)(g2-1)(g3-1)=-chi*GOrd and 
	
    ii) GOrd is less or equal to the maximum order of the automorphism group of a curve of genus gi 
        i.e. the function "Conder(GOrd,gi)" returns true.
	
    The set, where these triples are stored is called "Generas". 

3)  for each triple [g1,g2,g3] in the set "Generas" we run through the admissible genera hi of the quotients 
    curves Ci/G. They are bounded in terms of g_[i+1] and g_[i+2] according to Proposition 3.0.10 vi) 
    (the bracket [-] denotes the residue mod 3). 
	
4)  for those combinations of h1, h2 and h3 which fulfill the inequality from Proposition 3.0.6, we determine 
    the admissible types Ti i.e. "ListOfTypes(GOrd,gi,(g[i+1]-1)*(g[i+2]-1),hi)" and form all possible tuples 
    [GOrd,T1,T2,T3]. The tuples [GOrd,T1,T2,T3], where the groups of order GOrd are not contained in the 
    Database of Small groups are collected in the file "ExcepUnmixed(chi)". The remaining tuples are returned, 
    lexicographically ordered, as the output of the script. */
	
AdNDunmixed:=function(chi)
F:="ExcepUnmixed" cat IntegerToString(chi) cat ".txt";
fprintf F, "Unmixed case, chi=%o and absolutely faithful G-action.\n\n\n
Exceptional numerical data:\n\n\n", chi;
b:=Floor(168*Sqrt(-21*chi));  	                   // bound for GOrd according to Corollary 3.0.7.
SetAdUnmixed:={};

for GOrd in [1..b] do
	Generas:={};
	Divi:=Divisors(-chi*GOrd);  
		for n1 in [1..#Divi] do for n2 in [n1..#Divi] do
			d1:=Divi[n1]; d2:=Divi[n2]; d3:=-chi*GOrd/(d1*d2);
				if d3 in IntegerRing() and d3 ge d2 then d3:=IntegerRing()!d3;
					if Conder(GOrd,d1+1) and Conder(GOrd,d2+1) and Conder(GOrd,d3+1) then 
						Include(~Generas,[d1+1,d2+1,d3+1]);
					end if; 
				end if; 
		end for; end for;
for gens in Generas do
	g1:=gens[1]; g2:=gens[2]; g3:=gens[3];
	maxh1:=Floor(1-chi/((g2-1)*(g3-1))); 
	maxh2:=Floor(1-chi/((g1-1)*(g3-1)));							              // maxhi are the upper bounds for the genera of the  
	maxh3:=Floor(1-chi/((g1-1)*(g2-1))); 							              // quotient curves (Proposition 3.0.10 vi))
		for h1 in [0..maxh1] do for h2 in [0..maxh2] do for h3 in [0..maxh3] do     
				if GOrd^2 le -8*chi/(ThetaMin(h1)*ThetaMin(h2)*ThetaMin(h3)) then // we check the inequality from Proposition 3.0.6
					for T1 in ListOfTypes(GOrd,g1,(g2-1)*(g3-1),h1) do   	      // the integers m_{i,j} in Ti are divisors of
					for T2 in ListOfTypes(GOrd,g2,(g1-1)*(g3-1),h2) do	          // (g_[i+1]-1)*(g_[i+2]-1) cf. Proposition 3.0.10 ii)
					for T3 in ListOfTypes(GOrd,g3,(g1-1)*(g2-1),h3) do
						D:=[[GOrd]] cat OrderedSeq([T1,T2,T3]);	                  // to avoid repetitions, we order the types lexicographically		
							if IsInSmallGroupDatabase(GOrd) then 
								Include(~SetAdUnmixed,D);
							else 
								fprintf F, "D=%o\n\n", D;
							end if;
					end for; end for; end for; 
				end if;
		end for; end for; end for; 
end for; 
end for;
return OrderedSeq(SetAdUnmixed); end function;															
																			 
/* The script "ClassifyUnmixed" is used to perform Part 2 of the algorithm in Chapter 3 (in the unmixed case). 
It determines for a given negative integer "chi" all threefolds isogenous to a product of unmixed type with 
"chi(O_X)=chi". The strategy is the following: 

1)  we call the function "AdNDunmixed(chi)" 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). 

4)  those tuples (G,V1,V2,V3) which fulfill the freeness condition of Proposition 2.3.2 a), i.e. 
    "SmoothUnmixed(G,V1,V2,V3,T1,T2,T3)" returns true, are algebraic data of (families) of threefolds X isogenous 
    to a product. We compute the Hodge numbers of these threefolds X using the function "HodgeDiamondUnmixed". 
    The group, the types, the Hodge numbers and the dimension of the families (cf. Remark 2.3.7) are saved in the 
    file "unmixed(chi).txt"

At a certain moment within the computation there will be no further occurrences i.e. the function stops writing 
data in the file "unmixed(chi).txt". However, as long as the computation is running, there are still groups that
need to be considered and excluded (this can take a while!). If the whole computation is finished, the function 
will return "Classification_accomplished". */ 

ClassifyUnmixed:=function(chi)
F:="Unmixed" cat IntegerToString(chi) cat ".txt";
fprintf F, "Threefolds isogenous to a product:  \n
unmixed case, chi=%o and absolutely faithful G-action:\n\n\n\n\n", chi;
count:=1; AdNum:=AdNDunmixed(chi);

for D in AdNum do GOrd:=D[1][1];T1:=D[2];T2:=D[3];T3:=D[4];
	for G in SmallGroups(GOrd: Warning:=false) do
		if ExistVectGens(G,T1) and ExistVectGens(G,T2) and ExistVectGens(G,T3) then	
			invarset:={};	
				for V1 in GenVecRep(G,T1) do for V2 in GenVecRep(G,T2) do for V3 in GenVecRep(G,T3) do		
					if SmoothUnmixed(G,V1,V2,V3,T1,T2,T3)  then	
						invar:= HodgeDiamondUnmixed(G,V1,V2,V3,T1,T2,T3);
							if invar notin invarset then 
								Include(~invarset,invar);
								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 Hodge numbers: h30=%o, h20=%o, h10=%o, h11= %o and h12=%o\n", 
								invar[1],invar[2], invar[3], invar[4], invar[5];		
								fprintf F,  "\n Number of parameters: %o\n", 
								3*(T1[1]+T2[1]+T3[1])-12 + #T1 + #T2 + #T3;
								defs:=Deformations(G,V1,V2,V3,T1,T2,T3);
								fprintf F,  "\n Coh of TX: %o \n", 
								defs;
								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;