1################################################################################# # FIND LINES FOR THE RAY A ANALYZING THE SHAPES OF THE POSSIBLE SINGULAR MINORS # ################################################################################# # The procedure used for ruling out potential tropical non-boundary lines for all cones in the Yoshida fan was successful for all but one type of ray, namely, ray a. The aforementioned method ruled out 12 potential lines (labeled by extremal curves), so 15 remained to be analyzed. The failure in these cases is caused by the fact that the minimizing factor in each of the 3 by 3-tropical minors involve "None" entries, i.e. entries for which the expected valuation need not be the true one. By inspection, we observed that some of these 3 by 3 submatrices have many infinity entries, so the actual minor calculation involves fewer than 6 terms, and all of them involve some "None" entries. Ideally, we want to search for shapes that yield only 2 terms for the tropical minor. # To solve the question, we add an extra feature to the function checkNonVanishingMinorsWithInfinities defined on the script findLines.sage, namely that writes down the "shape" of the 3 by 3 submatrices. We call the new function checkNonVanishingMinorsWithInfinitiesAndShape. We are interested in the shapes that have a row with 2 infinity entries (marked with "-") and an extra no "None" entry, i.e. corresponding to a known true valuation. For these shapes, the tropical minor will come from a 2x2 submatrix. We look for those 2x2 submatrices of that have a column of "?" (corresponding to undeterminate valuations) and "*" (corresponding to a known valuation). The entries ? indicate the corresponding coordinates in the 5 classical boundary points in P^44 have non-monomial factors in Yoshidas functions. # For each of the 15 relevant extremal curves, we search for these shapes and record the relevant triples of rows and columns, in addition to the shape of this 3 by 3 minor. We record the entries of the original 5x45 matrix associated to the column with two "?"s and call the non-monomial factors of these two entries by A and B. They are rational functions in the Yoshidas. # The function 'checkRatio' computes the ratio between two factorized rational functions in the Yoshida variables. We use the homomorphism YtoD to rewrite the product of all non-monomial factors of this ratio as a Laurent monomial in the positive roots in W(E6). We expect their ratio to be a monomial in the Yoshidas. The result is the entry A/B of Table 2 in the website. The ratio will be a monomial in the cube roots of the Yoshida variables. The output shows that the uncertainty between the two relevant entries marked with "?" can be ruled out: both quantities jump by the same amount, so the 3 by 3 tropical minor will be singular for any choice of d's with the prescribed valuations. #Each calculation for the 15 extremal curves takes a few seconds on a 2.4 GHz Intel(R) Core 2 Duo with 3MB cache and 2GB RAM. load("findLines.sage") cone = load("Input/aCell.sobj") M_with_nones = load("Input/TropicalMa_with_nones_signed_ordered_permutedCols.sobj") M_without_nones = load("Input/TropicalMa_no_nones_signed_ordered_permutedCols.sobj") pds = load("Input/AllPds_signed_ordered_permutedCols.sobj") YM = load("../../../software/Yoshida/Output/Yoshida_matrix.sobj") positive_roots = load("../../../software/Yoshida/Scripts/Input/rootsE6.sobj") roots = positive_roots keys = load("../../../software/ComputeLines/Scripts/Input/anticanonical_keys.sobj") #keys = sorted(pds[E1][0].keys(), reverse=True) os.chdir('../../../software/Yoshida/Scripts/') load("Yoshida.sage") os.chdir('../../../software/ComputeLines/Scripts/') yoshidas = [VectorToYoshida(YM[i], positive_roots) for i in range(0,40)] DField = FractionField(PolynomialRing(QQ, ds)) YtoD = YField.hom([DField(y) for y in yoshidas]) #A simple calculation shows that the Yoshida matrix YM has rank 16. A basis is given by the rows 5 and [17..31] of YM. They are not a Z-span of the row space of the Yoshida matrix: they have index 3 in their saturation (i.e. the intersection of the row space spanned over Q and Z^36). Thus, these 16 Yoshida functions are a multiplicative basis of all Laurent monomials in the Yoshidas, up to cube roots. #By construction, each element of this basis is a tuple of length 36, corresponding to the exponent vector of the ordered 36 positive roots of W(E6) in the factorization of each Yoshida function. The ordered positive roots are loaded. We use this basis to find an expression for the cube of A/B in terms of these Yoshida functions. We know such expression exists by construction (A and B are rational functions in the Yoshidas). # For simplicity, we have saved the YM basis as "Input/expVectorsZBasisIndex3.sobj" # A=matrix([YM[k] for k in [5]+range(17,32)]) # A.rank() # 16 # A # [0 0 1 0 0 1 0 1 0 0 0 0 1 0 0 1 0 0 0 0 0 0 1 0 0 1 0 0 1 0 0 0 0 0 1 0] # [0 0 0 1 0 1 0 0 0 1 0 1 1 0 0 1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 1] # [0 1 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 0 0 0 0 0 0] # [0 0 0 0 0 0 0 1 0 0 1 0 1 0 0 0 0 0 1 0 1 0 0 0 0 1 0 1 0 1 0 1 0 0 0 0] # [1 0 0 0 0 1 1 1 0 0 1 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1] # [0 1 0 0 0 1 1 0 0 1 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 1 0 1 0 1 0 0 1 0 0] # [1 1 1 0 1 1 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1] # [1 0 0 0 0 0 0 1 1 0 1 0 0 0 0 0 0 1 0 0 1 0 1 0 0 0 0 0 0 0 0 0 1 0 1 0] # [0 0 0 0 0 0 0 1 0 0 0 1 1 0 1 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 1 1 0 0 0] # [0 0 1 0 1 0 0 0 0 0 0 0 1 0 1 0 0 0 1 1 0 1 0 0 0 1 0 0 0 0 0 0 0 0 0 1] # [1 1 0 0 0 0 0 0 1 0 1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 1 0 0 1 0 0] # [0 0 0 0 0 0 1 1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 1 1 1 0 0 0 0 0] # [0 0 0 1 0 0 0 0 0 0 0 0 0 1 0 1 0 0 1 1 0 0 0 0 0 1 0 0 1 1 1 0 0 0 0 0] # [0 0 0 1 0 0 0 0 0 0 0 1 0 1 0 0 1 0 0 0 0 0 0 1 1 0 0 1 0 1 0 1 0 0 0 0] # [1 0 0 0 1 0 0 1 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 1 0 1 0 0 0 1 0 0 0 0 1 0] # [0 0 0 0 1 0 1 0 0 1 0 1 0 0 1 0 0 0 0 0 0 0 0 1 1 0 1 0 0 0 0 0 0 0 0 1] # listminorsA = (A.matrix_from_columns([15..35])).minors(16) # ss = set(listminorsA) # ss # {-9, -6, -3, 0, 3, 6, 9, 12} # save(A, "Input/expVectorsZBasisIndex3.sobj") uyvs_basis = load("Input/expVectorsZBasisIndex3.sobj") # sage: YM.rank() # 16 # sage: matrix(uyvs_basis).rank() # 16 # The next function picks two triples of numbers in [5] and [45], a cone in the Yoshida fan and the 2 tropical matrices with and without 'None' entries (i.e. actual and expect valuation of the 5 boundary points pds in P^44). It computes the corresponding tropical 3 by 3 minor, records the shape of the minor for the matrix with actual valuations and outputs true or false whenever the tropical minor of the matrix with expected valuations is singular or not. def checkNonVanishingMinorsWithInfinitiesAndShape(rows, columns, cone, M_without_nones, M_with_nones): J = sorted(rows) [i,j,k] = sorted(columns) G = list(SymmetricGroup(3)) # Extract the submatrix J x [i,j,k] sub_matrix = [[M_without_nones[J[0]][i], M_without_nones[J[0]][j], M_without_nones[J[0]][k]], [M_without_nones[J[1]][i], M_without_nones[J[1]][j], M_without_nones[J[1]][k]], [M_without_nones[J[2]][i], M_without_nones[J[2]][j], M_without_nones[J[2]][k]]] # Take the determinant of the submatrix # Product becomes + and + becomes min. But we don't actually take the min; we keep the whole list. det_sub_matrix = [tropicalMult([sub_matrix[0][p(1)-1], sub_matrix[1][p(2)-1], sub_matrix[2][p(3)-1]]) for p in G] # Taking the min is done by is_trop_zero. # is_trop_zero(v, exp) will return a list [m] where the m th term in exp achieves the minimum at v. evaluated_minor = [is_trop_zero(vector(v), det_sub_matrix) for v in cone.rays()] # We also print the shape of the submatrix for x in J: for y in [i,j,k]: entry = M_with_nones[x][y] if entry == None: print "?", elif entry == +Infinity: print "-", else: print "*", print "" # Now we intersect these minimizers intersection_of_minimizers = intersect_all(evaluated_minor) if len(intersection_of_minimizers) == 1: return True else: return False # #The next function that expresses the ratio between two entries of two boundary points associated to a potential tropical line as a product of positive roots. The entries pd1 and pd2 are factored in terms of Yoshida functions. Their ratio should be a monomial in the Yoshidas times a product of non-monomial factors in the Yoshidas. We convert the quotient of these non-monomial factors to a product of positive roots in W(E6) using the YtoD homomorphism. #The entries of pds are factored in terms of Yoshida functions. # This function is used to check that even in the case when the valuations are higher than expected, both terms in the 2x2 minor will go up by the same amount. def checkRatio(entry1, entry2, pds): pd1 = pds[entry1[0]][keys[entry1[1]]] pd2 = pds[entry2[0]][keys[entry2[1]]] f = (pd1/pd2) binomials = 1 for (factor, exponent) in f: if len(factor.monomials()) > 1: binomials = binomials * factor^exponent return YtoD(binomials).factor() # def checkRatioMonomials(entry1, entry2, pds): # pd1 = pds[entry1[0]][keys[entry1[1]]] # pd2 = pds[entry2[0]][keys[entry2[1]]] # f = (pd1/pd2) # allMonFactors = 1 # for (factor, exponent) in f: # if len(factor.monomials()) == 1: # allMonFactors = allMonFactors * factor^exponent # return YtoD(allMonFactors).factor() #The next function expresses a product of positive roots as a Laurent monomial in the 16 exponent vectors of a Yoshida Q-basis, whenever possible. The result is correct up to sign, and we check the sign on a different function def constructMonomialFromProduct(expressionInRoots, roots, basisOfYoshidas): v_exp = exponent_vector(expand(expressionInRoots), roots) soln = matrix(basisOfYoshidas).transpose() \ vector(v_exp) return soln # The next function finds the correct sign in the monomial expression of Yoshidas. We multiply the input vertex by 3 to avoid cube roots of Yoshidas. labels = [5]+[17..31] def findConstant(ratioInY): factorInYs = 1 triple = 3*vector(ratioInY) for k in range(0,16): factorInYs = factorInYs*(yoshidas[labels[k]].factor())^triple[k] return factorInYs ########## # For E3 # ########## rows = [0,1,2] columns = [8,9,24] extremal_curve = E3 checkNonVanishingMinorsWithInfinitiesAndShape(rows, columns, cone, M_without_nones[extremal_curve], M_with_nones[extremal_curve]) # * - - # - * ? # * * ? # True ratioInDs = checkRatio((1,24), (2,24), pds[extremal_curve]) # We record the output: print ratioInDs #-1 ratioInYoshidas = constructMonomialFromProduct(ratioInDs, positive_roots,uyvs_basis) # We record the output: print ratioInYoshidas # (0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0) ########## # For E4 # ########## rows = [0,1,2] columns = [8,9,13] extremal_curve = E4 checkNonVanishingMinorsWithInfinitiesAndShape(rows, columns, cone, M_without_nones[extremal_curve], M_with_nones[extremal_curve]) # * - ? # - * - # * * ? # True ratioInDs = checkRatio((0,13), (2,13), pds[extremal_curve]) # We record the output: print ratioInDs #(-d2 + d4)^-1 * (d2 + d4 + d5)^-1 * (d1 - d6)^-1 * (d1 + d5 + d6)^-1 * (d4 - d6) * (d4 + d5 + d6) * (-d1 + d2) * (d1 + d2 + d5) ratioInYoshidas = constructMonomialFromProduct(ratioInDs, positive_roots,uyvs_basis) # We record the output: print ratioInYoshidas #(1/3, 0, -2/3, 0, -1/3, -1/3, 1/3, 0, 0, 0, 2/3, -1/3, 0, 0, 1/3, 0) # Write the cube as product of Yoshidas # Y[5] Y[18]^-2 Y[20]^-1 Y[21]^-1 Y[22] Y[26]^2 Y[27]^-1 Y[30] #We find the appropriate constant: print expand(findConstant(ratioInYoshidas)/(ratioInDs)^3) # We record the output: # 1 ########## # For E5 # ########## rows = [0,1,2] columns = [7,32,33] extremal_curve = E5 checkNonVanishingMinorsWithInfinitiesAndShape(rows, columns, cone, M_without_nones[extremal_curve], M_with_nones[extremal_curve]) # * ? - # - - * # * ? * # True ratioInDs = checkRatio((0,32), (2,32), pds[extremal_curve]) # We record the output: print ratioInDs #(d2 + d5 + d6)^-1 * (d2 + d3 + d4)^-1 * (d1 + d4 + d6)^-1 * (d1 + d3 + d5)^-1 * (-d4 + d5) * (d3 - d6) * (-d1 + d2) * (d1 + d2 + d3 + d4 + d5 + d6) ratioInYoshidas = constructMonomialFromProduct(ratioInDs, positive_roots,uyvs_basis) # We record the output: print ratioInYoshidas (-1/3, 1, 2/3, -1, 1/3, -2/3, -1/3, 0, 0, 0, 1/3, 1/3, 0, -1, 2/3, 0) # Write the cube as product of Yoshidas: # Y[5]^-1 Y[17]^3 Y[18]^2 Y[19]^-3 Y[20] Y[21]^-2 Y[22]^-1 Y[26] Y[27] Y[29]^-3 Y[30]^2 #We find the appropriate constant: print expand(findConstant(ratioInYoshidas)/(ratioInDs)^3) # We record the output: # -1 ########## # For E6 # ########## rows = [0,1,2] columns = [7,8,12] extremal_curve = E6 checkNonVanishingMinorsWithInfinitiesAndShape(rows, columns, cone, M_without_nones[extremal_curve], M_with_nones[extremal_curve]) # - * - # * - ? # * * ? # True ratioInDs = checkRatio((1,12), (2,12), pds[extremal_curve]) # We record the output: print ratioInDs #1 ratioInYoshidas = constructMonomialFromProduct(ratioInDs, positive_roots,uyvs_basis) # We record the output: print ratioInYoshidas # (0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0) ########### # For F12 # ########### rows = [0,2,4] columns = [17,26,44] extremal_curve = F12 checkNonVanishingMinorsWithInfinitiesAndShape(rows, columns, cone, M_without_nones[extremal_curve], M_with_nones[extremal_curve]) # ? - * # - * - # ? * * # True ratioInDs = checkRatio((0,17), (4,17), pds[extremal_curve]) # We record the output: print ratioInDs # -1 ratioInYoshidas = constructMonomialFromProduct(ratioInDs, positive_roots,uyvs_basis) # We record the output: print ratioInYoshidas # (0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0) ########### # For F34 # ########### rows = [0,2,4] columns = [5,7,23] extremal_curve = F34 checkNonVanishingMinorsWithInfinitiesAndShape(rows, columns, cone, M_without_nones[extremal_curve], M_with_nones[extremal_curve]) # * - - # - * ? # * * ? # True ratioInDs = checkRatio((2,23), (4,23), pds[extremal_curve]) # We record the output: print ratioInDs # 1 ratioInYoshidas = constructMonomialFromProduct(ratioInDs, positive_roots,uyvs_basis) # We record the output: print ratioInYoshidas # (0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0) ########### # For F35 # ########### rows = [0,1,2] columns = [6,15,23] extremal_curve = F35 checkNonVanishingMinorsWithInfinitiesAndShape(rows, columns, cone, M_without_nones[extremal_curve], M_with_nones[extremal_curve]) # * * ? # - * - # * - ? # True ratioInDs = checkRatio((0,23), (2,23), pds[extremal_curve]) # We record the output: print ratioInDs #(d3 - d6)^-1 * (d3 + d4 + d6)^-1 * (-d1 + d2)^-1 * (d1 + d2 + d4)^-1 * (-d2 + d3) * (d2 + d3 + d4) * (d1 - d6) * (d1 + d4 + d6) ratioInYoshidas = constructMonomialFromProduct(ratioInDs, positive_roots,uyvs_basis) # We record the output: print ratioInYoshidas # (2/3, 0, -1/3, 0, -2/3, 1/3, -1/3, 0, -1, 1, 1/3, 1/3, -1, 1, -1/3, 0) # We write the cube as product of Yoshidas # Y[5]^2 Y[18]^-1 Y[20]^-2 Y[21] Y[22]^-1 Y[24]^-3 Y[25]^3 Y[26] Y[27] Y[28]^-3 Y[29]^3 Y[30]^-1 #We find the appropriate constant: print expand(findConstant(ratioInYoshidas)/(ratioInDs)^3) # We record the output: # 1 ########### # For F36 # ########### rows = [0,1,2] columns = [6,9,19] extremal_curve = F36 checkNonVanishingMinorsWithInfinitiesAndShape(rows, columns, cone, M_without_nones[extremal_curve], M_with_nones[extremal_curve]) # * - - # - * ? # * * ? # True ratioInDs = checkRatio((1,19), (2,19), pds[extremal_curve]) # We record the output: print ratioInDs # -1 ratioInYoshidas = constructMonomialFromProduct(ratioInDs, positive_roots,uyvs_basis) # We record the output: print ratioInYoshidas # (0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0) ########### # For F45 # ########### rows = [0,1,2] columns = [7,10,12] extremal_curve = F45 checkNonVanishingMinorsWithInfinitiesAndShape(rows, columns, cone, M_without_nones[extremal_curve], M_with_nones[extremal_curve]) # * * ? # - * - # * - ? # True ratioInDs = checkRatio((0,12), (2,12), pds[extremal_curve]) print ratioInDs #(d5 - d6)^-1 * (d4 + d5 + d6)^-1 * (-d1 + d2)^-1 * (d1 + d2 + d4)^-1 * (-d2 + d5) * (d2 + d4 + d5) * (d1 - d6) * (d1 + d4 + d6) ratioInYoshidas = constructMonomialFromProduct(ratioInDs, positive_roots,uyvs_basis) # We record the output: print ratioInYoshidas # (1/3, 0, 1/3, 0, -1/3, -1/3, -2/3, 0, 0, 0, 2/3, -1/3, 0, 0, -2/3, 1) # Write the cube as product of Yoshidas: #Y[5] Y[18] Y[20]^-1 Y[21]^-1 Y[22]^-2 Y[26]^2 Y[27]^-1 Y[30]^-2 Y[31]^3 #We find the appropriate constant: print expand(findConstant(ratioInYoshidas)/(ratioInDs)^3) # We record the output: # 1 ########### # For F46 # ########### rows = [0,1,2] columns = [7,9,23] extremal_curve = F46 checkNonVanishingMinorsWithInfinitiesAndShape(rows, columns, cone, M_without_nones[extremal_curve], M_with_nones[extremal_curve]) # * - ? # - * - # * * ? # True ratioInDs = checkRatio((0,23), (2,23), pds[extremal_curve]) # We record the output: print ratioInDs #(-d2 + d3)^-1 * (d2 + d3 + d4)^-1 * (d1 - d6)^-1 * (d1 + d4 + d6)^-1 * (d3 - d6) * (d3 + d4 + d6) * (-d1 + d2) * (d1 + d2 + d4) ratioInYoshidas = constructMonomialFromProduct(ratioInDs, positive_roots,uyvs_basis) # We record the output: print ratioInYoshidas #(-2/3, 0, 1/3, 0, 2/3, -1/3, 1/3, 0, 1, -1, -1/3, -1/3, 1, -1, 1/3, 0) # We write the cube as product of Yoshidas # Y[5]^-2 Y[18] Y[20]^2 Y[21]^-1 Y[22] Y[24]^3 Y[25]^-3 Y[26]^-1 Y[27]^-1 Y[28]^3 Y[29]^-3 Y[30] #We find the appropriate constant: print expand(findConstant(ratioInYoshidas)/(ratioInDs)^3) We record the output: # 1 ########### # For F56 # ########### rows = [0,1,2] columns = [8,9,13] extremal_curve = F56 checkNonVanishingMinorsWithInfinitiesAndShape(rows, columns, cone, M_without_nones[extremal_curve], M_with_nones[extremal_curve]) # * - ? # - * - # * * ? # True ratioInDs = checkRatio((0,13), (2,13), pds[extremal_curve]) # We record the output: print ratioInDs #(d2 - d6)^-1 * (d2 + d5 + d6)^-1 * (-d1 + d4)^-1 * (d1 + d4 + d5)^-1 * (d4 - d6) * (d4 + d5 + d6) * (-d1 + d2) * (d1 + d2 + d5) ratioInYoshidas = constructMonomialFromProduct(ratioInDs, positive_roots,uyvs_basis) # We record the output: print ratioInYoshidas #(2/3, -1, -1/3, 0, 1/3, -2/3, 2/3, 0, 0, -1, 1/3, -2/3, 1, 0, -1/3, 1) # Write the cube as product of Yoshidas: # Y[5]^2 Y[17]^-3 Y[18]^-1 Y[20] Y[21]^-2 Y[22]^2 Y[25]^-3 Y[26] Y[27]^-2 Y[28]^3 Y[30]^-1 Y[31]^3 #We find the appropriate constant: print expand(findConstant(ratioInYoshidas)/(ratioInDs)^3) # We record the output: # 1 ########## # For G3 # ########## rows = [0,2,4] columns = [30,35,44] extremal_curve = G3 checkNonVanishingMinorsWithInfinitiesAndShape(rows, columns, cone, M_without_nones[extremal_curve], M_with_nones[extremal_curve]) # ? - * # - * - # ? * * # True ratioInDs = checkRatio((0,30), (4,30), pds[extremal_curve]) # We record the output: print ratioInDs # 1 ratioInYoshidas = constructMonomialFromProduct(ratioInDs, positive_roots,uyvs_basis) # We record the output: print ratioInYoshidas # (0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0) ########## # For G4 # ########## rows = [0,3,4] columns = [20,32,38] extremal_curve = G4 checkNonVanishingMinorsWithInfinitiesAndShape(rows, columns, cone, M_without_nones[extremal_curve], M_with_nones[extremal_curve]) # * ? - # - - * # * ? * # True ratioInDs = checkRatio((0,32), (4,32), pds[extremal_curve]) # We record the output: print ratioInDs #(d2 + d4 + d6)^-1 * (d2 + d3 + d5)^-1 * (d1 + d5 + d6)^-1 * (d1 + d3 + d4)^-1 * (-d4 + d5) * (d3 - d6) * (-d1 + d2) * (d1 + d2 + d3 + d4 + d5 + d6) ratioInYoshidas = constructMonomialFromProduct(ratioInDs, positive_roots,uyvs_basis) # We record the output: print ratioInYoshidas #(-2/3, 0, 1/3, 0, 2/3, -1/3, 1/3, 0, 0, 0, -1/3, -1/3, 0, 0, 1/3, 0) # We write the cube as product of Yoshidas # Y[5]^-2 Y[18] Y[20]^2 Y[21]^-1 Y[22] Y[26]^-1 Y[27]^-1 Y[30] #We find the appropriate constant: print expand(findConstant(ratioInYoshidas)/(ratioInDs)^3) # We record the output: # -1 ########## # For G5 # ########## rows = [0,2,4] columns = [32,34,42] extremal_curve = G5 checkNonVanishingMinorsWithInfinitiesAndShape(rows, columns, cone, M_without_nones[extremal_curve], M_with_nones[extremal_curve]) # ? * * # - * - # ? * * # True ratioInDs = checkRatio((0,32), (4,32), pds[extremal_curve]) # We record the output: print ratioInDs # 1 ratioInYoshidas = constructMonomialFromProduct(ratioInDs, positive_roots,uyvs_basis) # We record the output: print ratioInYoshidas # (0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0) ########## # For G6 # ########## rows = [0,1,3] columns = [11,32,42] extremal_curve = G6 checkNonVanishingMinorsWithInfinitiesAndShape(rows, columns, cone, M_without_nones[extremal_curve], M_with_nones[extremal_curve]) # * ? - # - - * # * ? * # True ratioInDs = checkRatio((0,32), (3,32), pds[extremal_curve]) # We record the output: print ratioInDs # 1 ratioInYoshidas = constructMonomialFromProduct(ratioInDs, positive_roots,uyvs_basis) # We record the output: print ratioInYoshidas # (0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)