################################################# # Groebner cone, and subdivision computations A # ################################################# # In order to certify the calculations in "Qrefinementwithx34Noa4BadPrimes.sage" does not depend on the chosen weight vector, we need to check the Dumbbell Cone is not subdivided by the Grobner complex of A. This script computes the Grobner Cones for this polynomial and checks for potential subdivisions. # Our calculations are valid when the residue field has characteristic 0. Based on the results, we later refine the calculation to include positive characteristic, based on the initial forms we obtain. # The initial forms are computed in the script "initialFormsABCDQ4.sage" # The necessary data (including the polynomials) and macros are obtained by loading the following file: load("macroslocalJInvariantComputationsAndPrimesWithBadReduction.sage") load("Qrefinementwithx34Noa4.sage") # We create the fraction field of the ambient polynomial rings K = FractionField(S); KK = FractionField(SS); ######################################## # Calculation of the Groebner fan of A # ######################################## # Iq = ideal(A) # GFq = Iq.groebner_fan() # We pre-compute the Grobner fan: # GFqFan = GFq.polyhedralfan() # save(GFqFan,"GrobnerFanA.sobj") # We convert the data to Rational Polyhedral fan: # newGF = GFqFan.to_RationalPolyhedralFan() # save(newGF, "GFAFan_as_RationalPolyhedra.sobj") # newGF=load("GFAFan_as_RationalPolyhedra.sobj") # We load the pre-computed the Grober fan. GFqFan = load("GrobnerFanA.sobj") # We record the f-vector: # print GFqFan.f_vector() # [1, 12, 60, 120, 90, 20] # We confirm the dimension of the fan is the expected one: # print GFqFan.dim() # 6 # We record the coordinates of the rays of the Grobner fan: RaysGFqfan = GFqFan.rays() # print RaysGFqfan # [[-5, 1, 1, 1, 1, 1], [-1, -1, -1, -1, -1, 5], [-1, -1, -1, -1, 5, -1], [-1, -1, -1, 5, -1, -1], [-1, -1, 5, -1, -1, -1], [-1, 5, -1, -1, -1, -1], [1, -5, 1, 1, 1, 1], [1, 1, -5, 1, 1, 1], [1, 1, 1, -5, 1, 1], [1, 1, 1, 1, -5, 1], [1, 1, 1, 1, 1, -5], [5, -1, -1, -1, -1, -1]] # We record the maximal cones of the fan. Each cone is described by the indices of the extremal rays spanning these cones. Such indices refer to the list of 12 rays: MaximalConesA = GFqFan.maximal_cones().values()[0] # print MaximalConesA # [[0, 1, 2, 3, 6, 7], [0, 1, 2, 4, 6, 8], [0, 1, 3, 4, 6, 9], [0, 2, 3, 4, 6, 10], [0, 1, 2, 5, 7, 8], [0, 1, 3, 5, 7, 9], [0, 2, 3, 5, 7, 10], [0, 1, 4, 5, 8, 9], [0, 2, 4, 5, 8, 10], [0, 3, 4, 5, 9, 10], [1, 2, 6, 7, 8, 11], [1, 3, 6, 7, 9, 11], [2, 3, 6, 7, 10, 11], [1, 4, 6, 8, 9, 11], [2, 4, 6, 8, 10, 11], [3, 4, 6, 9, 10, 11], [1, 5, 7, 8, 9, 11], [2, 5, 7, 8, 10, 11], [3, 5, 7, 9, 10, 11], [4, 5, 8, 9, 10, 11]] # We record the maximal cones in the Grobner Fan of A as a dictionary of polyhedral objects. The keys coincide with the indices of the maximal cones in the output of the Gfan computation. PolyMaximalCones = MaximalCones(GFqFan) # We check that they have the expected dimension: # set([dim(x) for x in PolyMaximalConesA.values()]) # {6} ################### # Exponents of AT # ################### # Recall: the variables of SS are ordered a6,a5,x34,a3,a2,a1 # We use the variable Q to refer to the polynomial Q = AT # We record the monomials and coefficients of B, as well about the exponent vectors. monQ = Q.monomials() coeffQ = Q.coefficients() exponentVectorsQ = [x.exponents() for x in monQ] # We convert each the tuple of each entry (a list) into a list of integers. exponentVectorsQInZZ = [] m = len(exponentVectorsQ[0][0]) for x in exponentVectorsQ: v = [ZZ(x[0][j]) for j in range(0,m)] exponentVectorsQInZZ.append(v) # len(exponentVectorsQInZZ) # 177 ####################################### # Construct the Newton Polytope of AT # ####################################### # The calculations of Grobner fans only require the vertices of the Newton polytope of Q. The number of vertices of this polytope is 24 compared to the 177 monomials in Q. The computation of the Grobner fan of the full Q does not terminate, as opposed to that of the alternative polynomial AltQ. NPQ = Polyhedron(vertices= exponentVectorsQInZZ) # NPQ # A 5-dimensional polyhedron in ZZ^6 defined as the convex hull of 24 vertices # we record the extremal monomials of Q. extremalExponents = [tuple(list(x)) for x in NPQ.vertices()] # print len(extremalExponents) # 24 # We construct AltQ, a polynomial obtained as the sum of the terms of Q involving extremal monomials. AltQMonomials = [exponentVectorsQInZZ.index(list(x)) for x in extremalExponents] # len(AltQMonomials) # 24 AltQ = SS(0) for j in AltQMonomials: AltQ = AltQ + SS(coeffQ[j]*monQ[j]) # AltQ # 6*a6^2*a5^2*x34^2 + 8*a6^2*a5^2*a3^2 + 6*a6^2*x34^2*a3^2 + 6*a5^2*x34^2*a3^2 + 6*a6^2*a3^4 + 6*a5^2*a3^4 + 6*a6^2*a5^2*a2^2 + 6*a6^2*x34^2*a2^2 + 6*a5^2*x34^2*a2^2 + 8*a6^2*a3^2*a2^2 + 8*a5^2*a3^2*a2^2 + 6*x34^2*a3^2*a2^2 + 6*a3^4*a2^2 + 6*a6^2*a5^2*a1^2 + 6*a6^2*x34^2*a1^2 + 6*a5^2*x34^2*a1^2 + 8*a6^2*a3^2*a1^2 + 8*a5^2*a3^2*a1^2 + 6*x34^2*a3^2*a1^2 + 6*a3^4*a1^2 + 6*a6^2*a2^2*a1^2 + 6*a5^2*a2^2*a1^2 + 6*x34^2*a2^2*a1^2 + 8*a3^2*a2^2*a1^2 ######################################### # Calculation of the Groebner fan of AT # ######################################### # We use AltQ to compute the Grobner fan of AT: # Iq = ideal(AltQ) # GFq = Iq.groebner_fan() # We pre-compute the Grobner fan: GFqFan = GFq.polyhedralfan() save(GFqFan,"GrobnerFanANoa4.sobj") # We convert the data to Rational Polyhedral fan: # newGF = GFqFan.to_RationalPolyhedralFan() # save(newGF, "GFAFan_as_RationalPolyhedra.sobj") # newGF=load("GFAFan_as_RationalPolyhedra.sobj") # We load the pre-computed the Grober fan. GFqFan = load("GrobnerFanANoa4.sobj") # We record the f-vector: # print GFqFan.f_vector() # [1, 12, 56, 110, 88, 24] # We confirm the dimension of the fan is the expected one: # print GFqFan.dim() # 6 # We record the coordinates of the rays of the Grobner fan: RaysGFqfan = GFqFan.rays() # print RaysGFqfan # [[-5, 1, 1, 1, 1, 1], [-1, -1, -1, -1, -1, 5], [-1, -1, -1, -1, 5, -1], [-1, -1, 2, 2, -1, -1], [-1, -1, 5, -1, -1, -1], [-1, 5, -1, -1, -1, -1], [1, -5, 1, 1, 1, 1], [1, 1, -5, 1, 1, 1], [1, 1, 1, -5, 1, 1], [1, 1, 1, 1, -5, 1], [1, 1, 1, 1, 1, -5], [5, -1, -1, -1, -1, -1]] # We record the maximal cones of the fan. Each cone is described by the indices of the extremal rays spanning these cones. Such indices refer to the list of 12 rays: MaximalConesQ = GFqFan.maximal_cones().values()[0] # print MaximalConesQ # [[0, 1, 2, 4, 6, 8], [0, 1, 3, 4, 6, 9], [0, 2, 3, 4, 6, 10], [0, 1, 2, 5, 7, 8], [0, 1, 4, 5, 8, 9], [0, 2, 4, 5, 8, 10], [0, 3, 4, 5, 9, 10], [0, 1, 2, 6, 7], [0, 1, 5, 7, 9], [0, 2, 5, 7, 10], [0, 1, 3, 6, 7, 9], [0, 2, 3, 6, 7, 10], [0, 3, 5, 7, 9, 10], [1, 2, 6, 7, 8, 11], [1, 4, 6, 8, 9, 11], [2, 4, 6, 8, 10, 11], [3, 4, 6, 9, 10, 11], [1, 5, 7, 8, 9, 11], [2, 5, 7, 8, 10, 11], [4, 5, 8, 9, 10, 11], [1, 6, 7, 9, 11], [2, 6, 7, 10, 11], [5, 7, 9, 10, 11], [3, 6, 7, 9, 10, 11]] # We record the maximal cones in the Grobner Fan of C as a dictionary of polyhedral objects. The keys coincide with the indices of the maximal cones in the output of the Gfan computation. PolyMaximalConesAT = MaximalCones(GFqFan) # We check that they have the expected dimension: # set([dim(x) for x in PolyMaximalCones.values()]) # {6} ##################################### # Subdivisions induced on each cone # ##################################### # We start by loading the cones: load("allConesGenus2.sage") ########################################################### # Subdivision of Dumbbell induced by the Grobner fan of A # ########################################################### # The following script computes the intersection of the Dumbbell cone with all maximal cells in the Grobner fan of Q. IntersectionsQDumbbellCone = {} for i in range(0,len(PolyMaximalCones.keys())): # print str(i) polyCone =PolyMaximalCones[i] IntersectionQPolyCone = DumbbellCone.intersection(polyCone) IntersectionsQDumbbellCone[i] = IntersectionQPolyCone set([dim(x) for x in IntersectionsQDumbbellCone.values()]) # {1, 2, 3, 4, 5, 6} # We record those intersection of maximal dimension, i.e. the dimension of the Theta Cone. maxIntersections = [i for i in IntersectionsQDumbbellCone.keys() if dim(IntersectionsQDumbbellCone[i])==6] # print maxIntersections # [19] SubdivisionsOfDumbbellByQ = [IntersectionsQDumbbellCone[i] for i in maxIntersections] # print [len(SubdivisionsOfDumbbellByQ[i].rays()) for i in range(0,len(SubdivisionsOfDumbbellByQ))] # [5] # print [dim(SubdivisionsOfDumbbellByQ[i]) for i in range(0,len(SubdivisionsOfDumbbellByQ))] # [6] # No subdivision is produced. ######################################################### # Subdivision of Theta induced by the Grobner fan of AT # ######################################################### # The following script computes the intersection of the Theta cone with all maximal cells in the Grobner fan of A. IntersectionsQThetaCone = {} for i in range(0,len(PolyMaximalConesAT.keys())): # print str(i) polyCone =PolyMaximalConesAT[i] IntersectionQPolyCone = ThetaCone.intersection(polyCone) IntersectionsQThetaCone[i] = IntersectionQPolyCone set([dim(x) for x in IntersectionsQThetaCone.values()]) # {1, 2, 3, 4, 5, 6} # We record those intersection of maximal dimension, i.e. the dimension of the Theta Cone. maxIntersections = [i for i in IntersectionsQThetaCone.keys() if dim(IntersectionsQThetaCone[i])==6] # print maxIntersections # [22] SubdivisionsOfThetaByQ = [IntersectionsQThetaCone[i] for i in maxIntersections] # print [len(SubdivisionsOfThetaByQ[i].rays()) for i in range(0,len(SubdivisionsOfThetaByQ))] # [5] # print [dim(SubdivisionsOfThetaByQ[i]) for i in range(0,len(SubdivisionsOfThetaByQ))] # [6] # No subdivision is produced. ############################################################### # Subdivision of Figure Eight induced by the Grobner fan of A # ############################################################### # The following script computes the intersection of the Figure Eight cone with all maximal cells in the Grobner fan of A. IntersectionsQFigEightCone = {} for i in range(0,len(PolyMaximalCones.keys())): # print str(i) polyCone =PolyMaximalCones[i] IntersectionQPolyCone = FigEightCone.intersection(polyCone) IntersectionsQFigEightCone[i] = IntersectionQPolyCone set([dim(x) for x in IntersectionsQFigEightCone.values()]) # {1, 2, 3, 4, 5} # We record those intersection of maximal dimension, i.e. the dimension of the Theta Cone. maxIntersections = [i for i in IntersectionsQFigEightCone.keys() if dim(IntersectionsQFigEightCone[i])==5] # print maxIntersections # [18, 19] SubdivisionsOfFigEightByQ = [IntersectionsQFigEightCone[i] for i in maxIntersections] # print [len(SubdivisionsOfFigEightByQ[i].rays()) for i in range(0,len(SubdivisionsOfFigEightByQ))] # [4, 4] # print [dim(SubdivisionsOfFigEightByQ[i]) for i in range(0,len(SubdivisionsOfFigEightByQ))] # [5, 5] # We check the two cells agree: SubdivisionsOfFigEightByQ[0] == SubdivisionsOfFigEightByQ[1] True # No subdivision is produced. ########################################################## # Subdivision of Type IV induced by the Grobner fan of A # ########################################################## # The following script computes the intersection of the Type IV cone with all maximal cells in the Grobner fan of A. IntersectionsQTypeIVCone = {} for i in range(0,len(PolyMaximalCones.keys())): # print str(i) polyCone =PolyMaximalCones[i] IntersectionQPolyCone = TypeIVCone.intersection(polyCone) IntersectionsQTypeIVCone[i] = IntersectionQPolyCone set([dim(x) for x in IntersectionsQTypeIVCone.values()]) # {1, 2, 3, 4, 5} # We record those intersection of maximal dimension, i.e. the dimension of the Theta Cone. maxIntersections = [i for i in IntersectionsQTypeIVCone.keys() if dim(IntersectionsQTypeIVCone[i])==5] # print maxIntersections # [19] SubdivisionsOfTypeIVByQ = [IntersectionsQTypeIVCone[i] for i in maxIntersections] # print [len(SubdivisionsOfTypeIVByQ[i].rays()) for i in range(0,len(SubdivisionsOfTypeIVByQ))] # [4] # print [dim(SubdivisionsOfTypeIVByQ[i]) for i in range(0,len(SubdivisionsOfTypeIVByQ))] # [5] # No subdivision is produced. ######################################################### # Subdivision of Type V induced by the Grobner fan of A # ######################################################### # The following script computes the intersection of the Type V cone with all maximal cells in the Grobner fan of A. IntersectionsQTypeVCone = {} for i in range(0,len(PolyMaximalCones.keys())): # print str(i) polyCone =PolyMaximalCones[i] IntersectionQPolyCone = TypeVCone.intersection(polyCone) IntersectionsQTypeVCone[i] = IntersectionQPolyCone set([dim(x) for x in IntersectionsQTypeVCone.values()]) # {1, 2, 3, 4} # We record those intersection of maximal dimension, i.e. the dimension of the Theta Cone. maxIntersections = [i for i in IntersectionsQTypeVCone.keys() if dim(IntersectionsQTypeVCone[i])==4] # print maxIntersections # [19] SubdivisionsOfTypeVByQ = [IntersectionsQTypeVCone[i] for i in maxIntersections] # print [len(SubdivisionsOfTypeVByQ[i].rays()) for i in range(0,len(SubdivisionsOfTypeVByQ))] # [3] # print [dim(SubdivisionsOfTypeVByQ[i]) for i in range(0,len(SubdivisionsOfTypeVByQ))] # [4] # No subdivision is produced. ########################################################## # Subdivision of Type VI induced by the Grobner fan of A # ########################################################## # The following script computes the intersection of the Type VI cone with all maximal cells in the Grobner fan of A. IntersectionsQTypeVICone = {} for i in range(0,len(PolyMaximalCones.keys())): # print str(i) polyCone =PolyMaximalCones[i] IntersectionQPolyCone = TypeVICone.intersection(polyCone) IntersectionsQTypeVICone[i] = IntersectionQPolyCone set([dim(x) for x in IntersectionsQTypeVICone.values()]) # {1, 2, 3, 4} # We record those intersection of maximal dimension, i.e. the dimension of the Theta Cone. maxIntersections = [i for i in IntersectionsQTypeVICone.keys() if dim(IntersectionsQTypeVICone[i])==4] # print maxIntersections # [15, 18, 19] SubdivisionsOfTypeVIByQ = [IntersectionsQTypeVICone[i] for i in maxIntersections] # print [len(SubdivisionsOfTypeVIByQ[i].rays()) for i in range(0,len(SubdivisionsOfTypeVIByQ))] # [3, 3, 3] # print [dim(SubdivisionsOfTypeVIByQ[i]) for i in range(0,len(SubdivisionsOfTypeVIByQ))] # [4, 4, 4] # We check that these intersections are the same. We conclude there is no subdivision. # all( [SubdivisionsOfTypeVIByQ[i] == SubdivisionsOfTypeVIByQ[j] for i in range(0,len(maxIntersections)-1) for j in range(i+1,len(maxIntersections))]) # True # No subdivision is produced. ########################################################### # Subdivision of Type VII induced by the Grobner fan of A # ########################################################### # The following script computes the intersection of the Type VII cone with all maximal cells in the Grobner fan of A. IntersectionsQTypeVIICone = {} for i in range(0,len(PolyMaximalCones.keys())): # print str(i) polyCone =PolyMaximalCones[i] IntersectionQPolyCone = TypeVIICone.intersection(polyCone) IntersectionsQTypeVIICone[i] = IntersectionQPolyCone set([dim(x) for x in IntersectionsQTypeVIICone.values()]) # {1, 2, 3} # We record those intersection of maximal dimension, i.e. the dimension of the Theta Cone. maxIntersections = [i for i in IntersectionsQTypeVIICone.keys() if dim(IntersectionsQTypeVIICone[i])==3] # print maxIntersections # [12, 14, 15, 17, 18, 19] SubdivisionsOfTypeVIIByQ = [IntersectionsQTypeVIICone[i] for i in maxIntersections] # print [len(SubdivisionsOfTypeVIIByQ[i].rays()) for i in range(0,len(SubdivisionsOfTypeVIIByQ))] # [2, 2, 2, 2, 2, 2] # print [dim(SubdivisionsOfTypeVIIByQ[i]) for i in range(0,len(SubdivisionsOfTypeVIIByQ))] # [3, 3, 3, 3, 3, 3] # We check that these intersections are the same. We conclude there is no subdivision. # all( [SubdivisionsOfTypeVIIByQ[i] == SubdivisionsOfTypeVIIByQ[j] for i in range(0,len(maxIntersections)-1) for j in range(i+1,len(maxIntersections))]) # True # No subdivision is produced. ############################################################################# # CONCLUSION: No subdivisions are produced and we can use any sample point to compute initial forms. ##############################################################################