#######################################################################################################################################
# Calculation of the 10 nodal points associated to each of the 27 lines on a smooth with no Eckardt points and their tropicalizations #
#######################################################################################################################################

# The following script allows to compute the ten nodal points associated to each extremal curve in X. They will be used to compute the associated Pluecker vectors (in the corresponding matroid strata) and characterized them later as the tropical convex hull of its leaves.
# The algorithm makes use of the Script "CalculationOfAllPds.sage". The result will be a family, indexed by the extremal curves. Each element of the family is a family of ten elements. Each element in the family gives a different node. We use the lex order on E+F+G to represent them, and the order of the coordinates of each node is given in decreasing order for X+Y.
# We verify that tuples of ten nodes associated to a given extremal curve are colinear (since they belong to the extremal curve, which is a line).


# We use the computation of the ratios among Cross functions (done in the script 'CrossValuations.sage') associated to the same Eckardt quintic to write the tropicalization of the 135 nodes of the arrangement of 27 lines on a cubic surface in terms of the valuations of the 45 relevant cross functions and the 40 Yoshida functions. This data will be used to compute the boundary tree arrangement on the corresponding tropical cubic surface.

# We proceed in several steps:

# STEP 0: We load the relevant data for all our computations. #

# STEP 1: Find the patterns for 0/infinities in the correspondence matrix and the nodes per extremal curve. #

# STEP 2: Computing 10 relevant coordinates for each tropical line and blocks of vanishing entries on classical nodes. #

# STEP 3: Calculation of 135 classical nodes (as rational functions in 135 Cross and 40 Yoshida functions) #

# STEP 4: We exploit the fact that ratios of suitable Cross functions have determined valuations (linear combinations of Yoshida valuations), to reduce the number of Cross functions with unknown valuations for each cone in the Naruki fan. 

# STEP 5: Tropicalization of all Nodes as linear functions in 45 relevant Cross and 40 Yoshida valuations #



###########################################################################
# Setting up the ambient rings with the W(E6) action.
###########################################################################

# 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 i<j and k<l and m<n and i<k and k<m and len(uniq([i,j,k,l,m,n])) == 6]

# A list of variables Yoshida_0, ..., Yoshida_39
Yoshidas = [var("Yoshida%s"%i) for i in range(0,40)]

# A polynomial ring on all these generators
basering = FractionField(PolynomialRing(QQ, ds))
Sxy = PolynomialRing(QQ, Xs+Ys)
T = PolynomialRing(QQ, ds+Es+Fs+Gs)

os.chdir('../../Yoshida')
YM = load("Output/Yoshida_matrix.sobj")
YRing = PolynomialRing(QQ, Yoshidas)
YField = FractionField(YRing)
#load("Yoshida.sage")


# The functions for computing valuations and substitutions.
os.chdir('Scripts')
load("allTropicalNodesPerNarukiConesMacros.sage")

# We need to work with the fraction field of Qt.
Qt = PolynomialRing(QQ,[var("t")])
QtField = FractionField(Qt)

# We use the Cross functions computed in "Yoshida.sage"

cross_variables = [var("Cross%s"%i) for i in range(0,135)]

cross_to_yoshidas = load("Input/cross_to_yoshidas.sobj")

# We start by creating ambient rings and quotient fields
YCRing = PolynomialRing(QQ, Yoshidas + cross_variables)
YCField = FractionField(YCRing)

AllConeNames = ['aa2a3a4', 'aa2a3b', 'aa2a3', 'aa2a4', 'aa3a4','a2a3a4', 'aa2b', 'aa3b', 'a2a3b', 'aa2','aa3','aa4','a2a3', 'a2a4', 'a3a4', 'ab', 'a2b', 'a3b', 'a', 'a2', 'a3', 'a4','b']


extremalCurves = Es+Fs+Gs
keys = [Sxy(x) for x in sorted(Sxy.gens(), reverse=True)]

os.chdir('../../TropicalConvexHulls/Scripts')


# We load the dictionaries of expected and true valuation of all Cross functions:
dict_exp_cross_vals=load('../../TropicalConvexHulls/Scripts/Input/dict_exp_cross_valuations_per_cone.sobj')

dict_true_cross_vals = load('../../TropicalConvexHulls/Scripts/Input/dict_cross_valuations_per_cone.sobj')

# We load the dictionary of cross ratios among Cross functions:
dict_cross_ratios = load('../../TropicalConvexHulls/Scripts/Input/dict_cross_ratiosv2.sobj')

# # Sample value:
# dict_cross_ratios[SR(Cross1)]
# (Cross0,
#  Yoshida17^6*Yoshida18^2*Yoshida21^4*Yoshida23^3*Yoshida25^6*Yoshida27^4*Yoshida30^5/(Yoshida19^3*Yoshida20^2*Yoshida22^4*Yoshida24^3*Yoshida26^2*Yoshida28^6*Yoshida31^6*Yoshida5^4))


#########################
# Faces of Naruki cones #
#########################

NarukiFaces = dict()
# Dim 4
NarukiFaces['aa2a3a4']= ['aa2a3a4', 'aa2a3', 'aa2a4', 'aa3a4', 'a2a3a4', 'aa2', 'aa3', 'aa4', 'a2a3', 'a2a4', 'a3a4','a', 'a2', 'a3', 'a4']
NarukiFaces['aa2a3b'] = ['aa2a3b', 'aa2a3', 'aa2b', 'aa3b', 'a2a3b', 'aa2', 'aa3', 'a2a3',  'ab', 'a2b', 'a3b', 'a', 'a2', 'a3',  'b']
# Dim 3
NarukiFaces['aa2a3'] = [ 'aa2a3',  'aa2', 'aa3',  'a2a3','a', 'a2', 'a3']
NarukiFaces['aa2a4'] = ['aa2a4', 'aa2',  'aa4',  'a2a4', 'a', 'a2',  'a4']
NarukiFaces['aa3a4'] = ['aa3a4',  'aa3', 'aa4',  'a3a4','a',  'a3', 'a4']
NarukiFaces['a2a3a4'] = ['a2a3a4', 'a2a3', 'a2a4', 'a3a4', 'a2', 'a3', 'a4']
NarukiFaces['aa2b'] = [ 'aa2b', 'aa2',   'ab', 'a2b', 'a', 'a2',   'b']
NarukiFaces['aa3b'] = [ 'aa3b',  'aa3',   'ab',  'a3b', 'a', 'a3',  'b']
NarukiFaces['a2a3b'] = ['a2a3b', 'a2a3',  'a2b', 'a3b',  'a2', 'a3',  'b']
# Dim 2
NarukiFaces['aa2'] = [ 'aa2',   'a', 'a2']
NarukiFaces['aa3'] = [ 'aa3',   'a', 'a3']
NarukiFaces['aa4'] = [ 'aa4',   'a', 'a4']
NarukiFaces['a2a3'] = [ 'a2a3',   'a2', 'a3']
NarukiFaces['a2a4'] = [ 'a2a4',   'a2', 'a4']
NarukiFaces['a3a4'] = [ 'a3a4',   'a3', 'a4']
NarukiFaces['ab'] = [ 'ab',   'a', 'b']
NarukiFaces['a2b'] = [ 'a2b',   'a2', 'b']
NarukiFaces['a3b'] = [ 'a3b',   'a3', 'b']
# Dim 1
NarukiFaces['a'] = ['a']
NarukiFaces['a2'] = ['a2']
NarukiFaces['a3'] = ['a3']
NarukiFaces['a4'] = ['a4']
NarukiFaces['b'] = ['b']


# The following function is used to replace a list of cones by a set corresponding by these cones and all their faces.

def replaceConesWithFaces(coneList, facesdict):
    newConeList = []
    # print coneList
    for x in coneList:
     	newConeList = newConeList + facesdict[x]
    return set(newConeList)


# The following function takes a list of lists, and returns a list of all the elements (without repetitions)

def combineLists(listOfList):
    newList = []
    for x in listOfList:
    	for y in x:
    	    newList.append(y)
    return list(set(newList))


# The following function is used to specialize all the entry values of a matrix 'listEntriesMatrix' (given as a list of lists) using a dictionary 'dictSubst'

def substituteMatrixEntries(listEntriesMatrix,dictSubst):
    newRow = dict()
    for i in range(0,len(listEntriesMatrix)):
    	newRow[i] = [SR(listEntriesMatrix[i][j]).substitute(dictSubst) for j in range(0, len(listEntriesMatrix[i]))]
    return newRow.values()		




###########################################################################
# STEP 1: Find the patterns for 0/infinities in the correspondence matrix #
###########################################################################

# The matrices with and without nones contain all 135 nodes for each cone in the Naruki fan. We need to extract this information, as well as the information from the pds. 
# At the pd level, the nodes corresponding to an extremal curve share the same five 0 coordinates, plus 4 more each.
# At the tropical level, this translates into +Infinity coordinates.
# The key on each quintuple of points, is going to tell us where to look.

# We can generate the 27 lists of 10 nodes with 3 values (the classical, the expected and the true valuation) exploiting the action of W(E6), or we can do it by automatizing the inspection. We choose the later.

pds = load("../../Yoshida/Output/AllPds_signed_ordered_permutedCols.sobj")

extremalCurves = Es+Fs+Gs
keys = [Sxy(x) for x in sorted(Sxy.gens(), reverse=True)]

# # Matrix for correspondences calculation (we commented the code since the output is stored as a sobj file
# MatrixCorrespondence = {}
# for key in keys:
#     row = {}
#     curve0 = correspondence[S(key)].factor()[0][0]
#     curve1 = correspondence[S(key)].factor()[1][0]
#     curve2 = correspondence[S(key)].factor()[2][0]
#     for extremal in extremalCurves:
#     	if extremal in [curve0,curve1, curve2]:
# 	   row[extremal]=1
# 	else:
# 	   row[extremal]=0
#     MatrixCorrespondence[key]=row

# MatrixCorrespondenceRowsCurves ={}
# for extremal in extremalCurves:
#     print extremal
#     MatrixCorrespondenceRowsCurves[extremal] ={}
#     for key in keys:
# 	MatrixCorrespondenceRowsCurves[extremal][key] = MatrixCorrespondence[SR(key)][extremal]

# We save the output as a sobj file
# save(MatrixCorrespondenceRowsCurves, "Input/MatrixCorrespondenceRowsCurves.sobj")

MatrixCorrespondenceRowsCurves = load("Input/MatrixCorrespondenceRowsCurves.sobj")

Nodes = {}
for extremal in extremalCurves:
    print extremal
    validkeys = [key for key in keys if MatrixCorrespondenceRowsCurves[extremal][key] ==1]
    intersectingCurves =[]
    for key in validkeys:
    	curveKey =  [curve for curve in extremalCurves if curve !=extremal if MatrixCorrespondenceRowsCurves[curve][key]==1]
	intersectingCurves  = intersectingCurves + curveKey 
    Nodes[extremal] = list(set(intersectingCurves))


# For the record, we print the dictionary Nodes:
# print Nodes
# {F36: [E3, G3, F12, E6, F24, G6, F15, F45, F14, F25], G3: [E4, F36, E6, F35, F34, E5, E2, F13, F23, E1], F12: [F56, F36, F35, F34, F46, F45, E2, G2, G1, E1], E6: [F56, F36, G4, G3, F46, G2, G1, F16, G5, F26], F24: [F56, E4, F36, G4, F15, F35, E2, F13, G2, F16], F46: [E4, G4, F12, E6, G6, F15, F35, F13, F23, F25], F14: [F56, E4, F36, G4, F35, G1, F23, E1, F26, F25], F25: [F36, F34, E5, F46, E2, F14, F13, G2, F16, G5], E3: [F36, G4, G6, F35, F34, F13, G2, G1, F23, G5], G4: [E3, E6, F24, F34, E5, F46, F45, E2, F14, E1], F15: [F36, F24, F34, E5, F46, G1, F23, G5, E1, F26], F45: [E4, F36, G4, F12, E5, F13, F23, F16, G5, F26], F13: [F56, E3, G3, F24, F46, F45, G1, E1, F26, F25], G5: [F56, E4, E3, E6, F15, F35, F45, E2, E1, F25], F26: [E6, G6, F15, F35, F34, F45, E2, F14, F13, G2], F56: [F12, E6, F24, G6, F34, E5, F14, F13, F23, G5], E4: [G3, F24, G6, F34, F46, F45, F14, G2, G1, G5], G2: [E4, E3, F12, E6, F24, E5, F23, E1, F26, F25], G1: [E4, E3, F12, E6, F15, E5, E2, F14, F13, F16], F23: [F56, E3, G3, F15, F46, F45, E2, F14, G2, F16], F16: [E6, F24, G6, F35, F34, F45, G1, F23, E1, F25], E1: [G4, G3, F12, G6, F15, F14, F13, G2, F16, G5], G6: [F56, E4, E3, F36, E5, F46, E2, F16, E1, F26], F35: [E3, G3, F12, F24, E5, F46, F14, F16, G5, F26], F34: [F56, E4, E3, G4, G3, F12, F15, F16, F26, F25], E5: [F56, G4, G3, G6, F15, F35, F45, G2, G1, F25], E2: [G4, G3, F12, F24, G6, G1, F23, G5, F26, F25]}



# We create the dictionary of pairs giving the 10 nodes for each extremal curve:

PairsForExtremals = dict()
for extremal in extremalCurves:
    PairsForExtremals[extremal] = [pair for pair in pairs if extremal in set(pair)]

# We record the output:
# {F23: [(F23, E3), (F23, F14), (F23, E2), (F23, G2), (F23, F15), (F56, F23), (F23, F16), (F23, G3), (F23, F46), (F23, F45)], F36: [(F36, F14), (F36, F25), (F15, F36), (F45, F36), (F36, F12), (E3, F36), (F36, G3), (F24, F36), (F36, E6), (G6, F36)], E1: [(E1, G3), (G6, E1), (F16, E1), (E1, F12), (E1, F13), (E1, G4), (F15, E1), (G5, E1), (E1, G2), (E1, F14)], F12: [(E1, F12), (G2, F12), (F36, F12), (F45, F12), (F12, G1), (F56, F12), (F46, F12), (F34, F12), (E2, F12), (F35, F12)], G4: [(E5, G4), (F46, G4), (G4, F34), (F45, G4), (E1, G4), (E2, G4), (G4, E6), (F24, G4), (E3, G4), (F14, G4)], F25: [(F16, F25), (F46, F25), (F36, F25), (G5, F25), (F34, F25), (E2, F25), (G2, F25), (F14, F25), (F13, F25), (E5, F25)], E3: [(E3, F35), (F23, E3), (G6, E3), (E3, F13), (E3, F36), (E3, G1), (E3, F34), (E3, G4), (E3, G2), (E3, G5)], G2: [(G2, E6), (E5, G2), (G2, F26), (G2, F12), (F23, G2), (E4, G2), (G2, F25), (E3, G2), (E1, G2), (F24, G2)], F13: [(F13, G1), (F45, F13), (E3, F13), (E1, F13), (F24, F13), (G3, F13), (F56, F13), (F13, F25), (F46, F13), (F13, F26)], F45: [(F45, F13), (F45, F36), (F45, F12), (E4, F45), (F45, G4), (E5, F45), (F45, F26), (F45, F16), (F45, G5), (F23, F45)], E4: [(E4, G3), (E4, F46), (E4, G2), (F24, E4), (E4, F45), (E4, G5), (E4, G6), (E4, F14), (E4, G1), (E4, F34)], G3: [(E1, G3), (G3, E6), (E4, G3), (F35, G3), (E2, G3), (G3, F34), (F36, G3), (E5, G3), (F23, G3), (G3, F13)], F24: [(F24, F16), (F24, F15), (F24, F56), (F24, F35), (F24, E4), (F24, E2), (F24, G4), (F24, F36), (F24, F13), (F24, G2)], E2: [(G5, E2), (E2, F26), (E2, F25), (F23, E2), (G6, E2), (E2, G3), (F24, E2), (E2, G4), (E2, F12), (E2, G1)], F46: [(F46, F25), (F46, G4), (E4, F46), (F46, F15), (F46, F12), (F46, F35), (F46, G6), (F23, F46), (F46, F13), (F46, E6)], G6: [(G6, F16), (G6, E1), (G6, E3), (F56, G6), (E5, G6), (G6, E2), (G6, F26), (E4, G6), (F46, G6), (G6, F36)], G5: [(G5, E2), (G5, F15), (G5, F25), (F56, G5), (E4, G5), (G5, F35), (G5, E1), (F45, G5), (E3, G5), (G5, E6)], F14: [(F36, F14), (F14, F26), (F23, F14), (F56, F14), (F14, F35), (F14, G1), (E4, F14), (F14, G4), (F14, F25), (E1, F14)], F26: [(F15, F26), (F14, F26), (E2, F26), (G2, F26), (F35, F26), (F34, F26), (G6, F26), (F26, E6), (F45, F26), (F13, F26)], F35: [(E3, F35), (F35, F26), (F24, F35), (F14, F35), (F35, G3), (E5, F35), (F16, F35), (G5, F35), (F46, F35), (F35, F12)], F34: [(F16, F34), (F34, F25), (F34, F26), (G4, F34), (G3, F34), (E3, F34), (F34, F12), (F56, F34), (F15, F34), (E4, F34)], E6: [(G3, E6), (G2, E6), (G1, E6), (F56, E6), (G4, E6), (F26, E6), (F16, E6), (F36, E6), (G5, E6), (F46, E6)], E5: [(E5, G2), (E5, G4), (E5, G6), (E5, F35), (E5, F45), (E5, G1), (E5, G3), (E5, F15), (E5, F56), (E5, F25)], G1: [(F13, G1), (F16, G1), (F14, G1), (G1, E6), (F15, G1), (F12, G1), (E3, G1), (E5, G1), (E2, G1), (E4, G1)], F56: [(F56, F14), (F24, F56), (F56, G6), (F56, G5), (F56, F23), (F56, F12), (F56, E6), (F56, F34), (F56, F13), (E5, F56)], F16: [(F16, F25), (F16, F34), (G6, F16), (F24, F16), (F16, E1), (F16, G1), (F16, F35), (F23, F16), (F16, E6), (F45, F16)], F15: [(G5, F15), (F15, F26), (F24, F15), (F15, F36), (F46, F15), (F15, G1), (F23, F15), (F15, E1), (F15, F34), (E5, F15)]}



# We first reorder Nodes[extremal] so that it agrees with that of the list PairsForExtremals[extremal].

NodesOrdered = dict()
for extremal in extremalCurves:
    NodesOrdered[extremal]=[]
    for x in PairsForExtremals[extremal]:
    	if x[0] == extremal:
	   NodesOrdered[extremal].append(x[1])
	else:
		NodesOrdered[extremal].append(x[0])






#######################################################################################################################
# STEP 2: Computing 10 relevant coordinates for each tropical line and blocks of vanishing entries on classical nodes #
#######################################################################################################################


########################
# Relevant coordinates #
########################

# To find a suitable projection to TP^9 that allows us to recover the tropical nodes in TP^44 from this projection, we need to pick 1 coordinate per node that vanishes only on that node and is nonzero on the remaining 9 nodes. These are obtained as the minimum coordinate (in the lex order) the the 4 coordinates of each node that vanish on the node but not on the extremal curve.

RelevantCoordinates = {}
for extremal in extremalCurves:
    # The validColums record the anticanonical coordinates containinig "extremal"
    validcolumns = [key for key in keys if MatrixCorrespondenceRowsCurves[extremal][key] ==1]
    relevant10 = []
    for node in newNodesSR[extremal]:
    	validColumnsNode = [key for key in keys if MatrixCorrespondenceRowsCurves[node][key] ==1 if key not in validcolumns]
	print len(validColumnsNode)
	print validColumnsNode
	print validColumnsNode[0]
	# We select the lowest in the lex order.
	relevant10 = relevant10 + [validColumnsNode[0]]
    RelevantCoordinates[extremal] = relevant10

# # We record the RelevantCoordinates:
# print RelevantCoordinates
# RelevantCoordinates= {F23: [X45, X56, X16, X15, X13, X31, X21, X12, X46, X14], F36: [X45, X12, X15, X13, X25, X24, X31, X61, X16, X14], E1: [X21, X61, X51, X24, X23, X32, X26, X25, X41, X31], F12: [X45, X36, X13, X31, X56, X23, X35, X34, X32, X46], G4: [X45, X12, X42, X31, X21, X43, X61, X51, X46, X41], F25: [X36, X16, X21, X34, X12, X51, X46, X15, X14, X13], E3: [X23, X63, X21, X14, X53, X43, X12, X16, X15, X13], G2: [X26, X23, X13, X21, X41, X25, X24, X31, X61, X51], F13: [X26, X45, X12, X21, X56, X23, X25, X24, X32, X46], F45: [X26, X23, X36, X12, X41, X16, X14, X51, X15, X13], E4: [X54, X21, X13, X24, X34, X12, X64, X16, X15, X14], G3: [X32, X36, X12, X41, X21, X35, X34, X61, X51, X31], F24: [X36, X56, X41, X16, X15, X14, X21, X35, X12, X13], E2: [X62, X32, X12, X31, X14, X13, X52, X42, X16, X15], F46: [X23, X12, X41, X15, X14, X25, X35, X61, X16, X13], G6: [X62, X63, X12, X65, X41, X61, X31, X21, X51, X64], G5: [X54, X12, X56, X41, X51, X52, X31, X21, X53, X61], F14: [X26, X23, X36, X12, X21, X56, X42, X24, X25, X35], F26: [X45, X15, X21, X35, X34, X12, X61, X16, X14, X13], F35: [X26, X12, X16, X13, X24, X31, X51, X46, X15, X14], F34: [X26, X12, X56, X41, X16, X15, X14, X13, X25, X31], E6: [X26, X36, X21, X56, X16, X14, X13, X12, X46, X15], E5: [X45, X21, X65, X15, X14, X13, X25, X35, X12, X16], G1: [X12, X42, X16, X15, X32, X23, X62, X52, X14, X13], F56: [X23, X12, X24, X34, X61, X51, X16, X15, X14, X13], F16: [X23, X45, X12, X21, X25, X24, X35, X34, X62, X26], F15: [X26, X23, X36, X12, X21, X24, X34, X52, X46, X25]}


# Since we will write coordinates of points as lists, we need to find the indices of the RelevantCoordinates in the "keys". The resulting lists of indices must be sorted since the RelevantCoordinates[extremal] are not ordered lexicographically.

RelevantCoordinatesIndices= {}
for extremal in extremalCurves:
    RelevantCoordinatesIndices[extremal]=sorted([keys.index(k) for k in RelevantCoordinates[extremal]])



# We record the RelevantCoordinatesIndices:
# print RelevantCoordinatesIndices
# {F23: [0, 1, 2, 3, 4, 5, 10, 18, 19, 24], F36: [0, 1, 2, 3, 4, 7, 8, 10, 18, 25], E1: [5, 6, 7, 8, 9, 10, 11, 15, 20, 25], F12: [1, 6, 10, 11, 12, 13, 14, 18, 19, 24], G4: [0, 5, 10, 15, 16, 17, 18, 19, 20, 25], F25: [0, 1, 2, 3, 4, 5, 12, 14, 19, 20], E3: [0, 1, 2, 3, 4, 5, 6, 17, 22, 27], G2: [1, 5, 6, 7, 8, 9, 10, 15, 20, 25], F13: [0, 5, 6, 7, 8, 9, 11, 18, 19, 24], F45: [0, 1, 2, 3, 4, 6, 9, 14, 15, 20], E4: [0, 1, 2, 3, 4, 5, 7, 12, 23, 28], G3: [0, 5, 10, 11, 12, 13, 14, 15, 20, 25], F24: [0, 1, 2, 3, 4, 5, 13, 14, 15, 24], E2: [0, 1, 2, 3, 4, 10, 11, 16, 21, 26], F46: [0, 1, 2, 3, 4, 6, 8, 13, 15, 25], G6: [0, 5, 10, 15, 20, 25, 26, 27, 28, 29], G5: [0, 5, 10, 15, 20, 21, 22, 23, 24, 25], F14: [0, 5, 6, 7, 8, 9, 13, 14, 16, 24], F26: [0, 1, 2, 3, 4, 5, 12, 13, 18, 25], F35: [0, 1, 2, 3, 4, 7, 9, 10, 19, 20], F34: [0, 1, 2, 3, 4, 8, 9, 10, 15, 24], E6: [0, 1, 2, 3, 4, 5, 9, 14, 19, 24], E5: [0, 1, 2, 3, 4, 5, 8, 13, 18, 29], G1: [0, 1, 2, 3, 4, 6, 11, 16, 21, 26], F56: [0, 1, 2, 3, 4, 6, 7, 12, 20, 25], F16: [0, 5, 6, 7, 8, 9, 12, 13, 18, 26], F15: [0, 5, 6, 7, 8, 9, 12, 14, 19, 21]}





#############################################################
# Blocks of vanishing of relevant anticanonical coordinates #
#############################################################


# We construct the indices of the 5 anticanonical coordinates associated to an extremal curve together with the 10 blocks of indices of the 4 coordinates (with values +Infinity) associated to each node of the extremal curve.

# import copy
# infinityBlocks = {}
# for extremal in extremalCurves:
#     print str(extremal)
#     infinityBlocks[extremal]={}
#     # The validColums record the anticanonical coordinates containinig "extremal"
#     validcolumns = [key for key in keys if MatrixCorrespondenceRowsCurves[extremal][key] ==1]
#     validcolumnsIndices = sorted([keys.index(x) for x in validcolumns])
#     # print validcolumnsIndices
#     for node in newNodesSR[extremal]:
#     	validColumnsNode = [key for key in keys if MatrixCorrespondenceRowsCurves[node][key] ==1 if key not in validcolumns]
# 	validColumnsNodeIndices = sorted([keys.index(x) for x in validColumnsNode])
	
# 	print len(validColumnsNode)
# 	print validColumnsNode
# 	infinityBlocks[extremal][node] =(copy.copy(validcolumnsIndices), copy.copy(validColumnsNodeIndices))

# # We record the data:
# save(infinityBlocks,'Input/infinityBlocksIndicesPerExtremal.sobj')

# We load the data:
infinityBlocks = load('../../TropicalConvexHulls/Scripts/Input/infinityBlocksIndicesPerExtremal.sobj')

# # We record the output:
# print infinityBlocks
# {F23: {F45: ([6, 11, 36, 39, 42], [18, 23, 32, 35]), F56: ([6, 11, 36, 39, 42], [24, 29, 30, 33]), F16: ([6, 11, 36, 39, 42], [4, 25, 43, 44]), F15: ([6, 11, 36, 39, 42], [3, 20, 40, 41]), G3: ([6, 11, 36, 39, 42], [1, 17, 22, 27]), E3: ([6, 11, 36, 39, 42], [10, 12, 13, 14]), E2: ([6, 11, 36, 39, 42], [5, 7, 8, 9]), G2: ([6, 11, 36, 39, 42], [0, 16, 21, 26]), F46: ([6, 11, 36, 39, 42], [19, 28, 31, 34]), F14: ([6, 11, 36, 39, 42], [2, 15, 37, 38])}, F36: {F45: ([14, 27, 32, 37, 40], [18, 23, 35, 42]), F12: ([14, 27, 32, 37, 40], [0, 5, 30, 31]), F15: ([14, 27, 32, 37, 40], [3, 20, 39, 41]), G3: ([14, 27, 32, 37, 40], [1, 6, 17, 22]), F25: ([14, 27, 32, 37, 40], [8, 21, 34, 44]), F24: ([14, 27, 32, 37, 40], [7, 16, 33, 43]), E3: ([14, 27, 32, 37, 40], [10, 11, 12, 13]), E6: ([14, 27, 32, 37, 40], [25, 26, 28, 29]), G6: ([14, 27, 32, 37, 40], [4, 9, 19, 24]), F14: ([14, 27, 32, 37, 40], [2, 15, 36, 38])}, E1: {F12: ([0, 1, 2, 3, 4], [5, 30, 31, 32]), F16: ([0, 1, 2, 3, 4], [25, 42, 43, 44]), F15: ([0, 1, 2, 3, 4], [20, 39, 40, 41]), G4: ([0, 1, 2, 3, 4], [7, 12, 23, 28]), G3: ([0, 1, 2, 3, 4], [6, 17, 22, 27]), G2: ([0, 1, 2, 3, 4], [11, 16, 21, 26]), G6: ([0, 1, 2, 3, 4], [9, 14, 19, 24]), G5: ([0, 1, 2, 3, 4], [8, 13, 18, 29]), F14: ([0, 1, 2, 3, 4], [15, 36, 37, 38]), F13: ([0, 1, 2, 3, 4], [10, 33, 34, 35])}, F12: {F45: ([0, 5, 30, 31, 32], [18, 23, 35, 42]), F36: ([0, 5, 30, 31, 32], [14, 27, 37, 40]), E1: ([0, 5, 30, 31, 32], [1, 2, 3, 4]), G1: ([0, 5, 30, 31, 32], [10, 15, 20, 25]), F56: ([0, 5, 30, 31, 32], [24, 29, 33, 36]), E2: ([0, 5, 30, 31, 32], [6, 7, 8, 9]), F35: ([0, 5, 30, 31, 32], [13, 22, 38, 43]), F34: ([0, 5, 30, 31, 32], [12, 17, 41, 44]), G2: ([0, 5, 30, 31, 32], [11, 16, 21, 26]), F46: ([0, 5, 30, 31, 32], [19, 28, 34, 39])}, G4: {F45: ([2, 7, 12, 23, 28], [18, 32, 35, 42]), E1: ([2, 7, 12, 23, 28], [0, 1, 3, 4]), F24: ([2, 7, 12, 23, 28], [16, 33, 40, 43]), E3: ([2, 7, 12, 23, 28], [10, 11, 13, 14]), E2: ([2, 7, 12, 23, 28], [5, 6, 8, 9]), F34: ([2, 7, 12, 23, 28], [17, 30, 41, 44]), E6: ([2, 7, 12, 23, 28], [25, 26, 27, 29]), E5: ([2, 7, 12, 23, 28], [20, 21, 22, 24]), F46: ([2, 7, 12, 23, 28], [19, 31, 34, 39]), F14: ([2, 7, 12, 23, 28], [15, 36, 37, 38])}, F25: {F36: ([8, 21, 34, 37, 44], [14, 27, 32, 40]), F16: ([8, 21, 34, 37, 44], [4, 25, 42, 43]), E2: ([8, 21, 34, 37, 44], [5, 6, 7, 9]), F34: ([8, 21, 34, 37, 44], [12, 17, 30, 41]), G2: ([8, 21, 34, 37, 44], [0, 11, 16, 26]), E5: ([8, 21, 34, 37, 44], [20, 22, 23, 24]), F46: ([8, 21, 34, 37, 44], [19, 28, 31, 39]), G5: ([8, 21, 34, 37, 44], [3, 13, 18, 29]), F14: ([8, 21, 34, 37, 44], [2, 15, 36, 38]), F13: ([8, 21, 34, 37, 44], [1, 10, 33, 35])}, E3: {F23: ([10, 11, 12, 13, 14], [6, 36, 39, 42]), F36: ([10, 11, 12, 13, 14], [27, 32, 37, 40]), G1: ([10, 11, 12, 13, 14], [5, 15, 20, 25]), G4: ([10, 11, 12, 13, 14], [2, 7, 23, 28]), F35: ([10, 11, 12, 13, 14], [22, 31, 38, 43]), F34: ([10, 11, 12, 13, 14], [17, 30, 41, 44]), G2: ([10, 11, 12, 13, 14], [0, 16, 21, 26]), G6: ([10, 11, 12, 13, 14], [4, 9, 19, 24]), G5: ([10, 11, 12, 13, 14], [3, 8, 18, 29]), F13: ([10, 11, 12, 13, 14], [1, 33, 34, 35])}, G2: {F26: ([0, 11, 16, 21, 26], [9, 35, 38, 41]), F23: ([0, 11, 16, 21, 26], [6, 36, 39, 42]), E1: ([0, 11, 16, 21, 26], [1, 2, 3, 4]), F12: ([0, 11, 16, 21, 26], [5, 30, 31, 32]), E4: ([0, 11, 16, 21, 26], [15, 17, 18, 19]), F25: ([0, 11, 16, 21, 26], [8, 34, 37, 44]), F24: ([0, 11, 16, 21, 26], [7, 33, 40, 43]), E3: ([0, 11, 16, 21, 26], [10, 12, 13, 14]), E6: ([0, 11, 16, 21, 26], [25, 27, 28, 29]), E5: ([0, 11, 16, 21, 26], [20, 22, 23, 24])}, F13: {F26: ([1, 10, 33, 34, 35], [9, 26, 38, 41]), F45: ([1, 10, 33, 34, 35], [18, 23, 32, 42]), E1: ([1, 10, 33, 34, 35], [0, 2, 3, 4]), G1: ([1, 10, 33, 34, 35], [5, 15, 20, 25]), F56: ([1, 10, 33, 34, 35], [24, 29, 30, 36]), G3: ([1, 10, 33, 34, 35], [6, 17, 22, 27]), F25: ([1, 10, 33, 34, 35], [8, 21, 37, 44]), F24: ([1, 10, 33, 34, 35], [7, 16, 40, 43]), E3: ([1, 10, 33, 34, 35], [11, 12, 13, 14]), F46: ([1, 10, 33, 34, 35], [19, 28, 31, 39])}, F45: {F26: ([18, 23, 32, 35, 42], [9, 26, 38, 41]), F23: ([18, 23, 32, 35, 42], [6, 11, 36, 39]), F36: ([18, 23, 32, 35, 42], [14, 27, 37, 40]), F12: ([18, 23, 32, 35, 42], [0, 5, 30, 31]), E4: ([18, 23, 32, 35, 42], [15, 16, 17, 19]), F16: ([18, 23, 32, 35, 42], [4, 25, 43, 44]), G4: ([18, 23, 32, 35, 42], [2, 7, 12, 28]), E5: ([18, 23, 32, 35, 42], [20, 21, 22, 24]), G5: ([18, 23, 32, 35, 42], [3, 8, 13, 29]), F13: ([18, 23, 32, 35, 42], [1, 10, 33, 34])}, E4: {F45: ([15, 16, 17, 18, 19], [23, 32, 35, 42]), G1: ([15, 16, 17, 18, 19], [5, 10, 20, 25]), G3: ([15, 16, 17, 18, 19], [1, 6, 22, 27]), F24: ([15, 16, 17, 18, 19], [7, 33, 40, 43]), F34: ([15, 16, 17, 18, 19], [12, 30, 41, 44]), G2: ([15, 16, 17, 18, 19], [0, 11, 21, 26]), F46: ([15, 16, 17, 18, 19], [28, 31, 34, 39]), G6: ([15, 16, 17, 18, 19], [4, 9, 14, 24]), G5: ([15, 16, 17, 18, 19], [3, 8, 13, 29]), F14: ([15, 16, 17, 18, 19], [2, 36, 37, 38])}, G3: {F23: ([1, 6, 17, 22, 27], [11, 36, 39, 42]), F36: ([1, 6, 17, 22, 27], [14, 32, 37, 40]), E1: ([1, 6, 17, 22, 27], [0, 2, 3, 4]), E4: ([1, 6, 17, 22, 27], [15, 16, 18, 19]), E2: ([1, 6, 17, 22, 27], [5, 7, 8, 9]), F35: ([1, 6, 17, 22, 27], [13, 31, 38, 43]), F34: ([1, 6, 17, 22, 27], [12, 30, 41, 44]), E6: ([1, 6, 17, 22, 27], [25, 26, 28, 29]), E5: ([1, 6, 17, 22, 27], [20, 21, 23, 24]), F13: ([1, 6, 17, 22, 27], [10, 33, 34, 35])}, F24: {F36: ([7, 16, 33, 40, 43], [14, 27, 32, 37]), F56: ([7, 16, 33, 40, 43], [24, 29, 30, 36]), E4: ([7, 16, 33, 40, 43], [15, 17, 18, 19]), F16: ([7, 16, 33, 40, 43], [4, 25, 42, 44]), F15: ([7, 16, 33, 40, 43], [3, 20, 39, 41]), G4: ([7, 16, 33, 40, 43], [2, 12, 23, 28]), E2: ([7, 16, 33, 40, 43], [5, 6, 8, 9]), F35: ([7, 16, 33, 40, 43], [13, 22, 31, 38]), G2: ([7, 16, 33, 40, 43], [0, 11, 21, 26]), F13: ([7, 16, 33, 40, 43], [1, 10, 34, 35])}, E2: {F26: ([5, 6, 7, 8, 9], [26, 35, 38, 41]), F23: ([5, 6, 7, 8, 9], [11, 36, 39, 42]), F12: ([5, 6, 7, 8, 9], [0, 30, 31, 32]), G1: ([5, 6, 7, 8, 9], [10, 15, 20, 25]), G4: ([5, 6, 7, 8, 9], [2, 12, 23, 28]), G3: ([5, 6, 7, 8, 9], [1, 17, 22, 27]), F25: ([5, 6, 7, 8, 9], [21, 34, 37, 44]), F24: ([5, 6, 7, 8, 9], [16, 33, 40, 43]), G6: ([5, 6, 7, 8, 9], [4, 14, 19, 24]), G5: ([5, 6, 7, 8, 9], [3, 13, 18, 29])}, F46: {F23: ([19, 28, 31, 34, 39], [6, 11, 36, 42]), F12: ([19, 28, 31, 34, 39], [0, 5, 30, 32]), E4: ([19, 28, 31, 34, 39], [15, 16, 17, 18]), F15: ([19, 28, 31, 34, 39], [3, 20, 40, 41]), G4: ([19, 28, 31, 34, 39], [2, 7, 12, 23]), F25: ([19, 28, 31, 34, 39], [8, 21, 37, 44]), F35: ([19, 28, 31, 34, 39], [13, 22, 38, 43]), E6: ([19, 28, 31, 34, 39], [25, 26, 27, 29]), G6: ([19, 28, 31, 34, 39], [4, 9, 14, 24]), F13: ([19, 28, 31, 34, 39], [1, 10, 33, 35])}, G6: {F26: ([4, 9, 14, 19, 24], [26, 35, 38, 41]), F36: ([4, 9, 14, 19, 24], [27, 32, 37, 40]), E1: ([4, 9, 14, 19, 24], [0, 1, 2, 3]), F56: ([4, 9, 14, 19, 24], [29, 30, 33, 36]), E4: ([4, 9, 14, 19, 24], [15, 16, 17, 18]), F16: ([4, 9, 14, 19, 24], [25, 42, 43, 44]), E3: ([4, 9, 14, 19, 24], [10, 11, 12, 13]), E2: ([4, 9, 14, 19, 24], [5, 6, 7, 8]), E5: ([4, 9, 14, 19, 24], [20, 21, 22, 23]), F46: ([4, 9, 14, 19, 24], [28, 31, 34, 39])}, G5: {F45: ([3, 8, 13, 18, 29], [23, 32, 35, 42]), E1: ([3, 8, 13, 18, 29], [0, 1, 2, 4]), F56: ([3, 8, 13, 18, 29], [24, 30, 33, 36]), E4: ([3, 8, 13, 18, 29], [15, 16, 17, 19]), F15: ([3, 8, 13, 18, 29], [20, 39, 40, 41]), F25: ([3, 8, 13, 18, 29], [21, 34, 37, 44]), E3: ([3, 8, 13, 18, 29], [10, 11, 12, 14]), E2: ([3, 8, 13, 18, 29], [5, 6, 7, 9]), F35: ([3, 8, 13, 18, 29], [22, 31, 38, 43]), E6: ([3, 8, 13, 18, 29], [25, 26, 27, 28])}, F14: {F26: ([2, 15, 36, 37, 38], [9, 26, 35, 41]), F23: ([2, 15, 36, 37, 38], [6, 11, 39, 42]), F36: ([2, 15, 36, 37, 38], [14, 27, 32, 40]), E1: ([2, 15, 36, 37, 38], [0, 1, 3, 4]), G1: ([2, 15, 36, 37, 38], [5, 10, 20, 25]), F56: ([2, 15, 36, 37, 38], [24, 29, 30, 33]), E4: ([2, 15, 36, 37, 38], [16, 17, 18, 19]), G4: ([2, 15, 36, 37, 38], [7, 12, 23, 28]), F25: ([2, 15, 36, 37, 38], [8, 21, 34, 44]), F35: ([2, 15, 36, 37, 38], [13, 22, 31, 43])}, F26: {F45: ([9, 26, 35, 38, 41], [18, 23, 32, 42]), F15: ([9, 26, 35, 38, 41], [3, 20, 39, 40]), E2: ([9, 26, 35, 38, 41], [5, 6, 7, 8]), F35: ([9, 26, 35, 38, 41], [13, 22, 31, 43]), F34: ([9, 26, 35, 38, 41], [12, 17, 30, 44]), G2: ([9, 26, 35, 38, 41], [0, 11, 16, 21]), E6: ([9, 26, 35, 38, 41], [25, 27, 28, 29]), G6: ([9, 26, 35, 38, 41], [4, 14, 19, 24]), F14: ([9, 26, 35, 38, 41], [2, 15, 36, 37]), F13: ([9, 26, 35, 38, 41], [1, 10, 33, 34])}, F35: {F26: ([13, 22, 31, 38, 43], [9, 26, 35, 41]), F12: ([13, 22, 31, 38, 43], [0, 5, 30, 32]), F16: ([13, 22, 31, 38, 43], [4, 25, 42, 44]), G3: ([13, 22, 31, 38, 43], [1, 6, 17, 27]), F24: ([13, 22, 31, 38, 43], [7, 16, 33, 40]), E3: ([13, 22, 31, 38, 43], [10, 11, 12, 14]), E5: ([13, 22, 31, 38, 43], [20, 21, 23, 24]), F46: ([13, 22, 31, 38, 43], [19, 28, 34, 39]), G5: ([13, 22, 31, 38, 43], [3, 8, 18, 29]), F14: ([13, 22, 31, 38, 43], [2, 15, 36, 37])}, F34: {F26: ([12, 17, 30, 41, 44], [9, 26, 35, 38]), F12: ([12, 17, 30, 41, 44], [0, 5, 31, 32]), F56: ([12, 17, 30, 41, 44], [24, 29, 33, 36]), E4: ([12, 17, 30, 41, 44], [15, 16, 18, 19]), F16: ([12, 17, 30, 41, 44], [4, 25, 42, 43]), F15: ([12, 17, 30, 41, 44], [3, 20, 39, 40]), G4: ([12, 17, 30, 41, 44], [2, 7, 23, 28]), G3: ([12, 17, 30, 41, 44], [1, 6, 22, 27]), F25: ([12, 17, 30, 41, 44], [8, 21, 34, 37]), E3: ([12, 17, 30, 41, 44], [10, 11, 13, 14])}, E6: {F26: ([25, 26, 27, 28, 29], [9, 35, 38, 41]), F36: ([25, 26, 27, 28, 29], [14, 32, 37, 40]), G1: ([25, 26, 27, 28, 29], [5, 10, 15, 20]), F56: ([25, 26, 27, 28, 29], [24, 30, 33, 36]), F16: ([25, 26, 27, 28, 29], [4, 42, 43, 44]), G4: ([25, 26, 27, 28, 29], [2, 7, 12, 23]), G3: ([25, 26, 27, 28, 29], [1, 6, 17, 22]), G2: ([25, 26, 27, 28, 29], [0, 11, 16, 21]), F46: ([25, 26, 27, 28, 29], [19, 31, 34, 39]), G5: ([25, 26, 27, 28, 29], [3, 8, 13, 18])}, E5: {F45: ([20, 21, 22, 23, 24], [18, 32, 35, 42]), G1: ([20, 21, 22, 23, 24], [5, 10, 15, 25]), F56: ([20, 21, 22, 23, 24], [29, 30, 33, 36]), F15: ([20, 21, 22, 23, 24], [3, 39, 40, 41]), G4: ([20, 21, 22, 23, 24], [2, 7, 12, 28]), G3: ([20, 21, 22, 23, 24], [1, 6, 17, 27]), F25: ([20, 21, 22, 23, 24], [8, 34, 37, 44]), F35: ([20, 21, 22, 23, 24], [13, 31, 38, 43]), G2: ([20, 21, 22, 23, 24], [0, 11, 16, 26]), G6: ([20, 21, 22, 23, 24], [4, 9, 14, 19])}, G1: {F12: ([5, 10, 15, 20, 25], [0, 30, 31, 32]), E4: ([5, 10, 15, 20, 25], [16, 17, 18, 19]), F16: ([5, 10, 15, 20, 25], [4, 42, 43, 44]), F15: ([5, 10, 15, 20, 25], [3, 39, 40, 41]), E3: ([5, 10, 15, 20, 25], [11, 12, 13, 14]), E2: ([5, 10, 15, 20, 25], [6, 7, 8, 9]), E6: ([5, 10, 15, 20, 25], [26, 27, 28, 29]), E5: ([5, 10, 15, 20, 25], [21, 22, 23, 24]), F14: ([5, 10, 15, 20, 25], [2, 36, 37, 38]), F13: ([5, 10, 15, 20, 25], [1, 33, 34, 35])}, F56: {F23: ([24, 29, 30, 33, 36], [6, 11, 39, 42]), F12: ([24, 29, 30, 33, 36], [0, 5, 31, 32]), F24: ([24, 29, 30, 33, 36], [7, 16, 40, 43]), F34: ([24, 29, 30, 33, 36], [12, 17, 41, 44]), E6: ([24, 29, 30, 33, 36], [25, 26, 27, 28]), E5: ([24, 29, 30, 33, 36], [20, 21, 22, 23]), G6: ([24, 29, 30, 33, 36], [4, 9, 14, 19]), G5: ([24, 29, 30, 33, 36], [3, 8, 13, 18]), F14: ([24, 29, 30, 33, 36], [2, 15, 37, 38]), F13: ([24, 29, 30, 33, 36], [1, 10, 34, 35])}, F16: {F23: ([4, 25, 42, 43, 44], [6, 11, 36, 39]), F45: ([4, 25, 42, 43, 44], [18, 23, 32, 35]), E1: ([4, 25, 42, 43, 44], [0, 1, 2, 3]), G1: ([4, 25, 42, 43, 44], [5, 10, 15, 20]), F25: ([4, 25, 42, 43, 44], [8, 21, 34, 37]), F24: ([4, 25, 42, 43, 44], [7, 16, 33, 40]), F35: ([4, 25, 42, 43, 44], [13, 22, 31, 38]), F34: ([4, 25, 42, 43, 44], [12, 17, 30, 41]), E6: ([4, 25, 42, 43, 44], [26, 27, 28, 29]), G6: ([4, 25, 42, 43, 44], [9, 14, 19, 24])}, F15: {F26: ([3, 20, 39, 40, 41], [9, 26, 35, 38]), F23: ([3, 20, 39, 40, 41], [6, 11, 36, 42]), F36: ([3, 20, 39, 40, 41], [14, 27, 32, 37]), E1: ([3, 20, 39, 40, 41], [0, 1, 2, 4]), G1: ([3, 20, 39, 40, 41], [5, 10, 15, 25]), F24: ([3, 20, 39, 40, 41], [7, 16, 33, 43]), F34: ([3, 20, 39, 40, 41], [12, 17, 30, 44]), E5: ([3, 20, 39, 40, 41], [21, 22, 23, 24]), F46: ([3, 20, 39, 40, 41], [19, 28, 31, 34]), G5: ([3, 20, 39, 40, 41], [8, 13, 18, 29])}}



# We create a dictionary of Infinity with lists of anticanonical coordinates rather that the column numbers.
InfinityBlockEntries = {extremal: {node: ([keys[x] for x in InfinityBlocks[extremal][node][0]], [keys[x] for x in InfinityBlocks[extremal][node][1]])  for node in NodesOrdered[extremal]} for extremal in extremalCurves}


# The first entry of the tuples is the list of anticanonical coordinates that vanish on the extremal curve. We are interested in the second entry of the tuple. The following dictionary records this information.

InfinityBlockEntriesLast = {extremal: {node: [keys[x] for x in InfinityBlocks[extremal][node][1]]  for node in NodesOrdered[extremal]} for extremal in extremalCurves}



#################################################################
# STEP 3: Calculation of 10 classical nodes and positions in TM #
#################################################################

# We search on the pds to find the classical expressions for the nodes. Once these are found, we will search for their tropicalizations (with and without nones).

# To find the nodes of E1, we look at the dictionary of nodes. A node curve1 \cap curve2, will be listed in pds[curve3] for curve3 = 3rd non-zero entry on the unique key with 1s at entries curve1 and curve2. We figure out which of the 5 entries in pds[curve3] is it by checking which i in range(0,5) satisfies the property  pds[curve3][i][S(key)] == 0.

# At the same time, we record the positions to extract from the TM matrices (with or without Nones) later on.

# The resulting dictionary "NodesFromPds" will be used in "../../TropicalConvexHulls/Scripts/NodesForAllExtremalCurves.sage"

# NodesFromPds ={}
# positionsInTM ={}
# for extremal in extremalCurves:
#     positionsInTM[extremal] ={}
#     NodesFromPds[extremal] = {}
#     for node in Nodes[extremal]:
# #    	print str(node)
# #    	each pair of intersecting curves lies in a unique triangle, wich we compute from :
#     	triangle = [key for key in keys if MatrixCorrespondenceRowsCurves[extremal][key]==1 if MatrixCorrespondenceRowsCurves[node][key]==1][0]
#     	curve3 = [curve for curve in extremalCurves if MatrixCorrespondenceRowsCurves[curve][triangle]==1 if curve != extremal if curve !=node][0]
# 	possibleNodes = pds[curve3]
# 	# Each node lies in the link of a unique curve, but the link has 5 elements, so we need to find the exact position for the node. We do so by finding the one in the correct triangle.
# 	position = [i for i in range(0,5) if possibleNodes[i][triangle]==0][0]
# 	positionsInTM[extremal][node] = (curve3,position)
# 	NodesFromPds[extremal][node] = {}
# 	for k in keys:
# 	    print str(k)
# 	    if possibleNodes[position][k] == 0:
# 	       NodesFromPds[extremal][node][k] = YField(0)
# 	    else:
# 	       NodesFromPds[extremal][node][k] = YField(expand(possibleNodes[position][k])).factor() 



# # # We record the output as a sage Object
# # save(NodesFromPds,"../../TropicalConvexHulls/Scripts/Input/10NodesPerExtremalCurvesYField.sobj")


NodesFromPds = load("../../TropicalConvexHulls/Scripts/Input/10NodesPerExtremalCurvesYField.sobj")

# We print the position dictionary for the record:
# print positionsInTM

positionsInTM = {F36: {E3: (G6, 1), G3: (E6, 4), F12: (F45, 3), E6: (G3, 4), F24: (F15, 2), G6: (E3, 0), F15: (F24, 3), F45: (F12, 4), F14: (F25, 2), F25: (F14, 3)}, G3: {E4: (F34, 1), F36: (E6, 4), E6: (F36, 1), F35: (E5, 4), F34: (E4, 4), E5: (F35, 1), E2: (F23, 0), F13: (E1, 4), F23: (E2, 4), E1: (F13, 0)}, F12: {F56: (F34, 2), F36: (F45, 3), F35: (F46, 4), F34: (F56, 4), F46: (F35, 3), F45: (F36, 4), E2: (G1, 0), G2: (E1, 2), G1: (E2, 3), E1: (G2, 0)}, E6: {F56: (G5, 4), F36: (G3, 4), G4: (F46, 1), G3: (F36, 1), F46: (G4, 4), G2: (F26, 1), G1: (F16, 1), F16: (G1, 4), G5: (F56, 1), F26: (G2, 4)}, F24: {F56: (F13, 2), E4: (G2, 2), F36: (F15, 2), G4: (E2, 2), F15: (F36, 3), F35: (F16, 2), E2: (G4, 2), F13: (F56, 2), G2: (E4, 2), F16: (F35, 4)}, F46: {E4: (G6, 2), G4: (E6, 0), F12: (F35, 3), E6: (G4, 4), G6: (E4, 0), F15: (F23, 3), F35: (F12, 3), F13: (F25, 3), F23: (F15, 3), F25: (F13, 3)}, F14: {F56: (F23, 2), E4: (G1, 2), F36: (F25, 2), G4: (E1, 3), F35: (F26, 2), G1: (E4, 3), F23: (F56, 3), E1: (G4, 0), F26: (F35, 2), F25: (F36, 2)}, F25: {F36: (F14, 3), F34: (F16, 3), E5: (G2, 3), F46: (F13, 3), E2: (G5, 3), F14: (F36, 2), F13: (F46, 2), G2: (E5, 2), F16: (F34, 4), G5: (E2, 1)}, E3: {F36: (G6, 1), G4: (F34, 0), G6: (F36, 0), F35: (G5, 1), F34: (G4, 1), F13: (G1, 1), G2: (F23, 1), G1: (F13, 1), F23: (G2, 1), G5: (F35, 0)}, G4: {E3: (F34, 0), E6: (F46, 1), F24: (E2, 2), F34: (E3, 4), E5: (F45, 1), F46: (E6, 0), F45: (E5, 1), E2: (F24, 0), F14: (E1, 3), E1: (F14, 0)}, F15: {F36: (F24, 3), F24: (F36, 3), F34: (F26, 3), E5: (G1, 3), F46: (F23, 3), G1: (E5, 3), F23: (F46, 3), G5: (E1, 1), E1: (G5, 0), F26: (F34, 3)}, F45: {E4: (G5, 2), F36: (F12, 4), G4: (E5, 1), F12: (F36, 4), E5: (G4, 3), F13: (F26, 4), F23: (F16, 4), F16: (F23, 4), G5: (E4, 1), F26: (F13, 4)}, F13: {F56: (F24, 2), E3: (G1, 1), G3: (E1, 4), F24: (F56, 2), F46: (F25, 3), F45: (F26, 4), G1: (E3, 3), E1: (G3, 0), F26: (F45, 2), F25: (F46, 2)}, G5: {F56: (E6, 1), E4: (F45, 0), E3: (F35, 0), E6: (F56, 1), F15: (E1, 1), F35: (E3, 1), F45: (E4, 1), E2: (F25, 0), E1: (F15, 0), F25: (E2, 1)}, F26: {E6: (G2, 4), G6: (E2, 0), F15: (F34, 3), F35: (F14, 4), F34: (F15, 4), F45: (F13, 4), E2: (G6, 4), F14: (F35, 2), F13: (F45, 2), G2: (E6, 2)}, F56: {F12: (F34, 2), E6: (G5, 4), F24: (F13, 2), G6: (E5, 0), F34: (F12, 2), E5: (G6, 3), F14: (F23, 2), F13: (F24, 2), F23: (F14, 2), G5: (E6, 1)}, E4: {G3: (F34, 1), F24: (G2, 2), G6: (F46, 0), F34: (G3, 2), F46: (G6, 2), F45: (G5, 2), F14: (G1, 2), G2: (F24, 1), G1: (F14, 1), G5: (F45, 0)}, G2: {E4: (F24, 1), E3: (F23, 1), F12: (E1, 2), E6: (F26, 1), F24: (E4, 2), E5: (F25, 1), F23: (E3, 2), E1: (F12, 0), F26: (E6, 2), F25: (E5, 2)}, G1: {E4: (F14, 1), E3: (F13, 1), F12: (E2, 3), E6: (F16, 1), F15: (E5, 3), E5: (F15, 1), E2: (F12, 1), F14: (E4, 3), F13: (E3, 3), F16: (E6, 3)}, F23: {F56: (F14, 2), E3: (G2, 1), G3: (E2, 4), F15: (F46, 3), F46: (F15, 3), F45: (F16, 4), E2: (G3, 1), F14: (F56, 3), G2: (E3, 2), F16: (F45, 4)}, F16: {E6: (G1, 4), F24: (F35, 4), G6: (E1, 0), F35: (F24, 4), F34: (F25, 4), F45: (F23, 4), G1: (E6, 3), F23: (F45, 4), E1: (G6, 0), F25: (F34, 4)}, E1: {G4: (F14, 0), G3: (F13, 0), F12: (G2, 0), G6: (F16, 0), F15: (G5, 0), F14: (G4, 0), F13: (G3, 0), G2: (F12, 0), F16: (G6, 0), G5: (F15, 0)}, G6: {F56: (E5, 0), E4: (F46, 0), E3: (F36, 0), F36: (E3, 0), E5: (F56, 0), F46: (E4, 0), E2: (F26, 0), F16: (E1, 0), E1: (F16, 0), F26: (E2, 0)}, F35: {E3: (G5, 1), G3: (E5, 4), F12: (F46, 4), F24: (F16, 2), E5: (G3, 3), F46: (F12, 3), F14: (F26, 2), F16: (F24, 4), G5: (E3, 1), F26: (F14, 4)}, F34: {F56: (F12, 2), E4: (G3, 2), E3: (G4, 1), G4: (E3, 4), G3: (E4, 4), F12: (F56, 4), F15: (F26, 3), F16: (F25, 4), F26: (F15, 4), F25: (F16, 3)}, E5: {F56: (G6, 3), G4: (F45, 1), G3: (F35, 1), G6: (F56, 0), F15: (G1, 3), F35: (G3, 3), F45: (G4, 3), G2: (F25, 1), G1: (F15, 1), F25: (G2, 3)}, E2: {G4: (F24, 0), G3: (F23, 0), F12: (G1, 0), F24: (G4, 2), G6: (F26, 0), G1: (F12, 1), F23: (G3, 1), G5: (F25, 0), F26: (G6, 4), F25: (G5, 3)}}



######################################
# Check that the nodes are collinear #
######################################

# The required functions and variables are coded in "OperatorsOnYoshidas.sage"

os.chdir("../../Yoshida/Scripts")

load("OperatorsOnYoshidas.sage")

os.chdir("../../TropicalConvexHulls/Scripts")


NodesFromPds = load("../../TropicalConvexHulls/Scripts/Input/10NodesPerExtremalCurvesYField.sobj")

otype = 0.parent()
srtype = SR(Yoshida1).parent()

def factorizToSR(poly):
    if poly.parent() == otype:
       return  poly
    if poly.parent() == srtype:
       return poly
    else:
	return SR(poly.value())
	
# newNodesSR = {}
# for extremal in extremalCurves:
#     print ''
#     print str(extremal)
#     newNodesSR[extremal]= {}
#     for k in Nodes[extremal]:
#     	print str(k)
#     	kthEntry = {}
#     	for key in keys:
# #	    print str(key)
# 	    kthEntry[key] = factorizToSR(NodesFromPds[extremal][k][key])
# 	newNodesSR[extremal][k] = kthEntry #newNodesSR[extremal].append(kthEntry)

# save(newNodesSR, "../../TropicalConvexHulls/Scripts/Input/10NodesPerExtremalCurvesSR.sobj") 


newNodesSR = load("../../TropicalConvexHulls/Scripts/Input/10NodesPerExtremalCurvesSR.sobj")


# We work with one extremal curve at a time, transform the SR expressions into expressions in ds using y_to_d. The calculation for each extremal curve takes about 15 minutes on a 2.4 GHz Intel(R) Core 2 Duo with 3MB cache and 2GB RAM. Since all our calculations were done taking advantage of the W(E6)-action, we need only check E1:

nodesInDs = {}
for extremal in extremalCurves[0:1]:
    print ''
    print str(extremal)
    nodesInDs[extremal] ={}
    for k in Nodes[extremal]:
    	print str(k)
    	newrow = {}
	for key in keys:
	    newrow[key] = newNodesSR[extremal][k][key].substitute(y_to_d)
	nodesInDs[extremal][k] = newrow
	
# Next we do a random substitution to check the rank of the (10x45)-matrix 

# Pick Random integers
# ZZ= IntegerRing()
# d = (ZZ.random_element(-1000,1000), ZZ.random_element(-1000,1000), ZZ.random_element(-1000,1000),ZZ.random_element(-1000,1000),ZZ.random_element(-1000,1000),ZZ.random_element(-1000,1000))
v# vald = {SR(ds[k]):d[k] for k in range(0,6)}
vald = {SR(d1): -717, SR(d2):-662, SR(d3):471,SR(d4): -136, SR(d5):-266, SR(d6):-182}

testMatrix = {}
for extremal in extremalCurves[0:1]:
#    test = nodesInDs[extremal]
    # Convert the dictionaries into a list of lists and evaluate at 
    rowsToBuild = []
    for k in Nodes[extremal]:
    	    v = [QQ(factorizToSR(nodesInDs[extremal][k][key]).substitute(vald)) for key in keys]
    	    rowsToBuild.append(v)
    testMatrix[extremal] = rowsToBuild

ME1 = matrix(testMatrix[E1])
rank(ME1)
# 2




###############################################################
# Computing all 135 Nodes (as Rational functions in Yoshidas) #
###############################################################

# We construct all 135 Nodes as a dictionary that takes a tuple as an index.

# IndicesOrderedPairsOfCurves=[]
# for extremal in extremalCurves:
#     print str(extremal)
#     for curve in Nodes[extremal]:
#         newPair = set([extremal,curve])
# 	if newPair in IndicesOrderedPairsOfCurves:
# 	   print 'Pair is not new'
# 	else:
# 		IndicesOrderedPairsOfCurves.append(newPair)
#     print 'Done with this extremal curve'

# len(IndicesOrderedPairsOfCurves)

# We record the output:
# print IndicesOrderedPairsOfCurves

IndicesOrderedPairsOfCurves = [set([F12, E1]), set([F16, E1]), set([F15, E1]), set([G4, E1]), set([E1, G3]), set([G2, E1]), set([G6, E1]), set([G5, E1]), set([F14, E1]), set([E1, F13]), set([F26, E2]), set([F23, E2]), set([F12, E2]), set([G1, E2]), set([E2, G4]), set([E2, G3]), set([F25, E2]), set([F24, E2]), set([G6, E2]), set([E2, G5]), set([F23, E3]), set([E3, F36]), set([G1, E3]), set([E3, G4]), set([E3, F35]), set([E3, F34]), set([G2, E3]), set([G6, E3]), set([E3, G5]), set([E3, F13]), set([E4, F45]), set([G1, E4]), set([E4, G3]), set([F24, E4]), set([E4, F34]), set([G2, E4]), set([E4, F46]), set([E4, G6]), set([E4, G5]), set([E4, F14]), set([E5, F45]), set([G1, E5]), set([E5, F56]), set([E5, F15]), set([E5, G4]), set([E5, G3]), set([F25, E5]), set([E5, F35]), set([G2, E5]), set([E5, G6]), set([F26, E6]), set([E6, F36]), set([E6, G1]), set([E6, F56]), set([E6, F16]), set([E6, G4]), set([E6, G3]), set([G2, E6]), set([E6, F46]), set([E6, G5]), set([F12, F45]), set([F12, F36]), set([F12, G1]), set([F12, F56]), set([F12, F35]), set([F12, F34]), set([F12, G2]), set([F12, F46]), set([F26, F13]), set([F45, F13]), set([G1, F13]), set([F56, F13]), set([G3, F13]), set([F25, F13]), set([F24, F13]), set([F46, F13]), set([F26, F14]), set([F23, F14]), set([F36, F14]), set([G1, F14]), set([F56, F14]), set([G4, F14]), set([F25, F14]), set([F35, F14]), set([F26, F15]), set([F23, F15]), set([F15, F36]), set([G1, F15]), set([F24, F15]), set([F15, F34]), set([F46, F15]), set([F15, G5]), set([F23, F16]), set([F45, F16]), set([G1, F16]), set([F25, F16]), set([F24, F16]), set([F16, F35]), set([F16, F34]), set([G6, F16]), set([F23, F45]), set([F56, F23]), set([F23, G3]), set([G2, F23]), set([F23, F46]), set([F24, F36]), set([F24, F56]), set([F24, G4]), set([F24, F35]), set([G2, F24]), set([F25, F36]), set([F25, F34]), set([G2, F25]), set([F25, F46]), set([F25, G5]), set([F26, F45]), set([F26, F35]), set([F26, F34]), set([F26, G2]), set([F26, G6]), set([F56, F34]), set([G4, F34]), set([G3, F34]), set([F35, G3]), set([F46, F35]), set([G5, F35]), set([F45, F36]), set([F36, G3]), set([G6, F36]), set([F45, G4]), set([F45, G5]), set([F46, G4]), set([F46, G6]), set([F56, G6]), set([F56, G5])]



# # We write the coordinates of all 135 Nodes. We record it as a dictionary, with keys given by ordered tuples for the elements of "IndicesOrderedPairsOfCurves"
# all135Nodes = {}
# for x in IndicesOrderedPairsOfCurves:
#     xList = sorted(list(x))
#     all135Nodes[tuple(xList)] = NodesFromPds[xList[0]][xList[1]]    
# We save the output to load it later (the order within the tuple changes)
# save(all135Nodes, "Input/all135ClassicalNodes.sobj")

# We load the output:
all135Nodes = load("../../Yoshida/Scripts/Input/all135ClassicalNodes.sobj")







##################################################################################
# Computing all 135 Nodes (as rational functions in Yoshida and Cross functions) #
##################################################################################


# We construct all 135 Nodes in Cross and Yoshidas as a dictionary that takes a tuple of intersecting extremal curves as an index. We do so in order to optimize the computation of the expected and true tropical nodes.

# Next, we create the dictionary of nodes in Yoshidas and Cross functions.
# Each node takes about 3 minutes to compute on a 2.4 GHz Intel(R) Core 2 Duo with 3MB cache and 2GB RAM.

# all135NodesInYC = dict()
# for pair in all135Nodes.keys():
#     print pair
#     all135NodesInYC[pair] = nodesInCrossAndYoshidas(all135Nodes[pair],cross_to_yoshidas)
#     print ''
#     print ''
			   
# # We save the output as a Sage object
# save(all135NodesInYC, 'Input/all135NodesInYC.sobj')

# We load the precomputed dictionary of 135 Nodes in Yoshida and Cross functions
all135NodesInYC = load('../../Yoshida/Scripts/Input/all135NodesInYC.sobj')





#######################################################
# Functions to build 10 nodes for each Extremal Curve #
#######################################################

# Next, we build the dictionary of 10 nodes associated to each extremal curve. We use the dictionary 'all135NodesInYC' computed earlier

# We work with one extremal curve at a time, transform the SR expressions into expressions in Yoshidas and Cross functions. The calculation for each extremal curve takes about 15 minutes on a 2.4 GHz Intel(R) Core 2 Duo with 3MB cache and 2GB RAM.

# To find the nodes of curve1, we look at the dictionary of nodes. A node curve1 \cap curve2, will be listed in the dictionary 'all135NodesInYC' as all135NodesInYC[(curve1, curve2)] or all135NodesInYC[(curve2, curve1)]

# The keys correspond to the ordered list of 45 anticanonical triangles (loaded in 'Yoshida/Scripts/allTropicalNodesPerNarukiConesMacros.sage')

# The pairs of extremal curves giving nodes are the keys from 'all135NodesInYC'

keys = [S(x) for x in sorted(S.gens(), reverse=True)]
pairs = all135NodesInYC.keys()

# NodesYCPerExtremal = dict()
# for extremal in extremalCurves:
#     NodesYCPerExtremal[extremal] = dict()
#     for node in Nodes[extremal]:
#     	print node
#     	if (extremal,node) in pairs:
# 	   NodesYCPerExtremal[extremal][node] = all135NodesInYC[(extremal,node)]
# 	elif (node,extremal) in pairs:
# 	     NodesYCPerExtremal[extremal][node] = all135NodesInYC[(node,extremal)]
# 	else:
# 		print "We have a problem!!!"


# # We record the output as a Sage Object file:
# save(NodesYCPerExtremal,"../../TropicalConvexHulls/Scripts/Input/10NodesPerExtremalCurvesYCField.sobj")

NodesYCPerExtremal = load("../../TropicalConvexHulls/Scripts/Input/10NodesPerExtremalCurvesYCField.sobj")

# # We record this as a single plain text file:
# f = file("../Output/10NodesYCPerExtremalCurves.txt",'w')
# for extremal in extremalCurves:
#     f.write('Nodes for extremal curve ' +  str(extremal) + '\n')
#     f.write('Nodes['+ str(extremal) + ']' + '=' + str(NodesYCPerExtremal[extremal]) + '\n' + '\n')
# f.close()    








################################################
# STEP 4: Exploiting ratios of cross functions #
################################################


####################################
# Valuation of all Cross functions #
####################################


# In order to compute the tropicalization of all nodes, and write the output as a linear function in valuations of Yoshida and Cross functions, we use a modification of the function 'yoshida_and_cross_to_trop_yoshida_and_cross_with_Nones' from '../../Yoshida/Scripts/allTropicalNodesPerNarukiConesMacros.sage':

# The following fucntion substitutes the entries of each node by the valuation of Cross functions, 

# c = rational function in Yoshida and Cross functions

def yoshida_and_cross_to_trop_yoshida_and_cross(c):
    if c == 0:
        return +Infinity
    c = YCField(expand(c)).factor()
    linear_form = 0
    for (f,e) in c:
    	# print f
        if len(YCRing(f).monomials()) == 1:
	   if SR(f) in Yoshidas + cross_variables: 
              linear_form = linear_form + e*f
	   else:
		print 'There is an error. Abort???'
        else:
		print 'There is an error. Abort???'
    return linear_form



# We tropicalize the monomial in the yoshidas, remembering to multiply the result by 1/3. We also fix the values for Cross[3*k] to be Cross[3*k]

# tropical_dict_cross_ratios =dict()
# for key in dict_cross_ratios.keys():
#     print key
#     tropical_dict_cross_ratios[dict_cross_ratios[key][0]] = SR(dict_cross_ratios[key][0])
#     tropical_dict_cross_ratios[key] = SR(dict_cross_ratios[key][0]) + SR(1/3*yoshida_and_cross_to_trop_yoshida_and_cross(dict_cross_ratios[key][1]))

# # We save the data as a sage object file:
# save(tropical_dict_cross_ratios, '../../TropicalConvexHulls/Scripts/Input/tropical_dict_cross_ratiosv2.sobj')

# # We record the output (ordered increasingly according to the index of Cross functions):
# for k in range(0,len(cross_variables)):
#     print {cross_variables[k]: tropical_dict_cross_ratios[cross_variables[k]]}

# {Cross0: Cross0}
# {Cross1: Cross0 + 2*Yoshida17 + 2/3*Yoshida18 - Yoshida19 - 2/3*Yoshida20 + 4/3*Yoshida21 - 4/3*Yoshida22 + Yoshida23 - Yoshida24 + 2*Yoshida25 - 2/3*Yoshida26 + 4/3*Yoshida27 - 2*Yoshida28 + 5/3*Yoshida30 - 2*Yoshida31 - 4/3*Yoshida5}
# {Cross2: Cross0 + 1/3*Yoshida18 + 2/3*Yoshida20 + 2/3*Yoshida21 + 1/3*Yoshida22 - 4/3*Yoshida26 + 2/3*Yoshida27 + 1/3*Yoshida30 - Yoshida31 - 2/3*Yoshida5}
# {Cross3: Cross3}
# {Cross4: Cross3 - 1/3*Yoshida18 + Yoshida19 - 2/3*Yoshida20 + 1/3*Yoshida21 + 2/3*Yoshida22 - 2/3*Yoshida26 + 1/3*Yoshida27 - 1/3*Yoshida30 - 1/3*Yoshida5}
# {Cross5: Cross3 + 1/3*Yoshida18 - 1/3*Yoshida20 - 1/3*Yoshida21 + 1/3*Yoshida22 - 1/3*Yoshida26 + 2/3*Yoshida27 - 2/3*Yoshida30 + 1/3*Yoshida5}
# {Cross6: Cross6}
# {Cross7: Cross6 - Yoshida17 + 1/3*Yoshida18 + Yoshida19 + 2/3*Yoshida20 - 1/3*Yoshida21 + 4/3*Yoshida22 + Yoshida24 - Yoshida25 - 4/3*Yoshida26 - 1/3*Yoshida27 + Yoshida28 - 2/3*Yoshida30 - 2/3*Yoshida5}
# {Cross8: Cross6 + 2/3*Yoshida18 + 1/3*Yoshida20 - 2/3*Yoshida21 + 2/3*Yoshida22 - 2/3*Yoshida26 + 1/3*Yoshida27 - 1/3*Yoshida30 - 1/3*Yoshida5}
# {Cross9: Cross9}
# {Cross10: Cross9 - 1/3*Yoshida18 - 2/3*Yoshida20 - 2/3*Yoshida21 - 1/3*Yoshida22 + 4/3*Yoshida26 + 1/3*Yoshida27 - Yoshida29 - 1/3*Yoshida30 + Yoshida31 + 2/3*Yoshida5}
# {Cross11: Cross9 + 1/3*Yoshida18 - 1/3*Yoshida20 - 1/3*Yoshida21 - 2/3*Yoshida22 + 2/3*Yoshida26 - 1/3*Yoshida27 - Yoshida29 + 1/3*Yoshida30 + Yoshida31 + 1/3*Yoshida5}
# {Cross12: Cross12}
# {Cross13: Cross12 - Yoshida17 + 2/3*Yoshida18 + 1/3*Yoshida20 + 1/3*Yoshida21 + 2/3*Yoshida22 + Yoshida24 - Yoshida25 - 2/3*Yoshida26 - 2/3*Yoshida27 + Yoshida28 - 1/3*Yoshida30 - 1/3*Yoshida5}
# {Cross14: Cross12 - Yoshida17 - 2/3*Yoshida18 - 1/3*Yoshida20 + 2/3*Yoshida21 + 1/3*Yoshida22 - 1/3*Yoshida26 - 1/3*Yoshida27 + Yoshida29 + 1/3*Yoshida30 + 1/3*Yoshida5}
# {Cross15: Cross15}
# {Cross16: Cross15 - Yoshida17 - 1/3*Yoshida18 + 1/3*Yoshida20 + 1/3*Yoshida21 + 2/3*Yoshida22 - 2/3*Yoshida26 + 1/3*Yoshida27 + Yoshida29 - 1/3*Yoshida30 - 1/3*Yoshida5}
# {Cross17: Cross15 - Yoshida17 + 1/3*Yoshida18 + 2/3*Yoshida20 - 1/3*Yoshida21 + 4/3*Yoshida22 + Yoshida24 - Yoshida25 - 1/3*Yoshida26 - 1/3*Yoshida27 + Yoshida28 - 2/3*Yoshida30 - 2/3*Yoshida5}
# {Cross18: Cross18}
# {Cross19: Cross18 + 2/3*Yoshida18 + 1/3*Yoshida20 + 1/3*Yoshida21 + 2/3*Yoshida22 - 2/3*Yoshida26 + 1/3*Yoshida27 - 1/3*Yoshida30 - Yoshida31 - 1/3*Yoshida5}
# {Cross20: Cross18 + Yoshida17 + 1/3*Yoshida18 - 1/3*Yoshida20 + 2/3*Yoshida21 - 2/3*Yoshida22 + Yoshida23 - Yoshida24 + Yoshida25 - 1/3*Yoshida26 + 2/3*Yoshida27 - Yoshida28 + 1/3*Yoshida30 - Yoshida31 - 2/3*Yoshida5}
# {Cross21: Cross21}
# {Cross22: Cross21 - Yoshida17 - 1/3*Yoshida18 + 1/3*Yoshida20 + 1/3*Yoshida21 + 2/3*Yoshida22 + Yoshida24 - 2/3*Yoshida26 - 2/3*Yoshida27 + Yoshida28 - 1/3*Yoshida30 - 1/3*Yoshida5}
# {Cross23: Cross21 - 2/3*Yoshida18 - 1/3*Yoshida20 + 2/3*Yoshida21 + 1/3*Yoshida22 - 1/3*Yoshida26 - 1/3*Yoshida27 + 1/3*Yoshida30 + 1/3*Yoshida5}
# {Cross24: Cross24}
# {Cross25: Cross24 + 1/3*Yoshida18 - 1/3*Yoshida20 - 1/3*Yoshida21 + 1/3*Yoshida22 + 2/3*Yoshida26 - 1/3*Yoshida27 - 2/3*Yoshida30 + 1/3*Yoshida5}
# {Cross26: Cross24 + 2*Yoshida17 + 2/3*Yoshida18 - Yoshida19 - 2/3*Yoshida20 + 1/3*Yoshida21 - 4/3*Yoshida22 + Yoshida23 - Yoshida24 + Yoshida25 + 1/3*Yoshida26 + 1/3*Yoshida27 - Yoshida28 + 2/3*Yoshida30 - Yoshida31 - 1/3*Yoshida5}
# {Cross27: Cross28 + Yoshida17 + 1/3*Yoshida18 - Yoshida19 - 1/3*Yoshida20 - 1/3*Yoshida21 - 2/3*Yoshida22 + 2/3*Yoshida26 + 2/3*Yoshida27 - Yoshida28 + 1/3*Yoshida30 + 1/3*Yoshida5}
# {Cross28: Cross28}
# {Cross29: Cross28 + Yoshida17 + 2/3*Yoshida18 - Yoshida19 + 1/3*Yoshida20 + 1/3*Yoshida21 - 1/3*Yoshida22 + 1/3*Yoshida26 + 1/3*Yoshida27 - Yoshida28 + 2/3*Yoshida30 - Yoshida31 - 1/3*Yoshida5}
# {Cross30: Cross30}
# {Cross31: Cross30 + 2*Yoshida17 + 2/3*Yoshida18 - Yoshida19 - 2/3*Yoshida20 + 4/3*Yoshida21 - 7/3*Yoshida22 + Yoshida23 - Yoshida24 + Yoshida25 + 1/3*Yoshida26 + 1/3*Yoshida27 - 2*Yoshida28 + 5/3*Yoshida30 - Yoshida31 - 1/3*Yoshida5}
# {Cross32: Cross30 + Yoshida17 + 1/3*Yoshida18 - 1/3*Yoshida20 + 2/3*Yoshida21 - 2/3*Yoshida22 - 1/3*Yoshida26 + 2/3*Yoshida27 - Yoshida28 + 4/3*Yoshida30 - Yoshida31 - 2/3*Yoshida5}
# {Cross33: Cross33}
# {Cross34: Cross33 - 1/3*Yoshida18 + 1/3*Yoshida20 + 1/3*Yoshida21 - 1/3*Yoshida22 + 1/3*Yoshida26 + 1/3*Yoshida27 - 1/3*Yoshida30 - 1/3*Yoshida5}
# {Cross35: Cross33 + 1/3*Yoshida18 + 2/3*Yoshida20 - 1/3*Yoshida21 + 1/3*Yoshida22 + Yoshida24 - Yoshida25 - 1/3*Yoshida26 - 1/3*Yoshida27 + Yoshida28 - 2/3*Yoshida30 - 2/3*Yoshida5}
# {Cross36: Cross37 + 2*Yoshida17 + 4/3*Yoshida18 - Yoshida19 - 1/3*Yoshida20 - 1/3*Yoshida21 - 2/3*Yoshida22 + 2/3*Yoshida26 + 2/3*Yoshida27 - Yoshida28 - Yoshida29 + 4/3*Yoshida30 - Yoshida31 - 2/3*Yoshida5}
# {Cross37: Cross37}
# {Cross38: Cross37 + 2*Yoshida17 + 2/3*Yoshida18 - Yoshida19 - 2/3*Yoshida20 - 2/3*Yoshida21 - 4/3*Yoshida22 + 4/3*Yoshida26 + 1/3*Yoshida27 - Yoshida28 - Yoshida29 + 2/3*Yoshida30 + 2/3*Yoshida5}
# {Cross39: Cross41 + Yoshida17 + 2/3*Yoshida18 - 2/3*Yoshida20 + 1/3*Yoshida21 - 1/3*Yoshida22 + 1/3*Yoshida26 + 1/3*Yoshida27 - Yoshida28 + 2/3*Yoshida30 - Yoshida31 - 1/3*Yoshida5}
# {Cross40: Cross41 + 2*Yoshida17 + 1/3*Yoshida18 - Yoshida19 - 4/3*Yoshida20 + 2/3*Yoshida21 - 5/3*Yoshida22 + Yoshida23 - Yoshida24 + Yoshida25 + 2/3*Yoshida26 + 2/3*Yoshida27 - 2*Yoshida28 + 4/3*Yoshida30 - Yoshida31 + 1/3*Yoshida5}
# {Cross41: Cross41}
# {Cross42: Cross42}
# {Cross43: Cross42 - 2/3*Yoshida18 - 1/3*Yoshida20 + 2/3*Yoshida21 + 1/3*Yoshida22 - Yoshida24 + Yoshida25 - 1/3*Yoshida26 + 2/3*Yoshida27 - Yoshida28 + Yoshida29 + 1/3*Yoshida30 - Yoshida31 + 1/3*Yoshida5}
# {Cross44: Cross42 + Yoshida17 - 1/3*Yoshida18 - 2/3*Yoshida20 + 1/3*Yoshida21 - 1/3*Yoshida22 - Yoshida24 + Yoshida25 + 1/3*Yoshida26 + 4/3*Yoshida27 - Yoshida28 + 2/3*Yoshida30 - Yoshida31 - 1/3*Yoshida5}
# {Cross45: Cross45}
# {Cross46: Cross45 - Yoshida17 - 2/3*Yoshida18 + Yoshida19 + 2/3*Yoshida20 - 1/3*Yoshida21 + 1/3*Yoshida22 - Yoshida25 - 1/3*Yoshida26 - 1/3*Yoshida27 + Yoshida28 - 2/3*Yoshida30 + Yoshida31 + 1/3*Yoshida5}
# {Cross47: Cross45 - 1/3*Yoshida18 + 1/3*Yoshida20 - 2/3*Yoshida21 - 1/3*Yoshida22 - Yoshida25 + 1/3*Yoshida26 - 2/3*Yoshida27 + Yoshida28 - 1/3*Yoshida30 + Yoshida31 + 2/3*Yoshida5}
# {Cross48: Cross48}
# {Cross49: Cross48 + Yoshida17 + 1/3*Yoshida18 - Yoshida19 - 1/3*Yoshida20 + 2/3*Yoshida21 - 2/3*Yoshida22 + Yoshida23 + Yoshida25 - 1/3*Yoshida26 + 2/3*Yoshida27 - Yoshida28 + 1/3*Yoshida30 - Yoshida31 - 2/3*Yoshida5}
# {Cross50: Cross48 - 1/3*Yoshida18 + 1/3*Yoshida20 + 1/3*Yoshida21 + 2/3*Yoshida22 - 2/3*Yoshida26 + 1/3*Yoshida27 - 1/3*Yoshida30 - 1/3*Yoshida5}
# {Cross51: Cross51}
# {Cross52: Cross51 + Yoshida17 + 2/3*Yoshida18 - Yoshida19 + 1/3*Yoshida20 - 2/3*Yoshida21 - 1/3*Yoshida22 + 1/3*Yoshida26 + 1/3*Yoshida27 + 2/3*Yoshida30 - Yoshida31 - 1/3*Yoshida5}
# {Cross53: Cross51 + Yoshida17 + 1/3*Yoshida18 - Yoshida19 - 1/3*Yoshida20 - 1/3*Yoshida21 - 2/3*Yoshida22 + Yoshida25 + 2/3*Yoshida26 + 2/3*Yoshida27 - Yoshida28 + 1/3*Yoshida30 - Yoshida31 + 1/3*Yoshida5}
# {Cross54: Cross54}
# {Cross55: Cross54 - 1/3*Yoshida18 + 1/3*Yoshida20 - 2/3*Yoshida21 + 2/3*Yoshida22 - 2/3*Yoshida26 + 1/3*Yoshida27 + Yoshida28 - 1/3*Yoshida30 - 1/3*Yoshida5}
# {Cross56: Cross54 - 2/3*Yoshida18 - 1/3*Yoshida20 - 1/3*Yoshida21 + 1/3*Yoshida22 - 1/3*Yoshida26 + 2/3*Yoshida27 + 1/3*Yoshida30 + 1/3*Yoshida5}
# {Cross57: Cross57}
# {Cross58: Cross57 - Yoshida17 + 1/3*Yoshida18 + Yoshida19 + 2/3*Yoshida20 - 1/3*Yoshida21 + 1/3*Yoshida22 - Yoshida25 - 1/3*Yoshida26 - 4/3*Yoshida27 + Yoshida28 - 2/3*Yoshida30 + Yoshida31 + 1/3*Yoshida5}
# {Cross59: Cross57 + 2/3*Yoshida18 + 4/3*Yoshida20 - 2/3*Yoshida21 + 2/3*Yoshida22 - Yoshida25 - 2/3*Yoshida26 - 2/3*Yoshida27 + Yoshida28 - 1/3*Yoshida30 - 1/3*Yoshida5}
# {Cross60: Cross60}
# {Cross61: Cross60 - 1/3*Yoshida18 - 2/3*Yoshida20 + 1/3*Yoshida21 - 1/3*Yoshida22 + 1/3*Yoshida26 - 2/3*Yoshida27 + 2/3*Yoshida30 + 2/3*Yoshida5}
# {Cross62: Cross60 + 1/3*Yoshida18 - 1/3*Yoshida20 + 2/3*Yoshida21 + 1/3*Yoshida22 + Yoshida24 - 1/3*Yoshida26 - 1/3*Yoshida27 + 1/3*Yoshida30 - Yoshida31 - 2/3*Yoshida5}
# {Cross63: Cross63}
# {Cross64: Cross63 - Yoshida17 + 2/3*Yoshida18 + 4/3*Yoshida20 - 2/3*Yoshida21 + 2/3*Yoshida22 + Yoshida24 - Yoshida25 - 2/3*Yoshida26 - 2/3*Yoshida27 + 2*Yoshida28 - 4/3*Yoshida30 - 1/3*Yoshida5}
# {Cross65: Cross63 + 1/3*Yoshida18 + 2/3*Yoshida20 - 1/3*Yoshida21 - 2/3*Yoshida22 + 2/3*Yoshida26 - 1/3*Yoshida27 - 2/3*Yoshida30 + 1/3*Yoshida5}
# {Cross66: Cross66}
# {Cross67: Cross66 - Yoshida17 - 4/3*Yoshida18 + Yoshida19 - 2/3*Yoshida20 + 1/3*Yoshida21 + 2/3*Yoshida22 - Yoshida23 + 1/3*Yoshida26 + 1/3*Yoshida27 - 1/3*Yoshida30 + Yoshida31 + 2/3*Yoshida5}
# {Cross68: Cross66 - Yoshida17 - 2/3*Yoshida18 + Yoshida19 - 1/3*Yoshida20 - 1/3*Yoshida21 + 1/3*Yoshida22 - Yoshida23 + 2/3*Yoshida26 - 1/3*Yoshida27 - 2/3*Yoshida30 + Yoshida31 + 4/3*Yoshida5}
# {Cross69: Cross69}
# {Cross70: Cross69 - 1/3*Yoshida18 - 2/3*Yoshida20 + 4/3*Yoshida21 - 1/3*Yoshida22 + Yoshida25 + 1/3*Yoshida26 + 1/3*Yoshida27 - Yoshida28 + 2/3*Yoshida30 - Yoshida31 - 1/3*Yoshida5}
# {Cross71: Cross69 - Yoshida17 - 2/3*Yoshida18 + Yoshida19 - 1/3*Yoshida20 + 2/3*Yoshida21 + 1/3*Yoshida22 - 1/3*Yoshida26 - 1/3*Yoshida27 + 1/3*Yoshida30 + 1/3*Yoshida5}
# {Cross72: Cross73 - Yoshida17 + 1/3*Yoshida18 + 2/3*Yoshida20 - 1/3*Yoshida21 + 1/3*Yoshida22 - 1/3*Yoshida26 - 1/3*Yoshida27 + Yoshida28 - 2/3*Yoshida30 + 1/3*Yoshida5}
# {Cross73: Cross73}
# {Cross74: Cross73 + Yoshida17 + 2/3*Yoshida18 - Yoshida19 + 1/3*Yoshida20 + 1/3*Yoshida21 - 4/3*Yoshida22 + Yoshida23 - Yoshida24 + Yoshida25 + 1/3*Yoshida26 + 1/3*Yoshida27 - Yoshida28 + 2/3*Yoshida30 - Yoshida31 - 1/3*Yoshida5}
# {Cross75: Cross76 + Yoshida17 - 2/3*Yoshida18 - 4/3*Yoshida20 + 2/3*Yoshida21 - 2/3*Yoshida22 - Yoshida24 + Yoshida25 + 2/3*Yoshida26 + 2/3*Yoshida27 - Yoshida28 + 1/3*Yoshida30 + 1/3*Yoshida5}
# {Cross76: Cross76}
# {Cross77: Cross76 - 1/3*Yoshida18 - 2/3*Yoshida20 + 1/3*Yoshida21 - 1/3*Yoshida22 - Yoshida24 + Yoshida25 + 1/3*Yoshida26 + 1/3*Yoshida27 - Yoshida28 + Yoshida29 - 1/3*Yoshida30 + 2/3*Yoshida5}
# {Cross78: Cross78}
# {Cross79: Cross78 - Yoshida17 - 1/3*Yoshida18 + 1/3*Yoshida20 - 2/3*Yoshida21 + 2/3*Yoshida22 + Yoshida24 - Yoshida25 + 1/3*Yoshida26 - 2/3*Yoshida27 + Yoshida28 - 4/3*Yoshida30 + Yoshida31 + 2/3*Yoshida5}
# {Cross80: Cross78 - Yoshida17 - 2/3*Yoshida18 + 2/3*Yoshida20 + 2/3*Yoshida21 + 1/3*Yoshida22 - 1/3*Yoshida26 - 1/3*Yoshida27 + Yoshida29 - 2/3*Yoshida30 + 1/3*Yoshida5}
# {Cross81: Cross81}
# {Cross82: Cross81 - 2/3*Yoshida18 - 1/3*Yoshida20 + 2/3*Yoshida21 + 1/3*Yoshida22 + Yoshida25 - 1/3*Yoshida26 + 2/3*Yoshida27 - Yoshida28 + Yoshida29 + 1/3*Yoshida30 - Yoshida31 - 2/3*Yoshida5}
# {Cross83: Cross81 - 1/3*Yoshida18 + 1/3*Yoshida20 - 2/3*Yoshida21 + 2/3*Yoshida22 + 1/3*Yoshida26 + 1/3*Yoshida27 - 1/3*Yoshida30 - 1/3*Yoshida5}
# {Cross84: Cross84}
# {Cross85: Cross84 - 2*Yoshida17 - 4/3*Yoshida18 + Yoshida19 + 1/3*Yoshida20 - 2/3*Yoshida21 + 5/3*Yoshida22 - Yoshida23 + Yoshida24 - Yoshida25 + 1/3*Yoshida26 - 2/3*Yoshida27 + 2*Yoshida28 - 4/3*Yoshida30 + Yoshida31 + 2/3*Yoshida5}
# {Cross86: Cross84 - Yoshida17 - 2/3*Yoshida18 + Yoshida19 + 2/3*Yoshida20 - 1/3*Yoshida21 + 4/3*Yoshida22 - Yoshida23 + Yoshida24 - Yoshida25 - 1/3*Yoshida26 - 1/3*Yoshida27 + Yoshida28 - 2/3*Yoshida30 + 1/3*Yoshida5}
# {Cross87: Cross87}
# {Cross88: Cross87 - 1/3*Yoshida18 - 2/3*Yoshida20 + 1/3*Yoshida21 + 2/3*Yoshida22 + 1/3*Yoshida26 + 1/3*Yoshida27 - 1/3*Yoshida30 - 1/3*Yoshida5}
# {Cross89: Cross87 + Yoshida17 + 1/3*Yoshida18 - Yoshida19 - 1/3*Yoshida20 + 2/3*Yoshida21 - 2/3*Yoshida22 + Yoshida23 - Yoshida24 + Yoshida25 - 1/3*Yoshida26 + 2/3*Yoshida27 - Yoshida28 + Yoshida29 + 1/3*Yoshida30 - Yoshida31 - 2/3*Yoshida5}
# {Cross90: Cross90}
# {Cross91: Cross90 - Yoshida17 + 1/3*Yoshida18 + 2/3*Yoshida20 - 1/3*Yoshida21 + 1/3*Yoshida22 - Yoshida25 - 1/3*Yoshida26 - 1/3*Yoshida27 + Yoshida28 - 2/3*Yoshida30 + Yoshida31 + 1/3*Yoshida5}
# {Cross92: Cross90 - Yoshida17 - 1/3*Yoshida18 + 1/3*Yoshida20 - 2/3*Yoshida21 + 2/3*Yoshida22 - Yoshida25 + 1/3*Yoshida26 - 2/3*Yoshida27 + Yoshida28 - 1/3*Yoshida30 + Yoshida31 + 2/3*Yoshida5}
# {Cross93: Cross93}
# {Cross94: Cross93 - 2/3*Yoshida18 - 1/3*Yoshida20 + 2/3*Yoshida21 - 2/3*Yoshida22 + Yoshida25 + 2/3*Yoshida26 - 1/3*Yoshida27 - Yoshida28 + 1/3*Yoshida30 + 1/3*Yoshida5}
# {Cross95: Cross93 - Yoshida17 - 4/3*Yoshida18 + Yoshida19 - 2/3*Yoshida20 + 1/3*Yoshida21 + 2/3*Yoshida22 + 1/3*Yoshida26 - 2/3*Yoshida27 - 1/3*Yoshida30 + Yoshida31 + 2/3*Yoshida5}
# {Cross96: Cross97 - 1/3*Yoshida18 - 2/3*Yoshida20 + 1/3*Yoshida21 - 1/3*Yoshida22 + 1/3*Yoshida26 + 1/3*Yoshida27 - 1/3*Yoshida30 + 2/3*Yoshida5}
# {Cross97: Cross97}
# {Cross98: Cross97 - Yoshida17 - 2/3*Yoshida18 + Yoshida19 - 1/3*Yoshida20 + 2/3*Yoshida21 + 1/3*Yoshida22 - 1/3*Yoshida26 - 1/3*Yoshida27 + Yoshida29 - 2/3*Yoshida30 + 1/3*Yoshida5}
# {Cross99: Cross99}
# {Cross100: Cross99 + Yoshida17 + 1/3*Yoshida18 - Yoshida19 - 1/3*Yoshida20 + 2/3*Yoshida21 - 2/3*Yoshida22 + Yoshida23 - Yoshida24 + Yoshida25 - 1/3*Yoshida26 + 2/3*Yoshida27 - Yoshida28 + 4/3*Yoshida30 - Yoshida31 - 2/3*Yoshida5}
# {Cross101: Cross99 - Yoshida17 - 1/3*Yoshida18 + 1/3*Yoshida20 + 1/3*Yoshida21 + 2/3*Yoshida22 - 2/3*Yoshida26 + 1/3*Yoshida27 + Yoshida28 - 1/3*Yoshida30 - 1/3*Yoshida5}
# {Cross102: Cross102}
# {Cross103: Cross102 - 1/3*Yoshida18 + 1/3*Yoshida20 + 1/3*Yoshida21 + 2/3*Yoshida22 - 2/3*Yoshida26 + 1/3*Yoshida27 + 2/3*Yoshida30 - Yoshida31 - 1/3*Yoshida5}
# {Cross104: Cross102 - 2/3*Yoshida18 - 1/3*Yoshida20 + 2/3*Yoshida21 + 1/3*Yoshida22 + Yoshida25 - 1/3*Yoshida26 + 2/3*Yoshida27 + 1/3*Yoshida30 - Yoshida31 - 2/3*Yoshida5}
# {Cross105: Cross105}
# {Cross106: Cross105 - 2*Yoshida17 - 2/3*Yoshida18 + Yoshida19 + 2/3*Yoshida20 - 1/3*Yoshida21 + 4/3*Yoshida22 + Yoshida24 - Yoshida25 - 1/3*Yoshida26 - 4/3*Yoshida27 + 2*Yoshida28 - 5/3*Yoshida30 + Yoshida31 + 1/3*Yoshida5}
# {Cross107: Cross105 - 1/3*Yoshida18 + 1/3*Yoshida20 + 1/3*Yoshida21 - 1/3*Yoshida22 + 1/3*Yoshida26 - 2/3*Yoshida27 - 1/3*Yoshida30 + 2/3*Yoshida5}
# {Cross108: Cross110 + Yoshida17 + 2/3*Yoshida18 - 2/3*Yoshida20 + 1/3*Yoshida21 - 1/3*Yoshida22 + 1/3*Yoshida26 + 1/3*Yoshida27 - Yoshida28 - Yoshida29 + 2/3*Yoshida30 - 1/3*Yoshida5}
# {Cross109: Cross110 + Yoshida17 + 1/3*Yoshida18 - 1/3*Yoshida20 - 1/3*Yoshida21 - 2/3*Yoshida22 + 2/3*Yoshida26 + 2/3*Yoshida27 - Yoshida28 - Yoshida29 + 1/3*Yoshida30 + 1/3*Yoshida5}
# {Cross110: Cross110}
# {Cross111: Cross111}
# {Cross112: Cross111 - Yoshida17 - 1/3*Yoshida18 + 1/3*Yoshida20 + 1/3*Yoshida21 - 1/3*Yoshida22 + 1/3*Yoshida26 - 2/3*Yoshida27 - 1/3*Yoshida30 + Yoshida31 + 2/3*Yoshida5}
# {Cross113: Cross111 - Yoshida17 - 2/3*Yoshida18 - 1/3*Yoshida20 - 1/3*Yoshida21 + 1/3*Yoshida22 + 2/3*Yoshida26 - 1/3*Yoshida27 - 2/3*Yoshida30 + Yoshida31 + 4/3*Yoshida5}
# {Cross114: Cross114}
# {Cross115: Cross114 - Yoshida17 - 1/3*Yoshida18 + Yoshida19 + 1/3*Yoshida20 - 2/3*Yoshida21 + 2/3*Yoshida22 - Yoshida25 + 1/3*Yoshida26 - 2/3*Yoshida27 + Yoshida28 - 4/3*Yoshida30 + Yoshida31 + 2/3*Yoshida5}
# {Cross116: Cross114 + 1/3*Yoshida18 + 2/3*Yoshida20 - 1/3*Yoshida21 + 1/3*Yoshida22 - Yoshida25 - 1/3*Yoshida26 - 1/3*Yoshida27 + Yoshida28 - 2/3*Yoshida30 + 1/3*Yoshida5}
# {Cross117: Cross117}
# {Cross118: Cross117 + 2/3*Yoshida18 + 1/3*Yoshida20 - 2/3*Yoshida21 + 2/3*Yoshida22 + Yoshida24 - Yoshida25 - 2/3*Yoshida26 + 1/3*Yoshida27 + Yoshida28 - Yoshida29 - 1/3*Yoshida30 - 1/3*Yoshida5}
# {Cross119: Cross117 + Yoshida17 + 1/3*Yoshida18 - 1/3*Yoshida20 - 1/3*Yoshida21 + 1/3*Yoshida22 - 1/3*Yoshida26 + 2/3*Yoshida27 - Yoshida29 + 1/3*Yoshida30 - 2/3*Yoshida5}
# {Cross120: Cross120}
# {Cross121: Cross120 + 1/3*Yoshida18 - 1/3*Yoshida20 + 2/3*Yoshida21 + 1/3*Yoshida22 - 1/3*Yoshida26 + 2/3*Yoshida27 + 1/3*Yoshida30 - Yoshida31 - 2/3*Yoshida5}
# {Cross122: Cross120 - 1/3*Yoshida18 - 2/3*Yoshida20 + 4/3*Yoshida21 - 1/3*Yoshida22 + Yoshida23 - Yoshida24 + Yoshida25 - 2/3*Yoshida26 + 1/3*Yoshida27 - Yoshida28 + Yoshida29 + 2/3*Yoshida30 - Yoshida31 - 1/3*Yoshida5}
# {Cross123: Cross123}
# {Cross124: Cross123 - Yoshida17 - 1/3*Yoshida18 + 1/3*Yoshida20 + 1/3*Yoshida21 + 2/3*Yoshida22 + Yoshida25 - 2/3*Yoshida26 + 1/3*Yoshida27 + Yoshida29 - 1/3*Yoshida30 - Yoshida31 - 1/3*Yoshida5}
# {Cross125: Cross123 + 1/3*Yoshida18 + 2/3*Yoshida20 - 1/3*Yoshida21 + 1/3*Yoshida22 - 1/3*Yoshida26 + 2/3*Yoshida27 + 1/3*Yoshida30 - Yoshida31 - 2/3*Yoshida5}
# {Cross126: Cross126}
# {Cross127: Cross126 - 2*Yoshida17 - 2/3*Yoshida18 + Yoshida19 + 2/3*Yoshida20 - 1/3*Yoshida21 + 4/3*Yoshida22 - Yoshida23 + Yoshida24 - Yoshida25 - 1/3*Yoshida26 - 4/3*Yoshida27 + 2*Yoshida28 - 2/3*Yoshida30 + Yoshida31 + 1/3*Yoshida5}
# {Cross128: Cross126 - Yoshida17 - 1/3*Yoshida18 + Yoshida19 + 1/3*Yoshida20 + 1/3*Yoshida21 + 5/3*Yoshida22 - Yoshida23 + Yoshida24 - Yoshida25 - 2/3*Yoshida26 - 2/3*Yoshida27 + Yoshida28 - 1/3*Yoshida30 - 1/3*Yoshida5}
# {Cross129: Cross129}
# {Cross130: Cross129 + 1/3*Yoshida18 + 2/3*Yoshida20 - 1/3*Yoshida21 + 1/3*Yoshida22 - 1/3*Yoshida26 - 1/3*Yoshida27 - 2/3*Yoshida30 + 1/3*Yoshida5}
# {Cross131: Cross129 + 2/3*Yoshida18 + 1/3*Yoshida20 + 1/3*Yoshida21 - 1/3*Yoshida22 + Yoshida23 - 2/3*Yoshida26 - 2/3*Yoshida27 - 1/3*Yoshida30 - 1/3*Yoshida5}
# {Cross132: Cross132}
# {Cross133: Cross132 + Yoshida17 + 1/3*Yoshida18 - Yoshida19 - 1/3*Yoshida20 + 5/3*Yoshida21 - 5/3*Yoshida22 + Yoshida23 - Yoshida24 + 2*Yoshida25 - 1/3*Yoshida26 + 2/3*Yoshida27 - 2*Yoshida28 + Yoshida29 + 4/3*Yoshida30 - 2*Yoshida31 - 2/3*Yoshida5}
# {Cross134: Cross132 + 2/3*Yoshida18 + 1/3*Yoshida20 + 1/3*Yoshida21 - 1/3*Yoshida22 - 2/3*Yoshida26 + 1/3*Yoshida27 + 2/3*Yoshida30 - Yoshida31 - 1/3*Yoshida5}

# We load the data of the tropical dictionary:
tropical_dict_cross_ratios = load('Input/tropical_dict_cross_ratiosv2.sobj')


#########################################################################################
# Computation of valuations for rational function in Cross and Yoshidas per Naruki cone #
#########################################################################################

# The following function takes an expression in Yoshidas and Cross functions,  a cone name, the dictionary of true cross valuations and the tropical dictionary of cross ratios, and computes the true valuation of the expressions:

def trueValuationsForYCExpressionsOnCone(coneName, test, tropical_dict_cross_ratios, dict_true_cross_vals):
    testYC = expand(SR(test).substitute(tropical_dict_cross_ratios))
    dict0Cross = {cross: 0  for cross in cross_variables}
    dict0Yosh = {yoshida: 0 for yoshida in Yoshidas}
    testY = SR(testYC).substitute(dict0Cross)
    testC = SR(testYC).substitute(dict0Yosh)
    testCMon = YCRing(testC).monomials()
    testCCoeff = YCRing(testC).coefficients()
    allMonTrue = [dict_true_cross_vals[coneName][SR(x)] for x in testCMon]
    if None in allMonTrue:
       newtestYC = None
    else:       
       truetestC = sum([SR(testCCoeff[k]*dict_true_cross_vals[coneName][SR(testCMon[k])]) for k in range(0,len(testCMon))])
       newtestYC = truetestC + testY
    return newtestYC


# The following function takes a linear expression in Cross and Yoshida functions and a cone name and replaces all the Cross functions with known valuations. The Crosses that remain will have None values:

def substituteCrossesWithKnownValuationsFromYoshidaExpressionsOnCone(coneName, test, tropical_dict_cross_ratios, dict_true_cross_vals):
    testYC = expand(SR(test).substitute(tropical_dict_cross_ratios))
    dict0Cross = {cross: 0  for cross in cross_variables}
    dict0Yosh = {yoshida: 0 for yoshida in Yoshidas}
    testY = SR(testYC).substitute(dict0Cross)
    testC = SR(testYC).substitute(dict0Yosh)
    testCMon = YCRing(testC).monomials()
    testCCoeff = YCRing(testC).coefficients()
    allMonTrue = [(testCCoeff[k],SR(testCMon[k]), dict_true_cross_vals[coneName][SR(testCMon[k])]) for k in range(0,len(testCMon))]
    allMonNoNone = [(x[0], x[2]) for x in allMonTrue if x[2] !=None]
    allMonNone = [(x[0], x[1]) for x in allMonTrue if x[2] ==None]
    nonePart = sum([x[0]*x[1] for x in allMonNone])
    noNonePart = sum([x[0]*x[1] for x in allMonNoNone]) + testY
    return nonePart + noNonePart

# # E.g.
# test   = Cross37 - Yoshida4
# substituteCrossesWithKnownValuationsFromYoshidaExpressionsOnCone('aa2a3b', test, tropical_dict_cross_ratios, dict_true_cross_vals)
# -Yoshida4 + Yoshida9
# substituteCrossesWithKnownValuationsFromYoshidaExpressionsOnCone('aa2a3a4', test, tropical_dict_cross_ratios, dict_true_cross_vals)
# Cross37 -Yoshida4


# The following function computes the value of a given linear expressions in Yoshidas for a fixed cone. We can use it to double check our symbolic expressions against the numerical values.

# toCheck = polynomial expressions in Yoshidas
# coneName = name of a cone in the Naruki fan.
def computeExpressionsInYoshidasAtCoM(coneName, toCheck):
    cone = load('../../ComputeLines/Scripts/Input/' + str(coneName)+'Cell.sobj')
    interior_point = sum([vector(r) for r in cone.rays()])
    valuesYP = {SR(Yoshidas[m]): interior_point[m] for m in range(0,len(Yoshidas))}
    return SR(toCheck).substitute(valuesYP)



# We compare the expected valuation for Cross36 on 'aa2a3a4' coming from dict_exp_cross_vals with the value obtained from the tropical_dict_cross_ratios and the expected valuation for the Cross37. We confirm that the difference is always non-negative. Furthermore, it is strictly positive on each face of 'aa2a3a4' containing a4 among its spanning rays:

# test = Cross36
# checkExpC36 = substituteCrossesWithKnownValuationsFromYoshidaExpressionsOnCone('aa2a3a4', test, tropical_dict_cross_ratios, dict_exp_cross_vals) - dict_exp_cross_vals['aa2a3a4'][test]
# coneList = NarukiFaces['aa2a3a4']
# newConeList = replaceConesWithFaces(coneList, NarukiFaces)
# print all({faceName:  bool(0<= SR(computeExpressionsInYoshidasAtCoM(faceName, checkExpC36))) for faceName in newConeList}.values())
# True
# bool(0< SR(computeExpressionsInYoshidasAtCoM('aa2a3a4', checkExpC36)))
# True
# print {faceName:  bool(0< SR(computeExpressionsInYoshidasAtCoM(faceName, checkExpC36))) for faceName in newConeList}
# {'a': False, 'aa2a3': False, 'a3a4': True, 'a2a4': True, 'aa2a4': True, 'a2a3': False, 'aa3a4': True, 'aa4': True, 'a3': False, 'a2': False, 'aa2a3a4': True, 'a4': True, 'aa3': False, 'aa2': False, 'a2a3a4': True}




########################################
# STEP 5: Tropicalization of all Nodes as linear functions in 45 relevant Cross and 40 Yoshida valuations #
########################################

# We load the dictionary of 135 Nodes in Yoshida and Cross functions computed above:

all135NodesInYC = load('../../Yoshida/Scripts/Input/all135NodesInYC.sobj')

pairs = all135NodesInYC.keys()


# # We compute the tropical nodes as a dictionary:

# TropYCNodes = dict()
# for pair in pairs:
#     print pair
#     TropYCNodes[pair] = dict()
#     for key in keys:
#     	# print key
#     	TropYCNodes[pair][key] = SR(yoshida_and_cross_to_trop_yoshida_and_cross(all135NodesInYC[pair][key]))

# We use the information of the valuation of ratios of Cross function to simplify the expressions of the tropical nodes:

# TropYCNodesv2 = dict()
# for pair in pairs:
#     print pair
#     TropYCNodesv2[pair] = dict()
#     for key in keys:
#     	# print key
#     	# TropYCNodes[pair][key] = yoshida_and_cross_to_trop_yoshida_and_cross(all135NodesInYC[pair][key])
#     	TropYCNodesv2[pair][key] = SR(TropYCNodes[pair][key]).substitute(tropical_dict_cross_ratios)
#     save(TropYCNodesv2, 'Input/all135TropicalNodesYCv2.sobj')	

# We load the precomputed dictionary:
TropYCNodesv2=load('../../TropicalConvexHulls/Scripts/Input/all135TropicalNodesYCv2.sobj')