// *********************************************************************************************************************************** // ************************************************* Z/3xZ/3 case ******************************************************************** // *********************************************************************************************************************************** // The function "Kernels" is used to determine the orbits of the action of the normalizer N_{Aut(E^3)}(Z_3^2) on the // set $\mathcal K$ of possible kernels "K < Z_3^3 = Fix(ze)^3=^3" of the addition map. As an argument it takes the dimension "dim" // of the kernels which is between 0 and 2. In the computation we identify t with 1 and work with the finite field F3 F3:=FiniteField(3); Nor:=sub; V:=VectorSpace(F3,3); UnitVec:=[V![1,0,0],V![0,1,0],V![0,0,1]]; function Kernels(dim) List:=[]; Orb:=OrbitsOfSpaces(Nor,dim); for W in Orb do test:=true; for e in UnitVec do if e in W[2] then test:=false; break e; end if; end for; if test then List:=Append(List,W[2]); end if; end for; return List; end function; // There are precisely 4 orbist: 1 of dim 0, 2 of dim 1, 1 of dim 2 /* #Kernels(0); #Kernels(1); #Kernels(2); */ /* ********* Below is the main part of our code **************************** With this code, we classify all 3-dimensional quotients of abelian varieties by an action of Z_3^2 that has a non-empty and finite fixed locus and preserves the volume form. In particular, we use it to perform the computations in the proof of Proposition 4.26. The code consits of three parts: PART I: generation of all Z_3^2-actions with isolated fixed points and the initialization 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 Z_3^2-actions with 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:=CyclotomicField(3); /* We choose generators h and k of Z_3^2. According to Theorem 2.3, the analytic representation is given by:*/ 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]); // These are representatives for the 4 orbits, i.e., the kernels K_i of the addition map, that we will use. K1:={Matrix(F,3,1,[0,0,0])}; K2:={a*Matrix(F,3,1,[t,t,0]): a in {0,1,-1}}; K3:={a*Matrix(F,3,1,[t,t,t]): a in {0,1,-1}}; K4:={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,K3,K4]; /* 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,...,4" 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.21). */ function GoodCond(a1,a2,a3,j) for t1 in [0,t,-t] do for t2 in [0,t,-t] do w1:=Matrix(F,3,1,[a1,t1,t2]); w2:=Matrix(F,3,1,[t1,a2,t2]); w3:=Matrix(F,3,1,[t1,t2,a3]); if InLatt(w1,j) or InLatt(w2,j) or InLatt(w3,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.25. Note that all candidates are contained in the set E[9]^3. We check with the code which of these elements are in fact fiexed 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)*I3*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(Z_3^2,E^3/K_j). Input: "v1", "v2": two translation vectors; "j": parameter for the kernel; "Ld": list of translation parts of the biholomorphisms computed with "Listd(j)" */ function TestCohom(v1,v2,j,Ld) for d in Ld do if InLatt(v1-v2-(h*d-d),j) then return true; end if; end for; return false; end function; /* The function "Actions" determines all actions with only isolated fixed points with translation part in standard form on E^3/K_j, for each j=1,...,4 (first output). The second output is a list consisting of one representative for each good comohomology class in H^1(Z_3^2,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 v:=Matrix(F,3,1,[(ze-1)*a1,(ze-1)*a2,(ze-1)*a3]); if InLatt(v,j) and GoodCond(a1,a2,a3,j) then ListTransVec:=Include(ListTransVec, Matrix(F,3,1,[a1,a2,a3])); ListOfActions:=Include(ListOfActions, Matrix(F,4,4, [[1,0,0,a1],[0,ze^2,0,a2],[0,0,ze,a3],[0,0,0,1]])); end if; end for; end for; end for; GoodClasses:={}; RefListTransVec:=ListTransVec; while not IsEmpty(ListTransVec) do RefListTransVec:=ListTransVec; v1:=Rep(ListTransVec); GoodClasses:=Include(GoodClasses,Matrix(F,4,4, [[1,0,0,v1[1][1]],[0,ze^2,0,v1[2][1]],[0,0,ze,v1[3][1]],[0,0,0,1]])); 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 function "Normal" determines the normalizers N_C(Lambda_j) from Proposition 4.24 */ /* First, we define the normalizer N_{Aut(E^3)}(rho(Z_3^2)):*/ Nor:=MatrixGroup<3,F| DiagonalMatrix([-ze,1,1]), Matrix([[0,1,0],[1,0,0],[0,0,1]]), Matrix([[0,1,0],[0,0,1],[1,0,0]])>; function Normal(j) List:={}; K:=Kernels[j]; for C in Nor do test:= true; for l in K do if not InLatt(C*l,j) or not InLatt(C^-1*l,j) then test:=false; break l; end if; end for; if test then List:=Include(List,C); end if; end for; return List; end function; /*******************************************************************************/ /* 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_j) and two actions "H1" and "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)" fulfillling the cocylcle-condition.*/ function Existsd(C,H1,phiH2,j,Ld) MPH1, TPH1:=PartsAff(H1); MPphiH2,TPphiH2:=PartsAff(phiH2); for d in Ld do if 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 N_{Aut(E^3)}(rho(Z_3^2)), the function "IdAuto" returns the corresponding automorphism. More precisley, it returns the image of h as a tuple [a,b] s.t. phi(h)=h^a*k^b. (Remark that k is fixed by phi). The possible images of h in terms of [a,b] s.t. phi(h)=h^a*k^b are listed at the beginning of the function. */ function IdAuto(C) ListImages:=[[1,0],[2,0],[1,1],[2,2],[1,2],[2,1]]; for n in ListImages do if C*h*C^-1 eq h^n[1]*k^n[2] then return n; end if; end for; end function; /* The function "TestIso" checks if two given actions "W1" and "W2" lead to biholomorphic quotients. As an input it gets the actions "W1" and "W2", the paramter "j", the normalizer "N=N_C(Lambda_j)", and the list of translation vectors "Ld=Listd(j)". */ function TestIso(W1,W2,j,N,Ld) H1:=W1; H2:=W2; for C in N do phi:=IdAuto(C); phiH2:=H2^phi[1]*Matrix(F,4,4,[[ze,0,0,0],[0,ze,0,0],[0,0,ze,0],[0,0,0,1]])^phi[2]; if Existsd(C,H1,phiH2,j,Ld) then return true; end if; end for; return false; end function; /* The function "ClassZ3xZ3" is the main classification function. It determines for each lattice all biholomorphism classes of three-dimensional quotients of abelian varities by an action of Z_3^2 that has finite and non-empty fixed locus and preserves the volume form. Running this function finishes the proof of Proposition 4.26. Because of the size of the output and the length of the computation a file "Z3xZ3.txt" is created. It contains for each "j" 1) the number of actions, 2) the number of good cohomology classes, 3) the size of the normalizer N_C(Lambda_j), 4) the number of biholomorphism classes and 5) for each biholomorphism class a corresponding action on E^3/K_j. */ function ClassZ3xZ3(j) F:="Z3xZ3.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; N:=Normal(j); fprintf F, "Size of the normalizer: %o \n \n", #N; while not IsEmpty(GoodClasses) do RefListAct:=GoodClasses; W1:=Rep(GoodClasses); Append(~IsoClasses,W1); for W2 in RefListAct do if TestIso(W1,W2,j,N,Ld) then Exclude(~GoodClasses,W2); end if; end for; end while; fprintf F, "Number of biholomorphism classes: %o \n \n", #IsoClasses; fprintf F, "Actions [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,...,4". */ for j in [1..4] do ClassZ3xZ3(j); end for; // ************************************************************************************************************************************************* // *************************************************** Output Z/3xZ/3 case ************************************************************************* // ************************************************************************************************************************************************* Kernel 1) Number of actions with isolated fixed points: 8 Number of good cohomology classes: 8 Size of the normalizer: 1296 Number of biholomorphism classes: 1 Actions [H]: [ [ 1 0 0 1/3*(2*ze + 1)] [ 0 -ze - 1 0 1/3*(ze + 2)] [ 0 0 ze 1/3*(2*ze + 1)] [ 0 0 0 1] ] Kernel 2) Number of actions with isolated fixed points: 36 Number of good cohomology classes: 4 Size of the normalizer: 216 Number of biholomorphism classes: 1 Actions [H]: [ [ 1 0 0 1/3*ze] [ 0 -ze - 1 0 1/3*ze] [ 0 0 ze 1/3*(2*ze + 1)] [ 0 0 0 1] ] Kernel 3) Number of actions with isolated fixed points: 54 Number of good cohomology classes: 6 Size of the normalizer: 324 Number of biholomorphism classes: 1 Actions [H]: [ [ 1 0 0 2/3] [ 0 -ze - 1 0 2/3*ze] [ 0 0 ze 2/3] [ 0 0 0 1] ] Kernel 4) Number of actions with isolated fixed points: 54 Number of good cohomology classes: 2 Size of the normalizer: 324 Number of biholomorphism classes: 1 Actions [H]: [ [ 1 0 0 1/3*ze] [ 0 -ze - 1 0 1/3] [ 0 0 ze 2/3] [ 0 0 0 1] ] // ******************************************************************************************************************************************************************************* // ********************************************************************************* He(3) case ********************************************************************************** // ******************************************************************************************************************************************************************************* /* 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:=CyclotomicField(3); /* The group G=He(3) can be presented as G= 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; // ******************************************************************************************************************************************************************************* // ********************************************************************************* Output He(3) case *************************************************************************** // ******************************************************************************************************************************************************************************* Kernel 1) Number of actions with isolated fixed points: 486 Number of good cohomology classes: 6 Number of biholomorphism classes: 1 Actions [G,H]: [ [ [ 0 0 1 1/3*(2*ze + 1)] [ 1 0 0 0] [ 0 1 0 1/3*(2*ze + 1)] [ 0 0 0 1], [ 1 0 0 1/3*ze] [ 0 -ze - 1 0 1/3*ze] [ 0 0 ze 1/3*ze] [ 0 0 0 1] ] ] Kernel 2) Number of actions with isolated fixed points: 1458 Number of good cohomology classes: 6 Number of biholomorphism classes: 1 Actions [G,H]: [ [ [ 0 0 1 0] [ 1 0 0 1/3*(ze + 2)] [ 0 1 0 0] [ 0 0 0 1], [ 1 0 0 2/3*ze] [ 0 -ze - 1 0 2/3] [ 0 0 ze 2/3] [ 0 0 0 1] ] ]