/* =======================================================================================================
This file contains the main routine to classify threefolds isogenous to a product in the index six case,
under the assumption that the G-action is absolutely faithful. The code is also used in the paper "Mixed 
Threefolds Isogenous to a Product" and in my PhD thesis. Any citations below e.g. Corollary 2.3.4 refer 
to my thesis. 
========================================================================================================*/

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

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

/* The script "AdNDindexSix" is used to determine the set of admissible numerical data for a given input
value of chi (<=-1) (see the algorithm in Chapter 3). The computation is the same as in the index three 
case, except that the group order GOrd is divisible by 18 and not just by 9 (cf. Corollary 2.3.4). */

AdNDindexSix:=function(chi)
F:="ExcepIndexSix" cat IntegerToString(chi) cat ".txt";
fprintf F, "Index six case, chi=%o and absolutely faithful G-action.\n\n\n
Exceptional numerical data:\n\n\n", chi;

GOrdMax:=Floor(1512*Sqrt(-7*chi));
g1max:=Floor(Root(-chi*GOrdMax, 3)+1);   
ListAdIndex6:=[];

ListPairs:=[];
	for g1 in [2..g1max] do
		GOrd:=-(g1-1)^3/chi;                    		
		if GOrd/18 in IntegerRing() and Conder(GOrd/3,g1) then 
			GOrd:=IntegerRing()!GOrd; Append(~ListPairs,[GOrd,g1]);
		end if;
	end for;

for Pair in ListPairs do
	GOrd:=Pair[1]; G1_Ord:=IntegerRing()!(GOrd/3); g1:=Pair[2];
	h1max:= Floor(1-3*chi/(g1-1)^2);
		for h1 in [0..h1max] do
			if GOrd^2 le -216*chi/(ThetaMin(h1)^3)  then 
				for T1 in ListOfTypes(G1_Ord,g1,(g1-1)^2,h1) do
					D:=[[GOrd],T1];
						if IsInSmallGroupDatabase(G1_Ord) then 
							Append(~ListAdIndex6,D);
						else 
							fprintf F, "D=%o\n\n", D;
						end if;
				end for; 
			end if;
		end for;
end for;
return ListAdIndex6; end function;

/* The script "NDHIndexSix" is used to determine the set of triples of the form [GOrd,T1,H], where 
[GOrd,T1] is an admissible numerical datum and H is a candidate for G1 i.e. H is of order GOrd/3 
and admits a generating vector of type "T1". The triples [GOrd,T1,H], where the groups of order GOrd 
are not contained in the database of Small Groups are stored in the file "ExcepIndexSix(chi)". 
The remaining triples are returned as the output of the function. */

NDHIndexSix:=function(chi)
AdNum:=AdNDindexSix(chi);
F:="ExcepIndexSix" cat IntegerToString(chi) cat ".txt";
fprintf F,"Exceptional triples: \n\n\n ";
	Ord_T1_H:=[];
		for Tup in AdNum do
			GOrd:=Tup[1][1]; T1:=Tup[2];
				for H in SmallGroups(IntegerRing()!(GOrd/3): Warning:=false) do
					if ExistVectGens(H,T1) then 
						ID:=IdentifyGroup(H); DNew:=Tup cat [[ID[1],ID[2]]];
							if IsInSmallGroupDatabase(GOrd) then
								Append(~Ord_T1_H,DNew);
							else 
								fprintf F, "%o\n\n", DNew;
							end if;				
					end if;
				end for; 
		end for;
return Ord_T1_H; end function;

/* The function "NonSplitIndexSix" returns true if the sequence 1 --> G0 --> G --> S3 --> 1 is non-split. 
This is a necessary condition for the freeness of the G-action according to Proposition 2.3.3. */

NonSplitIndexSix:=function(G,G0)
	test:=true; L:=Set(G) diff Set(G0);
		for a in ElsOfOrd(L,2) do
			for b in ElsOfOrd(L,3) do
				if a*b*a  eq b^(-1) then 
					test:=false; break a;
				end if;
			end for;
		end for;
return test; end function;

/* Let G be a finite group and G0 be a normal subgroup of index six such that G/G0 is isomorphic to S3. 
The function "Elemets_tau_h" returns elements tau and h in G\G0 such that tau^2 is not contained in G0 
and h^2 is contained in G0. Note that these elements give rise to an isomorphism G/G0 --> S3. */

Elemets_tau_h:=function(G,G0)
L:=Set(G) diff Set(G0);
	for g in L do
		if g^2 notin G0 then
			tau:=g; break g; 
		end if;
	end for;
for u in L do
	if u^2 in G0 then 
		h:=u;end if;
end for;
return tau, h; end function;

/* The script "ClassifyIndexSix" is used to perform Step 2 of the algorithm in Chapter 3. It determines for 
a given negative integer "chi" (the input value) all threefolds isogenous to a product of mixed type with 
"chi(O_X)=chi" in the index six case. The strategy is the following: 

1)  we determine the list "PossOrders", which contains all integers GOrd belonging to some triple [GOrd,T1,H]
    in "NDHIndexSix(chi)".

2)  for each GOrd in "PossOrders" and for each group G of order GOrd we build the set "PG0" of normal subgroups G0
    of Order GOrd/3 such that G/G0 is isomporphic to S3 and the short exact sequence 1 --> G0 --> G --> S3 --> 1 
    is non-split.  

3)  we run through the groups G0 in PG0, determine for each G0 elements tau and h in G\G0 as explained above and 
    define the subgroup G1cand to be the subgroup generated by all elements of G0 and the element h. 

4)  next we run through the triples [GOrd,T1,H] in "NDHIndexSix(chi)". For those triples, where H is isomorphic to 
    G1cand we determine a set of representatives of generating vectors V1 calling the function "GenVecRep(G1cand,T1)".

5)  we run through all V1 contained in "GenVecRep(G1cand,T1) and consider the tuples (G,G0,tau,h,V1). 

6)  those tuples (G,G0,tau,V1) fulfilling the freeness conditions of Proposition 2.3.2 d) are algebraic data of 
    (families) of threefolds X isogenous to a product. We compute the Hodge numbers of these threefolds X using 
    the function "HodgeDiamondIndex6". The groups G and G0, the type T1, the Hodge numbers and the dimension of the families 
    are saved in the file "IndexSix(chi).txt". */

ClassifyIndexSix:=function(chi);
F:="IndexSix" cat IntegerToString(chi) cat ".txt";
fprintf F, "Threefolds isogenous to a product of mixed type:\n
index six case, chi=%o and absolutely faithful G-action:\n\n\n\n\n", chi;
count:=1; Num_H:=NDHIndexSix(chi);

SetOrd:={};
	for D in Num_H do 
		Include(~SetOrd,D[1][1]);
	end for;
PossOrders:=OrderedSeq(SetOrd);

for GOrd in PossOrders do
		for G in SmallGroups(GOrd: Warning:=false) do
			N:=NormalSubgroups(G);	
			PossG0:={N[i]`subgroup : i in [1..#N]| IsIsomorphic(G/N[i]`subgroup,Sym(3))
			and NonSplitIndexSix(G,N[i]`subgroup)};				
				for G0 in PossG0 do	
					IdG0:=IdentifyGroup(G0);
					tau,h :=Elemets_tau_h(G,G0); G1cand:=sub<G | Set(G0) join {h}>;					
						for D in Num_H do
							T1:=D[2]; ide:=<D[3][1],D[3][2]>; invarset:={};
								if <D[3][1],D[3][2]> eq  IdentifyGroup(G1cand) then
									for V1 in GenVecRep(G1cand,T1) do
										if SmoothIndex6(G,G0,tau,h,V1,T1) then
											invar:=HodgeDiamondIndex6(G,G0,tau,h,V1,T1) cat [IdG0[1],IdG0[2]]; 					
												if invar notin invarset then 
													Include(~invarset,invar);
													fprintf F, "%o) Groups: G= %o, G0=%o \n", count, IdentifyGroup(G),
													[IdG0[1],IdG0[2]];
													fprintf F, "\n Type: (the first entry is gi') \n";
													fprintf F, "\n T1=%o;\n", T1;
													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\n\n\n\n";
													fprintf F,  "\n number of parameters: %o;\n", 3*T1[1] - 4 + #T1;
													fprintf F, "\n\n\n\n\n";
													count:=count+1;
												end if;
										end if;
									end for;
								end if;
						end for;
				end for;
		end for;
end for;
return "Classification_accomplished";
end function;