/* =============================================================================================
This file contains the main routine to classify singular Gorenstein product quotient threefolds
(cf. Chapter 5). 
============================================================================================== /*

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

load "Isogenous/SubIso/Types.magma";
load "Isogenous/SubIso/GenVectors.magma";
load "Singular/SubSing/BasketOfSings.magma";
load "Singular/SubSing/CohInvariants.magma";

/*The script "AdNumGorenstein" is used to determine the set of admissible numerical data [GOrd,T1,T2,T3] 
of Gorenstein product quotient threefolds, for a given negative integer "chi" (see the algorithm 
in Chapter 5). The strategy is the same as for threefolds isogenous to a product of unmixed type, 
except for the following: 
   
1)  GOrd is not allowed to be a power of 2 (see Proposition 5.0.5)
	
2)  the types Ti have length at least 1 (since we want to construct singular examples)
   
3)  not all of the entries mij of Ti are powers of two (see Proposition 5.0.5)
	
4)  the entries mij are only divisors of 8(g[i+1]-1)(g[i+2]-1) and not necessarily divisors of 
    (g[i+1]-1)(g[i+2]-1) (see Proposition 5.0.6).

The subscript "FilterTypes" excludes those types not fulfilling 2) or 3). */ 

FilterTypes:=function(Types)
TypesNew:={};
for T in Types do
		Div:={};
			for n in [2..#T] do
				Div:=Set(PrimeDivisors(T[n])) join Div;
			end for;
	if not Div subset {2} then     	// note that this condition also excludes types of the form [g';-]
		Include(~TypesNew,T);
	end if;
end for;
return TypesNew; end function;

AdNumGorenstein:=function(chi)
F:="ExcepGorenstein" cat IntegerToString(chi) cat ".txt";
fprintf F, "The Gorenstein case with chi=%o. \n\n\n
Exceptional numerical data:\n\n\n", chi;

b:=Floor(168*Sqrt(-21*chi));  
SetAdGoren:={};

for GOrd in [1..b] do
if not PrimeDivisors(GOrd) eq [2] then 
		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)));                     // cf. Proposition 4.5.6 iv)
	maxh2:=Floor(1-chi/((g1-1)*(g3-1)));
	maxh3:=Floor(1-chi/((g1-1)*(g2-1)));
		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            
				for T1 in FilterTypes(ListOfTypes(GOrd,g1,8*(g2-1)*(g3-1),h1)) do        
				for T2 in FilterTypes(ListOfTypes(GOrd,g2,8*(g1-1)*(g3-1),h2)) do
				for T3 in FilterTypes(ListOfTypes(GOrd,g3,8*(g1-1)*(g2-1),h3)) do
					D:=[[GOrd]] cat OrderedSeq([T1,T2,T3]);			             
						if IsInSmallGroupDatabase(GOrd) then 
							Include(~SetAdGoren,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 if;
end for;
return OrderedSeq(SetAdGoren); end function;

/* The script "ClassifyGorenstein" is used to perform Part 2 of the algorithm in Chapter 5. 
It determines for a given negative integer "chi" all singular Gorenstein product quotient threefolds 
with "chi(O_X)=chi". The strategy is the following: 

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

4)  we compute the basket of singularities of X from the algebraic datum (G,V1,V2,V3). If it consists of Gorenstein
    singularities only, then we determine the Hodge numbers of a crepant resolution Xhat of X. The script "Contained" 
    checks whether a threefold with the same data has already occurred. If not, then we save the group, the types, 
    the Hodge numbers and the Basket of X in the file "Gorenstein chi.txt". */

Contained:=function(sings,invars,Occ_sing,Occ_invar)
test:=false;
for i in [1..#Occ_invar] do
	if sings eq Occ_sing[i] and invars eq Occ_invar[i] then 
		test:=true; break i;
	end if;
end for;
return test; end function;

ClassifyGorenstein:=function(chi)

F:="Gorenstein" cat IntegerToString(chi) cat ".txt";
fprintf F, "Singular Gorenstein product quotient threefolds with chi= %o
\n\n\n\n\n", chi;
count:=1; AdNum:=AdNumGorenstein(chi);

for D in AdNum do GOrd:=D[1][1];T1:=D[2];T2:=D[3];T3:=D[4]; Vol:=-48*chi; 
	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);
									if IsEmpty(BaskTer) and IsEmpty(BaskTypeIII) and not IsEmpty(BaskGor) then
										invar:=HodgeDiamondCrepantRes(G,V1,V2,V3,T1,T2,T3,BaskGor);
											if not Contained(BaskGor,invar,Sings,Invariants) then  
												Append(~Sings,BaskGor); Append(~Invariants,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 of Xhat: 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 Singularities of X: %o\n",BaskGor;
												fprintf F, "\n\n\n\n\n";
												count:=count+1;
											end if;
									end if;
							end if;
					end for; end for; end for;
		end if;
	end for;
end for;
return "Classification_accomplished"; end function;