/* ================================================================================================
This file contains all (auxiliary) functions that we need to determine the admissible numerical 
data of threefolds isogenous to a product (Part 1 of the algorithm in Chapter 3 of my thesis), 
in particular:
i)  a function to compute the types Ti and 
ii) an implementation of Conder's table, which reports the upper bound of the order of a group 
    acting faithfully on a compact Riemann surface of genus g > 1 (in terms of g) for all genera
    in the range 2 <=g<=301 (cf. Remark 3.0.5). 
The code is also used in the paper "Mixed Threefolds Isogenous to a Product". Any citations below
e.g. Proposition 3.0.10 refer to my thesis. 
================================================================================================= */

/* Let "T:=[h; m1,..., mr]" be a type. The script "Theta" determines the rational number Theta(T) 
(see Definition 3.0.2). */

Theta:= function(T)
	h:=T[1]; t:= 2*h -2;
	for i in [2..#T] do 
		m:=T[i]; t:= t + 1 - 1/m;
	end for;
return t; end function;

/* The script "OrderedSeq" transforms a (multi-) set or a sequence into an ordered sequence. */

OrderedSeq:=function(mset)
seq:=[ ];
	while #mset ne 0 do 
		Append(~seq, Minimum(mset)); Exclude(~mset, Minimum(mset)); 
	end while;
return seq; end function;

/* The script "MinRam" returns the minimum length of a type T=[h; m1,...,mr] depending on h: 
Recall that a Galois cover C --> C/G, where g(C)>1, is ramified in at least 
i)   three points if h:=g(C/G)=0,
ii)  one point if h=1 and 
iii) zero points if h>1. */

MinRam:=function(h)
if h eq 0 then return 3; 
	elif h eq 1 then return 1; else return 0;
end if; end function;

/* The script "ListOfTypes" determines the set of types T=[h; m1,..., mr] such that:
i)   the mi's are bounded by 4g + 2 (Wiman),
ii)  the mi's are divisors of GOrd and d, 
iii) the length r of T is bounded from above according to Proposition 3.0.10 iv)
     and form below by "MinRam(h)" 
iv)  Hurwitz' formula 2g-2 = GOrd*Theta(T) holds. */

ListOfTypes:=function(GOrd,g,d,h) 
Types:= {}; Orders:={k: k in Divisors(Gcd(GOrd,d)) | 2 le k and k le 4*g +2}; 
MaxRam:= Max(Floor(4*(g-1)/GOrd -4*h + 4),0);        
	for r in [MinRam(h).. MaxRam] do M:=Multisets({ x : x in Orders},r);
		for mset in M do T:=[h] cat OrderedSeq(mset);
			if GOrd*Theta(T) eq (2*g-2) then  
				Include(~Types,T) ;
			end if; 
	end for; end for;
return Types; end function;

/* The script "ThetaMin" returns for a fixed h (the genus of the quotient surface) the minimal 
value of Theta that can be realized with a suitable type of the form T =[h; m1,..., mr] 
(cf. Remark 3.0.3). */

ThetaMin:=function(h)
val:=0; L:=[1/42,1/2];
	if h le 1 then 
		val:=L[h+1]; else val:=2*h-2; 
	end if;
return val; end function;

/* Using the script "Conder", we can decide if a natural number "GOrd" (a group order) is less 
or equal to the maximum order of a group that can act on a compact Riemann surface of genus 
g (where g > 1): for g between 2 and 301, we check if GOrd is less or equal to the value in 
Conder's  table (cf. Remark 3.0.5), for g > 301 we simply check if Hurwitz' bound is fulfilled. 
True or false is returned accordingly. */

Conder:=function(GOrd,g)
test:=true;
CondersList:=[48,168,120,192,150,504,336,320,432,240,120,360,1092,504,720,1344,
168,720,228,480,1008,192,216,720,750,624,1296,672,264,720,372,1536,1320,544,672,
1728,444,912,936,960,410,1512,516,1320,2160,384,408,1920,1176,1200,2448,832,456,
1296,1320,1344,1368,928,504,1440,732,1488,1512,3072,1014,576,804,2448,660,672,
710,2160,876,1776,1800,912,1176,1872,948,1536,3888,1312,696,4032,1200,2064,712,
2640,744,3600,2184,768,2232,768,3420,3840,1164,2352,1320,2400,1010,4896,1236,
2496,2016,1696,888,5184,1308,2640,2664,2688,936,3420,936,1856,9828,960,1734,2880,
5808,2928,1080,1488,1500,3024,1524,10752,3096,2080,1310,3960,1596,3216,6480,2176,
1128,1152,1668,2184,1144,1152,1352,6912,12180,3504,3528,2368,1224,3600,1812,3648,
2448,1320,1550,3744,1884,3792,1288,3840,1320,3888,1956,2624,6600,1344,1368,8064,
4056,2720,6840,2064,1416,1856,3000,2640,1432,2848,1464,8640,2172,4368,4392,1600,
1512,4464,1512,1536,4536,2640,1910,5760,2316,4656,3420,4704,1608,2640,2388,4800,
4824,3232,1656,7344,2050,4944,1672,4368,2904,5040,2532,3392,1720,1728,1800,6480,
2604,5232,5256,5280,1800,5328,2676,5376,5400,3616,1848,6840,2748,6072,3276,3712,
1896,11232,1896,1920,5688,2176,1944,9600,2892,5808,11664,3904,4116,2624,2964,5952,
2008,12000,2510,6048,12144,6096,4896,12288,2088,6192,3108,4160,3132,2112,2136,7920,
2200,6384,2152,3216,2184,5040,3252,4896,6552,4384,3750,2304,3324,6672,6696,2688,
2810,2304,3396,2400,10260,4368,2328,13824,13872,4640,6984,4672,2376,7056,2376,7104,
3888,4768,4056,9000]; 
if g le 301 then 
	if GOrd gt CondersList[g-1] then 
		test:=false;
	end if;
	else
if GOrd gt 84*(g-1) then test:=false;
end if; end if;
return test; end function;