################################################################################### # Lifting Pairs of Extra Trees for the Apex of the Naruki cone to residual conics # ################################################################################### # If the valuation on the Cross functions are the expected ones, all anticanonical coordinates of the tropical nodes can be determined. If the valuations are higher than expected, some entries on the tropical nodes become unknown, yielding to jumps. For the apex, all Cross functions have unknown true valuations and their expected valuations are zero. # We know that the necessary condinewtions for the existence of extra lines depends on the equality of the valuations of five specify Cross functions (those associated to the anticanonical triangles vanishing along the indexing extremal curve). The list is recorded on the dictionary 'allCrossesApexPerExtremal' computed on 'TropicalConvexHulls/Scripts/ComputeTreesForApexCone.sage' The two lists of Cross functions share at most one element in common. # In this script we list the five boundary point of all possible extra lines (working just with E1 by symmetry reasons) and show that their unique lifts in the cubic surface X are never tropically coplanar. This implies that the pairs of extra lines will never lift to a (residual) conic. # Second, we compute the tropical rank of all boundary points of pairs of extra lines and determine conditions on the 10 relevant Cross functions that ensure the tropical rank equals 3. We do so by finding a 4x4 tropical minor that gives conditions on the Cross functions, and finding a 3x3 tropical minor that is non-singular. Notice that this does not imply the Kapranov rank is 3, so we cannot use this method to prove the pairs of lines don't lift to conics on X. ############################################################################################### # Setting up the ambient rings with the W(E6) action, the Cross functions, and Tropical Nodes # ############################################################################################### # A list of variables d_1, ..., d_6 for the coefficients ds = [var("d%s"%i) for i in range(1,7)] # A list of variables E_1, ..., E_6 Es = [var("E%s"%i) for i in range(1,7)] # A list of variables F_12, ..., F_56 Fs = [var("F%s%s"%(i,j)) for i in range(1,7) for j in range(1,7) if i < j] # A list of variables G_1, ..., G_6 Gs = [var("G%s"%i) for i in range(1,7)] # A list of variables X_12, ..., X_65 Xs = [var("X%s%s"%(i,j)) for i in range(1,7) for j in range(1,7) if i != j] # A list of variables Y_123456, ..., Y_162534 Ys = [var("Y%s%s%s%s%s%s"%(i,j,k,l,m,n)) for i in range(1,7) for j in range(1,7) for k in range(1,7) for l in range(1,7) for m in range(1,7) for n in range(1,7) if i1: print "The input is not a monomial" return None fl = SR(f).factor_list() expVector = sum([x[1]*vector(YM.rows()[Yoshidas.index(YRing(x[0]))]) for x in fl]) return expVector # The following will translate a polynomial in Yoshidas into the potentially non-monomial factor of its presentation in ds. def fromNonMonFactorsToDs(f): Monsf = YRing(f).monomials() # print len(Monsf) Coeffsf = YRing(f).coefficients() print len(Coeffsf) ExponentsMonsf = [fromMonomialToRoots(x) for x in Monsf] print ExponentsMonsf # we take the minimal of all exponents of positive roots to remove from each term. This will reduce the final degree of each term. minExps = vector({x: min([y[x] for y in ExponentsMonsf]) for x in range(0,36)}) print minExps # minExpsPoly = SR(VectorToYoshida(list(minExps), positive_roots)) # print minExpsPoly ScaledExponentsMonsf = [x-minExps for x in ExponentsMonsf] newTerms = [SR(VectorToYoshida(list(y), positive_roots)) for y in ScaledExponentsMonsf] return (sum([Coeffsf[i]*newTerms[i] for i in range(0, len(Coeffsf))]), minExps) ##################################### # Monomial and Non-monomial factors # ##################################### # The following function will be used to rewrite the factorization of non-vanishing Plueckers into a Monomial in Yoshidas and Cross functions, and non-monomial factors. def fromBinomialsAndMonomialsToCrossesAndYoshidas(factorsList): nonMonomialFactors = [] newFactorsList = [] for x in factorsList: if len(YRing(x[0]).monomials())==2: newx = ([SR(y) for y in cross_to_yoshidas.keys() if SR(x[0]) in cross_to_yoshidas[y]][0], x[1]) newFactorsList = newFactorsList + [newx] elif len(YRing(x[0]).monomials())==1: newFactorsList = newFactorsList + [(SR(x[0]), x[1])] else: nonMonomialFactors = nonMonomialFactors + [(SR(x[0]), x[1])] return [newFactorsList, nonMonomialFactors] # The following variant is used when the binomials found are not Cross functions. def fromBinomialsAndMonomialsToCrossesAndYoshidasAndRest(factorsList): nonMonomialFactors = [] newFactorsList = [] for x in factorsList: if len(YRing(x[0]).monomials())==2: crossCand = [SR(y) for y in cross_to_yoshidas.keys() if SR(x[0]) in cross_to_yoshidas[y]] if crossCand != []: newx = (crossCand[0], x[1]) newFactorsList = newFactorsList + [newx] else: newx = x nonMonomialFactors = nonMonomialFactors + [(SR(x[0]), x[1])] elif len(YRing(x[0]).monomials())==1: newFactorsList = newFactorsList + [(SR(x[0]), x[1])] else: nonMonomialFactors = nonMonomialFactors + [(SR(x[0]), x[1])] return [newFactorsList, nonMonomialFactors] ################################################# # Rewriting using 16 Standard Yoshida functions # ################################################# # We analyze non-monomial factors separately. In order to find extra monomial factors, we rewrite each term of the non-monomial factor in terms of the 16 Yoshidas generating the row space of the Yoshida matrix. # Qs= polynomial ring on the parameters d1,..., d6 # YM = Yoshida matrix # f = irreducible polynomial in the Yoshida functions. def computingFixedExpressionsInYs(f,Qs,YM): newFactors = dict() Monsf = YRing(f).monomials() Coeffsf = YRing(f).coefficients() ExponentsMonsf = {x:fromMonomialToRoots(x) for x in Monsf} for x in Monsf: linear_vector = vector(ZZ,ExponentsMonsf[x]) if linear_vector in span(ZZ, YM.rows()): yoshida_vector = YM.solve_left(linear_vector) newFactors[Monsf.index(x)]= prod([Yoshidas[i]^yoshida_vector[i] for i in range(0, 40)]) else: print "we are in trouble" return None return sum([Coeffsf[k]*newFactors[k] for k in range(0, len(Monsf))]) # The following function is used to simplify factorizations and extract extra monomial factors from non-monomial ones. We assume we have at most 1 non-monomial factor on each value of factorsList. This is the case for the Plueckers we are interested in: def groupAllFactors(factorsList,Qs,YM): newFactors = dict() for z in factorsList.keys(): print str(z) if factorsList[z][-1] == []: print "nothing to do" newFactors[z] = factorsList[z] elif len(factorsList[z][-1]) > 2: print "we are in trouble: more than one non-monomial factor!" return None else: e = factorsList[z][-1][0][-1] print e allMons = computingFixedExpressionsInYs(factorsList[z][-1][0][0], Qs,YM) allMonsNum = allMons.numerator() allMonsDenom = allMons.denominator() testNum = fromBinomialsAndMonomialsToCrossesAndYoshidas(SR(allMonsNum).factor_list()) testDenom = fromBinomialsAndMonomialsToCrossesAndYoshidas(SR(allMonsDenom).factor_list()) newMons = factorsList[z][0] + [(x[0], e*x[1]) for x in testNum[0]] + [(x[0], -e*x[1]) for x in testDenom[0]] # We refactor the monomial part to get rid of repetitions of variables and group signs together: simplerNewMons = SR(prod([x[0]^x[1] for x in newMons])).factor_list() if testNum[1] != []: newNonMons = [(y[0], e*y[1]) for y in testNum[1]] newFactors[z] = [simplerNewMons, newNonMons] else: newFactors[z] = [simplerNewMons, []] return newFactors # This function constructs the kth canonical basis element of an n-dimensional vector space def canonicalBasisElement(k,n): vectorDs = {i: 0 for i in range(0,n)} vectorDs[k] = 1 return vector(QQ,vectorDs.values()) # The function below takes a vector of exponents (extraRoots) and a list of factors with their multiplicity newFactorList) and produces the vector of exponents of all root factors. def groupRoots(newFactorList, extraRoots,positive_roots): # select the linear factors: we expect these are roots rootsToConsider = [(Qd(newFactorList[x][0]),newFactorList[x][1]) for x in range(0,len(newFactorList)) if Qd(newFactorList[x][0]).total_degree() == 1] print str(rootsToConsider) rootsToVector = vector(ZZ,[0]*len(positive_roots)) positiveRootsInDs = [Qd(x) for x in positive_roots] for x in rootsToConsider: if Qd(x[0]) in positiveRootsInDs: rootsToVector = rootsToVector + x[1]*canonicalBasisElement(positiveRootsInDs.index(x[0]), len(positive_roots)) elif Qd(-1*x[0]) in positiveRootsInDs: rootsToVector = rootsToVector + x[1]*canonicalBasisElement(positiveRootsInDs.index(Qd(-1*x[0])), len(positive_roots)) else: print "We are in trouble!" return None newVector = rootsToVector + vector(ZZ,list(extraRoots)) return newVector # The following function computes the cartesian product of lists. def computeProductOfLists(L): X = [x for x in L[0]] print X if len(L)==1: return X for i in range(1,len(L)): print L[i] newX = [] for x in X: for y in L[i]: newx = x + y newX = newX + [newx] X = newX return newX # The following function inputs a vector of roots, and labels for quintics and outputs the possible Cross functions and the resulting altered vector of roots, obtained by all possible 4 factors that give the different Cross functions # ffdict = dictionary of degree 4 factors to multiply the quintic and get a Cross function # dictionaryCrossToDv = dictionary of Cross functions expressed in terms of ds. (the values are in the Symbolic Ring) # allRoots = vector of roots factors on the Plueckers # positive_roots = usual list of positive roots. # quintics = dictionary of quintics def rewritingNonMonomialFactors(allRoots,positive_roots, ffdict, quinticsList,dictionaryCrossToDv,quintics): allPossibilities = [[SR(ffdict[quinticsList[i]][j]).factor_list() for j in range(0,3)] for i in range(0, len(quinticsList))] allQuintics = [[[k for k in dictionaryCrossToDv.keys() if dictionaryCrossToDv[k]==SR(ffdict[quinticsList[i]][j]*quintics[S(quinticsList[i])])] for j in range(0,3)] for i in range(0,len(quinticsList))] print allQuintics allTuples = computeProductOfLists(allPossibilities) allQuinticsTuples = computeProductOfLists(allQuintics) allTuplesN = [[(x[0],-x[1]) for x in y if Qd(x[0]).total_degree() == 1] for y in allTuples] newRoots = [groupRoots(allTuplesN[k], allRoots,positive_roots) for k in range(0,len(allTuplesN))] return (newRoots, allQuinticsTuples) # We incorporate negative exponents = -1 to the list of quintics def rewritingNonMonomialFactorsNegQuintics(allRoots,positive_roots, ffdict, quinticsListPM,dictionaryCrossToDv,quintics): (quinticsListP, quinticsListM) = quinticsListPM allPossibilitiesP = [[SR(ffdict[quinticsListP[i]][j]).factor_list() for j in range(0,3)] for i in range(0, len(quinticsListP))] allPossibilitiesM = [[SR(ffdict[quinticsListM[i]][j]^(-1)).factor_list() for j in range(0,3)] for i in range(0, len(quinticsListM))] allPossibilities = allPossibilitiesP + allPossibilitiesM allQuinticsP = [[[k for k in dictionaryCrossToDv.keys() if dictionaryCrossToDv[k]==SR(ffdict[quinticsListP[i]][j]*quintics[S(quinticsListP[i])])] for j in range(0,3)] for i in range(0,len(quinticsListP))] allQuinticsM = [[[SR(k)^(-1) for k in dictionaryCrossToDv.keys() if dictionaryCrossToDv[k]==SR(ffdict[quinticsListM[i]][j]*quintics[S(quinticsListM[i])])] for j in range(0,3)] for i in range(0,len(quinticsListM))] allQuintics = allQuinticsP + allQuinticsM print (allQuinticsP,allQuinticsM) # allTuplesP = computeProductOfLists(allPossibilitiesP) # allTuplesM = computeProductOfLists(allPossibilitiesM) # allQuinticsTuplesP = computeProductOfLists(allQuinticsP) # allQuinticsTuplesM = computeProductOfLists(allQuinticsM) allTuples = computeProductOfLists(allPossibilities) allQuinticsTuples = computeProductOfLists(allQuintics) allTuplesN = [[(x[0],-x[1]) for x in y if Qd(x[0]).total_degree() == 1] for y in allTuples] # allTuplesPN = [[(x[0],-x[1]) for x in y if Qd(x[0]).total_degree() == 1] for y in allTuplesP] # allTuplesMN = [[(x[0],-x[1]) for x in y if Qd(x[0]).total_degree() == 1] for y in allTuplesM] newRoots = [groupRoots(allTuplesN[k], allRoots,positive_roots) for k in range(0,len(allTuplesN))] return (newRoots, allQuinticsTuples) # The following function takes a list of vectors of roots, and checks if it lies in the ZZ-row span of YM. The output has the same length and its entries are either None or the corresponding production of Yoshidas. def fromAllRootsToMonomials(newRoots,YM): MonFactors = [] for x in newRoots: print str(x) linear_vector = vector(ZZ,x) if linear_vector in span(ZZ, YM.rows()): yoshida_vector = YM.solve_left(linear_vector) MonFactors.append(prod([Yoshidas[i]^yoshida_vector[i] for i in range(0, 40)])) else: print "we are in trouble" MonFactors.append(None) return MonFactors # We do the same but with solutions over QQ def fromAllRootsToMonomialsQQ(newRoots,YM): MonFactors = [] for x in newRoots: print str(x) linear_vector = vector(ZZ,x) if linear_vector in span(QQ, YM.rows()): yoshida_vector = YM.solve_left(linear_vector) MonFactors.append(prod([Yoshidas[i]^yoshida_vector[i] for i in range(0, 40)])) else: print "we are in trouble" MonFactors.append(None) return MonFactors # We combine the previous functions to get a factorization whenever possible def fromQuinticsAndRootsToYoshidasAndCrosses(allRoots, positive_roots, ffdict,QuinticsList,dictionaryCrossToDv,quintics,YM): rootsAndCrosses = rewritingNonMonomialFactors(allRoots,positive_roots, ffdict, QuinticsList,dictionaryCrossToDv,quintics) print rootsAndCrosses monFactor = fromAllRootsToMonomials(rootsAndCrosses[0],YM) print monFactor possibleIndices = [k for k in range(0,len(monFactor)) if monFactor[k] !=None] print possibleIndices possibleFactors = [SR(monFactor[k]*prod(rootsAndCrosses[-1][k])).factor_list() for k in possibleIndices] return possibleFactors # We combine the previous functions to get a factorization whenever possible, incorporating negative exponents to the quintics. def fromQuinticsAndRootsToYoshidasAndCrossesNegQuintics(allRoots, positive_roots, ffdict,QuinticsListPM,dictionaryCrossToDv,quintics,YM): rootsAndCrosses = rewritingNonMonomialFactorsNegQuintics(allRoots,positive_roots, ffdict, QuinticsListPM,dictionaryCrossToDv,quintics) print rootsAndCrosses monFactor = fromAllRootsToMonomials(rootsAndCrosses[0],YM) print monFactor possibleIndices = [k for k in range(0,len(monFactor)) if monFactor[k] !=None] print possibleIndices possibleFactors = [SR(monFactor[k]*prod(rootsAndCrosses[-1][k])).factor_list() for k in possibleIndices] return possibleFactors # The following function corrects the sign of the obtained factorization of the fake non-monomial Plueckers: def correctingSigns(f,factorsNZRep,finalFactNonMon,allYandCrossToNumDv): fvalue = SR(f).substitute(allYandCrossToNumDv) allfactorsNZ = prod([SR(x[0]^x[1]) for x in factorsNZRep]) allFinalFactorizationNonMon = prod([SR(x[0])^x[1] for x in finalFactNonMon]) newMon = SR(allfactorsNZ*allFinalFactorizationNonMon) newMonNum = newMon.substitute(allYandCrossToNumDv) newSign = sign(fvalue/newMonNum) signedMon = SR(newMon*newSign).factor_list() return signedMon ########################### # Record the denominators # ########################### allDenomFactors=combineLists([allDenoms[keys[k]] for k in cols]) # allDenomFactors # [(Cross54, -1), (Cross69, -1), (Cross41, -1), (Cross60, -1)] ########################## # Symbolic Shifted Minor # ########################## shiftedminorSymb = shiftedMatrix5x45ForE1.transpose().matrix_from_rows_and_columns(rows,cols) # We test the minor is generically non-zero dictShiftedNumE1 = convertIntMP2FromYtoDs(shiftedminorSymb.transpose(),YcrossdsToNumDv,4,4) matrixShiftedNumE1 = matrix(4,4, dictShiftedNumE1) rank(matrixNumE1) 4 ########################### # Non-shifted computation # ########################### matrixYC = matrix(SR,[matrixForE1[key] for key in keys]) dictNumE1 = convertIntMP2FromYtoDs(matrixYC.transpose(),YcrossdsToNumDv,5,45) matrixNumE1 = matrix(5, 45, dictNumE1) rank(matrixNumE1) 4 subMatrixYC = matrixYC.transpose().matrix_from_rows_and_columns([0,1,2,3],[40,41,43,44]) minor = det(subMatrixYC) # print minor # minor = -Yoshida0^2*Yoshida1*Yoshida10*Yoshida12*Yoshida17^3*Yoshida18*Yoshida2*Yoshida21^2*Yoshida23*Yoshida24*Yoshida25*Yoshida30^2*Yoshida34^3*Yoshida37^2/(Cross39*Cross56*Cross61*Cross71*Yoshida13*Yoshida19*Yoshida22^2*Yoshida28*Yoshida29*Yoshida31^2*Yoshida33*Yoshida35^2*Yoshida39^3*Yoshida5^2*Yoshida6^2) + Yoshida0*Yoshida11*Yoshida12*Yoshida14*Yoshida16*Yoshida17^2*Yoshida18*Yoshida21*Yoshida23^2*Yoshida25*Yoshida26*Yoshida30*Yoshida34^2*Yoshida37/(Cross40*Cross54*Cross61*Cross71*Yoshida10*Yoshida22*Yoshida27*Yoshida29*Yoshida31*Yoshida35^2*Yoshida39^3*Yoshida5^2*Yoshida6) - Yoshida0^3*Yoshida1*Yoshida10*Yoshida12^2*Yoshida15*Yoshida17^5*Yoshida18*Yoshida2*Yoshida21^2*Yoshida23^2*Yoshida24*Yoshida25^2*Yoshida30^2*Yoshida34^4*Yoshida37^2*Yoshida38^2/(Cross41*Cross55*Cross61*Cross71*Yoshida13*Yoshida14*Yoshida16*Yoshida19^2*Yoshida22^2*Yoshida26*Yoshida28*Yoshida31^3*Yoshida33^2*Yoshida35^3*Yoshida39^4*Yoshida4*Yoshida5^2*Yoshida6^3*Yoshida8) + Yoshida0^2*Yoshida1*Yoshida10*Yoshida11*Yoshida12*Yoshida17^3*Yoshida18*Yoshida2*Yoshida21^2*Yoshida23*Yoshida24*Yoshida30^2*Yoshida34^3*Yoshida37^2/(Cross39*Cross54*Cross61*Cross71*Yoshida13*Yoshida19*Yoshida22^2*Yoshida28*Yoshida29*Yoshida31*Yoshida33*Yoshida35^2*Yoshida39^3*Yoshida5^2*Yoshida6^2*Yoshida8) + Yoshida0^3*Yoshida1*Yoshida12^2*Yoshida15*Yoshida17^4*Yoshida18*Yoshida21*Yoshida23^3*Yoshida25^2*Yoshida30*Yoshida34^4*Yoshida37^2*Yoshida38^2/(Cross41*Cross55*Cross61*Cross71*Yoshida10*Yoshida19*Yoshida22*Yoshida26*Yoshida27*Yoshida31^3*Yoshida33^2*Yoshida35^3*Yoshida39^4*Yoshida4*Yoshida5^2*Yoshida6^2*Yoshida8) - Yoshida0^2*Yoshida1*Yoshida11*Yoshida12*Yoshida14*Yoshida16*Yoshida17^3*Yoshida18*Yoshida21^2*Yoshida23^3*Yoshida25*Yoshida30^2*Yoshida34^3*Yoshida37^2/(Cross40*Cross54*Cross61*Cross71*Yoshida13*Yoshida19*Yoshida22^2*Yoshida27*Yoshida29*Yoshida31*Yoshida33*Yoshida35^3*Yoshida39^3*Yoshida4*Yoshida5^2*Yoshida6^2*Yoshida8) - Yoshida0^2*Yoshida1*Yoshida11*Yoshida12*Yoshida14*Yoshida16*Yoshida17^2*Yoshida18*Yoshida21*Yoshida23^2*Yoshida30*Yoshida34^3*Yoshida37^2/(Cross39*Cross54*Cross61*Cross71*Yoshida10*Yoshida22*Yoshida27*Yoshida29*Yoshida31*Yoshida33*Yoshida35^2*Yoshida39^3*Yoshida5^2*Yoshida6*Yoshida8) - Yoshida0^3*Yoshida1^2*Yoshida12^2*Yoshida14*Yoshida17^3*Yoshida18*Yoshida21*Yoshida23^3*Yoshida25^2*Yoshida30*Yoshida34^4*Yoshida37^2*Yoshida38/(Cross40*Cross55*Cross61*Cross71*Yoshida10*Yoshida19*Yoshida22*Yoshida26*Yoshida27*Yoshida31^3*Yoshida33^2*Yoshida35^3*Yoshida39^4*Yoshida4*Yoshida5^2*Yoshida6*Yoshida8) - Yoshida0*Yoshida12^2*Yoshida15*Yoshida17^4*Yoshida18*Yoshida2*Yoshida21*Yoshida23*Yoshida24*Yoshida25^2*Yoshida30*Yoshida34^3*Yoshida37*Yoshida38^2/(Cross41*Cross56*Cross61*Cross71*Yoshida1*Yoshida14*Yoshida22*Yoshida28*Yoshida31^3*Yoshida33*Yoshida35^2*Yoshida39^3*Yoshida5^2*Yoshida6^2*Yoshida9) + Yoshida0^2*Yoshida10*Yoshida12^2*Yoshida15*Yoshida17^5*Yoshida18*Yoshida2*Yoshida21^2*Yoshida23^2*Yoshida24*Yoshida25^2*Yoshida30^2*Yoshida34^4*Yoshida37^2*Yoshida38^2/(Cross41*Cross56*Cross61*Cross71*Yoshida13*Yoshida14*Yoshida19*Yoshida22^2*Yoshida26*Yoshida28*Yoshida31^3*Yoshida33^2*Yoshida35^3*Yoshida39^3*Yoshida4*Yoshida5^2*Yoshida6^3*Yoshida8*Yoshida9) + Yoshida0^2*Yoshida1*Yoshida12^2*Yoshida17^3*Yoshida18*Yoshida2*Yoshida21*Yoshida23*Yoshida24*Yoshida25*Yoshida30*Yoshida34^4*Yoshida37^2*Yoshida38/(Cross39*Cross56*Cross61*Cross71*Yoshida22*Yoshida26*Yoshida28*Yoshida31^3*Yoshida33^2*Yoshida35^2*Yoshida39^3*Yoshida5^2*Yoshida6*Yoshida8*Yoshida9) + Yoshida0^3*Yoshida1^2*Yoshida12*Yoshida14*Yoshida17^3*Yoshida18*Yoshida21^2*Yoshida23^3*Yoshida25^2*Yoshida30^2*Yoshida34^3*Yoshida37^2*Yoshida9/(Cross40*Cross55*Cross61*Cross71*Yoshida13*Yoshida19^2*Yoshida22^2*Yoshida27*Yoshida29*Yoshida31^2*Yoshida33*Yoshida35^3*Yoshida39^4*Yoshida4*Yoshida5^2*Yoshida6^2) minorFactorization = minor.factor_list() # minorFactorization # [(Cross39*Cross40*Cross54*Cross55*Yoshida0*Yoshida1*Yoshida10^2*Yoshida12*Yoshida15*Yoshida16*Yoshida17^3*Yoshida19*Yoshida2*Yoshida21*Yoshida23*Yoshida24*Yoshida25^2*Yoshida27*Yoshida29*Yoshida30*Yoshida34^2*Yoshida37*Yoshida38^2*Yoshida39 + Cross40*Cross41*Cross54*Cross55*Yoshida0*Yoshida1^2*Yoshida10*Yoshida12*Yoshida13*Yoshida14*Yoshida16*Yoshida17*Yoshida19^2*Yoshida2*Yoshida22*Yoshida24*Yoshida25*Yoshida27*Yoshida29*Yoshida34^2*Yoshida35*Yoshida37*Yoshida38*Yoshida39*Yoshida4*Yoshida6^2 - Cross39*Cross40*Cross54*Cross55*Yoshida10*Yoshida12*Yoshida13*Yoshida15*Yoshida16*Yoshida17^2*Yoshida19^2*Yoshida2*Yoshida22*Yoshida24*Yoshida25^2*Yoshida26*Yoshida27*Yoshida29*Yoshida33*Yoshida34*Yoshida35*Yoshida38^2*Yoshida39*Yoshida4*Yoshida6*Yoshida8 - Cross39*Cross40*Cross54*Cross56*Yoshida0^2*Yoshida1^2*Yoshida10^2*Yoshida12*Yoshida15*Yoshida17^3*Yoshida2*Yoshida21*Yoshida23*Yoshida24*Yoshida25^2*Yoshida27*Yoshida29*Yoshida30*Yoshida34^2*Yoshida37*Yoshida38^2*Yoshida9 + Cross39*Cross40*Cross54*Cross56*Yoshida0^2*Yoshida1^2*Yoshida12*Yoshida13*Yoshida14*Yoshida15*Yoshida16*Yoshida17^2*Yoshida19*Yoshida22*Yoshida23^2*Yoshida25^2*Yoshida28*Yoshida29*Yoshida34^2*Yoshida37*Yoshida38^2*Yoshida6*Yoshida9 - Cross39*Cross41*Cross55*Cross56*Yoshida0*Yoshida1^2*Yoshida10*Yoshida11*Yoshida14^2*Yoshida16^2*Yoshida17*Yoshida19*Yoshida21*Yoshida23^2*Yoshida25*Yoshida26*Yoshida28*Yoshida30*Yoshida31^2*Yoshida33*Yoshida34*Yoshida37*Yoshida39*Yoshida6*Yoshida9 + Cross40*Cross41*Cross55*Cross56*Yoshida0*Yoshida1^2*Yoshida10^2*Yoshida11*Yoshida14*Yoshida16*Yoshida17*Yoshida19*Yoshida2*Yoshida21*Yoshida24*Yoshida26*Yoshida27*Yoshida30*Yoshida31^2*Yoshida33*Yoshida34*Yoshida35*Yoshida37*Yoshida39*Yoshida4*Yoshida6*Yoshida9 - Cross39*Cross41*Cross54*Cross56*Yoshida0^2*Yoshida1^3*Yoshida12*Yoshida13*Yoshida14^2*Yoshida16*Yoshida17*Yoshida19*Yoshida22*Yoshida23^2*Yoshida25^2*Yoshida28*Yoshida29*Yoshida34^2*Yoshida37*Yoshida38*Yoshida6^2*Yoshida9 - Cross40*Cross41*Cross55*Cross56*Yoshida0*Yoshida1^2*Yoshida11*Yoshida13*Yoshida14^2*Yoshida16^2*Yoshida19^2*Yoshida22*Yoshida23*Yoshida26*Yoshida28*Yoshida31^2*Yoshida33*Yoshida34*Yoshida35*Yoshida37*Yoshida39*Yoshida4*Yoshida6^2*Yoshida9 - Cross40*Cross41*Cross54*Cross55*Yoshida0*Yoshida1^2*Yoshida10^2*Yoshida14*Yoshida16*Yoshida17*Yoshida19*Yoshida2*Yoshida21*Yoshida24*Yoshida25*Yoshida26*Yoshida27*Yoshida30*Yoshida31*Yoshida33*Yoshida34*Yoshida35*Yoshida37*Yoshida39*Yoshida4*Yoshida6*Yoshida8*Yoshida9 + Cross39*Cross41*Cross55*Cross56*Yoshida1*Yoshida11*Yoshida13*Yoshida14^2*Yoshida16^2*Yoshida19^2*Yoshida22*Yoshida23*Yoshida25*Yoshida26^2*Yoshida28*Yoshida31^2*Yoshida33^2*Yoshida35*Yoshida39*Yoshida4*Yoshida6^2*Yoshida8*Yoshida9 + Cross39*Cross41*Cross54*Cross56*Yoshida0^2*Yoshida1^3*Yoshida10*Yoshida14^2*Yoshida16*Yoshida17*Yoshida21*Yoshida23^2*Yoshida25^2*Yoshida26*Yoshida28*Yoshida30*Yoshida31*Yoshida33*Yoshida34*Yoshida37*Yoshida6*Yoshida8*Yoshida9^2, # 1), # (Cross39, -1), # (Cross40, -1), # (Cross41, -1), # (Cross54, -1), # (Cross55, -1), # (Cross56, -1), # (Cross61, -1), # (Cross71, -1), # (Yoshida0, 1), # (Yoshida1, -1), # (Yoshida10, -1), # (Yoshida12, 1), # (Yoshida13, -1), # (Yoshida14, -1), # (Yoshida16, -1), # (Yoshida17, 2), # (Yoshida18, 1), # (Yoshida19, -2), # (Yoshida21, 1), # (Yoshida22, -2), # (Yoshida23, 1), # (Yoshida26, -1), # (Yoshida27, -1), # (Yoshida28, -1), # (Yoshida29, -1), # (Yoshida30, 1), # (Yoshida31, -3), # (Yoshida33, -2), # (Yoshida34, 2), # (Yoshida35, -3), # (Yoshida37, 1), # (Yoshida39, -4), # (Yoshida4, -1), # (Yoshida5, -2), # (Yoshida6, -3), # (Yoshida8, -1), # (Yoshida9, -1)] badFactors = [x for x in minorFactorization if len(YCRing(x[0]).monomials()) >1] # len(badFactors) # 1 # We have only one non-monomial factor that we need to rewrite in terms of Yoshida and cross functions. badFactor = badFactors[0][0] badExp = badFactors[0][1] # badExp # 1 # We record the good factors: MonFactors = [x for x in minorFactorization if x not in badFactors] # print MonFactors # [(Cross39, -1), (Cross40, -1), (Cross41, -1), (Cross54, -1), (Cross55, -1), (Cross56, -1), (Cross61, -1), (Cross71, -1), (Yoshida0, 1), (Yoshida1, -1), (Yoshida10, -1), (Yoshida12, 1), (Yoshida13, -1), (Yoshida14, -1), (Yoshida16, -1), (Yoshida17, 2), (Yoshida18, 1), (Yoshida19, -2), (Yoshida21, 1), (Yoshida22, -2), (Yoshida23, 1), (Yoshida26, -1), (Yoshida27, -1), (Yoshida28, -1), (Yoshida29, -1), (Yoshida30, 1), (Yoshida31, -3), (Yoshida33, -2), (Yoshida34, 2), (Yoshida35, -3), (Yoshida37, 1), (Yoshida39, -4), (Yoshida4, -1), (Yoshida5, -2), (Yoshida6, -3), (Yoshida8, -1), (Yoshida9, -1)] allMon = YCRing(badFactor).monomials() allCoef = YCRing(badFactor).coefficients() # allCoef # [-1, 1, -1, 1, 1, -1, 1, -1, 1, -1, -1, 1] # # We record the number of monomials in this single bad factors: # len(YCRing(badFactor).monomials()) # 12 ################################### # Rewriting the single bad factor # ################################### # allMonInDs = [] # for k in range(0,len(allMon)): # print k # newValue = substituteOnFactorList(SR(allMon[k]),dictionary_cross_yoshidas_in_ds) # allMonInDs.append(newValue) # print allMonInDs # allMonInDs = [[(d5 - d6, 5), (Cross41, 2), (d2 + d4 + d6, 5), (d1 - d2, 6), (d1 + d2 + d5, 6), (d3 + d4 + d5, 7), (d1 + d2 + d3 + d4 + d5 + d6, 5), (d2 + d3 + d4, 7), (d2 + d3 + d5, 7), (d1 + d5 + d6, 4), (d3 - d6, 5), (d1 + d2 + d3, 6), (Cross54, 2), (d2 - d4, 3), (d3 + d4 + d6, 7), (d2 - d3, 6), (d3 + d5 + d6, 5), (d2 - d6, 9), (d2 + d3 + d6, 7), (d1 - d3, 7), (d1 - d6, 6), (d2 - d5, 7), (d1 + d3 + d5, 8), (d3 - d5, 6), (d1 - d4, 7), (d4 - d5, 8), (d2 + d4 + d5, 6), (d1 + d4 + d5, 8), (d2 + d5 + d6, 9), (d1 + d2 + d6, 9), (d1 + d2 + d4, 6), (d1 - d5, 5), (d1 + d3 + d4, 7), (d3 - d4, 7), (d1 + d3 + d6, 7), (d1 + d4 + d6, 7), (d4 - d6, 6), (d4 + d5 + d6, 8), (-1, 23)], [(d5 - d6, 5), (Cross41, 2), (d1 - d6, 6), (d1 - d2, 5), (d2 + d4 + d6, 5), (d1 - d4, 8), (d1 + d2 + d3 + d4 + d5 + d6, 5), (d2 + d3 + d4, 7), (d2 + d3 + d5, 7), (d1 + d5 + d6, 3), (d3 - d6, 5), (d1 + d2 + d3, 6), (Cross54, 2), (d2 - d4, 3), (d3 + d4 + d6, 6), (d3 - d4, 6), (d3 + d5 + d6, 5), (d2 - d6, 9), (d1 + d3 + d5, 8), (d2 + d3 + d6, 7), (d1 - d3, 8), (d1 + d2 + d5, 6), (d2 - d5, 8), (d4 - d6, 6), (d3 - d5, 6), (d3 + d4 + d5, 7), (d4 - d5, 8), (d2 + d4 + d5, 6), (d1 + d4 + d5, 8), (d2 + d5 + d6, 10), (d1 + d2 + d6, 8), (d1 + d2 + d4, 6), (d1 - d5, 4), (d1 + d3 + d4, 7), (d2 - d3, 6), (d1 + d4 + d6, 8), (d1 + d3 + d6, 8), (d4 + d5 + d6, 8), (-1, 23)], [(d5 - d6, 5), (Cross41, 2), (d1 - d6, 7), (d1 - d2, 5), (d2 + d4 + d6, 6), (d1 - d4, 6), (d1 + d2 + d3 + d4 + d5 + d6, 5), (d2 + d3 + d4, 7), (d2 + d3 + d5, 7), (d1 + d5 + d6, 5), (d3 - d6, 4), (d1 + d2 + d3, 6), (Cross54, 2), (d2 - d4, 4), (d3 + d4 + d6, 6), (d3 - d4, 7), (d3 + d5 + d6, 4), (d2 - d6, 9), (d1 + d3 + d5, 8), (d2 + d3 + d6, 7), (d1 - d3, 8), (d1 + d2 + d5, 6), (d2 - d5, 7), (d4 - d6, 6), (d1 + d4 + d6, 7), (d3 + d4 + d5, 8), (d4 - d5, 8), (d2 + d4 + d5, 6), (d1 + d4 + d5, 7), (d2 + d5 + d6, 9), (d1 + d2 + d6, 8), (d1 + d2 + d4, 6), (d1 - d5, 5), (d1 + d3 + d4, 7), (d2 - d3, 6), (d3 - d5, 6), (d1 + d3 + d6, 8), (d4 + d5 + d6, 8), (-1, 23)], [(d5 - d6, 5), (Cross41, 2), (d1 - d6, 7), (d1 - d2, 6), (d2 + d4 + d6, 5), (d1 - d4, 7), (d1 + d2 + d3 + d4 + d5 + d6, 5), (d2 + d3 + d4, 7), (d2 + d3 + d5, 7), (d1 + d5 + d6, 4), (d3 - d6, 4), (d1 + d2 + d3, 6), (Cross54, 2), (d2 - d4, 3), (d3 + d4 + d6, 6), (d3 - d4, 7), (d3 + d5 + d6, 5), (d2 - d6, 9), (d1 + d3 + d5, 8), (d2 + d3 + d6, 7), (d1 - d3, 7), (d1 + d2 + d5, 6), (d2 - d5, 7), (d4 - d6, 6), (d1 + d4 + d6, 8), (d3 + d4 + d5, 8), (d4 - d5, 8), (d2 + d4 + d5, 6), (d1 + d4 + d5, 7), (d2 + d5 + d6, 9), (d1 + d2 + d6, 9), (d1 + d2 + d4, 6), (d1 - d5, 4), (d1 + d3 + d4, 7), (d2 - d3, 6), (d3 - d5, 7), (d1 + d3 + d6, 7), (d4 + d5 + d6, 8), (-1, 23)], [(d5 - d6, 5), (Cross41, 2), (d1 - d6, 6), (d1 - d2, 7), (d2 + d4 + d6, 5), (d1 - d4, 8), (d1 + d2 + d3 + d4 + d5 + d6, 5), (d1 + d2 + d4, 6), (d2 + d3 + d5, 8), (d1 + d5 + d6, 3), (d3 - d6, 5), (d1 + d2 + d3, 6), (Cross54, 2), (d2 - d4, 2), (d3 + d4 + d6, 7), (d3 - d4, 7), (d3 + d5 + d6, 6), (d1 + d3 + d6, 7), (d1 + d3 + d5, 7), (d2 + d3 + d6, 6), (d1 - d3, 6), (d1 + d2 + d5, 6), (d2 - d5, 7), (d4 - d6, 6), (d3 - d5, 7), (d3 + d4 + d5, 7), (d4 - d5, 8), (d2 + d4 + d5, 5), (d1 + d4 + d5, 9), (d2 + d5 + d6, 9), (d1 + d2 + d6, 10), (d1 - d5, 4), (d1 + d3 + d4, 7), (d2 - d3, 6), (d1 + d4 + d6, 7), (d2 - d6, 9), (d4 + d5 + d6, 8), (-1, 21), (d2 + d3 + d4, 7)], [(d5 - d6, 5), (Cross41, 2), (d1 - d6, 6), (d1 - d2, 5), (d2 + d4 + d6, 6), (d1 - d4, 8), (d1 + d2 + d3 + d4 + d5 + d6, 5), (d1 + d2 + d4, 6), (d2 + d3 + d5, 8), (d1 + d5 + d6, 3), (d3 - d6, 5), (d1 + d2 + d3, 6), (Cross54, 2), (d2 - d4, 3), (d3 + d4 + d6, 6), (d3 - d4, 6), (d3 + d5 + d6, 5), (d1 + d3 + d6, 9), (d1 + d3 + d5, 7), (d2 + d3 + d6, 6), (d1 - d3, 8), (d1 + d2 + d5, 6), (d2 - d5, 8), (d4 - d6, 6), (d3 - d5, 6), (d3 + d4 + d5, 7), (d4 - d5, 8), (d2 + d4 + d5, 5), (d1 + d4 + d5, 9), (d2 + d5 + d6, 10), (d1 + d2 + d6, 8), (d1 - d5, 4), (d1 + d3 + d4, 7), (d2 - d3, 6), (d1 + d4 + d6, 7), (d2 - d6, 9), (d4 + d5 + d6, 8), (-1, 21), (d2 + d3 + d4, 7)], [(d5 - d6, 5), (Cross41, 2), (d1 - d6, 6), (d1 + d2 + d6, 8), (d1 - d2, 6), (d2 + d4 + d6, 6), (d1 - d4, 7), (d1 + d2 + d3 + d4 + d5 + d6, 5), (d2 + d3 + d4, 7), (d2 + d3 + d5, 7), (d1 + d5 + d6, 4), (d3 - d6, 5), (d1 + d2 + d3, 6), (Cross54, 2), (d2 - d4, 3), (d3 + d4 + d6, 6), (d3 - d4, 7), (d3 + d5 + d6, 5), (d1 + d3 + d6, 8), (d2 + d3 + d6, 7), (d1 - d3, 7), (d1 + d2 + d5, 7), (d2 - d5, 7), (d1 + d3 + d5, 7), (d1 + d4 + d6, 7), (d3 + d4 + d5, 8), (d4 - d5, 8), (d2 + d4 + d5, 5), (d1 + d4 + d5, 8), (d2 + d5 + d6, 9), (d4 - d6, 6), (d1 + d3 + d4, 7), (d1 - d5, 5), (d1 + d2 + d4, 6), (d2 - d3, 6), (d3 - d5, 6), (d2 - d6, 9), (d4 + d5 + d6, 8), (-1, 21)], [(d5 - d6, 5), (Cross41, 2), (d1 - d6, 6), (d1 + d2 + d6, 9), (d1 - d2, 7), (d2 + d4 + d6, 5), (d1 - d4, 8), (d1 + d2 + d3 + d4 + d5 + d6, 5), (d1 + d3 + d4, 7), (d2 + d3 + d5, 7), (d1 + d5 + d6, 3), (d3 - d6, 5), (d1 + d2 + d3, 6), (Cross54, 2), (d2 - d4, 2), (d3 + d4 + d6, 6), (d3 - d4, 7), (d3 + d5 + d6, 6), (d1 + d3 + d6, 7), (d2 + d3 + d6, 7), (d1 - d3, 6), (d1 + d2 + d5, 7), (d2 - d5, 7), (d1 + d3 + d5, 7), (d1 + d4 + d6, 8), (d3 + d4 + d5, 8), (d4 - d5, 8), (d2 + d4 + d5, 5), (d1 + d4 + d5, 8), (d2 + d5 + d6, 9), (d4 - d6, 6), (d1 - d5, 4), (d1 + d2 + d4, 6), (d2 - d3, 6), (d3 - d5, 7), (d2 - d6, 9), (d4 + d5 + d6, 8), (-1, 21), (d2 + d3 + d4, 7)], [(d5 - d6, 5), (Cross41, 2), (d2 + d4 + d6, 5), (d1 - d2, 7), (d1 + d2 + d5, 7), (d3 + d4 + d5, 8), (d1 + d2 + d3 + d4 + d5 + d6, 5), (d2 + d3 + d4, 7), (d2 + d3 + d5, 7), (d1 + d5 + d6, 5), (d3 - d6, 5), (d1 + d2 + d3, 6), (Cross54, 2), (d2 - d4, 3), (d3 + d4 + d6, 7), (d2 - d3, 6), (d3 + d5 + d6, 5), (d1 + d3 + d6, 7), (d2 + d3 + d6, 7), (d1 - d3, 6), (d1 - d6, 7), (d2 - d5, 7), (d1 + d2 + d6, 9), (d3 - d5, 6), (d1 - d4, 6), (d4 - d5, 8), (d2 + d4 + d5, 6), (d1 + d4 + d5, 7), (d2 + d5 + d6, 8), (d1 + d3 + d5, 7), (d1 + d3 + d4, 7), (d1 - d5, 5), (d1 + d2 + d4, 6), (d3 - d4, 8), (d4 - d6, 6), (d1 + d4 + d6, 7), (d2 - d6, 8), (d4 + d5 + d6, 8), (-1, 23)], [(d5 - d6, 5), (Cross41, 2), (d1 - d6, 7), (d1 + d2 + d6, 8), (d1 - d2, 6), (d2 + d4 + d6, 5), (d1 - d4, 7), (d1 + d2 + d3 + d4 + d5 + d6, 5), (d2 + d3 + d4, 7), (d2 + d3 + d5, 7), (d1 + d5 + d6, 4), (d3 - d6, 5), (d1 + d2 + d3, 6), (Cross54, 2), (d2 - d4, 3), (d3 + d4 + d6, 6), (d3 - d4, 7), (d3 + d5 + d6, 5), (d1 + d3 + d6, 8), (d2 + d3 + d6, 7), (d1 - d3, 7), (d1 + d2 + d5, 7), (d2 - d5, 8), (d1 + d3 + d5, 7), (d3 - d5, 6), (d3 + d4 + d5, 8), (d4 - d5, 8), (d2 + d4 + d5, 6), (d1 + d4 + d5, 7), (d2 + d5 + d6, 9), (d4 - d6, 6), (d1 + d3 + d4, 7), (d1 - d5, 4), (d1 + d2 + d4, 6), (d2 - d3, 6), (d1 + d4 + d6, 8), (d2 - d6, 8), (d4 + d5 + d6, 8), (-1, 23)], [(d5 - d6, 5), (Cross41, 2), (d1 - d6, 8), (d1 - d2, 7), (d2 + d4 + d6, 5), (d1 - d4, 6), (d1 + d2 + d3 + d4 + d5 + d6, 5), (d1 + d3 + d4, 7), (d2 + d3 + d5, 8), (d1 + d5 + d6, 5), (d3 - d6, 4), (d1 + d2 + d3, 6), (Cross54, 2), (d2 - d4, 3), (d3 + d4 + d6, 7), (d3 - d4, 8), (d3 + d5 + d6, 5), (d1 + d3 + d6, 7), (d1 + d3 + d5, 7), (d2 + d3 + d6, 6), (d1 - d3, 6), (d1 + d2 + d5, 6), (d2 - d5, 7), (d4 - d6, 6), (d3 - d5, 7), (d3 + d4 + d5, 8), (d4 - d5, 8), (d2 + d4 + d5, 6), (d1 + d4 + d5, 7), (d2 + d5 + d6, 8), (d1 + d2 + d6, 10), (d1 - d5, 4), (d1 + d2 + d4, 6), (d2 - d3, 6), (d1 + d4 + d6, 7), (d2 - d6, 8), (d4 + d5 + d6, 8), (-1, 23), (d2 + d3 + d4, 7)], [(d5 - d6, 5), (Cross41, 2), (d1 - d6, 8), (d1 - d2, 5), (d2 + d4 + d6, 6), (d1 - d4, 6), (d1 + d2 + d3 + d4 + d5 + d6, 5), (d1 + d3 + d4, 7), (d2 + d3 + d5, 8), (d1 + d5 + d6, 5), (d3 - d6, 4), (d1 + d2 + d3, 6), (Cross54, 2), (d2 - d4, 4), (d3 + d4 + d6, 6), (d3 - d4, 7), (d3 + d5 + d6, 4), (d1 + d3 + d6, 9), (d1 + d3 + d5, 7), (d2 + d3 + d6, 6), (d1 - d3, 8), (d1 + d2 + d5, 6), (d2 - d5, 8), (d4 - d6, 6), (d3 - d5, 6), (d3 + d4 + d5, 8), (d4 - d5, 8), (d2 + d4 + d5, 6), (d1 + d4 + d5, 7), (d2 + d5 + d6, 9), (d1 + d2 + d6, 8), (d1 - d5, 4), (d1 + d2 + d4, 6), (d2 - d3, 6), (d1 + d4 + d6, 7), (d2 - d6, 8), (d4 + d5 + d6, 8), (-1, 23), (d2 + d3 + d4, 7)]] # We rewrite the BadFactor using only the relevant Cross functions: newAllFactor = sum([allCoef[k]*fromFactorsToRationalFunctions(allMonInDs[k]) for k in range(0,len(allMonInDs))]) # newAllFactor # -Cross41^2*Cross54^2*(d1 + d2 + d3 + d4 + d5 + d6)^5*(d1 + d2 + d3)^6*(d1 + d2 + d4)^6*(d1 + d2 + d5)^6*(d1 + d2 + d6)^8*(d1 - d2)^5*(d1 + d3 + d4)^7*(d1 + d3 + d5)^7*(d1 + d3 + d6)^9*(d1 - d3)^8*(d1 + d4 + d5)^7*(d1 + d4 + d6)^7*(d1 - d4)^6*(d1 + d5 + d6)^5*(d1 - d5)^4*(d1 - d6)^8*(d2 + d3 + d4)^7*(d2 + d3 + d5)^8*(d2 + d3 + d6)^6*(d2 - d3)^6*(d2 + d4 + d5)^6*(d2 + d4 + d6)^6*(d2 - d4)^4*(d2 + d5 + d6)^9*(d2 - d5)^8*(d2 - d6)^8*(d3 + d4 + d5)^8*(d3 + d4 + d6)^6*(d3 - d4)^7*(d3 + d5 + d6)^4*(d3 - d5)^6*(d3 - d6)^4*(d4 + d5 + d6)^8*(d4 - d5)^8*(d4 - d6)^6*(d5 - d6)^5 + Cross41^2*Cross54^2*(d1 + d2 + d3 + d4 + d5 + d6)^5*(d1 + d2 + d3)^6*(d1 + d2 + d4)^6*(d1 + d2 + d5)^6*(d1 + d2 + d6)^8*(d1 - d2)^5*(d1 + d3 + d4)^7*(d1 + d3 + d5)^8*(d1 + d3 + d6)^8*(d1 - d3)^8*(d1 + d4 + d5)^7*(d1 + d4 + d6)^7*(d1 - d4)^6*(d1 + d5 + d6)^5*(d1 - d5)^5*(d1 - d6)^7*(d2 + d3 + d4)^7*(d2 + d3 + d5)^7*(d2 + d3 + d6)^7*(d2 - d3)^6*(d2 + d4 + d5)^6*(d2 + d4 + d6)^6*(d2 - d4)^4*(d2 + d5 + d6)^9*(d2 - d5)^7*(d2 - d6)^9*(d3 + d4 + d5)^8*(d3 + d4 + d6)^6*(d3 - d4)^7*(d3 + d5 + d6)^4*(d3 - d5)^6*(d3 - d6)^4*(d4 + d5 + d6)^8*(d4 - d5)^8*(d4 - d6)^6*(d5 - d6)^5 - Cross41^2*Cross54^2*(d1 + d2 + d3 + d4 + d5 + d6)^5*(d1 + d2 + d3)^6*(d1 + d2 + d4)^6*(d1 + d2 + d5)^6*(d1 + d2 + d6)^9*(d1 - d2)^6*(d1 + d3 + d4)^7*(d1 + d3 + d5)^8*(d1 + d3 + d6)^7*(d1 - d3)^7*(d1 + d4 + d5)^7*(d1 + d4 + d6)^8*(d1 - d4)^7*(d1 + d5 + d6)^4*(d1 - d5)^4*(d1 - d6)^7*(d2 + d3 + d4)^7*(d2 + d3 + d5)^7*(d2 + d3 + d6)^7*(d2 - d3)^6*(d2 + d4 + d5)^6*(d2 + d4 + d6)^5*(d2 - d4)^3*(d2 + d5 + d6)^9*(d2 - d5)^7*(d2 - d6)^9*(d3 + d4 + d5)^8*(d3 + d4 + d6)^6*(d3 - d4)^7*(d3 + d5 + d6)^5*(d3 - d5)^7*(d3 - d6)^4*(d4 + d5 + d6)^8*(d4 - d5)^8*(d4 - d6)^6*(d5 - d6)^5 + Cross41^2*Cross54^2*(d1 + d2 + d3 + d4 + d5 + d6)^5*(d1 + d2 + d3)^6*(d1 + d2 + d4)^6*(d1 + d2 + d5)^6*(d1 + d2 + d6)^10*(d1 - d2)^7*(d1 + d3 + d4)^7*(d1 + d3 + d5)^7*(d1 + d3 + d6)^7*(d1 - d3)^6*(d1 + d4 + d5)^7*(d1 + d4 + d6)^7*(d1 - d4)^6*(d1 + d5 + d6)^5*(d1 - d5)^4*(d1 - d6)^8*(d2 + d3 + d4)^7*(d2 + d3 + d5)^8*(d2 + d3 + d6)^6*(d2 - d3)^6*(d2 + d4 + d5)^6*(d2 + d4 + d6)^5*(d2 - d4)^3*(d2 + d5 + d6)^8*(d2 - d5)^7*(d2 - d6)^8*(d3 + d4 + d5)^8*(d3 + d4 + d6)^7*(d3 - d4)^8*(d3 + d5 + d6)^5*(d3 - d5)^7*(d3 - d6)^4*(d4 + d5 + d6)^8*(d4 - d5)^8*(d4 - d6)^6*(d5 - d6)^5 - Cross41^2*Cross54^2*(d1 + d2 + d3 + d4 + d5 + d6)^5*(d1 + d2 + d3)^6*(d1 + d2 + d4)^6*(d1 + d2 + d5)^6*(d1 + d2 + d6)^8*(d1 - d2)^5*(d1 + d3 + d4)^7*(d1 + d3 + d5)^8*(d1 + d3 + d6)^8*(d1 - d3)^8*(d1 + d4 + d5)^8*(d1 + d4 + d6)^8*(d1 - d4)^8*(d1 + d5 + d6)^3*(d1 - d5)^4*(d1 - d6)^6*(d2 + d3 + d4)^7*(d2 + d3 + d5)^7*(d2 + d3 + d6)^7*(d2 - d3)^6*(d2 + d4 + d5)^6*(d2 + d4 + d6)^5*(d2 - d4)^3*(d2 + d5 + d6)^10*(d2 - d5)^8*(d2 - d6)^9*(d3 + d4 + d5)^7*(d3 + d4 + d6)^6*(d3 - d4)^6*(d3 + d5 + d6)^5*(d3 - d5)^6*(d3 - d6)^5*(d4 + d5 + d6)^8*(d4 - d5)^8*(d4 - d6)^6*(d5 - d6)^5 + Cross41^2*Cross54^2*(d1 + d2 + d3 + d4 + d5 + d6)^5*(d1 + d2 + d3)^6*(d1 + d2 + d4)^6*(d1 + d2 + d5)^6*(d1 + d2 + d6)^8*(d1 - d2)^5*(d1 + d3 + d4)^7*(d1 + d3 + d5)^7*(d1 + d3 + d6)^9*(d1 - d3)^8*(d1 + d4 + d5)^9*(d1 + d4 + d6)^7*(d1 - d4)^8*(d1 + d5 + d6)^3*(d1 - d5)^4*(d1 - d6)^6*(d2 + d3 + d4)^7*(d2 + d3 + d5)^8*(d2 + d3 + d6)^6*(d2 - d3)^6*(d2 + d4 + d5)^5*(d2 + d4 + d6)^6*(d2 - d4)^3*(d2 + d5 + d6)^10*(d2 - d5)^8*(d2 - d6)^9*(d3 + d4 + d5)^7*(d3 + d4 + d6)^6*(d3 - d4)^6*(d3 + d5 + d6)^5*(d3 - d5)^6*(d3 - d6)^5*(d4 + d5 + d6)^8*(d4 - d5)^8*(d4 - d6)^6*(d5 - d6)^5 + Cross41^2*Cross54^2*(d1 + d2 + d3 + d4 + d5 + d6)^5*(d1 + d2 + d3)^6*(d1 + d2 + d4)^6*(d1 + d2 + d5)^7*(d1 + d2 + d6)^8*(d1 - d2)^6*(d1 + d3 + d4)^7*(d1 + d3 + d5)^7*(d1 + d3 + d6)^8*(d1 - d3)^7*(d1 + d4 + d5)^7*(d1 + d4 + d6)^8*(d1 - d4)^7*(d1 + d5 + d6)^4*(d1 - d5)^4*(d1 - d6)^7*(d2 + d3 + d4)^7*(d2 + d3 + d5)^7*(d2 + d3 + d6)^7*(d2 - d3)^6*(d2 + d4 + d5)^6*(d2 + d4 + d6)^5*(d2 - d4)^3*(d2 + d5 + d6)^9*(d2 - d5)^8*(d2 - d6)^8*(d3 + d4 + d5)^8*(d3 + d4 + d6)^6*(d3 - d4)^7*(d3 + d5 + d6)^5*(d3 - d5)^6*(d3 - d6)^5*(d4 + d5 + d6)^8*(d4 - d5)^8*(d4 - d6)^6*(d5 - d6)^5 - Cross41^2*Cross54^2*(d1 + d2 + d3 + d4 + d5 + d6)^5*(d1 + d2 + d3)^6*(d1 + d2 + d4)^6*(d1 + d2 + d5)^7*(d1 + d2 + d6)^8*(d1 - d2)^6*(d1 + d3 + d4)^7*(d1 + d3 + d5)^7*(d1 + d3 + d6)^8*(d1 - d3)^7*(d1 + d4 + d5)^8*(d1 + d4 + d6)^7*(d1 - d4)^7*(d1 + d5 + d6)^4*(d1 - d5)^5*(d1 - d6)^6*(d2 + d3 + d4)^7*(d2 + d3 + d5)^7*(d2 + d3 + d6)^7*(d2 - d3)^6*(d2 + d4 + d5)^5*(d2 + d4 + d6)^6*(d2 - d4)^3*(d2 + d5 + d6)^9*(d2 - d5)^7*(d2 - d6)^9*(d3 + d4 + d5)^8*(d3 + d4 + d6)^6*(d3 - d4)^7*(d3 + d5 + d6)^5*(d3 - d5)^6*(d3 - d6)^5*(d4 + d5 + d6)^8*(d4 - d5)^8*(d4 - d6)^6*(d5 - d6)^5 + Cross41^2*Cross54^2*(d1 + d2 + d3 + d4 + d5 + d6)^5*(d1 + d2 + d3)^6*(d1 + d2 + d4)^6*(d1 + d2 + d5)^6*(d1 + d2 + d6)^9*(d1 - d2)^6*(d1 + d3 + d4)^7*(d1 + d3 + d5)^8*(d1 + d3 + d6)^7*(d1 - d3)^7*(d1 + d4 + d5)^8*(d1 + d4 + d6)^7*(d1 - d4)^7*(d1 + d5 + d6)^4*(d1 - d5)^5*(d1 - d6)^6*(d2 + d3 + d4)^7*(d2 + d3 + d5)^7*(d2 + d3 + d6)^7*(d2 - d3)^6*(d2 + d4 + d5)^6*(d2 + d4 + d6)^5*(d2 - d4)^3*(d2 + d5 + d6)^9*(d2 - d5)^7*(d2 - d6)^9*(d3 + d4 + d5)^7*(d3 + d4 + d6)^7*(d3 - d4)^7*(d3 + d5 + d6)^5*(d3 - d5)^6*(d3 - d6)^5*(d4 + d5 + d6)^8*(d4 - d5)^8*(d4 - d6)^6*(d5 - d6)^5 - Cross41^2*Cross54^2*(d1 + d2 + d3 + d4 + d5 + d6)^5*(d1 + d2 + d3)^6*(d1 + d2 + d4)^6*(d1 + d2 + d5)^7*(d1 + d2 + d6)^9*(d1 - d2)^7*(d1 + d3 + d4)^7*(d1 + d3 + d5)^7*(d1 + d3 + d6)^7*(d1 - d3)^6*(d1 + d4 + d5)^7*(d1 + d4 + d6)^7*(d1 - d4)^6*(d1 + d5 + d6)^5*(d1 - d5)^5*(d1 - d6)^7*(d2 + d3 + d4)^7*(d2 + d3 + d5)^7*(d2 + d3 + d6)^7*(d2 - d3)^6*(d2 + d4 + d5)^6*(d2 + d4 + d6)^5*(d2 - d4)^3*(d2 + d5 + d6)^8*(d2 - d5)^7*(d2 - d6)^8*(d3 + d4 + d5)^8*(d3 + d4 + d6)^7*(d3 - d4)^8*(d3 + d5 + d6)^5*(d3 - d5)^6*(d3 - d6)^5*(d4 + d5 + d6)^8*(d4 - d5)^8*(d4 - d6)^6*(d5 - d6)^5 + Cross41^2*Cross54^2*(d1 + d2 + d3 + d4 + d5 + d6)^5*(d1 + d2 + d3)^6*(d1 + d2 + d4)^6*(d1 + d2 + d5)^7*(d1 + d2 + d6)^9*(d1 - d2)^7*(d1 + d3 + d4)^7*(d1 + d3 + d5)^7*(d1 + d3 + d6)^7*(d1 - d3)^6*(d1 + d4 + d5)^8*(d1 + d4 + d6)^8*(d1 - d4)^8*(d1 + d5 + d6)^3*(d1 - d5)^4*(d1 - d6)^6*(d2 + d3 + d4)^7*(d2 + d3 + d5)^7*(d2 + d3 + d6)^7*(d2 - d3)^6*(d2 + d4 + d5)^5*(d2 + d4 + d6)^5*(d2 - d4)^2*(d2 + d5 + d6)^9*(d2 - d5)^7*(d2 - d6)^9*(d3 + d4 + d5)^8*(d3 + d4 + d6)^6*(d3 - d4)^7*(d3 + d5 + d6)^6*(d3 - d5)^7*(d3 - d6)^5*(d4 + d5 + d6)^8*(d4 - d5)^8*(d4 - d6)^6*(d5 - d6)^5 - Cross41^2*Cross54^2*(d1 + d2 + d3 + d4 + d5 + d6)^5*(d1 + d2 + d3)^6*(d1 + d2 + d4)^6*(d1 + d2 + d5)^6*(d1 + d2 + d6)^10*(d1 - d2)^7*(d1 + d3 + d4)^7*(d1 + d3 + d5)^7*(d1 + d3 + d6)^7*(d1 - d3)^6*(d1 + d4 + d5)^9*(d1 + d4 + d6)^7*(d1 - d4)^8*(d1 + d5 + d6)^3*(d1 - d5)^4*(d1 - d6)^6*(d2 + d3 + d4)^7*(d2 + d3 + d5)^8*(d2 + d3 + d6)^6*(d2 - d3)^6*(d2 + d4 + d5)^5*(d2 + d4 + d6)^5*(d2 - d4)^2*(d2 + d5 + d6)^9*(d2 - d5)^7*(d2 - d6)^9*(d3 + d4 + d5)^7*(d3 + d4 + d6)^7*(d3 - d4)^7*(d3 + d5 + d6)^6*(d3 - d5)^7*(d3 - d6)^5*(d4 + d5 + d6)^8*(d4 - d5)^8*(d4 - d6)^6*(d5 - d6)^5 # # Check the numerical value agrees: # bool(newAllFactor.substitute(YcrossdsToNumDv) == badFactor.substitute(YcrossdsToNumDv)) # True #################################### # Factorizing newAllFactor via gcd # #################################### # To speed up the computation of the factors of newAllFactor, we factorize each of the 12 monomials, compute their gcd, factor the gcd out and factorize the remaining piece. def computegcd(colDenom): if colDenom == []: return 1 else: gcdCol = colDenom[0] for x in range(1,len(colDenom)): gcdCol = gcd(colDenom[x], gcdCol) return gcdCol # We start by factoring each monomial: newAllMon = [fromFactorsToRationalFunctions(allMonInDs[k]) for k in range(0,len(allMonInDs))] ############### # Compute gcd # ############### gcdnewAllMon = computegcd(newAllMon) # gcdnewAllMon # Cross41^2*Cross54^2*(d1 + d2 + d3 + d4 + d5 + d6)^5*(d1 + d2 + d3)^6*(d1 + d2 + d4)^6*(d1 + d2 + d5)^6*(d1 + d2 + d6)^8*(d1 - d2)^5*(d1 + d3 + d4)^7*(d1 + d3 + d5)^7*(d1 + d3 + d6)^7*(d1 - d3)^6*(d1 + d4 + d5)^7*(d1 + d4 + d6)^7*(d1 - d4)^6*(d1 + d5 + d6)^3*(d1 - d5)^4*(d1 - d6)^6*(d2 + d3 + d4)^7*(d2 + d3 + d5)^7*(d2 + d3 + d6)^6*(d2 - d3)^6*(d2 + d4 + d5)^5*(d2 + d4 + d6)^5*(d2 - d4)^2*(d2 + d5 + d6)^8*(d2 - d5)^7*(d2 - d6)^8*(d3 + d4 + d5)^7*(d3 + d4 + d6)^6*(d3 - d4)^6*(d3 + d5 + d6)^4*(d3 - d5)^6*(d3 - d6)^4*(d4 + d5 + d6)^8*(d4 - d5)^8*(d4 - d6)^6*(d5 - d6)^5 # We can record the gcds: gcdFactors = gcdnewAllMon.factor_list() # print gcdFactors # gcdFactors = [(Cross41,2), (Cross54,2), (d1 + d2 + d3 + d4 + d5 + d6,5), (d1 + d2 + d3,6), (d1 + d2 + d4,6), (d1 + d2 + d5,6), (d1 + d2 + d6,8), (d1 - d2,5), (d1 + d3 + d4,7), (d1 + d3 + d5,7), (d1 + d3 + d6,7), (d1 - d3,6), (d1 + d4 + d5,7), (d1 + d4 + d6,7), (d1 - d4,6),(d1 + d5 + d6,3), (d1 - d5,4), (d1 - d6,6), (d2 + d3 + d4,7), (d2 + d3 + d5,7), (d2 + d3 + d6,6), (d2 - d3,6), (d2 + d4 + d5,5), (d2 + d4 + d6,5), (d2 - d4,2), (d2 + d5 + d6,8), (d2 - d5,7), (d2 - d6,8),(d3 + d4 + d5,7), (d3 + d4 + d6,6), (d3 - d4,6), (d3 + d5 + d6,4), (d3 - d5,6), (d3 - d6,4), (d4 + d5 + d6,8), (d4 - d5,8), (d4 - d6,6), (d5 - d6,5)] ################### # Factor out gcds # ################### newAllMonNoGcd = [newAllMon[k]/gcdnewAllMon for k in range(0,len(newAllMon))] # print newAllMonNoGcd # [-(d1 + d2 + d6)*(d1 - d2)*(d1 + d3 + d5)*(d1 - d3)*(d1 + d4 + d5)*(d1 - d4)*(d1 + d5 + d6)*(d1 - d5)*(d2 + d3 + d6)*(d2 + d4 + d5)*(d2 - d4)*(d2 + d5 + d6)*(d2 - d6)*(d3 + d4 + d6)*(d3 - d4)*(d3 + d5 + d6)*(d3 - d6), -(d1 + d3 + d5)*(d1 + d3 + d6)*(d1 - d3)^2*(d1 + d4 + d5)*(d1 + d4 + d6)*(d1 - d4)^2*(d2 + d3 + d6)*(d2 + d4 + d5)*(d2 - d4)*(d2 + d5 + d6)^2*(d2 - d5)*(d2 - d6)*(d3 + d5 + d6)*(d3 - d6), -(d1 + d3 + d5)*(d1 + d3 + d6)*(d1 - d3)^2*(d1 + d5 + d6)^2*(d1 - d5)*(d1 - d6)*(d2 + d3 + d6)*(d2 + d4 + d5)*(d2 + d4 + d6)*(d2 - d4)^2*(d2 + d5 + d6)*(d2 - d6)*(d3 + d4 + d5)*(d3 - d4), -(d1 + d2 + d6)*(d1 - d2)*(d1 + d3 + d5)*(d1 - d3)*(d1 + d4 + d6)*(d1 - d4)*(d1 + d5 + d6)*(d1 - d6)*(d2 + d3 + d6)*(d2 + d4 + d5)*(d2 - d4)*(d2 + d5 + d6)*(d2 - d6)*(d3 + d4 + d5)*(d3 - d4)*(d3 + d5 + d6)*(d3 - d5), -(d1 + d2 + d6)^2*(d1 - d2)^2*(d1 + d4 + d5)^2*(d1 - d4)^2*(d2 + d3 + d5)*(d2 + d5 + d6)*(d2 - d6)*(d3 + d4 + d6)*(d3 - d4)*(d3 + d5 + d6)^2*(d3 - d5)*(d3 - d6), -(d1 + d3 + d6)^2*(d1 - d3)^2*(d1 + d4 + d5)^2*(d1 - d4)^2*(d2 + d3 + d5)*(d2 + d4 + d6)*(d2 - d4)*(d2 + d5 + d6)^2*(d2 - d5)*(d2 - d6)*(d3 + d5 + d6)*(d3 - d6), -(d1 + d2 + d5)*(d1 - d2)*(d1 + d3 + d6)*(d1 - d3)*(d1 + d4 + d5)*(d1 - d4)*(d1 + d5 + d6)*(d1 - d5)*(d2 + d3 + d6)*(d2 + d4 + d6)*(d2 - d4)*(d2 + d5 + d6)*(d2 - d6)*(d3 + d4 + d5)*(d3 - d4)*(d3 + d5 + d6)*(d3 - d6), -(d1 + d2 + d5)*(d1 + d2 + d6)*(d1 - d2)^2*(d1 + d4 + d5)*(d1 + d4 + d6)*(d1 - d4)^2*(d2 + d3 + d6)*(d2 + d5 + d6)*(d2 - d6)*(d3 + d4 + d5)*(d3 - d4)*(d3 + d5 + d6)^2*(d3 - d5)*(d3 - d6), -(d1 + d2 + d5)*(d1 + d2 + d6)*(d1 - d2)^2*(d1 + d5 + d6)^2*(d1 - d5)*(d1 - d6)*(d2 + d3 + d6)*(d2 + d4 + d5)*(d2 - d4)*(d3 + d4 + d5)*(d3 + d4 + d6)*(d3 - d4)^2*(d3 + d5 + d6)*(d3 - d6), -(d1 + d2 + d5)*(d1 - d2)*(d1 + d3 + d6)*(d1 - d3)*(d1 + d4 + d6)*(d1 - d4)*(d1 + d5 + d6)*(d1 - d6)*(d2 + d3 + d6)*(d2 + d4 + d5)*(d2 - d4)*(d2 + d5 + d6)*(d2 - d5)*(d3 + d4 + d5)*(d3 - d4)*(d3 + d5 + d6)*(d3 - d6), -(d1 + d2 + d6)^2*(d1 - d2)^2*(d1 + d5 + d6)^2*(d1 - d6)^2*(d2 + d3 + d5)*(d2 + d4 + d5)*(d2 - d4)*(d3 + d4 + d5)*(d3 + d4 + d6)*(d3 - d4)^2*(d3 + d5 + d6)*(d3 - d5), -(d1 + d3 + d6)^2*(d1 - d3)^2*(d1 + d5 + d6)^2*(d1 - d6)^2*(d2 + d3 + d5)*(d2 + d4 + d5)*(d2 + d4 + d6)*(d2 - d4)^2*(d2 + d5 + d6)*(d2 - d5)*(d3 + d4 + d5)*(d3 - d4)] newAllFactorNogcd = sum([allCoef[k]*newAllMonNoGcd[k] for k in range(0,len(allMonInDs))]) newAllFactorNogcd 2*(d1^4*d2 + d1^3*d2^2 + d1^4*d3 + 2*d1^3*d2*d3 + d1^2*d2^2*d3 + d1^3*d3^2 + d1^2*d2*d3^2 + d1^4*d4 + 2*d1^3*d2*d4 + d1^2*d2^2*d4 + 2*d1^3*d3*d4 + 3*d1^2*d2*d3*d4 + d1*d2^2*d3*d4 + d1^2*d3^2*d4 + d1*d2*d3^2*d4 + d1^3*d4^2 + d1^2*d2*d4^2 + d1^2*d3*d4^2 + d1*d2*d3*d4^2 + d1^4*d5 + 2*d1^3*d2*d5 + d1^2*d2^2*d5 + 2*d1^3*d3*d5 + 3*d1^2*d2*d3*d5 + d1*d2^2*d3*d5 + d1^2*d3^2*d5 + d1*d2*d3^2*d5 + 2*d1^3*d4*d5 + 3*d1^2*d2*d4*d5 + d1*d2^2*d4*d5 + 3*d1^2*d3*d4*d5 + 2*d1*d2*d3*d4*d5 - d2^2*d3*d4*d5 + d1*d3^2*d4*d5 - d2*d3^2*d4*d5 + d1^2*d4^2*d5 + d1*d2*d4^2*d5 + d1*d3*d4^2*d5 - d2*d3*d4^2*d5 + d1^3*d5^2 + d1^2*d2*d5^2 + d1^2*d3*d5^2 + d1*d2*d3*d5^2 + d1^2*d4*d5^2 + d1*d2*d4*d5^2 + d1*d3*d4*d5^2 - d2*d3*d4*d5^2 - d1^4*d6 - d1^2*d2*d3*d6 - d1*d2^2*d3*d6 - d1*d2*d3^2*d6 - d1^2*d2*d4*d6 - d1*d2^2*d4*d6 - d1^2*d3*d4*d6 - 2*d1*d2*d3*d4*d6 - d1*d3^2*d4*d6 - d1*d2*d4^2*d6 - d1*d3*d4^2*d6 - d1^2*d2*d5*d6 - d1*d2^2*d5*d6 - d1^2*d3*d5*d6 - 2*d1*d2*d3*d5*d6 - d1*d3^2*d5*d6 - d1^2*d4*d5*d6 - 2*d1*d2*d4*d5*d6 - 2*d1*d3*d4*d5*d6 - d1*d4^2*d5*d6 - d1*d2*d5^2*d6 - d1*d3*d5^2*d6 - d1*d4*d5^2*d6 - d1^3*d6^2 - d1*d2*d3*d6^2 - d2^2*d3*d6^2 - d2*d3^2*d6^2 - d1*d2*d4*d6^2 - d2^2*d4*d6^2 - d1*d3*d4*d6^2 - 2*d2*d3*d4*d6^2 - d3^2*d4*d6^2 - d2*d4^2*d6^2 - d3*d4^2*d6^2 - d1*d2*d5*d6^2 - d2^2*d5*d6^2 - d1*d3*d5*d6^2 - 2*d2*d3*d5*d6^2 - d3^2*d5*d6^2 - d1*d4*d5*d6^2 - 2*d2*d4*d5*d6^2 - 2*d3*d4*d5*d6^2 - d4^2*d5*d6^2 - d2*d5^2*d6^2 - d3*d5^2*d6^2 - d4*d5^2*d6^2)*(d1 - d2)*(d1 - d3)*(d1 - d4)*(d1 + d5 + d6)*(d2 + d3 + d6)*(d2 - d3)*(d2 - d4)*(d2 + d5 + d6)*(d3 - d4)*(d3 + d5 + d6)*(d4 + d5 + d6)*(d5 - d6) noGcdFactors = newAllFactorNogcd.factor_list() # noGcdFactors # [(d1^4*d2 + d1^3*d2^2 + d1^4*d3 + 2*d1^3*d2*d3 + d1^2*d2^2*d3 + d1^3*d3^2 + d1^2*d2*d3^2 + d1^4*d4 + 2*d1^3*d2*d4 + d1^2*d2^2*d4 + 2*d1^3*d3*d4 + 3*d1^2*d2*d3*d4 + d1*d2^2*d3*d4 + d1^2*d3^2*d4 + d1*d2*d3^2*d4 + d1^3*d4^2 + d1^2*d2*d4^2 + d1^2*d3*d4^2 + d1*d2*d3*d4^2 + d1^4*d5 + 2*d1^3*d2*d5 + d1^2*d2^2*d5 + 2*d1^3*d3*d5 + 3*d1^2*d2*d3*d5 + d1*d2^2*d3*d5 + d1^2*d3^2*d5 + d1*d2*d3^2*d5 + 2*d1^3*d4*d5 + 3*d1^2*d2*d4*d5 + d1*d2^2*d4*d5 + 3*d1^2*d3*d4*d5 + 2*d1*d2*d3*d4*d5 - d2^2*d3*d4*d5 + d1*d3^2*d4*d5 - d2*d3^2*d4*d5 + d1^2*d4^2*d5 + d1*d2*d4^2*d5 + d1*d3*d4^2*d5 - d2*d3*d4^2*d5 + d1^3*d5^2 + d1^2*d2*d5^2 + d1^2*d3*d5^2 + d1*d2*d3*d5^2 + d1^2*d4*d5^2 + d1*d2*d4*d5^2 + d1*d3*d4*d5^2 - d2*d3*d4*d5^2 - d1^4*d6 - d1^2*d2*d3*d6 - d1*d2^2*d3*d6 - d1*d2*d3^2*d6 - d1^2*d2*d4*d6 - d1*d2^2*d4*d6 - d1^2*d3*d4*d6 - 2*d1*d2*d3*d4*d6 - d1*d3^2*d4*d6 - d1*d2*d4^2*d6 - d1*d3*d4^2*d6 - d1^2*d2*d5*d6 - d1*d2^2*d5*d6 - d1^2*d3*d5*d6 - 2*d1*d2*d3*d5*d6 - d1*d3^2*d5*d6 - d1^2*d4*d5*d6 - 2*d1*d2*d4*d5*d6 - 2*d1*d3*d4*d5*d6 - d1*d4^2*d5*d6 - d1*d2*d5^2*d6 - d1*d3*d5^2*d6 - d1*d4*d5^2*d6 - d1^3*d6^2 - d1*d2*d3*d6^2 - d2^2*d3*d6^2 - d2*d3^2*d6^2 - d1*d2*d4*d6^2 - d2^2*d4*d6^2 - d1*d3*d4*d6^2 - 2*d2*d3*d4*d6^2 - d3^2*d4*d6^2 - d2*d4^2*d6^2 - d3*d4^2*d6^2 - d1*d2*d5*d6^2 - d2^2*d5*d6^2 - d1*d3*d5*d6^2 - 2*d2*d3*d5*d6^2 - d3^2*d5*d6^2 - d1*d4*d5*d6^2 - 2*d2*d4*d5*d6^2 - 2*d3*d4*d5*d6^2 - d4^2*d5*d6^2 - d2*d5^2*d6^2 - d3*d5^2*d6^2 - d4*d5^2*d6^2, # 1), # (d1 - d2, 1), # (d1 - d3, 1), # (d1 - d4, 1), # (d1 + d5 + d6, 1), # (d2 + d3 + d6, 1), # (d2 - d3, 1), # (d2 - d4, 1), # (d2 + d5 + d6, 1), # (d3 - d4, 1), # (d3 + d5 + d6, 1), # (d4 + d5 + d6, 1), # (d5 - d6, 1), # (2, 1)] allFactorsWithGcd = noGcdFactors + gcdFactors # allFactorsWithGcd # [(d1^4*d2 + d1^3*d2^2 + d1^4*d3 + 2*d1^3*d2*d3 + d1^2*d2^2*d3 + d1^3*d3^2 + d1^2*d2*d3^2 + d1^4*d4 + 2*d1^3*d2*d4 + d1^2*d2^2*d4 + 2*d1^3*d3*d4 + 3*d1^2*d2*d3*d4 + d1*d2^2*d3*d4 + d1^2*d3^2*d4 + d1*d2*d3^2*d4 + d1^3*d4^2 + d1^2*d2*d4^2 + d1^2*d3*d4^2 + d1*d2*d3*d4^2 + d1^4*d5 + 2*d1^3*d2*d5 + d1^2*d2^2*d5 + 2*d1^3*d3*d5 + 3*d1^2*d2*d3*d5 + d1*d2^2*d3*d5 + d1^2*d3^2*d5 + d1*d2*d3^2*d5 + 2*d1^3*d4*d5 + 3*d1^2*d2*d4*d5 + d1*d2^2*d4*d5 + 3*d1^2*d3*d4*d5 + 2*d1*d2*d3*d4*d5 - d2^2*d3*d4*d5 + d1*d3^2*d4*d5 - d2*d3^2*d4*d5 + d1^2*d4^2*d5 + d1*d2*d4^2*d5 + d1*d3*d4^2*d5 - d2*d3*d4^2*d5 + d1^3*d5^2 + d1^2*d2*d5^2 + d1^2*d3*d5^2 + d1*d2*d3*d5^2 + d1^2*d4*d5^2 + d1*d2*d4*d5^2 + d1*d3*d4*d5^2 - d2*d3*d4*d5^2 - d1^4*d6 - d1^2*d2*d3*d6 - d1*d2^2*d3*d6 - d1*d2*d3^2*d6 - d1^2*d2*d4*d6 - d1*d2^2*d4*d6 - d1^2*d3*d4*d6 - 2*d1*d2*d3*d4*d6 - d1*d3^2*d4*d6 - d1*d2*d4^2*d6 - d1*d3*d4^2*d6 - d1^2*d2*d5*d6 - d1*d2^2*d5*d6 - d1^2*d3*d5*d6 - 2*d1*d2*d3*d5*d6 - d1*d3^2*d5*d6 - d1^2*d4*d5*d6 - 2*d1*d2*d4*d5*d6 - 2*d1*d3*d4*d5*d6 - d1*d4^2*d5*d6 - d1*d2*d5^2*d6 - d1*d3*d5^2*d6 - d1*d4*d5^2*d6 - d1^3*d6^2 - d1*d2*d3*d6^2 - d2^2*d3*d6^2 - d2*d3^2*d6^2 - d1*d2*d4*d6^2 - d2^2*d4*d6^2 - d1*d3*d4*d6^2 - 2*d2*d3*d4*d6^2 - d3^2*d4*d6^2 - d2*d4^2*d6^2 - d3*d4^2*d6^2 - d1*d2*d5*d6^2 - d2^2*d5*d6^2 - d1*d3*d5*d6^2 - 2*d2*d3*d5*d6^2 - d3^2*d5*d6^2 - d1*d4*d5*d6^2 - 2*d2*d4*d5*d6^2 - 2*d3*d4*d5*d6^2 - d4^2*d5*d6^2 - d2*d5^2*d6^2 - d3*d5^2*d6^2 - d4*d5^2*d6^2, # 1), # (d1 - d2, 1), # (d1 - d3, 1), # (d1 - d4, 1), # (d1 + d5 + d6, 1), # (d2 + d3 + d6, 1), # (d2 - d3, 1), # (d2 - d4, 1), # (d2 + d5 + d6, 1), # (d3 - d4, 1), # (d3 + d5 + d6, 1), # (d4 + d5 + d6, 1), # (d5 - d6, 1), # (2, 1), # (Cross41, 2), # (Cross54, 2), # (d1 + d2 + d3 + d4 + d5 + d6, 5), # (d1 + d2 + d3, 6), # (d1 + d2 + d4, 6), # (d1 + d2 + d5, 6), # (d1 + d2 + d6, 8), # (d1 - d2, 5), # (d1 + d3 + d4, 7), # (d1 + d3 + d5, 7), # (d1 + d3 + d6, 7), # (d1 - d3, 6), # (d1 + d4 + d5, 7), # (d1 + d4 + d6, 7), # (d1 - d4, 6), # (d1 + d5 + d6, 3), # (d1 - d5, 4), # (d1 - d6, 6), # (d2 + d3 + d4, 7), # (d2 + d3 + d5, 7), # (d2 + d3 + d6, 6), # (d2 - d3, 6), # (d2 + d4 + d5, 5), # (d2 + d4 + d6, 5), # (d2 - d4, 2), # (d2 + d5 + d6, 8), # (d2 - d5, 7), # (d2 - d6, 8), # (d3 + d4 + d5, 7), # (d3 + d4 + d6, 6), # (d3 - d4, 6), # (d3 + d5 + d6, 4), # (d3 - d5, 6), # (d3 - d6, 4), # (d4 + d5 + d6, 8), # (d4 - d5, 8), # (d4 - d6, 6), # (d5 - d6, 5)] # We group the non-crossFactors: crossFactorsWithGcd = [] for x in allFactorsWithGcd: if x[0] in cross_variables: crossFactorsWithGcd.append(x) ################# # Cross factors # ################# crossFactorsWithGcd crossFactorsWithGcd = [(Cross41, 2), (Cross54, 2)] ################ # Root factors # ################ symbRoots = [SR(x) for x in positive_roots] # We group the root factors: trialRootFactorsWithGcd = [] for x in allFactorsWithGcd: if x[0] in symbRoots: trialRootFactorsWithGcd.append(x) if -1*x[0] in symbRoots: trialRootFactorsWithGcd.append((-1*x[0],x[1])) trialRootFactorsWithGcd.append((-1,x[1])) allRoots = set([x[0] for x in trialRootFactorsWithGcd]) coeffRoots = (-1, sum([x[1] for x in trialRootFactorsWithGcd if x[0] == -1])) # coeffRoots # (-1, 92) # We can ignore the coefficient because it equals 1. newList = dict() for x in allRoots: newList[x] = sum([y[1] for y in trialRootFactorsWithGcd if y[0] == x]) rootFactorsWithGcd = [(x,newList[x]) for x in allRoots if x!=-1] print rootFactorsWithGcd # rootFactorsWithGcd = [(d1 + d2 + d3 + d4 + d5 + d6, 5), (-d5 + d6, 6), (-d1 + d6, 6), (d2 + d4 + d6, 5), (-d1 + d2, 6), (-d1 + d5, 4), (-d3 + d4, 7), (d3 + d4 + d5, 7), (-d1 + d4, 7), (d2 + d3 + d4, 7), (d1 + d5 + d6, 4), (d2 + d3 + d5, 7), (-d3 + d6, 4), (d1 + d4 + d5, 7), (d1 + d2 + d3, 6), (-d2 + d4, 3), (d3 + d4 + d6, 6), (d3 + d5 + d6, 5), (-d2 + d6, 8), (d1 + d3 + d6, 7), (d2 + d3 + d6, 7), (-d1 + d3, 7), (-d4 + d6, 6), (-d2 + d5, 7), (-d4 + d5, 8), (d1 + d2 + d5, 6), (d2 + d4 + d5, 5), (d1 + d2 + d6, 8), (d2 + d5 + d6, 9), (d1 + d3 + d5, 7), (d1 + d2 + d4, 6), (d1 + d3 + d4, 7), (-d2 + d3, 7), (-d3 + d5, 6), (d1 + d4 + d6, 7), (d4 + d5 + d6, 9)] ################### # quintic factors # ################### remainingFactors = [x for x in allFactorsWithGcd if SR(x[0]) not in allRoots if x not in crossFactorsWithGcd if SR(-1*x[0]) not in allRoots] remainingFactors [(d1^4*d2 + d1^3*d2^2 + d1^4*d3 + 2*d1^3*d2*d3 + d1^2*d2^2*d3 + d1^3*d3^2 + d1^2*d2*d3^2 + d1^4*d4 + 2*d1^3*d2*d4 + d1^2*d2^2*d4 + 2*d1^3*d3*d4 + 3*d1^2*d2*d3*d4 + d1*d2^2*d3*d4 + d1^2*d3^2*d4 + d1*d2*d3^2*d4 + d1^3*d4^2 + d1^2*d2*d4^2 + d1^2*d3*d4^2 + d1*d2*d3*d4^2 + d1^4*d5 + 2*d1^3*d2*d5 + d1^2*d2^2*d5 + 2*d1^3*d3*d5 + 3*d1^2*d2*d3*d5 + d1*d2^2*d3*d5 + d1^2*d3^2*d5 + d1*d2*d3^2*d5 + 2*d1^3*d4*d5 + 3*d1^2*d2*d4*d5 + d1*d2^2*d4*d5 + 3*d1^2*d3*d4*d5 + 2*d1*d2*d3*d4*d5 - d2^2*d3*d4*d5 + d1*d3^2*d4*d5 - d2*d3^2*d4*d5 + d1^2*d4^2*d5 + d1*d2*d4^2*d5 + d1*d3*d4^2*d5 - d2*d3*d4^2*d5 + d1^3*d5^2 + d1^2*d2*d5^2 + d1^2*d3*d5^2 + d1*d2*d3*d5^2 + d1^2*d4*d5^2 + d1*d2*d4*d5^2 + d1*d3*d4*d5^2 - d2*d3*d4*d5^2 - d1^4*d6 - d1^2*d2*d3*d6 - d1*d2^2*d3*d6 - d1*d2*d3^2*d6 - d1^2*d2*d4*d6 - d1*d2^2*d4*d6 - d1^2*d3*d4*d6 - 2*d1*d2*d3*d4*d6 - d1*d3^2*d4*d6 - d1*d2*d4^2*d6 - d1*d3*d4^2*d6 - d1^2*d2*d5*d6 - d1*d2^2*d5*d6 - d1^2*d3*d5*d6 - 2*d1*d2*d3*d5*d6 - d1*d3^2*d5*d6 - d1^2*d4*d5*d6 - 2*d1*d2*d4*d5*d6 - 2*d1*d3*d4*d5*d6 - d1*d4^2*d5*d6 - d1*d2*d5^2*d6 - d1*d3*d5^2*d6 - d1*d4*d5^2*d6 - d1^3*d6^2 - d1*d2*d3*d6^2 - d2^2*d3*d6^2 - d2*d3^2*d6^2 - d1*d2*d4*d6^2 - d2^2*d4*d6^2 - d1*d3*d4*d6^2 - 2*d2*d3*d4*d6^2 - d3^2*d4*d6^2 - d2*d4^2*d6^2 - d3*d4^2*d6^2 - d1*d2*d5*d6^2 - d2^2*d5*d6^2 - d1*d3*d5*d6^2 - 2*d2*d3*d5*d6^2 - d3^2*d5*d6^2 - d1*d4*d5*d6^2 - 2*d2*d4*d5*d6^2 - 2*d3*d4*d5*d6^2 - d4^2*d5*d6^2 - d2*d5^2*d6^2 - d3*d5^2*d6^2 - d4*d5^2*d6^2, 1), (2, 1)] # remainingFactors = [(d1^4*d2 + d1^3*d2^2 + d1^4*d3 + 2*d1^3*d2*d3 + d1^2*d2^2*d3 + d1^3*d3^2 + d1^2*d2*d3^2 + d1^4*d4 + 2*d1^3*d2*d4 + d1^2*d2^2*d4 + 2*d1^3*d3*d4 + 3*d1^2*d2*d3*d4 + d1*d2^2*d3*d4 + d1^2*d3^2*d4 + d1*d2*d3^2*d4 + d1^3*d4^2 + d1^2*d2*d4^2 + d1^2*d3*d4^2 + d1*d2*d3*d4^2 + d1^4*d5 + 2*d1^3*d2*d5 + d1^2*d2^2*d5 + 2*d1^3*d3*d5 + 3*d1^2*d2*d3*d5 + d1*d2^2*d3*d5 + d1^2*d3^2*d5 + d1*d2*d3^2*d5 + 2*d1^3*d4*d5 + 3*d1^2*d2*d4*d5 + d1*d2^2*d4*d5 + 3*d1^2*d3*d4*d5 + 2*d1*d2*d3*d4*d5 - d2^2*d3*d4*d5 + d1*d3^2*d4*d5 - d2*d3^2*d4*d5 + d1^2*d4^2*d5 + d1*d2*d4^2*d5 + d1*d3*d4^2*d5 - d2*d3*d4^2*d5 + d1^3*d5^2 + d1^2*d2*d5^2 + d1^2*d3*d5^2 + d1*d2*d3*d5^2 + d1^2*d4*d5^2 + d1*d2*d4*d5^2 + d1*d3*d4*d5^2 - d2*d3*d4*d5^2 - d1^4*d6 - d1^2*d2*d3*d6 - d1*d2^2*d3*d6 - d1*d2*d3^2*d6 - d1^2*d2*d4*d6 - d1*d2^2*d4*d6 - d1^2*d3*d4*d6 - 2*d1*d2*d3*d4*d6 - d1*d3^2*d4*d6 - d1*d2*d4^2*d6 - d1*d3*d4^2*d6 - d1^2*d2*d5*d6 - d1*d2^2*d5*d6 - d1^2*d3*d5*d6 - 2*d1*d2*d3*d5*d6 - d1*d3^2*d5*d6 - d1^2*d4*d5*d6 - 2*d1*d2*d4*d5*d6 - 2*d1*d3*d4*d5*d6 - d1*d4^2*d5*d6 - d1*d2*d5^2*d6 - d1*d3*d5^2*d6 - d1*d4*d5^2*d6 - d1^3*d6^2 - d1*d2*d3*d6^2 - d2^2*d3*d6^2 - d2*d3^2*d6^2 - d1*d2*d4*d6^2 - d2^2*d4*d6^2 - d1*d3*d4*d6^2 - 2*d2*d3*d4*d6^2 - d3^2*d4*d6^2 - d2*d4^2*d6^2 - d3*d4^2*d6^2 - d1*d2*d5*d6^2 - d2^2*d5*d6^2 - d1*d3*d5*d6^2 - 2*d2*d3*d5*d6^2 - d3^2*d5*d6^2 - d1*d4*d5*d6^2 - 2*d2*d4*d5*d6^2 - 2*d3*d4*d5*d6^2 - d4^2*d5*d6^2 - d2*d5^2*d6^2 - d3*d5^2*d6^2 - d4*d5^2*d6^2, 1), (2, 1)] quinticsToTest = [Qd(x[0]) for x in remainingFactors if Qd(x[0]).total_degree() == 5] # QP = {y: [x for x in quintics.keys() if quinticsToTest[y] == Qd(quintics[x])] for y in range(0,len(quinticsToTest))} # QP # {0: []} # QM = {y: [x for x in quintics.keys() if quinticsToTest[y] == Qd(-1*quintics[x])] for y in range(0,len(quinticsToTest))} # QM # {0: [X16]} QuinticsPM = [x[0] for x in QP.values() if x!=[]] + [x[0] for x in QM.values() if x!=[]] QuinticsPM # [X16] QuinticsPM = [S(X16)] ############################# # Exponents of Root factors # ############################# allRoots = groupRoots(rootFactorsWithGcd, tuple(36*[0]), positive_roots) allRoots allRoots = (6, 6, 7, 7, 8, 6, 3, 6, 6, 7, 6, 7, 7, 6, 4, 7, 7, 8, 8, 4, 7, 7, 7, 7, 6, 7, 5, 7, 4, 7, 5, 9, 6, 5, 9, 5) # sum(allRoots) + 5 # 234 # 9.divides(234) # True ################################# # Combining Quintics with Roots # ################################# finalAnswer = fromQuinticsAndRootsToYoshidasAndCrosses(allRoots, positive_roots, ffdict,QuinticsPM,cross_to_ds,quintics,YM) # finalAnswer # [[(Cross35, 1), # (Yoshida0, 7), # (Yoshida1, 7), # (Yoshida10, 1), # (Yoshida11, -1), # (Yoshida12, -1), # (Yoshida13, 4), # (Yoshida2, 1), # (Yoshida3, -1), # (Yoshida5, 1), # (Yoshida6, 6), # (Yoshida7, -1), # (Yoshida8, 1), # (Yoshida9, 1)]] MonFactors = [(Cross39, -1), (Cross40, -1), (Cross41, -1), (Cross54, -1), (Cross55, -1), (Cross56, -1), (Cross61, -1), (Cross71, -1), (Yoshida0, 1), (Yoshida1, -1), (Yoshida10, -1), (Yoshida12, 1), (Yoshida13, -1), (Yoshida14, -1), (Yoshida16, -1), (Yoshida17, 2), (Yoshida18, 1), (Yoshida19, -2), (Yoshida21, 1), (Yoshida22, -2), (Yoshida23, 1), (Yoshida26, -1), (Yoshida27, -1), (Yoshida28, -1), (Yoshida29, -1), (Yoshida30, 1), (Yoshida31, -3), (Yoshida33, -2), (Yoshida34, 2), (Yoshida35, -3), (Yoshida37, 1), (Yoshida39, -4), (Yoshida4, -1), (Yoshida5, -2), (Yoshida6, -3), (Yoshida8, -1), (Yoshida9, -1)] allFactorsv1 = finalAnswer[0] + MonFactors + [remainingFactors[-1]] setAllFactors = set([x[0] for x in allFactorsv1]) allExp = dict() for y in setAllFactors: allExp[y] = sum([x[1] for x in allFactorsv1 if x[0] == y]) trueFinalAnswers = [(y,allExp[y]) for y in setAllFactors] # print trueFinalAnswers # [(Yoshida6, 3), (2, 1), (Yoshida34, 2), (Yoshida33, -2), (Cross71, -1), (Yoshida19, -2), (Yoshida8, 0), (Yoshida7, -1), (Cross40, -1), (Cross39, -1), (Yoshida30, 1), (Yoshida13, 3), (Yoshida12, 0), (Yoshida2, 1), (Yoshida1, 6), (Yoshida28, -1), (Yoshida26, -1), (Yoshida37, 1), (Yoshida31, -3), (Yoshida3, -1), (Yoshida9, 0), (Yoshida27, -1), (Yoshida16, -1), (Cross55, -1), (Yoshida5, -1), (Yoshida35, -3), (Yoshida14, -1), (Cross61, -1), (Yoshida21, 1), (Yoshida10, 0), (Yoshida22, -2), (Yoshida23, 1), (Cross56, -1), (Yoshida4, -1), (Cross41, -1), (Cross35, 1), (Yoshida39, -4), (Yoshida29, -1), (Cross54, -1), (Yoshida11, -1), (Yoshida18, 1), (Yoshida17, 2), (Yoshida0, 8)] ################### # Constant Factor # ################### constantFactor = [y for y in trueFinalAnswers if y[0] in QQ] constantFactor [(2, 1)] ################# # Cross factors # ################# crossFactors = [y for y in trueFinalAnswers if y[0] in cross_variables] [(Cross71, -1), (Cross40, -1), (Cross39, -1), (Cross55, -1), (Cross61, -1), (Cross56, -1), (Cross41, -1), (Cross35, 1), (Cross54, -1)] ############################# # Rewriting Yoshida factors # ############################# YoshidaFactors = [y for y in trueFinalAnswers if y[0] in Yoshidas] f = prod([y[0]^y[1] for y in YoshidaFactors]) fn = f.numerator() fd = f.denominator() newExpressionn = computingFixedExpressionsInYs(fn,Qd,YM) newExpressiond = computingFixedExpressionsInYs(fd,Qd,YM) SR(newExpressionn/newExpressiond).factor_list() [(Yoshida0, 1), (Yoshida10, -1), (Yoshida11, 1), (Yoshida12, -1), (Yoshida13, -2), (Yoshida15, 2), (Yoshida17, -1), (Yoshida3, -2), (Yoshida4, -1), (Yoshida5, 4), (Yoshida7, 2), (Yoshida9, 1)] newExpressionn/newExpressiond Yoshida0*Yoshida11*Yoshida15^2*Yoshida5^4*Yoshida7^2*Yoshida9/(Yoshida10*Yoshida12*Yoshida13^2*Yoshida17*Yoshida3^2*Yoshida4) ################################# # COMPUTATION OF TROPICAL RANKS # ################################# # We create the dictionary of Yoshidas with all values equal to 0 to replace on the 5x45 matrices. dict0Yos = {Yoshidas[k]:0 for k in range(0,len(Yoshidas))} # We load the shifted five boundary points and the shifting points computed in 'TrivialValuation/Scripts/ComputeExtraTreesForApexCone.sage' shiftPtExtremal = load('Input/shiftPtExtremal.sobj') newTropLinkExtremal = load('Input/newTropLinkExtremal.sobj') # We recover the unshifted five boundary points of each extra tropical curve by adding the values of the five shifted point and the shifts (declaring '+Infinity' - Crossi = '+Infinity). unshiftedTropLInkExtremal = dict() for extremal in extremalCurves: print extremal newValue = [] for k in range(0,len(newTropLinkExtremal[extremal])): newrow = dict() for key in newTropLinkExtremal[extremal][0].keys(): print str(key) if newTropLinkExtremal[extremal][k][key] !=+Infinity: newrow[key] = newTropLinkExtremal[extremal][k][key] + shiftPtExtremal[extremal][key] else: newrow[key] = newTropLinkExtremal[extremal][k][key] newValue.append(newrow) unshiftedTropLInkExtremal[extremal] = newValue ################################################################################### # Building pairs of 10 relevant Cross functions arising from pairs of extra lines # ################################################################################### # We start by recording the dictionary of 5 Cross functions associated to each extremal curve. allCrossesApexPerExtremal = load('../../TropicalConvexHulls/Scripts/Input/allCrossesApexPerExtremal.sobj') # We consider the pairs of indices, one of which is E1 and add the list of 5 relevant Cross functions. We create the dictionary where we replace all the values by the Cross with smallest index within this list. CrossE1 = sorted(allCrossesApexPerExtremal[E1], reverse=True) PairsOfExtremalsWithE1AndCrossDict = dict() for extremal in extremalCurves[1:]: newCross = sorted(allCrossesApexPerExtremal[extremal], reverse=True) allCrosses = sorted(list(set(newCross+CrossE1)), reverse=True) if len(allCrosses) == 9: PairsOfExtremalsWithE1AndCrossDict[extremal] = {cross: allCrosses[0] for cross in allCrosses} else: PairsOfExtremalsWithE1AndCrossDict[extremal] = dict() for cross in CrossE1: PairsOfExtremalsWithE1AndCrossDict[extremal][cross] = CrossE1[0] for cross in newCross: PairsOfExtremalsWithE1AndCrossDict[extremal][cross] = newCross[0] # We record the output: # print PairsOfExtremalsWithE1AndCrossDict # {F23: {Cross6: Cross6, Cross33: Cross9, Cross111: Cross9, Cross9: Cross9, Cross84: Cross6, Cross78: Cross9, Cross42: Cross9, Cross129: Cross6, Cross105: Cross6, Cross30: Cross6}, F36: {Cross120: Cross37, Cross33: Cross9, Cross41: Cross37, Cross42: Cross9, Cross111: Cross9, Cross9: Cross9, Cross97: Cross37, Cross78: Cross9, Cross37: Cross37, Cross99: Cross37}, F12: {Cross114: Cross9, Cross33: Cross9, Cross9: Cross9, Cross111: Cross9, Cross97: Cross9, Cross78: Cross9, Cross42: Cross9, Cross57: Cross9, Cross81: Cross9}, G4: {Cross21: Cross9, Cross33: Cross9, Cross123: Cross9, Cross102: Cross9, Cross9: Cross9, Cross111: Cross9, Cross78: Cross9, Cross42: Cross9, Cross76: Cross9}, F25: {Cross120: Cross69, Cross132: Cross69, Cross33: Cross9, Cross69: Cross69, Cross111: Cross9, Cross9: Cross9, Cross78: Cross9, Cross42: Cross9, Cross87: Cross69, Cross93: Cross69}, E3: {Cross33: Cross9, Cross90: Cross0, Cross0: Cross0, Cross102: Cross0, Cross111: Cross9, Cross9: Cross9, Cross84: Cross0, Cross78: Cross9, Cross42: Cross9, Cross99: Cross0}, G2: {Cross33: Cross9, Cross9: Cross9, Cross110: Cross9, Cross111: Cross9, Cross84: Cross9, Cross78: Cross9, Cross126: Cross9, Cross42: Cross9, Cross87: Cross9}, F13: {Cross132: Cross0, Cross33: Cross0, Cross0: Cross0, Cross117: Cross0, Cross48: Cross0, Cross9: Cross0, Cross111: Cross0, Cross78: Cross0, Cross42: Cross0}, F45: {Cross6: Cross3, Cross33: Cross9, Cross117: Cross3, Cross3: Cross3, Cross111: Cross9, Cross9: Cross9, Cross97: Cross3, Cross78: Cross9, Cross42: Cross9, Cross76: Cross3}, E4: {Cross33: Cross9, Cross28: Cross3, Cross3: Cross3, Cross111: Cross9, Cross9: Cross9, Cross78: Cross9, Cross126: Cross3, Cross18: Cross3, Cross42: Cross9, Cross73: Cross3}, G3: {Cross33: Cross9, Cross28: Cross9, Cross37: Cross9, Cross9: Cross9, Cross111: Cross9, Cross78: Cross9, Cross42: Cross9, Cross105: Cross9, Cross15: Cross9}, F24: {Cross21: Cross21, Cross33: Cross9, Cross41: Cross21, Cross48: Cross21, Cross111: Cross9, Cross9: Cross9, Cross78: Cross9, Cross126: Cross21, Cross42: Cross9, Cross60: Cross21}, E2: {Cross21: Cross21, Cross114: Cross21, Cross33: Cross9, Cross111: Cross9, Cross9: Cross9, Cross78: Cross9, Cross63: Cross21, Cross42: Cross9, Cross105: Cross21, Cross93: Cross21}, F46: {Cross132: Cross30, Cross33: Cross9, Cross123: Cross30, Cross111: Cross9, Cross9: Cross9, Cross78: Cross9, Cross81: Cross30, Cross42: Cross9, Cross73: Cross30, Cross30: Cross30}, G6: {Cross33: Cross9, Cross66: Cross9, Cross9: Cross9, Cross73: Cross9, Cross78: Cross9, Cross63: Cross9, Cross42: Cross9, Cross111: Cross9, Cross99: Cross9}, G5: {Cross33: Cross3, Cross90: Cross3, Cross3: Cross3, Cross9: Cross3, Cross42: Cross3, Cross111: Cross3, Cross78: Cross3, Cross51: Cross3, Cross93: Cross3}, F14: {Cross120: Cross9, Cross33: Cross9, Cross12: Cross9, Cross9: Cross9, Cross111: Cross9, Cross78: Cross9, Cross18: Cross9, Cross42: Cross9, Cross129: Cross9}, F26: {Cross33: Cross9, Cross54: Cross12, Cross12: Cross12, Cross117: Cross12, Cross111: Cross9, Cross110: Cross12, Cross9: Cross9, Cross78: Cross9, Cross63: Cross12, Cross42: Cross9}, F35: {Cross33: Cross9, Cross90: Cross12, Cross12: Cross12, Cross111: Cross9, Cross9: Cross9, Cross78: Cross9, Cross42: Cross9, Cross60: Cross12, Cross81: Cross12, Cross15: Cross12}, F34: {Cross33: Cross9, Cross54: Cross28, Cross28: Cross28, Cross102: Cross28, Cross111: Cross9, Cross9: Cross9, Cross78: Cross9, Cross42: Cross9, Cross69: Cross28, Cross57: Cross28}, E6: {Cross33: Cross9, Cross123: Cross37, Cross42: Cross9, Cross111: Cross9, Cross110: Cross37, Cross9: Cross9, Cross78: Cross9, Cross37: Cross37, Cross51: Cross37, Cross45: Cross37}, E5: {Cross33: Cross9, Cross66: Cross15, Cross24: Cross15, Cross111: Cross9, Cross9: Cross9, Cross78: Cross9, Cross42: Cross9, Cross87: Cross15, Cross76: Cross15, Cross15: Cross15}, G1: {Cross114: Cross0, Cross33: Cross9, Cross0: Cross0, Cross24: Cross0, Cross111: Cross9, Cross9: Cross9, Cross78: Cross9, Cross18: Cross0, Cross42: Cross9, Cross45: Cross0}, F56: {Cross33: Cross9, Cross48: Cross48, Cross51: Cross48, Cross111: Cross9, Cross9: Cross9, Cross66: Cross48, Cross78: Cross9, Cross42: Cross9, Cross129: Cross48, Cross57: Cross48}, F16: {Cross6: Cross6, Cross33: Cross6, Cross69: Cross6, Cross9: Cross6, Cross111: Cross6, Cross78: Cross6, Cross42: Cross6, Cross60: Cross6, Cross45: Cross6}, F15: {Cross33: Cross9, Cross54: Cross9, Cross24: Cross9, Cross9: Cross9, Cross111: Cross9, Cross41: Cross9, Cross42: Cross9, Cross78: Cross9, Cross30: Cross9}} # # We record the length of relevant Cross functions coming from the pairs of indexing extremal curves (one of which is E1). # print [len(PairsOfExtremalsWithE1AndCrossDict[extremal].values()) for extremal in extremalCurves[1:]] # [10, 10, 10, 10, 10, 9, 9, 9, 9, 9, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 9, 9, 9, 9, 9] ################################################################# # Building 10 boundary points pairs of extra lines including E1 # ################################################################# # We take the dictionaries of Cross functions 'PairsOfExtremalsWithE1AndCrossDict' computed above to write down the 10x45 matrices of boundary points. # tenBoundaryPoints = dict() # for extremal in PairsOfExtremalsWithE1AndCrossDict.keys(): # print extremal # allLeaves = [] # for k in range(0,len(unshiftedTropLInkExtremal[E1])): # print k # newRow = dict() # for key in unshiftedTropLInkExtremal[E1][0]: # print key # if unshiftedTropLInkExtremal[E1][k][key] != +Infinity: # newRow[key] = SR(unshiftedTropLInkExtremal[E1][k][key]).substitute(PairsOfExtremalsWithE1AndCrossDict[extremal]) # else: # newRow[key] = +Infinity # allLeaves.append(newRow) # for k in range(0,len(unshiftedTropLInkExtremal[extremal])): # print k # newRow = dict() # for key in unshiftedTropLInkExtremal[extremal][0]: # print key # if unshiftedTropLInkExtremal[extremal][k][key] != +Infinity: # newRow[key] = SR(unshiftedTropLInkExtremal[extremal][k][key]).substitute(PairsOfExtremalsWithE1AndCrossDict[extremal]) # else: # newRow[key] = +Infinity # allLeaves.append(newRow) # tenBoundaryPoints[extremal] = allLeaves # # We save the output: # save(tenBoundaryPoints, 'Input/tenBoundaryPoints.sobj') # We load the data: tenBoundaryPoints = load('Input/tenBoundaryPoints.sobj') # We record the matrices (column by column): # for extremal in extremalCurves[1:]: # print extremal # for a in keys: # print a # print [tenBoundaryPoints[extremal][k][a] for k in range(0,10)] # print '' # E2 # X12 # [0, 0, +Infinity, 0, 0, -Cross9, -Cross9, +Infinity, -Cross9, -Cross9] # X13 # [0, +Infinity, 0, 0, 0, -Cross9, +Infinity, -Cross9, -Cross9, -Cross9] # X14 # [+Infinity, 0, 0, 0, 0, +Infinity, -Cross9, -Cross9, -Cross9, -Cross9] # X15 # [0, 0, 0, 0, +Infinity, -Cross9, -Cross9, -Cross9, -Cross9, +Infinity] # X16 # [0, 0, 0, +Infinity, 0, -Cross9, -Cross9, -Cross9, +Infinity, -Cross9] # X21 # [-Cross21, -Cross21, +Infinity, -Cross21, -Cross21, 0, 0, +Infinity, 0, 0] # X23 # [-Cross21, +Infinity, -Cross21, -Cross21, -Cross21, 0, +Infinity, 0, 0, 0] # X24 # [+Infinity, -Cross21, -Cross21, -Cross21, -Cross21, +Infinity, 0, 0, 0, 0] # X25 # [-Cross21, -Cross21, -Cross21, -Cross21, +Infinity, 0, 0, 0, 0, +Infinity] # X26 # [-Cross21, -Cross21, -Cross21, +Infinity, -Cross21, 0, 0, 0, +Infinity, 0] # X31 # [-Cross0, +Infinity, -Cross0, -Cross0, -Cross0, -Cross0, -Cross0, +Infinity, -Cross0, -Cross0] # X32 # [-Cross84, -Cross84, +Infinity, -Cross84, -Cross84, -Cross84, +Infinity, -Cross84, -Cross84, -Cross84] # X34 # [+Infinity, -Cross102, -Cross102, -Cross102, -Cross102, +Infinity, -Cross102, -Cross102, -Cross102, -Cross102] # X35 # [-Cross90, -Cross90, -Cross90, -Cross90, +Infinity, -Cross90, -Cross90, -Cross90, -Cross90, +Infinity] # X36 # [-Cross99, -Cross99, -Cross99, +Infinity, -Cross99, -Cross99, -Cross99, -Cross99, +Infinity, -Cross99] # X41 # [+Infinity, -Cross18, -Cross18, -Cross18, -Cross18, -Cross18, -Cross18, +Infinity, -Cross18, -Cross18] # X42 # [-Cross126, -Cross126, +Infinity, -Cross126, -Cross126, +Infinity, -Cross126, -Cross126, -Cross126, -Cross126] # X43 # [-Cross28, +Infinity, -Cross28, -Cross28, -Cross28, -Cross28, +Infinity, -Cross28, -Cross28, -Cross28] # X45 # [-Cross3, -Cross3, -Cross3, -Cross3, +Infinity, -Cross3, -Cross3, -Cross3, -Cross3, +Infinity] # X46 # [-Cross73, -Cross73, -Cross73, +Infinity, -Cross73, -Cross73, -Cross73, -Cross73, +Infinity, -Cross73] # X51 # [-Cross24, -Cross24, -Cross24, -Cross24, +Infinity, -Cross24, -Cross24, +Infinity, -Cross24, -Cross24] # X52 # [-Cross87, -Cross87, +Infinity, -Cross87, -Cross87, -Cross87, -Cross87, -Cross87, -Cross87, +Infinity] # X53 # [-Cross15, +Infinity, -Cross15, -Cross15, -Cross15, -Cross15, +Infinity, -Cross15, -Cross15, -Cross15] # X54 # [+Infinity, -Cross76, -Cross76, -Cross76, -Cross76, +Infinity, -Cross76, -Cross76, -Cross76, -Cross76] # X56 # [-Cross66, -Cross66, -Cross66, +Infinity, -Cross66, -Cross66, -Cross66, -Cross66, +Infinity, -Cross66] # X61 # [-Cross45, -Cross45, -Cross45, +Infinity, -Cross45, -Cross45, -Cross45, +Infinity, -Cross45, -Cross45] # X62 # [-Cross110, -Cross110, +Infinity, -Cross110, -Cross110, -Cross110, -Cross110, -Cross110, +Infinity, -Cross110] # X63 # [-Cross37, +Infinity, -Cross37, -Cross37, -Cross37, -Cross37, +Infinity, -Cross37, -Cross37, -Cross37] # X64 # [+Infinity, -Cross123, -Cross123, -Cross123, -Cross123, +Infinity, -Cross123, -Cross123, -Cross123, -Cross123] # X65 # [-Cross51, -Cross51, -Cross51, -Cross51, +Infinity, -Cross51, -Cross51, -Cross51, -Cross51, +Infinity] # Y123456 # [-Cross57, -Cross57, +Infinity, -Cross57, -Cross57, -Cross57, -Cross57, +Infinity, -Cross57, -Cross57] # Y123546 # [-Cross81, -Cross81, +Infinity, -Cross81, -Cross81, -Cross81, -Cross81, +Infinity, -Cross81, -Cross81] # Y123645 # [-Cross97, -Cross97, +Infinity, -Cross97, -Cross97, -Cross97, -Cross97, +Infinity, -Cross97, -Cross97] # Y132456 # [-Cross48, +Infinity, -Cross48, -Cross48, -Cross48, +Infinity, -Cross48, -Cross48, -Cross48, -Cross48] # Y132546 # [-Cross132, +Infinity, -Cross132, -Cross132, -Cross132, -Cross132, -Cross132, -Cross132, -Cross132, +Infinity] # Y132645 # [-Cross117, +Infinity, -Cross117, -Cross117, -Cross117, -Cross117, -Cross117, -Cross117, +Infinity, -Cross117] # Y142356 # [+Infinity, -Cross129, -Cross129, -Cross129, -Cross129, -Cross129, +Infinity, -Cross129, -Cross129, -Cross129] # Y142536 # [+Infinity, -Cross120, -Cross120, -Cross120, -Cross120, -Cross120, -Cross120, -Cross120, -Cross120, +Infinity] # Y142635 # [+Infinity, -Cross12, -Cross12, -Cross12, -Cross12, -Cross12, -Cross12, -Cross12, +Infinity, -Cross12] # Y152346 # [-Cross30, -Cross30, -Cross30, -Cross30, +Infinity, -Cross30, +Infinity, -Cross30, -Cross30, -Cross30] # Y152436 # [-Cross41, -Cross41, -Cross41, -Cross41, +Infinity, +Infinity, -Cross41, -Cross41, -Cross41, -Cross41] # Y152634 # [-Cross54, -Cross54, -Cross54, -Cross54, +Infinity, -Cross54, -Cross54, -Cross54, +Infinity, -Cross54] # Y162345 # [-Cross6, -Cross6, -Cross6, +Infinity, -Cross6, -Cross6, +Infinity, -Cross6, -Cross6, -Cross6] # Y162435 # [-Cross60, -Cross60, -Cross60, +Infinity, -Cross60, +Infinity, -Cross60, -Cross60, -Cross60, -Cross60] # Y162534 # [-Cross69, -Cross69, -Cross69, +Infinity, -Cross69, -Cross69, -Cross69, -Cross69, -Cross69, +Infinity] # E3 # X12 # [0, 0, +Infinity, 0, 0, -Cross9, -Cross9, -Cross9, -Cross9, +Infinity] # X13 # [0, +Infinity, 0, 0, 0, -Cross9, -Cross9, -Cross9, +Infinity, -Cross9] # X14 # [+Infinity, 0, 0, 0, 0, -Cross9, +Infinity, -Cross9, -Cross9, -Cross9] # X15 # [0, 0, 0, 0, +Infinity, -Cross9, -Cross9, +Infinity, -Cross9, -Cross9] # X16 # [0, 0, 0, +Infinity, 0, +Infinity, -Cross9, -Cross9, -Cross9, -Cross9] # X21 # [-Cross114, -Cross114, +Infinity, -Cross114, -Cross114, -Cross114, -Cross114, -Cross114, +Infinity, -Cross114] # X23 # [-Cross105, +Infinity, -Cross105, -Cross105, -Cross105, -Cross105, -Cross105, -Cross105, -Cross105, +Infinity] # X24 # [+Infinity, -Cross21, -Cross21, -Cross21, -Cross21, -Cross21, +Infinity, -Cross21, -Cross21, -Cross21] # X25 # [-Cross93, -Cross93, -Cross93, -Cross93, +Infinity, -Cross93, -Cross93, +Infinity, -Cross93, -Cross93] # X26 # [-Cross63, -Cross63, -Cross63, +Infinity, -Cross63, +Infinity, -Cross63, -Cross63, -Cross63, -Cross63] # X31 # [-Cross0, +Infinity, -Cross0, -Cross0, -Cross0, 0, 0, 0, +Infinity, 0] # X32 # [-Cross0, -Cross0, +Infinity, -Cross0, -Cross0, 0, 0, 0, 0, +Infinity] # X34 # [+Infinity, -Cross0, -Cross0, -Cross0, -Cross0, 0, +Infinity, 0, 0, 0] # X35 # [-Cross0, -Cross0, -Cross0, -Cross0, +Infinity, 0, 0, +Infinity, 0, 0] # X36 # [-Cross0, -Cross0, -Cross0, +Infinity, -Cross0, +Infinity, 0, 0, 0, 0] # X41 # [+Infinity, -Cross18, -Cross18, -Cross18, -Cross18, -Cross18, -Cross18, -Cross18, +Infinity, -Cross18] # X42 # [-Cross126, -Cross126, +Infinity, -Cross126, -Cross126, -Cross126, -Cross126, -Cross126, -Cross126, +Infinity] # X43 # [-Cross28, +Infinity, -Cross28, -Cross28, -Cross28, -Cross28, +Infinity, -Cross28, -Cross28, -Cross28] # X45 # [-Cross3, -Cross3, -Cross3, -Cross3, +Infinity, -Cross3, -Cross3, +Infinity, -Cross3, -Cross3] # X46 # [-Cross73, -Cross73, -Cross73, +Infinity, -Cross73, +Infinity, -Cross73, -Cross73, -Cross73, -Cross73] # X51 # [-Cross24, -Cross24, -Cross24, -Cross24, +Infinity, -Cross24, -Cross24, -Cross24, +Infinity, -Cross24] # X52 # [-Cross87, -Cross87, +Infinity, -Cross87, -Cross87, -Cross87, -Cross87, -Cross87, -Cross87, +Infinity] # X53 # [-Cross15, +Infinity, -Cross15, -Cross15, -Cross15, -Cross15, -Cross15, +Infinity, -Cross15, -Cross15] # X54 # [+Infinity, -Cross76, -Cross76, -Cross76, -Cross76, -Cross76, +Infinity, -Cross76, -Cross76, -Cross76] # X56 # [-Cross66, -Cross66, -Cross66, +Infinity, -Cross66, +Infinity, -Cross66, -Cross66, -Cross66, -Cross66] # X61 # [-Cross45, -Cross45, -Cross45, +Infinity, -Cross45, -Cross45, -Cross45, -Cross45, +Infinity, -Cross45] # X62 # [-Cross110, -Cross110, +Infinity, -Cross110, -Cross110, -Cross110, -Cross110, -Cross110, -Cross110, +Infinity] # X63 # [-Cross37, +Infinity, -Cross37, -Cross37, -Cross37, +Infinity, -Cross37, -Cross37, -Cross37, -Cross37] # X64 # [+Infinity, -Cross123, -Cross123, -Cross123, -Cross123, -Cross123, +Infinity, -Cross123, -Cross123, -Cross123] # X65 # [-Cross51, -Cross51, -Cross51, -Cross51, +Infinity, -Cross51, -Cross51, +Infinity, -Cross51, -Cross51] # Y123456 # [-Cross57, -Cross57, +Infinity, -Cross57, -Cross57, -Cross57, +Infinity, -Cross57, -Cross57, -Cross57] # Y123546 # [-Cross81, -Cross81, +Infinity, -Cross81, -Cross81, -Cross81, -Cross81, +Infinity, -Cross81, -Cross81] # Y123645 # [-Cross97, -Cross97, +Infinity, -Cross97, -Cross97, +Infinity, -Cross97, -Cross97, -Cross97, -Cross97] # Y132456 # [-Cross48, +Infinity, -Cross48, -Cross48, -Cross48, -Cross48, -Cross48, -Cross48, +Infinity, -Cross48] # Y132546 # [-Cross132, +Infinity, -Cross132, -Cross132, -Cross132, -Cross132, -Cross132, -Cross132, +Infinity, -Cross132] # Y132645 # [-Cross117, +Infinity, -Cross117, -Cross117, -Cross117, -Cross117, -Cross117, -Cross117, +Infinity, -Cross117] # Y142356 # [+Infinity, -Cross129, -Cross129, -Cross129, -Cross129, -Cross129, -Cross129, -Cross129, -Cross129, +Infinity] # Y142536 # [+Infinity, -Cross120, -Cross120, -Cross120, -Cross120, +Infinity, -Cross120, -Cross120, -Cross120, -Cross120] # Y142635 # [+Infinity, -Cross12, -Cross12, -Cross12, -Cross12, -Cross12, -Cross12, +Infinity, -Cross12, -Cross12] # Y152346 # [-Cross30, -Cross30, -Cross30, -Cross30, +Infinity, -Cross30, -Cross30, -Cross30, -Cross30, +Infinity] # Y152436 # [-Cross41, -Cross41, -Cross41, -Cross41, +Infinity, +Infinity, -Cross41, -Cross41, -Cross41, -Cross41] # Y152634 # [-Cross54, -Cross54, -Cross54, -Cross54, +Infinity, -Cross54, +Infinity, -Cross54, -Cross54, -Cross54] # Y162345 # [-Cross6, -Cross6, -Cross6, +Infinity, -Cross6, -Cross6, -Cross6, -Cross6, -Cross6, +Infinity] # Y162435 # [-Cross60, -Cross60, -Cross60, +Infinity, -Cross60, -Cross60, -Cross60, +Infinity, -Cross60, -Cross60] # Y162534 # [-Cross69, -Cross69, -Cross69, +Infinity, -Cross69, -Cross69, +Infinity, -Cross69, -Cross69, -Cross69] # E4 # X12 # [0, 0, +Infinity, 0, 0, -Cross9, +Infinity, -Cross9, -Cross9, -Cross9] # X13 # [0, +Infinity, 0, 0, 0, +Infinity, -Cross9, -Cross9, -Cross9, -Cross9] # X14 # [+Infinity, 0, 0, 0, 0, -Cross9, -Cross9, -Cross9, -Cross9, +Infinity] # X15 # [0, 0, 0, 0, +Infinity, -Cross9, -Cross9, -Cross9, +Infinity, -Cross9] # X16 # [0, 0, 0, +Infinity, 0, -Cross9, -Cross9, +Infinity, -Cross9, -Cross9] # X21 # [-Cross114, -Cross114, +Infinity, -Cross114, -Cross114, -Cross114, -Cross114, -Cross114, -Cross114, +Infinity] # X23 # [-Cross105, +Infinity, -Cross105, -Cross105, -Cross105, +Infinity, -Cross105, -Cross105, -Cross105, -Cross105] # X24 # [+Infinity, -Cross21, -Cross21, -Cross21, -Cross21, -Cross21, +Infinity, -Cross21, -Cross21, -Cross21] # X25 # [-Cross93, -Cross93, -Cross93, -Cross93, +Infinity, -Cross93, -Cross93, -Cross93, +Infinity, -Cross93] # X26 # [-Cross63, -Cross63, -Cross63, +Infinity, -Cross63, -Cross63, -Cross63, +Infinity, -Cross63, -Cross63] # X31 # [-Cross0, +Infinity, -Cross0, -Cross0, -Cross0, -Cross0, -Cross0, -Cross0, -Cross0, +Infinity] # X32 # [-Cross84, -Cross84, +Infinity, -Cross84, -Cross84, -Cross84, +Infinity, -Cross84, -Cross84, -Cross84] # X34 # [+Infinity, -Cross102, -Cross102, -Cross102, -Cross102, +Infinity, -Cross102, -Cross102, -Cross102, -Cross102] # X35 # [-Cross90, -Cross90, -Cross90, -Cross90, +Infinity, -Cross90, -Cross90, -Cross90, +Infinity, -Cross90] # X36 # [-Cross99, -Cross99, -Cross99, +Infinity, -Cross99, -Cross99, -Cross99, +Infinity, -Cross99, -Cross99] # X41 # [+Infinity, -Cross3, -Cross3, -Cross3, -Cross3, 0, 0, 0, 0, +Infinity] # X42 # [-Cross3, -Cross3, +Infinity, -Cross3, -Cross3, 0, +Infinity, 0, 0, 0] # X43 # [-Cross3, +Infinity, -Cross3, -Cross3, -Cross3, +Infinity, 0, 0, 0, 0] # X45 # [-Cross3, -Cross3, -Cross3, -Cross3, +Infinity, 0, 0, 0, +Infinity, 0] # X46 # [-Cross3, -Cross3, -Cross3, +Infinity, -Cross3, 0, 0, +Infinity, 0, 0] # X51 # [-Cross24, -Cross24, -Cross24, -Cross24, +Infinity, -Cross24, -Cross24, -Cross24, -Cross24, +Infinity] # X52 # [-Cross87, -Cross87, +Infinity, -Cross87, -Cross87, -Cross87, +Infinity, -Cross87, -Cross87, -Cross87] # X53 # [-Cross15, +Infinity, -Cross15, -Cross15, -Cross15, +Infinity, -Cross15, -Cross15, -Cross15, -Cross15] # X54 # [+Infinity, -Cross76, -Cross76, -Cross76, -Cross76, -Cross76, -Cross76, -Cross76, +Infinity, -Cross76] # X56 # [-Cross66, -Cross66, -Cross66, +Infinity, -Cross66, -Cross66, -Cross66, +Infinity, -Cross66, -Cross66] # X61 # [-Cross45, -Cross45, -Cross45, +Infinity, -Cross45, -Cross45, -Cross45, -Cross45, -Cross45, +Infinity] # X62 # [-Cross110, -Cross110, +Infinity, -Cross110, -Cross110, -Cross110, +Infinity, -Cross110, -Cross110, -Cross110] # X63 # [-Cross37, +Infinity, -Cross37, -Cross37, -Cross37, +Infinity, -Cross37, -Cross37, -Cross37, -Cross37] # X64 # [+Infinity, -Cross123, -Cross123, -Cross123, -Cross123, -Cross123, -Cross123, +Infinity, -Cross123, -Cross123] # X65 # [-Cross51, -Cross51, -Cross51, -Cross51, +Infinity, -Cross51, -Cross51, -Cross51, +Infinity, -Cross51] # Y123456 # [-Cross57, -Cross57, +Infinity, -Cross57, -Cross57, +Infinity, -Cross57, -Cross57, -Cross57, -Cross57] # Y123546 # [-Cross81, -Cross81, +Infinity, -Cross81, -Cross81, -Cross81, -Cross81, +Infinity, -Cross81, -Cross81] # Y123645 # [-Cross97, -Cross97, +Infinity, -Cross97, -Cross97, -Cross97, -Cross97, -Cross97, +Infinity, -Cross97] # Y132456 # [-Cross48, +Infinity, -Cross48, -Cross48, -Cross48, -Cross48, +Infinity, -Cross48, -Cross48, -Cross48] # Y132546 # [-Cross132, +Infinity, -Cross132, -Cross132, -Cross132, -Cross132, -Cross132, +Infinity, -Cross132, -Cross132] # Y132645 # [-Cross117, +Infinity, -Cross117, -Cross117, -Cross117, -Cross117, -Cross117, -Cross117, +Infinity, -Cross117] # Y142356 # [+Infinity, -Cross129, -Cross129, -Cross129, -Cross129, -Cross129, -Cross129, -Cross129, -Cross129, +Infinity] # Y142536 # [+Infinity, -Cross120, -Cross120, -Cross120, -Cross120, -Cross120, -Cross120, -Cross120, -Cross120, +Infinity] # Y142635 # [+Infinity, -Cross12, -Cross12, -Cross12, -Cross12, -Cross12, -Cross12, -Cross12, -Cross12, +Infinity] # Y152346 # [-Cross30, -Cross30, -Cross30, -Cross30, +Infinity, -Cross30, -Cross30, +Infinity, -Cross30, -Cross30] # Y152436 # [-Cross41, -Cross41, -Cross41, -Cross41, +Infinity, -Cross41, +Infinity, -Cross41, -Cross41, -Cross41] # Y152634 # [-Cross54, -Cross54, -Cross54, -Cross54, +Infinity, +Infinity, -Cross54, -Cross54, -Cross54, -Cross54] # Y162345 # [-Cross6, -Cross6, -Cross6, +Infinity, -Cross6, -Cross6, -Cross6, -Cross6, +Infinity, -Cross6] # Y162435 # [-Cross60, -Cross60, -Cross60, +Infinity, -Cross60, -Cross60, +Infinity, -Cross60, -Cross60, -Cross60] # Y162534 # [-Cross69, -Cross69, -Cross69, +Infinity, -Cross69, +Infinity, -Cross69, -Cross69, -Cross69, -Cross69] # E5 # X12 # [0, 0, +Infinity, 0, 0, -Cross9, -Cross9, -Cross9, -Cross9, +Infinity] # X13 # [0, +Infinity, 0, 0, 0, -Cross9, -Cross9, +Infinity, -Cross9, -Cross9] # X14 # [+Infinity, 0, 0, 0, 0, -Cross9, +Infinity, -Cross9, -Cross9, -Cross9] # X15 # [0, 0, 0, 0, +Infinity, -Cross9, -Cross9, -Cross9, +Infinity, -Cross9] # X16 # [0, 0, 0, +Infinity, 0, +Infinity, -Cross9, -Cross9, -Cross9, -Cross9] # X21 # [-Cross114, -Cross114, +Infinity, -Cross114, -Cross114, -Cross114, -Cross114, -Cross114, +Infinity, -Cross114] # X23 # [-Cross105, +Infinity, -Cross105, -Cross105, -Cross105, -Cross105, -Cross105, +Infinity, -Cross105, -Cross105] # X24 # [+Infinity, -Cross21, -Cross21, -Cross21, -Cross21, -Cross21, +Infinity, -Cross21, -Cross21, -Cross21] # X25 # [-Cross93, -Cross93, -Cross93, -Cross93, +Infinity, -Cross93, -Cross93, -Cross93, -Cross93, +Infinity] # X26 # [-Cross63, -Cross63, -Cross63, +Infinity, -Cross63, +Infinity, -Cross63, -Cross63, -Cross63, -Cross63] # X31 # [-Cross0, +Infinity, -Cross0, -Cross0, -Cross0, -Cross0, -Cross0, -Cross0, +Infinity, -Cross0] # X32 # [-Cross84, -Cross84, +Infinity, -Cross84, -Cross84, -Cross84, -Cross84, -Cross84, -Cross84, +Infinity] # X34 # [+Infinity, -Cross102, -Cross102, -Cross102, -Cross102, -Cross102, +Infinity, -Cross102, -Cross102, -Cross102] # X35 # [-Cross90, -Cross90, -Cross90, -Cross90, +Infinity, -Cross90, -Cross90, +Infinity, -Cross90, -Cross90] # X36 # [-Cross99, -Cross99, -Cross99, +Infinity, -Cross99, +Infinity, -Cross99, -Cross99, -Cross99, -Cross99] # X41 # [+Infinity, -Cross18, -Cross18, -Cross18, -Cross18, -Cross18, -Cross18, -Cross18, +Infinity, -Cross18] # X42 # [-Cross126, -Cross126, +Infinity, -Cross126, -Cross126, -Cross126, -Cross126, -Cross126, -Cross126, +Infinity] # X43 # [-Cross28, +Infinity, -Cross28, -Cross28, -Cross28, -Cross28, -Cross28, +Infinity, -Cross28, -Cross28] # X45 # [-Cross3, -Cross3, -Cross3, -Cross3, +Infinity, -Cross3, +Infinity, -Cross3, -Cross3, -Cross3] # X46 # [-Cross73, -Cross73, -Cross73, +Infinity, -Cross73, +Infinity, -Cross73, -Cross73, -Cross73, -Cross73] # X51 # [-Cross15, -Cross15, -Cross15, -Cross15, +Infinity, 0, 0, 0, +Infinity, 0] # X52 # [-Cross15, -Cross15, +Infinity, -Cross15, -Cross15, 0, 0, 0, 0, +Infinity] # X53 # [-Cross15, +Infinity, -Cross15, -Cross15, -Cross15, 0, 0, +Infinity, 0, 0] # X54 # [+Infinity, -Cross15, -Cross15, -Cross15, -Cross15, 0, +Infinity, 0, 0, 0] # X56 # [-Cross15, -Cross15, -Cross15, +Infinity, -Cross15, +Infinity, 0, 0, 0, 0] # X61 # [-Cross45, -Cross45, -Cross45, +Infinity, -Cross45, -Cross45, -Cross45, -Cross45, +Infinity, -Cross45] # X62 # [-Cross110, -Cross110, +Infinity, -Cross110, -Cross110, -Cross110, -Cross110, -Cross110, -Cross110, +Infinity] # X63 # [-Cross37, +Infinity, -Cross37, -Cross37, -Cross37, -Cross37, -Cross37, +Infinity, -Cross37, -Cross37] # X64 # [+Infinity, -Cross123, -Cross123, -Cross123, -Cross123, -Cross123, +Infinity, -Cross123, -Cross123, -Cross123] # X65 # [-Cross51, -Cross51, -Cross51, -Cross51, +Infinity, +Infinity, -Cross51, -Cross51, -Cross51, -Cross51] # Y123456 # [-Cross57, -Cross57, +Infinity, -Cross57, -Cross57, +Infinity, -Cross57, -Cross57, -Cross57, -Cross57] # Y123546 # [-Cross81, -Cross81, +Infinity, -Cross81, -Cross81, -Cross81, -Cross81, +Infinity, -Cross81, -Cross81] # Y123645 # [-Cross97, -Cross97, +Infinity, -Cross97, -Cross97, -Cross97, +Infinity, -Cross97, -Cross97, -Cross97] # Y132456 # [-Cross48, +Infinity, -Cross48, -Cross48, -Cross48, +Infinity, -Cross48, -Cross48, -Cross48, -Cross48] # Y132546 # [-Cross132, +Infinity, -Cross132, -Cross132, -Cross132, -Cross132, -Cross132, -Cross132, -Cross132, +Infinity] # Y132645 # [-Cross117, +Infinity, -Cross117, -Cross117, -Cross117, -Cross117, +Infinity, -Cross117, -Cross117, -Cross117] # Y142356 # [+Infinity, -Cross129, -Cross129, -Cross129, -Cross129, +Infinity, -Cross129, -Cross129, -Cross129, -Cross129] # Y142536 # [+Infinity, -Cross120, -Cross120, -Cross120, -Cross120, -Cross120, -Cross120, -Cross120, -Cross120, +Infinity] # Y142635 # [+Infinity, -Cross12, -Cross12, -Cross12, -Cross12, -Cross12, -Cross12, +Infinity, -Cross12, -Cross12] # Y152346 # [-Cross30, -Cross30, -Cross30, -Cross30, +Infinity, -Cross30, -Cross30, -Cross30, +Infinity, -Cross30] # Y152436 # [-Cross41, -Cross41, -Cross41, -Cross41, +Infinity, -Cross41, -Cross41, -Cross41, +Infinity, -Cross41] # Y152634 # [-Cross54, -Cross54, -Cross54, -Cross54, +Infinity, -Cross54, -Cross54, -Cross54, +Infinity, -Cross54] # Y162345 # [-Cross6, -Cross6, -Cross6, +Infinity, -Cross6, -Cross6, +Infinity, -Cross6, -Cross6, -Cross6] # Y162435 # [-Cross60, -Cross60, -Cross60, +Infinity, -Cross60, -Cross60, -Cross60, +Infinity, -Cross60, -Cross60] # Y162534 # [-Cross69, -Cross69, -Cross69, +Infinity, -Cross69, -Cross69, -Cross69, -Cross69, -Cross69, +Infinity] # E6 # X12 # [0, 0, +Infinity, 0, 0, -Cross9, -Cross9, -Cross9, +Infinity, -Cross9] # X13 # [0, +Infinity, 0, 0, 0, -Cross9, +Infinity, -Cross9, -Cross9, -Cross9] # X14 # [+Infinity, 0, 0, 0, 0, -Cross9, -Cross9, +Infinity, -Cross9, -Cross9] # X15 # [0, 0, 0, 0, +Infinity, +Infinity, -Cross9, -Cross9, -Cross9, -Cross9] # X16 # [0, 0, 0, +Infinity, 0, -Cross9, -Cross9, -Cross9, -Cross9, +Infinity] # X21 # [-Cross114, -Cross114, +Infinity, -Cross114, -Cross114, -Cross114, -Cross114, -Cross114, -Cross114, +Infinity] # X23 # [-Cross105, +Infinity, -Cross105, -Cross105, -Cross105, -Cross105, +Infinity, -Cross105, -Cross105, -Cross105] # X24 # [+Infinity, -Cross21, -Cross21, -Cross21, -Cross21, -Cross21, -Cross21, +Infinity, -Cross21, -Cross21] # X25 # [-Cross93, -Cross93, -Cross93, -Cross93, +Infinity, +Infinity, -Cross93, -Cross93, -Cross93, -Cross93] # X26 # [-Cross63, -Cross63, -Cross63, +Infinity, -Cross63, -Cross63, -Cross63, -Cross63, +Infinity, -Cross63] # X31 # [-Cross0, +Infinity, -Cross0, -Cross0, -Cross0, -Cross0, -Cross0, -Cross0, -Cross0, +Infinity] # X32 # [-Cross84, -Cross84, +Infinity, -Cross84, -Cross84, -Cross84, -Cross84, -Cross84, +Infinity, -Cross84] # X34 # [+Infinity, -Cross102, -Cross102, -Cross102, -Cross102, -Cross102, -Cross102, +Infinity, -Cross102, -Cross102] # X35 # [-Cross90, -Cross90, -Cross90, -Cross90, +Infinity, +Infinity, -Cross90, -Cross90, -Cross90, -Cross90] # X36 # [-Cross99, -Cross99, -Cross99, +Infinity, -Cross99, -Cross99, +Infinity, -Cross99, -Cross99, -Cross99] # X41 # [+Infinity, -Cross18, -Cross18, -Cross18, -Cross18, -Cross18, -Cross18, -Cross18, -Cross18, +Infinity] # X42 # [-Cross126, -Cross126, +Infinity, -Cross126, -Cross126, -Cross126, -Cross126, -Cross126, +Infinity, -Cross126] # X43 # [-Cross28, +Infinity, -Cross28, -Cross28, -Cross28, -Cross28, +Infinity, -Cross28, -Cross28, -Cross28] # X45 # [-Cross3, -Cross3, -Cross3, -Cross3, +Infinity, +Infinity, -Cross3, -Cross3, -Cross3, -Cross3] # X46 # [-Cross73, -Cross73, -Cross73, +Infinity, -Cross73, -Cross73, -Cross73, +Infinity, -Cross73, -Cross73] # X51 # [-Cross24, -Cross24, -Cross24, -Cross24, +Infinity, -Cross24, -Cross24, -Cross24, -Cross24, +Infinity] # X52 # [-Cross87, -Cross87, +Infinity, -Cross87, -Cross87, -Cross87, -Cross87, -Cross87, +Infinity, -Cross87] # X53 # [-Cross15, +Infinity, -Cross15, -Cross15, -Cross15, -Cross15, +Infinity, -Cross15, -Cross15, -Cross15] # X54 # [+Infinity, -Cross76, -Cross76, -Cross76, -Cross76, -Cross76, -Cross76, +Infinity, -Cross76, -Cross76] # X56 # [-Cross66, -Cross66, -Cross66, +Infinity, -Cross66, +Infinity, -Cross66, -Cross66, -Cross66, -Cross66] # X61 # [-Cross37, -Cross37, -Cross37, +Infinity, -Cross37, 0, 0, 0, 0, +Infinity] # X62 # [-Cross37, -Cross37, +Infinity, -Cross37, -Cross37, 0, 0, 0, +Infinity, 0] # X63 # [-Cross37, +Infinity, -Cross37, -Cross37, -Cross37, 0, +Infinity, 0, 0, 0] # X64 # [+Infinity, -Cross37, -Cross37, -Cross37, -Cross37, 0, 0, +Infinity, 0, 0] # X65 # [-Cross37, -Cross37, -Cross37, -Cross37, +Infinity, +Infinity, 0, 0, 0, 0] # Y123456 # [-Cross57, -Cross57, +Infinity, -Cross57, -Cross57, +Infinity, -Cross57, -Cross57, -Cross57, -Cross57] # Y123546 # [-Cross81, -Cross81, +Infinity, -Cross81, -Cross81, -Cross81, -Cross81, +Infinity, -Cross81, -Cross81] # Y123645 # [-Cross97, -Cross97, +Infinity, -Cross97, -Cross97, -Cross97, +Infinity, -Cross97, -Cross97, -Cross97] # Y132456 # [-Cross48, +Infinity, -Cross48, -Cross48, -Cross48, +Infinity, -Cross48, -Cross48, -Cross48, -Cross48] # Y132546 # [-Cross132, +Infinity, -Cross132, -Cross132, -Cross132, -Cross132, -Cross132, +Infinity, -Cross132, -Cross132] # Y132645 # [-Cross117, +Infinity, -Cross117, -Cross117, -Cross117, -Cross117, -Cross117, -Cross117, +Infinity, -Cross117] # Y142356 # [+Infinity, -Cross129, -Cross129, -Cross129, -Cross129, +Infinity, -Cross129, -Cross129, -Cross129, -Cross129] # Y142536 # [+Infinity, -Cross120, -Cross120, -Cross120, -Cross120, -Cross120, +Infinity, -Cross120, -Cross120, -Cross120] # Y142635 # [+Infinity, -Cross12, -Cross12, -Cross12, -Cross12, -Cross12, -Cross12, -Cross12, +Infinity, -Cross12] # Y152346 # [-Cross30, -Cross30, -Cross30, -Cross30, +Infinity, -Cross30, -Cross30, +Infinity, -Cross30, -Cross30] # Y152436 # [-Cross41, -Cross41, -Cross41, -Cross41, +Infinity, -Cross41, +Infinity, -Cross41, -Cross41, -Cross41] # Y152634 # [-Cross54, -Cross54, -Cross54, -Cross54, +Infinity, -Cross54, -Cross54, -Cross54, +Infinity, -Cross54] # Y162345 # [-Cross6, -Cross6, -Cross6, +Infinity, -Cross6, -Cross6, -Cross6, -Cross6, -Cross6, +Infinity] # Y162435 # [-Cross60, -Cross60, -Cross60, +Infinity, -Cross60, -Cross60, -Cross60, -Cross60, -Cross60, +Infinity] # Y162534 # [-Cross69, -Cross69, -Cross69, +Infinity, -Cross69, -Cross69, -Cross69, -Cross69, -Cross69, +Infinity] # F12 # X12 # [0, 0, +Infinity, 0, 0, 0, 0, 0, 0, +Infinity] # X13 # [0, +Infinity, 0, 0, 0, -Cross9, -Cross9, -Cross9, -Cross9, +Infinity] # X14 # [+Infinity, 0, 0, 0, 0, -Cross9, -Cross9, -Cross9, -Cross9, +Infinity] # X15 # [0, 0, 0, 0, +Infinity, -Cross9, -Cross9, -Cross9, -Cross9, +Infinity] # X16 # [0, 0, 0, +Infinity, 0, -Cross9, -Cross9, -Cross9, -Cross9, +Infinity] # X21 # [-Cross9, -Cross9, +Infinity, -Cross9, -Cross9, 0, 0, 0, +Infinity, 0] # X23 # [-Cross105, +Infinity, -Cross105, -Cross105, -Cross105, -Cross105, -Cross105, -Cross105, +Infinity, -Cross105] # X24 # [+Infinity, -Cross21, -Cross21, -Cross21, -Cross21, -Cross21, -Cross21, -Cross21, +Infinity, -Cross21] # X25 # [-Cross93, -Cross93, -Cross93, -Cross93, +Infinity, -Cross93, -Cross93, -Cross93, +Infinity, -Cross93] # X26 # [-Cross63, -Cross63, -Cross63, +Infinity, -Cross63, -Cross63, -Cross63, -Cross63, +Infinity, -Cross63] # X31 # [-Cross0, +Infinity, -Cross0, -Cross0, -Cross0, -Cross0, -Cross0, -Cross0, +Infinity, -Cross0] # X32 # [-Cross84, -Cross84, +Infinity, -Cross84, -Cross84, -Cross84, -Cross84, -Cross84, -Cross84, +Infinity] # X34 # [+Infinity, -Cross102, -Cross102, -Cross102, -Cross102, +Infinity, -Cross102, -Cross102, -Cross102, -Cross102] # X35 # [-Cross90, -Cross90, -Cross90, -Cross90, +Infinity, -Cross90, -Cross90, +Infinity, -Cross90, -Cross90] # X36 # [-Cross99, -Cross99, -Cross99, +Infinity, -Cross99, -Cross99, +Infinity, -Cross99, -Cross99, -Cross99] # X41 # [+Infinity, -Cross18, -Cross18, -Cross18, -Cross18, -Cross18, -Cross18, -Cross18, +Infinity, -Cross18] # X42 # [-Cross126, -Cross126, +Infinity, -Cross126, -Cross126, -Cross126, -Cross126, -Cross126, -Cross126, +Infinity] # X43 # [-Cross28, +Infinity, -Cross28, -Cross28, -Cross28, +Infinity, -Cross28, -Cross28, -Cross28, -Cross28] # X45 # [-Cross3, -Cross3, -Cross3, -Cross3, +Infinity, -Cross3, +Infinity, -Cross3, -Cross3, -Cross3] # X46 # [-Cross73, -Cross73, -Cross73, +Infinity, -Cross73, -Cross73, -Cross73, +Infinity, -Cross73, -Cross73] # X51 # [-Cross24, -Cross24, -Cross24, -Cross24, +Infinity, -Cross24, -Cross24, -Cross24, +Infinity, -Cross24] # X52 # [-Cross87, -Cross87, +Infinity, -Cross87, -Cross87, -Cross87, -Cross87, -Cross87, -Cross87, +Infinity] # X53 # [-Cross15, +Infinity, -Cross15, -Cross15, -Cross15, -Cross15, -Cross15, +Infinity, -Cross15, -Cross15] # X54 # [+Infinity, -Cross76, -Cross76, -Cross76, -Cross76, -Cross76, +Infinity, -Cross76, -Cross76, -Cross76] # X56 # [-Cross66, -Cross66, -Cross66, +Infinity, -Cross66, +Infinity, -Cross66, -Cross66, -Cross66, -Cross66] # X61 # [-Cross45, -Cross45, -Cross45, +Infinity, -Cross45, -Cross45, -Cross45, -Cross45, +Infinity, -Cross45] # X62 # [-Cross110, -Cross110, +Infinity, -Cross110, -Cross110, -Cross110, -Cross110, -Cross110, -Cross110, +Infinity] # X63 # [-Cross37, +Infinity, -Cross37, -Cross37, -Cross37, -Cross37, +Infinity, -Cross37, -Cross37, -Cross37] # X64 # [+Infinity, -Cross123, -Cross123, -Cross123, -Cross123, -Cross123, -Cross123, +Infinity, -Cross123, -Cross123] # X65 # [-Cross51, -Cross51, -Cross51, -Cross51, +Infinity, +Infinity, -Cross51, -Cross51, -Cross51, -Cross51] # Y123456 # [-Cross9, -Cross9, +Infinity, -Cross9, -Cross9, +Infinity, 0, 0, 0, 0] # Y123546 # [-Cross9, -Cross9, +Infinity, -Cross9, -Cross9, 0, 0, +Infinity, 0, 0] # Y123645 # [-Cross9, -Cross9, +Infinity, -Cross9, -Cross9, 0, +Infinity, 0, 0, 0] # Y132456 # [-Cross48, +Infinity, -Cross48, -Cross48, -Cross48, +Infinity, -Cross48, -Cross48, -Cross48, -Cross48] # Y132546 # [-Cross132, +Infinity, -Cross132, -Cross132, -Cross132, -Cross132, -Cross132, +Infinity, -Cross132, -Cross132] # Y132645 # [-Cross117, +Infinity, -Cross117, -Cross117, -Cross117, -Cross117, +Infinity, -Cross117, -Cross117, -Cross117] # Y142356 # [+Infinity, -Cross129, -Cross129, -Cross129, -Cross129, +Infinity, -Cross129, -Cross129, -Cross129, -Cross129] # Y142536 # [+Infinity, -Cross120, -Cross120, -Cross120, -Cross120, -Cross120, +Infinity, -Cross120, -Cross120, -Cross120] # Y142635 # [+Infinity, -Cross12, -Cross12, -Cross12, -Cross12, -Cross12, -Cross12, +Infinity, -Cross12, -Cross12] # Y152346 # [-Cross30, -Cross30, -Cross30, -Cross30, +Infinity, -Cross30, -Cross30, +Infinity, -Cross30, -Cross30] # Y152436 # [-Cross41, -Cross41, -Cross41, -Cross41, +Infinity, -Cross41, +Infinity, -Cross41, -Cross41, -Cross41] # Y152634 # [-Cross54, -Cross54, -Cross54, -Cross54, +Infinity, +Infinity, -Cross54, -Cross54, -Cross54, -Cross54] # Y162345 # [-Cross6, -Cross6, -Cross6, +Infinity, -Cross6, -Cross6, +Infinity, -Cross6, -Cross6, -Cross6] # Y162435 # [-Cross60, -Cross60, -Cross60, +Infinity, -Cross60, -Cross60, -Cross60, +Infinity, -Cross60, -Cross60] # Y162534 # [-Cross69, -Cross69, -Cross69, +Infinity, -Cross69, +Infinity, -Cross69, -Cross69, -Cross69, -Cross69] # F13 # X12 # [0, 0, +Infinity, 0, 0, -Cross0, -Cross0, +Infinity, -Cross0, -Cross0] # X13 # [0, +Infinity, 0, 0, 0, 0, 0, +Infinity, 0, 0] # X14 # [+Infinity, 0, 0, 0, 0, -Cross0, -Cross0, +Infinity, -Cross0, -Cross0] # X15 # [0, 0, 0, 0, +Infinity, -Cross0, -Cross0, +Infinity, -Cross0, -Cross0] # X16 # [0, 0, 0, +Infinity, 0, -Cross0, -Cross0, +Infinity, -Cross0, -Cross0] # X21 # [-Cross114, -Cross114, +Infinity, -Cross114, -Cross114, -Cross114, +Infinity, -Cross114, -Cross114, -Cross114] # X23 # [-Cross105, +Infinity, -Cross105, -Cross105, -Cross105, -Cross105, -Cross105, +Infinity, -Cross105, -Cross105] # X24 # [+Infinity, -Cross21, -Cross21, -Cross21, -Cross21, +Infinity, -Cross21, -Cross21, -Cross21, -Cross21] # X25 # [-Cross93, -Cross93, -Cross93, -Cross93, +Infinity, -Cross93, -Cross93, -Cross93, +Infinity, -Cross93] # X26 # [-Cross63, -Cross63, -Cross63, +Infinity, -Cross63, -Cross63, -Cross63, -Cross63, -Cross63, +Infinity] # X31 # [-Cross0, +Infinity, -Cross0, -Cross0, -Cross0, 0, +Infinity, 0, 0, 0] # X32 # [-Cross84, -Cross84, +Infinity, -Cross84, -Cross84, -Cross84, +Infinity, -Cross84, -Cross84, -Cross84] # X34 # [+Infinity, -Cross102, -Cross102, -Cross102, -Cross102, -Cross102, +Infinity, -Cross102, -Cross102, -Cross102] # X35 # [-Cross90, -Cross90, -Cross90, -Cross90, +Infinity, -Cross90, +Infinity, -Cross90, -Cross90, -Cross90] # X36 # [-Cross99, -Cross99, -Cross99, +Infinity, -Cross99, -Cross99, +Infinity, -Cross99, -Cross99, -Cross99] # X41 # [+Infinity, -Cross18, -Cross18, -Cross18, -Cross18, -Cross18, +Infinity, -Cross18, -Cross18, -Cross18] # X42 # [-Cross126, -Cross126, +Infinity, -Cross126, -Cross126, +Infinity, -Cross126, -Cross126, -Cross126, -Cross126] # X43 # [-Cross28, +Infinity, -Cross28, -Cross28, -Cross28, -Cross28, -Cross28, +Infinity, -Cross28, -Cross28] # X45 # [-Cross3, -Cross3, -Cross3, -Cross3, +Infinity, -Cross3, -Cross3, -Cross3, -Cross3, +Infinity] # X46 # [-Cross73, -Cross73, -Cross73, +Infinity, -Cross73, -Cross73, -Cross73, -Cross73, +Infinity, -Cross73] # X51 # [-Cross24, -Cross24, -Cross24, -Cross24, +Infinity, -Cross24, +Infinity, -Cross24, -Cross24, -Cross24] # X52 # [-Cross87, -Cross87, +Infinity, -Cross87, -Cross87, -Cross87, -Cross87, -Cross87, +Infinity, -Cross87] # X53 # [-Cross15, +Infinity, -Cross15, -Cross15, -Cross15, -Cross15, -Cross15, +Infinity, -Cross15, -Cross15] # X54 # [+Infinity, -Cross76, -Cross76, -Cross76, -Cross76, -Cross76, -Cross76, -Cross76, -Cross76, +Infinity] # X56 # [-Cross66, -Cross66, -Cross66, +Infinity, -Cross66, +Infinity, -Cross66, -Cross66, -Cross66, -Cross66] # X61 # [-Cross45, -Cross45, -Cross45, +Infinity, -Cross45, -Cross45, +Infinity, -Cross45, -Cross45, -Cross45] # X62 # [-Cross110, -Cross110, +Infinity, -Cross110, -Cross110, -Cross110, -Cross110, -Cross110, -Cross110, +Infinity] # X63 # [-Cross37, +Infinity, -Cross37, -Cross37, -Cross37, -Cross37, -Cross37, +Infinity, -Cross37, -Cross37] # X64 # [+Infinity, -Cross123, -Cross123, -Cross123, -Cross123, -Cross123, -Cross123, -Cross123, +Infinity, -Cross123] # X65 # [-Cross51, -Cross51, -Cross51, -Cross51, +Infinity, +Infinity, -Cross51, -Cross51, -Cross51, -Cross51] # Y123456 # [-Cross57, -Cross57, +Infinity, -Cross57, -Cross57, +Infinity, -Cross57, -Cross57, -Cross57, -Cross57] # Y123546 # [-Cross81, -Cross81, +Infinity, -Cross81, -Cross81, -Cross81, -Cross81, -Cross81, +Infinity, -Cross81] # Y123645 # [-Cross97, -Cross97, +Infinity, -Cross97, -Cross97, -Cross97, -Cross97, -Cross97, -Cross97, +Infinity] # Y132456 # [-Cross0, +Infinity, -Cross0, -Cross0, -Cross0, +Infinity, 0, 0, 0, 0] # Y132546 # [-Cross0, +Infinity, -Cross0, -Cross0, -Cross0, 0, 0, 0, +Infinity, 0] # Y132645 # [-Cross0, +Infinity, -Cross0, -Cross0, -Cross0, 0, 0, 0, 0, +Infinity] # Y142356 # [+Infinity, -Cross129, -Cross129, -Cross129, -Cross129, +Infinity, -Cross129, -Cross129, -Cross129, -Cross129] # Y142536 # [+Infinity, -Cross120, -Cross120, -Cross120, -Cross120, -Cross120, -Cross120, -Cross120, +Infinity, -Cross120] # Y142635 # [+Infinity, -Cross12, -Cross12, -Cross12, -Cross12, -Cross12, -Cross12, -Cross12, -Cross12, +Infinity] # Y152346 # [-Cross30, -Cross30, -Cross30, -Cross30, +Infinity, -Cross30, -Cross30, -Cross30, +Infinity, -Cross30] # Y152436 # [-Cross41, -Cross41, -Cross41, -Cross41, +Infinity, +Infinity, -Cross41, -Cross41, -Cross41, -Cross41] # Y152634 # [-Cross54, -Cross54, -Cross54, -Cross54, +Infinity, -Cross54, -Cross54, -Cross54, -Cross54, +Infinity] # Y162345 # [-Cross6, -Cross6, -Cross6, +Infinity, -Cross6, -Cross6, -Cross6, -Cross6, -Cross6, +Infinity] # Y162435 # [-Cross60, -Cross60, -Cross60, +Infinity, -Cross60, +Infinity, -Cross60, -Cross60, -Cross60, -Cross60] # Y162534 # [-Cross69, -Cross69, -Cross69, +Infinity, -Cross69, -Cross69, -Cross69, -Cross69, +Infinity, -Cross69] # F14 # X12 # [0, 0, +Infinity, 0, 0, -Cross9, -Cross9, -Cross9, +Infinity, -Cross9] # X13 # [0, +Infinity, 0, 0, 0, -Cross9, -Cross9, -Cross9, +Infinity, -Cross9] # X14 # [+Infinity, 0, 0, 0, 0, 0, 0, 0, +Infinity, 0] # X15 # [0, 0, 0, 0, +Infinity, -Cross9, -Cross9, -Cross9, +Infinity, -Cross9] # X16 # [0, 0, 0, +Infinity, 0, -Cross9, -Cross9, -Cross9, +Infinity, -Cross9] # X21 # [-Cross114, -Cross114, +Infinity, -Cross114, -Cross114, -Cross114, +Infinity, -Cross114, -Cross114, -Cross114] # X23 # [-Cross105, +Infinity, -Cross105, -Cross105, -Cross105, +Infinity, -Cross105, -Cross105, -Cross105, -Cross105] # X24 # [+Infinity, -Cross21, -Cross21, -Cross21, -Cross21, -Cross21, -Cross21, -Cross21, +Infinity, -Cross21] # X25 # [-Cross93, -Cross93, -Cross93, -Cross93, +Infinity, -Cross93, -Cross93, +Infinity, -Cross93, -Cross93] # X26 # [-Cross63, -Cross63, -Cross63, +Infinity, -Cross63, -Cross63, -Cross63, -Cross63, -Cross63, +Infinity] # X31 # [-Cross0, +Infinity, -Cross0, -Cross0, -Cross0, -Cross0, +Infinity, -Cross0, -Cross0, -Cross0] # X32 # [-Cross84, -Cross84, +Infinity, -Cross84, -Cross84, +Infinity, -Cross84, -Cross84, -Cross84, -Cross84] # X34 # [+Infinity, -Cross102, -Cross102, -Cross102, -Cross102, -Cross102, -Cross102, -Cross102, +Infinity, -Cross102] # X35 # [-Cross90, -Cross90, -Cross90, -Cross90, +Infinity, -Cross90, -Cross90, -Cross90, -Cross90, +Infinity] # X36 # [-Cross99, -Cross99, -Cross99, +Infinity, -Cross99, -Cross99, -Cross99, +Infinity, -Cross99, -Cross99] # X41 # [+Infinity, -Cross9, -Cross9, -Cross9, -Cross9, 0, +Infinity, 0, 0, 0] # X42 # [-Cross126, -Cross126, +Infinity, -Cross126, -Cross126, -Cross126, +Infinity, -Cross126, -Cross126, -Cross126] # X43 # [-Cross28, +Infinity, -Cross28, -Cross28, -Cross28, -Cross28, +Infinity, -Cross28, -Cross28, -Cross28] # X45 # [-Cross3, -Cross3, -Cross3, -Cross3, +Infinity, -Cross3, +Infinity, -Cross3, -Cross3, -Cross3] # X46 # [-Cross73, -Cross73, -Cross73, +Infinity, -Cross73, -Cross73, +Infinity, -Cross73, -Cross73, -Cross73] # X51 # [-Cross24, -Cross24, -Cross24, -Cross24, +Infinity, -Cross24, +Infinity, -Cross24, -Cross24, -Cross24] # X52 # [-Cross87, -Cross87, +Infinity, -Cross87, -Cross87, -Cross87, -Cross87, +Infinity, -Cross87, -Cross87] # X53 # [-Cross15, +Infinity, -Cross15, -Cross15, -Cross15, -Cross15, -Cross15, -Cross15, -Cross15, +Infinity] # X54 # [+Infinity, -Cross76, -Cross76, -Cross76, -Cross76, -Cross76, -Cross76, -Cross76, +Infinity, -Cross76] # X56 # [-Cross66, -Cross66, -Cross66, +Infinity, -Cross66, +Infinity, -Cross66, -Cross66, -Cross66, -Cross66] # X61 # [-Cross45, -Cross45, -Cross45, +Infinity, -Cross45, -Cross45, +Infinity, -Cross45, -Cross45, -Cross45] # X62 # [-Cross110, -Cross110, +Infinity, -Cross110, -Cross110, -Cross110, -Cross110, -Cross110, -Cross110, +Infinity] # X63 # [-Cross37, +Infinity, -Cross37, -Cross37, -Cross37, -Cross37, -Cross37, +Infinity, -Cross37, -Cross37] # X64 # [+Infinity, -Cross123, -Cross123, -Cross123, -Cross123, -Cross123, -Cross123, -Cross123, +Infinity, -Cross123] # X65 # [-Cross51, -Cross51, -Cross51, -Cross51, +Infinity, +Infinity, -Cross51, -Cross51, -Cross51, -Cross51] # Y123456 # [-Cross57, -Cross57, +Infinity, -Cross57, -Cross57, +Infinity, -Cross57, -Cross57, -Cross57, -Cross57] # Y123546 # [-Cross81, -Cross81, +Infinity, -Cross81, -Cross81, -Cross81, -Cross81, -Cross81, -Cross81, +Infinity] # Y123645 # [-Cross97, -Cross97, +Infinity, -Cross97, -Cross97, -Cross97, -Cross97, +Infinity, -Cross97, -Cross97] # Y132456 # [-Cross48, +Infinity, -Cross48, -Cross48, -Cross48, +Infinity, -Cross48, -Cross48, -Cross48, -Cross48] # Y132546 # [-Cross132, +Infinity, -Cross132, -Cross132, -Cross132, -Cross132, -Cross132, +Infinity, -Cross132, -Cross132] # Y132645 # [-Cross117, +Infinity, -Cross117, -Cross117, -Cross117, -Cross117, -Cross117, -Cross117, -Cross117, +Infinity] # Y142356 # [+Infinity, -Cross9, -Cross9, -Cross9, -Cross9, +Infinity, 0, 0, 0, 0] # Y142536 # [+Infinity, -Cross9, -Cross9, -Cross9, -Cross9, 0, 0, +Infinity, 0, 0] # Y142635 # [+Infinity, -Cross9, -Cross9, -Cross9, -Cross9, 0, 0, 0, 0, +Infinity] # Y152346 # [-Cross30, -Cross30, -Cross30, -Cross30, +Infinity, +Infinity, -Cross30, -Cross30, -Cross30, -Cross30] # Y152436 # [-Cross41, -Cross41, -Cross41, -Cross41, +Infinity, -Cross41, -Cross41, +Infinity, -Cross41, -Cross41] # Y152634 # [-Cross54, -Cross54, -Cross54, -Cross54, +Infinity, -Cross54, -Cross54, -Cross54, -Cross54, +Infinity] # Y162345 # [-Cross6, -Cross6, -Cross6, +Infinity, -Cross6, +Infinity, -Cross6, -Cross6, -Cross6, -Cross6] # Y162435 # [-Cross60, -Cross60, -Cross60, +Infinity, -Cross60, -Cross60, -Cross60, -Cross60, -Cross60, +Infinity] # Y162534 # [-Cross69, -Cross69, -Cross69, +Infinity, -Cross69, -Cross69, -Cross69, +Infinity, -Cross69, -Cross69] # F15 # X12 # [0, 0, +Infinity, 0, 0, -Cross9, -Cross9, -Cross9, -Cross9, +Infinity] # X13 # [0, +Infinity, 0, 0, 0, -Cross9, -Cross9, -Cross9, -Cross9, +Infinity] # X14 # [+Infinity, 0, 0, 0, 0, -Cross9, -Cross9, -Cross9, -Cross9, +Infinity] # X15 # [0, 0, 0, 0, +Infinity, 0, 0, 0, 0, +Infinity] # X16 # [0, 0, 0, +Infinity, 0, -Cross9, -Cross9, -Cross9, -Cross9, +Infinity] # X21 # [-Cross114, -Cross114, +Infinity, -Cross114, -Cross114, -Cross114, -Cross114, +Infinity, -Cross114, -Cross114] # X23 # [-Cross105, +Infinity, -Cross105, -Cross105, -Cross105, -Cross105, -Cross105, -Cross105, +Infinity, -Cross105] # X24 # [+Infinity, -Cross21, -Cross21, -Cross21, -Cross21, +Infinity, -Cross21, -Cross21, -Cross21, -Cross21] # X25 # [-Cross93, -Cross93, -Cross93, -Cross93, +Infinity, -Cross93, -Cross93, -Cross93, -Cross93, +Infinity] # X26 # [-Cross63, -Cross63, -Cross63, +Infinity, -Cross63, -Cross63, +Infinity, -Cross63, -Cross63, -Cross63] # X31 # [-Cross0, +Infinity, -Cross0, -Cross0, -Cross0, -Cross0, -Cross0, +Infinity, -Cross0, -Cross0] # X32 # [-Cross84, -Cross84, +Infinity, -Cross84, -Cross84, -Cross84, -Cross84, -Cross84, +Infinity, -Cross84] # X34 # [+Infinity, -Cross102, -Cross102, -Cross102, -Cross102, -Cross102, +Infinity, -Cross102, -Cross102, -Cross102] # X35 # [-Cross90, -Cross90, -Cross90, -Cross90, +Infinity, -Cross90, -Cross90, -Cross90, -Cross90, +Infinity] # X36 # [-Cross99, -Cross99, -Cross99, +Infinity, -Cross99, +Infinity, -Cross99, -Cross99, -Cross99, -Cross99] # X41 # [+Infinity, -Cross18, -Cross18, -Cross18, -Cross18, -Cross18, -Cross18, +Infinity, -Cross18, -Cross18] # X42 # [-Cross126, -Cross126, +Infinity, -Cross126, -Cross126, +Infinity, -Cross126, -Cross126, -Cross126, -Cross126] # X43 # [-Cross28, +Infinity, -Cross28, -Cross28, -Cross28, -Cross28, +Infinity, -Cross28, -Cross28, -Cross28] # X45 # [-Cross3, -Cross3, -Cross3, -Cross3, +Infinity, -Cross3, -Cross3, -Cross3, -Cross3, +Infinity] # X46 # [-Cross73, -Cross73, -Cross73, +Infinity, -Cross73, -Cross73, -Cross73, -Cross73, +Infinity, -Cross73] # X51 # [-Cross9, -Cross9, -Cross9, -Cross9, +Infinity, 0, 0, +Infinity, 0, 0] # X52 # [-Cross87, -Cross87, +Infinity, -Cross87, -Cross87, -Cross87, -Cross87, +Infinity, -Cross87, -Cross87] # X53 # [-Cross15, +Infinity, -Cross15, -Cross15, -Cross15, -Cross15, -Cross15, +Infinity, -Cross15, -Cross15] # X54 # [+Infinity, -Cross76, -Cross76, -Cross76, -Cross76, -Cross76, -Cross76, +Infinity, -Cross76, -Cross76] # X56 # [-Cross66, -Cross66, -Cross66, +Infinity, -Cross66, -Cross66, -Cross66, +Infinity, -Cross66, -Cross66] # X61 # [-Cross45, -Cross45, -Cross45, +Infinity, -Cross45, -Cross45, -Cross45, +Infinity, -Cross45, -Cross45] # X62 # [-Cross110, -Cross110, +Infinity, -Cross110, -Cross110, -Cross110, +Infinity, -Cross110, -Cross110, -Cross110] # X63 # [-Cross37, +Infinity, -Cross37, -Cross37, -Cross37, +Infinity, -Cross37, -Cross37, -Cross37, -Cross37] # X64 # [+Infinity, -Cross123, -Cross123, -Cross123, -Cross123, -Cross123, -Cross123, -Cross123, +Infinity, -Cross123] # X65 # [-Cross51, -Cross51, -Cross51, -Cross51, +Infinity, -Cross51, -Cross51, -Cross51, -Cross51, +Infinity] # Y123456 # [-Cross57, -Cross57, +Infinity, -Cross57, -Cross57, -Cross57, +Infinity, -Cross57, -Cross57, -Cross57] # Y123546 # [-Cross81, -Cross81, +Infinity, -Cross81, -Cross81, -Cross81, -Cross81, -Cross81, +Infinity, -Cross81] # Y123645 # [-Cross97, -Cross97, +Infinity, -Cross97, -Cross97, +Infinity, -Cross97, -Cross97, -Cross97, -Cross97] # Y132456 # [-Cross48, +Infinity, -Cross48, -Cross48, -Cross48, +Infinity, -Cross48, -Cross48, -Cross48, -Cross48] # Y132546 # [-Cross132, +Infinity, -Cross132, -Cross132, -Cross132, -Cross132, -Cross132, -Cross132, +Infinity, -Cross132] # Y132645 # [-Cross117, +Infinity, -Cross117, -Cross117, -Cross117, -Cross117, +Infinity, -Cross117, -Cross117, -Cross117] # Y142356 # [+Infinity, -Cross129, -Cross129, -Cross129, -Cross129, -Cross129, -Cross129, -Cross129, +Infinity, -Cross129] # Y142536 # [+Infinity, -Cross120, -Cross120, -Cross120, -Cross120, +Infinity, -Cross120, -Cross120, -Cross120, -Cross120] # Y142635 # [+Infinity, -Cross12, -Cross12, -Cross12, -Cross12, -Cross12, +Infinity, -Cross12, -Cross12, -Cross12] # Y152346 # [-Cross9, -Cross9, -Cross9, -Cross9, +Infinity, 0, 0, 0, +Infinity, 0] # Y152436 # [-Cross9, -Cross9, -Cross9, -Cross9, +Infinity, +Infinity, 0, 0, 0, 0] # Y152634 # [-Cross9, -Cross9, -Cross9, -Cross9, +Infinity, 0, +Infinity, 0, 0, 0] # Y162345 # [-Cross6, -Cross6, -Cross6, +Infinity, -Cross6, -Cross6, -Cross6, -Cross6, +Infinity, -Cross6] # Y162435 # [-Cross60, -Cross60, -Cross60, +Infinity, -Cross60, +Infinity, -Cross60, -Cross60, -Cross60, -Cross60] # Y162534 # [-Cross69, -Cross69, -Cross69, +Infinity, -Cross69, -Cross69, +Infinity, -Cross69, -Cross69, -Cross69] # F16 # X12 # [0, 0, +Infinity, 0, 0, -Cross6, -Cross6, +Infinity, -Cross6, -Cross6] # X13 # [0, +Infinity, 0, 0, 0, -Cross6, -Cross6, +Infinity, -Cross6, -Cross6] # X14 # [+Infinity, 0, 0, 0, 0, -Cross6, -Cross6, +Infinity, -Cross6, -Cross6] # X15 # [0, 0, 0, 0, +Infinity, -Cross6, -Cross6, +Infinity, -Cross6, -Cross6] # X16 # [0, 0, 0, +Infinity, 0, 0, 0, +Infinity, 0, 0] # X21 # [-Cross114, -Cross114, +Infinity, -Cross114, -Cross114, +Infinity, -Cross114, -Cross114, -Cross114, -Cross114] # X23 # [-Cross105, +Infinity, -Cross105, -Cross105, -Cross105, -Cross105, -Cross105, -Cross105, -Cross105, +Infinity] # X24 # [+Infinity, -Cross21, -Cross21, -Cross21, -Cross21, -Cross21, +Infinity, -Cross21, -Cross21, -Cross21] # X25 # [-Cross93, -Cross93, -Cross93, -Cross93, +Infinity, -Cross93, -Cross93, -Cross93, +Infinity, -Cross93] # X26 # [-Cross63, -Cross63, -Cross63, +Infinity, -Cross63, -Cross63, -Cross63, +Infinity, -Cross63, -Cross63] # X31 # [-Cross0, +Infinity, -Cross0, -Cross0, -Cross0, +Infinity, -Cross0, -Cross0, -Cross0, -Cross0] # X32 # [-Cross84, -Cross84, +Infinity, -Cross84, -Cross84, -Cross84, -Cross84, -Cross84, -Cross84, +Infinity] # X34 # [+Infinity, -Cross102, -Cross102, -Cross102, -Cross102, -Cross102, -Cross102, -Cross102, +Infinity, -Cross102] # X35 # [-Cross90, -Cross90, -Cross90, -Cross90, +Infinity, -Cross90, +Infinity, -Cross90, -Cross90, -Cross90] # X36 # [-Cross99, -Cross99, -Cross99, +Infinity, -Cross99, -Cross99, -Cross99, +Infinity, -Cross99, -Cross99] # X41 # [+Infinity, -Cross18, -Cross18, -Cross18, -Cross18, +Infinity, -Cross18, -Cross18, -Cross18, -Cross18] # X42 # [-Cross126, -Cross126, +Infinity, -Cross126, -Cross126, -Cross126, +Infinity, -Cross126, -Cross126, -Cross126] # X43 # [-Cross28, +Infinity, -Cross28, -Cross28, -Cross28, -Cross28, -Cross28, -Cross28, +Infinity, -Cross28] # X45 # [-Cross3, -Cross3, -Cross3, -Cross3, +Infinity, -Cross3, -Cross3, -Cross3, -Cross3, +Infinity] # X46 # [-Cross73, -Cross73, -Cross73, +Infinity, -Cross73, -Cross73, -Cross73, +Infinity, -Cross73, -Cross73] # X51 # [-Cross24, -Cross24, -Cross24, -Cross24, +Infinity, +Infinity, -Cross24, -Cross24, -Cross24, -Cross24] # X52 # [-Cross87, -Cross87, +Infinity, -Cross87, -Cross87, -Cross87, -Cross87, -Cross87, +Infinity, -Cross87] # X53 # [-Cross15, +Infinity, -Cross15, -Cross15, -Cross15, -Cross15, +Infinity, -Cross15, -Cross15, -Cross15] # X54 # [+Infinity, -Cross76, -Cross76, -Cross76, -Cross76, -Cross76, -Cross76, -Cross76, -Cross76, +Infinity] # X56 # [-Cross66, -Cross66, -Cross66, +Infinity, -Cross66, -Cross66, -Cross66, +Infinity, -Cross66, -Cross66] # X61 # [-Cross6, -Cross6, -Cross6, +Infinity, -Cross6, +Infinity, 0, 0, 0, 0] # X62 # [-Cross110, -Cross110, +Infinity, -Cross110, -Cross110, +Infinity, -Cross110, -Cross110, -Cross110, -Cross110] # X63 # [-Cross37, +Infinity, -Cross37, -Cross37, -Cross37, +Infinity, -Cross37, -Cross37, -Cross37, -Cross37] # X64 # [+Infinity, -Cross123, -Cross123, -Cross123, -Cross123, +Infinity, -Cross123, -Cross123, -Cross123, -Cross123] # X65 # [-Cross51, -Cross51, -Cross51, -Cross51, +Infinity, +Infinity, -Cross51, -Cross51, -Cross51, -Cross51] # Y123456 # [-Cross57, -Cross57, +Infinity, -Cross57, -Cross57, -Cross57, -Cross57, -Cross57, +Infinity, -Cross57] # Y123546 # [-Cross81, -Cross81, +Infinity, -Cross81, -Cross81, -Cross81, +Infinity, -Cross81, -Cross81, -Cross81] # Y123645 # [-Cross97, -Cross97, +Infinity, -Cross97, -Cross97, -Cross97, -Cross97, -Cross97, -Cross97, +Infinity] # Y132456 # [-Cross48, +Infinity, -Cross48, -Cross48, -Cross48, -Cross48, +Infinity, -Cross48, -Cross48, -Cross48] # Y132546 # [-Cross132, +Infinity, -Cross132, -Cross132, -Cross132, -Cross132, -Cross132, -Cross132, +Infinity, -Cross132] # Y132645 # [-Cross117, +Infinity, -Cross117, -Cross117, -Cross117, -Cross117, -Cross117, -Cross117, -Cross117, +Infinity] # Y142356 # [+Infinity, -Cross129, -Cross129, -Cross129, -Cross129, -Cross129, -Cross129, -Cross129, -Cross129, +Infinity] # Y142536 # [+Infinity, -Cross120, -Cross120, -Cross120, -Cross120, -Cross120, -Cross120, -Cross120, +Infinity, -Cross120] # Y142635 # [+Infinity, -Cross12, -Cross12, -Cross12, -Cross12, -Cross12, +Infinity, -Cross12, -Cross12, -Cross12] # Y152346 # [-Cross30, -Cross30, -Cross30, -Cross30, +Infinity, -Cross30, -Cross30, -Cross30, -Cross30, +Infinity] # Y152436 # [-Cross41, -Cross41, -Cross41, -Cross41, +Infinity, -Cross41, +Infinity, -Cross41, -Cross41, -Cross41] # Y152634 # [-Cross54, -Cross54, -Cross54, -Cross54, +Infinity, -Cross54, -Cross54, -Cross54, +Infinity, -Cross54] # Y162345 # [-Cross6, -Cross6, -Cross6, +Infinity, -Cross6, 0, 0, 0, 0, +Infinity] # Y162435 # [-Cross6, -Cross6, -Cross6, +Infinity, -Cross6, 0, +Infinity, 0, 0, 0] # Y162534 # [-Cross6, -Cross6, -Cross6, +Infinity, -Cross6, 0, 0, 0, +Infinity, 0] # F23 # X12 # [0, 0, +Infinity, 0, 0, -Cross9, +Infinity, -Cross9, -Cross9, -Cross9] # X13 # [0, +Infinity, 0, 0, 0, -Cross9, -Cross9, +Infinity, -Cross9, -Cross9] # X14 # [+Infinity, 0, 0, 0, 0, +Infinity, -Cross9, -Cross9, -Cross9, -Cross9] # X15 # [0, 0, 0, 0, +Infinity, -Cross9, -Cross9, -Cross9, +Infinity, -Cross9] # X16 # [0, 0, 0, +Infinity, 0, -Cross9, -Cross9, -Cross9, -Cross9, +Infinity] # X21 # [-Cross114, -Cross114, +Infinity, -Cross114, -Cross114, -Cross114, -Cross114, +Infinity, -Cross114, -Cross114] # X23 # [-Cross6, +Infinity, -Cross6, -Cross6, -Cross6, 0, 0, +Infinity, 0, 0] # X24 # [+Infinity, -Cross21, -Cross21, -Cross21, -Cross21, -Cross21, -Cross21, +Infinity, -Cross21, -Cross21] # X25 # [-Cross93, -Cross93, -Cross93, -Cross93, +Infinity, -Cross93, -Cross93, +Infinity, -Cross93, -Cross93] # X26 # [-Cross63, -Cross63, -Cross63, +Infinity, -Cross63, -Cross63, -Cross63, +Infinity, -Cross63, -Cross63] # X31 # [-Cross0, +Infinity, -Cross0, -Cross0, -Cross0, -Cross0, +Infinity, -Cross0, -Cross0, -Cross0] # X32 # [-Cross6, -Cross6, +Infinity, -Cross6, -Cross6, 0, +Infinity, 0, 0, 0] # X34 # [+Infinity, -Cross102, -Cross102, -Cross102, -Cross102, -Cross102, +Infinity, -Cross102, -Cross102, -Cross102] # X35 # [-Cross90, -Cross90, -Cross90, -Cross90, +Infinity, -Cross90, +Infinity, -Cross90, -Cross90, -Cross90] # X36 # [-Cross99, -Cross99, -Cross99, +Infinity, -Cross99, -Cross99, +Infinity, -Cross99, -Cross99, -Cross99] # X41 # [+Infinity, -Cross18, -Cross18, -Cross18, -Cross18, +Infinity, -Cross18, -Cross18, -Cross18, -Cross18] # X42 # [-Cross126, -Cross126, +Infinity, -Cross126, -Cross126, -Cross126, +Infinity, -Cross126, -Cross126, -Cross126] # X43 # [-Cross28, +Infinity, -Cross28, -Cross28, -Cross28, -Cross28, -Cross28, +Infinity, -Cross28, -Cross28] # X45 # [-Cross3, -Cross3, -Cross3, -Cross3, +Infinity, -Cross3, -Cross3, -Cross3, -Cross3, +Infinity] # X46 # [-Cross73, -Cross73, -Cross73, +Infinity, -Cross73, -Cross73, -Cross73, -Cross73, +Infinity, -Cross73] # X51 # [-Cross24, -Cross24, -Cross24, -Cross24, +Infinity, -Cross24, -Cross24, -Cross24, +Infinity, -Cross24] # X52 # [-Cross87, -Cross87, +Infinity, -Cross87, -Cross87, -Cross87, +Infinity, -Cross87, -Cross87, -Cross87] # X53 # [-Cross15, +Infinity, -Cross15, -Cross15, -Cross15, -Cross15, -Cross15, +Infinity, -Cross15, -Cross15] # X54 # [+Infinity, -Cross76, -Cross76, -Cross76, -Cross76, -Cross76, -Cross76, -Cross76, -Cross76, +Infinity] # X56 # [-Cross66, -Cross66, -Cross66, +Infinity, -Cross66, +Infinity, -Cross66, -Cross66, -Cross66, -Cross66] # X61 # [-Cross45, -Cross45, -Cross45, +Infinity, -Cross45, -Cross45, -Cross45, -Cross45, -Cross45, +Infinity] # X62 # [-Cross110, -Cross110, +Infinity, -Cross110, -Cross110, -Cross110, +Infinity, -Cross110, -Cross110, -Cross110] # X63 # [-Cross37, +Infinity, -Cross37, -Cross37, -Cross37, -Cross37, -Cross37, +Infinity, -Cross37, -Cross37] # X64 # [+Infinity, -Cross123, -Cross123, -Cross123, -Cross123, -Cross123, -Cross123, -Cross123, +Infinity, -Cross123] # X65 # [-Cross51, -Cross51, -Cross51, -Cross51, +Infinity, +Infinity, -Cross51, -Cross51, -Cross51, -Cross51] # Y123456 # [-Cross57, -Cross57, +Infinity, -Cross57, -Cross57, +Infinity, -Cross57, -Cross57, -Cross57, -Cross57] # Y123546 # [-Cross81, -Cross81, +Infinity, -Cross81, -Cross81, -Cross81, -Cross81, -Cross81, +Infinity, -Cross81] # Y123645 # [-Cross97, -Cross97, +Infinity, -Cross97, -Cross97, -Cross97, -Cross97, -Cross97, -Cross97, +Infinity] # Y132456 # [-Cross48, +Infinity, -Cross48, -Cross48, -Cross48, +Infinity, -Cross48, -Cross48, -Cross48, -Cross48] # Y132546 # [-Cross132, +Infinity, -Cross132, -Cross132, -Cross132, -Cross132, -Cross132, -Cross132, +Infinity, -Cross132] # Y132645 # [-Cross117, +Infinity, -Cross117, -Cross117, -Cross117, -Cross117, -Cross117, -Cross117, -Cross117, +Infinity] # Y142356 # [+Infinity, -Cross6, -Cross6, -Cross6, -Cross6, +Infinity, 0, 0, 0, 0] # Y142536 # [+Infinity, -Cross120, -Cross120, -Cross120, -Cross120, +Infinity, -Cross120, -Cross120, -Cross120, -Cross120] # Y142635 # [+Infinity, -Cross12, -Cross12, -Cross12, -Cross12, +Infinity, -Cross12, -Cross12, -Cross12, -Cross12] # Y152346 # [-Cross6, -Cross6, -Cross6, -Cross6, +Infinity, 0, 0, 0, +Infinity, 0] # Y152436 # [-Cross41, -Cross41, -Cross41, -Cross41, +Infinity, -Cross41, -Cross41, -Cross41, +Infinity, -Cross41] # Y152634 # [-Cross54, -Cross54, -Cross54, -Cross54, +Infinity, -Cross54, -Cross54, -Cross54, +Infinity, -Cross54] # Y162345 # [-Cross6, -Cross6, -Cross6, +Infinity, -Cross6, 0, 0, 0, 0, +Infinity] # Y162435 # [-Cross60, -Cross60, -Cross60, +Infinity, -Cross60, -Cross60, -Cross60, -Cross60, -Cross60, +Infinity] # Y162534 # [-Cross69, -Cross69, -Cross69, +Infinity, -Cross69, -Cross69, -Cross69, -Cross69, -Cross69, +Infinity] # F24 # X12 # [0, 0, +Infinity, 0, 0, -Cross9, +Infinity, -Cross9, -Cross9, -Cross9] # X13 # [0, +Infinity, 0, 0, 0, +Infinity, -Cross9, -Cross9, -Cross9, -Cross9] # X14 # [+Infinity, 0, 0, 0, 0, -Cross9, -Cross9, -Cross9, +Infinity, -Cross9] # X15 # [0, 0, 0, 0, +Infinity, -Cross9, -Cross9, +Infinity, -Cross9, -Cross9] # X16 # [0, 0, 0, +Infinity, 0, -Cross9, -Cross9, -Cross9, -Cross9, +Infinity] # X21 # [-Cross114, -Cross114, +Infinity, -Cross114, -Cross114, -Cross114, -Cross114, -Cross114, +Infinity, -Cross114] # X23 # [-Cross105, +Infinity, -Cross105, -Cross105, -Cross105, -Cross105, -Cross105, -Cross105, +Infinity, -Cross105] # X24 # [+Infinity, -Cross21, -Cross21, -Cross21, -Cross21, 0, 0, 0, +Infinity, 0] # X25 # [-Cross93, -Cross93, -Cross93, -Cross93, +Infinity, -Cross93, -Cross93, -Cross93, +Infinity, -Cross93] # X26 # [-Cross63, -Cross63, -Cross63, +Infinity, -Cross63, -Cross63, -Cross63, -Cross63, +Infinity, -Cross63] # X31 # [-Cross0, +Infinity, -Cross0, -Cross0, -Cross0, +Infinity, -Cross0, -Cross0, -Cross0, -Cross0] # X32 # [-Cross84, -Cross84, +Infinity, -Cross84, -Cross84, -Cross84, +Infinity, -Cross84, -Cross84, -Cross84] # X34 # [+Infinity, -Cross102, -Cross102, -Cross102, -Cross102, -Cross102, -Cross102, -Cross102, +Infinity, -Cross102] # X35 # [-Cross90, -Cross90, -Cross90, -Cross90, +Infinity, -Cross90, -Cross90, -Cross90, -Cross90, +Infinity] # X36 # [-Cross99, -Cross99, -Cross99, +Infinity, -Cross99, -Cross99, -Cross99, +Infinity, -Cross99, -Cross99] # X41 # [+Infinity, -Cross18, -Cross18, -Cross18, -Cross18, -Cross18, +Infinity, -Cross18, -Cross18, -Cross18] # X42 # [-Cross21, -Cross21, +Infinity, -Cross21, -Cross21, 0, +Infinity, 0, 0, 0] # X43 # [-Cross28, +Infinity, -Cross28, -Cross28, -Cross28, -Cross28, +Infinity, -Cross28, -Cross28, -Cross28] # X45 # [-Cross3, -Cross3, -Cross3, -Cross3, +Infinity, -Cross3, +Infinity, -Cross3, -Cross3, -Cross3] # X46 # [-Cross73, -Cross73, -Cross73, +Infinity, -Cross73, -Cross73, +Infinity, -Cross73, -Cross73, -Cross73] # X51 # [-Cross24, -Cross24, -Cross24, -Cross24, +Infinity, -Cross24, -Cross24, +Infinity, -Cross24, -Cross24] # X52 # [-Cross87, -Cross87, +Infinity, -Cross87, -Cross87, -Cross87, +Infinity, -Cross87, -Cross87, -Cross87] # X53 # [-Cross15, +Infinity, -Cross15, -Cross15, -Cross15, -Cross15, -Cross15, -Cross15, -Cross15, +Infinity] # X54 # [+Infinity, -Cross76, -Cross76, -Cross76, -Cross76, -Cross76, -Cross76, -Cross76, +Infinity, -Cross76] # X56 # [-Cross66, -Cross66, -Cross66, +Infinity, -Cross66, +Infinity, -Cross66, -Cross66, -Cross66, -Cross66] # X61 # [-Cross45, -Cross45, -Cross45, +Infinity, -Cross45, -Cross45, -Cross45, -Cross45, -Cross45, +Infinity] # X62 # [-Cross110, -Cross110, +Infinity, -Cross110, -Cross110, -Cross110, +Infinity, -Cross110, -Cross110, -Cross110] # X63 # [-Cross37, +Infinity, -Cross37, -Cross37, -Cross37, -Cross37, -Cross37, +Infinity, -Cross37, -Cross37] # X64 # [+Infinity, -Cross123, -Cross123, -Cross123, -Cross123, -Cross123, -Cross123, -Cross123, +Infinity, -Cross123] # X65 # [-Cross51, -Cross51, -Cross51, -Cross51, +Infinity, +Infinity, -Cross51, -Cross51, -Cross51, -Cross51] # Y123456 # [-Cross57, -Cross57, +Infinity, -Cross57, -Cross57, +Infinity, -Cross57, -Cross57, -Cross57, -Cross57] # Y123546 # [-Cross81, -Cross81, +Infinity, -Cross81, -Cross81, -Cross81, -Cross81, -Cross81, -Cross81, +Infinity] # Y123645 # [-Cross97, -Cross97, +Infinity, -Cross97, -Cross97, -Cross97, -Cross97, +Infinity, -Cross97, -Cross97] # Y132456 # [-Cross21, +Infinity, -Cross21, -Cross21, -Cross21, +Infinity, 0, 0, 0, 0] # Y132546 # [-Cross132, +Infinity, -Cross132, -Cross132, -Cross132, +Infinity, -Cross132, -Cross132, -Cross132, -Cross132] # Y132645 # [-Cross117, +Infinity, -Cross117, -Cross117, -Cross117, +Infinity, -Cross117, -Cross117, -Cross117, -Cross117] # Y142356 # [+Infinity, -Cross129, -Cross129, -Cross129, -Cross129, +Infinity, -Cross129, -Cross129, -Cross129, -Cross129] # Y142536 # [+Infinity, -Cross120, -Cross120, -Cross120, -Cross120, -Cross120, -Cross120, +Infinity, -Cross120, -Cross120] # Y142635 # [+Infinity, -Cross12, -Cross12, -Cross12, -Cross12, -Cross12, -Cross12, -Cross12, -Cross12, +Infinity] # Y152346 # [-Cross30, -Cross30, -Cross30, -Cross30, +Infinity, -Cross30, -Cross30, +Infinity, -Cross30, -Cross30] # Y152436 # [-Cross21, -Cross21, -Cross21, -Cross21, +Infinity, 0, 0, +Infinity, 0, 0] # Y152634 # [-Cross54, -Cross54, -Cross54, -Cross54, +Infinity, -Cross54, -Cross54, +Infinity, -Cross54, -Cross54] # Y162345 # [-Cross6, -Cross6, -Cross6, +Infinity, -Cross6, -Cross6, -Cross6, -Cross6, -Cross6, +Infinity] # Y162435 # [-Cross21, -Cross21, -Cross21, +Infinity, -Cross21, 0, 0, 0, 0, +Infinity] # Y162534 # [-Cross69, -Cross69, -Cross69, +Infinity, -Cross69, -Cross69, -Cross69, -Cross69, -Cross69, +Infinity] # F25 # X12 # [0, 0, +Infinity, 0, 0, -Cross9, -Cross9, +Infinity, -Cross9, -Cross9] # X13 # [0, +Infinity, 0, 0, 0, -Cross9, -Cross9, -Cross9, +Infinity, -Cross9] # X14 # [+Infinity, 0, 0, 0, 0, +Infinity, -Cross9, -Cross9, -Cross9, -Cross9] # X15 # [0, 0, 0, 0, +Infinity, -Cross9, -Cross9, -Cross9, -Cross9, +Infinity] # X16 # [0, 0, 0, +Infinity, 0, -Cross9, +Infinity, -Cross9, -Cross9, -Cross9] # X21 # [-Cross114, -Cross114, +Infinity, -Cross114, -Cross114, -Cross114, -Cross114, -Cross114, -Cross114, +Infinity] # X23 # [-Cross105, +Infinity, -Cross105, -Cross105, -Cross105, -Cross105, -Cross105, -Cross105, -Cross105, +Infinity] # X24 # [+Infinity, -Cross21, -Cross21, -Cross21, -Cross21, -Cross21, -Cross21, -Cross21, -Cross21, +Infinity] # X25 # [-Cross69, -Cross69, -Cross69, -Cross69, +Infinity, 0, 0, 0, 0, +Infinity] # X26 # [-Cross63, -Cross63, -Cross63, +Infinity, -Cross63, -Cross63, -Cross63, -Cross63, -Cross63, +Infinity] # X31 # [-Cross0, +Infinity, -Cross0, -Cross0, -Cross0, -Cross0, -Cross0, -Cross0, +Infinity, -Cross0] # X32 # [-Cross84, -Cross84, +Infinity, -Cross84, -Cross84, -Cross84, -Cross84, +Infinity, -Cross84, -Cross84] # X34 # [+Infinity, -Cross102, -Cross102, -Cross102, -Cross102, -Cross102, +Infinity, -Cross102, -Cross102, -Cross102] # X35 # [-Cross90, -Cross90, -Cross90, -Cross90, +Infinity, -Cross90, -Cross90, -Cross90, -Cross90, +Infinity] # X36 # [-Cross99, -Cross99, -Cross99, +Infinity, -Cross99, +Infinity, -Cross99, -Cross99, -Cross99, -Cross99] # X41 # [+Infinity, -Cross18, -Cross18, -Cross18, -Cross18, +Infinity, -Cross18, -Cross18, -Cross18, -Cross18] # X42 # [-Cross126, -Cross126, +Infinity, -Cross126, -Cross126, -Cross126, -Cross126, +Infinity, -Cross126, -Cross126] # X43 # [-Cross28, +Infinity, -Cross28, -Cross28, -Cross28, -Cross28, +Infinity, -Cross28, -Cross28, -Cross28] # X45 # [-Cross3, -Cross3, -Cross3, -Cross3, +Infinity, -Cross3, -Cross3, -Cross3, -Cross3, +Infinity] # X46 # [-Cross73, -Cross73, -Cross73, +Infinity, -Cross73, -Cross73, -Cross73, -Cross73, +Infinity, -Cross73] # X51 # [-Cross24, -Cross24, -Cross24, -Cross24, +Infinity, -Cross24, -Cross24, +Infinity, -Cross24, -Cross24] # X52 # [-Cross69, -Cross69, +Infinity, -Cross69, -Cross69, 0, 0, +Infinity, 0, 0] # X53 # [-Cross15, +Infinity, -Cross15, -Cross15, -Cross15, -Cross15, -Cross15, +Infinity, -Cross15, -Cross15] # X54 # [+Infinity, -Cross76, -Cross76, -Cross76, -Cross76, -Cross76, -Cross76, +Infinity, -Cross76, -Cross76] # X56 # [-Cross66, -Cross66, -Cross66, +Infinity, -Cross66, -Cross66, -Cross66, +Infinity, -Cross66, -Cross66] # X61 # [-Cross45, -Cross45, -Cross45, +Infinity, -Cross45, -Cross45, +Infinity, -Cross45, -Cross45, -Cross45] # X62 # [-Cross110, -Cross110, +Infinity, -Cross110, -Cross110, -Cross110, -Cross110, +Infinity, -Cross110, -Cross110] # X63 # [-Cross37, +Infinity, -Cross37, -Cross37, -Cross37, +Infinity, -Cross37, -Cross37, -Cross37, -Cross37] # X64 # [+Infinity, -Cross123, -Cross123, -Cross123, -Cross123, -Cross123, -Cross123, -Cross123, +Infinity, -Cross123] # X65 # [-Cross51, -Cross51, -Cross51, -Cross51, +Infinity, -Cross51, -Cross51, -Cross51, -Cross51, +Infinity] # Y123456 # [-Cross57, -Cross57, +Infinity, -Cross57, -Cross57, -Cross57, +Infinity, -Cross57, -Cross57, -Cross57] # Y123546 # [-Cross81, -Cross81, +Infinity, -Cross81, -Cross81, -Cross81, -Cross81, -Cross81, +Infinity, -Cross81] # Y123645 # [-Cross97, -Cross97, +Infinity, -Cross97, -Cross97, +Infinity, -Cross97, -Cross97, -Cross97, -Cross97] # Y132456 # [-Cross48, +Infinity, -Cross48, -Cross48, -Cross48, -Cross48, -Cross48, -Cross48, +Infinity, -Cross48] # Y132546 # [-Cross69, +Infinity, -Cross69, -Cross69, -Cross69, 0, 0, 0, +Infinity, 0] # Y132645 # [-Cross117, +Infinity, -Cross117, -Cross117, -Cross117, -Cross117, -Cross117, -Cross117, +Infinity, -Cross117] # Y142356 # [+Infinity, -Cross129, -Cross129, -Cross129, -Cross129, +Infinity, -Cross129, -Cross129, -Cross129, -Cross129] # Y142536 # [+Infinity, -Cross69, -Cross69, -Cross69, -Cross69, +Infinity, 0, 0, 0, 0] # Y142635 # [+Infinity, -Cross12, -Cross12, -Cross12, -Cross12, +Infinity, -Cross12, -Cross12, -Cross12, -Cross12] # Y152346 # [-Cross30, -Cross30, -Cross30, -Cross30, +Infinity, -Cross30, -Cross30, -Cross30, +Infinity, -Cross30] # Y152436 # [-Cross41, -Cross41, -Cross41, -Cross41, +Infinity, +Infinity, -Cross41, -Cross41, -Cross41, -Cross41] # Y152634 # [-Cross54, -Cross54, -Cross54, -Cross54, +Infinity, -Cross54, +Infinity, -Cross54, -Cross54, -Cross54] # Y162345 # [-Cross6, -Cross6, -Cross6, +Infinity, -Cross6, -Cross6, +Infinity, -Cross6, -Cross6, -Cross6] # Y162435 # [-Cross60, -Cross60, -Cross60, +Infinity, -Cross60, -Cross60, +Infinity, -Cross60, -Cross60, -Cross60] # Y162534 # [-Cross69, -Cross69, -Cross69, +Infinity, -Cross69, 0, +Infinity, 0, 0, 0] # F26 # X12 # [0, 0, +Infinity, 0, 0, +Infinity, -Cross9, -Cross9, -Cross9, -Cross9] # X13 # [0, +Infinity, 0, 0, 0, -Cross9, -Cross9, -Cross9, -Cross9, +Infinity] # X14 # [+Infinity, 0, 0, 0, 0, -Cross9, -Cross9, -Cross9, +Infinity, -Cross9] # X15 # [0, 0, 0, 0, +Infinity, -Cross9, -Cross9, +Infinity, -Cross9, -Cross9] # X16 # [0, 0, 0, +Infinity, 0, -Cross9, +Infinity, -Cross9, -Cross9, -Cross9] # X21 # [-Cross114, -Cross114, +Infinity, -Cross114, -Cross114, -Cross114, +Infinity, -Cross114, -Cross114, -Cross114] # X23 # [-Cross105, +Infinity, -Cross105, -Cross105, -Cross105, -Cross105, +Infinity, -Cross105, -Cross105, -Cross105] # X24 # [+Infinity, -Cross21, -Cross21, -Cross21, -Cross21, -Cross21, +Infinity, -Cross21, -Cross21, -Cross21] # X25 # [-Cross93, -Cross93, -Cross93, -Cross93, +Infinity, -Cross93, +Infinity, -Cross93, -Cross93, -Cross93] # X26 # [-Cross12, -Cross12, -Cross12, +Infinity, -Cross12, 0, +Infinity, 0, 0, 0] # X31 # [-Cross0, +Infinity, -Cross0, -Cross0, -Cross0, -Cross0, -Cross0, -Cross0, -Cross0, +Infinity] # X32 # [-Cross84, -Cross84, +Infinity, -Cross84, -Cross84, +Infinity, -Cross84, -Cross84, -Cross84, -Cross84] # X34 # [+Infinity, -Cross102, -Cross102, -Cross102, -Cross102, -Cross102, -Cross102, +Infinity, -Cross102, -Cross102] # X35 # [-Cross90, -Cross90, -Cross90, -Cross90, +Infinity, -Cross90, -Cross90, -Cross90, +Infinity, -Cross90] # X36 # [-Cross99, -Cross99, -Cross99, +Infinity, -Cross99, -Cross99, +Infinity, -Cross99, -Cross99, -Cross99] # X41 # [+Infinity, -Cross18, -Cross18, -Cross18, -Cross18, -Cross18, -Cross18, -Cross18, +Infinity, -Cross18] # X42 # [-Cross126, -Cross126, +Infinity, -Cross126, -Cross126, +Infinity, -Cross126, -Cross126, -Cross126, -Cross126] # X43 # [-Cross28, +Infinity, -Cross28, -Cross28, -Cross28, -Cross28, -Cross28, +Infinity, -Cross28, -Cross28] # X45 # [-Cross3, -Cross3, -Cross3, -Cross3, +Infinity, -Cross3, -Cross3, -Cross3, -Cross3, +Infinity] # X46 # [-Cross73, -Cross73, -Cross73, +Infinity, -Cross73, -Cross73, +Infinity, -Cross73, -Cross73, -Cross73] # X51 # [-Cross24, -Cross24, -Cross24, -Cross24, +Infinity, -Cross24, -Cross24, +Infinity, -Cross24, -Cross24] # X52 # [-Cross87, -Cross87, +Infinity, -Cross87, -Cross87, +Infinity, -Cross87, -Cross87, -Cross87, -Cross87] # X53 # [-Cross15, +Infinity, -Cross15, -Cross15, -Cross15, -Cross15, -Cross15, -Cross15, +Infinity, -Cross15] # X54 # [+Infinity, -Cross76, -Cross76, -Cross76, -Cross76, -Cross76, -Cross76, -Cross76, -Cross76, +Infinity] # X56 # [-Cross66, -Cross66, -Cross66, +Infinity, -Cross66, -Cross66, +Infinity, -Cross66, -Cross66, -Cross66] # X61 # [-Cross45, -Cross45, -Cross45, +Infinity, -Cross45, +Infinity, -Cross45, -Cross45, -Cross45, -Cross45] # X62 # [-Cross12, -Cross12, +Infinity, -Cross12, -Cross12, +Infinity, 0, 0, 0, 0] # X63 # [-Cross37, +Infinity, -Cross37, -Cross37, -Cross37, +Infinity, -Cross37, -Cross37, -Cross37, -Cross37] # X64 # [+Infinity, -Cross123, -Cross123, -Cross123, -Cross123, +Infinity, -Cross123, -Cross123, -Cross123, -Cross123] # X65 # [-Cross51, -Cross51, -Cross51, -Cross51, +Infinity, +Infinity, -Cross51, -Cross51, -Cross51, -Cross51] # Y123456 # [-Cross57, -Cross57, +Infinity, -Cross57, -Cross57, -Cross57, -Cross57, +Infinity, -Cross57, -Cross57] # Y123546 # [-Cross81, -Cross81, +Infinity, -Cross81, -Cross81, -Cross81, -Cross81, -Cross81, +Infinity, -Cross81] # Y123645 # [-Cross97, -Cross97, +Infinity, -Cross97, -Cross97, -Cross97, -Cross97, -Cross97, -Cross97, +Infinity] # Y132456 # [-Cross48, +Infinity, -Cross48, -Cross48, -Cross48, -Cross48, -Cross48, -Cross48, -Cross48, +Infinity] # Y132546 # [-Cross132, +Infinity, -Cross132, -Cross132, -Cross132, -Cross132, -Cross132, -Cross132, -Cross132, +Infinity] # Y132645 # [-Cross12, +Infinity, -Cross12, -Cross12, -Cross12, 0, 0, 0, 0, +Infinity] # Y142356 # [+Infinity, -Cross129, -Cross129, -Cross129, -Cross129, -Cross129, -Cross129, -Cross129, +Infinity, -Cross129] # Y142536 # [+Infinity, -Cross120, -Cross120, -Cross120, -Cross120, -Cross120, -Cross120, -Cross120, +Infinity, -Cross120] # Y142635 # [+Infinity, -Cross12, -Cross12, -Cross12, -Cross12, 0, 0, 0, +Infinity, 0] # Y152346 # [-Cross30, -Cross30, -Cross30, -Cross30, +Infinity, -Cross30, -Cross30, +Infinity, -Cross30, -Cross30] # Y152436 # [-Cross41, -Cross41, -Cross41, -Cross41, +Infinity, -Cross41, -Cross41, +Infinity, -Cross41, -Cross41] # Y152634 # [-Cross12, -Cross12, -Cross12, -Cross12, +Infinity, 0, 0, +Infinity, 0, 0] # Y162345 # [-Cross6, -Cross6, -Cross6, +Infinity, -Cross6, -Cross6, -Cross6, -Cross6, -Cross6, +Infinity] # Y162435 # [-Cross60, -Cross60, -Cross60, +Infinity, -Cross60, -Cross60, -Cross60, -Cross60, +Infinity, -Cross60] # Y162534 # [-Cross69, -Cross69, -Cross69, +Infinity, -Cross69, -Cross69, -Cross69, +Infinity, -Cross69, -Cross69] # F34 # X12 # [0, 0, +Infinity, 0, 0, +Infinity, -Cross9, -Cross9, -Cross9, -Cross9] # X13 # [0, +Infinity, 0, 0, 0, -Cross9, +Infinity, -Cross9, -Cross9, -Cross9] # X14 # [+Infinity, 0, 0, 0, 0, -Cross9, -Cross9, +Infinity, -Cross9, -Cross9] # X15 # [0, 0, 0, 0, +Infinity, -Cross9, -Cross9, -Cross9, +Infinity, -Cross9] # X16 # [0, 0, 0, +Infinity, 0, -Cross9, -Cross9, -Cross9, -Cross9, +Infinity] # X21 # [-Cross114, -Cross114, +Infinity, -Cross114, -Cross114, +Infinity, -Cross114, -Cross114, -Cross114, -Cross114] # X23 # [-Cross105, +Infinity, -Cross105, -Cross105, -Cross105, -Cross105, +Infinity, -Cross105, -Cross105, -Cross105] # X24 # [+Infinity, -Cross21, -Cross21, -Cross21, -Cross21, -Cross21, -Cross21, +Infinity, -Cross21, -Cross21] # X25 # [-Cross93, -Cross93, -Cross93, -Cross93, +Infinity, -Cross93, -Cross93, -Cross93, -Cross93, +Infinity] # X26 # [-Cross63, -Cross63, -Cross63, +Infinity, -Cross63, -Cross63, -Cross63, -Cross63, +Infinity, -Cross63] # X31 # [-Cross0, +Infinity, -Cross0, -Cross0, -Cross0, -Cross0, -Cross0, +Infinity, -Cross0, -Cross0] # X32 # [-Cross84, -Cross84, +Infinity, -Cross84, -Cross84, -Cross84, -Cross84, +Infinity, -Cross84, -Cross84] # X34 # [+Infinity, -Cross28, -Cross28, -Cross28, -Cross28, 0, 0, +Infinity, 0, 0] # X35 # [-Cross90, -Cross90, -Cross90, -Cross90, +Infinity, -Cross90, -Cross90, +Infinity, -Cross90, -Cross90] # X36 # [-Cross99, -Cross99, -Cross99, +Infinity, -Cross99, -Cross99, -Cross99, +Infinity, -Cross99, -Cross99] # X41 # [+Infinity, -Cross18, -Cross18, -Cross18, -Cross18, -Cross18, +Infinity, -Cross18, -Cross18, -Cross18] # X42 # [-Cross126, -Cross126, +Infinity, -Cross126, -Cross126, -Cross126, +Infinity, -Cross126, -Cross126, -Cross126] # X43 # [-Cross28, +Infinity, -Cross28, -Cross28, -Cross28, 0, +Infinity, 0, 0, 0] # X45 # [-Cross3, -Cross3, -Cross3, -Cross3, +Infinity, -Cross3, +Infinity, -Cross3, -Cross3, -Cross3] # X46 # [-Cross73, -Cross73, -Cross73, +Infinity, -Cross73, -Cross73, +Infinity, -Cross73, -Cross73, -Cross73] # X51 # [-Cross24, -Cross24, -Cross24, -Cross24, +Infinity, -Cross24, -Cross24, -Cross24, +Infinity, -Cross24] # X52 # [-Cross87, -Cross87, +Infinity, -Cross87, -Cross87, -Cross87, -Cross87, -Cross87, -Cross87, +Infinity] # X53 # [-Cross15, +Infinity, -Cross15, -Cross15, -Cross15, -Cross15, +Infinity, -Cross15, -Cross15, -Cross15] # X54 # [+Infinity, -Cross76, -Cross76, -Cross76, -Cross76, -Cross76, -Cross76, +Infinity, -Cross76, -Cross76] # X56 # [-Cross66, -Cross66, -Cross66, +Infinity, -Cross66, +Infinity, -Cross66, -Cross66, -Cross66, -Cross66] # X61 # [-Cross45, -Cross45, -Cross45, +Infinity, -Cross45, -Cross45, -Cross45, -Cross45, -Cross45, +Infinity] # X62 # [-Cross110, -Cross110, +Infinity, -Cross110, -Cross110, -Cross110, -Cross110, -Cross110, +Infinity, -Cross110] # X63 # [-Cross37, +Infinity, -Cross37, -Cross37, -Cross37, -Cross37, +Infinity, -Cross37, -Cross37, -Cross37] # X64 # [+Infinity, -Cross123, -Cross123, -Cross123, -Cross123, -Cross123, -Cross123, +Infinity, -Cross123, -Cross123] # X65 # [-Cross51, -Cross51, -Cross51, -Cross51, +Infinity, +Infinity, -Cross51, -Cross51, -Cross51, -Cross51] # Y123456 # [-Cross28, -Cross28, +Infinity, -Cross28, -Cross28, +Infinity, 0, 0, 0, 0] # Y123546 # [-Cross81, -Cross81, +Infinity, -Cross81, -Cross81, +Infinity, -Cross81, -Cross81, -Cross81, -Cross81] # Y123645 # [-Cross97, -Cross97, +Infinity, -Cross97, -Cross97, +Infinity, -Cross97, -Cross97, -Cross97, -Cross97] # Y132456 # [-Cross48, +Infinity, -Cross48, -Cross48, -Cross48, +Infinity, -Cross48, -Cross48, -Cross48, -Cross48] # Y132546 # [-Cross132, +Infinity, -Cross132, -Cross132, -Cross132, -Cross132, -Cross132, -Cross132, -Cross132, +Infinity] # Y132645 # [-Cross117, +Infinity, -Cross117, -Cross117, -Cross117, -Cross117, -Cross117, -Cross117, +Infinity, -Cross117] # Y142356 # [+Infinity, -Cross129, -Cross129, -Cross129, -Cross129, +Infinity, -Cross129, -Cross129, -Cross129, -Cross129] # Y142536 # [+Infinity, -Cross120, -Cross120, -Cross120, -Cross120, -Cross120, -Cross120, -Cross120, -Cross120, +Infinity] # Y142635 # [+Infinity, -Cross12, -Cross12, -Cross12, -Cross12, -Cross12, -Cross12, -Cross12, +Infinity, -Cross12] # Y152346 # [-Cross30, -Cross30, -Cross30, -Cross30, +Infinity, -Cross30, -Cross30, -Cross30, +Infinity, -Cross30] # Y152436 # [-Cross41, -Cross41, -Cross41, -Cross41, +Infinity, -Cross41, -Cross41, -Cross41, +Infinity, -Cross41] # Y152634 # [-Cross28, -Cross28, -Cross28, -Cross28, +Infinity, 0, 0, 0, +Infinity, 0] # Y162345 # [-Cross6, -Cross6, -Cross6, +Infinity, -Cross6, -Cross6, -Cross6, -Cross6, -Cross6, +Infinity] # Y162435 # [-Cross60, -Cross60, -Cross60, +Infinity, -Cross60, -Cross60, -Cross60, -Cross60, -Cross60, +Infinity] # Y162534 # [-Cross28, -Cross28, -Cross28, +Infinity, -Cross28, 0, 0, 0, 0, +Infinity] # F35 # X12 # [0, 0, +Infinity, 0, 0, -Cross9, -Cross9, +Infinity, -Cross9, -Cross9] # X13 # [0, +Infinity, 0, 0, 0, -Cross9, +Infinity, -Cross9, -Cross9, -Cross9] # X14 # [+Infinity, 0, 0, 0, 0, -Cross9, -Cross9, -Cross9, -Cross9, +Infinity] # X15 # [0, 0, 0, 0, +Infinity, +Infinity, -Cross9, -Cross9, -Cross9, -Cross9] # X16 # [0, 0, 0, +Infinity, 0, -Cross9, -Cross9, -Cross9, +Infinity, -Cross9] # X21 # [-Cross114, -Cross114, +Infinity, -Cross114, -Cross114, -Cross114, -Cross114, +Infinity, -Cross114, -Cross114] # X23 # [-Cross105, +Infinity, -Cross105, -Cross105, -Cross105, -Cross105, +Infinity, -Cross105, -Cross105, -Cross105] # X24 # [+Infinity, -Cross21, -Cross21, -Cross21, -Cross21, -Cross21, -Cross21, -Cross21, +Infinity, -Cross21] # X25 # [-Cross93, -Cross93, -Cross93, -Cross93, +Infinity, +Infinity, -Cross93, -Cross93, -Cross93, -Cross93] # X26 # [-Cross63, -Cross63, -Cross63, +Infinity, -Cross63, -Cross63, -Cross63, -Cross63, -Cross63, +Infinity] # X31 # [-Cross0, +Infinity, -Cross0, -Cross0, -Cross0, +Infinity, -Cross0, -Cross0, -Cross0, -Cross0] # X32 # [-Cross84, -Cross84, +Infinity, -Cross84, -Cross84, +Infinity, -Cross84, -Cross84, -Cross84, -Cross84] # X34 # [+Infinity, -Cross102, -Cross102, -Cross102, -Cross102, +Infinity, -Cross102, -Cross102, -Cross102, -Cross102] # X35 # [-Cross12, -Cross12, -Cross12, -Cross12, +Infinity, +Infinity, 0, 0, 0, 0] # X36 # [-Cross99, -Cross99, -Cross99, +Infinity, -Cross99, +Infinity, -Cross99, -Cross99, -Cross99, -Cross99] # X41 # [+Infinity, -Cross18, -Cross18, -Cross18, -Cross18, -Cross18, -Cross18, -Cross18, -Cross18, +Infinity] # X42 # [-Cross126, -Cross126, +Infinity, -Cross126, -Cross126, -Cross126, -Cross126, -Cross126, +Infinity, -Cross126] # X43 # [-Cross28, +Infinity, -Cross28, -Cross28, -Cross28, -Cross28, +Infinity, -Cross28, -Cross28, -Cross28] # X45 # [-Cross3, -Cross3, -Cross3, -Cross3, +Infinity, +Infinity, -Cross3, -Cross3, -Cross3, -Cross3] # X46 # [-Cross73, -Cross73, -Cross73, +Infinity, -Cross73, -Cross73, -Cross73, +Infinity, -Cross73, -Cross73] # X51 # [-Cross24, -Cross24, -Cross24, -Cross24, +Infinity, -Cross24, +Infinity, -Cross24, -Cross24, -Cross24] # X52 # [-Cross87, -Cross87, +Infinity, -Cross87, -Cross87, -Cross87, +Infinity, -Cross87, -Cross87, -Cross87] # X53 # [-Cross12, +Infinity, -Cross12, -Cross12, -Cross12, 0, +Infinity, 0, 0, 0] # X54 # [+Infinity, -Cross76, -Cross76, -Cross76, -Cross76, -Cross76, +Infinity, -Cross76, -Cross76, -Cross76] # X56 # [-Cross66, -Cross66, -Cross66, +Infinity, -Cross66, -Cross66, +Infinity, -Cross66, -Cross66, -Cross66] # X61 # [-Cross45, -Cross45, -Cross45, +Infinity, -Cross45, -Cross45, -Cross45, -Cross45, +Infinity, -Cross45] # X62 # [-Cross110, -Cross110, +Infinity, -Cross110, -Cross110, -Cross110, -Cross110, -Cross110, -Cross110, +Infinity] # X63 # [-Cross37, +Infinity, -Cross37, -Cross37, -Cross37, -Cross37, +Infinity, -Cross37, -Cross37, -Cross37] # X64 # [+Infinity, -Cross123, -Cross123, -Cross123, -Cross123, -Cross123, -Cross123, +Infinity, -Cross123, -Cross123] # X65 # [-Cross51, -Cross51, -Cross51, -Cross51, +Infinity, +Infinity, -Cross51, -Cross51, -Cross51, -Cross51] # Y123456 # [-Cross57, -Cross57, +Infinity, -Cross57, -Cross57, -Cross57, -Cross57, +Infinity, -Cross57, -Cross57] # Y123546 # [-Cross12, -Cross12, +Infinity, -Cross12, -Cross12, 0, 0, +Infinity, 0, 0] # Y123645 # [-Cross97, -Cross97, +Infinity, -Cross97, -Cross97, -Cross97, -Cross97, +Infinity, -Cross97, -Cross97] # Y132456 # [-Cross48, +Infinity, -Cross48, -Cross48, -Cross48, -Cross48, -Cross48, -Cross48, +Infinity, -Cross48] # Y132546 # [-Cross132, +Infinity, -Cross132, -Cross132, -Cross132, -Cross132, -Cross132, +Infinity, -Cross132, -Cross132] # Y132645 # [-Cross117, +Infinity, -Cross117, -Cross117, -Cross117, -Cross117, -Cross117, -Cross117, -Cross117, +Infinity] # Y142356 # [+Infinity, -Cross129, -Cross129, -Cross129, -Cross129, -Cross129, -Cross129, -Cross129, -Cross129, +Infinity] # Y142536 # [+Infinity, -Cross120, -Cross120, -Cross120, -Cross120, -Cross120, -Cross120, -Cross120, -Cross120, +Infinity] # Y142635 # [+Infinity, -Cross12, -Cross12, -Cross12, -Cross12, 0, 0, 0, 0, +Infinity] # Y152346 # [-Cross30, -Cross30, -Cross30, -Cross30, +Infinity, -Cross30, -Cross30, +Infinity, -Cross30, -Cross30] # Y152436 # [-Cross41, -Cross41, -Cross41, -Cross41, +Infinity, -Cross41, -Cross41, -Cross41, +Infinity, -Cross41] # Y152634 # [-Cross54, -Cross54, -Cross54, -Cross54, +Infinity, -Cross54, -Cross54, -Cross54, -Cross54, +Infinity] # Y162345 # [-Cross6, -Cross6, -Cross6, +Infinity, -Cross6, -Cross6, -Cross6, -Cross6, +Infinity, -Cross6] # Y162435 # [-Cross12, -Cross12, -Cross12, +Infinity, -Cross12, 0, 0, 0, +Infinity, 0] # Y162534 # [-Cross69, -Cross69, -Cross69, +Infinity, -Cross69, -Cross69, -Cross69, -Cross69, +Infinity, -Cross69] # F36 # X12 # [0, 0, +Infinity, 0, 0, -Cross9, -Cross9, +Infinity, -Cross9, -Cross9] # X13 # [0, +Infinity, 0, 0, 0, -Cross9, +Infinity, -Cross9, -Cross9, -Cross9] # X14 # [+Infinity, 0, 0, 0, 0, -Cross9, -Cross9, -Cross9, -Cross9, +Infinity] # X15 # [0, 0, 0, 0, +Infinity, -Cross9, -Cross9, -Cross9, +Infinity, -Cross9] # X16 # [0, 0, 0, +Infinity, 0, +Infinity, -Cross9, -Cross9, -Cross9, -Cross9] # X21 # [-Cross114, -Cross114, +Infinity, -Cross114, -Cross114, -Cross114, -Cross114, +Infinity, -Cross114, -Cross114] # X23 # [-Cross105, +Infinity, -Cross105, -Cross105, -Cross105, -Cross105, +Infinity, -Cross105, -Cross105, -Cross105] # X24 # [+Infinity, -Cross21, -Cross21, -Cross21, -Cross21, -Cross21, -Cross21, -Cross21, +Infinity, -Cross21] # X25 # [-Cross93, -Cross93, -Cross93, -Cross93, +Infinity, -Cross93, -Cross93, -Cross93, -Cross93, +Infinity] # X26 # [-Cross63, -Cross63, -Cross63, +Infinity, -Cross63, +Infinity, -Cross63, -Cross63, -Cross63, -Cross63] # X31 # [-Cross0, +Infinity, -Cross0, -Cross0, -Cross0, +Infinity, -Cross0, -Cross0, -Cross0, -Cross0] # X32 # [-Cross84, -Cross84, +Infinity, -Cross84, -Cross84, +Infinity, -Cross84, -Cross84, -Cross84, -Cross84] # X34 # [+Infinity, -Cross102, -Cross102, -Cross102, -Cross102, +Infinity, -Cross102, -Cross102, -Cross102, -Cross102] # X35 # [-Cross90, -Cross90, -Cross90, -Cross90, +Infinity, +Infinity, -Cross90, -Cross90, -Cross90, -Cross90] # X36 # [-Cross37, -Cross37, -Cross37, +Infinity, -Cross37, +Infinity, 0, 0, 0, 0] # X41 # [+Infinity, -Cross18, -Cross18, -Cross18, -Cross18, -Cross18, -Cross18, -Cross18, -Cross18, +Infinity] # X42 # [-Cross126, -Cross126, +Infinity, -Cross126, -Cross126, -Cross126, -Cross126, -Cross126, +Infinity, -Cross126] # X43 # [-Cross28, +Infinity, -Cross28, -Cross28, -Cross28, -Cross28, +Infinity, -Cross28, -Cross28, -Cross28] # X45 # [-Cross3, -Cross3, -Cross3, -Cross3, +Infinity, -Cross3, -Cross3, +Infinity, -Cross3, -Cross3] # X46 # [-Cross73, -Cross73, -Cross73, +Infinity, -Cross73, +Infinity, -Cross73, -Cross73, -Cross73, -Cross73] # X51 # [-Cross24, -Cross24, -Cross24, -Cross24, +Infinity, -Cross24, -Cross24, -Cross24, +Infinity, -Cross24] # X52 # [-Cross87, -Cross87, +Infinity, -Cross87, -Cross87, -Cross87, -Cross87, -Cross87, -Cross87, +Infinity] # X53 # [-Cross15, +Infinity, -Cross15, -Cross15, -Cross15, -Cross15, +Infinity, -Cross15, -Cross15, -Cross15] # X54 # [+Infinity, -Cross76, -Cross76, -Cross76, -Cross76, -Cross76, -Cross76, +Infinity, -Cross76, -Cross76] # X56 # [-Cross66, -Cross66, -Cross66, +Infinity, -Cross66, +Infinity, -Cross66, -Cross66, -Cross66, -Cross66] # X61 # [-Cross45, -Cross45, -Cross45, +Infinity, -Cross45, -Cross45, +Infinity, -Cross45, -Cross45, -Cross45] # X62 # [-Cross110, -Cross110, +Infinity, -Cross110, -Cross110, -Cross110, +Infinity, -Cross110, -Cross110, -Cross110] # X63 # [-Cross37, +Infinity, -Cross37, -Cross37, -Cross37, 0, +Infinity, 0, 0, 0] # X64 # [+Infinity, -Cross123, -Cross123, -Cross123, -Cross123, -Cross123, +Infinity, -Cross123, -Cross123, -Cross123] # X65 # [-Cross51, -Cross51, -Cross51, -Cross51, +Infinity, -Cross51, +Infinity, -Cross51, -Cross51, -Cross51] # Y123456 # [-Cross57, -Cross57, +Infinity, -Cross57, -Cross57, -Cross57, -Cross57, +Infinity, -Cross57, -Cross57] # Y123546 # [-Cross81, -Cross81, +Infinity, -Cross81, -Cross81, -Cross81, -Cross81, +Infinity, -Cross81, -Cross81] # Y123645 # [-Cross37, -Cross37, +Infinity, -Cross37, -Cross37, 0, 0, +Infinity, 0, 0] # Y132456 # [-Cross48, +Infinity, -Cross48, -Cross48, -Cross48, -Cross48, -Cross48, -Cross48, +Infinity, -Cross48] # Y132546 # [-Cross132, +Infinity, -Cross132, -Cross132, -Cross132, -Cross132, -Cross132, -Cross132, -Cross132, +Infinity] # Y132645 # [-Cross117, +Infinity, -Cross117, -Cross117, -Cross117, -Cross117, -Cross117, +Infinity, -Cross117, -Cross117] # Y142356 # [+Infinity, -Cross129, -Cross129, -Cross129, -Cross129, -Cross129, -Cross129, -Cross129, -Cross129, +Infinity] # Y142536 # [+Infinity, -Cross37, -Cross37, -Cross37, -Cross37, 0, 0, 0, 0, +Infinity] # Y142635 # [+Infinity, -Cross12, -Cross12, -Cross12, -Cross12, -Cross12, -Cross12, -Cross12, -Cross12, +Infinity] # Y152346 # [-Cross30, -Cross30, -Cross30, -Cross30, +Infinity, -Cross30, -Cross30, -Cross30, +Infinity, -Cross30] # Y152436 # [-Cross37, -Cross37, -Cross37, -Cross37, +Infinity, 0, 0, 0, +Infinity, 0] # Y152634 # [-Cross54, -Cross54, -Cross54, -Cross54, +Infinity, -Cross54, -Cross54, -Cross54, +Infinity, -Cross54] # Y162345 # [-Cross6, -Cross6, -Cross6, +Infinity, -Cross6, -Cross6, -Cross6, +Infinity, -Cross6, -Cross6] # Y162435 # [-Cross60, -Cross60, -Cross60, +Infinity, -Cross60, -Cross60, -Cross60, -Cross60, +Infinity, -Cross60] # Y162534 # [-Cross69, -Cross69, -Cross69, +Infinity, -Cross69, -Cross69, -Cross69, -Cross69, -Cross69, +Infinity] # F45 # X12 # [0, 0, +Infinity, 0, 0, -Cross9, +Infinity, -Cross9, -Cross9, -Cross9] # X13 # [0, +Infinity, 0, 0, 0, -Cross9, -Cross9, -Cross9, +Infinity, -Cross9] # X14 # [+Infinity, 0, 0, 0, 0, -Cross9, -Cross9, +Infinity, -Cross9, -Cross9] # X15 # [0, 0, 0, 0, +Infinity, +Infinity, -Cross9, -Cross9, -Cross9, -Cross9] # X16 # [0, 0, 0, +Infinity, 0, -Cross9, -Cross9, -Cross9, -Cross9, +Infinity] # X21 # [-Cross114, -Cross114, +Infinity, -Cross114, -Cross114, -Cross114, +Infinity, -Cross114, -Cross114, -Cross114] # X23 # [-Cross105, +Infinity, -Cross105, -Cross105, -Cross105, -Cross105, -Cross105, -Cross105, -Cross105, +Infinity] # X24 # [+Infinity, -Cross21, -Cross21, -Cross21, -Cross21, -Cross21, -Cross21, +Infinity, -Cross21, -Cross21] # X25 # [-Cross93, -Cross93, -Cross93, -Cross93, +Infinity, +Infinity, -Cross93, -Cross93, -Cross93, -Cross93] # X26 # [-Cross63, -Cross63, -Cross63, +Infinity, -Cross63, -Cross63, -Cross63, -Cross63, +Infinity, -Cross63] # X31 # [-Cross0, +Infinity, -Cross0, -Cross0, -Cross0, -Cross0, -Cross0, -Cross0, +Infinity, -Cross0] # X32 # [-Cross84, -Cross84, +Infinity, -Cross84, -Cross84, -Cross84, -Cross84, -Cross84, -Cross84, +Infinity] # X34 # [+Infinity, -Cross102, -Cross102, -Cross102, -Cross102, -Cross102, -Cross102, +Infinity, -Cross102, -Cross102] # X35 # [-Cross90, -Cross90, -Cross90, -Cross90, +Infinity, +Infinity, -Cross90, -Cross90, -Cross90, -Cross90] # X36 # [-Cross99, -Cross99, -Cross99, +Infinity, -Cross99, -Cross99, +Infinity, -Cross99, -Cross99, -Cross99] # X41 # [+Infinity, -Cross18, -Cross18, -Cross18, -Cross18, +Infinity, -Cross18, -Cross18, -Cross18, -Cross18] # X42 # [-Cross126, -Cross126, +Infinity, -Cross126, -Cross126, +Infinity, -Cross126, -Cross126, -Cross126, -Cross126] # X43 # [-Cross28, +Infinity, -Cross28, -Cross28, -Cross28, +Infinity, -Cross28, -Cross28, -Cross28, -Cross28] # X45 # [-Cross3, -Cross3, -Cross3, -Cross3, +Infinity, +Infinity, 0, 0, 0, 0] # X46 # [-Cross73, -Cross73, -Cross73, +Infinity, -Cross73, +Infinity, -Cross73, -Cross73, -Cross73, -Cross73] # X51 # [-Cross24, -Cross24, -Cross24, -Cross24, +Infinity, -Cross24, -Cross24, +Infinity, -Cross24, -Cross24] # X52 # [-Cross87, -Cross87, +Infinity, -Cross87, -Cross87, -Cross87, -Cross87, +Infinity, -Cross87, -Cross87] # X53 # [-Cross15, +Infinity, -Cross15, -Cross15, -Cross15, -Cross15, -Cross15, +Infinity, -Cross15, -Cross15] # X54 # [+Infinity, -Cross3, -Cross3, -Cross3, -Cross3, 0, 0, +Infinity, 0, 0] # X56 # [-Cross66, -Cross66, -Cross66, +Infinity, -Cross66, -Cross66, -Cross66, +Infinity, -Cross66, -Cross66] # X61 # [-Cross45, -Cross45, -Cross45, +Infinity, -Cross45, -Cross45, -Cross45, -Cross45, -Cross45, +Infinity] # X62 # [-Cross110, -Cross110, +Infinity, -Cross110, -Cross110, -Cross110, -Cross110, -Cross110, +Infinity, -Cross110] # X63 # [-Cross37, +Infinity, -Cross37, -Cross37, -Cross37, -Cross37, +Infinity, -Cross37, -Cross37, -Cross37] # X64 # [+Infinity, -Cross123, -Cross123, -Cross123, -Cross123, -Cross123, -Cross123, +Infinity, -Cross123, -Cross123] # X65 # [-Cross51, -Cross51, -Cross51, -Cross51, +Infinity, +Infinity, -Cross51, -Cross51, -Cross51, -Cross51] # Y123456 # [-Cross57, -Cross57, +Infinity, -Cross57, -Cross57, -Cross57, +Infinity, -Cross57, -Cross57, -Cross57] # Y123546 # [-Cross81, -Cross81, +Infinity, -Cross81, -Cross81, -Cross81, +Infinity, -Cross81, -Cross81, -Cross81] # Y123645 # [-Cross3, -Cross3, +Infinity, -Cross3, -Cross3, 0, +Infinity, 0, 0, 0] # Y132456 # [-Cross48, +Infinity, -Cross48, -Cross48, -Cross48, -Cross48, -Cross48, -Cross48, +Infinity, -Cross48] # Y132546 # [-Cross132, +Infinity, -Cross132, -Cross132, -Cross132, -Cross132, -Cross132, -Cross132, +Infinity, -Cross132] # Y132645 # [-Cross3, +Infinity, -Cross3, -Cross3, -Cross3, 0, 0, 0, +Infinity, 0] # Y142356 # [+Infinity, -Cross129, -Cross129, -Cross129, -Cross129, -Cross129, -Cross129, -Cross129, -Cross129, +Infinity] # Y142536 # [+Infinity, -Cross120, -Cross120, -Cross120, -Cross120, -Cross120, +Infinity, -Cross120, -Cross120, -Cross120] # Y142635 # [+Infinity, -Cross12, -Cross12, -Cross12, -Cross12, -Cross12, -Cross12, -Cross12, +Infinity, -Cross12] # Y152346 # [-Cross30, -Cross30, -Cross30, -Cross30, +Infinity, -Cross30, -Cross30, -Cross30, -Cross30, +Infinity] # Y152436 # [-Cross41, -Cross41, -Cross41, -Cross41, +Infinity, -Cross41, +Infinity, -Cross41, -Cross41, -Cross41] # Y152634 # [-Cross54, -Cross54, -Cross54, -Cross54, +Infinity, -Cross54, -Cross54, -Cross54, +Infinity, -Cross54] # Y162345 # [-Cross3, -Cross3, -Cross3, +Infinity, -Cross3, 0, 0, 0, 0, +Infinity] # Y162435 # [-Cross60, -Cross60, -Cross60, +Infinity, -Cross60, -Cross60, -Cross60, -Cross60, -Cross60, +Infinity] # Y162534 # [-Cross69, -Cross69, -Cross69, +Infinity, -Cross69, -Cross69, -Cross69, -Cross69, -Cross69, +Infinity] # F46 # X12 # [0, 0, +Infinity, 0, 0, -Cross9, -Cross9, +Infinity, -Cross9, -Cross9] # X13 # [0, +Infinity, 0, 0, 0, -Cross9, -Cross9, -Cross9, -Cross9, +Infinity] # X14 # [+Infinity, 0, 0, 0, 0, -Cross9, +Infinity, -Cross9, -Cross9, -Cross9] # X15 # [0, 0, 0, 0, +Infinity, -Cross9, -Cross9, -Cross9, +Infinity, -Cross9] # X16 # [0, 0, 0, +Infinity, 0, +Infinity, -Cross9, -Cross9, -Cross9, -Cross9] # X21 # [-Cross114, -Cross114, +Infinity, -Cross114, -Cross114, -Cross114, -Cross114, +Infinity, -Cross114, -Cross114] # X23 # [-Cross105, +Infinity, -Cross105, -Cross105, -Cross105, -Cross105, -Cross105, -Cross105, +Infinity, -Cross105] # X24 # [+Infinity, -Cross21, -Cross21, -Cross21, -Cross21, -Cross21, +Infinity, -Cross21, -Cross21, -Cross21] # X25 # [-Cross93, -Cross93, -Cross93, -Cross93, +Infinity, -Cross93, -Cross93, -Cross93, -Cross93, +Infinity] # X26 # [-Cross63, -Cross63, -Cross63, +Infinity, -Cross63, +Infinity, -Cross63, -Cross63, -Cross63, -Cross63] # X31 # [-Cross0, +Infinity, -Cross0, -Cross0, -Cross0, -Cross0, -Cross0, -Cross0, -Cross0, +Infinity] # X32 # [-Cross84, -Cross84, +Infinity, -Cross84, -Cross84, -Cross84, -Cross84, -Cross84, +Infinity, -Cross84] # X34 # [+Infinity, -Cross102, -Cross102, -Cross102, -Cross102, -Cross102, +Infinity, -Cross102, -Cross102, -Cross102] # X35 # [-Cross90, -Cross90, -Cross90, -Cross90, +Infinity, -Cross90, -Cross90, +Infinity, -Cross90, -Cross90] # X36 # [-Cross99, -Cross99, -Cross99, +Infinity, -Cross99, +Infinity, -Cross99, -Cross99, -Cross99, -Cross99] # X41 # [+Infinity, -Cross18, -Cross18, -Cross18, -Cross18, +Infinity, -Cross18, -Cross18, -Cross18, -Cross18] # X42 # [-Cross126, -Cross126, +Infinity, -Cross126, -Cross126, +Infinity, -Cross126, -Cross126, -Cross126, -Cross126] # X43 # [-Cross28, +Infinity, -Cross28, -Cross28, -Cross28, +Infinity, -Cross28, -Cross28, -Cross28, -Cross28] # X45 # [-Cross3, -Cross3, -Cross3, -Cross3, +Infinity, +Infinity, -Cross3, -Cross3, -Cross3, -Cross3] # X46 # [-Cross30, -Cross30, -Cross30, +Infinity, -Cross30, +Infinity, 0, 0, 0, 0] # X51 # [-Cross24, -Cross24, -Cross24, -Cross24, +Infinity, -Cross24, -Cross24, -Cross24, +Infinity, -Cross24] # X52 # [-Cross87, -Cross87, +Infinity, -Cross87, -Cross87, -Cross87, -Cross87, -Cross87, -Cross87, +Infinity] # X53 # [-Cross15, +Infinity, -Cross15, -Cross15, -Cross15, -Cross15, -Cross15, +Infinity, -Cross15, -Cross15] # X54 # [+Infinity, -Cross76, -Cross76, -Cross76, -Cross76, -Cross76, +Infinity, -Cross76, -Cross76, -Cross76] # X56 # [-Cross66, -Cross66, -Cross66, +Infinity, -Cross66, +Infinity, -Cross66, -Cross66, -Cross66, -Cross66] # X61 # [-Cross45, -Cross45, -Cross45, +Infinity, -Cross45, -Cross45, +Infinity, -Cross45, -Cross45, -Cross45] # X62 # [-Cross110, -Cross110, +Infinity, -Cross110, -Cross110, -Cross110, +Infinity, -Cross110, -Cross110, -Cross110] # X63 # [-Cross37, +Infinity, -Cross37, -Cross37, -Cross37, -Cross37, +Infinity, -Cross37, -Cross37, -Cross37] # X64 # [+Infinity, -Cross30, -Cross30, -Cross30, -Cross30, 0, +Infinity, 0, 0, 0] # X65 # [-Cross51, -Cross51, -Cross51, -Cross51, +Infinity, -Cross51, +Infinity, -Cross51, -Cross51, -Cross51] # Y123456 # [-Cross57, -Cross57, +Infinity, -Cross57, -Cross57, -Cross57, -Cross57, +Infinity, -Cross57, -Cross57] # Y123546 # [-Cross30, -Cross30, +Infinity, -Cross30, -Cross30, 0, 0, +Infinity, 0, 0] # Y123645 # [-Cross97, -Cross97, +Infinity, -Cross97, -Cross97, -Cross97, -Cross97, +Infinity, -Cross97, -Cross97] # Y132456 # [-Cross48, +Infinity, -Cross48, -Cross48, -Cross48, -Cross48, -Cross48, -Cross48, -Cross48, +Infinity] # Y132546 # [-Cross30, +Infinity, -Cross30, -Cross30, -Cross30, 0, 0, 0, 0, +Infinity] # Y132645 # [-Cross117, +Infinity, -Cross117, -Cross117, -Cross117, -Cross117, -Cross117, -Cross117, -Cross117, +Infinity] # Y142356 # [+Infinity, -Cross129, -Cross129, -Cross129, -Cross129, -Cross129, -Cross129, -Cross129, +Infinity, -Cross129] # Y142536 # [+Infinity, -Cross120, -Cross120, -Cross120, -Cross120, -Cross120, -Cross120, -Cross120, -Cross120, +Infinity] # Y142635 # [+Infinity, -Cross12, -Cross12, -Cross12, -Cross12, -Cross12, -Cross12, +Infinity, -Cross12, -Cross12] # Y152346 # [-Cross30, -Cross30, -Cross30, -Cross30, +Infinity, 0, 0, 0, +Infinity, 0] # Y152436 # [-Cross41, -Cross41, -Cross41, -Cross41, +Infinity, -Cross41, -Cross41, -Cross41, +Infinity, -Cross41] # Y152634 # [-Cross54, -Cross54, -Cross54, -Cross54, +Infinity, -Cross54, -Cross54, -Cross54, +Infinity, -Cross54] # Y162345 # [-Cross6, -Cross6, -Cross6, +Infinity, -Cross6, -Cross6, -Cross6, -Cross6, +Infinity, -Cross6] # Y162435 # [-Cross60, -Cross60, -Cross60, +Infinity, -Cross60, -Cross60, -Cross60, +Infinity, -Cross60, -Cross60] # Y162534 # [-Cross69, -Cross69, -Cross69, +Infinity, -Cross69, -Cross69, -Cross69, -Cross69, -Cross69, +Infinity] # F56 # X12 # [0, 0, +Infinity, 0, 0, +Infinity, -Cross9, -Cross9, -Cross9, -Cross9] # X13 # [0, +Infinity, 0, 0, 0, -Cross9, -Cross9, +Infinity, -Cross9, -Cross9] # X14 # [+Infinity, 0, 0, 0, 0, -Cross9, -Cross9, -Cross9, -Cross9, +Infinity] # X15 # [0, 0, 0, 0, +Infinity, -Cross9, +Infinity, -Cross9, -Cross9, -Cross9] # X16 # [0, 0, 0, +Infinity, 0, -Cross9, -Cross9, -Cross9, +Infinity, -Cross9] # X21 # [-Cross114, -Cross114, +Infinity, -Cross114, -Cross114, +Infinity, -Cross114, -Cross114, -Cross114, -Cross114] # X23 # [-Cross105, +Infinity, -Cross105, -Cross105, -Cross105, -Cross105, -Cross105, -Cross105, -Cross105, +Infinity] # X24 # [+Infinity, -Cross21, -Cross21, -Cross21, -Cross21, -Cross21, -Cross21, +Infinity, -Cross21, -Cross21] # X25 # [-Cross93, -Cross93, -Cross93, -Cross93, +Infinity, -Cross93, +Infinity, -Cross93, -Cross93, -Cross93] # X26 # [-Cross63, -Cross63, -Cross63, +Infinity, -Cross63, -Cross63, -Cross63, -Cross63, +Infinity, -Cross63] # X31 # [-Cross0, +Infinity, -Cross0, -Cross0, -Cross0, -Cross0, -Cross0, +Infinity, -Cross0, -Cross0] # X32 # [-Cross84, -Cross84, +Infinity, -Cross84, -Cross84, -Cross84, -Cross84, -Cross84, -Cross84, +Infinity] # X34 # [+Infinity, -Cross102, -Cross102, -Cross102, -Cross102, +Infinity, -Cross102, -Cross102, -Cross102, -Cross102] # X35 # [-Cross90, -Cross90, -Cross90, -Cross90, +Infinity, -Cross90, +Infinity, -Cross90, -Cross90, -Cross90] # X36 # [-Cross99, -Cross99, -Cross99, +Infinity, -Cross99, -Cross99, -Cross99, -Cross99, +Infinity, -Cross99] # X41 # [+Infinity, -Cross18, -Cross18, -Cross18, -Cross18, -Cross18, -Cross18, -Cross18, -Cross18, +Infinity] # X42 # [-Cross126, -Cross126, +Infinity, -Cross126, -Cross126, -Cross126, -Cross126, +Infinity, -Cross126, -Cross126] # X43 # [-Cross28, +Infinity, -Cross28, -Cross28, -Cross28, +Infinity, -Cross28, -Cross28, -Cross28, -Cross28] # X45 # [-Cross3, -Cross3, -Cross3, -Cross3, +Infinity, -Cross3, +Infinity, -Cross3, -Cross3, -Cross3] # X46 # [-Cross73, -Cross73, -Cross73, +Infinity, -Cross73, -Cross73, -Cross73, -Cross73, +Infinity, -Cross73] # X51 # [-Cross24, -Cross24, -Cross24, -Cross24, +Infinity, -Cross24, -Cross24, -Cross24, +Infinity, -Cross24] # X52 # [-Cross87, -Cross87, +Infinity, -Cross87, -Cross87, -Cross87, -Cross87, -Cross87, +Infinity, -Cross87] # X53 # [-Cross15, +Infinity, -Cross15, -Cross15, -Cross15, -Cross15, -Cross15, -Cross15, +Infinity, -Cross15] # X54 # [+Infinity, -Cross76, -Cross76, -Cross76, -Cross76, -Cross76, -Cross76, -Cross76, +Infinity, -Cross76] # X56 # [-Cross48, -Cross48, -Cross48, +Infinity, -Cross48, 0, 0, 0, +Infinity, 0] # X61 # [-Cross45, -Cross45, -Cross45, +Infinity, -Cross45, -Cross45, +Infinity, -Cross45, -Cross45, -Cross45] # X62 # [-Cross110, -Cross110, +Infinity, -Cross110, -Cross110, -Cross110, +Infinity, -Cross110, -Cross110, -Cross110] # X63 # [-Cross37, +Infinity, -Cross37, -Cross37, -Cross37, -Cross37, +Infinity, -Cross37, -Cross37, -Cross37] # X64 # [+Infinity, -Cross123, -Cross123, -Cross123, -Cross123, -Cross123, +Infinity, -Cross123, -Cross123, -Cross123] # X65 # [-Cross48, -Cross48, -Cross48, -Cross48, +Infinity, 0, +Infinity, 0, 0, 0] # Y123456 # [-Cross48, -Cross48, +Infinity, -Cross48, -Cross48, +Infinity, 0, 0, 0, 0] # Y123546 # [-Cross81, -Cross81, +Infinity, -Cross81, -Cross81, +Infinity, -Cross81, -Cross81, -Cross81, -Cross81] # Y123645 # [-Cross97, -Cross97, +Infinity, -Cross97, -Cross97, +Infinity, -Cross97, -Cross97, -Cross97, -Cross97] # Y132456 # [-Cross48, +Infinity, -Cross48, -Cross48, -Cross48, 0, 0, +Infinity, 0, 0] # Y132546 # [-Cross132, +Infinity, -Cross132, -Cross132, -Cross132, -Cross132, -Cross132, +Infinity, -Cross132, -Cross132] # Y132645 # [-Cross117, +Infinity, -Cross117, -Cross117, -Cross117, -Cross117, -Cross117, +Infinity, -Cross117, -Cross117] # Y142356 # [+Infinity, -Cross48, -Cross48, -Cross48, -Cross48, 0, 0, 0, 0, +Infinity] # Y142536 # [+Infinity, -Cross120, -Cross120, -Cross120, -Cross120, -Cross120, -Cross120, -Cross120, -Cross120, +Infinity] # Y142635 # [+Infinity, -Cross12, -Cross12, -Cross12, -Cross12, -Cross12, -Cross12, -Cross12, -Cross12, +Infinity] # Y152346 # [-Cross30, -Cross30, -Cross30, -Cross30, +Infinity, -Cross30, -Cross30, -Cross30, -Cross30, +Infinity] # Y152436 # [-Cross41, -Cross41, -Cross41, -Cross41, +Infinity, -Cross41, -Cross41, +Infinity, -Cross41, -Cross41] # Y152634 # [-Cross54, -Cross54, -Cross54, -Cross54, +Infinity, +Infinity, -Cross54, -Cross54, -Cross54, -Cross54] # Y162345 # [-Cross6, -Cross6, -Cross6, +Infinity, -Cross6, -Cross6, -Cross6, -Cross6, -Cross6, +Infinity] # Y162435 # [-Cross60, -Cross60, -Cross60, +Infinity, -Cross60, -Cross60, -Cross60, +Infinity, -Cross60, -Cross60] # Y162534 # [-Cross69, -Cross69, -Cross69, +Infinity, -Cross69, +Infinity, -Cross69, -Cross69, -Cross69, -Cross69] # G1 # X12 # [0, 0, +Infinity, 0, 0, -Cross9, -Cross9, +Infinity, -Cross9, -Cross9] # X13 # [0, +Infinity, 0, 0, 0, -Cross9, +Infinity, -Cross9, -Cross9, -Cross9] # X14 # [+Infinity, 0, 0, 0, 0, +Infinity, -Cross9, -Cross9, -Cross9, -Cross9] # X15 # [0, 0, 0, 0, +Infinity, -Cross9, -Cross9, -Cross9, -Cross9, +Infinity] # X16 # [0, 0, 0, +Infinity, 0, -Cross9, -Cross9, -Cross9, +Infinity, -Cross9] # X21 # [-Cross0, -Cross0, +Infinity, -Cross0, -Cross0, 0, 0, +Infinity, 0, 0] # X23 # [-Cross105, +Infinity, -Cross105, -Cross105, -Cross105, -Cross105, -Cross105, +Infinity, -Cross105, -Cross105] # X24 # [+Infinity, -Cross21, -Cross21, -Cross21, -Cross21, -Cross21, -Cross21, +Infinity, -Cross21, -Cross21] # X25 # [-Cross93, -Cross93, -Cross93, -Cross93, +Infinity, -Cross93, -Cross93, +Infinity, -Cross93, -Cross93] # X26 # [-Cross63, -Cross63, -Cross63, +Infinity, -Cross63, -Cross63, -Cross63, +Infinity, -Cross63, -Cross63] # X31 # [-Cross0, +Infinity, -Cross0, -Cross0, -Cross0, 0, +Infinity, 0, 0, 0] # X32 # [-Cross84, -Cross84, +Infinity, -Cross84, -Cross84, -Cross84, +Infinity, -Cross84, -Cross84, -Cross84] # X34 # [+Infinity, -Cross102, -Cross102, -Cross102, -Cross102, -Cross102, +Infinity, -Cross102, -Cross102, -Cross102] # X35 # [-Cross90, -Cross90, -Cross90, -Cross90, +Infinity, -Cross90, +Infinity, -Cross90, -Cross90, -Cross90] # X36 # [-Cross99, -Cross99, -Cross99, +Infinity, -Cross99, -Cross99, +Infinity, -Cross99, -Cross99, -Cross99] # X41 # [+Infinity, -Cross0, -Cross0, -Cross0, -Cross0, +Infinity, 0, 0, 0, 0] # X42 # [-Cross126, -Cross126, +Infinity, -Cross126, -Cross126, +Infinity, -Cross126, -Cross126, -Cross126, -Cross126] # X43 # [-Cross28, +Infinity, -Cross28, -Cross28, -Cross28, +Infinity, -Cross28, -Cross28, -Cross28, -Cross28] # X45 # [-Cross3, -Cross3, -Cross3, -Cross3, +Infinity, +Infinity, -Cross3, -Cross3, -Cross3, -Cross3] # X46 # [-Cross73, -Cross73, -Cross73, +Infinity, -Cross73, +Infinity, -Cross73, -Cross73, -Cross73, -Cross73] # X51 # [-Cross0, -Cross0, -Cross0, -Cross0, +Infinity, 0, 0, 0, 0, +Infinity] # X52 # [-Cross87, -Cross87, +Infinity, -Cross87, -Cross87, -Cross87, -Cross87, -Cross87, -Cross87, +Infinity] # X53 # [-Cross15, +Infinity, -Cross15, -Cross15, -Cross15, -Cross15, -Cross15, -Cross15, -Cross15, +Infinity] # X54 # [+Infinity, -Cross76, -Cross76, -Cross76, -Cross76, -Cross76, -Cross76, -Cross76, -Cross76, +Infinity] # X56 # [-Cross66, -Cross66, -Cross66, +Infinity, -Cross66, -Cross66, -Cross66, -Cross66, -Cross66, +Infinity] # X61 # [-Cross0, -Cross0, -Cross0, +Infinity, -Cross0, 0, 0, 0, +Infinity, 0] # X62 # [-Cross110, -Cross110, +Infinity, -Cross110, -Cross110, -Cross110, -Cross110, -Cross110, +Infinity, -Cross110] # X63 # [-Cross37, +Infinity, -Cross37, -Cross37, -Cross37, -Cross37, -Cross37, -Cross37, +Infinity, -Cross37] # X64 # [+Infinity, -Cross123, -Cross123, -Cross123, -Cross123, -Cross123, -Cross123, -Cross123, +Infinity, -Cross123] # X65 # [-Cross51, -Cross51, -Cross51, -Cross51, +Infinity, -Cross51, -Cross51, -Cross51, +Infinity, -Cross51] # Y123456 # [-Cross57, -Cross57, +Infinity, -Cross57, -Cross57, -Cross57, -Cross57, +Infinity, -Cross57, -Cross57] # Y123546 # [-Cross81, -Cross81, +Infinity, -Cross81, -Cross81, -Cross81, -Cross81, +Infinity, -Cross81, -Cross81] # Y123645 # [-Cross97, -Cross97, +Infinity, -Cross97, -Cross97, -Cross97, -Cross97, +Infinity, -Cross97, -Cross97] # Y132456 # [-Cross48, +Infinity, -Cross48, -Cross48, -Cross48, -Cross48, +Infinity, -Cross48, -Cross48, -Cross48] # Y132546 # [-Cross132, +Infinity, -Cross132, -Cross132, -Cross132, -Cross132, +Infinity, -Cross132, -Cross132, -Cross132] # Y132645 # [-Cross117, +Infinity, -Cross117, -Cross117, -Cross117, -Cross117, +Infinity, -Cross117, -Cross117, -Cross117] # Y142356 # [+Infinity, -Cross129, -Cross129, -Cross129, -Cross129, +Infinity, -Cross129, -Cross129, -Cross129, -Cross129] # Y142536 # [+Infinity, -Cross120, -Cross120, -Cross120, -Cross120, +Infinity, -Cross120, -Cross120, -Cross120, -Cross120] # Y142635 # [+Infinity, -Cross12, -Cross12, -Cross12, -Cross12, +Infinity, -Cross12, -Cross12, -Cross12, -Cross12] # Y152346 # [-Cross30, -Cross30, -Cross30, -Cross30, +Infinity, -Cross30, -Cross30, -Cross30, -Cross30, +Infinity] # Y152436 # [-Cross41, -Cross41, -Cross41, -Cross41, +Infinity, -Cross41, -Cross41, -Cross41, -Cross41, +Infinity] # Y152634 # [-Cross54, -Cross54, -Cross54, -Cross54, +Infinity, -Cross54, -Cross54, -Cross54, -Cross54, +Infinity] # Y162345 # [-Cross6, -Cross6, -Cross6, +Infinity, -Cross6, -Cross6, -Cross6, -Cross6, +Infinity, -Cross6] # Y162435 # [-Cross60, -Cross60, -Cross60, +Infinity, -Cross60, -Cross60, -Cross60, -Cross60, +Infinity, -Cross60] # Y162534 # [-Cross69, -Cross69, -Cross69, +Infinity, -Cross69, -Cross69, -Cross69, -Cross69, +Infinity, -Cross69] # G2 # X12 # [0, 0, +Infinity, 0, 0, 0, 0, +Infinity, 0, 0] # X13 # [0, +Infinity, 0, 0, 0, -Cross9, -Cross9, +Infinity, -Cross9, -Cross9] # X14 # [+Infinity, 0, 0, 0, 0, -Cross9, -Cross9, +Infinity, -Cross9, -Cross9] # X15 # [0, 0, 0, 0, +Infinity, -Cross9, -Cross9, +Infinity, -Cross9, -Cross9] # X16 # [0, 0, 0, +Infinity, 0, -Cross9, -Cross9, +Infinity, -Cross9, -Cross9] # X21 # [-Cross114, -Cross114, +Infinity, -Cross114, -Cross114, -Cross114, -Cross114, +Infinity, -Cross114, -Cross114] # X23 # [-Cross105, +Infinity, -Cross105, -Cross105, -Cross105, -Cross105, +Infinity, -Cross105, -Cross105, -Cross105] # X24 # [+Infinity, -Cross21, -Cross21, -Cross21, -Cross21, +Infinity, -Cross21, -Cross21, -Cross21, -Cross21] # X25 # [-Cross93, -Cross93, -Cross93, -Cross93, +Infinity, -Cross93, -Cross93, -Cross93, -Cross93, +Infinity] # X26 # [-Cross63, -Cross63, -Cross63, +Infinity, -Cross63, -Cross63, -Cross63, -Cross63, +Infinity, -Cross63] # X31 # [-Cross0, +Infinity, -Cross0, -Cross0, -Cross0, -Cross0, +Infinity, -Cross0, -Cross0, -Cross0] # X32 # [-Cross9, -Cross9, +Infinity, -Cross9, -Cross9, 0, +Infinity, 0, 0, 0] # X34 # [+Infinity, -Cross102, -Cross102, -Cross102, -Cross102, -Cross102, +Infinity, -Cross102, -Cross102, -Cross102] # X35 # [-Cross90, -Cross90, -Cross90, -Cross90, +Infinity, -Cross90, +Infinity, -Cross90, -Cross90, -Cross90] # X36 # [-Cross99, -Cross99, -Cross99, +Infinity, -Cross99, -Cross99, +Infinity, -Cross99, -Cross99, -Cross99] # X41 # [+Infinity, -Cross18, -Cross18, -Cross18, -Cross18, +Infinity, -Cross18, -Cross18, -Cross18, -Cross18] # X42 # [-Cross9, -Cross9, +Infinity, -Cross9, -Cross9, +Infinity, 0, 0, 0, 0] # X43 # [-Cross28, +Infinity, -Cross28, -Cross28, -Cross28, +Infinity, -Cross28, -Cross28, -Cross28, -Cross28] # X45 # [-Cross3, -Cross3, -Cross3, -Cross3, +Infinity, +Infinity, -Cross3, -Cross3, -Cross3, -Cross3] # X46 # [-Cross73, -Cross73, -Cross73, +Infinity, -Cross73, +Infinity, -Cross73, -Cross73, -Cross73, -Cross73] # X51 # [-Cross24, -Cross24, -Cross24, -Cross24, +Infinity, -Cross24, -Cross24, -Cross24, -Cross24, +Infinity] # X52 # [-Cross9, -Cross9, +Infinity, -Cross9, -Cross9, 0, 0, 0, 0, +Infinity] # X53 # [-Cross15, +Infinity, -Cross15, -Cross15, -Cross15, -Cross15, -Cross15, -Cross15, -Cross15, +Infinity] # X54 # [+Infinity, -Cross76, -Cross76, -Cross76, -Cross76, -Cross76, -Cross76, -Cross76, -Cross76, +Infinity] # X56 # [-Cross66, -Cross66, -Cross66, +Infinity, -Cross66, -Cross66, -Cross66, -Cross66, -Cross66, +Infinity] # X61 # [-Cross45, -Cross45, -Cross45, +Infinity, -Cross45, -Cross45, -Cross45, -Cross45, +Infinity, -Cross45] # X62 # [-Cross9, -Cross9, +Infinity, -Cross9, -Cross9, 0, 0, 0, +Infinity, 0] # X63 # [-Cross37, +Infinity, -Cross37, -Cross37, -Cross37, -Cross37, -Cross37, -Cross37, +Infinity, -Cross37] # X64 # [+Infinity, -Cross123, -Cross123, -Cross123, -Cross123, -Cross123, -Cross123, -Cross123, +Infinity, -Cross123] # X65 # [-Cross51, -Cross51, -Cross51, -Cross51, +Infinity, -Cross51, -Cross51, -Cross51, +Infinity, -Cross51] # Y123456 # [-Cross57, -Cross57, +Infinity, -Cross57, -Cross57, -Cross57, -Cross57, +Infinity, -Cross57, -Cross57] # Y123546 # [-Cross81, -Cross81, +Infinity, -Cross81, -Cross81, -Cross81, -Cross81, +Infinity, -Cross81, -Cross81] # Y123645 # [-Cross97, -Cross97, +Infinity, -Cross97, -Cross97, -Cross97, -Cross97, +Infinity, -Cross97, -Cross97] # Y132456 # [-Cross48, +Infinity, -Cross48, -Cross48, -Cross48, +Infinity, -Cross48, -Cross48, -Cross48, -Cross48] # Y132546 # [-Cross132, +Infinity, -Cross132, -Cross132, -Cross132, -Cross132, -Cross132, -Cross132, -Cross132, +Infinity] # Y132645 # [-Cross117, +Infinity, -Cross117, -Cross117, -Cross117, -Cross117, -Cross117, -Cross117, +Infinity, -Cross117] # Y142356 # [+Infinity, -Cross129, -Cross129, -Cross129, -Cross129, -Cross129, +Infinity, -Cross129, -Cross129, -Cross129] # Y142536 # [+Infinity, -Cross120, -Cross120, -Cross120, -Cross120, -Cross120, -Cross120, -Cross120, -Cross120, +Infinity] # Y142635 # [+Infinity, -Cross12, -Cross12, -Cross12, -Cross12, -Cross12, -Cross12, -Cross12, +Infinity, -Cross12] # Y152346 # [-Cross30, -Cross30, -Cross30, -Cross30, +Infinity, -Cross30, +Infinity, -Cross30, -Cross30, -Cross30] # Y152436 # [-Cross41, -Cross41, -Cross41, -Cross41, +Infinity, +Infinity, -Cross41, -Cross41, -Cross41, -Cross41] # Y152634 # [-Cross54, -Cross54, -Cross54, -Cross54, +Infinity, -Cross54, -Cross54, -Cross54, +Infinity, -Cross54] # Y162345 # [-Cross6, -Cross6, -Cross6, +Infinity, -Cross6, -Cross6, +Infinity, -Cross6, -Cross6, -Cross6] # Y162435 # [-Cross60, -Cross60, -Cross60, +Infinity, -Cross60, +Infinity, -Cross60, -Cross60, -Cross60, -Cross60] # Y162534 # [-Cross69, -Cross69, -Cross69, +Infinity, -Cross69, -Cross69, -Cross69, -Cross69, -Cross69, +Infinity] # G3 # X12 # [0, 0, +Infinity, 0, 0, -Cross9, -Cross9, -Cross9, -Cross9, +Infinity] # X13 # [0, +Infinity, 0, 0, 0, 0, 0, 0, 0, +Infinity] # X14 # [+Infinity, 0, 0, 0, 0, -Cross9, -Cross9, -Cross9, -Cross9, +Infinity] # X15 # [0, 0, 0, 0, +Infinity, -Cross9, -Cross9, -Cross9, -Cross9, +Infinity] # X16 # [0, 0, 0, +Infinity, 0, -Cross9, -Cross9, -Cross9, -Cross9, +Infinity] # X21 # [-Cross114, -Cross114, +Infinity, -Cross114, -Cross114, -Cross114, -Cross114, -Cross114, +Infinity, -Cross114] # X23 # [-Cross9, +Infinity, -Cross9, -Cross9, -Cross9, 0, 0, 0, +Infinity, 0] # X24 # [+Infinity, -Cross21, -Cross21, -Cross21, -Cross21, -Cross21, -Cross21, -Cross21, +Infinity, -Cross21] # X25 # [-Cross93, -Cross93, -Cross93, -Cross93, +Infinity, -Cross93, -Cross93, -Cross93, +Infinity, -Cross93] # X26 # [-Cross63, -Cross63, -Cross63, +Infinity, -Cross63, -Cross63, -Cross63, -Cross63, +Infinity, -Cross63] # X31 # [-Cross0, +Infinity, -Cross0, -Cross0, -Cross0, -Cross0, -Cross0, -Cross0, -Cross0, +Infinity] # X32 # [-Cross84, -Cross84, +Infinity, -Cross84, -Cross84, -Cross84, -Cross84, -Cross84, +Infinity, -Cross84] # X34 # [+Infinity, -Cross102, -Cross102, -Cross102, -Cross102, +Infinity, -Cross102, -Cross102, -Cross102, -Cross102] # X35 # [-Cross90, -Cross90, -Cross90, -Cross90, +Infinity, -Cross90, -Cross90, +Infinity, -Cross90, -Cross90] # X36 # [-Cross99, -Cross99, -Cross99, +Infinity, -Cross99, -Cross99, +Infinity, -Cross99, -Cross99, -Cross99] # X41 # [+Infinity, -Cross18, -Cross18, -Cross18, -Cross18, +Infinity, -Cross18, -Cross18, -Cross18, -Cross18] # X42 # [-Cross126, -Cross126, +Infinity, -Cross126, -Cross126, +Infinity, -Cross126, -Cross126, -Cross126, -Cross126] # X43 # [-Cross9, +Infinity, -Cross9, -Cross9, -Cross9, +Infinity, 0, 0, 0, 0] # X45 # [-Cross3, -Cross3, -Cross3, -Cross3, +Infinity, +Infinity, -Cross3, -Cross3, -Cross3, -Cross3] # X46 # [-Cross73, -Cross73, -Cross73, +Infinity, -Cross73, +Infinity, -Cross73, -Cross73, -Cross73, -Cross73] # X51 # [-Cross24, -Cross24, -Cross24, -Cross24, +Infinity, -Cross24, -Cross24, +Infinity, -Cross24, -Cross24] # X52 # [-Cross87, -Cross87, +Infinity, -Cross87, -Cross87, -Cross87, -Cross87, +Infinity, -Cross87, -Cross87] # X53 # [-Cross9, +Infinity, -Cross9, -Cross9, -Cross9, 0, 0, +Infinity, 0, 0] # X54 # [+Infinity, -Cross76, -Cross76, -Cross76, -Cross76, -Cross76, -Cross76, +Infinity, -Cross76, -Cross76] # X56 # [-Cross66, -Cross66, -Cross66, +Infinity, -Cross66, -Cross66, -Cross66, +Infinity, -Cross66, -Cross66] # X61 # [-Cross45, -Cross45, -Cross45, +Infinity, -Cross45, -Cross45, +Infinity, -Cross45, -Cross45, -Cross45] # X62 # [-Cross110, -Cross110, +Infinity, -Cross110, -Cross110, -Cross110, +Infinity, -Cross110, -Cross110, -Cross110] # X63 # [-Cross9, +Infinity, -Cross9, -Cross9, -Cross9, 0, +Infinity, 0, 0, 0] # X64 # [+Infinity, -Cross123, -Cross123, -Cross123, -Cross123, -Cross123, +Infinity, -Cross123, -Cross123, -Cross123] # X65 # [-Cross51, -Cross51, -Cross51, -Cross51, +Infinity, -Cross51, +Infinity, -Cross51, -Cross51, -Cross51] # Y123456 # [-Cross57, -Cross57, +Infinity, -Cross57, -Cross57, +Infinity, -Cross57, -Cross57, -Cross57, -Cross57] # Y123546 # [-Cross81, -Cross81, +Infinity, -Cross81, -Cross81, -Cross81, -Cross81, +Infinity, -Cross81, -Cross81] # Y123645 # [-Cross97, -Cross97, +Infinity, -Cross97, -Cross97, -Cross97, +Infinity, -Cross97, -Cross97, -Cross97] # Y132456 # [-Cross48, +Infinity, -Cross48, -Cross48, -Cross48, -Cross48, -Cross48, -Cross48, -Cross48, +Infinity] # Y132546 # [-Cross132, +Infinity, -Cross132, -Cross132, -Cross132, -Cross132, -Cross132, -Cross132, -Cross132, +Infinity] # Y132645 # [-Cross117, +Infinity, -Cross117, -Cross117, -Cross117, -Cross117, -Cross117, -Cross117, -Cross117, +Infinity] # Y142356 # [+Infinity, -Cross129, -Cross129, -Cross129, -Cross129, -Cross129, -Cross129, -Cross129, +Infinity, -Cross129] # Y142536 # [+Infinity, -Cross120, -Cross120, -Cross120, -Cross120, -Cross120, +Infinity, -Cross120, -Cross120, -Cross120] # Y142635 # [+Infinity, -Cross12, -Cross12, -Cross12, -Cross12, -Cross12, -Cross12, +Infinity, -Cross12, -Cross12] # Y152346 # [-Cross30, -Cross30, -Cross30, -Cross30, +Infinity, -Cross30, -Cross30, -Cross30, +Infinity, -Cross30] # Y152436 # [-Cross41, -Cross41, -Cross41, -Cross41, +Infinity, -Cross41, +Infinity, -Cross41, -Cross41, -Cross41] # Y152634 # [-Cross54, -Cross54, -Cross54, -Cross54, +Infinity, +Infinity, -Cross54, -Cross54, -Cross54, -Cross54] # Y162345 # [-Cross6, -Cross6, -Cross6, +Infinity, -Cross6, -Cross6, -Cross6, -Cross6, +Infinity, -Cross6] # Y162435 # [-Cross60, -Cross60, -Cross60, +Infinity, -Cross60, -Cross60, -Cross60, +Infinity, -Cross60, -Cross60] # Y162534 # [-Cross69, -Cross69, -Cross69, +Infinity, -Cross69, +Infinity, -Cross69, -Cross69, -Cross69, -Cross69] # G4 # X12 # [0, 0, +Infinity, 0, 0, -Cross9, -Cross9, -Cross9, -Cross9, +Infinity] # X13 # [0, +Infinity, 0, 0, 0, -Cross9, -Cross9, -Cross9, -Cross9, +Infinity] # X14 # [+Infinity, 0, 0, 0, 0, 0, 0, 0, 0, +Infinity] # X15 # [0, 0, 0, 0, +Infinity, -Cross9, -Cross9, -Cross9, -Cross9, +Infinity] # X16 # [0, 0, 0, +Infinity, 0, -Cross9, -Cross9, -Cross9, -Cross9, +Infinity] # X21 # [-Cross114, -Cross114, +Infinity, -Cross114, -Cross114, -Cross114, -Cross114, +Infinity, -Cross114, -Cross114] # X23 # [-Cross105, +Infinity, -Cross105, -Cross105, -Cross105, -Cross105, -Cross105, +Infinity, -Cross105, -Cross105] # X24 # [+Infinity, -Cross9, -Cross9, -Cross9, -Cross9, 0, 0, +Infinity, 0, 0] # X25 # [-Cross93, -Cross93, -Cross93, -Cross93, +Infinity, -Cross93, -Cross93, +Infinity, -Cross93, -Cross93] # X26 # [-Cross63, -Cross63, -Cross63, +Infinity, -Cross63, -Cross63, -Cross63, +Infinity, -Cross63, -Cross63] # X31 # [-Cross0, +Infinity, -Cross0, -Cross0, -Cross0, +Infinity, -Cross0, -Cross0, -Cross0, -Cross0] # X32 # [-Cross84, -Cross84, +Infinity, -Cross84, -Cross84, +Infinity, -Cross84, -Cross84, -Cross84, -Cross84] # X34 # [+Infinity, -Cross9, -Cross9, -Cross9, -Cross9, +Infinity, 0, 0, 0, 0] # X35 # [-Cross90, -Cross90, -Cross90, -Cross90, +Infinity, +Infinity, -Cross90, -Cross90, -Cross90, -Cross90] # X36 # [-Cross99, -Cross99, -Cross99, +Infinity, -Cross99, +Infinity, -Cross99, -Cross99, -Cross99, -Cross99] # X41 # [+Infinity, -Cross18, -Cross18, -Cross18, -Cross18, -Cross18, -Cross18, -Cross18, -Cross18, +Infinity] # X42 # [-Cross126, -Cross126, +Infinity, -Cross126, -Cross126, -Cross126, -Cross126, +Infinity, -Cross126, -Cross126] # X43 # [-Cross28, +Infinity, -Cross28, -Cross28, -Cross28, +Infinity, -Cross28, -Cross28, -Cross28, -Cross28] # X45 # [-Cross3, -Cross3, -Cross3, -Cross3, +Infinity, -Cross3, -Cross3, -Cross3, +Infinity, -Cross3] # X46 # [-Cross73, -Cross73, -Cross73, +Infinity, -Cross73, -Cross73, +Infinity, -Cross73, -Cross73, -Cross73] # X51 # [-Cross24, -Cross24, -Cross24, -Cross24, +Infinity, -Cross24, -Cross24, -Cross24, +Infinity, -Cross24] # X52 # [-Cross87, -Cross87, +Infinity, -Cross87, -Cross87, -Cross87, -Cross87, -Cross87, +Infinity, -Cross87] # X53 # [-Cross15, +Infinity, -Cross15, -Cross15, -Cross15, -Cross15, -Cross15, -Cross15, +Infinity, -Cross15] # X54 # [+Infinity, -Cross9, -Cross9, -Cross9, -Cross9, 0, 0, 0, +Infinity, 0] # X56 # [-Cross66, -Cross66, -Cross66, +Infinity, -Cross66, -Cross66, -Cross66, -Cross66, +Infinity, -Cross66] # X61 # [-Cross45, -Cross45, -Cross45, +Infinity, -Cross45, -Cross45, +Infinity, -Cross45, -Cross45, -Cross45] # X62 # [-Cross110, -Cross110, +Infinity, -Cross110, -Cross110, -Cross110, +Infinity, -Cross110, -Cross110, -Cross110] # X63 # [-Cross37, +Infinity, -Cross37, -Cross37, -Cross37, -Cross37, +Infinity, -Cross37, -Cross37, -Cross37] # X64 # [+Infinity, -Cross9, -Cross9, -Cross9, -Cross9, 0, +Infinity, 0, 0, 0] # X65 # [-Cross51, -Cross51, -Cross51, -Cross51, +Infinity, -Cross51, +Infinity, -Cross51, -Cross51, -Cross51] # Y123456 # [-Cross57, -Cross57, +Infinity, -Cross57, -Cross57, +Infinity, -Cross57, -Cross57, -Cross57, -Cross57] # Y123546 # [-Cross81, -Cross81, +Infinity, -Cross81, -Cross81, -Cross81, +Infinity, -Cross81, -Cross81, -Cross81] # Y123645 # [-Cross97, -Cross97, +Infinity, -Cross97, -Cross97, -Cross97, -Cross97, -Cross97, +Infinity, -Cross97] # Y132456 # [-Cross48, +Infinity, -Cross48, -Cross48, -Cross48, -Cross48, -Cross48, +Infinity, -Cross48, -Cross48] # Y132546 # [-Cross132, +Infinity, -Cross132, -Cross132, -Cross132, -Cross132, +Infinity, -Cross132, -Cross132, -Cross132] # Y132645 # [-Cross117, +Infinity, -Cross117, -Cross117, -Cross117, -Cross117, -Cross117, -Cross117, +Infinity, -Cross117] # Y142356 # [+Infinity, -Cross129, -Cross129, -Cross129, -Cross129, -Cross129, -Cross129, -Cross129, -Cross129, +Infinity] # Y142536 # [+Infinity, -Cross120, -Cross120, -Cross120, -Cross120, -Cross120, -Cross120, -Cross120, -Cross120, +Infinity] # Y142635 # [+Infinity, -Cross12, -Cross12, -Cross12, -Cross12, -Cross12, -Cross12, -Cross12, -Cross12, +Infinity] # Y152346 # [-Cross30, -Cross30, -Cross30, -Cross30, +Infinity, -Cross30, +Infinity, -Cross30, -Cross30, -Cross30] # Y152436 # [-Cross41, -Cross41, -Cross41, -Cross41, +Infinity, -Cross41, -Cross41, +Infinity, -Cross41, -Cross41] # Y152634 # [-Cross54, -Cross54, -Cross54, -Cross54, +Infinity, +Infinity, -Cross54, -Cross54, -Cross54, -Cross54] # Y162345 # [-Cross6, -Cross6, -Cross6, +Infinity, -Cross6, -Cross6, -Cross6, -Cross6, +Infinity, -Cross6] # Y162435 # [-Cross60, -Cross60, -Cross60, +Infinity, -Cross60, -Cross60, -Cross60, +Infinity, -Cross60, -Cross60] # Y162534 # [-Cross69, -Cross69, -Cross69, +Infinity, -Cross69, +Infinity, -Cross69, -Cross69, -Cross69, -Cross69] # G5 # X12 # [0, 0, +Infinity, 0, 0, -Cross3, -Cross3, -Cross3, +Infinity, -Cross3] # X13 # [0, +Infinity, 0, 0, 0, -Cross3, -Cross3, -Cross3, +Infinity, -Cross3] # X14 # [+Infinity, 0, 0, 0, 0, -Cross3, -Cross3, -Cross3, +Infinity, -Cross3] # X15 # [0, 0, 0, 0, +Infinity, 0, 0, 0, +Infinity, 0] # X16 # [0, 0, 0, +Infinity, 0, -Cross3, -Cross3, -Cross3, +Infinity, -Cross3] # X21 # [-Cross114, -Cross114, +Infinity, -Cross114, -Cross114, -Cross114, -Cross114, -Cross114, -Cross114, +Infinity] # X23 # [-Cross105, +Infinity, -Cross105, -Cross105, -Cross105, -Cross105, -Cross105, -Cross105, -Cross105, +Infinity] # X24 # [+Infinity, -Cross21, -Cross21, -Cross21, -Cross21, -Cross21, -Cross21, -Cross21, -Cross21, +Infinity] # X25 # [-Cross3, -Cross3, -Cross3, -Cross3, +Infinity, 0, 0, 0, 0, +Infinity] # X26 # [-Cross63, -Cross63, -Cross63, +Infinity, -Cross63, -Cross63, -Cross63, -Cross63, -Cross63, +Infinity] # X31 # [-Cross0, +Infinity, -Cross0, -Cross0, -Cross0, -Cross0, -Cross0, +Infinity, -Cross0, -Cross0] # X32 # [-Cross84, -Cross84, +Infinity, -Cross84, -Cross84, -Cross84, -Cross84, +Infinity, -Cross84, -Cross84] # X34 # [+Infinity, -Cross102, -Cross102, -Cross102, -Cross102, -Cross102, -Cross102, +Infinity, -Cross102, -Cross102] # X35 # [-Cross3, -Cross3, -Cross3, -Cross3, +Infinity, 0, 0, +Infinity, 0, 0] # X36 # [-Cross99, -Cross99, -Cross99, +Infinity, -Cross99, -Cross99, -Cross99, +Infinity, -Cross99, -Cross99] # X41 # [+Infinity, -Cross18, -Cross18, -Cross18, -Cross18, -Cross18, +Infinity, -Cross18, -Cross18, -Cross18] # X42 # [-Cross126, -Cross126, +Infinity, -Cross126, -Cross126, -Cross126, +Infinity, -Cross126, -Cross126, -Cross126] # X43 # [-Cross28, +Infinity, -Cross28, -Cross28, -Cross28, -Cross28, +Infinity, -Cross28, -Cross28, -Cross28] # X45 # [-Cross3, -Cross3, -Cross3, -Cross3, +Infinity, 0, +Infinity, 0, 0, 0] # X46 # [-Cross73, -Cross73, -Cross73, +Infinity, -Cross73, -Cross73, +Infinity, -Cross73, -Cross73, -Cross73] # X51 # [-Cross24, -Cross24, -Cross24, -Cross24, +Infinity, -Cross24, -Cross24, -Cross24, +Infinity, -Cross24] # X52 # [-Cross87, -Cross87, +Infinity, -Cross87, -Cross87, -Cross87, -Cross87, -Cross87, -Cross87, +Infinity] # X53 # [-Cross15, +Infinity, -Cross15, -Cross15, -Cross15, -Cross15, -Cross15, +Infinity, -Cross15, -Cross15] # X54 # [+Infinity, -Cross76, -Cross76, -Cross76, -Cross76, -Cross76, +Infinity, -Cross76, -Cross76, -Cross76] # X56 # [-Cross66, -Cross66, -Cross66, +Infinity, -Cross66, +Infinity, -Cross66, -Cross66, -Cross66, -Cross66] # X61 # [-Cross45, -Cross45, -Cross45, +Infinity, -Cross45, +Infinity, -Cross45, -Cross45, -Cross45, -Cross45] # X62 # [-Cross110, -Cross110, +Infinity, -Cross110, -Cross110, +Infinity, -Cross110, -Cross110, -Cross110, -Cross110] # X63 # [-Cross37, +Infinity, -Cross37, -Cross37, -Cross37, +Infinity, -Cross37, -Cross37, -Cross37, -Cross37] # X64 # [+Infinity, -Cross123, -Cross123, -Cross123, -Cross123, +Infinity, -Cross123, -Cross123, -Cross123, -Cross123] # X65 # [-Cross3, -Cross3, -Cross3, -Cross3, +Infinity, +Infinity, 0, 0, 0, 0] # Y123456 # [-Cross57, -Cross57, +Infinity, -Cross57, -Cross57, +Infinity, -Cross57, -Cross57, -Cross57, -Cross57] # Y123546 # [-Cross81, -Cross81, +Infinity, -Cross81, -Cross81, -Cross81, -Cross81, +Infinity, -Cross81, -Cross81] # Y123645 # [-Cross97, -Cross97, +Infinity, -Cross97, -Cross97, -Cross97, +Infinity, -Cross97, -Cross97, -Cross97] # Y132456 # [-Cross48, +Infinity, -Cross48, -Cross48, -Cross48, +Infinity, -Cross48, -Cross48, -Cross48, -Cross48] # Y132546 # [-Cross132, +Infinity, -Cross132, -Cross132, -Cross132, -Cross132, -Cross132, -Cross132, -Cross132, +Infinity] # Y132645 # [-Cross117, +Infinity, -Cross117, -Cross117, -Cross117, -Cross117, +Infinity, -Cross117, -Cross117, -Cross117] # Y142356 # [+Infinity, -Cross129, -Cross129, -Cross129, -Cross129, +Infinity, -Cross129, -Cross129, -Cross129, -Cross129] # Y142536 # [+Infinity, -Cross120, -Cross120, -Cross120, -Cross120, -Cross120, -Cross120, -Cross120, -Cross120, +Infinity] # Y142635 # [+Infinity, -Cross12, -Cross12, -Cross12, -Cross12, -Cross12, -Cross12, +Infinity, -Cross12, -Cross12] # Y152346 # [-Cross30, -Cross30, -Cross30, -Cross30, +Infinity, -Cross30, -Cross30, -Cross30, +Infinity, -Cross30] # Y152436 # [-Cross41, -Cross41, -Cross41, -Cross41, +Infinity, -Cross41, -Cross41, -Cross41, +Infinity, -Cross41] # Y152634 # [-Cross54, -Cross54, -Cross54, -Cross54, +Infinity, -Cross54, -Cross54, -Cross54, +Infinity, -Cross54] # Y162345 # [-Cross6, -Cross6, -Cross6, +Infinity, -Cross6, -Cross6, +Infinity, -Cross6, -Cross6, -Cross6] # Y162435 # [-Cross60, -Cross60, -Cross60, +Infinity, -Cross60, -Cross60, -Cross60, +Infinity, -Cross60, -Cross60] # Y162534 # [-Cross69, -Cross69, -Cross69, +Infinity, -Cross69, -Cross69, -Cross69, -Cross69, -Cross69, +Infinity] # G6 # X12 # [0, 0, +Infinity, 0, 0, -Cross9, -Cross9, -Cross9, -Cross9, +Infinity] # X13 # [0, +Infinity, 0, 0, 0, -Cross9, -Cross9, -Cross9, -Cross9, +Infinity] # X14 # [+Infinity, 0, 0, 0, 0, -Cross9, -Cross9, -Cross9, -Cross9, +Infinity] # X15 # [0, 0, 0, 0, +Infinity, -Cross9, -Cross9, -Cross9, -Cross9, +Infinity] # X16 # [0, 0, 0, +Infinity, 0, 0, 0, 0, 0, +Infinity] # X21 # [-Cross114, -Cross114, +Infinity, -Cross114, -Cross114, -Cross114, -Cross114, -Cross114, +Infinity, -Cross114] # X23 # [-Cross105, +Infinity, -Cross105, -Cross105, -Cross105, -Cross105, -Cross105, -Cross105, +Infinity, -Cross105] # X24 # [+Infinity, -Cross21, -Cross21, -Cross21, -Cross21, -Cross21, -Cross21, -Cross21, +Infinity, -Cross21] # X25 # [-Cross93, -Cross93, -Cross93, -Cross93, +Infinity, -Cross93, -Cross93, -Cross93, +Infinity, -Cross93] # X26 # [-Cross9, -Cross9, -Cross9, +Infinity, -Cross9, 0, 0, 0, +Infinity, 0] # X31 # [-Cross0, +Infinity, -Cross0, -Cross0, -Cross0, -Cross0, -Cross0, +Infinity, -Cross0, -Cross0] # X32 # [-Cross84, -Cross84, +Infinity, -Cross84, -Cross84, -Cross84, -Cross84, +Infinity, -Cross84, -Cross84] # X34 # [+Infinity, -Cross102, -Cross102, -Cross102, -Cross102, -Cross102, -Cross102, +Infinity, -Cross102, -Cross102] # X35 # [-Cross90, -Cross90, -Cross90, -Cross90, +Infinity, -Cross90, -Cross90, +Infinity, -Cross90, -Cross90] # X36 # [-Cross9, -Cross9, -Cross9, +Infinity, -Cross9, 0, 0, +Infinity, 0, 0] # X41 # [+Infinity, -Cross18, -Cross18, -Cross18, -Cross18, -Cross18, +Infinity, -Cross18, -Cross18, -Cross18] # X42 # [-Cross126, -Cross126, +Infinity, -Cross126, -Cross126, -Cross126, +Infinity, -Cross126, -Cross126, -Cross126] # X43 # [-Cross28, +Infinity, -Cross28, -Cross28, -Cross28, -Cross28, +Infinity, -Cross28, -Cross28, -Cross28] # X45 # [-Cross3, -Cross3, -Cross3, -Cross3, +Infinity, -Cross3, +Infinity, -Cross3, -Cross3, -Cross3] # X46 # [-Cross9, -Cross9, -Cross9, +Infinity, -Cross9, 0, +Infinity, 0, 0, 0] # X51 # [-Cross24, -Cross24, -Cross24, -Cross24, +Infinity, +Infinity, -Cross24, -Cross24, -Cross24, -Cross24] # X52 # [-Cross87, -Cross87, +Infinity, -Cross87, -Cross87, +Infinity, -Cross87, -Cross87, -Cross87, -Cross87] # X53 # [-Cross15, +Infinity, -Cross15, -Cross15, -Cross15, +Infinity, -Cross15, -Cross15, -Cross15, -Cross15] # X54 # [+Infinity, -Cross76, -Cross76, -Cross76, -Cross76, +Infinity, -Cross76, -Cross76, -Cross76, -Cross76] # X56 # [-Cross9, -Cross9, -Cross9, +Infinity, -Cross9, +Infinity, 0, 0, 0, 0] # X61 # [-Cross45, -Cross45, -Cross45, +Infinity, -Cross45, -Cross45, -Cross45, -Cross45, -Cross45, +Infinity] # X62 # [-Cross110, -Cross110, +Infinity, -Cross110, -Cross110, -Cross110, -Cross110, -Cross110, +Infinity, -Cross110] # X63 # [-Cross37, +Infinity, -Cross37, -Cross37, -Cross37, -Cross37, -Cross37, +Infinity, -Cross37, -Cross37] # X64 # [+Infinity, -Cross123, -Cross123, -Cross123, -Cross123, -Cross123, +Infinity, -Cross123, -Cross123, -Cross123] # X65 # [-Cross51, -Cross51, -Cross51, -Cross51, +Infinity, +Infinity, -Cross51, -Cross51, -Cross51, -Cross51] # Y123456 # [-Cross57, -Cross57, +Infinity, -Cross57, -Cross57, +Infinity, -Cross57, -Cross57, -Cross57, -Cross57] # Y123546 # [-Cross81, -Cross81, +Infinity, -Cross81, -Cross81, -Cross81, +Infinity, -Cross81, -Cross81, -Cross81] # Y123645 # [-Cross97, -Cross97, +Infinity, -Cross97, -Cross97, -Cross97, -Cross97, +Infinity, -Cross97, -Cross97] # Y132456 # [-Cross48, +Infinity, -Cross48, -Cross48, -Cross48, +Infinity, -Cross48, -Cross48, -Cross48, -Cross48] # Y132546 # [-Cross132, +Infinity, -Cross132, -Cross132, -Cross132, -Cross132, +Infinity, -Cross132, -Cross132, -Cross132] # Y132645 # [-Cross117, +Infinity, -Cross117, -Cross117, -Cross117, -Cross117, -Cross117, -Cross117, +Infinity, -Cross117] # Y142356 # [+Infinity, -Cross129, -Cross129, -Cross129, -Cross129, +Infinity, -Cross129, -Cross129, -Cross129, -Cross129] # Y142536 # [+Infinity, -Cross120, -Cross120, -Cross120, -Cross120, -Cross120, -Cross120, +Infinity, -Cross120, -Cross120] # Y142635 # [+Infinity, -Cross12, -Cross12, -Cross12, -Cross12, -Cross12, -Cross12, -Cross12, +Infinity, -Cross12] # Y152346 # [-Cross30, -Cross30, -Cross30, -Cross30, +Infinity, -Cross30, +Infinity, -Cross30, -Cross30, -Cross30] # Y152436 # [-Cross41, -Cross41, -Cross41, -Cross41, +Infinity, -Cross41, -Cross41, +Infinity, -Cross41, -Cross41] # Y152634 # [-Cross54, -Cross54, -Cross54, -Cross54, +Infinity, -Cross54, -Cross54, -Cross54, +Infinity, -Cross54] # Y162345 # [-Cross6, -Cross6, -Cross6, +Infinity, -Cross6, -Cross6, -Cross6, -Cross6, -Cross6, +Infinity] # Y162435 # [-Cross60, -Cross60, -Cross60, +Infinity, -Cross60, -Cross60, -Cross60, -Cross60, -Cross60, +Infinity] # Y162534 # [-Cross69, -Cross69, -Cross69, +Infinity, -Cross69, -Cross69, -Cross69, -Cross69, -Cross69, +Infinity] ############################################ # Finding bad minors for each 10x45 matrix # ############################################ # We start by loading the block of infinity coordinates. The values are tuples of lists of numbers (corresponding to the columns, labelled from X12 to Y162534) InfinityBlocks = load('../../TropicalConvexHulls/Scripts/Input/infinityBlocksIndicesPerExtremal.sobj') # The first entry of the tuples is the list of anticanonical coordinates that vanish on the extremal curve and its the same for all values in this dictionary. We convert it from numbers to anticanonical triangles InfinityBlockEntriesFirst = {extremal: [keys[x] for x in InfinityBlocks[extremal].values()[0][0]] for extremal in extremalCurves} # Our goal is to find non-singular tropical 4x4 minores on each matrix. The minors must involve rows from both blocks ([0,...,4] and [5,...,9]). We show that a necessary condition for lifting is that all 9 or 10 relevant Cross functions for each pair (E1,C) have valuation 0. We do so by restricting our search of bad minors to the 10x10 matrix with columns involving the 5 anticanonical coordinates vanishing along E1 and C. To put things in orderly fashion, we use the anticanonical coordinates to label rows, and the boundary points will be columns. build10x10E1C = dict() for extremal in extremalCurves[1:]: print extremal coordsToPick = InfinityBlockEntriesFirst[E1] + InfinityBlockEntriesFirst[extremal] newMatrix = [] for key in InfinityBlockEntriesFirst[E1]: newRow = [tenBoundaryPoints[extremal][k][key] for k in range(0,10)] newMatrix.append(newRow) for key in InfinityBlockEntriesFirst[extremal]: newRow = [tenBoundaryPoints[extremal][k][key] for k in range(0,10)] newMatrix.append(newRow) build10x10E1C[extremal] = newMatrix # We proceed as follows: # 1) We compute the columns of the 10x45 matrix, and the common factors # 2) We pull out the factors. This will be the give the translation point. def extractingTranslationv2(extremal, build10x45E1Pairs): dict_cols = dict() nonInf = dict() shiftPt = dict() tenx45E1Extremal=build10x45E1Pairs[extremal].transpose() moreThanOne=dict() for x in range(0,tenx45E1Extremal.nrows()): print x dict_cols[x] = [tenx45E1Extremal[x][k] for k in range(0,tenx45E1Extremal.ncols())] # We compute the factors but must separate the case when an entry equals 0. nonInf[x] = [YCRing(dict_cols[x][k]).monomials() for k in range(0,len(dict_cols[x])) if dict_cols[x][k]!=+Infinity if dict_cols[x][k] != 0] + [[0] for k in range(0,len(dict_cols[x])) if dict_cols[x][k]!=+Infinity if dict_cols[x][k] == 0] if all([bool(len(p) == 1) for p in nonInf[x]]) == True: candidate = list(set([p[0] for p in nonInf[x]])) # Every row has one Infinity entry. The rest are either 0 and -Crossi, or just -Crossi. We only want to extract the one where we have one non-'+Infinity' entry. if len(candidate) == 1: # we pick the sign by looking at the original entries: shiftPt[x] = [SR(tenx45E1Extremal[x][k]) for k in range(0,len(dict_cols[x])) if dict_cols[x][k]!=+Infinity][0] else: print 'we have a problem!' shiftPt[x] = SR(0) if all([bool(len(p) == 2) for p in nonInf[x]]) == True: # We record the entries: moreThanOne[x] = NonInf[x] # We do not assign a shift: shiftPt[x] = SR(0) # Now that we have the shift, we can go back and change the matrix: newTropLink = [] for x in range(0,tenx45E1Extremal.nrows()): newRow =[] for k in range(0,tenx45E1Extremal.ncols()): if tenx45E1Extremal[x][k] != +Infinity: newRow.append(SR(tenx45E1Extremal[x][k]) - shiftPt[x]) else: newRow.append(SR(tenx45E1Extremal[x][k])) newTropLink.append(newRow) if moreThanOne !=dict(): print 'we have a bad row!' return (newTropLink, shiftPt) # Since after shifting most rows are 0/Infinity rows, it would be useful to only remember the distinct ones. The following function records the distinct rows of the shifted matrix and the row numbers with that value. # ListMatrix = the shifted matrix is recorded as a list of lists def collectDistinctRowValuesAndKeys(ListMatrix): allRows = [] allIndices = dict() for k in range(0,len(ListMatrix)): newRow = ListMatrix[k] if newRow not in allRows: allRows.append(newRow) allIndices[tuple(newRow)] = [k] else: allIndices[tuple(newRow)].append(k) return (allRows, allIndices) # We record the anticanonical coordinates corresponding to the rows of the matrix of shifted 10 boundary points with no repeated rows) # noRepeatedRows = matrix with no repeated rows. # rowsDict = row numbers in the original shifted 10x45 matrix with the same value for row. # anticKeys = list of anticanonical triangles in increasing lexicographic order ('keys') def findingAnticKeysForDistinctRows(noRepeatedRows, rowsDict, anticKeys): anticKeysForRows = dict() for k in range(0,len(noRepeatedRows)): anticKeysForRows[k] = [anticKeys[j] for j in rowsDict[tuple(noRepeatedRows[k])]] return anticKeysForRows ########################## # Non-Intersecting pairs # ########################## # For non-intersecting pairs, the shape of the 10x45 matrix is such that the only potential non-singular 4x4 minors arise from the 10 columns coming from the labeling extremal curves. # Even though for the non-intersecting intersecting pairs, the 10x10 matrix provides non-singular 4x4 minor, we want to look at the full matrices to get an insight into the minors to search for in the classical matrix. # build10x45E1NonIntersectingPairs = dict() # for extremal in extremalCurves[1:]: # if extremal not in [F12,F13, F14, F15, F16, G2, G3, G4, G5, G6]: # newMatrix = [] # print extremal # for k in range(0,5): # print k # newRow = [SR(unshiftedTropLInkExtremal[E1][k][key]).substitute(PairsOfExtremalsWithE1AndCrossDict[extremal]) for key in unshiftedTropLInkExtremal[E1][k].keys()] # newMatrix.append(newRow) # for k in range(0,5): # print k+5 # newRow = [SR(unshiftedTropLInkExtremal[extremal][k][key]).substitute(PairsOfExtremalsWithE1AndCrossDict[extremal]) for key in unshiftedTropLInkExtremal[extremal][k].keys()] # newMatrix.append(newRow) # build10x45E1NonIntersectingPairs[extremal] = matrix(SR,newMatrix) # save(build10x45E1NonIntersectingPairs, 'Input/build10x45E1NonIntersectingPairs.sobj') build10x45E1NonIntersectingPairs = load('Input/build10x45E1NonIntersectingPairs.sobj') # The next function replaces terms on entries of a matrix (given as a list of lists) using a dictionary 'dictCross' def replacingCrossesWith0(matrixList,dictCross): newMatrixList = [] for x in range(0,len(matrixList)): newrow = [] for y in range(0,len(matrixList[x])): newrow.append(SR(matrixList[x][y]).substitute(dictCross)) newMatrixList.append(newrow) return newMatrixList # anticRowKeys = dict() ################ # (E1,E2) pair # ################ extremal = E2 InfinityBlockEntriesFirst[E1] [X12, X13, X14, X15, X16] InfinityBlockEntriesFirst[extremal] [X21, X23, X24, X25, X26] # We build the matrix and transpose it matrixPair = matrix(SR,[build10x10E1C[extremal][k] for k in range(0,10)]).transpose() # print matrixPair # [ 0 0 +Infinity 0 0 -Cross9 -Cross9 +Infinity -Cross9 -Cross9] # [ 0 +Infinity 0 0 0 -Cross9 +Infinity -Cross9 -Cross9 -Cross9] # [+Infinity 0 0 0 0 +Infinity -Cross9 -Cross9 -Cross9 -Cross9] # [ 0 0 0 0 +Infinity -Cross9 -Cross9 -Cross9 -Cross9 +Infinity] # [ 0 0 0 +Infinity 0 -Cross9 -Cross9 -Cross9 +Infinity -Cross9] # [ -Cross21 -Cross21 +Infinity -Cross21 -Cross21 0 0 +Infinity 0 0] # [ -Cross21 +Infinity -Cross21 -Cross21 -Cross21 0 +Infinity 0 0 0] # [+Infinity -Cross21 -Cross21 -Cross21 -Cross21 +Infinity 0 0 0 0] # [ -Cross21 -Cross21 -Cross21 -Cross21 +Infinity 0 0 0 0 +Infinity] # [ -Cross21 -Cross21 -Cross21 +Infinity -Cross21 0 0 0 +Infinity 0] rows = [1,2,6,7] cols = [0,1,5,6] minorPair = matrixPair.matrix_from_rows_and_columns(rows,cols) # minorPair # [ 0 +Infinity -Cross9 +Infinity] # [+Infinity 0 +Infinity -Cross9] # [ -Cross21 +Infinity 0 +Infinity] # [+Infinity -Cross21 +Infinity 0] # trop_minor = min('Infinity',0,-Cross21-Cross9, -Cross21-Cross9, 2*(-Cross21-Cross9)) # CONCLUDE: singular iff v(Cross9) = v(Cross21) = 0 dictCross = {SR(Cross9):0, SR(Cross21):0} # We look at the 45x10 matrix and extract the shift (newMatrix, newShift) = extractingTranslationv2(extremal, build10x45E1NonIntersectingPairs) # Next, we replace the Cross functions appearing on the matrix by 0, since we know their valuation. subsNewMatrix = replacingCrossesWith0(newMatrix,dictCross) # The rows are ordered from x12, ..., y162534 # sorted(list(set([subsNewMatrix[x][k] for x in range(0,len(subsNewMatrix)) for k in range(0, len(subsNewMatrix[x]))]))) # [0, +Infinity] # print newShift.values() # [-Cross0, -Cross3, 0, 0, -Cross12, -Cross90, -Cross18, 0, -Cross97, -Cross24, -Cross28, -Cross132, 0, -Cross37, -Cross41, 0, -Cross45, -Cross48, -Cross51, -Cross54, -Cross57, -Cross6, -Cross66, -Cross69, -Cross73, -Cross76, 0, -Cross81, -Cross84, -Cross102, -Cross15, 0, -Cross60, -Cross99, -Cross87, 0, -Cross110, 0, 0, -Cross117, -Cross120, -Cross123, -Cross126, -Cross129, -Cross30] # [k for k in newShift.keys() if newShift[k] == SR(0)] # [2, 3, 7, 12, 15, 26, 31, 35, 37, 38] (noRepeatedRows, rowsDict) = collectDistinctRowValuesAndKeys(subsNewMatrix) # noRepeatedRows # [[0, +Infinity, 0, 0, 0, 0, 0, +Infinity, 0, 0], # [0, 0, 0, 0, +Infinity, 0, 0, 0, 0, +Infinity], # [0, 0, 0, +Infinity, 0, 0, 0, 0, +Infinity, 0], # [0, 0, +Infinity, 0, 0, 0, 0, +Infinity, 0, 0], # [+Infinity, 0, 0, 0, 0, 0, 0, 0, +Infinity, 0], # [+Infinity, 0, 0, 0, 0, 0, 0, +Infinity, 0, 0], # [+Infinity, 0, 0, 0, 0, +Infinity, 0, 0, 0, 0], # [0, 0, 0, 0, +Infinity, 0, 0, +Infinity, 0, 0], # [0, +Infinity, 0, 0, 0, 0, +Infinity, 0, 0, 0], # [0, +Infinity, 0, 0, 0, 0, 0, 0, 0, +Infinity], # [0, 0, 0, 0, +Infinity, +Infinity, 0, 0, 0, 0], # [0, 0, 0, +Infinity, 0, 0, 0, +Infinity, 0, 0], # [0, +Infinity, 0, 0, 0, +Infinity, 0, 0, 0, 0], # [0, 0, 0, 0, +Infinity, 0, 0, 0, +Infinity, 0], # [0, 0, 0, +Infinity, 0, 0, +Infinity, 0, 0, 0], # [0, 0, 0, +Infinity, 0, 0, 0, 0, 0, +Infinity], # [0, 0, +Infinity, 0, 0, 0, +Infinity, 0, 0, 0], # [0, 0, 0, +Infinity, 0, +Infinity, 0, 0, 0, 0], # [0, 0, +Infinity, 0, 0, 0, 0, 0, 0, +Infinity], # [0, 0, +Infinity, 0, 0, 0, 0, 0, +Infinity, 0], # [0, +Infinity, 0, 0, 0, 0, 0, 0, +Infinity, 0], # [+Infinity, 0, 0, 0, 0, 0, 0, 0, 0, +Infinity], # [0, 0, +Infinity, 0, 0, +Infinity, 0, 0, 0, 0], # [+Infinity, 0, 0, 0, 0, 0, +Infinity, 0, 0, 0], # [0, 0, 0, 0, +Infinity, 0, +Infinity, 0, 0, 0]] # We find a non-singular 3x3 minor: # matrix(SR, noRepeatedRows).matrix_from_rows_and_columns([10,11,24],[3,4,5]) # [ 0 +Infinity +Infinity] # [+Infinity 0 0] # [+Infinity 0 +Infinity] anticRowKeys[extremal] = findingAnticKeysForDistinctRows(noRepeatedRows, rowsDict, keys) # print anticRowKeys[extremal] # {0: [X12], 1: [X13, X21, X45, Y123546, Y142536], 2: [X14, X34, X53, X56, Y132456], 3: [X15, X25, X51, X63, Y142635], 4: [X16], 5: [X23], 6: [X24, X41, X61, X65, Y152634], 7: [X26], 8: [X31, X35, X62, Y123456, Y132645], 9: [X32], 10: [X36], 11: [X42], 12: [X43], 13: [X46], 14: [X52], 15: [X54], 16: [X64], 17: [Y123645], 18: [Y132546], 19: [Y142356], 20: [Y152346], 21: [Y152436], 22: [Y162345], 23: [Y162435], 24: [Y162534]} ################ # (E1,E3) pair # ################ extremal = E3 InfinityBlockEntriesFirst[E1] [X12, X13, X14, X15, X16] InfinityBlockEntriesFirst[extremal] [X31, X32, X34, X35, X36] # We build the matrix and transpose it matrixPair = matrix(SR,[build10x10E1C[extremal][k] for k in range(0,10)]).transpose() # print matrixPair # [ 0 0 +Infinity 0 0 -Cross0 -Cross0 +Infinity -Cross0 -Cross0] # [ 0 +Infinity 0 0 0 +Infinity -Cross0 -Cross0 -Cross0 -Cross0] # [+Infinity 0 0 0 0 -Cross0 +Infinity -Cross0 -Cross0 -Cross0] # [ 0 0 0 0 +Infinity -Cross0 -Cross0 -Cross0 -Cross0 +Infinity] # [ 0 0 0 +Infinity 0 -Cross0 -Cross0 -Cross0 +Infinity -Cross0] # [ -Cross9 -Cross9 -Cross9 -Cross9 +Infinity 0 0 0 0 +Infinity] # [ -Cross9 -Cross9 +Infinity -Cross9 -Cross9 0 0 +Infinity 0 0] # [ -Cross9 -Cross9 -Cross9 +Infinity -Cross9 0 0 0 +Infinity 0] # [ -Cross9 +Infinity -Cross9 -Cross9 -Cross9 +Infinity 0 0 0 0] # [+Infinity -Cross9 -Cross9 -Cross9 -Cross9 0 +Infinity 0 0 0] rows = [0,1,6,8] cols= [1,2,5,7] minorPair = matrixPair.matrix_from_rows_and_columns(rows,cols) # minorPair # [ 0 +Infinity -Cross0 +Infinity] # [+Infinity 0 +Infinity -Cross0] # [ -Cross9 +Infinity 0 +Infinity] # [+Infinity -Cross9 +Infinity 0] # trop_minor = min('Infinity',0,-Cross0-Cross9, -Cross0-Cross9, 2*(-Cross0-Cross9)) # CONCLUDE: singular iff v(Cross9) = v(Cross0) = 0 dictCross = {SR(Cross9):0, SR(Cross0):0} # We look at the 45x10 matrix and extract the shift (newMatrix, newShift) = extractingTranslationv2(extremal, build10x45E1NonIntersectingPairs) # Next, we replace the Cross functions appearing on the matrix by 0, since we know their valuation. subsNewMatrix = replacingCrossesWith0(newMatrix,dictCross) # The rows are ordered from x12, ..., y162534 # sorted(list(set([subsNewMatrix[x][k] for x in range(0,len(subsNewMatrix)) for k in range(0, len(subsNewMatrix[x]))]))) # [0, +Infinity] # print newShift.values() # [0, -Cross3, -Cross63, 0, -Cross12, 0, -Cross18, -Cross21, -Cross97, -Cross24, -Cross28, -Cross132, 0, -Cross37, -Cross41, 0, -Cross45, -Cross48, -Cross51, -Cross54, -Cross57, -Cross6, -Cross66, -Cross69, -Cross73, -Cross76, 0, -Cross81, 0, 0, -Cross15, -Cross93, -Cross60, 0, -Cross87, -Cross105, -Cross110, 0, -Cross114, -Cross117, -Cross120, -Cross123, -Cross126, -Cross129, -Cross30] # [k for k in newShift.keys() if newShift[k] == SR(0)] # [0, 3, 5, 12, 15, 26, 28, 29, 33, 37] (noRepeatedRows, rowsDict) = collectDistinctRowValuesAndKeys(subsNewMatrix) # noRepeatedRows # [[0, +Infinity, 0, 0, 0, 0, 0, 0, +Infinity, 0], # [0, 0, 0, 0, +Infinity, 0, 0, +Infinity, 0, 0], # [0, 0, 0, +Infinity, 0, +Infinity, 0, 0, 0, 0], # [0, 0, +Infinity, 0, 0, 0, 0, 0, 0, +Infinity], # [+Infinity, 0, 0, 0, 0, 0, 0, +Infinity, 0, 0], # [+Infinity, 0, 0, 0, 0, 0, 0, 0, +Infinity, 0], # [+Infinity, 0, 0, 0, 0, 0, +Infinity, 0, 0, 0], # [0, 0, +Infinity, 0, 0, +Infinity, 0, 0, 0, 0], # [0, 0, 0, 0, +Infinity, 0, 0, 0, +Infinity, 0], # [0, +Infinity, 0, 0, 0, 0, +Infinity, 0, 0, 0], # [0, +Infinity, 0, 0, 0, +Infinity, 0, 0, 0, 0], # [0, 0, 0, 0, +Infinity, +Infinity, 0, 0, 0, 0], # [0, 0, 0, +Infinity, 0, 0, 0, 0, +Infinity, 0], # [0, 0, 0, 0, +Infinity, 0, +Infinity, 0, 0, 0], # [0, 0, +Infinity, 0, 0, 0, +Infinity, 0, 0, 0], # [0, 0, 0, +Infinity, 0, 0, 0, 0, 0, +Infinity], # [0, 0, 0, +Infinity, 0, 0, +Infinity, 0, 0, 0], # [0, 0, +Infinity, 0, 0, 0, 0, +Infinity, 0, 0], # [0, +Infinity, 0, 0, 0, 0, 0, +Infinity, 0, 0], # [0, 0, 0, +Infinity, 0, 0, 0, +Infinity, 0, 0], # [0, +Infinity, 0, 0, 0, 0, 0, 0, 0, +Infinity], # [0, 0, +Infinity, 0, 0, 0, 0, 0, +Infinity, 0], # [+Infinity, 0, 0, 0, 0, +Infinity, 0, 0, 0, 0], # [+Infinity, 0, 0, 0, 0, 0, 0, 0, 0, +Infinity], # [0, 0, 0, 0, +Infinity, 0, 0, 0, 0, +Infinity]] # We find a non-singular 3x3 minor: # matrix(SR, noRepeatedRows).matrix_from_rows_and_columns([2,11,12],[3,4,5]) # [+Infinity 0 +Infinity] # [ 0 +Infinity +Infinity] # [+Infinity 0 0] anticRowKeys[extremal] = findingAnticKeysForDistinctRows(noRepeatedRows, rowsDict, keys) # print anticRowKeys[extremal] # {0: [X12, X32, X43, X62, Y152346], 1: [X13, X21, X45, Y123546, Y142536], 2: [X14, X34, X53, X56, Y132456], 3: [X15, X64, Y132546, Y142356, Y162345], 4: [X16], 5: [X23], 6: [X24, X41, X61, X65, Y152634], 7: [X25], 8: [X26], 9: [X31], 10: [X35], 11: [X36], 12: [X42], 13: [X46], 14: [X51], 15: [X52], 16: [X54], 17: [X63], 18: [Y123456], 19: [Y123645], 20: [Y132645], 21: [Y142635], 22: [Y152436], 23: [Y162435], 24: [Y162534]} ################ # (E1,E4) pair # ################ extremal = E4 InfinityBlockEntriesFirst[E1] [X12, X13, X14, X15, X16] InfinityBlockEntriesFirst[extremal] [X41, X42, X43, X45, X46] # We build the matrix and transpose it matrixPair = matrix(SR,[build10x10E1C[extremal][k] for k in range(0,10)]).transpose() # print matrixPair # [ 0 0 +Infinity 0 0 +Infinity -Cross3 -Cross3 -Cross3 -Cross3] # [ 0 +Infinity 0 0 0 -Cross3 -Cross3 +Infinity -Cross3 -Cross3] # [+Infinity 0 0 0 0 -Cross3 +Infinity -Cross3 -Cross3 -Cross3] # [ 0 0 0 0 +Infinity -Cross3 -Cross3 -Cross3 -Cross3 +Infinity] # [ 0 0 0 +Infinity 0 -Cross3 -Cross3 -Cross3 +Infinity -Cross3] # [ -Cross9 +Infinity -Cross9 -Cross9 -Cross9 0 0 +Infinity 0 0] # [+Infinity -Cross9 -Cross9 -Cross9 -Cross9 0 +Infinity 0 0 0] # [ -Cross9 -Cross9 -Cross9 -Cross9 +Infinity 0 0 0 0 +Infinity] # [ -Cross9 -Cross9 -Cross9 +Infinity -Cross9 0 0 0 +Infinity 0] # [ -Cross9 -Cross9 +Infinity -Cross9 -Cross9 +Infinity 0 0 0 0] rows = [1,2,5,6] cols= [0,1,6,7] minorPair = matrixPair.matrix_from_rows_and_columns(rows,cols) # minorPair # [ 0 +Infinity -Cross3 +Infinity] # [+Infinity 0 +Infinity -Cross3] # [ -Cross9 +Infinity 0 +Infinity] # [+Infinity -Cross9 +Infinity 0] # trop_minor = min('Infinity',0,-Cross3-Cross9, -Cross3-Cross9, 2*(-Cross3-Cross9)) # CONCLUDE: singular iff v(Cross9) = v(Cross3) = 0 dictCross = {SR(Cross9):0, SR(Cross3):0} # We look at the 45x10 matrix and extract the shift (newMatrix, newShift) = extractingTranslationv2(extremal, build10x45E1NonIntersectingPairs) # Next, we replace the Cross functions appearing on the matrix by 0, since we know their valuation. subsNewMatrix = replacingCrossesWith0(newMatrix,dictCross) # The rows are ordered from x12, ..., y162534 # sorted(list(set([subsNewMatrix[x][k] for x in range(0,len(subsNewMatrix)) for k in range(0, len(subsNewMatrix[x]))]))) [0, +Infinity] # print newShift.values() # [-Cross0, 0, -Cross63, 0, -Cross12, -Cross90, 0, -Cross21, -Cross97, -Cross24, 0, -Cross132, 0, -Cross37, -Cross41, 0, -Cross45, -Cross48, -Cross51, -Cross54, -Cross57, -Cross6, -Cross66, -Cross69, 0, -Cross76, 0, -Cross81, -Cross84, -Cross102, -Cross15, -Cross93, -Cross60, -Cross99, -Cross87, -Cross105, -Cross110, 0, -Cross114, -Cross117, -Cross120, -Cross123, 0, -Cross129, -Cross30] # [k for k in newShift.keys() if newShift[k] == SR(0)] # [1, 3, 6, 10, 12, 15, 24, 26, 37, 42] (noRepeatedRows, rowsDict) = collectDistinctRowValuesAndKeys(subsNewMatrix) # noRepeatedRows # [[0, +Infinity, 0, 0, 0, 0, 0, 0, 0, +Infinity], # [0, 0, 0, 0, +Infinity, 0, 0, 0, +Infinity, 0], # [0, 0, 0, +Infinity, 0, 0, 0, +Infinity, 0, 0], # [0, 0, +Infinity, 0, 0, 0, +Infinity, 0, 0, 0], # [+Infinity, 0, 0, 0, 0, 0, 0, 0, 0, +Infinity], # [+Infinity, 0, 0, 0, 0, 0, +Infinity, 0, 0, 0], # [0, 0, +Infinity, 0, 0, 0, 0, 0, +Infinity, 0], # [0, 0, 0, 0, +Infinity, 0, 0, 0, 0, +Infinity], # [0, +Infinity, 0, 0, 0, +Infinity, 0, 0, 0, 0], # [0, +Infinity, 0, 0, 0, 0, 0, +Infinity, 0, 0], # [0, 0, 0, 0, +Infinity, 0, +Infinity, 0, 0, 0], # [0, 0, 0, +Infinity, 0, 0, 0, 0, 0, +Infinity], # [0, +Infinity, 0, 0, 0, 0, +Infinity, 0, 0, 0], # [0, 0, 0, 0, +Infinity, +Infinity, 0, 0, 0, 0], # [0, 0, +Infinity, 0, 0, +Infinity, 0, 0, 0, 0], # [0, 0, 0, +Infinity, 0, 0, 0, 0, +Infinity, 0], # [0, 0, 0, +Infinity, 0, +Infinity, 0, 0, 0, 0], # [+Infinity, 0, 0, 0, 0, 0, 0, 0, +Infinity, 0], # [0, 0, +Infinity, 0, 0, 0, 0, +Infinity, 0, 0], # [+Infinity, 0, 0, 0, 0, +Infinity, 0, 0, 0, 0], # [0, 0, 0, +Infinity, 0, 0, +Infinity, 0, 0, 0], # [0, 0, +Infinity, 0, 0, 0, 0, 0, 0, +Infinity], # [0, +Infinity, 0, 0, 0, 0, 0, 0, +Infinity, 0], # [+Infinity, 0, 0, 0, 0, 0, 0, +Infinity, 0, 0], # [0, 0, 0, 0, +Infinity, 0, 0, +Infinity, 0, 0]] # By symmetry we can also find a 3x3 non-singular minor here anticRowKeys[extremal] = findingAnticKeysForDistinctRows(noRepeatedRows, rowsDict, keys) # print anticRowKeys[extremal] # {0: [X12], 1: [X13, X21, X45, Y123546, Y142536], 2: [X14, X34, X53, X56, Y132456], 3: [X15, X64, Y132546, Y142356, Y162345], 4: [X16, X23, X41, Y152436, Y162435], 5: [X24], 6: [X25], 7: [X26], 8: [X31, X35, X62, Y123456, Y132645], 9: [X32], 10: [X36], 11: [X42], 12: [X43], 13: [X46], 14: [X51], 15: [X52], 16: [X54], 17: [X61], 18: [X63], 19: [X65], 20: [Y123645], 21: [Y142635], 22: [Y152346], 23: [Y152634], 24: [Y162534]} ################ # (E1,E5) pair # ################ extremal = E5 InfinityBlockEntriesFirst[E1] [X12, X13, X14, X15, X16] InfinityBlockEntriesFirst[extremal] [X51, X52, X53, X54, X56] # We build the matrix and transpose it matrixPair = matrix(SR,[build10x10E1C[extremal][k] for k in range(0,10)]).transpose() # print matrixPair # [ 0 0 +Infinity 0 0 -Cross15 -Cross15 -Cross15 +Infinity -Cross15] # [ 0 +Infinity 0 0 0 -Cross15 -Cross15 +Infinity -Cross15 -Cross15] # [+Infinity 0 0 0 0 -Cross15 +Infinity -Cross15 -Cross15 -Cross15] # [ 0 0 0 0 +Infinity -Cross15 -Cross15 -Cross15 -Cross15 +Infinity] # [ 0 0 0 +Infinity 0 +Infinity -Cross15 -Cross15 -Cross15 -Cross15] # [ -Cross9 -Cross9 -Cross9 -Cross9 +Infinity 0 0 0 0 +Infinity] # [ -Cross9 -Cross9 +Infinity -Cross9 -Cross9 0 0 0 +Infinity 0] # [ -Cross9 +Infinity -Cross9 -Cross9 -Cross9 0 0 +Infinity 0 0] # [ -Cross9 -Cross9 -Cross9 +Infinity -Cross9 +Infinity 0 0 0 0] # [+Infinity -Cross9 -Cross9 -Cross9 -Cross9 0 +Infinity 0 0 0] rows = [0,1,6,7] cols= [1,2,7,8] minorPair = matrixPair.matrix_from_rows_and_columns(rows,cols) # minorPair # [ 0 +Infinity -Cross15 +Infinity] # [+Infinity 0 +Infinity -Cross15] # [ -Cross9 +Infinity 0 +Infinity] # [+Infinity -Cross9 +Infinity 0] # trop_minor = min('Infinity',0,-Cross15-Cross9, -Cross15-Cross9, 2*(-Cross15-Cross9)) # CONCLUDE: singular iff v(Cross9) = v(Cross15) = 0 dictCross = {SR(Cross9):0, SR(Cross15):0} # We look at the 45x10 matrix and extract the shift (newMatrix, newShift) = extractingTranslationv2(extremal, build10x45E1NonIntersectingPairs) # Next, we replace the Cross functions appearing on the matrix by 0, since we know their valuation. subsNewMatrix = replacingCrossesWith0(newMatrix,dictCross) # The rows are ordered from x12, ..., y162534 # sorted(list(set([subsNewMatrix[x][k] for x in range(0,len(subsNewMatrix)) for k in range(0, len(subsNewMatrix[x]))]))) # [0, +Infinity] # print newShift.values() # [-Cross0, -Cross3, -Cross63, 0, -Cross12, -Cross90, -Cross18, -Cross21, -Cross97, 0, -Cross28, -Cross132, 0, -Cross37, -Cross41, 0, -Cross45, -Cross48, -Cross51, -Cross54, -Cross57, -Cross6, 0, -Cross69, -Cross73, 0, 0, -Cross81, -Cross84, -Cross102, 0, -Cross93, -Cross60, -Cross99, 0, -Cross105, -Cross110, 0, -Cross114, -Cross117, -Cross120, -Cross123, -Cross126, -Cross129, -Cross30] # [k for k in newShift.keys() if newShift[k] == SR(0)] # [3, 9, 12, 15, 22, 25, 26, 30, 34, 37] (noRepeatedRows, rowsDict) = collectDistinctRowValuesAndKeys(subsNewMatrix) # noRepeatedRows # [[0, +Infinity, 0, 0, 0, 0, 0, 0, +Infinity, 0], # [0, 0, 0, 0, +Infinity, 0, +Infinity, 0, 0, 0], # [0, 0, 0, +Infinity, 0, +Infinity, 0, 0, 0, 0], # [0, 0, +Infinity, 0, 0, 0, 0, 0, 0, +Infinity], # [+Infinity, 0, 0, 0, 0, 0, 0, +Infinity, 0, 0], # [0, 0, 0, 0, +Infinity, 0, 0, +Infinity, 0, 0], # [+Infinity, 0, 0, 0, 0, 0, 0, 0, +Infinity, 0], # [+Infinity, 0, 0, 0, 0, 0, +Infinity, 0, 0, 0], # [0, 0, +Infinity, 0, 0, 0, +Infinity, 0, 0, 0], # [0, 0, 0, 0, +Infinity, 0, 0, 0, +Infinity, 0], # [0, +Infinity, 0, 0, 0, 0, 0, +Infinity, 0, 0], # [0, +Infinity, 0, 0, 0, 0, 0, 0, 0, +Infinity], # [0, 0, 0, +Infinity, 0, 0, 0, 0, +Infinity, 0], # [0, +Infinity, 0, 0, 0, +Infinity, 0, 0, 0, 0], # [0, 0, 0, 0, +Infinity, +Infinity, 0, 0, 0, 0], # [0, 0, +Infinity, 0, 0, +Infinity, 0, 0, 0, 0], # [0, 0, 0, +Infinity, 0, 0, +Infinity, 0, 0, 0], # [0, 0, 0, +Infinity, 0, 0, 0, 0, 0, +Infinity], # [0, 0, +Infinity, 0, 0, 0, 0, +Infinity, 0, 0], # [0, 0, 0, 0, +Infinity, 0, 0, 0, 0, +Infinity], # [0, 0, 0, +Infinity, 0, 0, 0, +Infinity, 0, 0], # [0, 0, +Infinity, 0, 0, 0, 0, 0, +Infinity, 0], # [0, +Infinity, 0, 0, 0, 0, +Infinity, 0, 0, 0], # [+Infinity, 0, 0, 0, 0, 0, 0, 0, 0, +Infinity], # [+Infinity, 0, 0, 0, 0, +Infinity, 0, 0, 0, 0]] # By symmetry we can also find a 3x3 non-singular minor here anticRowKeys[extremal] = findingAnticKeysForDistinctRows(noRepeatedRows, rowsDict, keys) # print anticRowKeys[extremal] # {0: [X12], 1: [X13], 2: [X14, X34, X53, X56, Y132456], 3: [X15, X64, Y132546, Y142356, Y162345], 4: [X16], 5: [X21], 6: [X23], 7: [X24, X41, X61, X65, Y152634], 8: [X25], 9: [X26, X36, X46, Y142536, Y162534], 10: [X31, X35, X62, Y123456, Y132645], 11: [X32], 12: [X42], 13: [X43], 14: [X45], 15: [X51], 16: [X52], 17: [X54], 18: [X63], 19: [Y123546], 20: [Y123645], 21: [Y142635], 22: [Y152346], 23: [Y152436], 24: [Y162435]} ################ # (E1,E6) pair # ################ extremal = E6 InfinityBlockEntriesFirst[E1] [X12, X13, X14, X15, X16] InfinityBlockEntriesFirst[extremal] [X61, X62, X63, X64, X65] # We build the matrix and transpose it matrixPair = matrix(SR,[build10x10E1C[extremal][k] for k in range(0,10)]).transpose() # print matrixPair # [ 0 0 +Infinity 0 0 -Cross37 -Cross37 -Cross37 +Infinity -Cross37] # [ 0 +Infinity 0 0 0 -Cross37 -Cross37 +Infinity -Cross37 -Cross37] # [+Infinity 0 0 0 0 -Cross37 +Infinity -Cross37 -Cross37 -Cross37] # [ 0 0 0 0 +Infinity +Infinity -Cross37 -Cross37 -Cross37 -Cross37] # [ 0 0 0 +Infinity 0 -Cross37 -Cross37 -Cross37 -Cross37 +Infinity] # [ -Cross9 -Cross9 -Cross9 +Infinity -Cross9 0 0 0 0 +Infinity] # [ -Cross9 +Infinity -Cross9 -Cross9 -Cross9 0 0 +Infinity 0 0] # [ -Cross9 -Cross9 +Infinity -Cross9 -Cross9 0 0 0 +Infinity 0] # [+Infinity -Cross9 -Cross9 -Cross9 -Cross9 0 +Infinity 0 0 0] # [ -Cross9 -Cross9 -Cross9 -Cross9 +Infinity +Infinity 0 0 0 0] rows = [1,2,6,8] cols= [0,1,6,7] minorPair = matrixPair.matrix_from_rows_and_columns(rows,cols) # minorPair # [ 0 +Infinity -Cross37 +Infinity] # [+Infinity 0 +Infinity -Cross37] # [ -Cross9 +Infinity 0 +Infinity] # [+Infinity -Cross9 +Infinity 0] # trop_minor = min('Infinity',0,-Cross37-Cross9, -Cross37-Cross9, 2*(-Cross37-Cross9)) # CONCLUDE: singular iff v(Cross9) = v(Cross37) = 0 dictCross = {SR(Cross9):0, SR(Cross37):0} # We look at the 45x10 matrix and extract the shift (newMatrix, newShift) = extractingTranslationv2(extremal, build10x45E1NonIntersectingPairs) # Next, we replace the Cross functions appearing on the matrix by 0, since we know their valuation. subsNewMatrix = replacingCrossesWith0(newMatrix,dictCross) # The rows are ordered from x12, ..., y162534 # sorted(list(set([subsNewMatrix[x][k] for x in range(0,len(subsNewMatrix)) for k in range(0, len(subsNewMatrix[x]))]))) # [0, +Infinity] # print newShift.values() # [-Cross0, -Cross3, -Cross63, 0, -Cross12, -Cross90, -Cross18, -Cross21, -Cross97, -Cross24, -Cross28, -Cross132, 0, 0, -Cross41, 0, 0, -Cross48, 0, -Cross54, -Cross57, -Cross6, -Cross66, -Cross69, -Cross73, -Cross76, 0, -Cross81, -Cross84, -Cross102, -Cross15, -Cross93, -Cross60, -Cross99, -Cross87, -Cross105, 0, 0, -Cross114, -Cross117, -Cross120, 0, -Cross126, -Cross129, -Cross30] # [k for k in newShift.keys() if newShift[k] == SR(0)] # [3, 12, 13, 15, 16, 18, 26, 36, 37, 41] (noRepeatedRows, rowsDict) = collectDistinctRowValuesAndKeys(subsNewMatrix) # noRepeatedRows # [[0, +Infinity, 0, 0, 0, 0, 0, 0, 0, +Infinity], # [0, 0, 0, 0, +Infinity, +Infinity, 0, 0, 0, 0], # [0, 0, 0, +Infinity, 0, 0, 0, 0, +Infinity, 0], # [0, 0, +Infinity, 0, 0, 0, 0, 0, +Infinity, 0], # [+Infinity, 0, 0, 0, 0, 0, 0, 0, +Infinity, 0], # [+Infinity, 0, 0, 0, 0, 0, 0, 0, 0, +Infinity], # [+Infinity, 0, 0, 0, 0, 0, 0, +Infinity, 0, 0], # [0, 0, +Infinity, 0, 0, 0, +Infinity, 0, 0, 0], # [0, 0, 0, 0, +Infinity, 0, 0, 0, 0, +Infinity], # [0, +Infinity, 0, 0, 0, 0, +Infinity, 0, 0, 0], # [0, +Infinity, 0, 0, 0, 0, 0, +Infinity, 0, 0], # [0, 0, 0, +Infinity, 0, 0, 0, 0, 0, +Infinity], # [0, 0, 0, 0, +Infinity, 0, +Infinity, 0, 0, 0], # [0, +Infinity, 0, 0, 0, +Infinity, 0, 0, 0, 0], # [0, 0, 0, 0, +Infinity, 0, 0, 0, +Infinity, 0], # [0, 0, +Infinity, 0, 0, +Infinity, 0, 0, 0, 0], # [0, 0, 0, +Infinity, 0, +Infinity, 0, 0, 0, 0], # [0, 0, 0, +Infinity, 0, 0, 0, +Infinity, 0, 0], # [0, 0, +Infinity, 0, 0, 0, 0, +Infinity, 0, 0], # [0, 0, 0, +Infinity, 0, 0, +Infinity, 0, 0, 0], # [0, 0, +Infinity, 0, 0, 0, 0, 0, 0, +Infinity], # [0, +Infinity, 0, 0, 0, 0, 0, 0, +Infinity, 0], # [+Infinity, 0, 0, 0, 0, 0, +Infinity, 0, 0, 0], # [+Infinity, 0, 0, 0, 0, +Infinity, 0, 0, 0, 0], # [0, 0, 0, 0, +Infinity, 0, 0, +Infinity, 0, 0]] # By symmetry we can also find a 3x3 non-singular minor here anticRowKeys[extremal] = findingAnticKeysForDistinctRows(noRepeatedRows, rowsDict, keys) # print anticRowKeys[extremal] # {0: [X12], 1: [X13, X21, X45, Y123546, Y142536], 2: [X14], 3: [X15, X64, Y132546, Y142356, Y162345], 4: [X16], 5: [X23], 6: [X24, X41, X61, X65, Y152634], 7: [X25], 8: [X26], 9: [X31, X35, X62, Y123456, Y132645], 10: [X32], 11: [X34, X42, X52, X54, Y123645], 12: [X36], 13: [X43], 14: [X46], 15: [X51], 16: [X53], 17: [X56], 18: [X63], 19: [Y132456], 20: [Y142635], 21: [Y152346], 22: [Y152436], 23: [Y162435], 24: [Y162534]} ################# # (E1,F23) pair # ################# extremal = F23 InfinityBlockEntriesFirst[E1] [X12, X13, X14, X15, X16] InfinityBlockEntriesFirst[extremal] [X23, X32, Y142356, Y152346, Y162345] # We build the matrix and transpose it matrixPair = matrix(SR,[build10x10E1C[extremal][k] for k in range(0,10)]).transpose() # print matrixPair # [ 0 0 +Infinity 0 0 -Cross6 -Cross6 +Infinity -Cross6 -Cross6] # [ 0 +Infinity 0 0 0 +Infinity -Cross6 -Cross6 -Cross6 -Cross6] # [+Infinity 0 0 0 0 -Cross6 +Infinity -Cross6 -Cross6 -Cross6] # [ 0 0 0 0 +Infinity -Cross6 -Cross6 -Cross6 -Cross6 +Infinity] # [ 0 0 0 +Infinity 0 -Cross6 -Cross6 -Cross6 +Infinity -Cross6] # [ -Cross9 -Cross9 +Infinity -Cross9 -Cross9 0 0 +Infinity 0 0] # [+Infinity -Cross9 -Cross9 -Cross9 -Cross9 0 +Infinity 0 0 0] # [ -Cross9 +Infinity -Cross9 -Cross9 -Cross9 +Infinity 0 0 0 0] # [ -Cross9 -Cross9 -Cross9 +Infinity -Cross9 0 0 0 +Infinity 0] # [ -Cross9 -Cross9 -Cross9 -Cross9 +Infinity 0 0 0 0 +Infinity] rows = [0,1,5,7] cols= [1,2,5,7] minorPair = matrixPair.matrix_from_rows_and_columns(rows,cols) # minorPair # [ 0 +Infinity -Cross6 +Infinity] # [+Infinity 0 +Infinity -Cross6] # [ -Cross9 +Infinity 0 +Infinity] # [+Infinity -Cross9 +Infinity 0] # trop_minor = min('Infinity',0,-Cross6-Cross9, -Cross6-Cross9, 2*(-Cross6-Cross9)) # CONCLUDE: singular iff v(Cross9) = v(Cross6) = 0 dictCross = {SR(Cross9):0, SR(Cross6):0} # We look at the 45x10 matrix and extract the shift (newMatrix, newShift) = extractingTranslationv2(extremal, build10x45E1NonIntersectingPairs) # Next, we replace the Cross functions appearing on the matrix by 0, since we know their valuation. subsNewMatrix = replacingCrossesWith0(newMatrix,dictCross) # The rows are ordered from x12, ..., y162534 # sorted(list(set([subsNewMatrix[x][k] for x in range(0,len(subsNewMatrix)) for k in range(0, len(subsNewMatrix[x]))]))) # [0, +Infinity] # print newShift.values() # [-Cross0, -Cross3, -Cross63, 0, -Cross12, -Cross90, -Cross18, -Cross21, -Cross97, -Cross24, -Cross28, -Cross132, 0, -Cross37, -Cross41, 0, -Cross45, -Cross48, -Cross51, -Cross54, -Cross57, 0, -Cross66, -Cross69, -Cross73, -Cross76, 0, -Cross81, 0, -Cross102, -Cross15, -Cross93, -Cross60, -Cross99, -Cross87, 0, -Cross110, 0, -Cross114, -Cross117, -Cross120, -Cross123, -Cross126, 0, 0] # [k for k in newShift.keys() if newShift[k] == SR(0)] # [3, 12, 15, 21, 26, 28, 35, 37, 43, 44] (noRepeatedRows, rowsDict) = collectDistinctRowValuesAndKeys(subsNewMatrix) # noRepeatedRows # [[0, +Infinity, 0, 0, 0, 0, +Infinity, 0, 0, 0], # [0, 0, 0, 0, +Infinity, 0, 0, 0, 0, +Infinity], # [0, 0, 0, +Infinity, 0, 0, 0, +Infinity, 0, 0], # [0, 0, +Infinity, 0, 0, 0, +Infinity, 0, 0, 0], # [+Infinity, 0, 0, 0, 0, +Infinity, 0, 0, 0, 0], # [0, 0, 0, 0, +Infinity, 0, +Infinity, 0, 0, 0], # [+Infinity, 0, 0, 0, 0, 0, 0, +Infinity, 0, 0], # [0, 0, +Infinity, 0, 0, 0, 0, 0, 0, +Infinity], # [0, 0, 0, 0, +Infinity, 0, 0, 0, +Infinity, 0], # [0, +Infinity, 0, 0, 0, 0, 0, +Infinity, 0, 0], # [0, +Infinity, 0, 0, 0, 0, 0, 0, +Infinity, 0], # [0, 0, 0, +Infinity, 0, 0, 0, 0, 0, +Infinity], # [0, +Infinity, 0, 0, 0, +Infinity, 0, 0, 0, 0], # [0, 0, 0, 0, +Infinity, +Infinity, 0, 0, 0, 0], # [0, 0, +Infinity, 0, 0, +Infinity, 0, 0, 0, 0], # [0, 0, 0, +Infinity, 0, +Infinity, 0, 0, 0, 0], # [0, 0, 0, +Infinity, 0, 0, 0, 0, +Infinity, 0], # [+Infinity, 0, 0, 0, 0, 0, 0, 0, 0, +Infinity], # [0, 0, +Infinity, 0, 0, 0, 0, 0, +Infinity, 0], # [+Infinity, 0, 0, 0, 0, 0, +Infinity, 0, 0, 0], # [0, 0, 0, 0, +Infinity, 0, 0, +Infinity, 0, 0], # [0, 0, 0, +Infinity, 0, 0, +Infinity, 0, 0, 0], # [0, 0, +Infinity, 0, 0, 0, 0, +Infinity, 0, 0], # [0, +Infinity, 0, 0, 0, 0, 0, 0, 0, +Infinity], # [+Infinity, 0, 0, 0, 0, 0, 0, 0, +Infinity, 0]] # We find a non-singular 3x3 minor: # matrix(SR, noRepeatedRows).matrix_from_rows_and_columns([13,15,16],[3,4,5]) # [ 0 +Infinity +Infinity] # [+Infinity 0 +Infinity] # [+Infinity 0 0] anticRowKeys[extremal] = findingAnticKeysForDistinctRows(noRepeatedRows, rowsDict, keys) # print anticRowKeys[extremal] # {0: [X12], 1: [X13], 2: [X14], 3: [X15, X64, Y132546, Y142356, Y162345], 4: [X16, X23, X41, Y152436, Y162435], 5: [X21], 6: [X24], 7: [X25], 8: [X26, X36, X46, Y142536, Y162534], 9: [X31, X35, X62, Y123456, Y132645], 10: [X32], 11: [X34, X42, X52, X54, Y123645], 12: [X43], 13: [X45], 14: [X51], 15: [X53], 16: [X56], 17: [X61], 18: [X63], 19: [X65], 20: [Y123546], 21: [Y132456], 22: [Y142635], 23: [Y152346], 24: [Y152634]} ################# # (E1,F24) pair # ################# extremal = F24 InfinityBlockEntriesFirst[E1] [X12, X13, X14, X15, X16] InfinityBlockEntriesFirst[extremal] [X24, X42, Y132456, Y152436, Y162435] # We build the matrix and transpose it matrixPair = matrix(SR,[build10x10E1C[extremal][k] for k in range(0,10)]).transpose() # print matrixPair # [ 0 0 +Infinity 0 0 +Infinity -Cross21 -Cross21 -Cross21 -Cross21] # [ 0 +Infinity 0 0 0 -Cross21 -Cross21 +Infinity -Cross21 -Cross21] # [+Infinity 0 0 0 0 -Cross21 +Infinity -Cross21 -Cross21 -Cross21] # [ 0 0 0 0 +Infinity -Cross21 -Cross21 -Cross21 -Cross21 +Infinity] # [ 0 0 0 +Infinity 0 -Cross21 -Cross21 -Cross21 +Infinity -Cross21] # [ -Cross9 +Infinity -Cross9 -Cross9 -Cross9 0 0 +Infinity 0 0] # [+Infinity -Cross9 -Cross9 -Cross9 -Cross9 0 +Infinity 0 0 0] # [ -Cross9 -Cross9 -Cross9 +Infinity -Cross9 0 0 0 +Infinity 0] # [ -Cross9 -Cross9 +Infinity -Cross9 -Cross9 +Infinity 0 0 0 0] # [ -Cross9 -Cross9 -Cross9 -Cross9 +Infinity 0 0 0 0 +Infinity] rows = [1,2,5,6] cols= [1,0,6,7] minorPair = matrixPair.matrix_from_rows_and_columns(rows,cols) # minorPair # [+Infinity 0 -Cross21 +Infinity] # [ 0 +Infinity +Infinity -Cross21] # [+Infinity -Cross9 0 +Infinity] # [ -Cross9 +Infinity +Infinity 0] # trop_minor = min('Infinity',0,-Cross21-Cross9, -Cross21-Cross9, 2*(-Cross21-Cross9)) # CONCLUDE: singular iff v(Cross9) = v(Cross21) = 0 dictCross = {SR(Cross9):0, SR(Cross21):0} # We look at the 45x10 matrix and extract the shift (newMatrix, newShift) = extractingTranslationv2(extremal, build10x45E1NonIntersectingPairs) # Next, we replace the Cross functions appearing on the matrix by 0, since we know their valuation. subsNewMatrix = replacingCrossesWith0(newMatrix,dictCross) # The rows are ordered from x12, ..., y162534 # sorted(list(set([subsNewMatrix[x][k] for x in range(0,len(subsNewMatrix)) for k in range(0, len(subsNewMatrix[x]))]))) # [0, +Infinity] # print newShift.values() # [-Cross0, -Cross3, -Cross63, 0, -Cross12, -Cross90, -Cross18, 0, -Cross97, -Cross24, -Cross28, -Cross132, 0, -Cross37, 0, 0, -Cross45, 0, -Cross51, -Cross54, -Cross57, -Cross6, -Cross66, -Cross69, -Cross73, -Cross76, 0, -Cross81, -Cross84, -Cross102, -Cross15, -Cross93, 0, -Cross99, -Cross87, -Cross105, -Cross110, 0, -Cross114, -Cross117, -Cross120, -Cross123, 0, -Cross129, -Cross30] # [k for k in newShift.keys() if newShift[k] == SR(0)] # [3, 7, 12, 14, 15, 17, 26, 32, 37, 42] (noRepeatedRows, rowsDict) = collectDistinctRowValuesAndKeys(subsNewMatrix) # noRepeatedRows # [[0, +Infinity, 0, 0, 0, +Infinity, 0, 0, 0, 0], # [0, 0, 0, 0, +Infinity, 0, +Infinity, 0, 0, 0], # [0, 0, 0, +Infinity, 0, 0, 0, 0, +Infinity, 0], # [0, 0, +Infinity, 0, 0, 0, +Infinity, 0, 0, 0], # [+Infinity, 0, 0, 0, 0, 0, 0, 0, 0, +Infinity], # [0, 0, 0, 0, +Infinity, 0, 0, 0, 0, +Infinity], # [+Infinity, 0, 0, 0, 0, 0, +Infinity, 0, 0, 0], # [+Infinity, 0, 0, 0, 0, 0, 0, 0, +Infinity, 0], # [0, 0, +Infinity, 0, 0, 0, 0, +Infinity, 0, 0], # [0, 0, 0, 0, +Infinity, 0, 0, +Infinity, 0, 0], # [0, +Infinity, 0, 0, 0, 0, +Infinity, 0, 0, 0], # [0, 0, 0, +Infinity, 0, 0, 0, 0, 0, +Infinity], # [0, +Infinity, 0, 0, 0, 0, 0, +Infinity, 0, 0], # [0, 0, 0, 0, +Infinity, +Infinity, 0, 0, 0, 0], # [0, 0, +Infinity, 0, 0, +Infinity, 0, 0, 0, 0], # [0, 0, 0, +Infinity, 0, +Infinity, 0, 0, 0, 0], # [0, 0, 0, +Infinity, 0, 0, +Infinity, 0, 0, 0], # [0, 0, +Infinity, 0, 0, 0, 0, 0, 0, +Infinity], # [0, +Infinity, 0, 0, 0, 0, 0, 0, 0, +Infinity], # [0, 0, 0, 0, +Infinity, 0, 0, 0, +Infinity, 0], # [0, 0, 0, +Infinity, 0, 0, 0, +Infinity, 0, 0], # [0, +Infinity, 0, 0, 0, 0, 0, 0, +Infinity, 0], # [0, 0, +Infinity, 0, 0, 0, 0, 0, +Infinity, 0], # [+Infinity, 0, 0, 0, 0, 0, 0, +Infinity, 0, 0], # [+Infinity, 0, 0, 0, 0, +Infinity, 0, 0, 0, 0]] # By symmetry we can also find a 3x3 non-singular minor here. anticRowKeys[extremal] = findingAnticKeysForDistinctRows(noRepeatedRows, rowsDict, keys) # print anticRowKeys[extremal] # {0: [X12, X32, X43, X62, Y152346], 1: [X13], 2: [X14], 3: [X15, X64, Y132546, Y142356, Y162345], 4: [X16], 5: [X21], 6: [X23], 7: [X24, X41, X61, X65, Y152634], 8: [X25], 9: [X26, X36, X46, Y142536, Y162534], 10: [X31], 11: [X34, X42, X52, X54, Y123645], 12: [X35], 13: [X45], 14: [X51], 15: [X53], 16: [X56], 17: [X63], 18: [Y123456], 19: [Y123546], 20: [Y132456], 21: [Y132645], 22: [Y142635], 23: [Y152436], 24: [Y162435]} ################# # (E1,F25) pair # ################# extremal = F25 InfinityBlockEntriesFirst[E1] [X12, X13, X14, X15, X16] InfinityBlockEntriesFirst[extremal] [X25, X52, Y132546, Y142536, Y162534] # We build the matrix and transpose it matrixPair = matrix(SR,[build10x10E1C[extremal][k] for k in range(0,10)]).transpose() # print matrixPair # [ 0 0 +Infinity 0 0 -Cross69 -Cross69 -Cross69 +Infinity -Cross69] # [ 0 +Infinity 0 0 0 -Cross69 -Cross69 +Infinity -Cross69 -Cross69] # [+Infinity 0 0 0 0 -Cross69 +Infinity -Cross69 -Cross69 -Cross69] # [ 0 0 0 0 +Infinity -Cross69 -Cross69 -Cross69 -Cross69 +Infinity] # [ 0 0 0 +Infinity 0 +Infinity -Cross69 -Cross69 -Cross69 -Cross69] # [ -Cross9 -Cross9 +Infinity -Cross9 -Cross9 0 0 0 +Infinity 0] # [ -Cross9 -Cross9 -Cross9 -Cross9 +Infinity 0 0 0 0 +Infinity] # [+Infinity -Cross9 -Cross9 -Cross9 -Cross9 0 +Infinity 0 0 0] # [ -Cross9 +Infinity -Cross9 -Cross9 -Cross9 0 0 +Infinity 0 0] # [ -Cross9 -Cross9 -Cross9 +Infinity -Cross9 +Infinity 0 0 0 0] rows = [0,1,5,8] cols= [1,2,7,8] minorPair = matrixPair.matrix_from_rows_and_columns(rows,cols) # minorPair # [ 0 +Infinity -Cross69 +Infinity] # [+Infinity 0 +Infinity -Cross69] # [ -Cross9 +Infinity 0 +Infinity] # [+Infinity -Cross9 +Infinity 0] # trop_minor = min('Infinity',0,-Cross69-Cross9, -Cross0-Cross9, 2*(-Cross69-Cross9)) # CONCLUDE: singular iff v(Cross9) = v(Cross69) = 0 dictCross = {SR(Cross9):0, SR(Cross69):0} # We look at the 45x10 matrix and extract the shift (newMatrix, newShift) = extractingTranslationv2(extremal, build10x45E1NonIntersectingPairs) # Next, we replace the Cross functions appearing on the matrix by 0, since we know their valuation. subsNewMatrix = replacingCrossesWith0(newMatrix,dictCross) # The rows are ordered from x12, ..., y162534 # sorted(list(set([subsNewMatrix[x][k] for x in range(0,len(subsNewMatrix)) for k in range(0, len(subsNewMatrix[x]))]))) # [0, +Infinity] # print newShift.values() # [-Cross0, -Cross3, -Cross63, 0, -Cross12, -Cross90, -Cross18, -Cross21, -Cross97, -Cross24, -Cross28, 0, 0, -Cross37, -Cross41, 0, -Cross45, -Cross48, -Cross51, -Cross54, -Cross57, -Cross6, -Cross66, 0, -Cross73, -Cross76, 0, -Cross81, -Cross84, -Cross102, -Cross15, 0, -Cross60, -Cross99, 0, -Cross105, -Cross110, 0, -Cross114, -Cross117, 0, -Cross123, -Cross126, -Cross129, -Cross30] # [k for k in newShift.keys() if newShift[k] == SR(0)] # [3, 11, 12, 15, 23, 26, 31, 34, 37, 40] (noRepeatedRows, rowsDict) = collectDistinctRowValuesAndKeys(subsNewMatrix) # noRepeatedRows # [[0, +Infinity, 0, 0, 0, 0, 0, 0, +Infinity, 0], # [0, 0, 0, 0, +Infinity, 0, 0, 0, 0, +Infinity], # [0, 0, 0, +Infinity, 0, 0, 0, 0, 0, +Infinity], # [0, 0, +Infinity, 0, 0, 0, 0, +Infinity, 0, 0], # [+Infinity, 0, 0, 0, 0, +Infinity, 0, 0, 0, 0], # [+Infinity, 0, 0, 0, 0, 0, 0, 0, 0, +Infinity], # [0, 0, +Infinity, 0, 0, +Infinity, 0, 0, 0, 0], # [0, 0, 0, 0, +Infinity, 0, 0, +Infinity, 0, 0], # [0, +Infinity, 0, 0, 0, 0, +Infinity, 0, 0, 0], # [0, 0, 0, +Infinity, 0, 0, +Infinity, 0, 0, 0], # [0, +Infinity, 0, 0, 0, +Infinity, 0, 0, 0, 0], # [0, 0, 0, 0, +Infinity, +Infinity, 0, 0, 0, 0], # [0, 0, 0, 0, +Infinity, 0, +Infinity, 0, 0, 0], # [0, 0, +Infinity, 0, 0, 0, +Infinity, 0, 0, 0], # [0, 0, 0, +Infinity, 0, 0, 0, +Infinity, 0, 0], # [0, 0, 0, +Infinity, 0, 0, 0, 0, +Infinity, 0], # [+Infinity, 0, 0, 0, 0, 0, 0, +Infinity, 0, 0], # [0, 0, +Infinity, 0, 0, 0, 0, 0, +Infinity, 0], # [+Infinity, 0, 0, 0, 0, 0, +Infinity, 0, 0, 0], # [0, +Infinity, 0, 0, 0, 0, 0, +Infinity, 0, 0], # [0, 0, 0, +Infinity, 0, +Infinity, 0, 0, 0, 0], # [0, +Infinity, 0, 0, 0, 0, 0, 0, 0, +Infinity], # [0, 0, +Infinity, 0, 0, 0, 0, 0, 0, +Infinity], # [+Infinity, 0, 0, 0, 0, 0, 0, 0, +Infinity, 0], # [0, 0, 0, 0, +Infinity, 0, 0, 0, +Infinity, 0]] # By symmetry we can also find a 3x3 non-singular minor here. anticRowKeys[extremal] = findingAnticKeysForDistinctRows(noRepeatedRows, rowsDict, keys) # print anticRowKeys[extremal] # {0: [X12, X32, X43, X62, Y152346], 1: [X13, X21, X45, Y123546, Y142536], 2: [X14], 3: [X15, X64, Y132546, Y142356, Y162345], 4: [X16, X23, X41, Y152436, Y162435], 5: [X24], 6: [X25], 7: [X26], 8: [X31], 9: [X34, X42, X52, X54, Y123645], 10: [X35], 11: [X36], 12: [X46], 13: [X51], 14: [X53], 15: [X56], 16: [X61], 17: [X63], 18: [X65], 19: [Y123456], 20: [Y132456], 21: [Y132645], 22: [Y142635], 23: [Y152634], 24: [Y162534]} ################# # (E1,F26) pair # ################# extremal = F26 InfinityBlockEntriesFirst[E1] [X12, X13, X14, X15, X16] InfinityBlockEntriesFirst[extremal] [X26, X62, Y132645, Y142635, Y152634] # We build the matrix and transpose it matrixPair = matrix(SR,[build10x10E1C[extremal][k] for k in range(0,10)]).transpose() # print matrixPair # [ 0 0 +Infinity 0 0 -Cross12 -Cross12 -Cross12 +Infinity -Cross12] # [ 0 +Infinity 0 0 0 -Cross12 -Cross12 +Infinity -Cross12 -Cross12] # [+Infinity 0 0 0 0 -Cross12 +Infinity -Cross12 -Cross12 -Cross12] # [ 0 0 0 0 +Infinity +Infinity -Cross12 -Cross12 -Cross12 -Cross12] # [ 0 0 0 +Infinity 0 -Cross12 -Cross12 -Cross12 -Cross12 +Infinity] # [+Infinity -Cross9 -Cross9 -Cross9 -Cross9 0 +Infinity 0 0 0] # [ -Cross9 -Cross9 -Cross9 -Cross9 +Infinity +Infinity 0 0 0 0] # [ -Cross9 -Cross9 -Cross9 +Infinity -Cross9 0 0 0 0 +Infinity] # [ -Cross9 -Cross9 +Infinity -Cross9 -Cross9 0 0 0 +Infinity 0] # [ -Cross9 +Infinity -Cross9 -Cross9 -Cross9 0 0 +Infinity 0 0] rows = [0,1,8,9] cols= [1,2,7,8] minorPair = matrixPair.matrix_from_rows_and_columns(rows,cols) # minorPair # [ 0 +Infinity -Cross12 +Infinity] # [+Infinity 0 +Infinity -Cross12] # [ -Cross9 +Infinity 0 +Infinity] # [+Infinity -Cross9 +Infinity 0] # trop_minor = min('Infinity',0,-Cross12-Cross9, -Cross12-Cross9, 2*(-Cross12-Cross9)) # CONCLUDE: singular iff v(Cross9) = v(Cross12) = 0 dictCross = {SR(Cross9):0, SR(Cross12):0} # We look at the 45x10 matrix and extract the shift (newMatrix, newShift) = extractingTranslationv2(extremal, build10x45E1NonIntersectingPairs) # Next, we replace the Cross functions appearing on the matrix by 0, since we know their valuation. subsNewMatrix = replacingCrossesWith0(newMatrix,dictCross) # The rows are ordered from x12, ..., y162534 # sorted(list(set([subsNewMatrix[x][k] for x in range(0,len(subsNewMatrix)) for k in range(0, len(subsNewMatrix[x]))]))) # [0, +Infinity] # print newShift.values() # [-Cross0, -Cross3, 0, 0, 0, -Cross90, -Cross18, -Cross21, -Cross97, -Cross24, -Cross28, -Cross132, 0, -Cross37, -Cross41, 0, -Cross45, -Cross48, -Cross51, 0, -Cross57, -Cross6, -Cross66, -Cross69, -Cross73, -Cross76, 0, -Cross81, -Cross84, -Cross102, -Cross15, -Cross93, -Cross60, -Cross99, -Cross87, -Cross105, 0, 0, -Cross114, 0, -Cross120, -Cross123, -Cross126, -Cross129, -Cross30] # [k for k in newShift.keys() if newShift[k] == SR(0)] # [2, 3, 4, 12, 15, 19, 26, 36, 37, 39] (noRepeatedRows, rowsDict) = collectDistinctRowValuesAndKeys(subsNewMatrix) # noRepeatedRows # [[0, +Infinity, 0, 0, 0, 0, 0, 0, 0, +Infinity], # [0, 0, 0, 0, +Infinity, 0, 0, 0, 0, +Infinity], # [0, 0, 0, +Infinity, 0, 0, +Infinity, 0, 0, 0], # [0, 0, +Infinity, 0, 0, +Infinity, 0, 0, 0, 0], # [+Infinity, 0, 0, 0, 0, 0, 0, 0, +Infinity, 0], # [0, 0, 0, 0, +Infinity, 0, 0, 0, +Infinity, 0], # [+Infinity, 0, 0, 0, 0, 0, +Infinity, 0, 0, 0], # [0, 0, +Infinity, 0, 0, 0, 0, 0, 0, +Infinity], # [0, 0, 0, 0, +Infinity, 0, 0, +Infinity, 0, 0], # [0, +Infinity, 0, 0, 0, 0, 0, +Infinity, 0, 0], # [0, +Infinity, 0, 0, 0, +Infinity, 0, 0, 0, 0], # [0, 0, 0, +Infinity, 0, +Infinity, 0, 0, 0, 0], # [0, 0, 0, 0, +Infinity, +Infinity, 0, 0, 0, 0], # [0, 0, +Infinity, 0, 0, 0, 0, +Infinity, 0, 0], # [0, 0, 0, +Infinity, 0, 0, 0, 0, 0, +Infinity], # [0, 0, 0, +Infinity, 0, 0, 0, +Infinity, 0, 0], # [+Infinity, 0, 0, 0, 0, 0, 0, 0, 0, +Infinity], # [0, 0, +Infinity, 0, 0, 0, 0, 0, +Infinity, 0], # [+Infinity, 0, 0, 0, 0, 0, 0, +Infinity, 0, 0], # [0, +Infinity, 0, 0, 0, 0, 0, 0, +Infinity, 0], # [0, 0, 0, 0, +Infinity, 0, +Infinity, 0, 0, 0], # [0, 0, 0, +Infinity, 0, 0, 0, 0, +Infinity, 0], # [0, +Infinity, 0, 0, 0, 0, +Infinity, 0, 0, 0], # [0, 0, +Infinity, 0, 0, 0, +Infinity, 0, 0, 0], # [+Infinity, 0, 0, 0, 0, +Infinity, 0, 0, 0, 0]] # By symmetry we can also find a 3x3 non-singular minor here. anticRowKeys[extremal] = findingAnticKeysForDistinctRows(noRepeatedRows, rowsDict, keys) # print anticRowKeys[extremal] # {0: [X12, X32, X43, X62, Y152346], 1: [X13], 2: [X14, X34, X53, X56, Y132456], 3: [X15, X64, Y132546, Y142356, Y162345], 4: [X16, X23, X41, Y152436, Y162435], 5: [X21], 6: [X24], 7: [X25], 8: [X26, X36, X46, Y142536, Y162534], 9: [X31], 10: [X35], 11: [X42], 12: [X45], 13: [X51], 14: [X52], 15: [X54], 16: [X61], 17: [X63], 18: [X65], 19: [Y123456], 20: [Y123546], 21: [Y123645], 22: [Y132645], 23: [Y142635], 24: [Y152634]} ################# # (E1,F34) pair # ################# extremal = F34 InfinityBlockEntriesFirst[E1] [X12, X13, X14, X15, X16] InfinityBlockEntriesFirst[extremal] [X34, X43, Y123456, Y152634, Y162534] # We build the matrix and transpose it matrixPair = matrix(SR,[build10x10E1C[extremal][k] for k in range(0,10)]).transpose() # print matrixPair # [ 0 0 +Infinity 0 0 +Infinity -Cross28 -Cross28 -Cross28 -Cross28] # [ 0 +Infinity 0 0 0 -Cross28 +Infinity -Cross28 -Cross28 -Cross28] # [+Infinity 0 0 0 0 -Cross28 -Cross28 +Infinity -Cross28 -Cross28] # [ 0 0 0 0 +Infinity -Cross28 -Cross28 -Cross28 -Cross28 +Infinity] # [ 0 0 0 +Infinity 0 -Cross28 -Cross28 -Cross28 +Infinity -Cross28] # [+Infinity -Cross9 -Cross9 -Cross9 -Cross9 0 0 +Infinity 0 0] # [ -Cross9 +Infinity -Cross9 -Cross9 -Cross9 0 +Infinity 0 0 0] # [ -Cross9 -Cross9 +Infinity -Cross9 -Cross9 +Infinity 0 0 0 0] # [ -Cross9 -Cross9 -Cross9 +Infinity -Cross9 0 0 0 +Infinity 0] # [ -Cross9 -Cross9 -Cross9 -Cross9 +Infinity 0 0 0 0 +Infinity] rows = [3,4,8,9] cols= [3,4,8,9] minorPair = matrixPair.matrix_from_rows_and_columns(rows,cols) # minorPair # [ 0 +Infinity -Cross28 +Infinity] # [+Infinity 0 +Infinity -Cross28] # [+Infinity -Cross9 +Infinity 0] # [ -Cross9 +Infinity 0 +Infinity] # trop_minor = min('Infinity',0,-Cross28-Cross9, -Cross28-Cross9, 2*(-Cross28-Cross9)) # CONCLUDE: singular iff v(Cross9) = v(Cross28) = 0 dictCross = {SR(Cross9):0, SR(Cross28):0} # We look at the 45x10 matrix and extract the shift (newMatrix, newShift) = extractingTranslationv2(extremal, build10x45E1NonIntersectingPairs) # Next, we replace the Cross functions appearing on the matrix by 0, since we know their valuation. subsNewMatrix = replacingCrossesWith0(newMatrix,dictCross) # The rows are ordered from x12, ..., y162534 # sorted(list(set([subsNewMatrix[x][k] for x in range(0,len(subsNewMatrix)) for k in range(0, len(subsNewMatrix[x]))]))) # [0, +Infinity] # print newShift.values() # [-Cross0, -Cross3, -Cross63, 0, -Cross12, -Cross90, -Cross18, -Cross21, -Cross97, -Cross24, 0, -Cross132, 0, -Cross37, -Cross41, 0, -Cross45, -Cross48, -Cross51, 0, 0, -Cross6, -Cross66, 0, -Cross73, -Cross76, 0, -Cross81, -Cross84, 0, -Cross15, -Cross93, -Cross60, -Cross99, -Cross87, -Cross105, -Cross110, 0, -Cross114, -Cross117, -Cross120, -Cross123, -Cross126, -Cross129, -Cross30] # [k for k in newShift.keys() if newShift[k] == SR(0)] # [3, 10, 12, 15, 19, 20, 23, 26, 29, 37] (noRepeatedRows, rowsDict) = collectDistinctRowValuesAndKeys(subsNewMatrix) # noRepeatedRows # [[0, +Infinity, 0, 0, 0, 0, 0, +Infinity, 0, 0], # [0, 0, 0, 0, +Infinity, 0, +Infinity, 0, 0, 0], # [0, 0, 0, +Infinity, 0, 0, 0, 0, +Infinity, 0], # [0, 0, +Infinity, 0, 0, +Infinity, 0, 0, 0, 0], # [+Infinity, 0, 0, 0, 0, 0, 0, 0, +Infinity, 0], # [0, 0, 0, 0, +Infinity, 0, 0, +Infinity, 0, 0], # [+Infinity, 0, 0, 0, 0, 0, +Infinity, 0, 0, 0], # [+Infinity, 0, 0, 0, 0, 0, 0, +Infinity, 0, 0], # [0, 0, 0, 0, +Infinity, 0, 0, 0, +Infinity, 0], # [0, +Infinity, 0, 0, 0, 0, +Infinity, 0, 0, 0], # [0, +Infinity, 0, 0, 0, 0, 0, 0, 0, +Infinity], # [0, 0, 0, +Infinity, 0, 0, 0, 0, 0, +Infinity], # [0, +Infinity, 0, 0, 0, +Infinity, 0, 0, 0, 0], # [0, 0, 0, 0, +Infinity, +Infinity, 0, 0, 0, 0], # [0, 0, 0, +Infinity, 0, +Infinity, 0, 0, 0, 0], # [0, 0, 0, +Infinity, 0, 0, +Infinity, 0, 0, 0], # [0, 0, +Infinity, 0, 0, 0, 0, +Infinity, 0, 0], # [0, 0, 0, 0, +Infinity, 0, 0, 0, 0, +Infinity], # [0, 0, 0, +Infinity, 0, 0, 0, +Infinity, 0, 0], # [0, 0, +Infinity, 0, 0, 0, 0, 0, 0, +Infinity], # [0, 0, +Infinity, 0, 0, 0, 0, 0, +Infinity, 0], # [0, +Infinity, 0, 0, 0, 0, 0, 0, +Infinity, 0], # [+Infinity, 0, 0, 0, 0, 0, 0, 0, 0, +Infinity], # [0, 0, +Infinity, 0, 0, 0, +Infinity, 0, 0, 0], # [+Infinity, 0, 0, 0, 0, +Infinity, 0, 0, 0, 0]] # By symmetry we can also find a 3x3 non-singular minor here. anticRowKeys[extremal] = findingAnticKeysForDistinctRows(noRepeatedRows, rowsDict, keys) # print anticRowKeys[extremal] # {0: [X12], 1: [X13], 2: [X14], 3: [X15, X25, X51, X63, Y142635], 4: [X16], 5: [X21], 6: [X23], 7: [X24, X41, X61, X65, Y152634], 8: [X26, X36, X46, Y142536, Y162534], 9: [X31, X35, X62, Y123456, Y132645], 10: [X32], 11: [X34, X42, X52, X54, Y123645], 12: [X43], 13: [X45], 14: [X53], 15: [X56], 16: [X64], 17: [Y123546], 18: [Y132456], 19: [Y132546], 20: [Y142356], 21: [Y152346], 22: [Y152436], 23: [Y162345], 24: [Y162435]} ################# # (E1,F35) pair # ################# extremal = F35 InfinityBlockEntriesFirst[E1] [X12, X13, X14, X15, X16] InfinityBlockEntriesFirst[extremal] [X35, X53, Y123546, Y142635, Y162435] # We build the matrix and transpose it matrixPair = matrix(SR,[build10x10E1C[extremal][k] for k in range(0,10)]).transpose() # print matrixPair # [ 0 0 +Infinity 0 0 -Cross12 -Cross12 -Cross12 +Infinity -Cross12] # [ 0 +Infinity 0 0 0 -Cross12 +Infinity -Cross12 -Cross12 -Cross12] # [+Infinity 0 0 0 0 -Cross12 -Cross12 +Infinity -Cross12 -Cross12] # [ 0 0 0 0 +Infinity -Cross12 -Cross12 -Cross12 -Cross12 +Infinity] # [ 0 0 0 +Infinity 0 +Infinity -Cross12 -Cross12 -Cross12 -Cross12] # [ -Cross9 -Cross9 -Cross9 +Infinity -Cross9 +Infinity 0 0 0 0] # [ -Cross9 +Infinity -Cross9 -Cross9 -Cross9 0 +Infinity 0 0 0] # [+Infinity -Cross9 -Cross9 -Cross9 -Cross9 0 0 +Infinity 0 0] # [ -Cross9 -Cross9 -Cross9 -Cross9 +Infinity 0 0 0 0 +Infinity] # [ -Cross9 -Cross9 +Infinity -Cross9 -Cross9 0 0 0 +Infinity 0] rows = [0,1,6,9] cols= [1,2,6,8] minorPair = matrixPair.matrix_from_rows_and_columns(rows,cols) # minorPair # [ 0 +Infinity -Cross12 +Infinity] # [+Infinity 0 +Infinity -Cross12] # [+Infinity -Cross9 +Infinity 0] # [ -Cross9 +Infinity 0 +Infinity] # trop_minor = min('Infinity',0,-Cross12-Cross9, -Cross12-Cross9, 2*(-Cross12-Cross9)) # CONCLUDE: singular iff v(Cross9) = v(Cross12) = 0 dictCross = {SR(Cross9):0, SR(Cross12):0} # We look at the 45x10 matrix and extract the shift (newMatrix, newShift) = extractingTranslationv2(extremal, build10x45E1NonIntersectingPairs) # Next, we replace the Cross functions appearing on the matrix by 0, since we know their valuation. subsNewMatrix = replacingCrossesWith0(newMatrix,dictCross) # The rows are ordered from x12, ..., y162534 # sorted(list(set([subsNewMatrix[x][k] for x in range(0,len(subsNewMatrix)) for k in range(0, len(subsNewMatrix[x]))]))) # [0, +Infinity] # print newShift.values() # [-Cross0, -Cross3, -Cross63, 0, 0, 0, -Cross18, -Cross21, -Cross97, -Cross24, -Cross28, -Cross132, 0, -Cross37, -Cross41, 0, -Cross45, -Cross48, -Cross51, -Cross54, -Cross57, -Cross6, -Cross66, -Cross69, -Cross73, -Cross76, 0, 0, -Cross84, -Cross102, 0, -Cross93, 0, -Cross99, -Cross87, -Cross105, -Cross110, 0, -Cross114, -Cross117, -Cross120, -Cross123, -Cross126, -Cross129, -Cross30] # [k for k in newShift.keys() if newShift[k] == SR(0)] # [3, 4, 5, 12, 15, 26, 27, 30, 32, 37] (noRepeatedRows, rowsDict) = collectDistinctRowValuesAndKeys(subsNewMatrix) # noRepeatedRows # [[0, +Infinity, 0, 0, 0, +Infinity, 0, 0, 0, 0], # [0, 0, 0, 0, +Infinity, +Infinity, 0, 0, 0, 0], # [0, 0, 0, +Infinity, 0, 0, 0, 0, 0, +Infinity], # [0, 0, +Infinity, 0, 0, 0, 0, +Infinity, 0, 0], # [+Infinity, 0, 0, 0, 0, 0, 0, 0, 0, +Infinity], # [+Infinity, 0, 0, 0, 0, 0, 0, 0, +Infinity, 0], # [0, 0, 0, 0, +Infinity, 0, +Infinity, 0, 0, 0], # [0, +Infinity, 0, 0, 0, 0, +Infinity, 0, 0, 0], # [0, +Infinity, 0, 0, 0, 0, 0, +Infinity, 0, 0], # [0, 0, 0, +Infinity, 0, 0, 0, 0, +Infinity, 0], # [0, 0, 0, 0, +Infinity, 0, 0, 0, +Infinity, 0], # [0, +Infinity, 0, 0, 0, 0, 0, 0, +Infinity, 0], # [0, 0, 0, 0, +Infinity, 0, 0, 0, 0, +Infinity], # [0, 0, 0, +Infinity, 0, 0, +Infinity, 0, 0, 0], # [0, 0, 0, +Infinity, 0, 0, 0, +Infinity, 0, 0], # [+Infinity, 0, 0, 0, 0, 0, +Infinity, 0, 0, 0], # [0, 0, +Infinity, 0, 0, +Infinity, 0, 0, 0, 0], # [+Infinity, 0, 0, 0, 0, +Infinity, 0, 0, 0, 0], # [0, 0, 0, +Infinity, 0, +Infinity, 0, 0, 0, 0], # [0, 0, +Infinity, 0, 0, 0, +Infinity, 0, 0, 0], # [0, 0, +Infinity, 0, 0, 0, 0, 0, 0, +Infinity], # [0, +Infinity, 0, 0, 0, 0, 0, 0, 0, +Infinity], # [+Infinity, 0, 0, 0, 0, 0, 0, +Infinity, 0, 0], # [0, 0, +Infinity, 0, 0, 0, 0, 0, +Infinity, 0], # [0, 0, 0, 0, +Infinity, 0, 0, +Infinity, 0, 0]] # By symmetry we can also find a 3x3 non-singular minor here. anticRowKeys[extremal] = findingAnticKeysForDistinctRows(noRepeatedRows, rowsDict, keys) # print anticRowKeys[extremal] # {0: [X12], 1: [X13, X21, X45, Y123546, Y142536], 2: [X14], 3: [X15, X25, X51, X63, Y142635], 4: [X16, X23, X41, Y152436, Y162435], 5: [X24], 6: [X26], 7: [X31, X35, X62, Y123456, Y132645], 8: [X32], 9: [X34, X42, X52, X54, Y123645], 10: [X36], 11: [X43], 12: [X46], 13: [X53], 14: [X56], 15: [X61], 16: [X64], 17: [X65], 18: [Y132456], 19: [Y132546], 20: [Y142356], 21: [Y152346], 22: [Y152634], 23: [Y162345], 24: [Y162534]} ################# # (E1,F36) pair # ################# extremal = F36 InfinityBlockEntriesFirst[E1] [X12, X13, X14, X15, X16] InfinityBlockEntriesFirst[extremal] [X36, X63, Y123645, Y142536, Y152436] # We build the matrix and transpose it matrixPair = matrix(SR,[build10x10E1C[extremal][k] for k in range(0,10)]).transpose() # print matrixPair # [ 0 0 +Infinity 0 0 -Cross37 -Cross37 -Cross37 +Infinity -Cross37] # [ 0 +Infinity 0 0 0 -Cross37 +Infinity -Cross37 -Cross37 -Cross37] # [+Infinity 0 0 0 0 -Cross37 -Cross37 +Infinity -Cross37 -Cross37] # [ 0 0 0 0 +Infinity +Infinity -Cross37 -Cross37 -Cross37 -Cross37] # [ 0 0 0 +Infinity 0 -Cross37 -Cross37 -Cross37 -Cross37 +Infinity] # [ -Cross9 -Cross9 -Cross9 -Cross9 +Infinity +Infinity 0 0 0 0] # [ -Cross9 +Infinity -Cross9 -Cross9 -Cross9 0 +Infinity 0 0 0] # [+Infinity -Cross9 -Cross9 -Cross9 -Cross9 0 0 +Infinity 0 0] # [ -Cross9 -Cross9 -Cross9 +Infinity -Cross9 0 0 0 0 +Infinity] # [ -Cross9 -Cross9 +Infinity -Cross9 -Cross9 0 0 0 +Infinity 0] rows = [0,4,8,9] cols = [2,3,8,9] minorPair = matrixPair.matrix_from_rows_and_columns(rows,cols) # minorPair # [+Infinity 0 +Infinity -Cross37] # [ 0 +Infinity -Cross37 +Infinity] # [ -Cross9 +Infinity 0 +Infinity] # [+Infinity -Cross9 +Infinity 0] # trop_minor = min('Infinity',0,-Cross37-Cross9, -Cross37-Cross9, 2*(-Cross37-Cross9)) # CONCLUDE: singular iff v(Cross9) = v(Cross37) = 0 dictCross = {SR(Cross9):0, SR(Cross37):0} # We look at the 45x10 matrix and extract the shift (newMatrix, newShift) = extractingTranslationv2(extremal, build10x45E1NonIntersectingPairs) # Next, we replace the Cross functions appearing on the matrix by 0, since we know their valuation. subsNewMatrix = replacingCrossesWith0(newMatrix,dictCross) # The rows are ordered from x12, ..., y162534 # sorted(list(set([subsNewMatrix[x][k] for x in range(0,len(subsNewMatrix)) for k in range(0, len(subsNewMatrix[x]))]))) # [0, +Infinity] # print newShift.values() # [-Cross0, -Cross3, -Cross63, 0, -Cross12, -Cross90, -Cross18, -Cross21, 0, -Cross24, -Cross28, -Cross132, 0, 0, 0, 0, -Cross45, -Cross48, -Cross51, -Cross54, -Cross57, -Cross6, -Cross66, -Cross69, -Cross73, -Cross76, 0, -Cross81, -Cross84, -Cross102, -Cross15, -Cross93, -Cross60, 0, -Cross87, -Cross105, -Cross110, 0, -Cross114, -Cross117, 0, -Cross123, -Cross126, -Cross129, -Cross30] # [k for k in newShift.keys() if newShift[k] == SR(0)] # [3, 8, 12, 13, 14, 15, 26, 33, 37, 40] (noRepeatedRows, rowsDict) = collectDistinctRowValuesAndKeys(subsNewMatrix) # noRepeatedRows # [[0, +Infinity, 0, 0, 0, +Infinity, 0, 0, 0, 0], # [0, 0, 0, 0, +Infinity, 0, 0, +Infinity, 0, 0], # [0, 0, 0, +Infinity, 0, +Infinity, 0, 0, 0, 0], # [0, 0, +Infinity, 0, 0, 0, 0, +Infinity, 0, 0], # [+Infinity, 0, 0, 0, 0, 0, 0, 0, 0, +Infinity], # [0, 0, 0, 0, +Infinity, +Infinity, 0, 0, 0, 0], # [+Infinity, 0, 0, 0, 0, 0, 0, 0, +Infinity, 0], # [0, 0, 0, 0, +Infinity, 0, 0, 0, +Infinity, 0], # [0, +Infinity, 0, 0, 0, 0, +Infinity, 0, 0, 0], # [0, +Infinity, 0, 0, 0, 0, 0, 0, 0, +Infinity], # [0, 0, 0, +Infinity, 0, 0, +Infinity, 0, 0, 0], # [0, +Infinity, 0, 0, 0, 0, 0, 0, +Infinity, 0], # [0, 0, 0, 0, +Infinity, 0, +Infinity, 0, 0, 0], # [0, 0, 0, +Infinity, 0, 0, 0, +Infinity, 0, 0], # [0, 0, 0, +Infinity, 0, 0, 0, 0, 0, +Infinity], # [+Infinity, 0, 0, 0, 0, 0, 0, +Infinity, 0, 0], # [0, 0, +Infinity, 0, 0, +Infinity, 0, 0, 0, 0], # [+Infinity, 0, 0, 0, 0, +Infinity, 0, 0, 0, 0], # [0, 0, 0, 0, +Infinity, 0, 0, 0, 0, +Infinity], # [0, 0, 0, +Infinity, 0, 0, 0, 0, +Infinity, 0], # [0, 0, +Infinity, 0, 0, 0, 0, 0, 0, +Infinity], # [0, 0, +Infinity, 0, 0, 0, +Infinity, 0, 0, 0], # [0, +Infinity, 0, 0, 0, 0, 0, +Infinity, 0, 0], # [+Infinity, 0, 0, 0, 0, 0, +Infinity, 0, 0, 0], # [0, 0, +Infinity, 0, 0, 0, 0, 0, +Infinity, 0]] # By symmetry we can also find a 3x3 non-singular minor here. anticRowKeys[extremal] = findingAnticKeysForDistinctRows(noRepeatedRows, rowsDict, keys) # print anticRowKeys[extremal] # {0: [X12], 1: [X13], 2: [X14, X34, X53, X56, Y132456], 3: [X15, X25, X51, X63, Y142635], 4: [X16, X23, X41, Y152436, Y162435], 5: [X21], 6: [X24], 7: [X26, X36, X46, Y142536, Y162534], 8: [X31, X35, X62, Y123456, Y132645], 9: [X32], 10: [X42], 11: [X43], 12: [X45], 13: [X52], 14: [X54], 15: [X61], 16: [X64], 17: [X65], 18: [Y123546], 19: [Y123645], 20: [Y132546], 21: [Y142356], 22: [Y152346], 23: [Y152634], 24: [Y162345]} ################# # (E1,F45) pair # ################# extremal = F45 InfinityBlockEntriesFirst[E1] [X12, X13, X14, X15, X16] InfinityBlockEntriesFirst[extremal] [X45, X54, Y123645, Y132645, Y162345] # We build the matrix and transpose it matrixPair = matrix(SR,[build10x10E1C[extremal][k] for k in range(0,10)]).transpose() # print matrixPair # [ 0 0 +Infinity 0 0 -Cross3 +Infinity -Cross3 -Cross3 -Cross3] # [ 0 +Infinity 0 0 0 -Cross3 -Cross3 -Cross3 +Infinity -Cross3] # [+Infinity 0 0 0 0 -Cross3 -Cross3 +Infinity -Cross3 -Cross3] # [ 0 0 0 0 +Infinity -Cross3 -Cross3 -Cross3 -Cross3 +Infinity] # [ 0 0 0 +Infinity 0 +Infinity -Cross3 -Cross3 -Cross3 -Cross3] # [ -Cross9 -Cross9 -Cross9 +Infinity -Cross9 +Infinity 0 0 0 0] # [+Infinity -Cross9 -Cross9 -Cross9 -Cross9 0 0 +Infinity 0 0] # [ -Cross9 -Cross9 +Infinity -Cross9 -Cross9 0 +Infinity 0 0 0] # [ -Cross9 +Infinity -Cross9 -Cross9 -Cross9 0 0 0 +Infinity 0] # [ -Cross9 -Cross9 -Cross9 -Cross9 +Infinity 0 0 0 0 +Infinity] rows = [0,1,7,8] cols= [1,2,6,8] minorPair = matrixPair.matrix_from_rows_and_columns(rows,cols) # minorPair # [ 0 +Infinity +Infinity -Cross3] # [+Infinity 0 -Cross3 +Infinity] # [ -Cross9 +Infinity +Infinity 0] # [+Infinity -Cross9 0 +Infinity] # trop_minor = min('Infinity',0,-Cross3-Cross9, -Cross3-Cross9, 2*(-Cross3-Cross9)) # CONCLUDE: singular iff v(Cross9) = v(Cross3) = 0 dictCross = {SR(Cross9):0, SR(Cross3):0} # We look at the 45x10 matrix and extract the shift (newMatrix, newShift) = extractingTranslationv2(extremal, build10x45E1NonIntersectingPairs) # Next, we replace the Cross functions appearing on the matrix by 0, since we know their valuation. subsNewMatrix = replacingCrossesWith0(newMatrix,dictCross) # The rows are ordered from x12, ..., y162534 # sorted(list(set([subsNewMatrix[x][k] for x in range(0,len(subsNewMatrix)) for k in range(0, len(subsNewMatrix[x]))]))) # [0, +Infinity] # print newShift.values() # [-Cross0, 0, -Cross63, 0, -Cross12, -Cross90, -Cross18, -Cross21, 0, -Cross24, -Cross28, -Cross132, 0, -Cross37, -Cross41, 0, -Cross45, -Cross48, -Cross51, -Cross54, -Cross57, 0, -Cross66, -Cross69, -Cross73, 0, 0, -Cross81, -Cross84, -Cross102, -Cross15, -Cross93, -Cross60, -Cross99, -Cross87, -Cross105, -Cross110, 0, -Cross114, 0, -Cross120, -Cross123, -Cross126, -Cross129, -Cross30] # [k for k in newShift.keys() if newShift[k] == SR(0)] # [1, 3, 8, 12, 15, 21, 25, 26, 37, 39] (noRepeatedRows, rowsDict) = collectDistinctRowValuesAndKeys(subsNewMatrix) # noRepeatedRows # [[0, +Infinity, 0, 0, 0, 0, 0, 0, +Infinity, 0], # [0, 0, 0, 0, +Infinity, +Infinity, 0, 0, 0, 0], # [0, 0, 0, +Infinity, 0, 0, 0, 0, +Infinity, 0], # [0, 0, +Infinity, 0, 0, 0, +Infinity, 0, 0, 0], # [+Infinity, 0, 0, 0, 0, 0, 0, 0, +Infinity, 0], # [+Infinity, 0, 0, 0, 0, +Infinity, 0, 0, 0, 0], # [+Infinity, 0, 0, 0, 0, 0, 0, +Infinity, 0, 0], # [0, 0, 0, 0, +Infinity, 0, 0, +Infinity, 0, 0], # [0, +Infinity, 0, 0, 0, +Infinity, 0, 0, 0, 0], # [0, 0, 0, +Infinity, 0, 0, 0, 0, 0, +Infinity], # [0, +Infinity, 0, 0, 0, 0, +Infinity, 0, 0, 0], # [0, 0, 0, 0, +Infinity, 0, +Infinity, 0, 0, 0], # [0, 0, 0, 0, +Infinity, 0, 0, 0, +Infinity, 0], # [0, 0, 0, +Infinity, 0, 0, 0, +Infinity, 0, 0], # [0, 0, 0, +Infinity, 0, +Infinity, 0, 0, 0, 0], # [0, 0, +Infinity, 0, 0, 0, 0, 0, 0, +Infinity], # [0, +Infinity, 0, 0, 0, 0, 0, +Infinity, 0, 0], # [0, 0, 0, +Infinity, 0, 0, +Infinity, 0, 0, 0], # [0, 0, +Infinity, 0, 0, 0, 0, +Infinity, 0, 0], # [0, +Infinity, 0, 0, 0, 0, 0, 0, 0, +Infinity], # [0, 0, +Infinity, 0, 0, 0, 0, 0, +Infinity, 0], # [+Infinity, 0, 0, 0, 0, 0, +Infinity, 0, 0, 0], # [0, 0, +Infinity, 0, 0, +Infinity, 0, 0, 0, 0], # [+Infinity, 0, 0, 0, 0, 0, 0, 0, 0, +Infinity], # [0, 0, 0, 0, +Infinity, 0, 0, 0, 0, +Infinity]] # By symmetry we can also find a 3x3 non-singular minor here. anticRowKeys[extremal] = findingAnticKeysForDistinctRows(noRepeatedRows, rowsDict, keys) # print anticRowKeys[extremal] # {0: [X12, X32, X43, X62, Y152346], 1: [X13, X21, X45, Y123546, Y142536], 2: [X14], 3: [X15, X25, X51, X63, Y142635], 4: [X16], 5: [X23], 6: [X24, X41, X61, X65, Y152634], 7: [X26], 8: [X31], 9: [X34, X42, X52, X54, Y123645], 10: [X35], 11: [X36], 12: [X46], 13: [X53], 14: [X56], 15: [X64], 16: [Y123456], 17: [Y132456], 18: [Y132546], 19: [Y132645], 20: [Y142356], 21: [Y152436], 22: [Y162345], 23: [Y162435], 24: [Y162534]} ################# # (E1,F46) pair # ################# extremal = F46 InfinityBlockEntriesFirst[E1] [X12, X13, X14, X15, X16] InfinityBlockEntriesFirst[extremal] [X46, X64, Y123546, Y132546, Y152346] # We build the matrix and transpose it matrixPair = matrix(SR,[build10x10E1C[extremal][k] for k in range(0,10)]).transpose() # print matrixPair # [ 0 0 +Infinity 0 0 -Cross30 +Infinity -Cross30 -Cross30 -Cross30] # [ 0 +Infinity 0 0 0 -Cross30 -Cross30 -Cross30 +Infinity -Cross30] # [+Infinity 0 0 0 0 -Cross30 -Cross30 +Infinity -Cross30 -Cross30] # [ 0 0 0 0 +Infinity +Infinity -Cross30 -Cross30 -Cross30 -Cross30] # [ 0 0 0 +Infinity 0 -Cross30 -Cross30 -Cross30 -Cross30 +Infinity] # [ -Cross9 -Cross9 -Cross9 -Cross9 +Infinity +Infinity 0 0 0 0] # [ -Cross9 -Cross9 +Infinity -Cross9 -Cross9 0 +Infinity 0 0 0] # [+Infinity -Cross9 -Cross9 -Cross9 -Cross9 0 0 +Infinity 0 0] # [ -Cross9 -Cross9 -Cross9 +Infinity -Cross9 0 0 0 0 +Infinity] # [ -Cross9 +Infinity -Cross9 -Cross9 -Cross9 0 0 0 +Infinity 0] rows = [0,1,6,9] cols= [1,2,6,8] minorPair = matrixPair.matrix_from_rows_and_columns(rows,cols) # minorPair # [ 0 +Infinity +Infinity -Cross30] # [+Infinity 0 -Cross30 +Infinity] # [ -Cross9 +Infinity +Infinity 0] # [+Infinity -Cross9 0 +Infinity] # trop_minor = min('Infinity',0,-Cross30-Cross9, -Cross30-Cross9, 2*(-Cross30-Cross9)) # CONCLUDE: singular iff v(Cross9) = v(Cross30) = 0 dictCross = {SR(Cross9):0, SR(Cross30):0} # We look at the 45x10 matrix and extract the shift (newMatrix, newShift) = extractingTranslationv2(extremal, build10x45E1NonIntersectingPairs) # Next, we replace the Cross functions appearing on the matrix by 0, since we know their valuation. subsNewMatrix = replacingCrossesWith0(newMatrix,dictCross) # The rows are ordered from x12, ..., y162534 # sorted(list(set([subsNewMatrix[x][k] for x in range(0,len(subsNewMatrix)) for k in range(0, len(subsNewMatrix[x]))]))) # [0, +Infinity] # print newShift.values() # [-Cross0, -Cross3, -Cross63, 0, -Cross12, -Cross90, -Cross18, -Cross21, -Cross97, -Cross24, -Cross28, 0, 0, -Cross37, -Cross41, 0, -Cross45, -Cross48, -Cross51, -Cross54, -Cross57, -Cross6, -Cross66, -Cross69, 0, -Cross76, 0, 0, -Cross84, -Cross102, -Cross15, -Cross93, -Cross60, -Cross99, -Cross87, -Cross105, -Cross110, 0, -Cross114, -Cross117, -Cross120, 0, -Cross126, -Cross129, 0] # [k for k in newShift.keys() if newShift[k] == SR(0)] # [3, 11, 12, 15, 24, 26, 27, 37, 41, 44] (noRepeatedRows, rowsDict) = collectDistinctRowValuesAndKeys(subsNewMatrix) # noRepeatedRows # [[0, +Infinity, 0, 0, 0, 0, 0, 0, 0, +Infinity], # [0, 0, 0, 0, +Infinity, +Infinity, 0, 0, 0, 0], # [0, 0, 0, +Infinity, 0, +Infinity, 0, 0, 0, 0], # [0, 0, +Infinity, 0, 0, 0, 0, +Infinity, 0, 0], # [+Infinity, 0, 0, 0, 0, 0, 0, +Infinity, 0, 0], # [0, 0, 0, 0, +Infinity, 0, 0, +Infinity, 0, 0], # [+Infinity, 0, 0, 0, 0, +Infinity, 0, 0, 0, 0], # [+Infinity, 0, 0, 0, 0, 0, +Infinity, 0, 0, 0], # [0, 0, 0, 0, +Infinity, 0, 0, 0, +Infinity, 0], # [0, +Infinity, 0, 0, 0, +Infinity, 0, 0, 0, 0], # [0, +Infinity, 0, 0, 0, 0, +Infinity, 0, 0, 0], # [0, 0, 0, +Infinity, 0, 0, +Infinity, 0, 0, 0], # [0, 0, 0, 0, +Infinity, 0, +Infinity, 0, 0, 0], # [0, 0, 0, +Infinity, 0, 0, 0, 0, +Infinity, 0], # [0, 0, 0, +Infinity, 0, 0, 0, 0, 0, +Infinity], # [0, 0, +Infinity, 0, 0, 0, 0, 0, +Infinity, 0], # [0, +Infinity, 0, 0, 0, 0, 0, +Infinity, 0, 0], # [0, 0, 0, 0, +Infinity, 0, 0, 0, 0, +Infinity], # [0, 0, 0, +Infinity, 0, 0, 0, +Infinity, 0, 0], # [0, 0, +Infinity, 0, 0, 0, 0, 0, 0, +Infinity], # [0, +Infinity, 0, 0, 0, 0, 0, 0, +Infinity, 0], # [0, 0, +Infinity, 0, 0, 0, +Infinity, 0, 0, 0], # [+Infinity, 0, 0, 0, 0, 0, 0, 0, 0, +Infinity], # [0, 0, +Infinity, 0, 0, +Infinity, 0, 0, 0, 0], # [+Infinity, 0, 0, 0, 0, 0, 0, 0, +Infinity, 0]] # By symmetry we can also find a 3x3 non-singular minor here. anticRowKeys[extremal] = findingAnticKeysForDistinctRows(noRepeatedRows, rowsDict, keys) # print anticRowKeys[extremal] # {0: [X12, X32, X43, X62, Y152346], 1: [X13], 2: [X14, X34, X53, X56, Y132456], 3: [X15, X25, X51, X63, Y142635], 4: [X16], 5: [X21], 6: [X23], 7: [X24, X41, X61, X65, Y152634], 8: [X26, X36, X46, Y142536, Y162534], 9: [X31], 10: [X35], 11: [X42], 12: [X45], 13: [X52], 14: [X54], 15: [X64], 16: [Y123456], 17: [Y123546], 18: [Y123645], 19: [Y132546], 20: [Y132645], 21: [Y142356], 22: [Y152436], 23: [Y162345], 24: [Y162435]} ################# # (E1,F56) pair # ################# extremal = F56 InfinityBlockEntriesFirst[E1] [X12, X13, X14, X15, X16] InfinityBlockEntriesFirst[extremal] [X56, X65, Y123456, Y132456, Y142356] # We build the matrix and transpose it matrixPair = matrix(SR,[build10x10E1C[extremal][k] for k in range(0,10)]).transpose() # print matrixPair # [ 0 0 +Infinity 0 0 -Cross48 -Cross48 -Cross48 -Cross48 +Infinity] # [ 0 +Infinity 0 0 0 -Cross48 -Cross48 -Cross48 +Infinity -Cross48] # [+Infinity 0 0 0 0 -Cross48 -Cross48 +Infinity -Cross48 -Cross48] # [ 0 0 0 0 +Infinity +Infinity -Cross48 -Cross48 -Cross48 -Cross48] # [ 0 0 0 +Infinity 0 -Cross48 +Infinity -Cross48 -Cross48 -Cross48] # [+Infinity -Cross9 -Cross9 -Cross9 -Cross9 0 0 +Infinity 0 0] # [ -Cross9 -Cross9 -Cross9 +Infinity -Cross9 0 +Infinity 0 0 0] # [ -Cross9 +Infinity -Cross9 -Cross9 -Cross9 0 0 0 +Infinity 0] # [ -Cross9 -Cross9 -Cross9 -Cross9 +Infinity +Infinity 0 0 0 0] # [ -Cross9 -Cross9 +Infinity -Cross9 -Cross9 0 0 0 0 +Infinity] rows = [0,1,7,9] cols= [1,2,8,9] minorPair = matrixPair.matrix_from_rows_and_columns(rows,cols) # minorPair # [ 0 +Infinity -Cross48 +Infinity] # [+Infinity 0 +Infinity -Cross48] # [+Infinity -Cross9 +Infinity 0] # [ -Cross9 +Infinity 0 +Infinity] # trop_minor = min('Infinity',0,-Cross48-Cross9, -Cross48-Cross9, 2*(-Cross48-Cross9)) # CONCLUDE: singular iff v(Cross9) = v(Cross48) = 0 dictCross = {SR(Cross9):0, SR(Cross48):0} # We look at the 45x10 matrix and extract the shift (newMatrix, newShift) = extractingTranslationv2(extremal, build10x45E1NonIntersectingPairs) # Next, we replace the Cross functions appearing on the matrix by 0, since we know their valuation. subsNewMatrix = replacingCrossesWith0(newMatrix,dictCross) # The rows are ordered from x12, ..., y162534 # sorted(list(set([subsNewMatrix[x][k] for x in range(0,len(subsNewMatrix)) for k in range(0, len(subsNewMatrix[x]))]))) # [0, +Infinity] # print newShift.values() # [-Cross0, -Cross3, -Cross63, 0, -Cross12, -Cross90, -Cross18, -Cross21, -Cross97, -Cross24, -Cross28, -Cross132, 0, -Cross37, -Cross41, 0, -Cross45, 0, 0, -Cross54, 0, -Cross6, 0, -Cross69, -Cross73, -Cross76, 0, -Cross81, -Cross84, -Cross102, -Cross15, -Cross93, -Cross60, -Cross99, -Cross87, -Cross105, -Cross110, 0, -Cross114, -Cross117, -Cross120, -Cross123, -Cross126, 0, -Cross30] # [k for k in newShift.keys() if newShift[k] == SR(0)] # [3, 12, 15, 17, 18, 20, 22, 26, 37, 43] (noRepeatedRows, rowsDict) = collectDistinctRowValuesAndKeys(subsNewMatrix) # noRepeatedRows # [[0, +Infinity, 0, 0, 0, 0, 0, +Infinity, 0, 0], # [0, 0, 0, 0, +Infinity, 0, +Infinity, 0, 0, 0], # [0, 0, 0, +Infinity, 0, 0, 0, 0, +Infinity, 0], # [0, 0, +Infinity, 0, 0, +Infinity, 0, 0, 0, 0], # [+Infinity, 0, 0, 0, 0, 0, 0, 0, 0, +Infinity], # [+Infinity, 0, 0, 0, 0, 0, 0, +Infinity, 0, 0], # [0, 0, 0, 0, +Infinity, 0, 0, 0, +Infinity, 0], # [0, +Infinity, 0, 0, 0, +Infinity, 0, 0, 0, 0], # [0, +Infinity, 0, 0, 0, 0, +Infinity, 0, 0, 0], # [0, 0, 0, 0, +Infinity, 0, 0, +Infinity, 0, 0], # [0, 0, 0, +Infinity, 0, 0, +Infinity, 0, 0, 0], # [0, 0, 0, 0, +Infinity, +Infinity, 0, 0, 0, 0], # [0, 0, 0, +Infinity, 0, 0, 0, 0, 0, +Infinity], # [0, 0, 0, +Infinity, 0, +Infinity, 0, 0, 0, 0], # [+Infinity, 0, 0, 0, 0, 0, 0, 0, +Infinity, 0], # [0, 0, +Infinity, 0, 0, 0, 0, 0, 0, +Infinity], # [+Infinity, 0, 0, 0, 0, +Infinity, 0, 0, 0, 0], # [0, +Infinity, 0, 0, 0, 0, 0, 0, +Infinity, 0], # [0, 0, 0, +Infinity, 0, 0, 0, +Infinity, 0, 0], # [0, 0, +Infinity, 0, 0, 0, 0, 0, +Infinity, 0], # [0, +Infinity, 0, 0, 0, 0, 0, 0, 0, +Infinity], # [0, 0, +Infinity, 0, 0, 0, +Infinity, 0, 0, 0], # [+Infinity, 0, 0, 0, 0, 0, +Infinity, 0, 0, 0], # [0, 0, +Infinity, 0, 0, 0, 0, +Infinity, 0, 0], # [0, 0, 0, 0, +Infinity, 0, 0, 0, 0, +Infinity]] # By symmetry we can also find a 3x3 non-singular minor here. anticRowKeys[extremal] = findingAnticKeysForDistinctRows(noRepeatedRows, rowsDict, keys) # print anticRowKeys[extremal] # {0: [X12, X32, X43, X62, Y152346], 1: [X13, X21, X45, Y123546, Y142536], 2: [X14, X34, X53, X56, Y132456], 3: [X15, X25, X51, X63, Y142635], 4: [X16, X23, X41, Y152436, Y162435], 5: [X24], 6: [X26], 7: [X31], 8: [X35], 9: [X36], 10: [X42], 11: [X46], 12: [X52], 13: [X54], 14: [X61], 15: [X64], 16: [X65], 17: [Y123456], 18: [Y123645], 19: [Y132546], 20: [Y132645], 21: [Y142356], 22: [Y152634], 23: [Y162345], 24: [Y162534]} ################ # (E1,G1) pair # ################ extremal = G1 InfinityBlockEntriesFirst[E1] [X12, X13, X14, X15, X16] InfinityBlockEntriesFirst[extremal] [X21, X31, X41, X51, X61] # We build the matrix and transpose it matrixPair = matrix(SR,[build10x10E1C[extremal][k] for k in range(0,10)]).transpose() # print matrixPair # [ 0 0 +Infinity 0 0 -Cross0 -Cross0 +Infinity -Cross0 -Cross0] # [ 0 +Infinity 0 0 0 -Cross0 +Infinity -Cross0 -Cross0 -Cross0] # [+Infinity 0 0 0 0 +Infinity -Cross0 -Cross0 -Cross0 -Cross0] # [ 0 0 0 0 +Infinity -Cross0 -Cross0 -Cross0 -Cross0 +Infinity] # [ 0 0 0 +Infinity 0 -Cross0 -Cross0 -Cross0 +Infinity -Cross0] # [ -Cross9 -Cross9 +Infinity -Cross9 -Cross9 0 0 +Infinity 0 0] # [ -Cross9 +Infinity -Cross9 -Cross9 -Cross9 0 +Infinity 0 0 0] # [+Infinity -Cross9 -Cross9 -Cross9 -Cross9 +Infinity 0 0 0 0] # [ -Cross9 -Cross9 -Cross9 -Cross9 +Infinity 0 0 0 0 +Infinity] # [ -Cross9 -Cross9 -Cross9 +Infinity -Cross9 0 0 0 +Infinity 0] rows = [0,1,5,6] cols= [1,2,6,7] minorPair = matrixPair.matrix_from_rows_and_columns(rows,cols) # minorPair # [ 0 +Infinity -Cross0 +Infinity] # [+Infinity 0 +Infinity -Cross0] # [ -Cross9 +Infinity 0 +Infinity] # [+Infinity -Cross9 +Infinity 0] # trop_minor = min('Infinity',0,-Cross0-Cross9, -Cross0-Cross9, 2*(-Cross0-Cross9)) # CONCLUDE: singular iff v(Cross9) = v(Cross0) = 0 dictCross = {SR(Cross9):0, SR(Cross0):0} # We look at the 45x10 matrix and extract the shift (newMatrix, newShift) = extractingTranslationv2(extremal, build10x45E1NonIntersectingPairs) # Next, we replace the Cross functions appearing on the matrix by 0, since we know their valuation. subsNewMatrix = replacingCrossesWith0(newMatrix,dictCross) # The rows are ordered from x12, ..., y162534 # sorted(list(set([subsNewMatrix[x][k] for x in range(0,len(subsNewMatrix)) for k in range(0, len(subsNewMatrix[x]))]))) # [0, +Infinity] # print newShift.values() # [0, -Cross3, -Cross63, 0, -Cross12, -Cross90, 0, -Cross21, -Cross97, 0, -Cross28, -Cross132, 0, -Cross37, -Cross41, 0, 0, -Cross48, -Cross51, -Cross54, -Cross57, -Cross6, -Cross66, -Cross69, -Cross73, -Cross76, 0, -Cross81, -Cross84, -Cross102, -Cross15, -Cross93, -Cross60, -Cross99, -Cross87, -Cross105, -Cross110, 0, 0, -Cross117, -Cross120, -Cross123, -Cross126, -Cross129, -Cross30] # [k for k in newShift.keys() if newShift[k] == SR(0)] # [0, 3, 6, 9, 12, 15, 16, 26, 37, 38] (noRepeatedRows, rowsDict) = collectDistinctRowValuesAndKeys(subsNewMatrix) # noRepeatedRows # [[0, +Infinity, 0, 0, 0, 0, +Infinity, 0, 0, 0], # [0, 0, 0, 0, +Infinity, +Infinity, 0, 0, 0, 0], # [0, 0, 0, +Infinity, 0, 0, 0, +Infinity, 0, 0], # [0, 0, +Infinity, 0, 0, 0, 0, +Infinity, 0, 0], # [+Infinity, 0, 0, 0, 0, +Infinity, 0, 0, 0, 0], # [0, 0, 0, 0, +Infinity, 0, +Infinity, 0, 0, 0], # [+Infinity, 0, 0, 0, 0, 0, 0, +Infinity, 0, 0], # [0, 0, 0, 0, +Infinity, 0, 0, 0, 0, +Infinity], # [0, +Infinity, 0, 0, 0, +Infinity, 0, 0, 0, 0], # [0, 0, 0, +Infinity, 0, 0, 0, 0, +Infinity, 0], # [0, +Infinity, 0, 0, 0, 0, 0, 0, +Infinity, 0], # [0, 0, 0, 0, +Infinity, 0, 0, 0, +Infinity, 0], # [0, 0, 0, +Infinity, 0, 0, 0, 0, 0, +Infinity], # [0, 0, 0, +Infinity, 0, +Infinity, 0, 0, 0, 0], # [+Infinity, 0, 0, 0, 0, 0, 0, 0, 0, +Infinity], # [0, 0, +Infinity, 0, 0, 0, +Infinity, 0, 0, 0], # [+Infinity, 0, 0, 0, 0, 0, +Infinity, 0, 0, 0], # [0, +Infinity, 0, 0, 0, 0, 0, 0, 0, +Infinity], # [0, 0, 0, 0, +Infinity, 0, 0, +Infinity, 0, 0], # [0, 0, 0, +Infinity, 0, 0, +Infinity, 0, 0, 0], # [0, 0, +Infinity, 0, 0, 0, 0, 0, 0, +Infinity], # [0, +Infinity, 0, 0, 0, 0, 0, +Infinity, 0, 0], # [0, 0, +Infinity, 0, 0, 0, 0, 0, +Infinity, 0], # [+Infinity, 0, 0, 0, 0, 0, 0, 0, +Infinity, 0], # [0, 0, +Infinity, 0, 0, +Infinity, 0, 0, 0, 0]] # By symmetry we can also find a 3x3 non-singular minor here. anticRowKeys[extremal] = findingAnticKeysForDistinctRows(noRepeatedRows, rowsDict, keys) # print anticRowKeys[extremal] # {0: [X12, X32, X43, X62, Y152346], 1: [X13], 2: [X14], 3: [X15, X25, X51, X63, Y142635], 4: [X16, X23, X41, Y152436, Y162435], 5: [X21], 6: [X24], 7: [X26, X36, X46, Y142536, Y162534], 8: [X31], 9: [X34, X42, X52, X54, Y123645], 10: [X35], 11: [X45], 12: [X53], 13: [X56], 14: [X61], 15: [X64], 16: [X65], 17: [Y123456], 18: [Y123546], 19: [Y132456], 20: [Y132546], 21: [Y132645], 22: [Y142356], 23: [Y152634], 24: [Y162345]} ###################### # Intersecting pairs # ###################### # For the intersecting pairs, the 10x10 matrix that worked for the non-intersecting pairs fails to provide an non-singular 4x4 minor. # build10x45E1IntersectingPairs = dict() # for extremal in [F12,F13, F14, F15, F16, G2, G3, G4, G5, G6]: # newMatrix = [] # print extremal # for k in range(0,5): # print k # newRow = [SR(unshiftedTropLInkExtremal[E1][k][key]).substitute(PairsOfExtremalsWithE1AndCrossDict[extremal]) for key in unshiftedTropLInkExtremal[E1][k].keys()] # newMatrix.append(newRow) # for k in range(0,5): # print k+5 # newRow = [SR(unshiftedTropLInkExtremal[extremal][k][key]).substitute(PairsOfExtremalsWithE1AndCrossDict[extremal]) for key in unshiftedTropLInkExtremal[extremal][k].keys()] # newMatrix.append(newRow) # build10x45E1IntersectingPairs[extremal] = matrix(SR,newMatrix) # save(build10x45E1IntersectingPairs, 'Input/build10x45E1IntersectingPairs.sobj') build10x45E1IntersectingPairs = load('Input/build10x45E1IntersectingPairs.sobj') ################# # (E1,F12) pair # ################# extremal = F12 InfinityBlockEntriesFirst[E1] [X12, X13, X14, X15, X16] InfinityBlockEntriesFirst[extremal] [X12, X21, Y123456, Y123546, Y123645] # We build the matrix and transpose it matrixPair = matrix(SR,[build10x10E1C[extremal][k] for k in range(0,10)]).transpose() # print matrixPair # [ 0 0 +Infinity 0 0 0 -Cross9 -Cross9 -Cross9 -Cross9] # [ 0 +Infinity 0 0 0 0 -Cross9 -Cross9 -Cross9 -Cross9] # [+Infinity 0 0 0 0 +Infinity +Infinity +Infinity +Infinity +Infinity] # [ 0 0 0 0 +Infinity 0 -Cross9 -Cross9 -Cross9 -Cross9] # [ 0 0 0 +Infinity 0 0 -Cross9 -Cross9 -Cross9 -Cross9] # [ 0 -Cross9 -Cross9 -Cross9 -Cross9 0 0 +Infinity 0 0] # [ 0 -Cross9 -Cross9 -Cross9 -Cross9 0 0 0 0 +Infinity] # [ 0 -Cross9 -Cross9 -Cross9 -Cross9 0 0 0 +Infinity 0] # [ 0 -Cross9 -Cross9 -Cross9 -Cross9 0 +Infinity 0 0 0] # [+Infinity +Infinity +Infinity +Infinity +Infinity +Infinity 0 0 0 0] # No minor computation leads to any restrictions. # We look at the 45x10 matrix and extract the shift (newMatrix, newShift) = extractingTranslationv2(extremal, build10x45E1IntersectingPairs) # The rows are ordered from x12, ..., y162534 # newMatrix # [[0, +Infinity, 0, 0, 0, 0, 0, 0, +Infinity, 0], # [0, 0, 0, 0, +Infinity, 0, +Infinity, 0, 0, 0], # [0, 0, 0, +Infinity, 0, 0, 0, 0, +Infinity, 0], # [0, 0, +Infinity, 0, 0, 0, 0, 0, 0, +Infinity], # [+Infinity, 0, 0, 0, 0, 0, 0, +Infinity, 0, 0], # [0, 0, 0, 0, +Infinity, 0, 0, +Infinity, 0, 0], # [+Infinity, 0, 0, 0, 0, 0, 0, 0, +Infinity, 0], # [+Infinity, 0, 0, 0, 0, 0, 0, 0, +Infinity, 0], # [-Cross9, -Cross9, +Infinity, -Cross9, -Cross9, 0, +Infinity, 0, 0, 0], # [0, 0, 0, 0, +Infinity, 0, 0, 0, +Infinity, 0], # [0, +Infinity, 0, 0, 0, +Infinity, 0, 0, 0, 0], # [0, +Infinity, 0, 0, 0, 0, 0, +Infinity, 0, 0], # [0, 0, 0, +Infinity, 0, -Cross9, -Cross9, -Cross9, -Cross9, +Infinity], # [0, +Infinity, 0, 0, 0, 0, +Infinity, 0, 0, 0], # [0, 0, 0, 0, +Infinity, 0, +Infinity, 0, 0, 0], # [+Infinity, 0, 0, 0, 0, -Cross9, -Cross9, -Cross9, -Cross9, +Infinity], # [0, 0, 0, +Infinity, 0, 0, 0, 0, +Infinity, 0], # [0, +Infinity, 0, 0, 0, +Infinity, 0, 0, 0, 0], # [0, 0, 0, 0, +Infinity, +Infinity, 0, 0, 0, 0], # [0, 0, 0, 0, +Infinity, +Infinity, 0, 0, 0, 0], # [-Cross9, -Cross9, +Infinity, -Cross9, -Cross9, +Infinity, 0, 0, 0, 0], # [0, 0, 0, +Infinity, 0, 0, +Infinity, 0, 0, 0], # [0, 0, 0, +Infinity, 0, +Infinity, 0, 0, 0, 0], # [0, 0, 0, +Infinity, 0, +Infinity, 0, 0, 0, 0], # [0, 0, 0, +Infinity, 0, 0, 0, +Infinity, 0, 0], # [+Infinity, 0, 0, 0, 0, 0, +Infinity, 0, 0, 0], # [0, +Infinity, 0, 0, 0, -Cross9, -Cross9, -Cross9, -Cross9, +Infinity], # [-Cross9, -Cross9, +Infinity, -Cross9, -Cross9, 0, 0, +Infinity, 0, 0], # [0, 0, +Infinity, 0, 0, 0, 0, 0, 0, +Infinity], # [+Infinity, 0, 0, 0, 0, +Infinity, 0, 0, 0, 0], # [0, +Infinity, 0, 0, 0, 0, 0, +Infinity, 0, 0], # [0, 0, 0, 0, +Infinity, 0, 0, 0, +Infinity, 0], # [0, 0, 0, +Infinity, 0, 0, 0, +Infinity, 0, 0], # [0, 0, 0, +Infinity, 0, 0, +Infinity, 0, 0, 0], # [0, 0, +Infinity, 0, 0, 0, 0, 0, 0, +Infinity], # [0, +Infinity, 0, 0, 0, 0, 0, 0, +Infinity, 0], # [0, 0, +Infinity, 0, 0, 0, 0, 0, 0, +Infinity], # [0, 0, 0, 0, +Infinity, -Cross9, -Cross9, -Cross9, -Cross9, +Infinity], # [-Cross9, -Cross9, +Infinity, -Cross9, -Cross9, 0, 0, 0, +Infinity, 0], # [0, +Infinity, 0, 0, 0, 0, +Infinity, 0, 0, 0], # [+Infinity, 0, 0, 0, 0, 0, +Infinity, 0, 0, 0], # [+Infinity, 0, 0, 0, 0, 0, 0, +Infinity, 0, 0], # [0, 0, +Infinity, 0, 0, 0, 0, 0, 0, +Infinity], # [+Infinity, 0, 0, 0, 0, +Infinity, 0, 0, 0, 0], # [0, 0, 0, 0, +Infinity, 0, 0, +Infinity, 0, 0]] # print newShift.values() # [-Cross0, -Cross3, -Cross63, 0, -Cross12, -Cross90, -Cross18, -Cross21, 0, -Cross24, -Cross28, -Cross132, 0, -Cross37, -Cross41, 0, -Cross45, -Cross48, -Cross51, -Cross54, 0, -Cross6, -Cross66, -Cross69, -Cross73, -Cross76, 0, 0, -Cross84, -Cross102, -Cross15, -Cross93, -Cross60, -Cross99, -Cross87, -Cross105, -Cross110, 0, 0, -Cross117, -Cross120, -Cross123, -Cross126, -Cross129, -Cross30] # [k for k in newShift.keys() if newShift[k] == SR(0)] # [3, 8, 12, 15, 20, 26, 27, 37, 38] (noRepeatedRows, rowsDict) =collectDistinctRowValuesAndKeys(newMatrix) # noRepeatedRows # [[0, +Infinity, 0, 0, 0, 0, 0, 0, +Infinity, 0], # [0, 0, 0, 0, +Infinity, 0, +Infinity, 0, 0, 0], # [0, 0, 0, +Infinity, 0, 0, 0, 0, +Infinity, 0], # [0, 0, +Infinity, 0, 0, 0, 0, 0, 0, +Infinity], # [+Infinity, 0, 0, 0, 0, 0, 0, +Infinity, 0, 0], # [0, 0, 0, 0, +Infinity, 0, 0, +Infinity, 0, 0], # [+Infinity, 0, 0, 0, 0, 0, 0, 0, +Infinity, 0], # [-Cross9, -Cross9, +Infinity, -Cross9, -Cross9, 0, +Infinity, 0, 0, 0], # [0, 0, 0, 0, +Infinity, 0, 0, 0, +Infinity, 0], # [0, +Infinity, 0, 0, 0, +Infinity, 0, 0, 0, 0], # [0, +Infinity, 0, 0, 0, 0, 0, +Infinity, 0, 0], # [0, 0, 0, +Infinity, 0, -Cross9, -Cross9, -Cross9, -Cross9, +Infinity], # [0, +Infinity, 0, 0, 0, 0, +Infinity, 0, 0, 0], # [+Infinity, 0, 0, 0, 0, -Cross9, -Cross9, -Cross9, -Cross9, +Infinity], # [0, 0, 0, 0, +Infinity, +Infinity, 0, 0, 0, 0], # [-Cross9, -Cross9, +Infinity, -Cross9, -Cross9, +Infinity, 0, 0, 0, 0], # [0, 0, 0, +Infinity, 0, 0, +Infinity, 0, 0, 0], # [0, 0, 0, +Infinity, 0, +Infinity, 0, 0, 0, 0], # [0, 0, 0, +Infinity, 0, 0, 0, +Infinity, 0, 0], # [+Infinity, 0, 0, 0, 0, 0, +Infinity, 0, 0, 0], # [0, +Infinity, 0, 0, 0, -Cross9, -Cross9, -Cross9, -Cross9, +Infinity], # [-Cross9, -Cross9, +Infinity, -Cross9, -Cross9, 0, 0, +Infinity, 0, 0], # [+Infinity, 0, 0, 0, 0, +Infinity, 0, 0, 0, 0], # [0, 0, 0, 0, +Infinity, -Cross9, -Cross9, -Cross9, -Cross9, +Infinity], # [-Cross9, -Cross9, +Infinity, -Cross9, -Cross9, 0, 0, 0, +Infinity, 0]] # We find a non-singular 3x3 minor: # matrix(SR, noRepeatedRows).matrix_from_rows_and_columns([13,15,19],[0,8,9]) # [+Infinity -Cross9 +Infinity] # [ -Cross9 0 0] # [+Infinity 0 0] anticRowKeys[extremal] = findingAnticKeysForDistinctRows(noRepeatedRows, rowsDict, keys) # print anticRowKeys[extremal] # {0: [X12, Y132645], 1: [X13, X36], 2: [X14, X42], 3: [X15, X64, Y132546, Y142356, Y162345], 4: [X16, Y152634], 5: [X21, Y162534], 6: [X23, X24], 7: [X25], 8: [X26, Y123546], 9: [X31, X43], 10: [X32, Y123456], 11: [X34], 12: [X35, Y152346], 13: [X41], 14: [X45, X46], 15: [X51], 16: [X52, Y132456], 17: [X53, X54], 18: [X56, Y123645], 19: [X61, Y152436], 20: [X62], 21: [X63], 22: [X65, Y162435], 23: [Y142536], 24: [Y142635]} ################# # (E1,F13) pair # ################# extremal = F13 InfinityBlockEntriesFirst[E1] [X12, X13, X14, X15, X16] InfinityBlockEntriesFirst[extremal] [X13, X31, Y132456, Y132546, Y132645] # We build the matrix and transpose it matrixPair = matrix(SR,[build10x10E1C[extremal][k] for k in range(0,10)]).transpose() # print matrixPair # [ 0 0 +Infinity 0 0 0 -Cross0 -Cross0 -Cross0 -Cross0] # [ 0 +Infinity 0 0 0 +Infinity +Infinity +Infinity +Infinity +Infinity] # [+Infinity 0 0 0 0 0 -Cross0 -Cross0 -Cross0 -Cross0] # [ 0 0 0 0 +Infinity 0 -Cross0 -Cross0 -Cross0 -Cross0] # [ 0 0 0 +Infinity 0 0 -Cross0 -Cross0 -Cross0 -Cross0] # [ -Cross0 0 -Cross0 -Cross0 -Cross0 0 0 +Infinity 0 0] # [ -Cross0 0 -Cross0 -Cross0 -Cross0 0 +Infinity 0 0 0] # [+Infinity +Infinity +Infinity +Infinity +Infinity +Infinity 0 0 0 0] # [ -Cross0 0 -Cross0 -Cross0 -Cross0 0 0 0 +Infinity 0] # [ -Cross0 0 -Cross0 -Cross0 -Cross0 0 0 0 0 +Infinity] # No minor computation leads to any restrictions. # We look at the 45x10 matrix and extract the shift (newMatrix, newShift) = extractingTranslationv2(extremal, build10x45E1IntersectingPairs) # The rows are ordered from x12, ..., y162534 # newMatrix # [[-Cross0, +Infinity, -Cross0, -Cross0, -Cross0, 0, +Infinity, 0, 0, 0], # [0, 0, 0, 0, +Infinity, 0, 0, 0, 0, +Infinity], # [0, 0, 0, +Infinity, 0, 0, 0, 0, 0, +Infinity], # [0, 0, +Infinity, 0, 0, -Cross0, -Cross0, +Infinity, -Cross0, -Cross0], # [+Infinity, 0, 0, 0, 0, 0, 0, 0, 0, +Infinity], # [0, 0, 0, 0, +Infinity, 0, +Infinity, 0, 0, 0], # [+Infinity, 0, 0, 0, 0, 0, +Infinity, 0, 0, 0], # [+Infinity, 0, 0, 0, 0, +Infinity, 0, 0, 0, 0], # [0, 0, +Infinity, 0, 0, 0, 0, 0, 0, +Infinity], # [0, 0, 0, 0, +Infinity, 0, +Infinity, 0, 0, 0], # [0, +Infinity, 0, 0, 0, 0, 0, +Infinity, 0, 0], # [-Cross0, +Infinity, -Cross0, -Cross0, -Cross0, 0, 0, 0, +Infinity, 0], # [0, 0, 0, +Infinity, 0, -Cross0, -Cross0, +Infinity, -Cross0, -Cross0], # [0, +Infinity, 0, 0, 0, 0, 0, +Infinity, 0, 0], # [0, 0, 0, 0, +Infinity, +Infinity, 0, 0, 0, 0], # [+Infinity, 0, 0, 0, 0, -Cross0, -Cross0, +Infinity, -Cross0, -Cross0], # [0, 0, 0, +Infinity, 0, 0, +Infinity, 0, 0, 0], # [-Cross0, +Infinity, -Cross0, -Cross0, -Cross0, +Infinity, 0, 0, 0, 0], # [0, 0, 0, 0, +Infinity, +Infinity, 0, 0, 0, 0], # [0, 0, 0, 0, +Infinity, 0, 0, 0, 0, +Infinity], # [0, 0, +Infinity, 0, 0, +Infinity, 0, 0, 0, 0], # [0, 0, 0, +Infinity, 0, 0, 0, 0, 0, +Infinity], # [0, 0, 0, +Infinity, 0, +Infinity, 0, 0, 0, 0], # [0, 0, 0, +Infinity, 0, 0, 0, 0, +Infinity, 0], # [0, 0, 0, +Infinity, 0, 0, 0, 0, +Infinity, 0], # [+Infinity, 0, 0, 0, 0, 0, 0, 0, 0, +Infinity], # [0, +Infinity, 0, 0, 0, 0, 0, +Infinity, 0, 0], # [0, 0, +Infinity, 0, 0, 0, 0, 0, +Infinity, 0], # [0, 0, +Infinity, 0, 0, 0, +Infinity, 0, 0, 0], # [+Infinity, 0, 0, 0, 0, 0, +Infinity, 0, 0, 0], # [0, +Infinity, 0, 0, 0, 0, 0, +Infinity, 0, 0], # [0, 0, 0, 0, +Infinity, 0, 0, 0, +Infinity, 0], # [0, 0, 0, +Infinity, 0, +Infinity, 0, 0, 0, 0], # [0, 0, 0, +Infinity, 0, 0, +Infinity, 0, 0, 0], # [0, 0, +Infinity, 0, 0, 0, 0, 0, +Infinity, 0], # [0, +Infinity, 0, 0, 0, 0, 0, +Infinity, 0, 0], # [0, 0, +Infinity, 0, 0, 0, 0, 0, 0, +Infinity], # [0, 0, 0, 0, +Infinity, -Cross0, -Cross0, +Infinity, -Cross0, -Cross0], # [0, 0, +Infinity, 0, 0, 0, +Infinity, 0, 0, 0], # [-Cross0, +Infinity, -Cross0, -Cross0, -Cross0, 0, 0, 0, 0, +Infinity], # [+Infinity, 0, 0, 0, 0, 0, 0, 0, +Infinity, 0], # [+Infinity, 0, 0, 0, 0, 0, 0, 0, +Infinity, 0], # [0, 0, +Infinity, 0, 0, +Infinity, 0, 0, 0, 0], # [+Infinity, 0, 0, 0, 0, +Infinity, 0, 0, 0, 0], # [0, 0, 0, 0, +Infinity, 0, 0, 0, +Infinity, 0]] # print newShift.values() # [0, -Cross3, -Cross63, 0, -Cross12, -Cross90, -Cross18, -Cross21, -Cross97, -Cross24, -Cross28, 0, 0, -Cross37, -Cross41, 0, -Cross45, 0, -Cross51, -Cross54, -Cross57, -Cross6, -Cross66, -Cross69, -Cross73, -Cross76, 0, -Cross81, -Cross84, -Cross102, -Cross15, -Cross93, -Cross60, -Cross99, -Cross87, -Cross105, -Cross110, 0, -Cross114, 0, -Cross120, -Cross123, -Cross126, -Cross129, -Cross30] # [k for k in newShift.keys() if newShift[k] == SR(0)] # [0, 3, 11, 12, 15, 17, 26, 37, 39] (noRepeatedRows, rowsDict) =collectDistinctRowValuesAndKeys(newMatrix) # noRepeatedRows # [[-Cross0, +Infinity, -Cross0, -Cross0, -Cross0, 0, +Infinity, 0, 0, 0], # [0, 0, 0, 0, +Infinity, 0, 0, 0, 0, +Infinity], # [0, 0, 0, +Infinity, 0, 0, 0, 0, 0, +Infinity], # [0, 0, +Infinity, 0, 0, -Cross0, -Cross0, +Infinity, -Cross0, -Cross0], # [+Infinity, 0, 0, 0, 0, 0, 0, 0, 0, +Infinity], # [0, 0, 0, 0, +Infinity, 0, +Infinity, 0, 0, 0], # [+Infinity, 0, 0, 0, 0, 0, +Infinity, 0, 0, 0], # [+Infinity, 0, 0, 0, 0, +Infinity, 0, 0, 0, 0], # [0, 0, +Infinity, 0, 0, 0, 0, 0, 0, +Infinity], # [0, +Infinity, 0, 0, 0, 0, 0, +Infinity, 0, 0], # [-Cross0, +Infinity, -Cross0, -Cross0, -Cross0, 0, 0, 0, +Infinity, 0], # [0, 0, 0, +Infinity, 0, -Cross0, -Cross0, +Infinity, -Cross0, -Cross0], # [0, 0, 0, 0, +Infinity, +Infinity, 0, 0, 0, 0], # [+Infinity, 0, 0, 0, 0, -Cross0, -Cross0, +Infinity, -Cross0, -Cross0], # [0, 0, 0, +Infinity, 0, 0, +Infinity, 0, 0, 0], # [-Cross0, +Infinity, -Cross0, -Cross0, -Cross0, +Infinity, 0, 0, 0, 0], # [0, 0, +Infinity, 0, 0, +Infinity, 0, 0, 0, 0], # [0, 0, 0, +Infinity, 0, +Infinity, 0, 0, 0, 0], # [0, 0, 0, +Infinity, 0, 0, 0, 0, +Infinity, 0], # [0, 0, +Infinity, 0, 0, 0, 0, 0, +Infinity, 0], # [0, 0, +Infinity, 0, 0, 0, +Infinity, 0, 0, 0], # [0, 0, 0, 0, +Infinity, 0, 0, 0, +Infinity, 0], # [0, 0, 0, 0, +Infinity, -Cross0, -Cross0, +Infinity, -Cross0, -Cross0], # [-Cross0, +Infinity, -Cross0, -Cross0, -Cross0, 0, 0, 0, 0, +Infinity], # [+Infinity, 0, 0, 0, 0, 0, 0, 0, +Infinity, 0]] # By symmetry we can also find a 3x3 non-singular minor here. anticRowKeys[extremal] = findingAnticKeysForDistinctRows(noRepeatedRows, rowsDict, keys) # print anticRowKeys[extremal] {0: [X12], 1: [X13, X46], 2: [X14, X52], 3: [X15], 4: [X16, X61], 5: [X21, X26], 6: [X23, X65], 7: [X24, Y162435], 8: [X25, Y142356], 9: [X31, X35, X62, Y123456, Y132645], 10: [X32], 11: [X34], 12: [X36, X45], 13: [X41], 14: [X42, Y132456], 15: [X43], 16: [X51, Y162345], 17: [X53, Y123645], 18: [X54, X56], 19: [X63, Y132546], 20: [X64, Y142635], 21: [Y123546, Y162534], 22: [Y142536], 23: [Y152346], 24: [Y152436, Y152634]} ################# # (E1,F14) pair # ################# extremal = F14 InfinityBlockEntriesFirst[E1] [X12, X13, X14, X15, X16] InfinityBlockEntriesFirst[extremal] [X14, X41, Y142356, Y142536, Y142635] # We build the matrix and transpose it matrixPair = matrix(SR,[build10x10E1C[extremal][k] for k in range(0,10)]).transpose() # print matrixPair # [ 0 0 +Infinity 0 0 +Infinity +Infinity +Infinity +Infinity +Infinity] # [ 0 +Infinity 0 0 0 0 -Cross9 -Cross9 -Cross9 -Cross9] # [+Infinity 0 0 0 0 0 -Cross9 -Cross9 -Cross9 -Cross9] # [ 0 0 0 0 +Infinity 0 -Cross9 -Cross9 -Cross9 -Cross9] # [ 0 0 0 +Infinity 0 0 -Cross9 -Cross9 -Cross9 -Cross9] # [ -Cross9 -Cross9 0 -Cross9 -Cross9 0 0 +Infinity 0 0] # [ -Cross9 -Cross9 0 -Cross9 -Cross9 0 +Infinity 0 0 0] # [ -Cross9 -Cross9 0 -Cross9 -Cross9 0 0 0 +Infinity 0] # [+Infinity +Infinity +Infinity +Infinity +Infinity +Infinity 0 0 0 0] # [ -Cross9 -Cross9 0 -Cross9 -Cross9 0 0 0 0 +Infinity] # No minor computation leads to any restrictions. # We look at the 45x10 matrix and extract the shift (newMatrix, newShift) = extractingTranslationv2(extremal, build10x45E1IntersectingPairs) # The rows are ordered from x12, ..., y162534 # newMatrix # [[0, +Infinity, 0, 0, 0, 0, +Infinity, 0, 0, 0], # [0, 0, 0, 0, +Infinity, 0, +Infinity, 0, 0, 0], # [0, 0, 0, +Infinity, 0, 0, 0, 0, 0, +Infinity], # [0, 0, +Infinity, 0, 0, -Cross9, -Cross9, -Cross9, +Infinity, -Cross9], # [+Infinity, -Cross9, -Cross9, -Cross9, -Cross9, 0, 0, 0, 0, +Infinity], # [0, 0, 0, 0, +Infinity, 0, 0, 0, 0, +Infinity], # [+Infinity, -Cross9, -Cross9, -Cross9, -Cross9, 0, +Infinity, 0, 0, 0], # [+Infinity, 0, 0, 0, 0, 0, 0, 0, +Infinity, 0], # [0, 0, +Infinity, 0, 0, 0, 0, +Infinity, 0, 0], # [0, 0, 0, 0, +Infinity, 0, +Infinity, 0, 0, 0], # [0, +Infinity, 0, 0, 0, 0, +Infinity, 0, 0, 0], # [0, +Infinity, 0, 0, 0, 0, 0, +Infinity, 0, 0], # [0, 0, 0, +Infinity, 0, -Cross9, -Cross9, -Cross9, +Infinity, -Cross9], # [0, +Infinity, 0, 0, 0, 0, 0, +Infinity, 0, 0], # [0, 0, 0, 0, +Infinity, 0, 0, +Infinity, 0, 0], # [+Infinity, 0, 0, 0, 0, 0, 0, 0, +Infinity, 0], # [0, 0, 0, +Infinity, 0, 0, +Infinity, 0, 0, 0], # [0, +Infinity, 0, 0, 0, +Infinity, 0, 0, 0, 0], # [0, 0, 0, 0, +Infinity, +Infinity, 0, 0, 0, 0], # [0, 0, 0, 0, +Infinity, 0, 0, 0, 0, +Infinity], # [0, 0, +Infinity, 0, 0, +Infinity, 0, 0, 0, 0], # [0, 0, 0, +Infinity, 0, +Infinity, 0, 0, 0, 0], # [0, 0, 0, +Infinity, 0, +Infinity, 0, 0, 0, 0], # [0, 0, 0, +Infinity, 0, 0, 0, +Infinity, 0, 0], # [0, 0, 0, +Infinity, 0, 0, +Infinity, 0, 0, 0], # [+Infinity, 0, 0, 0, 0, 0, 0, 0, +Infinity, 0], # [0, +Infinity, 0, 0, 0, -Cross9, -Cross9, -Cross9, +Infinity, -Cross9], # [0, 0, +Infinity, 0, 0, 0, 0, 0, 0, +Infinity], # [0, 0, +Infinity, 0, 0, +Infinity, 0, 0, 0, 0], # [+Infinity, 0, 0, 0, 0, 0, 0, 0, +Infinity, 0], # [0, +Infinity, 0, 0, 0, 0, 0, 0, 0, +Infinity], # [0, 0, 0, 0, +Infinity, 0, 0, +Infinity, 0, 0], # [0, 0, 0, +Infinity, 0, 0, 0, 0, 0, +Infinity], # [0, 0, 0, +Infinity, 0, 0, 0, +Infinity, 0, 0], # [0, 0, +Infinity, 0, 0, 0, 0, +Infinity, 0, 0], # [0, +Infinity, 0, 0, 0, +Infinity, 0, 0, 0, 0], # [0, 0, +Infinity, 0, 0, 0, 0, 0, 0, +Infinity], # [0, 0, 0, 0, +Infinity, -Cross9, -Cross9, -Cross9, +Infinity, -Cross9], # [0, 0, +Infinity, 0, 0, 0, +Infinity, 0, 0, 0], # [0, +Infinity, 0, 0, 0, 0, 0, 0, 0, +Infinity], # [+Infinity, -Cross9, -Cross9, -Cross9, -Cross9, 0, 0, +Infinity, 0, 0], # [+Infinity, 0, 0, 0, 0, 0, 0, 0, +Infinity, 0], # [0, 0, +Infinity, 0, 0, 0, +Infinity, 0, 0, 0], # [+Infinity, -Cross9, -Cross9, -Cross9, -Cross9, +Infinity, 0, 0, 0, 0], # [0, 0, 0, 0, +Infinity, +Infinity, 0, 0, 0, 0]] # print newShift.values() # [-Cross0, -Cross3, -Cross63, 0, 0, -Cross90, 0, -Cross21, -Cross97, -Cross24, -Cross28, -Cross132, 0, -Cross37, -Cross41, 0, -Cross45, -Cross48, -Cross51, -Cross54, -Cross57, -Cross6, -Cross66, -Cross69, -Cross73, -Cross76, 0, -Cross81, -Cross84, -Cross102, -Cross15, -Cross93, -Cross60, -Cross99, -Cross87, -Cross105, -Cross110, 0, -Cross114, -Cross117, 0, -Cross123, -Cross126, 0, -Cross30] # [k for k in newShift.keys() if newShift[k] == SR(0)] # [3, 4, 6, 12, 15, 26, 37, 40, 43] (noRepeatedRows, rowsDict) =collectDistinctRowValuesAndKeys(newMatrix) # noRepeatedRows # [[0, +Infinity, 0, 0, 0, 0, +Infinity, 0, 0, 0], # [0, 0, 0, 0, +Infinity, 0, +Infinity, 0, 0, 0], # [0, 0, 0, +Infinity, 0, 0, 0, 0, 0, +Infinity], # [0, 0, +Infinity, 0, 0, -Cross9, -Cross9, -Cross9, +Infinity, -Cross9], # [+Infinity, -Cross9, -Cross9, -Cross9, -Cross9, 0, 0, 0, 0, +Infinity], # [0, 0, 0, 0, +Infinity, 0, 0, 0, 0, +Infinity], # [+Infinity, -Cross9, -Cross9, -Cross9, -Cross9, 0, +Infinity, 0, 0, 0], # [+Infinity, 0, 0, 0, 0, 0, 0, 0, +Infinity, 0], # [0, 0, +Infinity, 0, 0, 0, 0, +Infinity, 0, 0], # [0, +Infinity, 0, 0, 0, 0, 0, +Infinity, 0, 0], # [0, 0, 0, +Infinity, 0, -Cross9, -Cross9, -Cross9, +Infinity, -Cross9], # [0, 0, 0, 0, +Infinity, 0, 0, +Infinity, 0, 0], # [0, 0, 0, +Infinity, 0, 0, +Infinity, 0, 0, 0], # [0, +Infinity, 0, 0, 0, +Infinity, 0, 0, 0, 0], # [0, 0, 0, 0, +Infinity, +Infinity, 0, 0, 0, 0], # [0, 0, +Infinity, 0, 0, +Infinity, 0, 0, 0, 0], # [0, 0, 0, +Infinity, 0, +Infinity, 0, 0, 0, 0], # [0, 0, 0, +Infinity, 0, 0, 0, +Infinity, 0, 0], # [0, +Infinity, 0, 0, 0, -Cross9, -Cross9, -Cross9, +Infinity, -Cross9], # [0, 0, +Infinity, 0, 0, 0, 0, 0, 0, +Infinity], # [0, +Infinity, 0, 0, 0, 0, 0, 0, 0, +Infinity], # [0, 0, 0, 0, +Infinity, -Cross9, -Cross9, -Cross9, +Infinity, -Cross9], # [0, 0, +Infinity, 0, 0, 0, +Infinity, 0, 0, 0], # [+Infinity, -Cross9, -Cross9, -Cross9, -Cross9, 0, 0, +Infinity, 0, 0], # [+Infinity, -Cross9, -Cross9, -Cross9, -Cross9, +Infinity, 0, 0, 0, 0]] # By symmetry we can also find a 3x3 non-singular minor here. anticRowKeys[extremal] = findingAnticKeysForDistinctRows(noRepeatedRows, rowsDict, keys) # print anticRowKeys[extremal] # {0: [X12, X31], 1: [X13, X26], 2: [X14, Y123645], 3: [X15], 4: [X16], 5: [X21, X46], 6: [X23], 7: [X24, X41, X61, X65, Y152634], 8: [X25, Y132546], 9: [X32, X35], 10: [X34], 11: [X36, Y123546], 12: [X42, X56], 13: [X43, Y132645], 14: [X45, Y162534], 15: [X51, X64], 16: [X52, X53], 17: [X54, Y132456], 18: [X62], 19: [X63, Y142356], 20: [Y123456, Y152346], 21: [Y142536], 22: [Y142635, Y162345], 23: [Y152436], 24: [Y162435]} ################# # (E1,F15) pair # ################# extremal = F15 InfinityBlockEntriesFirst[E1] [X12, X13, X14, X15, X16] InfinityBlockEntriesFirst[extremal] [X15, X51, Y152346, Y152436, Y152634] # We build the matrix and transpose it matrixPair = matrix(SR,[build10x10E1C[extremal][k] for k in range(0,10)]).transpose() # print matrixPair # [ 0 0 +Infinity 0 0 0 -Cross9 -Cross9 -Cross9 -Cross9] # [ 0 +Infinity 0 0 0 0 -Cross9 -Cross9 -Cross9 -Cross9] # [+Infinity 0 0 0 0 0 -Cross9 -Cross9 -Cross9 -Cross9] # [ 0 0 0 0 +Infinity 0 -Cross9 -Cross9 -Cross9 -Cross9] # [ 0 0 0 +Infinity 0 +Infinity +Infinity +Infinity +Infinity +Infinity] # [ -Cross9 -Cross9 -Cross9 0 -Cross9 0 0 0 +Infinity 0] # [ -Cross9 -Cross9 -Cross9 0 -Cross9 0 0 0 0 +Infinity] # [ -Cross9 -Cross9 -Cross9 0 -Cross9 0 +Infinity 0 0 0] # [ -Cross9 -Cross9 -Cross9 0 -Cross9 0 0 +Infinity 0 0] # [+Infinity +Infinity +Infinity +Infinity +Infinity +Infinity 0 0 0 0] # No minor computation leads to any restrictions. # We look at the 45x10 matrix and extract the shift (newMatrix, newShift) = extractingTranslationv2(extremal, build10x45E1IntersectingPairs) # The rows are ordered from x12, ..., y162534 # newMatrix # [[0, +Infinity, 0, 0, 0, 0, 0, +Infinity, 0, 0], # [0, 0, 0, 0, +Infinity, 0, 0, 0, 0, +Infinity], # [0, 0, 0, +Infinity, 0, 0, +Infinity, 0, 0, 0], # [0, 0, +Infinity, 0, 0, -Cross9, -Cross9, -Cross9, -Cross9, +Infinity], # [+Infinity, 0, 0, 0, 0, 0, +Infinity, 0, 0, 0], # [0, 0, 0, 0, +Infinity, 0, 0, 0, 0, +Infinity], # [+Infinity, 0, 0, 0, 0, 0, 0, +Infinity, 0, 0], # [+Infinity, 0, 0, 0, 0, +Infinity, 0, 0, 0, 0], # [0, 0, +Infinity, 0, 0, +Infinity, 0, 0, 0, 0], # [-Cross9, -Cross9, -Cross9, -Cross9, +Infinity, 0, 0, +Infinity, 0, 0], # [0, +Infinity, 0, 0, 0, 0, +Infinity, 0, 0, 0], # [0, +Infinity, 0, 0, 0, 0, 0, 0, +Infinity, 0], # [0, 0, 0, +Infinity, 0, -Cross9, -Cross9, -Cross9, -Cross9, +Infinity], # [0, +Infinity, 0, 0, 0, +Infinity, 0, 0, 0, 0], # [-Cross9, -Cross9, -Cross9, -Cross9, +Infinity, +Infinity, 0, 0, 0, 0], # [+Infinity, 0, 0, 0, 0, -Cross9, -Cross9, -Cross9, -Cross9, +Infinity], # [0, 0, 0, +Infinity, 0, 0, 0, +Infinity, 0, 0], # [0, +Infinity, 0, 0, 0, +Infinity, 0, 0, 0, 0], # [0, 0, 0, 0, +Infinity, 0, 0, 0, 0, +Infinity], # [-Cross9, -Cross9, -Cross9, -Cross9, +Infinity, 0, +Infinity, 0, 0, 0], # [0, 0, +Infinity, 0, 0, 0, +Infinity, 0, 0, 0], # [0, 0, 0, +Infinity, 0, 0, 0, 0, +Infinity, 0], # [0, 0, 0, +Infinity, 0, 0, 0, +Infinity, 0, 0], # [0, 0, 0, +Infinity, 0, 0, +Infinity, 0, 0, 0], # [0, 0, 0, +Infinity, 0, 0, 0, 0, +Infinity, 0], # [+Infinity, 0, 0, 0, 0, 0, 0, +Infinity, 0, 0], # [0, +Infinity, 0, 0, 0, -Cross9, -Cross9, -Cross9, -Cross9, +Infinity], # [0, 0, +Infinity, 0, 0, 0, 0, 0, +Infinity, 0], # [0, 0, +Infinity, 0, 0, 0, 0, 0, +Infinity, 0], # [+Infinity, 0, 0, 0, 0, 0, +Infinity, 0, 0, 0], # [0, +Infinity, 0, 0, 0, 0, 0, +Infinity, 0, 0], # [0, 0, 0, 0, +Infinity, 0, 0, 0, 0, +Infinity], # [0, 0, 0, +Infinity, 0, +Infinity, 0, 0, 0, 0], # [0, 0, 0, +Infinity, 0, +Infinity, 0, 0, 0, 0], # [0, 0, +Infinity, 0, 0, 0, 0, +Infinity, 0, 0], # [0, +Infinity, 0, 0, 0, 0, 0, 0, +Infinity, 0], # [0, 0, +Infinity, 0, 0, 0, +Infinity, 0, 0, 0], # [0, 0, 0, 0, +Infinity, 0, 0, 0, 0, +Infinity], # [0, 0, +Infinity, 0, 0, 0, 0, +Infinity, 0, 0], # [0, +Infinity, 0, 0, 0, 0, +Infinity, 0, 0, 0], # [+Infinity, 0, 0, 0, 0, +Infinity, 0, 0, 0, 0], # [+Infinity, 0, 0, 0, 0, 0, 0, 0, +Infinity, 0], # [0, 0, +Infinity, 0, 0, +Infinity, 0, 0, 0, 0], # [+Infinity, 0, 0, 0, 0, 0, 0, 0, +Infinity, 0], # [-Cross9, -Cross9, -Cross9, -Cross9, +Infinity, 0, 0, 0, +Infinity, 0]] # print newShift.values() # [-Cross0, -Cross3, -Cross63, 0, -Cross12, -Cross90, -Cross18, -Cross21, -Cross97, 0, -Cross28, -Cross132, 0, -Cross37, 0, 0, -Cross45, -Cross48, -Cross51, 0, -Cross57, -Cross6, -Cross66, -Cross69, -Cross73, -Cross76, 0, -Cross81, -Cross84, -Cross102, -Cross15, -Cross93, -Cross60, -Cross99, -Cross87, -Cross105, -Cross110, 0, -Cross114, -Cross117, -Cross120, -Cross123, -Cross126, -Cross129, 0] # [k for k in newShift.keys() if newShift[k] == SR(0)] # [3, 9, 12, 14, 15, 19, 26, 37, 44] (noRepeatedRows, rowsDict) =collectDistinctRowValuesAndKeys(newMatrix) # noRepeatedRows # [[0, +Infinity, 0, 0, 0, 0, 0, +Infinity, 0, 0], # [0, 0, 0, 0, +Infinity, 0, 0, 0, 0, +Infinity], # [0, 0, 0, +Infinity, 0, 0, +Infinity, 0, 0, 0], # [0, 0, +Infinity, 0, 0, -Cross9, -Cross9, -Cross9, -Cross9, +Infinity], # [+Infinity, 0, 0, 0, 0, 0, +Infinity, 0, 0, 0], # [+Infinity, 0, 0, 0, 0, 0, 0, +Infinity, 0, 0], # [+Infinity, 0, 0, 0, 0, +Infinity, 0, 0, 0, 0], # [0, 0, +Infinity, 0, 0, +Infinity, 0, 0, 0, 0], # [-Cross9, -Cross9, -Cross9, -Cross9, +Infinity, 0, 0, +Infinity, 0, 0], # [0, +Infinity, 0, 0, 0, 0, +Infinity, 0, 0, 0], # [0, +Infinity, 0, 0, 0, 0, 0, 0, +Infinity, 0], # [0, 0, 0, +Infinity, 0, -Cross9, -Cross9, -Cross9, -Cross9, +Infinity], # [0, +Infinity, 0, 0, 0, +Infinity, 0, 0, 0, 0], # [-Cross9, -Cross9, -Cross9, -Cross9, +Infinity, +Infinity, 0, 0, 0, 0], # [+Infinity, 0, 0, 0, 0, -Cross9, -Cross9, -Cross9, -Cross9, +Infinity], # [0, 0, 0, +Infinity, 0, 0, 0, +Infinity, 0, 0], # [-Cross9, -Cross9, -Cross9, -Cross9, +Infinity, 0, +Infinity, 0, 0, 0], # [0, 0, +Infinity, 0, 0, 0, +Infinity, 0, 0, 0], # [0, 0, 0, +Infinity, 0, 0, 0, 0, +Infinity, 0], # [0, +Infinity, 0, 0, 0, -Cross9, -Cross9, -Cross9, -Cross9, +Infinity], # [0, 0, +Infinity, 0, 0, 0, 0, 0, +Infinity, 0], # [0, 0, 0, +Infinity, 0, +Infinity, 0, 0, 0, 0], # [0, 0, +Infinity, 0, 0, 0, 0, +Infinity, 0, 0], # [+Infinity, 0, 0, 0, 0, 0, 0, 0, +Infinity, 0], # [-Cross9, -Cross9, -Cross9, -Cross9, +Infinity, 0, 0, 0, +Infinity, 0]] # By symmetry we can also find a 3x3 non-singular minor here. anticRowKeys[extremal] = findingAnticKeysForDistinctRows(noRepeatedRows, rowsDict, keys) # print anticRowKeys[extremal] # {0: [X12, Y123456], 1: [X13, X21, X45, Y123546, Y142536], 2: [X14, X54], 3: [X15], 4: [X16, X65], 5: [X23, X61], 6: [X24, Y152436], 7: [X25, Y162345], 8: [X26], 9: [X31, Y152346], 10: [X32, Y132645], 11: [X34], 12: [X35, X43], 13: [X36], 14: [X41], 15: [X42, X53], 16: [X46], 17: [X51, Y142356], 18: [X52, X56], 19: [X62], 20: [X63, X64], 21: [Y123645, Y132456], 22: [Y132546, Y142635], 23: [Y152634, Y162435], 24: [Y162534]} ################# # (E1,F16) pair # ################# extremal = F16 InfinityBlockEntriesFirst[E1] [X12, X13, X14, X15, X16] InfinityBlockEntriesFirst[extremal] [X16, X61, Y162345, Y162435, Y162534] # We build the matrix and transpose it # matrixPair = matrix(SR,[build10x10E1C[extremal][k] for k in range(0,10)]).transpose() # print matrixPair # [ 0 0 +Infinity 0 0 0 -Cross6 -Cross6 -Cross6 -Cross6] # [ 0 +Infinity 0 0 0 0 -Cross6 -Cross6 -Cross6 -Cross6] # [+Infinity 0 0 0 0 0 -Cross6 -Cross6 -Cross6 -Cross6] # [ 0 0 0 0 +Infinity +Infinity +Infinity +Infinity +Infinity +Infinity] # [ 0 0 0 +Infinity 0 0 -Cross6 -Cross6 -Cross6 -Cross6] # [ -Cross6 -Cross6 -Cross6 -Cross6 0 0 +Infinity 0 0 0] # [ -Cross6 -Cross6 -Cross6 -Cross6 0 0 0 0 +Infinity 0] # [+Infinity +Infinity +Infinity +Infinity +Infinity +Infinity 0 0 0 0] # [ -Cross6 -Cross6 -Cross6 -Cross6 0 0 0 0 0 +Infinity] # [ -Cross6 -Cross6 -Cross6 -Cross6 0 0 0 +Infinity 0 0] # No minor computation leads to any restrictions. # We look at the 45x10 matrix and extract the shift (newMatrix, newShift) = extractingTranslationv2(extremal, build10x45E1IntersectingPairs) # The rows are ordered from x12, ..., y162534 # newMatrix # [[0, +Infinity, 0, 0, 0, +Infinity, 0, 0, 0, 0], # [0, 0, 0, 0, +Infinity, 0, 0, 0, 0, +Infinity], # [0, 0, 0, +Infinity, 0, 0, 0, +Infinity, 0, 0], # [0, 0, +Infinity, 0, 0, -Cross6, -Cross6, +Infinity, -Cross6, -Cross6], # [+Infinity, 0, 0, 0, 0, 0, +Infinity, 0, 0, 0], # [0, 0, 0, 0, +Infinity, 0, +Infinity, 0, 0, 0], # [+Infinity, 0, 0, 0, 0, +Infinity, 0, 0, 0, 0], # [+Infinity, 0, 0, 0, 0, 0, +Infinity, 0, 0, 0], # [0, 0, +Infinity, 0, 0, 0, 0, 0, 0, +Infinity], # [0, 0, 0, 0, +Infinity, +Infinity, 0, 0, 0, 0], # [0, +Infinity, 0, 0, 0, 0, 0, 0, +Infinity, 0], # [0, +Infinity, 0, 0, 0, 0, 0, 0, +Infinity, 0], # [0, 0, 0, +Infinity, 0, 0, 0, +Infinity, 0, 0], # [0, +Infinity, 0, 0, 0, +Infinity, 0, 0, 0, 0], # [0, 0, 0, 0, +Infinity, 0, +Infinity, 0, 0, 0], # [+Infinity, 0, 0, 0, 0, -Cross6, -Cross6, +Infinity, -Cross6, -Cross6], # [-Cross6, -Cross6, -Cross6, +Infinity, -Cross6, +Infinity, 0, 0, 0, 0], # [0, +Infinity, 0, 0, 0, 0, +Infinity, 0, 0, 0], # [0, 0, 0, 0, +Infinity, +Infinity, 0, 0, 0, 0], # [0, 0, 0, 0, +Infinity, 0, 0, 0, +Infinity, 0], # [0, 0, +Infinity, 0, 0, 0, 0, 0, +Infinity, 0], # [-Cross6, -Cross6, -Cross6, +Infinity, -Cross6, 0, 0, 0, 0, +Infinity], # [0, 0, 0, +Infinity, 0, 0, 0, +Infinity, 0, 0], # [-Cross6, -Cross6, -Cross6, +Infinity, -Cross6, 0, 0, 0, +Infinity, 0], # [0, 0, 0, +Infinity, 0, 0, 0, +Infinity, 0, 0], # [+Infinity, 0, 0, 0, 0, 0, 0, 0, 0, +Infinity], # [0, +Infinity, 0, 0, 0, -Cross6, -Cross6, +Infinity, -Cross6, -Cross6], # [0, 0, +Infinity, 0, 0, 0, +Infinity, 0, 0, 0], # [0, 0, +Infinity, 0, 0, 0, 0, 0, 0, +Infinity], # [+Infinity, 0, 0, 0, 0, 0, 0, 0, +Infinity, 0], # [0, +Infinity, 0, 0, 0, 0, +Infinity, 0, 0, 0], # [0, 0, 0, 0, +Infinity, 0, 0, 0, +Infinity, 0], # [-Cross6, -Cross6, -Cross6, +Infinity, -Cross6, 0, +Infinity, 0, 0, 0], # [0, 0, 0, +Infinity, 0, 0, 0, +Infinity, 0, 0], # [0, 0, +Infinity, 0, 0, 0, 0, 0, +Infinity, 0], # [0, +Infinity, 0, 0, 0, 0, 0, 0, 0, +Infinity], # [0, 0, +Infinity, 0, 0, +Infinity, 0, 0, 0, 0], # [0, 0, 0, 0, +Infinity, -Cross6, -Cross6, +Infinity, -Cross6, -Cross6], # [0, 0, +Infinity, 0, 0, +Infinity, 0, 0, 0, 0], # [0, +Infinity, 0, 0, 0, 0, 0, 0, 0, +Infinity], # [+Infinity, 0, 0, 0, 0, 0, 0, 0, +Infinity, 0], # [+Infinity, 0, 0, 0, 0, +Infinity, 0, 0, 0, 0], # [0, 0, +Infinity, 0, 0, 0, +Infinity, 0, 0, 0], # [+Infinity, 0, 0, 0, 0, 0, 0, 0, 0, +Infinity], # [0, 0, 0, 0, +Infinity, 0, 0, 0, 0, +Infinity]] # By symmetry we can also find a 3x3 non-singular minor here. # print newShift.values() # [-Cross0, -Cross3, -Cross63, 0, -Cross12, -Cross90, -Cross18, -Cross21, -Cross97, -Cross24, -Cross28, -Cross132, 0, -Cross37, -Cross41, 0, 0, -Cross48, -Cross51, -Cross54, -Cross57, 0, -Cross66, 0, -Cross73, -Cross76, 0, -Cross81, -Cross84, -Cross102, -Cross15, -Cross93, 0, -Cross99, -Cross87, -Cross105, -Cross110, 0, -Cross114, -Cross117, -Cross120, -Cross123, -Cross126, -Cross129, -Cross30] # [k for k in newShift.keys() if newShift[k] == SR(0)] # [3, 12, 15, 16, 21, 23, 26, 32, 37] (noRepeatedRows, rowsDict) =collectDistinctRowValuesAndKeys(newMatrix) # noRepeatedRows # [[0, +Infinity, 0, 0, 0, +Infinity, 0, 0, 0, 0], # [0, 0, 0, 0, +Infinity, 0, 0, 0, 0, +Infinity], # [0, 0, 0, +Infinity, 0, 0, 0, +Infinity, 0, 0], # [0, 0, +Infinity, 0, 0, -Cross6, -Cross6, +Infinity, -Cross6, -Cross6], # [+Infinity, 0, 0, 0, 0, 0, +Infinity, 0, 0, 0], # [0, 0, 0, 0, +Infinity, 0, +Infinity, 0, 0, 0], # [+Infinity, 0, 0, 0, 0, +Infinity, 0, 0, 0, 0], # [0, 0, +Infinity, 0, 0, 0, 0, 0, 0, +Infinity], # [0, 0, 0, 0, +Infinity, +Infinity, 0, 0, 0, 0], # [0, +Infinity, 0, 0, 0, 0, 0, 0, +Infinity, 0], # [+Infinity, 0, 0, 0, 0, -Cross6, -Cross6, +Infinity, -Cross6, -Cross6], # [-Cross6, -Cross6, -Cross6, +Infinity, -Cross6, +Infinity, 0, 0, 0, 0], # [0, +Infinity, 0, 0, 0, 0, +Infinity, 0, 0, 0], # [0, 0, 0, 0, +Infinity, 0, 0, 0, +Infinity, 0], # [0, 0, +Infinity, 0, 0, 0, 0, 0, +Infinity, 0], # [-Cross6, -Cross6, -Cross6, +Infinity, -Cross6, 0, 0, 0, 0, +Infinity], # [-Cross6, -Cross6, -Cross6, +Infinity, -Cross6, 0, 0, 0, +Infinity, 0], # [+Infinity, 0, 0, 0, 0, 0, 0, 0, 0, +Infinity], # [0, +Infinity, 0, 0, 0, -Cross6, -Cross6, +Infinity, -Cross6, -Cross6], # [0, 0, +Infinity, 0, 0, 0, +Infinity, 0, 0, 0], # [+Infinity, 0, 0, 0, 0, 0, 0, 0, +Infinity, 0], # [-Cross6, -Cross6, -Cross6, +Infinity, -Cross6, 0, +Infinity, 0, 0, 0], # [0, +Infinity, 0, 0, 0, 0, 0, 0, 0, +Infinity], # [0, 0, +Infinity, 0, 0, +Infinity, 0, 0, 0, 0], # [0, 0, 0, 0, +Infinity, -Cross6, -Cross6, +Infinity, -Cross6, -Cross6]] anticRowKeys[extremal] = findingAnticKeysForDistinctRows(noRepeatedRows, rowsDict, keys) # print anticRowKeys[extremal] # {0: [X12, X35], 1: [X13, Y162534], 2: [X14, X34, X53, X56, Y132456], 3: [X15], 4: [X16, X24], 5: [X21, X36], 6: [X23, Y152634], 7: [X25, X64], 8: [X26, X45], 9: [X31, X32], 10: [X41], 11: [X42], 12: [X43, Y123456], 13: [X46, Y123546], 14: [X51, Y132546], 15: [X52], 16: [X54], 17: [X61, Y162435], 18: [X62], 19: [X63, Y162345], 20: [X65, Y152436], 21: [Y123645], 22: [Y132645, Y152346], 23: [Y142356, Y142635], 24: [Y142536]} ################ # (E1,G2) pair # ################ extremal = G2 InfinityBlockEntriesFirst[E1] [X12, X13, X14, X15, X16] InfinityBlockEntriesFirst[extremal] [X12, X32, X42, X52, X62] # We build the matrix and transpose it matrixPair = matrix(SR,[build10x10E1C[extremal][k] for k in range(0,10)]).transpose() # print matrixPair # [ 0 0 +Infinity 0 0 0 -Cross9 -Cross9 -Cross9 -Cross9] # [ 0 +Infinity 0 0 0 0 -Cross9 -Cross9 -Cross9 -Cross9] # [+Infinity 0 0 0 0 +Infinity +Infinity +Infinity +Infinity +Infinity] # [ 0 0 0 0 +Infinity 0 -Cross9 -Cross9 -Cross9 -Cross9] # [ 0 0 0 +Infinity 0 0 -Cross9 -Cross9 -Cross9 -Cross9] # [ 0 -Cross9 -Cross9 -Cross9 -Cross9 0 0 +Infinity 0 0] # [ 0 -Cross9 -Cross9 -Cross9 -Cross9 0 +Infinity 0 0 0] # [+Infinity +Infinity +Infinity +Infinity +Infinity +Infinity 0 0 0 0] # [ 0 -Cross9 -Cross9 -Cross9 -Cross9 0 0 0 0 +Infinity] # [ 0 -Cross9 -Cross9 -Cross9 -Cross9 0 0 0 +Infinity 0] # No minor computation leads to any restrictions. # We look at the 45x10 matrix and extract the shift (newMatrix, newShift) = extractingTranslationv2(extremal, build10x45E1IntersectingPairs) # The rows are ordered from x12, ..., y162534 # newMatrix # [[0, +Infinity, 0, 0, 0, 0, +Infinity, 0, 0, 0], # [0, 0, 0, 0, +Infinity, +Infinity, 0, 0, 0, 0], # [0, 0, 0, +Infinity, 0, 0, 0, 0, +Infinity, 0], # [0, 0, +Infinity, 0, 0, 0, 0, +Infinity, 0, 0], # [+Infinity, 0, 0, 0, 0, 0, 0, 0, +Infinity, 0], # [0, 0, 0, 0, +Infinity, 0, +Infinity, 0, 0, 0], # [+Infinity, 0, 0, 0, 0, +Infinity, 0, 0, 0, 0], # [+Infinity, 0, 0, 0, 0, +Infinity, 0, 0, 0, 0], # [0, 0, +Infinity, 0, 0, 0, 0, +Infinity, 0, 0], # [0, 0, 0, 0, +Infinity, 0, 0, 0, 0, +Infinity], # [0, +Infinity, 0, 0, 0, +Infinity, 0, 0, 0, 0], # [0, +Infinity, 0, 0, 0, 0, 0, 0, 0, +Infinity], # [0, 0, 0, +Infinity, 0, -Cross9, -Cross9, +Infinity, -Cross9, -Cross9], # [0, +Infinity, 0, 0, 0, 0, 0, 0, +Infinity, 0], # [0, 0, 0, 0, +Infinity, +Infinity, 0, 0, 0, 0], # [+Infinity, 0, 0, 0, 0, -Cross9, -Cross9, +Infinity, -Cross9, -Cross9], # [0, 0, 0, +Infinity, 0, 0, 0, 0, +Infinity, 0], # [0, +Infinity, 0, 0, 0, +Infinity, 0, 0, 0, 0], # [0, 0, 0, 0, +Infinity, 0, 0, 0, +Infinity, 0], # [0, 0, 0, 0, +Infinity, 0, 0, 0, +Infinity, 0], # [0, 0, +Infinity, 0, 0, 0, 0, +Infinity, 0, 0], # [0, 0, 0, +Infinity, 0, 0, +Infinity, 0, 0, 0], # [0, 0, 0, +Infinity, 0, 0, 0, 0, 0, +Infinity], # [0, 0, 0, +Infinity, 0, 0, 0, 0, 0, +Infinity], # [0, 0, 0, +Infinity, 0, +Infinity, 0, 0, 0, 0], # [+Infinity, 0, 0, 0, 0, 0, 0, 0, 0, +Infinity], # [0, +Infinity, 0, 0, 0, -Cross9, -Cross9, +Infinity, -Cross9, -Cross9], # [0, 0, +Infinity, 0, 0, 0, 0, +Infinity, 0, 0], # [-Cross9, -Cross9, +Infinity, -Cross9, -Cross9, 0, +Infinity, 0, 0, 0], # [+Infinity, 0, 0, 0, 0, 0, +Infinity, 0, 0, 0], # [0, +Infinity, 0, 0, 0, 0, 0, 0, 0, +Infinity], # [0, 0, 0, 0, +Infinity, 0, 0, 0, 0, +Infinity], # [0, 0, 0, +Infinity, 0, +Infinity, 0, 0, 0, 0], # [0, 0, 0, +Infinity, 0, 0, +Infinity, 0, 0, 0], # [-Cross9, -Cross9, +Infinity, -Cross9, -Cross9, 0, 0, 0, 0, +Infinity], # [0, +Infinity, 0, 0, 0, 0, +Infinity, 0, 0, 0], # [-Cross9, -Cross9, +Infinity, -Cross9, -Cross9, 0, 0, 0, +Infinity, 0], # [0, 0, 0, 0, +Infinity, -Cross9, -Cross9, +Infinity, -Cross9, -Cross9], # [0, 0, +Infinity, 0, 0, 0, 0, +Infinity, 0, 0], # [0, +Infinity, 0, 0, 0, 0, 0, 0, +Infinity, 0], # [+Infinity, 0, 0, 0, 0, 0, 0, 0, 0, +Infinity], # [+Infinity, 0, 0, 0, 0, 0, 0, 0, +Infinity, 0], # [-Cross9, -Cross9, +Infinity, -Cross9, -Cross9, +Infinity, 0, 0, 0, 0], # [+Infinity, 0, 0, 0, 0, 0, +Infinity, 0, 0, 0], # [0, 0, 0, 0, +Infinity, 0, +Infinity, 0, 0, 0]] # print newShift.values() # [-Cross0, -Cross3, -Cross63, 0, -Cross12, -Cross90, -Cross18, -Cross21, -Cross97, -Cross24, -Cross28, -Cross132, 0, -Cross37, -Cross41, 0, -Cross45, -Cross48, -Cross51, -Cross54, -Cross57, -Cross6, -Cross66, -Cross69, -Cross73, -Cross76, 0, -Cross81, 0, -Cross102, -Cross15, -Cross93, -Cross60, -Cross99, 0, -Cross105, 0, 0, -Cross114, -Cross117, -Cross120, -Cross123, 0, -Cross129, -Cross30] # [k for k in newShift.keys() if newShift[k] == SR(0)] # [3, 12, 15, 26, 28, 34, 36, 37, 42] (noRepeatedRows, rowsDict) =collectDistinctRowValuesAndKeys(newMatrix) # noRepeatedRows # [[0, +Infinity, 0, 0, 0, 0, +Infinity, 0, 0, 0], # [0, 0, 0, 0, +Infinity, +Infinity, 0, 0, 0, 0], # [0, 0, 0, +Infinity, 0, 0, 0, 0, +Infinity, 0], # [0, 0, +Infinity, 0, 0, 0, 0, +Infinity, 0, 0], # [+Infinity, 0, 0, 0, 0, 0, 0, 0, +Infinity, 0], # [0, 0, 0, 0, +Infinity, 0, +Infinity, 0, 0, 0], # [+Infinity, 0, 0, 0, 0, +Infinity, 0, 0, 0, 0], # [0, 0, 0, 0, +Infinity, 0, 0, 0, 0, +Infinity], # [0, +Infinity, 0, 0, 0, +Infinity, 0, 0, 0, 0], # [0, +Infinity, 0, 0, 0, 0, 0, 0, 0, +Infinity], # [0, 0, 0, +Infinity, 0, -Cross9, -Cross9, +Infinity, -Cross9, -Cross9], # [0, +Infinity, 0, 0, 0, 0, 0, 0, +Infinity, 0], # [+Infinity, 0, 0, 0, 0, -Cross9, -Cross9, +Infinity, -Cross9, -Cross9], # [0, 0, 0, 0, +Infinity, 0, 0, 0, +Infinity, 0], # [0, 0, 0, +Infinity, 0, 0, +Infinity, 0, 0, 0], # [0, 0, 0, +Infinity, 0, 0, 0, 0, 0, +Infinity], # [0, 0, 0, +Infinity, 0, +Infinity, 0, 0, 0, 0], # [+Infinity, 0, 0, 0, 0, 0, 0, 0, 0, +Infinity], # [0, +Infinity, 0, 0, 0, -Cross9, -Cross9, +Infinity, -Cross9, -Cross9], # [-Cross9, -Cross9, +Infinity, -Cross9, -Cross9, 0, +Infinity, 0, 0, 0], # [+Infinity, 0, 0, 0, 0, 0, +Infinity, 0, 0, 0], # [-Cross9, -Cross9, +Infinity, -Cross9, -Cross9, 0, 0, 0, 0, +Infinity], # [-Cross9, -Cross9, +Infinity, -Cross9, -Cross9, 0, 0, 0, +Infinity, 0], # [0, 0, 0, 0, +Infinity, -Cross9, -Cross9, +Infinity, -Cross9, -Cross9], # [-Cross9, -Cross9, +Infinity, -Cross9, -Cross9, +Infinity, 0, 0, 0, 0]] # We find a non-singular 3x3 minor: # matrix(SR, noRepeatedRows).matrix_from_rows_and_columns([4,11,12],[0,1,8]) # [+Infinity 0 +Infinity] # [ 0 +Infinity +Infinity] # [+Infinity 0 -Cross9] anticRowKeys[extremal] = findingAnticKeysForDistinctRows(noRepeatedRows, rowsDict, keys) # print anticRowKeys[extremal] # {0: [X12, Y132645], 1: [X13, X36], 2: [X14, X42], 3: [X15, X25, X51, X63, Y142635], 4: [X16, Y152634], 5: [X21, Y162534], 6: [X23, X24], 7: [X26, Y123546], 8: [X31, X43], 9: [X32, Y123456], 10: [X34], 11: [X35, Y152346], 12: [X41], 13: [X45, X46], 14: [X52, Y132456], 15: [X53, X54], 16: [X56, Y123645], 17: [X61, Y152436], 18: [X62], 19: [X64], 20: [X65, Y162435], 21: [Y132546], 22: [Y142356], 23: [Y142536], 24: [Y162345]} ################ # (E1,G3) pair # ################ extremal = G3 InfinityBlockEntriesFirst[E1] [X12, X13, X14, X15, X16] InfinityBlockEntriesFirst[extremal] [X13, X23, X43, X53, X63] # We build the matrix and transpose it matrixPair = matrix(SR,[build10x10E1C[extremal][k] for k in range(0,10)]).transpose() # print matrixPair # [ 0 0 +Infinity 0 0 0 -Cross9 -Cross9 -Cross9 -Cross9] # [ 0 +Infinity 0 0 0 +Infinity +Infinity +Infinity +Infinity +Infinity] # [+Infinity 0 0 0 0 0 -Cross9 -Cross9 -Cross9 -Cross9] # [ 0 0 0 0 +Infinity 0 -Cross9 -Cross9 -Cross9 -Cross9] # [ 0 0 0 +Infinity 0 0 -Cross9 -Cross9 -Cross9 -Cross9] # [ -Cross9 0 -Cross9 -Cross9 -Cross9 0 0 +Infinity 0 0] # [ -Cross9 0 -Cross9 -Cross9 -Cross9 0 0 0 0 +Infinity] # [ -Cross9 0 -Cross9 -Cross9 -Cross9 0 0 0 +Infinity 0] # [ -Cross9 0 -Cross9 -Cross9 -Cross9 0 +Infinity 0 0 0] # [+Infinity +Infinity +Infinity +Infinity +Infinity +Infinity 0 0 0 0] # No minor computation leads to any restrictions. # We look at the 45x10 matrix and extract the shift (newMatrix, newShift) = extractingTranslationv2(extremal, build10x45E1IntersectingPairs) # The rows are ordered from x12, ..., y162534 # newMatrix # [[0, +Infinity, 0, 0, 0, 0, 0, 0, 0, +Infinity], # [0, 0, 0, 0, +Infinity, +Infinity, 0, 0, 0, 0], # [0, 0, 0, +Infinity, 0, 0, 0, 0, +Infinity, 0], # [0, 0, +Infinity, 0, 0, -Cross9, -Cross9, -Cross9, -Cross9, +Infinity], # [+Infinity, 0, 0, 0, 0, 0, 0, +Infinity, 0, 0], # [0, 0, 0, 0, +Infinity, 0, 0, +Infinity, 0, 0], # [+Infinity, 0, 0, 0, 0, +Infinity, 0, 0, 0, 0], # [+Infinity, 0, 0, 0, 0, 0, 0, 0, +Infinity, 0], # [0, 0, +Infinity, 0, 0, 0, +Infinity, 0, 0, 0], # [0, 0, 0, 0, +Infinity, 0, 0, +Infinity, 0, 0], # [-Cross9, +Infinity, -Cross9, -Cross9, -Cross9, +Infinity, 0, 0, 0, 0], # [0, +Infinity, 0, 0, 0, 0, 0, 0, 0, +Infinity], # [0, 0, 0, +Infinity, 0, -Cross9, -Cross9, -Cross9, -Cross9, +Infinity], # [-Cross9, +Infinity, -Cross9, -Cross9, -Cross9, 0, +Infinity, 0, 0, 0], # [0, 0, 0, 0, +Infinity, 0, +Infinity, 0, 0, 0], # [+Infinity, 0, 0, 0, 0, -Cross9, -Cross9, -Cross9, -Cross9, +Infinity], # [0, 0, 0, +Infinity, 0, 0, +Infinity, 0, 0, 0], # [0, +Infinity, 0, 0, 0, 0, 0, 0, 0, +Infinity], # [0, 0, 0, 0, +Infinity, 0, +Infinity, 0, 0, 0], # [0, 0, 0, 0, +Infinity, +Infinity, 0, 0, 0, 0], # [0, 0, +Infinity, 0, 0, +Infinity, 0, 0, 0, 0], # [0, 0, 0, +Infinity, 0, 0, 0, 0, +Infinity, 0], # [0, 0, 0, +Infinity, 0, 0, 0, +Infinity, 0, 0], # [0, 0, 0, +Infinity, 0, +Infinity, 0, 0, 0, 0], # [0, 0, 0, +Infinity, 0, +Infinity, 0, 0, 0, 0], # [+Infinity, 0, 0, 0, 0, 0, 0, +Infinity, 0, 0], # [0, +Infinity, 0, 0, 0, 0, 0, 0, 0, +Infinity], # [0, 0, +Infinity, 0, 0, 0, 0, +Infinity, 0, 0], # [0, 0, +Infinity, 0, 0, 0, 0, 0, +Infinity, 0], # [+Infinity, 0, 0, 0, 0, +Infinity, 0, 0, 0, 0], # [-Cross9, +Infinity, -Cross9, -Cross9, -Cross9, 0, 0, +Infinity, 0, 0], # [0, 0, 0, 0, +Infinity, 0, 0, 0, +Infinity, 0], # [0, 0, 0, +Infinity, 0, 0, 0, +Infinity, 0, 0], # [0, 0, 0, +Infinity, 0, 0, +Infinity, 0, 0, 0], # [0, 0, +Infinity, 0, 0, 0, 0, +Infinity, 0, 0], # [-Cross9, +Infinity, -Cross9, -Cross9, -Cross9, 0, 0, 0, +Infinity, 0], # [0, 0, +Infinity, 0, 0, 0, +Infinity, 0, 0, 0], # [0, 0, 0, 0, +Infinity, -Cross9, -Cross9, -Cross9, -Cross9, +Infinity], # [0, 0, +Infinity, 0, 0, 0, 0, 0, +Infinity, 0], # [0, +Infinity, 0, 0, 0, 0, 0, 0, 0, +Infinity], # [+Infinity, 0, 0, 0, 0, 0, +Infinity, 0, 0, 0], # [+Infinity, 0, 0, 0, 0, 0, +Infinity, 0, 0, 0], # [0, 0, +Infinity, 0, 0, +Infinity, 0, 0, 0, 0], # [+Infinity, 0, 0, 0, 0, 0, 0, 0, +Infinity, 0], # [0, 0, 0, 0, +Infinity, 0, 0, 0, +Infinity, 0]] # print newShift.values() # [-Cross0, -Cross3, -Cross63, 0, -Cross12, -Cross90, -Cross18, -Cross21, -Cross97, -Cross24, 0, -Cross132, 0, 0, -Cross41, 0, -Cross45, -Cross48, -Cross51, -Cross54, -Cross57, -Cross6, -Cross66, -Cross69, -Cross73, -Cross76, 0, -Cross81, -Cross84, -Cross102, 0, -Cross93, -Cross60, -Cross99, -Cross87, 0, -Cross110, 0, -Cross114, -Cross117, -Cross120, -Cross123, -Cross126, -Cross129, -Cross30] # [k for k in newShift.keys() if newShift[k] == SR(0)] # [3, 10, 12, 13, 15, 26, 30, 35, 37] (noRepeatedRows, rowsDict) =collectDistinctRowValuesAndKeys(newMatrix) # noRepeatedRows # [[0, +Infinity, 0, 0, 0, 0, 0, 0, 0, +Infinity], # [0, 0, 0, 0, +Infinity, +Infinity, 0, 0, 0, 0], # [0, 0, 0, +Infinity, 0, 0, 0, 0, +Infinity, 0], # [0, 0, +Infinity, 0, 0, -Cross9, -Cross9, -Cross9, -Cross9, +Infinity], # [+Infinity, 0, 0, 0, 0, 0, 0, +Infinity, 0, 0], # [0, 0, 0, 0, +Infinity, 0, 0, +Infinity, 0, 0], # [+Infinity, 0, 0, 0, 0, +Infinity, 0, 0, 0, 0], # [+Infinity, 0, 0, 0, 0, 0, 0, 0, +Infinity, 0], # [0, 0, +Infinity, 0, 0, 0, +Infinity, 0, 0, 0], # [-Cross9, +Infinity, -Cross9, -Cross9, -Cross9, +Infinity, 0, 0, 0, 0], # [0, 0, 0, +Infinity, 0, -Cross9, -Cross9, -Cross9, -Cross9, +Infinity], # [-Cross9, +Infinity, -Cross9, -Cross9, -Cross9, 0, +Infinity, 0, 0, 0], # [0, 0, 0, 0, +Infinity, 0, +Infinity, 0, 0, 0], # [+Infinity, 0, 0, 0, 0, -Cross9, -Cross9, -Cross9, -Cross9, +Infinity], # [0, 0, 0, +Infinity, 0, 0, +Infinity, 0, 0, 0], # [0, 0, +Infinity, 0, 0, +Infinity, 0, 0, 0, 0], # [0, 0, 0, +Infinity, 0, 0, 0, +Infinity, 0, 0], # [0, 0, 0, +Infinity, 0, +Infinity, 0, 0, 0, 0], # [0, 0, +Infinity, 0, 0, 0, 0, +Infinity, 0, 0], # [0, 0, +Infinity, 0, 0, 0, 0, 0, +Infinity, 0], # [-Cross9, +Infinity, -Cross9, -Cross9, -Cross9, 0, 0, +Infinity, 0, 0], # [0, 0, 0, 0, +Infinity, 0, 0, 0, +Infinity, 0], # [-Cross9, +Infinity, -Cross9, -Cross9, -Cross9, 0, 0, 0, +Infinity, 0], # [0, 0, 0, 0, +Infinity, -Cross9, -Cross9, -Cross9, -Cross9, +Infinity], # [+Infinity, 0, 0, 0, 0, 0, +Infinity, 0, 0, 0]] # By symmetry we can also find a 3x3 non-singular minor here. anticRowKeys[extremal] = findingAnticKeysForDistinctRows(noRepeatedRows, rowsDict, keys) # print anticRowKeys[extremal] # {0: [X12, X32, X43, X62, Y152346], 1: [X13, X46], 2: [X14, X52], 3: [X15], 4: [X16, X61], 5: [X21, X26], 6: [X23, X65], 7: [X24, Y162435], 8: [X25, Y142356], 9: [X31], 10: [X34], 11: [X35], 12: [X36, X45], 13: [X41], 14: [X42, Y132456], 15: [X51, Y162345], 16: [X53, Y123645], 17: [X54, X56], 18: [X63, Y132546], 19: [X64, Y142635], 20: [Y123456], 21: [Y123546, Y162534], 22: [Y132645], 23: [Y142536], 24: [Y152436, Y152634]} ################ # (E1,G4) pair # ################ extremal = G4 InfinityBlockEntriesFirst[E1] [X12, X13, X14, X15, X16] InfinityBlockEntriesFirst[extremal] [X14, X24, X34, X54, X64] # We build the matrix and transpose it matrixPair = matrix(SR,[build10x10E1C[extremal][k] for k in range(0,10)]).transpose() # print matrixPair [ 0 0 +Infinity 0 0 +Infinity +Infinity +Infinity +Infinity +Infinity] [ 0 +Infinity 0 0 0 0 -Cross9 -Cross9 -Cross9 -Cross9] [+Infinity 0 0 0 0 0 -Cross9 -Cross9 -Cross9 -Cross9] [ 0 0 0 0 +Infinity 0 -Cross9 -Cross9 -Cross9 -Cross9] [ 0 0 0 +Infinity 0 0 -Cross9 -Cross9 -Cross9 -Cross9] [ -Cross9 -Cross9 0 -Cross9 -Cross9 0 0 +Infinity 0 0] [ -Cross9 -Cross9 0 -Cross9 -Cross9 0 0 0 0 +Infinity] [ -Cross9 -Cross9 0 -Cross9 -Cross9 0 +Infinity 0 0 0] [ -Cross9 -Cross9 0 -Cross9 -Cross9 0 0 0 +Infinity 0] [+Infinity +Infinity +Infinity +Infinity +Infinity +Infinity 0 0 0 0] # No minor computation leads to any restrictions. # We look at the 45x10 matrix and extract the shift (newMatrix, newShift) = extractingTranslationv2(extremal, build10x45E1IntersectingPairs) # The rows are ordered from x12, ..., y162534 # newMatrix # [[0, +Infinity, 0, 0, 0, +Infinity, 0, 0, 0, 0], # [0, 0, 0, 0, +Infinity, 0, 0, 0, +Infinity, 0], # [0, 0, 0, +Infinity, 0, 0, 0, +Infinity, 0, 0], # [0, 0, +Infinity, 0, 0, -Cross9, -Cross9, -Cross9, -Cross9, +Infinity], # [+Infinity, 0, 0, 0, 0, 0, 0, 0, 0, +Infinity], # [0, 0, 0, 0, +Infinity, +Infinity, 0, 0, 0, 0], # [+Infinity, 0, 0, 0, 0, 0, 0, 0, 0, +Infinity], # [+Infinity, -Cross9, -Cross9, -Cross9, -Cross9, 0, 0, +Infinity, 0, 0], # [0, 0, +Infinity, 0, 0, 0, 0, 0, +Infinity, 0], # [0, 0, 0, 0, +Infinity, 0, 0, 0, +Infinity, 0], # [0, +Infinity, 0, 0, 0, +Infinity, 0, 0, 0, 0], # [0, +Infinity, 0, 0, 0, 0, +Infinity, 0, 0, 0], # [0, 0, 0, +Infinity, 0, -Cross9, -Cross9, -Cross9, -Cross9, +Infinity], # [0, +Infinity, 0, 0, 0, 0, +Infinity, 0, 0, 0], # [0, 0, 0, 0, +Infinity, 0, 0, +Infinity, 0, 0], # [+Infinity, 0, 0, 0, 0, 0, 0, 0, 0, +Infinity], # [0, 0, 0, +Infinity, 0, 0, +Infinity, 0, 0, 0], # [0, +Infinity, 0, 0, 0, 0, 0, +Infinity, 0, 0], # [0, 0, 0, 0, +Infinity, 0, +Infinity, 0, 0, 0], # [0, 0, 0, 0, +Infinity, +Infinity, 0, 0, 0, 0], # [0, 0, +Infinity, 0, 0, +Infinity, 0, 0, 0, 0], # [0, 0, 0, +Infinity, 0, 0, 0, 0, +Infinity, 0], # [0, 0, 0, +Infinity, 0, 0, 0, 0, +Infinity, 0], # [0, 0, 0, +Infinity, 0, +Infinity, 0, 0, 0, 0], # [0, 0, 0, +Infinity, 0, 0, +Infinity, 0, 0, 0], # [+Infinity, -Cross9, -Cross9, -Cross9, -Cross9, 0, 0, 0, +Infinity, 0], # [0, +Infinity, 0, 0, 0, -Cross9, -Cross9, -Cross9, -Cross9, +Infinity], # [0, 0, +Infinity, 0, 0, 0, +Infinity, 0, 0, 0], # [0, 0, +Infinity, 0, 0, +Infinity, 0, 0, 0, 0], # [+Infinity, -Cross9, -Cross9, -Cross9, -Cross9, +Infinity, 0, 0, 0, 0], # [0, +Infinity, 0, 0, 0, 0, 0, 0, +Infinity, 0], # [0, 0, 0, 0, +Infinity, 0, 0, +Infinity, 0, 0], # [0, 0, 0, +Infinity, 0, 0, 0, +Infinity, 0, 0], # [0, 0, 0, +Infinity, 0, +Infinity, 0, 0, 0, 0], # [0, 0, +Infinity, 0, 0, 0, 0, 0, +Infinity, 0], # [0, +Infinity, 0, 0, 0, 0, 0, +Infinity, 0, 0], # [0, 0, +Infinity, 0, 0, 0, +Infinity, 0, 0, 0], # [0, 0, 0, 0, +Infinity, -Cross9, -Cross9, -Cross9, -Cross9, +Infinity], # [0, 0, +Infinity, 0, 0, 0, 0, +Infinity, 0, 0], # [0, +Infinity, 0, 0, 0, 0, 0, 0, +Infinity, 0], # [+Infinity, 0, 0, 0, 0, 0, 0, 0, 0, +Infinity], # [+Infinity, -Cross9, -Cross9, -Cross9, -Cross9, 0, +Infinity, 0, 0, 0], # [0, 0, +Infinity, 0, 0, 0, 0, +Infinity, 0, 0], # [+Infinity, 0, 0, 0, 0, 0, 0, 0, 0, +Infinity], # [0, 0, 0, 0, +Infinity, 0, +Infinity, 0, 0, 0]] # print newShift.values() # [-Cross0, -Cross3, -Cross63, 0, -Cross12, -Cross90, -Cross18, 0, -Cross97, -Cross24, -Cross28, -Cross132, 0, -Cross37, -Cross41, 0, -Cross45, -Cross48, -Cross51, -Cross54, -Cross57, -Cross6, -Cross66, -Cross69, -Cross73, 0, 0, -Cross81, -Cross84, 0, -Cross15, -Cross93, -Cross60, -Cross99, -Cross87, -Cross105, -Cross110, 0, -Cross114, -Cross117, -Cross120, 0, -Cross126, -Cross129, -Cross30] # [k for k in newShift.keys() if newShift[k] == SR(0)] # [3, 7, 12, 15, 25, 26, 29, 37, 41] (noRepeatedRows, rowsDict) =collectDistinctRowValuesAndKeys(newMatrix) # noRepeatedRows # [[0, +Infinity, 0, 0, 0, +Infinity, 0, 0, 0, 0], # [0, 0, 0, 0, +Infinity, 0, 0, 0, +Infinity, 0], # [0, 0, 0, +Infinity, 0, 0, 0, +Infinity, 0, 0], # [0, 0, +Infinity, 0, 0, -Cross9, -Cross9, -Cross9, -Cross9, +Infinity], # [+Infinity, 0, 0, 0, 0, 0, 0, 0, 0, +Infinity], # [0, 0, 0, 0, +Infinity, +Infinity, 0, 0, 0, 0], # [+Infinity, -Cross9, -Cross9, -Cross9, -Cross9, 0, 0, +Infinity, 0, 0], # [0, 0, +Infinity, 0, 0, 0, 0, 0, +Infinity, 0], # [0, +Infinity, 0, 0, 0, 0, +Infinity, 0, 0, 0], # [0, 0, 0, +Infinity, 0, -Cross9, -Cross9, -Cross9, -Cross9, +Infinity], # [0, 0, 0, 0, +Infinity, 0, 0, +Infinity, 0, 0], # [0, 0, 0, +Infinity, 0, 0, +Infinity, 0, 0, 0], # [0, +Infinity, 0, 0, 0, 0, 0, +Infinity, 0, 0], # [0, 0, 0, 0, +Infinity, 0, +Infinity, 0, 0, 0], # [0, 0, +Infinity, 0, 0, +Infinity, 0, 0, 0, 0], # [0, 0, 0, +Infinity, 0, 0, 0, 0, +Infinity, 0], # [0, 0, 0, +Infinity, 0, +Infinity, 0, 0, 0, 0], # [+Infinity, -Cross9, -Cross9, -Cross9, -Cross9, 0, 0, 0, +Infinity, 0], # [0, +Infinity, 0, 0, 0, -Cross9, -Cross9, -Cross9, -Cross9, +Infinity], # [0, 0, +Infinity, 0, 0, 0, +Infinity, 0, 0, 0], # [+Infinity, -Cross9, -Cross9, -Cross9, -Cross9, +Infinity, 0, 0, 0, 0], # [0, +Infinity, 0, 0, 0, 0, 0, 0, +Infinity, 0], # [0, 0, 0, 0, +Infinity, -Cross9, -Cross9, -Cross9, -Cross9, +Infinity], # [0, 0, +Infinity, 0, 0, 0, 0, +Infinity, 0, 0], # [+Infinity, -Cross9, -Cross9, -Cross9, -Cross9, 0, +Infinity, 0, 0, 0]] # By symmetry we can also find a 3x3 non-singular minor here. anticRowKeys[extremal] = findingAnticKeysForDistinctRows(noRepeatedRows, rowsDict, keys) # print anticRowKeys[extremal] # {0: [X12, X31], 1: [X13, X26], 2: [X14, Y123645], 3: [X15], 4: [X16, X23, X41, Y152436, Y162435], 5: [X21, X46], 6: [X24], 7: [X25, Y132546], 8: [X32, X35], 9: [X34], 10: [X36, Y123546], 11: [X42, X56], 12: [X43, Y132645], 13: [X45, Y162534], 14: [X51, X64], 15: [X52, X53], 16: [X54, Y132456], 17: [X61], 18: [X62], 19: [X63, Y142356], 20: [X65], 21: [Y123456, Y152346], 22: [Y142536], 23: [Y142635, Y162345], 24: [Y152634]} ################ # (E1,G5) pair # ################ extremal = G5 InfinityBlockEntriesFirst[E1] [X12, X13, X14, X15, X16] InfinityBlockEntriesFirst[extremal] [X15, X25, X35, X45, X65] # We build the matrix and transpose it matrixPair = matrix(SR,[build10x10E1C[extremal][k] for k in range(0,10)]).transpose() # print matrixPair # [ 0 0 +Infinity 0 0 0 -Cross3 -Cross3 -Cross3 -Cross3] # [ 0 +Infinity 0 0 0 0 -Cross3 -Cross3 -Cross3 -Cross3] # [+Infinity 0 0 0 0 0 -Cross3 -Cross3 -Cross3 -Cross3] # [ 0 0 0 0 +Infinity 0 -Cross3 -Cross3 -Cross3 -Cross3] # [ 0 0 0 +Infinity 0 +Infinity +Infinity +Infinity +Infinity +Infinity] # [ -Cross3 -Cross3 -Cross3 0 -Cross3 0 0 0 0 +Infinity] # [ -Cross3 -Cross3 -Cross3 0 -Cross3 0 0 0 +Infinity 0] # [ -Cross3 -Cross3 -Cross3 0 -Cross3 0 0 +Infinity 0 0] # [+Infinity +Infinity +Infinity +Infinity +Infinity +Infinity 0 0 0 0] # [ -Cross3 -Cross3 -Cross3 0 -Cross3 0 +Infinity 0 0 0] # No minor computation leads to any restrictions. # We look at the 45x10 matrix and extract the shift (newMatrix, newShift) = extractingTranslationv2(extremal, build10x45E1IntersectingPairs) # The rows are ordered from x12, ..., y162534 # newMatrix # [[0, +Infinity, 0, 0, 0, 0, 0, +Infinity, 0, 0], # [-Cross3, -Cross3, -Cross3, -Cross3, +Infinity, 0, +Infinity, 0, 0, 0], # [0, 0, 0, +Infinity, 0, 0, 0, 0, 0, +Infinity], # [0, 0, +Infinity, 0, 0, -Cross3, -Cross3, -Cross3, +Infinity, -Cross3], # [+Infinity, 0, 0, 0, 0, 0, 0, +Infinity, 0, 0], # [-Cross3, -Cross3, -Cross3, -Cross3, +Infinity, 0, 0, +Infinity, 0, 0], # [+Infinity, 0, 0, 0, 0, 0, +Infinity, 0, 0, 0], # [+Infinity, 0, 0, 0, 0, 0, 0, 0, 0, +Infinity], # [0, 0, +Infinity, 0, 0, 0, +Infinity, 0, 0, 0], # [0, 0, 0, 0, +Infinity, 0, 0, 0, +Infinity, 0], # [0, +Infinity, 0, 0, 0, 0, +Infinity, 0, 0, 0], # [0, +Infinity, 0, 0, 0, 0, 0, 0, 0, +Infinity], # [0, 0, 0, +Infinity, 0, -Cross3, -Cross3, -Cross3, +Infinity, -Cross3], # [0, +Infinity, 0, 0, 0, +Infinity, 0, 0, 0, 0], # [0, 0, 0, 0, +Infinity, 0, 0, 0, +Infinity, 0], # [+Infinity, 0, 0, 0, 0, -Cross3, -Cross3, -Cross3, +Infinity, -Cross3], # [0, 0, 0, +Infinity, 0, +Infinity, 0, 0, 0, 0], # [0, +Infinity, 0, 0, 0, +Infinity, 0, 0, 0, 0], # [-Cross3, -Cross3, -Cross3, -Cross3, +Infinity, +Infinity, 0, 0, 0, 0], # [0, 0, 0, 0, +Infinity, 0, 0, 0, +Infinity, 0], # [0, 0, +Infinity, 0, 0, +Infinity, 0, 0, 0, 0], # [0, 0, 0, +Infinity, 0, 0, +Infinity, 0, 0, 0], # [0, 0, 0, +Infinity, 0, +Infinity, 0, 0, 0, 0], # [0, 0, 0, +Infinity, 0, 0, 0, 0, 0, +Infinity], # [0, 0, 0, +Infinity, 0, 0, +Infinity, 0, 0, 0], # [+Infinity, 0, 0, 0, 0, 0, +Infinity, 0, 0, 0], # [0, +Infinity, 0, 0, 0, -Cross3, -Cross3, -Cross3, +Infinity, -Cross3], # [0, 0, +Infinity, 0, 0, 0, 0, +Infinity, 0, 0], # [0, 0, +Infinity, 0, 0, 0, 0, +Infinity, 0, 0], # [+Infinity, 0, 0, 0, 0, 0, 0, +Infinity, 0, 0], # [0, +Infinity, 0, 0, 0, 0, 0, +Infinity, 0, 0], # [-Cross3, -Cross3, -Cross3, -Cross3, +Infinity, 0, 0, 0, 0, +Infinity], # [0, 0, 0, +Infinity, 0, 0, 0, +Infinity, 0, 0], # [0, 0, 0, +Infinity, 0, 0, 0, +Infinity, 0, 0], # [0, 0, +Infinity, 0, 0, 0, 0, 0, 0, +Infinity], # [0, +Infinity, 0, 0, 0, 0, 0, 0, 0, +Infinity], # [0, 0, +Infinity, 0, 0, +Infinity, 0, 0, 0, 0], # [0, 0, 0, 0, +Infinity, 0, 0, 0, +Infinity, 0], # [0, 0, +Infinity, 0, 0, 0, 0, 0, 0, +Infinity], # [0, +Infinity, 0, 0, 0, 0, +Infinity, 0, 0, 0], # [+Infinity, 0, 0, 0, 0, 0, 0, 0, 0, +Infinity], # [+Infinity, 0, 0, 0, 0, +Infinity, 0, 0, 0, 0], # [0, 0, +Infinity, 0, 0, 0, +Infinity, 0, 0, 0], # [+Infinity, 0, 0, 0, 0, +Infinity, 0, 0, 0, 0], # [0, 0, 0, 0, +Infinity, 0, 0, 0, +Infinity, 0]] # print newShift.values() # [-Cross0, 0, -Cross63, 0, -Cross12, 0, -Cross18, -Cross21, -Cross97, -Cross24, -Cross28, -Cross132, 0, -Cross37, -Cross41, 0, -Cross45, -Cross48, 0, -Cross54, -Cross57, -Cross6, -Cross66, -Cross69, -Cross73, -Cross76, 0, -Cross81, -Cross84, -Cross102, -Cross15, 0, -Cross60, -Cross99, -Cross87, -Cross105, -Cross110, 0, -Cross114, -Cross117, -Cross120, -Cross123, -Cross126, -Cross129, -Cross30] # [k for k in newShift.keys() if newShift[k] == SR(0)] # [1, 3, 5, 12, 15, 18, 26, 31, 37] (noRepeatedRows, rowsDict) =collectDistinctRowValuesAndKeys(newMatrix) # noRepeatedRows # [[0, +Infinity, 0, 0, 0, 0, 0, +Infinity, 0, 0], # [-Cross3, -Cross3, -Cross3, -Cross3, +Infinity, 0, +Infinity, 0, 0, 0], # [0, 0, 0, +Infinity, 0, 0, 0, 0, 0, +Infinity], # [0, 0, +Infinity, 0, 0, -Cross3, -Cross3, -Cross3, +Infinity, -Cross3], # [+Infinity, 0, 0, 0, 0, 0, 0, +Infinity, 0, 0], # [-Cross3, -Cross3, -Cross3, -Cross3, +Infinity, 0, 0, +Infinity, 0, 0], # [+Infinity, 0, 0, 0, 0, 0, +Infinity, 0, 0, 0], # [+Infinity, 0, 0, 0, 0, 0, 0, 0, 0, +Infinity], # [0, 0, +Infinity, 0, 0, 0, +Infinity, 0, 0, 0], # [0, 0, 0, 0, +Infinity, 0, 0, 0, +Infinity, 0], # [0, +Infinity, 0, 0, 0, 0, +Infinity, 0, 0, 0], # [0, +Infinity, 0, 0, 0, 0, 0, 0, 0, +Infinity], # [0, 0, 0, +Infinity, 0, -Cross3, -Cross3, -Cross3, +Infinity, -Cross3], # [0, +Infinity, 0, 0, 0, +Infinity, 0, 0, 0, 0], # [+Infinity, 0, 0, 0, 0, -Cross3, -Cross3, -Cross3, +Infinity, -Cross3], # [0, 0, 0, +Infinity, 0, +Infinity, 0, 0, 0, 0], # [-Cross3, -Cross3, -Cross3, -Cross3, +Infinity, +Infinity, 0, 0, 0, 0], # [0, 0, +Infinity, 0, 0, +Infinity, 0, 0, 0, 0], # [0, 0, 0, +Infinity, 0, 0, +Infinity, 0, 0, 0], # [0, +Infinity, 0, 0, 0, -Cross3, -Cross3, -Cross3, +Infinity, -Cross3], # [0, 0, +Infinity, 0, 0, 0, 0, +Infinity, 0, 0], # [-Cross3, -Cross3, -Cross3, -Cross3, +Infinity, 0, 0, 0, 0, +Infinity], # [0, 0, 0, +Infinity, 0, 0, 0, +Infinity, 0, 0], # [0, 0, +Infinity, 0, 0, 0, 0, 0, 0, +Infinity], # [+Infinity, 0, 0, 0, 0, +Infinity, 0, 0, 0, 0]] # By symmetry we can also find a 3x3 non-singular minor here. anticRowKeys[extremal] = findingAnticKeysForDistinctRows(noRepeatedRows, rowsDict, keys) # print anticRowKeys[extremal] # {0: [X12, Y123456], 1: [X13], 2: [X14, X54], 3: [X15], 4: [X16, X65], 5: [X21], 6: [X23, X61], 7: [X24, Y152436], 8: [X25, Y162345], 9: [X26, X36, X46, Y142536, Y162534], 10: [X31, Y152346], 11: [X32, Y132645], 12: [X34], 13: [X35, X43], 14: [X41], 15: [X42, X53], 16: [X45], 17: [X51, Y142356], 18: [X52, X56], 19: [X62], 20: [X63, X64], 21: [Y123546], 22: [Y123645, Y132456], 23: [Y132546, Y142635], 24: [Y152634, Y162435]} ################ # (E1,G6) pair # ################ extremal = G6 InfinityBlockEntriesFirst[E1] [X12, X13, X14, X15, X16] InfinityBlockEntriesFirst[extremal] [X16, X26, X36, X46, X56] # We build the matrix and transpose it matrixPair = matrix(SR,[build10x10E1C[extremal][k] for k in range(0,10)]).transpose() # print matrixPair # [ 0 0 +Infinity 0 0 0 -Cross9 -Cross9 -Cross9 -Cross9] # [ 0 +Infinity 0 0 0 0 -Cross9 -Cross9 -Cross9 -Cross9] # [+Infinity 0 0 0 0 0 -Cross9 -Cross9 -Cross9 -Cross9] # [ 0 0 0 0 +Infinity +Infinity +Infinity +Infinity +Infinity +Infinity] # [ 0 0 0 +Infinity 0 0 -Cross9 -Cross9 -Cross9 -Cross9] # [ -Cross9 -Cross9 -Cross9 -Cross9 0 0 0 0 0 +Infinity] # [ -Cross9 -Cross9 -Cross9 -Cross9 0 0 0 0 +Infinity 0] # [ -Cross9 -Cross9 -Cross9 -Cross9 0 0 0 +Infinity 0 0] # [ -Cross9 -Cross9 -Cross9 -Cross9 0 0 +Infinity 0 0 0] # [+Infinity +Infinity +Infinity +Infinity +Infinity +Infinity 0 0 0 0] # No minor computation leads to any restrictions. # We look at the 45x10 matrix and extract the shift (newMatrix, newShift) = extractingTranslationv2(extremal, build10x45E1IntersectingPairs) # The rows are ordered from x12, ..., y162534 # newMatrix # [[0, +Infinity, 0, 0, 0, 0, 0, +Infinity, 0, 0], # [0, 0, 0, 0, +Infinity, 0, +Infinity, 0, 0, 0], # [-Cross9, -Cross9, -Cross9, +Infinity, -Cross9, 0, 0, 0, +Infinity, 0], # [0, 0, +Infinity, 0, 0, -Cross9, -Cross9, -Cross9, -Cross9, +Infinity], # [+Infinity, 0, 0, 0, 0, 0, 0, 0, +Infinity, 0], # [0, 0, 0, 0, +Infinity, 0, 0, +Infinity, 0, 0], # [+Infinity, 0, 0, 0, 0, 0, +Infinity, 0, 0, 0], # [+Infinity, 0, 0, 0, 0, 0, 0, 0, +Infinity, 0], # [0, 0, +Infinity, 0, 0, 0, 0, +Infinity, 0, 0], # [0, 0, 0, 0, +Infinity, +Infinity, 0, 0, 0, 0], # [0, +Infinity, 0, 0, 0, 0, +Infinity, 0, 0, 0], # [0, +Infinity, 0, 0, 0, 0, +Infinity, 0, 0, 0], # [0, 0, 0, +Infinity, 0, 0, 0, 0, 0, +Infinity], # [0, +Infinity, 0, 0, 0, 0, 0, +Infinity, 0, 0], # [0, 0, 0, 0, +Infinity, 0, 0, +Infinity, 0, 0], # [+Infinity, 0, 0, 0, 0, -Cross9, -Cross9, -Cross9, -Cross9, +Infinity], # [0, 0, 0, +Infinity, 0, 0, 0, 0, 0, +Infinity], # [0, +Infinity, 0, 0, 0, +Infinity, 0, 0, 0, 0], # [0, 0, 0, 0, +Infinity, +Infinity, 0, 0, 0, 0], # [0, 0, 0, 0, +Infinity, 0, 0, 0, +Infinity, 0], # [0, 0, +Infinity, 0, 0, +Infinity, 0, 0, 0, 0], # [0, 0, 0, +Infinity, 0, 0, 0, 0, 0, +Infinity], # [-Cross9, -Cross9, -Cross9, +Infinity, -Cross9, +Infinity, 0, 0, 0, 0], # [0, 0, 0, +Infinity, 0, 0, 0, 0, 0, +Infinity], # [-Cross9, -Cross9, -Cross9, +Infinity, -Cross9, 0, +Infinity, 0, 0, 0], # [+Infinity, 0, 0, 0, 0, +Infinity, 0, 0, 0, 0], # [0, +Infinity, 0, 0, 0, -Cross9, -Cross9, -Cross9, -Cross9, +Infinity], # [0, 0, +Infinity, 0, 0, 0, +Infinity, 0, 0, 0], # [0, 0, +Infinity, 0, 0, 0, 0, +Infinity, 0, 0], # [+Infinity, 0, 0, 0, 0, 0, 0, +Infinity, 0, 0], # [0, +Infinity, 0, 0, 0, +Infinity, 0, 0, 0, 0], # [0, 0, 0, 0, +Infinity, 0, 0, 0, +Infinity, 0], # [0, 0, 0, +Infinity, 0, 0, 0, 0, 0, +Infinity], # [-Cross9, -Cross9, -Cross9, +Infinity, -Cross9, 0, 0, +Infinity, 0, 0], # [0, 0, +Infinity, 0, 0, +Infinity, 0, 0, 0, 0], # [0, +Infinity, 0, 0, 0, 0, 0, 0, +Infinity, 0], # [0, 0, +Infinity, 0, 0, 0, 0, 0, +Infinity, 0], # [0, 0, 0, 0, +Infinity, -Cross9, -Cross9, -Cross9, -Cross9, +Infinity], # [0, 0, +Infinity, 0, 0, 0, 0, 0, +Infinity, 0], # [0, +Infinity, 0, 0, 0, 0, 0, 0, +Infinity, 0], # [+Infinity, 0, 0, 0, 0, 0, 0, +Infinity, 0, 0], # [+Infinity, 0, 0, 0, 0, 0, +Infinity, 0, 0, 0], # [0, 0, +Infinity, 0, 0, 0, +Infinity, 0, 0, 0], # [+Infinity, 0, 0, 0, 0, +Infinity, 0, 0, 0, 0], # [0, 0, 0, 0, +Infinity, 0, +Infinity, 0, 0, 0]] # print newShift.values() # [-Cross0, -Cross3, 0, 0, -Cross12, -Cross90, -Cross18, -Cross21, -Cross97, -Cross24, -Cross28, -Cross132, 0, -Cross37, -Cross41, 0, -Cross45, -Cross48, -Cross51, -Cross54, -Cross57, -Cross6, 0, -Cross69, 0, -Cross76, 0, -Cross81, -Cross84, -Cross102, -Cross15, -Cross93, -Cross60, 0, -Cross87, -Cross105, -Cross110, 0, -Cross114, -Cross117, -Cross120, -Cross123, -Cross126, -Cross129, -Cross30] # [k for k in newShift.keys() if newShift[k] == SR(0)] # [2, 3, 12, 15, 22, 24, 26, 33, 37] (noRepeatedRows, rowsDict) =collectDistinctRowValuesAndKeys(newMatrix) # noRepeatedRows # [[0, +Infinity, 0, 0, 0, 0, 0, +Infinity, 0, 0], # [0, 0, 0, 0, +Infinity, 0, +Infinity, 0, 0, 0], # [-Cross9, -Cross9, -Cross9, +Infinity, -Cross9, 0, 0, 0, +Infinity, 0], # [0, 0, +Infinity, 0, 0, -Cross9, -Cross9, -Cross9, -Cross9, +Infinity], # [+Infinity, 0, 0, 0, 0, 0, 0, 0, +Infinity, 0], # [0, 0, 0, 0, +Infinity, 0, 0, +Infinity, 0, 0], # [+Infinity, 0, 0, 0, 0, 0, +Infinity, 0, 0, 0], # [0, 0, +Infinity, 0, 0, 0, 0, +Infinity, 0, 0], # [0, 0, 0, 0, +Infinity, +Infinity, 0, 0, 0, 0], # [0, +Infinity, 0, 0, 0, 0, +Infinity, 0, 0, 0], # [0, 0, 0, +Infinity, 0, 0, 0, 0, 0, +Infinity], # [+Infinity, 0, 0, 0, 0, -Cross9, -Cross9, -Cross9, -Cross9, +Infinity], # [0, +Infinity, 0, 0, 0, +Infinity, 0, 0, 0, 0], # [0, 0, 0, 0, +Infinity, 0, 0, 0, +Infinity, 0], # [0, 0, +Infinity, 0, 0, +Infinity, 0, 0, 0, 0], # [-Cross9, -Cross9, -Cross9, +Infinity, -Cross9, +Infinity, 0, 0, 0, 0], # [-Cross9, -Cross9, -Cross9, +Infinity, -Cross9, 0, +Infinity, 0, 0, 0], # [+Infinity, 0, 0, 0, 0, +Infinity, 0, 0, 0, 0], # [0, +Infinity, 0, 0, 0, -Cross9, -Cross9, -Cross9, -Cross9, +Infinity], # [0, 0, +Infinity, 0, 0, 0, +Infinity, 0, 0, 0], # [+Infinity, 0, 0, 0, 0, 0, 0, +Infinity, 0, 0], # [-Cross9, -Cross9, -Cross9, +Infinity, -Cross9, 0, 0, +Infinity, 0, 0], # [0, +Infinity, 0, 0, 0, 0, 0, 0, +Infinity, 0], # [0, 0, +Infinity, 0, 0, 0, 0, 0, +Infinity, 0], # [0, 0, 0, 0, +Infinity, -Cross9, -Cross9, -Cross9, -Cross9, +Infinity]] # By symmetry we can also find a 3x3 non-singular minor here. anticRowKeys[extremal] = findingAnticKeysForDistinctRows(noRepeatedRows, rowsDict, keys) # print anticRowKeys[extremal] # {0: [X12, X35], 1: [X13, Y162534], 2: [X14], 3: [X15], 4: [X16, X24], 5: [X21, X36], 6: [X23, Y152634], 7: [X25, X64], 8: [X26, X45], 9: [X31, X32], 10: [X34, X42, X52, X54, Y123645], 11: [X41], 12: [X43, Y123456], 13: [X46, Y123546], 14: [X51, Y132546], 15: [X53], 16: [X56], 17: [X61, Y162435], 18: [X62], 19: [X63, Y162345], 20: [X65, Y152436], 21: [Y132456], 22: [Y132645, Y152346], 23: [Y142356, Y142635], 24: [Y142536]}