// The Case G=He(3)

/* With this code, we classify all three-dimensional quotients of abelian varieties by an action of He(3) that has a non-empty and finite fixed locus and preserves the volume form.
   In particular, we use it to perform the computation in the proof of Proposition 4.18. The code consists of three parts:

   PART I: generation of all He(3)-actions with isolated fixed points and the initialisation of all potential biholomorphisms
   PART II: the functions to check the cocycle-condition in Remark 3.7.(b)
   PART III: the classification functions for the biholomorphic classification
*/

/************************************************************************************/

/* PART I: generation of all He(3)-actions with only isolated fixed points and the initialization of all potential biholomorphisms */

//We work with the 3rd cyclotomic field, ze is a 3rd primitive root of unity
F<ze>:=CyclotomicField(3);

/* The group G=He(3) can be presented as G=<g,h,k | g^3=h^3=k^3=[g,k]=[h,k]=1, [g,h]=k> and is generated by g and h.
   According to Theorem 2.3, the analytic representation of He(3) is given by: */

g:=Matrix(F,3,3,[[0,0,1],[1,0,0],[0,1,0]]);
h:=DiagonalMatrix([1,ze^2,ze]);
k:=DiagonalMatrix([ze,ze,ze]);

//E3 denotes the group of 3-torsion points of the Fermat elliptic curve E.
E3:={1/3*(a+b*ze): a, b in {0,1,2}};

// Generator of the fixed locus of ze in E:
t:=1/3+2/3*ze;

I3:=DiagonalMatrix([1,1,1]);

/* The possible kernels K_i of the addition map are: */

K1:={a*Matrix(F,3,1,[t,t,t]): a in {0,1,-1}};
K2:={a*Matrix(F,3,1,[t,t,t])+b*Matrix(F,3,1,[t,-t,0]): a,b in {0,1,-1}};

Kernels:=[K1,K2];

/* The function "IntegralTest" checks if the entries of a 3-vector v (given as 3x1-matrix) are Eisenstein integers, i.e. integral over Z. */

function IntegralTest(v)
	return IsIntegral(v[1][1]) and IsIntegral(v[2][1]) and IsIntegral(v[3][1]);
end function;

/* The function "InLatt" takes as input a vector "v" and a parameter "j=1,2" and decides whether "v" belongs to the lattice "Lambda_j=Z[ze]^3+K_j". */

function InLatt(v,j)
	K:=Kernels[j];
	for l in K do
		if IntegralTest(v-l) then
			return true;
		end if;
	end for;
	return false; 
end function;

/* The function "GoodCond" checks whether a cocycle in standard form is good (cf. Lemma 4.10) */

function GoodCond(a1,a2,a3,b1,b2,b3,j)
	if IsIntegral(b1+b2+b3) or IsIntegral(ze^2*(b1+b2)+b3+ze^2*(a1+a3)+a2) or IsIntegral(ze*(b1+b2)+b3-ze*(a1+a2)-a3) then
		return false;
	end if;
	for t1 in [0,t,-t] do
	for t2 in [0,t,-t] do
		w:=Matrix(F,3,1,[a1,t1,t2]);
		if InLatt(w,j) then
			return false;
		end if;
	end for;
	end for;
	return true;
end function;

/* Here, we define the possible translation parts of potential biholomorphisms between two quotients, as explained in Proposition 4.17.  Note that all candidates are contained in the set E[9]^3. We check with the code which of these elements are in fact fixed points of multiplication with \ze_3 and then, we choose one representative of each class of the elements in C^3 mod the lattice.
   We also use them to define the 1-coboundaries which we need to compute a set of represenatatives for the  good cohomology classes.
   The input is the parameter "j" that refers to the lattice, resp. the kernel, that is used in the computation. */

function Listd(j)
	ListdMax:={a/9 + b/9*ze: a in [0..8], b in [0..8]};
	listd:=[];
	for d1 in ListdMax do
	for d2 in ListdMax do
	for d3 in ListdMax do
		d:=Matrix(F,3,1,[d1,d2,d3]);
		if  InLatt((ze-1)*d,j) then
			Append(~listd,d);
		end if;
	end for; end for; end for;
	Reflistd:=listd;
	shortlistd:=[];
	while not IsEmpty(listd) do
		Reflistd:=listd;
		d:=Rep(listd); Append(~shortlistd,d);
		for e in Reflistd do
			if InLatt(d-e,j) then
				Exclude(~listd,e);
			end if;
		end for;
	end while;
	return shortlistd;
end function;

/* With the function "TestCohom" we test if two given cocycles give the same cohomology class in H^1(He(3),E^3/K_j).
   Input: "v1", "v2": two translation vectors (given as tuples v_i=[taug_i,tauh_i]); "j": parameter for the kernel; "Ld": list of translation parts of the biholomorphisms computed with "Listd(j)" */

function TestCohom(v1,v2,j,Ld)
	taug1:=v1[1];
	tauh1:=v1[2];
	taug2:=v2[1];
	tauh2:=v2[2];
	for d in Ld do
		if InLatt(tauh1-tauh2-(h*d-d),j) and InLatt(taug1-taug2-(g*d-d),j) then
			return true;
		end if;
	end for;
	return false;
end function;

/* The function "Actions" determines all actions with isolated fixed points with translation part in standard form on E^3/K_j, for each j=1,2 (first output).
   The second output is a list consisting of one representative for each good comohomology class in H^1(He(3),E^3/K_j).
   As an input, it takes the parameter "j" corresponding to the kernel K_j and the list of translation vectors "Ld=Listd(j)". */

function Actions(j,Ld)
	ListTransVec:={};
	ListOfActions:={};
	for a1 in E3  do 
	for a2 in E3  do
	for a3 in E3  do
		for b1 in E3 do
		for b2 in E3 do
		for b3 in E3 do			
			v1:=Matrix(F,3,1,[(ze-1)*a1,(ze-1)*a2,(ze-1)*a3]);
			v2:=Matrix(F,3,1,[b1+b2+b3,b1+b2+b3,b1+b2+b3]);
			v3:=Matrix(F,3,1,[(ze-1)*b1,(ze-1)*b2,(ze-1)*b3]);
			v4:=Matrix(F,3,1,[ze*a1-a3+(ze-1)*b1,ze*a2-a1,ze*a3-a2+(ze^2-1)*b3]);
				if InLatt(v1,j) and InLatt(v2,j) and InLatt(v3,j) and InLatt(v4,j) and GoodCond(a1,a2,a3,b1,b2,b3,j) then
					ListTransVec:=Include(ListTransVec, [Matrix(F,3,1,[b1,b2,b3]),Matrix(F,3,1,[a1,a2,a3])]);
					WG:=Matrix(F,4,4, [[0,0,1,b1],[1,0,0,b2],[0,1,0,b3],[0,0,0,1]]);
					WH:=Matrix(F,4,4, [[1,0,0,a1],[0,ze^2,0,a2],[0,0,ze,a3],[0,0,0,1]]);
					ListOfActions:=Include(ListOfActions,[WG,WH]);
				end if;
		end for; end for; end for;
	end for; end for; end for;
	GoodClasses:={};
	RefListTransVec:=ListTransVec;
	while not IsEmpty(ListTransVec) do
		RefListTransVec:=ListTransVec;
		v1:=Rep(ListTransVec);
		v1g:=v1[1]; v1h:=v1[2];
		WG:=Matrix(F,4,4, [[0,0,1,v1g[1][1]],[1,0,0,v1g[2][1]],[0,1,0,v1g[3][1]],[0,0,0,1]]);
		WH:=Matrix(F,4,4, [[1,0,0,v1h[1][1]],[0,ze^2,0,v1h[2][1]],[0,0,ze,v1h[3][1]],[0,0,0,1]]);
		GoodClasses:=Include(GoodClasses, [WG,WH]);
		for v2 in RefListTransVec do
			if TestCohom(v1,v2,j,Ld) then
				Exclude(~ListTransVec,v2);
			end if;
		end for;
	end while;
	return ListOfActions, GoodClasses;
end function;

/* The normalizer N_C(Lambda_j) is for both j the group:*/

C1:=DiagonalMatrix([ze,ze^2,1]);
C2:=-t*Matrix([[1,ze^2,ze^2],[ze^2,1,ze^2],[ze^2,ze^2,1]]);
C3:=t*Matrix([[1,1,1],[1,ze^2,ze],[1,ze,ze^2]]);
Nor:=MatrixGroup<3,F| C1,C2,C3>;

/*************************************************************************************/

// PART II: The functions to check the cocycle-condition in Remark 3.7(b)

/* Given an affinity "f(z)=Cz + d" as a 4x4 matrix "B", the function "PartsAff" returns the 3x3 matrix "C" and the translation vector "d". */

function PartsAff(B)
	C:=Submatrix(B,[1,2,3],[1,2,3]);
	d:=Submatrix(B,[1,2,3],[4]);
	return C,d;
end function;

/* Given a matrix "C=C_{phi}" in the normalizer N_C(Lambda) and two actions "G1, H1" and "phiG2, phiH2", where the second one is composed with the automorphism "phi", the function "Existsd" checks the existence of a vector d in "Ld=Listd(j)" fulfilling the cocycle-condition. */

function Existsd(C,G1,H1,phiG2,phiH2,j,Ld)
	MPG1, TPG1:=PartsAff(G1);
	MPH1, TPH1:=PartsAff(H1);
	MPphiG2,TPphiG2:=PartsAff(phiG2);
	MPphiH2,TPphiH2:=PartsAff(phiH2);
	for d in Ld do
		if InLatt((MPphiG2-I3)*d-C*TPG1+TPphiG2,j) and InLatt((MPphiH2-I3)*d-C*TPH1+TPphiH2,j) then
			return true;
		end if;
	end for;
	return false;
end function;

/************************************************************************************/

/* PART III: the classification functions for the biholomorphic classification. */

/* Given a matrix "C" in the normalizer Nor=N_C(Lambda), the function "IdAuto" returns the corresponding automorphism "phi". More precisely, it returns the exponents [n1,n2,n3] and [m1,m2,m3] such that phi(g)=g^n1*h^n2*k^n3 and phi(h)=g^m1*h^m2*h^m3.*/

function IdAuto(C)
	for n1 in [0..2] do
	for n2 in [0..2] do
	for n3 in [0..2] do
		if C*g*C^-1 eq g^n1*h^n2*k^n3 then
			phig:=[n1,n2,n3];
		end if;
		if C*h*C^-1 eq g^n1*h^n2*k^n3 then
			phih:=[n1,n2,n3];
		end if;
	end for;
	end for;
	end for;
	return phig, phih;
end function;

/* The function "TestIso" checks if two given actions "W1" and "W2" lead to biholomorphic quotients. Remember that the actions are in the form [Phi(g),Phi(h)]. */

function TestIso(W1,W2,j,Ld)
	G1:=W1[1]; H1:=W1[2]; 
	G2:=W2[1]; H2:=W2[2];
	K2:=G2^-1*H2^-1*G2*H2;
	for C in Nor do
		phig, phih:=IdAuto(C);
		phiG2:=G2^(phig[1])*H2^(phig[2])*K2^(phig[3]);
		phiH2:=G2^(phih[1])*H2^(phih[2])*K2^(phih[3]);
		if Existsd(C,G1,H1,phiG2,phiH2,j,Ld) then
			return true;
		end if;
	end for;
	return false;
end function;

/* The function "ClassHe3" is the main classification function. It determines for each lattice all biholomorphism classes of 
   three-dimensional torus quotients by an action of He(3) with isolated fixed points. Running this function is used in the proof of  Proposition 4.18.
   Because of the size of the output and the length of the computation a file "He3.txt" is created. It contains for each "j" 
   1) the number of actions, 
   2) the number of good cohomology classes,
   3) the number of biholomorphism classes and 
   4) for each biholomorphism class a corresponding action on E^3/K_j. */

function ClassHe3(j)
	F:="He3.txt";
	fprintf F, "Kernel %o)\n \n", j;
	IsoClasses:=[];
	Ld:=Listd(j);
	LA,GoodClasses:=Actions(j,Ld);
	fprintf F, "Number of actions with isolated fixed points: %o \n \n", #LA;
	fprintf F, "Number of good cohomology classes: %o\n\n", #GoodClasses;
	RefListAct:=GoodClasses;
	while not IsEmpty(GoodClasses) do
		RefListAct:=GoodClasses;
		W1:=Rep(GoodClasses);
		Append(~IsoClasses,W1);
		for W2 in RefListAct do
			if TestIso(W1,W2,j,Ld) then
				Exclude(~GoodClasses,W2);
			end if;
		end for;
	end while;
	fprintf F, "Number of biholomorphism classes: %o \n \n", #IsoClasses;
	fprintf F, "Actions [G,H]: \n %o \n \n \n \n", IsoClasses;
	return "Classification for kernel", j, "is completed!";
end function;

/* Here, we run the classification function for each "j=1,2". */

for j in [1,2] do
	ClassHe3(j);
end for;