/* ===================================================================================================== This file contains the main routine to classify threefolds isogenous to a product in the index two 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 3.0.7 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 "AdNDindexTwo" is used to determine the set of admissible numerical data for a given input value of chi (<=-1) (see the algorithm in Chapter 3). We briefly explain the strategy: 1) we run through the admissible group orders GOrd. i.e. all positive integers GOrd divisible by two and bounded according to Corollary 3.0.7. 2) for each admissible GOrd we determine the pairs [g1,g2], where gi>=2 are integers such that: * (g1-1)(g2-1)^2=-chi*GOrd * the integers GOrd and GOrd/2 are less or equal to the maximum order of the automorphism group of a curve of genus g1 and g2, respectively (i.e. Conder(GOrd,g1) and Conder(GOrd/2,g2) return true). The set, where these tuples are stored is called "Generas". In contrast to the unmixed case, we can not assume that g1 <=g2. 3) for each pair [g1,g2] in the set "Generas" we run through the admissible genera h1 and h2 of the quotients curves C1/G and C2/G0. Recall that h1 is bounded by 1-chi/(g2-1)^2 and h2 by 1-2*chi/((g1-1)*(g2-1)) (see Proposition 3.0.10 vi)). 4) for those combinations, where the inequality from Proposition 3.0.6. holds, we determine the admissible types Ti i.e. * ListOfTypes(GOrd,g1,(g2-1)^2,h1) and * ListOfTypes(GOrd/2,g2,(g1-1)*(g2-1),h2) and build the triples [GOrd,T1,T2]. Those triples, where the groups of order GOrd/2 are not contained in the database of Small Groups are stored in the file "ExcepIndexTwo(chi)". The remaining triples are returned, as the output of the function. */ AdNDindexTwo:=function(chi) F:="ExcepIndexTwo" cat IntegerToString(chi) cat ".txt"; fprintf F, "Index two case, chi=%o and absolutely faithful G-action.\n\n\n Exceptional numerical data:\n\n\n", chi; SetAdIndex2:={}; b:=Floor(168*Sqrt(-21*chi)); // bound for G0_Ord cf. Corollary 3.0.7. for G0_Ord in [1..b] do GOrd:=2*G0_Ord; Generas:={}; for d in Divisors(-chi*GOrd) do g1:=d+1; g2:=Root(-chi*GOrd/(g1-1), 2) + 1; if g2 in IntegerRing() then g2:=IntegerRing()!g2; if Conder(GOrd,g1) and Conder(G0_Ord,g2) then Include(~Generas,[g1,g2]); end if; end if; end for; for gens in Generas do g1:=gens[1]; g2:=gens[2]; maxh1:= Floor(1-chi/(g2-1)^2); maxh2:= Floor(1-2*chi/((g1-1)*(g2-1))); for h1 in [0..maxh1] do for h2 in [0..maxh2] do if GOrd^2 le (-32*chi)/(ThetaMin(h1)*ThetaMin(h2)^2) then for T1 in ListOfTypes(GOrd,g1,(g2-1)^2,h1) do for T2 in ListOfTypes(G0_Ord,g2,(g1-1)*(g2-1),h2) do D:=[[GOrd]] cat [T1,T2]; if IsInSmallGroupDatabase(G0_Ord) then Include(~SetAdIndex2,D); else fprintf F, "D=%o\n\n", D; end if; end for; end for; end if; end for; end for; end for; end for; return OrderedSeq(SetAdIndex2); end function; /* The script "NDHIndexTwo" is used to determine the set of 4-tuples of the form [GOrd,T1,T2,H], where H is a group of order GOrd/2 admitting a generating vector of type T2 and [GOrd,T1,T2] is an admissible numerical datum. (cf. Step 1 of the algorithm). The strategy is the following: 1) we run through the tuples [GOrd,T1,T2] in the output of "AdNDindexTwo", remove T1 and store the pair [GOrd,T2] in the set "Ord_T2". 2) for each pair [GOrd,T2] in the set "Ord_T2", we run through the groups H of order GOrd/2.For those H admitting a generating vector of type T2, we store the triple [GOrd,T2,H] in the set "Ord_T2_H". To test this condition, we apply the function "ExistVectGens". 3) we build all four tuples [GOrd,T1,T2,H] such that [GOrd,T1,T2] is contained in "AdNDindexTwo" and [GOrd,T2,H] in "Ord_T2_H". The set of tuples [GOrd,T1,T2,H] where the groups of order GOrd are not contained in the database of Small Groups are stored in the file "ExcepIndexTwo(chi)", the other tuples are returned as the output of the function. */ NDHIndexTwo:=function(chi) AdNum:=AdNDindexTwo(chi); F:="ExcepIndexTwo" cat IntegerToString(chi) cat ".txt"; fprintf F,"Exceptional 4-tuples: \n\n\n "; Ord_T2:={}; for D in AdNum do Include(~Ord_T2,[[D[1][1]],D[3]]); end for; Ord_T2_H:={}; for Tup in Ord_T2 do for H in SmallGroups(IntegerRing()!(Tup[1][1]/2): Warning:=false) do if ExistVectGens(H,Tup[2]) then ID:=IdentifyGroup(H); Include(~Ord_T2_H, Tup cat [[ID[1],ID[2]]]); end if; end for; end for; NumandH:=[]; for D in AdNum do for Tup in Ord_T2_H do if D[1][1] eq Tup[1][1] and D[3] eq Tup[2] then DNew:=D cat [Tup[3]]; if IsInSmallGroupDatabase(D[1][1]) then Append(~NumandH,DNew); else fprintf F, "%o\n\n", DNew; end if; end if; end for; end for; return NumandH; end function; /* The script "ClassifyIndexTwo" 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 two case. The strategy is the following: 1) we determine the list "PossOrders", which contains all integers GOrd belonging to some four tuple [GOrd,T1,T2,H] in "NDHIndexTwo(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/2. 3) for each normal subgroup G0 in PG0 and for each four tuple [GOrd,T1,T2,H] in "NDHIndexTwo(chi)", such that H is isomorphic to G0, we determine a set of representatives of generating vectors Vi of type Ti calling the functions "GenVecRep(G,T1)" and "GenVecRep(G0,T2)". 4) we run through all V1 contained in GenVecRep(G,T1) and V2 contained in GenVecRep(G0,T2) and consider the tuples (G,G0,V1,V2). 5) those tuples (G,G0,V1,V2) that fulfill the freeness conditions of Proposition 2.3.2 b), i.e. "SmoothIndex2(G,G0,V1,V2,T1,T2)" 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 "HodgeDiamondIndex2". The group G, the types T1 and T2, the Hodge numbers and the dimension of the families (cf. Remark 2.3.7) are stored in the file "IndexTwo(chi).txt". */ ClassifyIndexTwo:=function(chi); F:="IndexTwo" cat IntegerToString(chi) cat ".txt"; fprintf F, "Threefolds isogenous to a product of mixed type: \n index two case, chi=%o and absolutely faithful G-action:\n\n\n\n\n", chi; count:=1; Num_H:=NDHIndexTwo(chi); Set:={}; for D in Num_H do Include(~Set,D[1][1]); end for; PossOrders:=OrderedSeq(Set); for GOrd in PossOrders do G0_Ord:=IntegerRing()!(GOrd/2); for G in SmallGroups(GOrd: Warning:=false) do NG0:=NormalSubgroups(G);invarset:={}; PG0:={NG0[i]`subgroup : i in [1..#NG0]| NG0[i]`order eq G0_Ord}; for G0 in PG0 do IdG0:=IdentifyGroup(G0); for D in Num_H do n:=D[1][1]; T1:=D[2]; T2:=D[3]; identi:=D[4]; if n eq GOrd and [IdG0[1],IdG0[2]] eq identi then for V1 in GenVecRep(G,T1) do for V2 in GenVecRep(G0,T2) do if SmoothIndex2(G,G0,V1,V2,T1,T2)then invar:=HodgeDiamondIndex2(G,G0,V1,V2,T1,T2) cat T1 cat T2 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; fprintf F, "\n Types: \n"; fprintf F, "\n T1=%o \n T2=%o\n", T1, T2; 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])-8 + #T1 + #T2; fprintf F, "\n\n\n\n\n"; count:=count+1; end if; end if; end for; end for; end if; end for; end for; end for; end for; return "Classification_accomplished"; end function;