############################################################################################################################
# Calculation of the Weyl group transformation from lines coming from planar configurations to the lines from convex hulls #
############################################################################################################################

# The following script allows to compute the Weyl group element sending the labelling for the 27 lines on each maximal cone obtained via a convex hull computation to the labelling obtained from the planar configurations. The existence of such element will certify that the convex hull computations were correct.

# The computation is done for each cone separately, and only records a list of sets for the cherries and only one side of the trees whenever the other side is completely determined by the involution. In some cases we'll need all the leaves.

# We first start by collecting all the Weyl group elements that give the list of lines giving the 2 and 3 types for each cone. After these are fixed, we then collect among them the ones that give the correct computation for the two types with the least number of elements: (II) for (aa2a3a4) and (III) for (aa2a3b).



###########################################################################
# 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)]

EFG = Es+Fs+Gs

# 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))
S = PolynomialRing(QQ, Xs+Ys)
Sxy = S

keys = [Sxy(x) for x in sorted(Sxy.gens(), reverse=True)]

T = PolynomialRing(QQ, ds+Es+Fs+Gs)
  
YRing = PolynomialRing(QQ, Yoshidas)
YField = FractionField(YRing)




# We write down the simple roots of E6
alpha1 = SR(d2-d1)
alpha2 = SR(d1+d2+d3)
alpha3 = SR(d3-d2)
alpha4 = SR(d4-d3)
alpha5 = SR(d5-d4)
alpha6 = SR(d6-d5)

alphas = [alpha1,alpha2, alpha3, alpha4, alpha5, alpha6]

roots = load("../../Yoshida/Scripts/Input/rootsE6.sobj")
positive_roots = load("../../General/posRootsE6.sobj")


##################################
# Functions for actions of W(E6) #
##################################

allTuplesWE6Representatives = load('../../Yoshida/Scripts/Input/allTuplesRepresentatives.sobj')

allAction = load("../../Yoshida/Scripts/Input/Symbolic_action_on_everything.sobj")


# In order to act by other elements with W(E6), we must be able to compose. The following functions allows us to compose pairs dictionaries (the are copied from the file 'involutionAndWE6.sage'):

def compose(dict1, dict2):
    answer = {}
    for k in dict1.keys():
        answer[k] = k.substitute(dict1).substitute(dict2)
    return answer

# The next function allows for inductive composition of multiple elements. We will use it to compose multiple dictionaries.
# By convention:
# Composition of [d1, d2, ..., dn] is dn o d(n-1) o ... o d2 o d1

def composeAll(allAction,l):
    answer = {}
    for d in l:
        answer = compose(allAction[d], answer)
    return answer



# We take a set of numbers and a dictionary with those numbers among their keys and output the set of values

def substituteVertices(setLeaves,dictLeaves):
    return set([dictLeaves[x] for x in setLeaves])

# The following takes a dictionary (dictTree) of dictionaries with keys given by pairs and values given by a dictionary of leaf labels with keys = range(0,10) and outputs a dictionary of dictionaries whose keys are tree labels and values are dictionaries with one key: the tree in the original orbit its coming from and the values are the list of non-trivial quartets determining the tree.

def computeLabelingOrbits(dictTrees, topType):
    quartetsOrbits = dict()
    for key in dictTrees.keys():
    	# print key
    	neweq = dict()
    	for leaves in dictTrees[key].keys():
    	    leaf0 = leaves[0]
	    leaf1 = leaves[1]
	    dictLeaves = dictTrees[key][leaves]
	    newTree = [(substituteVertices(x[0],dictLeaves),substituteVertices(x[1],dictLeaves)) for x in topType]
	    neweq[leaf1] = {leaf0: newTree}
	quartetsOrbits[key] = neweq    
    return quartetsOrbits


###################
# 1) CONE aa2a3a4 #
###################

#############################################
# Data from configurations and convex hulls #
#############################################

# We start with the data we have from our computations:

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

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

# Our keys are tuples of 27 elements (the order is the one given in EFG). So we first need to convert the sets above into sets of numbers.

confConeaa2a3a4Numbers = [set([EFG.index(x) for x in confConeaa2a3a4Tuples[0]]), set([EFG.index(x) for x in confConeaa2a3a4Tuples[1]])]

# print confConeaa2a3a4Numbers
# [set([0, 1, 2, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 17, 18, 19, 20, 21, 22, 24, 25, 26]), set([16, 23])]

convHConeaa2a3a4Numbers = [set([EFG.index(x) for x in convHConeaa2a3a4Tuples[0]]), set([EFG.index(x) for x in convHConeaa2a3a4Tuples[1]])]

# print convHConeaa2a3a4Numbers
# convHConeaa2a3a4Numbers = [set([EFG.index(x) for x in convHConeaa2a3a4Tuples[0]]), set([EFG.index(x) for x in convHConeaa2a3a4Tuples[1]])]

threeMissingTrees = [E4,E5,E6]
threeMissingTreesNumbers = set([EFG.index(x) for x in threeMissingTrees])
# print threeMissingTreesNumbers
# set([3, 4, 5])

##############################
# Orbit computation of types #
##############################

# We start by computing the orbits of list of sets for the convexHull Tuples.

orbitConvHaa2a3a4 = dict()
# for y in allTuplesWE6.keys()}:
for y in allTuplesRepresentatives:
    print y[0]
    orbitConvHaa2a3a4[y[0]] = [ set([y[0][x] for x in convHConeaa2a3a4Numbers[i]]) for i in range(0,len(convHConeaa2a3a4Numbers))]


# We check that the configuration sets of numbers lie in the values of the dictionary with the exception of the three missing trees:

# len([y for y in orbitConvHaa2a3a4.values() if confConeaa2a3a4Numbers[0].issubset(y[0]) if  confConeaa2a3a4Numbers[1].issubset(y[1])])
# 1152


# We find all the candidates of Weyl elements giving the tuples obtained from the configurations:

candidatesConeaa2a3a4 = [key for key in orbitConvHaa2a3a4.keys() if confConeaa2a3a4Numbers[0].issubset(orbitConvHaa2a3a4[key][0]) if confConeaa2a3a4Numbers[1].issubset(orbitConvHaa2a3a4[key][1])]


print len(candidatesConeaa2a3a4)
1152

finalCandidatesaa2a3a4 = candidatesConeaa2a3a4


#########################
# Labelling for aa2a3a4 #
#########################

# We compute the orbits for each of the tree labellings

orbitConvHE6aa2a3a4 = dict()
# for y in allTuplesWE6.keys()}:
for y in candidatesConeaa2a3a4:
    print y
    orbitConvHE6aa2a3a4[y] = [ set([y[x] for x in  ConvHE6aa2a3a4Numbers[i]]) for i in range(0,len(ConvHE6aa2a3a4Numbers))]

orbitConvHF36aa2a3a4 = dict()
# for y in allTuplesWE6.keys()}:
for y in candidatesConeaa2a3a4:
    print y
    orbitConvHF36aa2a3a4[y] = [ set([y[x] for x in  ConvHF36aa2a3a4Numbers[i]]) for i in range(0,len(ConvHF36aa2a3a4Numbers))]


orbitConvHG3aa2a3a4 = dict()
# for y in allTuplesWE6.keys()}:
for y in candidatesConeaa2a3a4:
    print y
    orbitConvHG3aa2a3a4[y] = [ set([y[x] for x in  ConvHG3aa2a3a4Numbers[i]]) for i in range(0,len(ConvHG3aa2a3a4Numbers))]






########################################
# Data from Configuration computations #
########################################

aa2a3a4ConfI = dict()
aa2a3a4ConfII = dict()

##########
# Type I #
##########

aa2a3a4ConfI[F12] = [(set([G1,F45]), set([E1,F34,F46, F35, E2, F36, G2, F56])),(set([E1,F34]), set([G1,F45,F46, F35, E2, F36, G2, F56])),(set([G1,F45,E1,F34]), set([F46, F35, E2, F36, G2, F56])),(set([G1,F45,E1,F34,F46]), set([F35, E2, F36, G2, F56])),(set([F35, E2, F36, G2, F56]),set([G1,F45,E1,F34,F46])),(set([ E2, F36, G2, F56]),set([F35,G1,F45,E1,F34,F46])),(set([ E2, F36]),set([G2, F56,F35,G1,F45,E1,F34,F46])),(set([G2, F56]),set([E2, F36,F35,G1,F45,E1,F34,F46]))]

aa2a3a4ConfI[F13] =  [(set([G1,F45]), set([F24,F46, E1,G3,F25, F56, E3, F26])), (set([F24,F46]), set([G1,F45,E1,G3,F25, F56, E3, F26])), (set([G1,F45,F24,F46]), set([E1,G3,F25, F56, E3, F26])),  (set([G1,F45,F24,F46,E1]), set([G3,F25, F56, E3, F26])), (set([G3,F25, F56, E3, F26]),set([G1,F45,F24,F46,E1])), ( set([F25, F56, E3, F26]),set([G1,F45,F24,F46,E1,G3])), ( set([F25, F56]),set([E3, F26,G1,F45,F24,F46,E1,G3])), ( set([E3, F26]),set([F25, F56,G1,F45,F24,F46,E1,G3]))]

aa2a3a4ConfI[F23] = [(set([E3,F14]), set([F15, F45, E2, G3, F16, F46, G2, F56])),(set([F15, F45]), set([E3,F14, E2, G3, F16, F46, G2, F56])), (set([E3,F14,F15, F45]), set([ E2, G3, F16, F46, G2, F56])), (set([E3,F14,F15, F45,E2]), set([  G3, F16, F46, G2, F56])), (set([  G3, F16, F46, G2, F56]), set([E3,F14,F15, F45,E2])), (set([ F16, F46, G2, F56]), set([ G3,  E3,F14,F15, F45,E2])), (set([ G2, F56]), set([ F16, F46, G3,  E3,F14,F15, F45,E2])), (set([ F16, F46]), set([G2, F56,  G3,  E3,F14,F15, F45,E2]))]

aa2a3a4ConfI[G1] = [(set([F13, E4]),set([F12, F16, E5, F15, E3, F14, E6, E2])),(set([F12, F16]),set([F13, E4, E5, F15, E3, F14, E6, E2])),(set([F13, E4,F12, F16]),set([ E5, F15, E3, F14, E6, E2])),(set([F13, E4,F12, F16, E5]),set([ F15, E3, F14, E6, E2])),(set([ F15, E3, F14, E6, E2]), set([F13, E4,F12, F16, E5])),(set([ E3, F14, E6, E2]), set([F15, F13, E4,F12, F16, E5])),(set([ E6, E2]), set([E3, F14, F15, F13, E4,F12, F16, E5])),(set([ E3, F14]), set([E6, E2, F15, F13, E4,F12, F16, E5]))]

aa2a3a4ConfI[G2] =[(set([E3,F26]), set([E1,E4,E5,F25,F23,E6,F24,F12])),(set([E1,E4]), set([E3,F26,E5,F25,F23,E6,F24,F12])),(set([E1,E4,E3,F26]), set([E5,F25,F23,E6,F24,F12])),(set([E1,E4,E3,F26,E5]), set([F25,F23,E6,F24,F12])),(set([F25,F23,E6,F24,F12]),set([E1,E4,E3,F26,E5])),(set([F23,E6,F24,F12]),set([F25,E1,E4,E3,F26,E5])),(set([F24,F12]),set([F23,E6,F25,E1,E4,E3,F26,E5])),(set([F23,E6]),set([F24,F12,F25,E1,E4,E3,F26,E5]))]

aa2a3a4ConfI[G4] = [(set([E1, F34]), set([F46, F24, E5, F45, E2, E6, E3, F14])), (set([F46, F24]), set([E1, F34, E5, F45, E2, E6, E3, F14])), (set([E1, F34,F46, F24]), set([E5, F45, E2, E6, E3, F14])), (set([E1, F34,F46, F24, E5]), set([F45, E2, E6, E3, F14])), (set([F45, E2, E6, E3, F14]), set([E1, F34,F46, F24, E5])), (set([E2, E6, E3, F14]), set([E1, F34,F46, F24, E5, F45])), (set([E2, E6]), set([E3, F14,E1, F34,F46, F24, E5, F45])), (set([E3, F14]), set([E2, E6,E1, F34,F46, F24, E5, F45]))]

aa2a3a4ConfI[G5] = [(set([E1, E4]), set([F56, F25, F35, E3, F15, F45, E2, E6])),(set([F56, F25]), set([E1, E4,F35, E3, F15, F45, E2, E6])), (set([E1, E4,F56, F25]), set([F35, E3, F15, F45, E2, E6])), (set([F35,E1, E4,F56, F25]), set([E3, F15, F45, E2, E6])), (set([E3, F15, F45, E2, E6]),set([F35,E1, E4,F56, F25])), (set([F15, F45, E2, E6]),set([F35,E1, E4,F56, F25, E3])), (set([ E2, E6]),set([F15, F45,F35,E1, E4,F56, F25, E3])), (set([F15, F45]),set([ E2, E6,F35,E1, E4,F56, F25, E3]))]

aa2a3a4ConfI[G6] = [(set([E1, E4]), set([F26, E3, E5, F56, F16, F46, E2, F36])),(set([F26, E3]), set([E1, E4, E5, F56, F16, F46, E2, F36])),(set([E1, E4,F26, E3]), set([E5, F56, F16, F46, E2, F36])),(set([E5, E1, E4,F26, E3]), set([F56, F16, F46, E2, F36])),(set([F56, F16, F46, E2, F36]),set([E5, E1, E4,F26, E3])), (set([F16, F46, E2, F36]),set([E5, E1, E4,F26, E3, F56])), (set([ E2, F36]),set([F16, F46,E5, E1, E4,F26, E3, F56])), (set([F16, F46]),set([E2, F36,E5, E1, E4,F26, E3, F56]))]

aa2a3a4ConfI[F45] = [(set([F12,F16]), set([F13,E4,E5,G4,F36,F23,F26,G5])), (set([F13,E4]), set([F12,F16,E5,G4,F36,F23,F26,G5])), (set([F12,F16,F13,E4]), set([E5,G4,F36,F23,F26,G5])), (set([E5,F12,F16,F13,E4]), set([G4,F36,F23,F26,G5])), (set([G4,F36,F23,F26,G5]),set([E5,F12,F16,F13,E4])), (set([F36,F23,F26,G5]),set([G4,E5,F12,F16,F13,E4])), (set([F26,G5]),set([F36,F23,G4,E5,F12,F16,F13,E4])), (set([F36,F23]),set([F26,G5,G4,E5,F12,F16,F13,E4]))]

aa2a3a4ConfI[F46] = [(set([F13,E4]), set([G4,F15,F12,F35,F25,G6,E6,F23])), (set([G4,F15]), set([F13,E4,F12,F35,F25,G6,E6,F23])), (set([G4,F15,F13,E4]), set([F12,F35,F25,G6,E6,F23])), (set([F12,G4,F15,F13,E4]), set([F35,F25,G6,E6,F23])), (set([F35,F25,G6,E6,F23]),set([F12,G4,F15,F13,E4])), (set([F25,G6,E6,F23]),set([F35,F12,G4,F15,F13,E4])), (set([E6,F23]),set([F25,G6,F35,F12,G4,F15,F13,E4])), (set([F25,G6]),set([E6,F23,F35,F12,G4,F15,F13,E4]))]

aa2a3a4ConfI[F56] = [(set([G5,F14]), set([F13,F34,E5,G6,E6,F23,F24,F12])), (set([F13,F34]), set([G5,F14,E5,G6,E6,F23,F24,F12])), (set([G5,F14,F13,F34]), set([E5,G6,E6,F23,F24,F12])), (set([E5,G5,F14,F13,F34]), set([G6,E6,F23,F24,F12])), (set([G6,E6,F23,F24,F12]), set([E5,G5,F14,F13,F34])), (set([E6,F23,F24,F12]),set([G6,E5,G5,F14,F13,F34])), (set([F24,F12]),set([E6,F23,G6,E5,G5,F14,F13,F34])), (set([E6,F23]),set([F24,F12,G6,E5,G5,F14,F13,F34]))]

aa2a3a4ConfI[F14] = [(set([F25,F56]), set([E4,E1,F35,F26,F36,F23,G1,G4])), (set([E4,E1]), set([F25,F56,F35,F26,F36,F23,G1,G4])), (set([E4,E1,F25,F56]), set([F35,F26,F36,F23,G1,G4])), (set([F35,E4,E1,F25,F56]), set([F26,F36,F23,G1,G4])), (set([F26,F36,F23,G1,G4]), set([F35,E4,E1,F25,F56])), (set([F36,F23,G1,G4]), set([F26,F35,E4,E1,F25,F56])), (set([G1,G4]), set([F36,F23,F26,F35,E4,E1,F25,F56])), (set([F36,F23]), set([G1,G4,F26,F35,E4,E1,F25,F56]))]

aa2a3a4ConfI[F24] = [(set([G4,F15]), set([F13,E4,F35,F16,E2,F36,F56,G2])), (set([F13,E4,G4,F15]), set([F35,F16,E2,F36,F56,G2])), (set([F16,F13,E4,G4,F15]), set([F35,E2,F36,F56,G2])), (set([F35,E2,F36,F56,G2]), set([F16,F13,E4,G4,F15])), (set([E2,F36,F56,G2]), set([F16,F35,F13,E4,G4,F15])), (set([E2,F36]), set([F56,G2,F16,F35,F13,E4,G4,F15])), (set([F56,G2]), set([E2,F36,F16,F35,F13,E4,G4,F15]))]

aa2a3a4ConfI[F34] = [(set([E3,F26]), set([F25,F56,G3,E4,G4,F15,F16,F12])), (set([F25,F56,E3,F26]), set([G3,E4,G4,F15,F16,F12])), (set([G3,F25,F56,E3,F26]), set([E4,G4,F15,F16,F12])), (set([E4,G4,F15,F16,F12]), set([G3,F25,F56,E3,F26])), (set([G4,F15,F16,F12]), set([E4,G3,F25,F56,E3,F26])), (set([F16,F12]), set([G4,F15,E4,G3,F25,F56,E3,F26])), (set([G4,F15]), set([F16,F12,E4,G3,F25,F56,E3,F26]))]

aa2a3a4ConfI[F15] = [(set([E1,F34]), set([F46,F24,E5,G1,F26,G5,F23,F36])), (set([F46,F24]), set([E1,F34,E5,G1,F26,G5,F23,F36])), (set([E1,F34,F46,F24]), set([E5,G1,F26,G5,F23,F36])), (set([E5,E1,F34,F46,F24]), set([G1,F26,G5,F23,F36])), (set([G1,F26,G5,F23,F36]), set([E5,E1,F34,F46,F24])), (set([F26,G5,F23,F36]), set([G1,E5,E1,F34,F46,F24])), (set([F23,F36]), set([F26,G5,G1,E5,E1,F34,F46,F24])), (set([F26,G5]), set([F23,F36,G1,E5,E1,F34,F46,F24]))] 

aa2a3a4ConfI[F25] = [(set([F13,F34]), set([G5,F14,E5,G2,F46,F16,E2,F36])), (set([G5,F14,F13,F34]), set([E5,G2,F46,F16,E2,F36])), (set([E5,G5,F14,F13,F34]), set([G2,F46,F16,E2,F36])), (set([G2,F46,F16,E2,F36]), set([E5,G5,F14,F13,F34])), (set([F46,F16,E2,F36]), set([G2,E5,G5,F14,F13,F34])), (set([E2,F36]), set([F46,F16,G2,E5,G5,F14,F13,F34])), (set([F46,F16]), set([E2,F36,G2,E5,G5,F14,F13,F34]))]

aa2a3a4ConfI[F16] = [(set([G1,F45]), set([F34,E1,F24,F35,E6,F23,F25,G6])), (set([F34,E1,G1,F45]), set([F24,F35,E6,F23,F25,G6])), (set([F24,F34,E1,G1,F45]), set([F35,E6,F23,F25,G6])), (set([F35,E6,F23,F25,G6]), set([F24,F34,E1,G1,F45])), (set([E6,F23,F25,G6]), set([F35,F24,F34,E1,G1,F45])), (set([F25,G6]), set([E6,F23,F35,F24,F34,E1,G1,F45])), (set([E6,F23]), set([F25,G6,F35,F24,F34,E1,G1,F45]))]

aa2a3a4ConfI[F26] = [(set([F13,F34]), set([G2,G6,F35,F14,F45,F15,E6,E2])), (set([G2,G6,F13,F34]), set([F35,F14,F45,F15,E6,E2])), (set([F35,G2,G6,F13,F34]), set([F14,F45,F15,E6,E2])), (set([F14,F45,F15,E6,E2]), set([F35,G2,G6,F13,F34])), (set([F45,F15,E6,E2]), set([F14,F35,G2,G6,F13,F34])), (set([E6,E2]), set([F45,F15,F14,F35,G2,G6,F13,F34])), (set([F45,F15]), set([E6,E2,F14,F35,G2,G6,F13,F34]))]

aa2a3a4ConfI[F36] = [(set([E3,F14]), set([F45,F15,E6,G3,G6,F25,F12,F24])), (set([F45,F15]), set([E3,F14,E6,G3,G6,F25,F12,F24])), (set([E3,F14,F45,F15]), set([E6,G3,G6,F25,F12,F24])), (set([E6,E3,F14,F45,F15]), set([G3,G6,F25,F12,F24])), (set([G3,G6,F25,F12,F24]), set([E6,E3,F14,F45,F15])), (set([G6,F25,F12,F24]), set([G3,E6,E3,F14,F45,F15])), (set([G6,F25]), set([F12,F24,G3,E6,E3,F14,F45,F15])), (set([F12,F24]), set([G6,F25,G3,E6,E3,F14,F45,F15]))]

aa2a3a4ConfI[E1] = [(set([F12,F16]), set([G4,F15,F13,G3,G2,G6,F14,G5])), (set([G4,F15]), set([F12,F16,F13,G3,G2,G6,F14,G5])), (set([F12,F16,G4,F15]), set([F13,G3,G2,G6,F14,G5])), (set([F13,F12,F16,G4,F15]), set([G3,G2,G6,F14,G5])), (set([G3,G2,G6,F14,G5]), set([F13,F12,F16,G4,F15])), (set([G2,G6,F14,G5]), set([G3,F13,F12,F16,G4,F15])), (set([F14,G5]), set([G2,G6,G3,F13,F12,F16,G4,F15])), (set([G2,G6]), set([F14,G5,G3,F13,F12,F16,G4,F15]))]

aa2a3a4ConfI[E2] = [(set([F24, F12]), set([F25,G6,G3,F23,G5,F26,G1,G4])), (set([F25,G6,F24, F12]), set([G3,F23,G5,F26,G1,G4])), (set([G3,F25,G6,F24, F12]), set([F23,G5,F26,G1,G4])), (set([F23,G5,F26,G1,G4]), set([G3,F25,G6,F24, F12])), (set([G5,F26,G1,G4]), set([F23,G3,F25,G6,F24, F12])), (set([G1,G4]), set([G5,F26,F23,G3,F25,G6,F24, F12])), (set([G5,F26]), set([G1,G4,F23,G3,F25,G6,F24, F12]))]

aa2a3a4ConfI[E3] = [(set([F13,F34]), set([G6,G2,F35,G5,G1,G4,F36,F23])), (set([G6,G2,F13,F34]), set([F35,G5,G1,G4,F36,F23])), (set([F35,G6,G2,F13,F34]), set([G5,G1,G4,F36,F23])), (set([G5,G1,G4,F36,F23]), set([F35,G6,G2,F13,F34])), (set([G1,G4,F36,F23]), set([G5,F35,G6,G2,F13,F34])), (set([G1,G4]), set([F36,F23, G5,F35,G6,G2,F13,F34])), (set([F36,F23]), set([G1,G4,G5,F35,G6,G2,F13,F34]))]


###########
# Type II #
###########

aa2a3a4ConfII[G3] = [(set([E1,E4]), set([F13,F34,E5,F35,F36,E2,E6,F23])), (set([F13,F34]), set([E1,E4,E5,F35,F36,E2,E6,F23])), (set([F13,F34,E1,E4]), set([E5,F35,F36,E2,E6,F23])), (set([F36,E2,E6,F23]), set([E5,F35,F13,F34,E1,E4])), (set([F36,E2]), set([E6,F23,E5,F35,F13,F34,E1,E4])), (set([E6,F23]), set([F36,E2,E5,F35,F13,F34,E1,E4]))]

aa2a3a4ConfII[F35] = [(set([E3,F26]), set([G5,F14,E5,G3,F12,F24,F46,F16])), (set([G5,F14]), set([E3,F26,E5,G3,F12,F24,F46,F16])), (set([G5,F14,E3,F26]), set([E5,G3,F12,F24,F46,F16])), (set([F12,F24,F46,F16]), set([E5,G3,G5,F14,E3,F26])), (set([F46,F16]), set([F12,F24,E5,G3,G5,F14,E3,F26])), (set([F12,F24]), set([F46,F16,E5,G3,G5,F14,E3,F26]))]






#######################################
# Topological types from Convex Hulls #
#######################################

# We can use the output of the convex hull computations (recorded in '../Output/NonLeavesAndDistancesForConesAndExtremals.sobj') to construct the list of leaves with the symmetry classes and topological embeddings. In this way, we can apply the maps and see if we can find the W(E6)-element. We can also do this by hand, by simply looking at the dictionary {line: dictionary of leaves} obtained from the sage object file.

# We use the labeling of the vertices given in the table:
allTrees = dict()
allTrees[E1] = {0: F12, 4: G3, 3: G4, 2: G5, 1: G6, 5: F13, 9: G2, 6: F14, 7: F15, 8: F16}
allTrees[E2] = {1: F12, 4: G3, 3: G4, 2: G5, 0: G6, 8: G1, 5: F23, 6: F24, 7: F25, 9: F26}
allTrees[E3] = {7: G2, 3: F13, 1: G4, 0: G5, 4: G6, 6: G1, 2: F23, 8: F34, 9: F35, 5: F36}
allTrees[E4] = {7: G2, 5: G3, 3: F14, 1: G5, 8: G6, 6: G1, 2: F24, 4: F34, 9: F45, 0: F46}
allTrees[E5] =  {6: G2, 5: G3, 1: G4, 3: F15, 8: G6, 7: G1, 2: F25, 4: F35, 9: F45, 0: F56}
allTrees[E6] =  {6: G2, 7: G3, 9: G4, 1: G5, 4: F16, 5: G1, 3: F26, 2: F36, 0: F46, 8: F56}
allTrees[F12] =  {3: E1, 2: E2, 7: G1, 6: G2, 9: F34, 8: F35, 5: F36, 4: F45, 1: F46, 0: F56}
allTrees[F13] =  {4: E1, 1: G1, 5: G3, 3: F24, 2: F25, 0: F26, 8: E3, 9: F45, 7: F46, 6: F56}
allTrees[F14] =  {6: E1, 9: G1, 7: F23, 3: G4, 5: F25, 8: F26, 1: F35, 4: F36, 0: E4, 2: F56}
allTrees[F15] =  {6: E1, 9: G1, 7: F23, 5: F24, 3: G5, 8: F26, 1: F34, 4: F36, 2: F46, 0: E5}
allTrees[F16] =  {6: E1, 5: G1, 7: F23, 9: F24, 8: F25, 3: G6, 1: F34, 0: F35, 2: F45, 4: E6}
allTrees[F23] = {8: G2, 4: G3, 7: F14, 6: F15, 9: F16, 5: E2, 1: E3, 0: F45, 3: F46, 2: F56}
allTrees[F24] = {9: G2, 7: F13, 3: G4, 5: F15, 8: F16, 6: E2, 1: F35, 4: F36, 0: E4, 2: F56}
allTrees[F25] = {9: G2, 7: F13, 5: F14, 3: G5, 8: F16, 6: E2, 1: F34, 4: F36, 2: F46, 0: E5}
allTrees[F26] =  {5: G2, 7: F13, 9: F14, 8: F15, 3: G6, 6: E2, 1: F34, 0: F35, 2: F45, 4: E6}
allTrees[F34] = {9: F12, 5: G3, 1: G4, 3: F15, 7: F16, 2: F25, 6: F26, 8: E3, 4: E4, 0: F56}
allTrees[F35] = {9: F12, 5: G3, 3: F14, 1: G5, 7: F16, 2: F24, 6: F26, 8: E3, 0: F46, 4: E5}
allTrees[F36] = {6: F12, 7: G3, 9: F14, 1: F15, 4: G6, 8: F24, 0: F25, 5: E3, 3: F45, 2: E6}
allTrees[F45] = {5: F12, 7: F13, 9: G4, 8: G5, 3: F16, 6: F23, 2: F26, 4: F36, 1: E4, 0: E5}
allTrees[F46] = {9: F12, 7: F13, 5: G4, 3: F15, 8: G6, 6: F23, 2: F25, 1: F35, 0: E4, 4: E6}
allTrees[F56] =  {8: F12, 7: F13, 3: F14, 5: G5, 9: G6, 6: F23, 2: F24, 1: F34, 0: E5, 4: E6}
allTrees[G1] = {3: F12, 7: F13, 8: F14, 9: F15, 5: F16, 6: E2, 2: E3, 1: E4, 0: E5, 4: E6}
allTrees[G2] = {6: E1, 3: F12, 7: F23, 8: F24, 9: F25, 5: F26, 2: E3, 1: E4, 0: E5, 4: E6}
allTrees[G3] = {8: E1, 9: E2, 1: F13, 0: F23, 5: F34, 6: F35, 7: F36, 4: E4, 3: E5, 2: E6}
allTrees[G4] =  {6: E1, 7: E2, 8: E3, 3: F14, 2: F24, 1: F34, 9: F45, 5: F46, 0: E5, 4: E6}
allTrees[G5] = {6: E1, 7: E2, 8: E3, 1: E4, 3: F15, 2: F25, 0: F35, 9: F45, 5: F56, 4: E6}
allTrees[G6] =  {6: E1, 7: E2, 5: E3, 1: E4, 0: E5, 3: F16, 2: F26, 4: F36, 8: F46, 9: F56}



##########################
# Topological structures #
##########################

# We list all the non-trivial quartets. Each lists consists of tuple of sets (A,B) with |A|<=|B| (if = holds, we put (A,B) and (B,A)). We use this to compute the labeling of trees obtained by the automorphisms.

typeIaa2a3a4Top = [(set([0,1]), set([2,3,4,5,6,7,8,9])), (set([2,3]), set([0,1,4,5,6,7,8,9])), (set([0,1,2,3]),  set([4,5,6,7,8,9])), (set([0,1,2,3,4]),  set([5,6,7,8,9])), (set([5,6,7,8,9]), set([0,1,2,3,4])), (set([6,7,8,9]), set([0,1,2,3,4,5])), (set([6,7]), set([0,1,2,3,4,5,8,9])), (set([8,9]), set([0,1,2,3,4,5,6,7]))]

typeIIaa2a3a4Top = [(set([0,1]), set([2,3,4,5,6,7,8,9])), (set([8,9]), set([0,1,2,3,4,5,6,7])), (set([3,4]), set([0,1,2,5,6,7,8,9])), (set([5,6]), set([0,1,2,3,4,7,8,9])),(set([0,1,8,9]),  set([2,3,4,5,6,7])), (set([3,4,5,6]),set([0,1,2,7,8,9]))]



###################
# Orbits of trees #
###################
# We translate the above information on the trees coming from the convex hull computations into numbers so that we can apply the W(E_6)-action:

allTreesNumbers = dict()
for key in allTrees.keys():
    # print key
    neweq = dict()    
    for l in range(0,10):
    	# print l
    	neweq[l] = EFG.index(allTrees[key][l])
    allTreesNumbers[EFG.index(key)] = neweq


# We compute the orbits for the chosen maximal cell in the Naruki fan:
allTreesOrbitaa2a3a4Numbers = dict()
for p in finalCandidatesaa2a3a4:
    neweq = dict()
    for key in allTreesNumbers.keys():
    	neweq[p[key]] = {l:p[allTreesNumbers[key][l]] for l in range(0,10)}
    allTreesOrbitaa2a3a4Numbers[p] = neweq


	
# Next, we translate back to the labelings coming from the lines
allTreesOrbitaa2a3a4 = dict()
for p in finalCandidatesaa2a3a4:
    neweq = dict()
    for key in allTreesOrbitaa2a3a4Numbers[p].keys():
    	neweq[EFG[key]] = {l:EFG[allTreesOrbitaa2a3a4Numbers[p][key][l]] for l in range(0,10)}
    allTreesOrbitaa2a3a4[p] = neweq




###################
# Orbits by types #
###################

# We record the set of numbers for each type from our convex hull computations:

typeIaa2a3a4 = convHConeaa2a3a4Numbers[0]
typeIIaa2a3a4 = convHConeaa2a3a4Numbers[1]



# We compute the orbits for the given maximal cell in the Naruki fan:

allTreesOrbitTypeIaa2a3a4Numbers = dict()
for p in finalCandidatesaa2a3a4:
    neweq = dict()
    for key in typeIaa2a3a4:
    	neweq[(key,p[key])] = {l:p[allTreesNumbers[key][l]] for l in range(0,10)}
    allTreesOrbitTypeIaa2a3a4Numbers[p] = neweq

allTreesOrbitTypeIIaa2a3a4Numbers = dict()
for p in finalCandidatesaa2a3a4:
    neweq = dict()
    for key in typeIIaa2a3a4:
    	neweq[(key,p[key])] = {l:p[allTreesNumbers[key][l]] for l in range(0,10)}
    allTreesOrbitTypeIIaa2a3a4Numbers[p] = neweq


# Next, we translate back to the labelings coming from the lines
allTreesOrbitTypeIaa2a3a4 = dict()
for p in finalCandidatesaa2a3a4:
    neweq = dict()
    for key in allTreesOrbitTypeIaa2a3a4Numbers[p].keys():
    	neweq[(EFG[key[0]], EFG[key[1]])] = {l:EFG[allTreesOrbitTypeIaa2a3a4Numbers[p][key][l]] for l in range(0,10)}
    allTreesOrbitTypeIaa2a3a4[p] = neweq

allTreesOrbitTypeIIaa2a3a4 = dict()
for p in finalCandidatesaa2a3a4:
    neweq = dict()
    for key in allTreesOrbitTypeIIaa2a3a4Numbers[p].keys():
    	neweq[(EFG[key[0]], EFG[key[1]])] = {l:EFG[allTreesOrbitTypeIIaa2a3a4Numbers[p][key][l]] for l in range(0,10)}
    allTreesOrbitTypeIIaa2a3a4[p] = neweq


# We check that all the keys agree with the lines coming from our configuration

# all([set([y[1] for y in x.keys()]) == set([EFG[j] for j in confConeaa2a3a4Numbers[0]]) for x in allTreesOrbitTypeIaa2a3a4.values()])
# True

# all([set([y[1] for y in x.keys()]) == set([EFG[j] for j in confConeaa2a3a4Numbers[1]]) for x in allTreesOrbitTypeIIaa2a3a4.values()])
# True


# We write dictionaries with easier keys in range(0,64) for each of the dictionaries above:

testIaa2a3a4 = dict()
for k in range(0,len(finalCandidatesaa2a3a4)):
    # testIaa2a3a4[k] = {line: allTreesOrbitTypeIaa2a3a4[finalCandidatesaa2a3a4[k]][line] for line in confConeaa2a3a4Tuples[0]}
    testIaa2a3a4[k] = allTreesOrbitTypeIaa2a3a4[finalCandidatesaa2a3a4[k]]

testIIaa2a3a4 = dict()
for k in range(0,len(finalCandidatesaa2a3a4)):
    # testIIaa2a3a4[k] = {line: allTreesOrbitTypeIIaa2a3a4[finalCandidatesaa2a3a4[k]][line] for line in confConeaa2a3a4Tuples[1]}
    testIIaa2a3a4[k] = allTreesOrbitTypeIIaa2a3a4[finalCandidatesaa2a3a4[k]]




########################
# Labelling for Orbits #
########################


dictOrb = allTreesOrbitTypeIaa2a3a4
topType = typeIaa2a3a4Top
orbitQuartetsIaa2a3a4 = computeLabelingOrbits(dictOrb, topType)

keysMapsaa2a3a4 = orbitQuartetsIaa2a3a4.keys()
print len(keysMapsaa2a3a4)
1152

dictOrb = allTreesOrbitTypeIIaa2a3a4
topType = typeIIaa2a3a4Top
orbitQuartetsIIaa2a3a4 = computeLabelingOrbits(dictOrb, topType)

print len(orbitQuartetsIIaa2a3a4.keys())
1152

##########
# Type I #
##########

l = F12
test = [key for key in keysMapsaa2a3a4 if True == all([x in orbitQuartetsIaa2a3a4[key][l].values()[0] for x in aa2a3a4ConfI[l]])]
len(test) 
192

l = F13
test1 = [key for key in keysMapsaa2a3a4 if True == all([x in orbitQuartetsIaa2a3a4[key][l].values()[0] for x in aa2a3a4ConfI[l]])]
len(test1) 
192

test == test1
False

test = [x for x in test1 if x in test]
len(test)
128

l = F23
test1 = [key for key in keysMapsaa2a3a4 if True == all([x in orbitQuartetsIaa2a3a4[key][l].values()[0] for x in aa2a3a4ConfI[l]])]
len(test1) 
192

test = [x for x in test1 if x in test]
len(test)
80

l = G1
test1 = [key for key in keysMapsaa2a3a4 if True == all([x in orbitQuartetsIaa2a3a4[key][l].values()[0] for x in aa2a3a4ConfI[l]])]
len(test1) 
192

test = [x for x in test1 if x in test]
len(test)
32

l = G2
test1 = [key for key in keysMapsaa2a3a4 if True == all([x in orbitQuartetsIaa2a3a4[key][l].values()[0] for x in aa2a3a4ConfI[l]])]
len(test1) 
192

test = [x for x in test1 if x in test]
len(test)
16


l = G4
test1 = [key for key in keysMapsaa2a3a4 if True == all([x in orbitQuartetsIaa2a3a4[key][l].values()[0] for x in aa2a3a4ConfI[l]])]
len(test1) 
192

test = [x for x in test1 if x in test]
len(test)
16


l = G5
test1 = [key for key in keysMapsaa2a3a4 if True == all([x in orbitQuartetsIaa2a3a4[key][l].values()[0] for x in aa2a3a4ConfI[l]])]
len(test1)
192

test = [x for x in test1 if x in test]
len(test)
16



l = G6
test1 = [key for key in keysMapsaa2a3a4 if True == all([x in orbitQuartetsIaa2a3a4[key][l].values()[0] for x in aa2a3a4ConfI[l]])]
len(test1)
192

test = [x for x in test1 if x in test]
len(test)
16




l = F45
test1 = [key for key in keysMapsaa2a3a4 if True == all([x in orbitQuartetsIaa2a3a4[key][l].values()[0] for x in aa2a3a4ConfI[l]])]
len(test1)
192
test = [x for x in test1 if x in test]
len(test)
16


l = F46
test1 = [key for key in keysMapsaa2a3a4 if True == all([x in orbitQuartetsIaa2a3a4[key][l].values()[0] for x in aa2a3a4ConfI[l]])]
len(test1)
192
test = [x for x in test1 if x in test]
len(test)
16


l = F56
test1 = [key for key in keysMapsaa2a3a4 if True == all([x in orbitQuartetsIaa2a3a4[key][l].values()[0] for x in aa2a3a4ConfI[l]])]
len(test1)
192
test = [x for x in test1 if x in test]
len(test)
16



l = F14
test1 = [key for key in keysMapsaa2a3a4 if True == all([x in orbitQuartetsIaa2a3a4[key][l].values()[0] for x in aa2a3a4ConfI[l]])]
len(test1)
192

test = [x for x in test1 if x in test]
len(test)
16



l = F24
test1 = [key for key in keysMapsaa2a3a4 if True == all([x in orbitQuartetsIaa2a3a4[key][l].values()[0] for x in aa2a3a4ConfI[l]])]
len(test1)
192

test = [x for x in test1 if x in test]
len(test)
16



l = F34
test1 = [key for key in keysMapsaa2a3a4 if True == all([x in orbitQuartetsIaa2a3a4[key][l].values()[0] for x in aa2a3a4ConfI[l]])]
len(test1)
192

test = [x for x in test1 if x in test]
len(test)
16



l = F15
test1 = [key for key in keysMapsaa2a3a4 if True == all([x in orbitQuartetsIaa2a3a4[key][l].values()[0] for x in aa2a3a4ConfI[l]])]
len(test1)
192

test = [x for x in test1 if x in test]
len(test)
16



l = F25
test1 = [key for key in keysMapsaa2a3a4 if True == all([x in orbitQuartetsIaa2a3a4[key][l].values()[0] for x in aa2a3a4ConfI[l]])]
len(test1)
192

test = [x for x in test1 if x in test]
len(test)
16




l = F16
test1 = [key for key in keysMapsaa2a3a4 if True == all([x in orbitQuartetsIaa2a3a4[key][l].values()[0] for x in aa2a3a4ConfI[l]])]
len(test1)
192

test = [x for x in test1 if x in test]
len(test)
16



l = F26
test1 = [key for key in keysMapsaa2a3a4 if True == all([x in orbitQuartetsIaa2a3a4[key][l].values()[0] for x in aa2a3a4ConfI[l]])]
len(test1)
192

test = [x for x in test1 if x in test]
len(test)
16

l = F36
test1 = [key for key in keysMapsaa2a3a4 if True == all([x in orbitQuartetsIaa2a3a4[key][l].values()[0] for x in aa2a3a4ConfI[l]])]
len(test1)
192

test = [x for x in test1 if x in test]
len(test)
16



l = E1
test1 = [key for key in keysMapsaa2a3a4 if True == all([x in orbitQuartetsIaa2a3a4[key][l].values()[0] for x in aa2a3a4ConfI[l]])]
len(test1)
192

test = [x for x in test1 if x in test]
len(test)
16


l = E2
test1 = [key for key in keysMapsaa2a3a4 if True == all([x in orbitQuartetsIaa2a3a4[key][l].values()[0] for x in aa2a3a4ConfI[l]])]
len(test1)
192

test = [x for x in test1 if x in test]
len(test)
16


l = E3
test1 = [key for key in keysMapsaa2a3a4 if True == all([x in orbitQuartetsIaa2a3a4[key][l].values()[0] for x in aa2a3a4ConfI[l]])]
len(test1)
192

test = [x for x in test1 if x in test]
len(test)
16


# Conclusion: we are left with 16 candidates.
aa2a3a4IMaps = test 
print len(aa2a3a4IMaps)
16


###########
# Type II #
###########

l = G3
test1 = [key for key in aa2a3a4IMaps if True == all([x in orbitQuartetsIIaa2a3a4[key][l].values()[0] for x in aa2a3a4ConfII[l]])]
len(test1) 
16

test1 == aa2a3a4IMaps
True

l = F35
test1 = [key for key in aa2a3a4IMaps if True == all([x in orbitQuartetsIIaa2a3a4[key][l].values()[0] for x in aa2a3a4ConfII[l]])]
len(test1) 
16

test1 == aa2a3a4IMaps
True

# Conclusion: we are left with 16 candidates.
aa2a3a4Maps = aa2a3a4IMaps 

# Missing lines to check: E4, E5, E6

# # We record the maps
# print aa2a3a4Maps 
# [(21, 18, 15, 22, 26, 16, 7, 9, 5, 1, 8, 24, 11, 17, 25, 13, 20, 23, 0, 12, 19, 14, 2, 4, 10, 6, 3), (18, 21, 0, 13, 20, 16, 3, 24, 17, 11, 14, 9, 1, 5, 2, 22, 26, 23, 15, 19, 12, 8, 25, 4, 6, 10, 7), (9, 24, 7, 22, 26, 16, 15, 21, 11, 17, 25, 18, 5, 1, 8, 13, 20, 23, 3, 6, 10, 2, 14, 4, 19, 12, 0), (9, 24, 7, 26, 22, 16, 15, 21, 17, 11, 25, 18, 1, 5, 8, 20, 13, 23, 3, 10, 6, 2, 14, 4, 12, 19, 0), (9, 24, 3, 13, 20, 16, 0, 21, 17, 11, 14, 18, 1, 5, 2, 22, 26, 23, 7, 10, 6, 8, 25, 4, 12, 19, 15), (24, 9, 7, 26, 22, 16, 15, 18, 1, 5, 8, 21, 17, 11, 25, 20, 13, 23, 3, 10, 6, 14, 2, 4, 12, 19, 0), (18, 21, 0, 20, 13, 16, 3, 24, 11, 17, 14, 9, 5, 1, 2, 26, 22, 23, 15, 12, 19, 8, 25, 4, 10, 6, 7), (21, 18, 15, 26, 22, 16, 7, 9, 1, 5, 8, 24, 17, 11, 25, 20, 13, 23, 0, 19, 12, 14, 2, 4, 6, 10, 3), (21, 18, 0, 20, 13, 16, 3, 9, 5, 1, 2, 24, 11, 17, 14, 26, 22, 23, 15, 12, 19, 25, 8, 4, 10, 6, 7), (18, 21, 15, 22, 26, 16, 7, 24, 11, 17, 25, 9, 5, 1, 8, 13, 20, 23, 0, 12, 19, 2, 14, 4, 10, 6, 3), (24, 9, 7, 22, 26, 16, 15, 18, 5, 1, 8, 21, 11, 17, 25, 13, 20, 23, 3, 6, 10, 14, 2, 4, 19, 12, 0), (9, 24, 3, 20, 13, 16, 0, 21, 11, 17, 14, 18, 5, 1, 2, 26, 22, 23, 7, 6, 10, 8, 25, 4, 19, 12, 15), (24, 9, 3, 20, 13, 16, 0, 18, 5, 1, 2, 21, 11, 17, 14, 26, 22, 23, 7, 6, 10, 25, 8, 4, 19, 12, 15), (18, 21, 15, 26, 22, 16, 7, 24, 17, 11, 25, 9, 1, 5, 8, 20, 13, 23, 0, 19, 12, 2, 14, 4, 6, 10, 3), (24, 9, 3, 13, 20, 16, 0, 18, 1, 5, 2, 21, 17, 11, 14, 22, 26, 23, 7, 10, 6, 25, 8, 4, 12, 19, 15), (21, 18, 0, 13, 20, 16, 3, 9, 1, 5, 2, 24, 17, 11, 14, 22, 26, 23, 15, 19, 12, 25, 8, 4, 6, 10, 7)]

# We record the elements of the Weyl group giving these generators:

aa2a3a4MapsAsWE6 = {x: [y[1] for y in allTuplesRepresentatives if y[0] == x][0] for x in aa2a3a4Maps}

# # We record the output. Each value yields an element of WE6 by composing the corresponding W(E6) generators from left to right.

# print aa2a3a4MapsAsWE6
# {(24, 9, 3, 13, 20, 16, 0, 18, 1, 5, 2, 21, 17, 11, 14, 22, 26, 23, 7, 10, 6, 25, 8, 4, 12, 19, 15): (5, 1, 2, 3, 1, 4, 5, 3, 2, 6, 3, 4, 3, 2, 6, 1, 3, 2, 6, 4, 3, 1, 5), (24, 9, 7, 22, 26, 16, 15, 18, 5, 1, 8, 21, 11, 17, 25, 13, 20, 23, 3, 6, 10, 14, 2, 4, 19, 12, 0): (5, 4, 3, 6, 2, 1, 4, 3, 4, 6, 5, 2, 3, 6, 4, 1, 2, 3, 5, 4, 5, 2, 1, 3, 6, 2, 4, 3, 6), (24, 9, 3, 20, 13, 16, 0, 18, 5, 1, 2, 21, 11, 17, 14, 26, 22, 23, 7, 6, 10, 25, 8, 4, 19, 12, 15): (5, 1, 2, 3, 1, 4, 2, 1, 6, 3, 4, 2, 5, 6, 1, 4, 3, 6, 2, 1, 3, 6), (21, 18, 0, 20, 13, 16, 3, 9, 5, 1, 2, 24, 11, 17, 14, 26, 22, 23, 15, 12, 19, 25, 8, 4, 10, 6, 7): (5, 1, 2, 3, 1, 4, 2, 1, 3, 6, 3, 1, 5, 6, 4, 5, 2, 3, 6), (18, 21, 0, 20, 13, 16, 3, 24, 11, 17, 14, 9, 5, 1, 2, 26, 22, 23, 15, 12, 19, 8, 25, 4, 10, 6, 7): (5, 2, 4, 3, 6, 4, 1, 3, 2, 5, 1, 6, 3, 4, 3, 6, 5, 1), (9, 24, 3, 20, 13, 16, 0, 21, 11, 17, 14, 18, 5, 1, 2, 26, 22, 23, 7, 6, 10, 8, 25, 4, 19, 12, 15): (5, 2, 4, 3, 6, 4, 1, 3, 2, 5, 1, 6, 3, 4, 3, 6, 2, 5, 3, 2, 1), (18, 21, 15, 22, 26, 16, 7, 24, 11, 17, 25, 9, 5, 1, 8, 13, 20, 23, 0, 12, 19, 2, 14, 4, 10, 6, 3): (3, 6, 3, 4, 2, 5, 4, 6, 3, 4, 5, 6, 2, 4, 3, 1, 2, 1, 4, 5, 1, 3, 4, 6, 5), (21, 18, 0, 13, 20, 16, 3, 9, 1, 5, 2, 24, 17, 11, 14, 22, 26, 23, 15, 19, 12, 25, 8, 4, 6, 10, 7): (5, 1, 2, 3, 1, 4, 2, 1, 5, 4, 3, 6, 3, 4, 1, 2, 3, 6, 4, 3, 5, 2), (9, 24, 7, 22, 26, 16, 15, 21, 11, 17, 25, 18, 5, 1, 8, 13, 20, 23, 3, 6, 10, 2, 14, 4, 19, 12, 0): (5, 4, 3, 6, 2, 1, 4, 3, 4, 6, 5, 2, 3, 6, 4, 2, 1, 3, 4, 2, 3, 1, 6, 4, 5, 3), (9, 24, 3, 13, 20, 16, 0, 21, 17, 11, 14, 18, 1, 5, 2, 22, 26, 23, 7, 10, 6, 8, 25, 4, 12, 19, 15): (3, 4, 2, 3, 6, 4, 5, 3, 2, 3, 4, 1, 6, 3, 2, 3, 1, 4, 6, 5, 3, 2, 6, 1), (24, 9, 7, 26, 22, 16, 15, 18, 1, 5, 8, 21, 17, 11, 25, 20, 13, 23, 3, 10, 6, 14, 2, 4, 12, 19, 0): (5, 2, 4, 3, 2, 6, 1, 3, 2, 1, 5, 4, 3, 6, 4, 3, 5, 2, 4, 3, 6, 1, 5, 2, 4, 3, 5, 1), (21, 18, 15, 22, 26, 16, 7, 9, 5, 1, 8, 24, 11, 17, 25, 13, 20, 23, 0, 12, 19, 14, 2, 4, 10, 6, 3): (1, 6, 3, 5, 4, 3, 6, 2, 5, 3, 4, 5, 1, 2, 6, 3, 2, 4, 3, 5, 6, 2), (18, 21, 0, 13, 20, 16, 3, 24, 17, 11, 14, 9, 1, 5, 2, 22, 26, 23, 15, 19, 12, 8, 25, 4, 6, 10, 7): (5, 2, 4, 5, 1, 3, 4, 3, 6, 5, 3, 2, 4, 3, 6, 4, 5), (18, 21, 15, 26, 22, 16, 7, 24, 17, 11, 25, 9, 1, 5, 8, 20, 13, 23, 0, 19, 12, 2, 14, 4, 6, 10, 3): (5, 2, 4, 3, 6, 1, 3, 4, 5, 2, 4, 3, 2, 1, 6, 2, 3, 4, 3, 5, 6, 3, 4, 1), (21, 18, 15, 26, 22, 16, 7, 9, 1, 5, 8, 24, 17, 11, 25, 20, 13, 23, 0, 19, 12, 14, 2, 4, 6, 10, 3): (1, 6, 3, 5, 4, 3, 6, 2, 5, 3, 6, 4, 1, 3, 2, 6, 3, 5, 4, 1, 3, 6, 5, 1, 2), (9, 24, 7, 26, 22, 16, 15, 21, 17, 11, 25, 18, 1, 5, 8, 20, 13, 23, 3, 10, 6, 2, 14, 4, 12, 19, 0): (5, 4, 3, 6, 2, 1, 4, 3, 4, 6, 5, 2, 3, 6, 4, 2, 1, 3, 4, 2, 3, 1, 6, 2, 3, 4, 2, 5, 3)}

################################################
# Finding the candidates for the missing trees #
################################################

# Next, we take the 16 valid maps and determine the possible outputs for each of the three undertermined trees E4, E5, E6. In particular, we determine in which Type they land. In all cases, we have E4 and E6 are of type I, whereas E5 is of type II.


findTypesForMissingTrees = dict()
for key in aa2a3a4Maps:
    findTypesForMissingTrees[key] = dict()
    for j in set(threeMissingTrees):
    	if j in orbitQuartetsIaa2a3a4[key].keys():
	   findTypesForMissingTrees[key][j] = str('I')
	else:   
             	   findTypesForMissingTrees[key][j] = str('II')

test = findTypesForMissingTrees.values()[0]
all([x == test for x in findTypesForMissingTrees.values()])
True
print test
{E6: 'I', E5: 'II', E4: 'I'}


missingLines = dict()
for key in aa2a3a4Maps:
    missingLines[key] = {j: orbitQuartetsIaa2a3a4[key][j] for j in set([E4,E6])}
    missingLines[key][E5] = orbitQuartetsIIaa2a3a4[key][E5]


# We record the lines acted on for each valid W(E6) element:
# print [missingLines.values()[k][E4].keys() for k in range(0,len(missingLines.values()))]
# [[E3], [F45], [E3], [F12], [F12], [E3], [G6], [F12], [F45], [E3], [F45], [G6], [F12], [G6], [G6], [F45]]


# print [missingLines.values()[k][E5].keys() for k in range(0,len(missingLines.values()))]
# [[G3], [G3], [G3], [G3], [G3], [G3], [G3], [G3], [G3], [G3], [G3], [G3], [G3], [G3], [G3], [G3]]


# print [missingLines.values()[k][E6].keys() for k in range(0,len(missingLines.values()))]
# [[F15], [F14], [F14], [F14], [F24], [F24], [F24], [F15], [F24], [F25], [F15], [F14], [F25], [F25], [F15], [F25]]

#################
# Missing trees #
#################

# Next, we check that we always get the same labeling for each of E4, E5, and E6.

# We check that the values are all the same for E4:
allE4 = [missingLines[key][E4].values()[0] for key in missingLines.keys()]
x = allE4[0]
all([all([y in allE4[k] for y in allE4[0]]) for k in range(0,len(allE4))])
True


# We check that the values are all the same for E5:
allE5 = [missingLines[key][E5].values()[0] for key in missingLines.keys()]
x = allE5[0]
all([all([y in allE5[k] for y in allE5[0]]) for k in range(0,len(allE5))])
True


# We check that the values are all the same for E6:
allE6 = [missingLines[key][E6].values()[0] for key in missingLines.keys()]
x = allE6[0]
all([all([y in allE6[k] for y in allE6[0]]) for k in range(0,len(allE6))])
True


# We record the quartets of the 3 missing trees:

#####################
# Type I: E4 and E6 #
#####################

# allE4[0]
# [({F24, F46}, {F45, G1, G3, F34, G2, G6, G5, F14}),
#  ({G1, F45}, {G3, F24, F34, G2, F46, G6, G5, F14}),
#  ({G1, F24, F46, F45}, {G3, F34, G2, G6, G5, F14}),
#  ({G1, F24, F46, F45, F34}, {G2, G6, G5, F14, G3}),
#  ({G2, G6, G5, F14, G3}, {G1, F24, F46, F45, F34}),
#  ({G2, G6, G5, F14}, {F45, G1, G3, F24, F34, F46}),
#  ({G5, F14}, {F45, G1, G3, F24, F34, G2, F46, G6}),
#  ({G2, G6}, {F45, G1, G3, F24, F34, F46, G5, F14})]

# allE6[0]
# [({G2, F56}, {F26, F36, G1, F16, G4, G3, F46, G5}),
#  ({F46, F16}, {F26, F36, G1, F56, G4, G3, G2, G5}),
#  ({G2, F56, F46, F16}, {F26, F36, G1, G4, G3, G5}),
#  ({G2, F56, F46, F16, G3}, {F26, G1, G5, G4, F36}),
#  ({F26, G1, G5, G4, F36}, {G2, F56, F46, F16, G3}),
#  ({F26, G1, G5, G4}, {F36, F56, F16, G3, G2, F46}),
#  ({G1, G4}, {F26, F36, F56, F16, G3, G2, F46, G5}),
#  ({F26, G5}, {F36, G1, F56, F16, G4, G3, G2, F46})]

aa2a3a4ConfI[E4] = allE4[0]
aa2a3a4ConfI[E6] = allE6[0]

###############
# Type II: E5 #
###############

# allE5[0]
# [({G1, F45}, {F56, F15, G4, G3, F25, F35, G2, G6}),
#  ({F15, G4}, {F45, G1, F56, G3, F25, F35, G2, G6}),
#  ({F25, F56}, {F45, G1, F15, G4, G3, F35, G2, G6}),
#  ({G2, G6}, {F45, G1, F56, F15, G4, G3, F25, F35}),
#  ({G1, F45, F15, G4}, {F56, G3, F25, F35, G2, G6}),
#  ({G2, F25, F56, G6}, {F45, G1, F15, G4, G3, F35})]



aa2a3a4ConfII[E5] = allE5[0]

aa2a3a4Conf = (aa2a3a4ConfI ,aa2a3a4ConfII)

# We record the tuple of splits for each tree, classified by types:
# save(aa2a3a4Conf, "../../TropicalConvexHulls/Output/aa2a3a4LinesFromPlanarConfiguration.sobj")




# # We record these splittings as a plain text file:
# f =file('../../TropicalConvexHulls/Output/aa2a3a4LinesFromPlanarConfiguration.txt','w')
# f.write('Type I Trees for (aa2a3a4):' + '\n'+'\n')
# for k in aa2a3a4ConfI.keys():
#     f.write('Line ' + str(k) + ': ' +'\n')
#     f.write(str(aa2a3a4ConfI[k]))
#     f.write('\n')

# f.write('\n')
# f.write('Type II Trees for (aa2a3a4):' + '\n' + '\n')
# for k in aa2a3a4ConfII.keys():
#     f.write('Line ' + str(k) + ': ' +'\n')
#     f.write(str(aa2a3a4ConfII[k]))
#     f.write('\n')

# f.close()



allTuplesaa2a3a4WE6 = {y: composeAll(allAction,list(aa2a3a4MapsAsWE6[y])) for y in aa2a3a4MapsAsWE6.keys()}

allValuesaa2a3a4WE6 ={y: dict({k: alphas[k].substitute(allTuplesaa2a3a4WE6[y]) for k in range(0,len(alphas))}) for y in allTuplesaa2a3a4WE6.keys() }

# allValuesaa2a3a4WE6.values()[0]
# {0: d2 - d4,
#  1: -d1 + d5,
#  2: d4 - d6,
#  3: d1 + d3 + d6,
#  4: -d1 - d2 - d3 - d4 - d5 - d6,
#  5: d2 + d4 + d6}

test = allValuesaa2a3a4WE6.values()[0]

aa2a3a4MapOnPosRoots = {j: [k for k in range(0,len(roots)) if SR(test[j]) == SR(roots[k])] for j in range(0,6)}

aa2a3a4MapOnNegRoots = {j: [k for k in range(0,len(roots)) if SR(test[j]) == SR(-1*roots[k])] for j in range(0,6)}

aa2a3a4MapOnPosRoots
{0: [], 1: [19], 2: [], 3: [23], 4: [], 5: [30]}
aa2a3a4MapOnNegRoots
{0: [6], 1: [], 2: [8], 3: [], 4: [35], 5: []}

# The following records one of the 16 Weyl group elements used for the cone (aa2a3a4)
[-1*positive_roots[6], positive_roots[19], -1*positive_roots[8], positive_roots[23], -1*positive_roots[35], positive_roots[30]]
# [-alpha[3] - alpha[4],
#  alpha[1] + alpha[3] + alpha[4] + alpha[5],
#  -alpha[5] - alpha[6],
#  alpha[2] + alpha[3] + alpha[4] + alpha[5] + alpha[6],
#  -alpha[1] - 2*alpha[2] - 2*alpha[3] - 3*alpha[4] - 2*alpha[5] - alpha[6],
#  alpha[1] + alpha[2] + alpha[3] + 2*alpha[4] + alpha[5] + alpha[6]]


# The following records the three trees needed from the Table to give the labelling of the missing trees E4 and E5, E6.
k0 = [key for key in  allTuplesaa2a3a4WE6.keys() if allValuesaa2a3a4WE6[key] == allValuesaa2a3a4WE6.values()[0]][0]
# print [missingLines[k0][E4].keys()[0], missingLines[k0][E5].keys()[0], missingLines[k0][E6].keys()[0]]
# [E3, G3, F15]


###################
# 2) CONE aa2a3ab #
###################

#############################################
# Data from configurations and convex hulls #
#############################################

# We start with the data we have from our computations:

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

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

# Our keys are tuples of 27 elements (the order is the one given in EFG). So we first need to convert the sets above into sets of numbers.

confConeaa2a3bNumbers = [set([EFG.index(x) for x in confConeaa2a3bTuples[0]]), set([EFG.index(x) for x in confConeaa2a3bTuples[1]]), set([EFG.index(x) for x in confConeaa2a3bTuples[2]])]

# print confConeaa2a3bNumbers
# [set([1, 2, 8, 9, 11, 14, 17, 18, 21, 24, 25]), set([0, 6, 7, 10, 12, 13, 15, 19, 20, 22, 26]), set([16, 23])]

convHConeaa2a3bNumbers = [set([EFG.index(x) for x in convHConeaa2a3bTuples[0]]), set([EFG.index(x) for x in convHConeaa2a3bTuples[1]]), set([EFG.index(x) for x in convHConeaa2a3bTuples[2]])]

# print convHConeaa2a3bNumbers
# [set([2, 3, 4, 6, 10, 14, 15, 16, 18, 21, 22, 26]), set([0, 1, 7, 8, 9, 11, 12, 13, 19, 20, 24, 25]), set([17, 5, 23])]

threeMissingTrees = [E4,E5,E6]
threeMissingTreesNumbers = set([EFG.index(x) for x in threeMissingTrees])
# print threeMissingTreesNumbers
# set([3, 4, 5])


##############################
# Orbit computation of types #
##############################

# We start by computing the orbits of list of sets for the convexHull Tuples.

orbitConvHaa2a3b = dict()
# for y in allTuplesWE6.keys()}:
for y in allTuplesRepresentatives:
    print y[0]
    orbitConvHaa2a3b[y[0]] = [ set([y[0][x] for x in convHConeaa2a3bNumbers[i]]) for i in range(0,len(convHConeaa2a3bNumbers))]


# We check that the configuration sets of numbers lie in the values of the dictionary:

# len([y for y in orbitConvHaa2a3b.values() if confConeaa2a3bNumbers[0].issubset(y[0]) if  confConeaa2a3bNumbers[1].issubset(y[1]) if  confConeaa2a3bNumbers[2].issubset(y[2])])
# 96


# We find all the candidates of Weyl elements giving the tuples obtained from the configurations:

candidatesConeaa2a3b = [key for key in orbitConvHaa2a3b.keys() if confConeaa2a3bNumbers[0].issubset(orbitConvHaa2a3b[key][0]) if confConeaa2a3bNumbers[1].issubset(orbitConvHaa2a3b[key][1]) if confConeaa2a3bNumbers[2].issubset(orbitConvHaa2a3b[key][2])]

# confConeaa2a3bNumbers in orbitConvHaa2a3b.values()
# True

# We find all the candidates of Weyl elements giving the tuples obtained from the configurations:

candidatesConeaa2a3b = [key for key in orbitConvHaa2a3b.keys() if orbitConvHaa2a3b[key]== confConeaa2a3bNumbers]

print len(candidatesConeaa2a3b)
96

# We check that candidatesConeaa2a3b is a subset of candidatesConeaa2a3a4:
all([x in candidatesConeaa2a3a4 for x in candidatesConeaa2a3b])
True


# Even though one set of candidates is included in the other, we still need to compute the orbits for both sets (it could very well happen that the W(E_6) element that works for one maximal cone does not work for the other.

finalCandidatesaa2a3b = candidatesConeaa2a3b

########################
# Labelling for aa2a3b #
########################

orbitConvHE6aa2a3b = dict()
# for y in allTuplesWE6.keys()}:
for y in candidatesConeaa2a3b:
    print y
    orbitConvHE6aa2a3b[y] = [ set([y[x] for x in  ConvHE6aa2a3bNumbers[i]]) for i in range(0,len(ConvHE6aa2a3bNumbers))]

orbitConvHF36aa2a3b = dict()
# for y in allTuplesWE6.keys()}:
for y in candidatesConeaa2a3b:
    print y
    orbitConvHF36aa2a3b[y] = [ set([y[x] for x in  ConvHF36aa2a3bNumbers[i]]) for i in range(0,len(ConvHF36aa2a3bNumbers))]


orbitConvHG3aa2a3b = dict()
# for y in allTuplesWE6.keys()}:
for y in candidatesConeaa2a3b:
#    print y
    orbitConvHG3aa2a3b[y] = [ set([y[x] for x in  ConvHG3aa2a3bNumbers[i]]) for i in range(0,len(ConvHG3aa2a3bNumbers))]


########################################
# Data from Configuration computations #
########################################

aa2a3bConfI = dict()
aa2a3bConfII = dict()
aa2a3bConfIII = dict()

##########
# Type I #
##########

aa2a3bConfI[F23] = [(set([F14,E3]), set([F15,F45,G3,E2,F16,F46,G2,F56])), (set([F15,F45]), set([G3,F14,E3,E2,F16,F46,G2,F56])), (set([F15,F45,G3]), set([F14,E3,E2,F16,F46,G2,F56])), (set([F15,F45,G3,F14,E3]), set([E2,F16,F46,G2,F56])), (set([E2,F16,F46,G2,F56]), set([F15,F45,G3,F14,E3])), (set([E2,F16,F46]), set([G2,F56,F15,F45,G3,F14,E3])), (set([F16,F46]), set([E2,G2,F56,F15,F45,G3,F14,E3])), (set([G2,F56]), set([E2,F16,F46,F15,F45,G3,F14,E3]))]

aa2a3bConfI[G1] = [(set([F16,F12]), set([F13,E4,F15,E3,F14,E5,E6,E2])), (set([F13,E4]), set([F15,F16,F12,E3,F14,E5,E6,E2])), (set([F13,E4,F15]), set([F16,F12,E3,F14,E5,E6,E2])), (set([F13,E4,F15,F16,F12]), set([E3,F14,E5,E6,E2])), (set([E3,F14,E5,E6,E2]), set([F13,E4,F15,F16,F12])), (set([E3,F14]), set([E5,E6,E2, F13,E4,F15,F16,F12])), (set([E3,F14,E5]), set([E6,E2, F13,E4,F15,F16,F12])), (set([E6,E2]), set([E3,F14,E5,F13,E4,F15,F16,F12]))]

aa2a3bConfI[G4] = [(set([F34,E1]), set([F45,F46,F24,E3,F14,E5,E6,E2])), (set([F34,E1,F45]), set([F46,F24,E3,F14,E5,E6,E2])), (set([F46,F24]), set([F34,E1,F45,E3,F14,E5,E6,E2])), (set([F46,F24,F34,E1,F45]), set([E3,F14,E5,E6,E2])), (set([E3,F14,E5,E6,E2]), set([F46,F24,F34,E1,F45])), (set([E3,F14,E5]), set([E6,E2,F46,F24,F34,E1,F45])), (set([E3,F14]), set([E5,E6,E2,F46,F24,F34,E1,F45])), (set([E6,E2]), set([E3,F14,E5,F46,F24,F34,E1,F45]))]

aa2a3bConfI[G5] = [(set([F56,F25]), set([E3,E1,E4,E6,E2,F35,F15,F45])), (set([F56,F25,E3]), set([E1,E4,E6,E2,F35,F15,F45])), (set([F56,F25,E3,E1,E4]), set([E6,E2,F35,F15,F45])), (set([E6,E2,F35,F15,F45]), set([F56,F25,E3,E1,E4])), (set([E1,E4]), set([F56,F25,E3,E6,E2,F35,F15,F45])), (set([E6,E2,F35]), set([F15,F45,F56,F25,E3,E1,E4])), (set([E6,E2]), set([F15,F45,F35,F56,F25,E3,E1,E4])), (set([F15,F45]), set([E6,E2,F35,F56,F25,E3,E1,E4]))]

aa2a3bConfI[F45] = [(set([F16,F12]), set([G4,F13,E4,G5,F26,F23,F36,E5])), (set([F16,F12,G4]), set([F13,E4,G5,F26,F23,F36,E5])), (set([F13,E4]), set([F16,F12,G4,G5,F26,F23,F36,E5])), (set([F16,F12,G4,F13,E4]), set([G5,F26,F23,F36,E5])), (set([G5,F26,F23,F36,E5]), set([F16,F12,G4,F13,E4])), (set([G5,F26]), set([F23,F36,E5,F16,F12,G4,F13,E4])), (set([F23,F36,E5]), set([G5,F26,F16,F12,G4,F13,E4])), (set([F23,F36]), set([E5,G5,F26,F16,F12,G4,F13,E4]))]

aa2a3bConfI[F14] = [(set([E1,E4]), set([F26,F25,F56,G4,G1,F35,F36,F23])), (set([E1,E4,F26]), set([F25,F56,G4,G1,F35,F36,F23])), (set([F25,F56]), set([E1,E4,F26,G4,G1,F35,F36,F23])), (set([E1,E4,F26,F25,F56]), set([G4,G1,F35,F36,F23])), (set([G4,G1,F35,F36,F23]), set([E1,E4,F26,F25,F56])), (set([F36,F23]), set([G4,G1,F35,E1,E4,F26,F25,F56])), (set([G4,G1,F35]), set([F36,F23,E1,E4,F26,F25,F56])), (set([G4,G1]), set([F35,F36,F23,E1,E4,F26,F25,F56]))]

aa2a3bConfI[F15] = [(set([F24,F46]), set([G1,E1,F34,G5,F26,E5,F36,F23])), (set([G1,F24,F46]), set([E1,F34,G5,F26,E5,F36,F23])), (set([E1,F34]), set([G1,F24,F46,G5,F26,E5,F36,F23])), (set([E1,F34,G1,F24,F46]), set([G5,F26,E5,F36,F23])), (set([G5,F26,E5,F36,F23]), set([E1,F34,G1,F24,F46])), (set([G5,F26]), set([E5,F36,F23,E1,F34,G1,F24,F46])), (set([F23,F36]), set([E5,G5,F26,E1,F34,G1,F24,F46])), (set([F23,E5,F36]), set([G5,F26,E1,F34,G1,F24,F46]))]

aa2a3bConfI[F26] = [(set([E6,E2]), set([F35,F45,F15,F34,F13,F14,G2,G6])), (set([E6,E2,F35]), set([F45,F15,F34,F13,F14,G2,G6])), (set([F45,F15]), set([E6,E2,F35,F34,F13,F14,G2,G6])), (set([F45,F15,E6,E2,F35]), set([F34,F13,F14,G2,G6])), (set([F34,F13,F14,G2,G6]), set([F45,F15,E6,E2,F35])), (set([F34,F13]), set([F14,G2,G6,F45,F15,E6,E2,F35])), (set([F14,G2,G6]), set([F34,F13,F45,F15,E6,E2,F35])), (set([G2,G6]), set([F14,F34,F13,F45,F15,E6,E2,F35]))]

aa2a3bConfI[F36] = [(set([F12,F24]), set([E6,G6,F25,E3,F14,G3,F15,F45])), (set([E6,F12,F24]), set([G6,F25,E3,F14,G3,F15,F45])), (set([G6,F25,E6,F12,F24]), set([E3,F14,G3,F15,F45])), (set([G6,F25]), set([E6,F12,F24,E3,F14,G3,F15,F45])), (set([E3,F14,G3,F15,F45]), set([G6,F25,E6,F12,F24])), (set([E3,F14]), set([G3,F15,F45,G6,F25,E6,F12,F24])), (set([G3,F15,F45]), set([E3,F14,G6,F25,E6,F12,F24])), (set([F15,F45]), set([G3,E3,F14,G6,F25,E6,F12,F24]))]

aa2a3bConfI[E2] = [(set([F25,G6]), set([F23,F24,F12,G1,G4,G3,F26,G5])), (set([F23,F25,G6]), set([F24,F12,G1,G4,G3,F26,G5])), (set([F23,F25,G6,F24,F12]), set([G1,G4,G3,F26,G5])), (set([F24,F12]), set([F23,F25,G6,G1,G4,G3,F26,G5])), (set([G1,G4,G3,F26,G5]), set([F23,F25,G6,F24,F12])), (set([G1,G4]), set([G3,F26,G5,F23,F25,G6,F24,F12])), (set([G3,F26,G5]), set([G1,G4,F23,F25,G6,F24,F12])), (set([F26,G5]), set([G3,G1,G4,F23,F25,G6,F24,F12]))]

aa2a3bConfI[E3] = [(set([F13,F34]), set([G5,G2,G6,F23,F36,G1,G4,F35])), (set([G5,F13,F34]), set([G2,G6,F23,F36,G1,G4,F35])), (set([G2,G6]), set([G5,F13,F34,F23,F36,G1,G4,F35])), (set([G2,G6,G5,F13,F34]), set([F23,F36,G1,G4,F35])), (set([F23,F36,G1,G4,F35]), set([G2,G6,G5,F13,F34])), (set([F23,F36]), set([G1,G4,F35,G2,G6,G5,F13,F34])), (set([G1,G4,F35]), set([F23,F36,G2,G6,G5,F13,F34])), (set([G1,G4]), set([F35,F23,F36,G2,G6,G5,F13,F34]))]


# aa2a3bConfI[E6] = [(set([]), set([])),


###########
# Type II #
###########

aa2a3bConfII[F12] = [(set([E1,F34]), set([F45,G1,F46,F35,E2,F36,G2,F56])), (set([E1,F34, F45]), set([G1,F46,F35,E2,F36,G2,F56])), (set([E1,F34, F45, G1]), set([F46,F35,E2,F36,G2,F56])), (set([E1,F34, F45, G1, F46]), set([F35,E2,F36,G2,F56])), (set([F35,E2,F36,G2,F56]), set([E1,F34, F45, G1, F46])), (set([E2,F36,G2,F56]), set([F35,E1,F34, F45, G1, F46])), (set([F36,G2,F56]), set([E2,F35,E1,F34, F45, G1, F46])), (set([G2,F56]), set([F36,E2,F35,E1,F34, F45, G1, F46]))]

aa2a3bConfII[F13] = [(set([F46,F24]), set([G1,F45,E1,G3,F26,E3,F25,F56])), (set([F46,F24, G1]), set([F45,E1,G3,F26,E3,F25,F56])), (set([F46,F24, G1, F45]), set([E1,G3,F26,E3,F25,F56])), (set([F46,F24, G1, F45, E1]), set([G3,F26,E3,F25,F56])), (set([G3,F26,E3,F25,F56]), set([F46,F24, G1, F45, E1])), (set([F26,E3,F25,F56]), set([G3,F46,F24, G1, F45, E1])), (set([E3,F25,F56]), set([F26,G3,F46,F24, G1, F45, E1])), (set([F25,F56]), set([E3,F26,G3,F46,F24, G1, F45, E1]))]

aa2a3bConfII[G2] = [(set([E1,E4]), set([F26,E3,F25,E5,F23,E6,F12,F24])), (set([E1,E4, F26]), set([E3,F25,E5,F23,E6,F12,F24])), (set([E1,E4, F26, E3]), set([F25,E5,F23,E6,F12,F24])), (set([E1,E4, F26, E3,F25]), set([E5,F23,E6,F12,F24])), (set([E5,F23,E6,F12,F24]), set([E1,E4, F26, E3,F25])), (set([F23,E6,F12,F24]), set([E5,E1,E4, F26, E3,F25])), (set([E6,F12,F24]), set([F23,E5,E1,E4, F26, E3,F25])), (set([F12,F24]), set([E6,F23,E5,E1,E4, F26, E3,F25]))]

aa2a3bConfII[G6] = [(set([E1,E4]), set([F26,E3,E5,F56,F36,E2,F16,F46])), (set([E1,E4,F26]), set([E3,E5,F56,F36,E2,F16,F46])), (set([E1,E4,F26,E3]), set([E5,F56,F36,E2,F16,F46])), (set([E1,E4,F26,E3,F56]), set([E5,F36,E2,F16,F46])), (set([E5,F36,E2,F16,F46]), set([E1,E4,F26,E3,F56])), (set([F36,E2,F16,F46]), set([F56,E1,E4,F26,E3,E5])), (set([E2,F16,F46]), set([F36,F56,E1,E4,F26,E3,E5])), (set([F16,F46]), set([E2,F36,F56,E1,E4,F26,E3,E5]))]

aa2a3bConfII[F46] = [(set([F13,E4]), set([F15,G4,F12,F35,E6,F23,F25,G6])), (set([F13,E4, F15]), set([G4,F12,F35,E6,F23,F25,G6])), (set([F13,E4, F15, G4]), set([F12,F35,E6,F23,F25,G6])), (set([F13,E4, F15, G4, F12]), set([F35,E6,F23,F25,G6])), (set([F35,E6,F23,F25,G6]), set([F13,E4, F15, G4, F12])), (set([E6,F23,F25,G6]), set([F35,F13,E4, F15, G4, F12])), (set([F23,F25,G6]), set([E6,F35,F13,E4, F15, G4, F12])), (set([F25,G6]), set([F23,E6,F35,F13,E4, F15, G4, F12]))]

aa2a3bConfII[F56] = [(set([F13, F34]), set([G5, F14, E5, G6, F23, E6, F24, F12])), (set([F13, F34, G5]), set([F14, E5, G6, F23, E6, F24, F12])), (set([F13, F34, G5, F14]), set([E5, G6, F23, E6, F24, F12])), (set([F13, F34, G5, F14, G6]), set([E5, F23, E6, F24, F12])), (set([E5, F23, E6, F24, F12]), set([F13, F34, G5, F14, G6])), (set([F23, E6, F24, F12]), set([G6, F13, F34, G5, F14, E5])), (set([E6, F24, F12]), set([F23, G6, F13, F34, G5, F14, E5])), (set([F24, F12]), set([E6, F23, G6, F13, F34, G5, F14, E5]))]

aa2a3bConfII[F24] = [(set([E4,F13]), set([F15,G4,F16,F35,E2,F36,G2,F56])), (set([F15,E4,F13]), set([G4,F16,F35,E2,F36,G2,F56])), (set([G4,F15,E4,F13]), set([F16,F35,E2,F36,G2,F56])), (set([F16,G4,F15,E4,F13]), set([F35,E2,F36,G2,F56])), (set([F35,E2,F36,G2,F56]), set([F16,G4,F15,E4,F13])), (set([E2,F36,G2,F56]), set([F35,F16,G4,F15,E4,F13])), (set([F36,G2,F56]), set([E2,F35,F16,G4,F15,E4,F13])), (set([G2,F56]), set([F36,E2,F35,F16,G4,F15,E4,F13]))]

aa2a3bConfII[F34] = [(set([F12,F16]), set([G4,F15,E4,G3,F26,E3,F56,F25])), (set([G4,F12,F16]), set([F15,E4,G3,F26,E3,F56,F25])), (set([F15,G4,F12,F16]), set([E4,G3,F26,E3,F56,F25])), (set([E4,F15,G4,F12,F16]), set([G3,F26,E3,F56,F25])), (set([G3,F26,E3,F56,F25]), set([E4,F15,G4,F12,F16])), (set([F26,E3,F56,F25]), set([G3,E4,F15,G4,F12,F16])), (set([E3,F56,F25]), set([F26,G3,E4,F15,G4,F12,F16])), (set([F56,F25]), set([E3,F26,G3,E4,F15,G4,F12,F16]))]

aa2a3bConfII[F25] = [(set([F46,F16]), set([E2,F36,E5,G2,F14,G5,F13,F34])), (set([E2,F46,F16]), set([F36,E5,G2,F14,G5,F13,F34])), (set([F36,E2,F46,F16]), set([E5,G2,F14,G5,F13,F34])), (set([E5,F36,E2,F46,F16]), set([G2,F14,G5,F13,F34])), (set([G2,F14,G5,F13,F34]), set([E5,F36,E2,F46,F16])), (set([F14,G5,F13,F34]), set([G2,E5,F36,E2,F46,F16])), (set([G5,F13,F34]), set([F14,G2,E5,F36,E2,F46,F16])), (set([F13,F34]), set([G5,F14,G2,E5,F36,E2,F46,F16]))]

aa2a3bConfII[F16] = [(set([E1,F34]), set([F45,G1,F24,F35,E6,F23,G6,F25])), (set([F45,E1,F34]), set([G1,F24,F35,E6,F23,G6,F25])), (set([G1,F45,E1,F34]), set([F24,F35,E6,F23,G6,F25])), (set([F24,G1,F45,E1,F34]), set([F35,E6,F23,G6,F25])), (set([F35,E6,F23,G6,F25]), set([F24,G1,F45,E1,F34])), (set([E6,F23,G6,F25]), set([F35,F24,G1,F45,E1,F34])), (set([F23,G6,F25]), set([E6,F35,F24,G1,F45,E1,F34])), (set([G6,F25]), set([F23,E6,F35,F24,G1,F45,E1,F34]))]

aa2a3bConfII[E1] = [(set([F12,F16]), set([G4,F15,F13,G3,G5,F14,G2,G6])), (set([G4,F12,F16]), set([F15,F13,G3,G5,F14,G2,G6])), (set([F15,G4,F12,F16]), set([F13,G3,G5,F14,G2,G6])), (set([F13,F15,G4,F12,F16]), set([G3,G5,F14,G2,G6])), (set([G3,G5,F14,G2,G6]), set([F13,F15,G4,F12,F16])), (set([G5,F14,G2,G6]), set([G3,F13,F15,G4,F12,F16])), (set([F14,G2,G6]), set([G5,G3,F13,F15,G4,F12,F16])), (set([G2,G6]), set([F14,G5,G3,F13,F15,G4,F12,F16]))]

# aa2a3bConfII[E4] = [(set([]), set([])),

############
# Type III #
############

aa2a3bConfIII[G3] = [(set([E1,E4]), set([F13,F34,E6,E2,F35,E5,F36,F23])), (set([F13,F34,E1,E4]), set([E6,E2,F35,E5,F36,F23])), (set([F13,F34]), set([E1,E4,E6,E2,F35,E5,F36,F23])), (set([E6,E2,F35]), set([E5,F36,F23, F13,F34,E1,E4])), (set([E6,E2]), set([F35, E5,F36,F23, F13,F34,E1,E4])), (set([E5,F36,F23]), set([E6,E2,F35, F13,F34,E1,E4])), (set([F36,F23]), set([E5,E6,E2,F35,F13,F34,E1,E4]))]

aa2a3bConfIII[F35] = [(set([G5,F26]), set([G3,E3,F14,E5,F24,F12,F16,F46])), (set([G5,F26,G3]), set([E3,F14,E5,F24,F12,F16,F46])), (set([E3,F14]), set([E5,G5,F26,G3,F24,F12,F16,F46])), (set([E3,F14,E5]), set([G5,F26,G3,F24,F12,F16,F46])), (set([F16,F46]), set([E3,F14,E5,G5,F26,G3,F24,F12])), (set([F24,F12]), set([F16,F46,E3,F14,E5,G5,F26,G3])), (set([F24,F12,F16,F46]), set([E3,F14,E5,G5,F26,G3]))]

# aa2a3bConfIII[E5] = [(set([]), set([])),





#######################################
# Topological types from Convex Hulls #
#######################################

# We can use the output of the convex hull computations (recorded in '../Output/NonLeavesAndDistancesForConesAndExtremals.sobj') to construct the list of leaves with the symmetry classes and topological embeddings. In this way, we can apply the maps and see if we can find the W(E6)-element. We can also do this by hand, by simply looking at the dictionary {line: dictionary of leaves} obtained from the sage object file.

# We use the labeling of the vertices given in the table:
allTreesb = dict()
allTreesb[E1] = {0: F12, 4: G3, 3: G4, 2: G5, 1: G6, 5: F13, 9: G2, 6: F14, 7: F15, 8: F16}
allTreesb[E2] = {0: F12, 4: G3, 3: G4, 2: G5, 1: G6, 9: G1, 5: F23, 6: F24, 7: F25, 8: F26}
allTreesb[E3] = {9: G2, 1: F13, 3: G4, 2: G5, 4: G6, 8: G1, 0: F23, 6: F34, 7: F35, 5: F36}
allTreesb[E4] = {7: G2, 5: G3, 3: F14, 1: G5, 9: G6, 6: G1, 2: F24, 4: F34, 8: F45, 0: F46}
allTreesb[E5] =  {6: G2, 5: G3, 1: G4, 3: F15, 9: G6, 7: G1, 2: F25, 4: F35, 8: F45, 0: F56}
allTreesb[E6] =  {6: G2, 7: G3, 9: G4, 1: G5, 4: F16, 5: G1, 3: F26, 2: F36, 0: F46, 8: F56}
allTreesb[F12] =  {0: E1, 1: E2, 8: G1, 9: G2, 6: F34, 7: F35, 5: F36, 4: F45, 2: F46, 3: F56}
allTreesb[F13] =  {4: E1, 0: G1, 5: G3, 3: F24, 2: F25, 1: F26, 9: E3, 8: F45, 7: F46, 6: F56}
allTreesb[F14] =  {6: E1, 8: G1, 7: F23, 3: G4, 5: F25, 9: F26, 0: F35, 4: F36, 1: E4, 2: F56}
allTreesb[F15] =  {6: E1, 8: G1, 7: F23, 5: F24, 3: G5, 9: F26, 0: F34, 4: F36, 2: F46, 1: E5}
allTreesb[F16] =  {6: E1, 5: G1, 7: F23, 9: F24, 8: F25, 3: G6, 1: F34, 0: F35, 2: F45, 4: E6}
allTreesb[F23] = {9: G2, 4: G3, 7: F14, 6: F15, 8: F16, 5: E2, 0: E3, 1: F45, 3: F46, 2: F56}
allTreesb[F24] = {8: G2, 7: F13, 3: G4, 5: F15, 9: F16, 6: E2, 0: F35, 4: F36, 1: E4, 2: F56}
allTreesb[F25] = {8: G2, 7: F13, 5: F14, 3: G5, 9: F16, 6: E2, 0: F34, 4: F36, 2: F46, 1: E5}
allTreesb[F26] =  {5: G2, 7: F13, 9: F14, 8: F15, 3: G6, 6: E2, 1: F34, 0: F35, 2: F45, 4: E6}
allTreesb[F34] = {7: F12, 5: G3, 3: G4, 1: F15, 9: F16, 0: F25, 8: F26, 6: E3, 4: E4, 2: F56}
allTreesb[F35] = {7: F12, 5: G3, 1: F14, 3: G5, 9: F16, 0: F24, 8: F26, 6: E3, 2: F46, 4: E5}
allTreesb[F36] = {6: F12, 7: G3, 9: F14, 1: F15, 4: G6, 8: F24, 0: F25, 5: E3, 3: F45, 2: E6}
allTreesb[F45] = {5: F12, 7: F13, 9: G4, 8: G5, 3: F16, 6: F23, 2: F26, 4: F36, 1: E4, 0: E5}
allTreesb[F46] = {8: F12, 7: F13, 5: G4, 3: F15, 9: G6, 6: F23, 2: F25, 1: F35, 0: E4, 4: E6}
allTreesb[F56] =  {8: F12, 7: F13, 3: F14, 5: G5, 9: G6, 6: F23, 2: F24, 1: F34, 0: E5, 4: E6}
allTreesb[G1] = {1: F12, 9: F13, 6: F14, 7: F15, 5: F16, 8: E2, 0: E3, 3: E4, 2: E5, 4: E6}
allTreesb[G2] = {8: E1, 1: F12, 9: F23, 6: F24, 7: F25, 5: F26, 0: E3, 3: E4, 2: E5, 4: E6}
allTreesb[G3] = {8: E1, 9: E2, 1: F13, 0: F23, 5: F34, 6: F35, 7: F36, 4: E4, 3: E5, 2: E6}
allTreesb[G4] =  {6: E1, 7: E2, 8: E3, 3: F14, 2: F24, 1: F34, 9: F45, 5: F46, 0: E5, 4: E6}
allTreesb[G5] = {6: E1, 7: E2, 8: E3, 0: E4, 3: F15, 2: F25, 1: F35, 9: F45, 5: F56, 4: E6}
allTreesb[G6] =  {6: E1, 7: E2, 5: E3, 1: E4, 0: E5, 3: F16, 2: F26, 4: F36, 8: F46, 9: F56}


##########################
# Topological structures #
##########################

# We list all the non-trivial quartets. Each lists consists of tuple of sets (A,B) with |A|<=|B| (if = holds, we put (A,B) and (B,A)). We use this to compute the labeling of trees obtained by the automorphisms.


typeIaa2a3bTop = [(set([0,1]), set([2,3,4,5,6,7,8,9])), (set([2,3]), set([0,1,4,5,6,7,8,9])), (set([6,7]), set([0,1,2,3,4,5,8,9])), (set([8,9]), set([0,1,2,3,4,5,6,7])), (set([2,3,4]),  set([0,1,5,6,7,8,9])), (set([5,6,7]),  set([0,1,2,3,4,8,9])), (set([0,1,2,3,4]),  set([5,6,7,8,9])),  (set([5,6,7,8,9]), set([0,1,2,3,4]))]

typeIIaa2a3bTop = [(set([2,3]), set([0,1,4,5,6,7,8,9])), (set([1,2,3]), set([0,4,5,6,7,8,9])), (set([0,1,2,3]), set([4,5,6,7,8,9])), (set([0,1,2,3,4]), set([5,6,7,8,9])), (set([5,6,7,8,9]), set([0,1,2,3,4])), (set([6,7,8,9]), set([0,1,2,3,4,5])), (set([6,7,8]), set([0,1,2,3,4,5,9])), (set([6,7]), set([0,1,2,3,4,5,8,9]))]

typeIIIaa2a3bTop = [(set([0,1]), set([2,3,4,5,6,7,8,9])), (set([8,9]), set([0,1,2,3,4,5,6,7])), (set([3,4]), set([0,1,2,5,6,7,8,9])), (set([5,6]), set([0,1,2,3,4,7,8,9])),  (set([2,3,4]),set([0,1,5,6,7,8,9])), (set([5,6,7]), set([0,1,2,3,4,8,9])), (set([0,1,8,9]),  set([2,3,4,5,6,7]))]


###################
# Orbits of trees #
###################
# We translate the above information on the trees coming from the convex hull computations into numbers so that we can apply the W(E_6)-action:

allTreesbNumbers = dict()
for key in allTreesb.keys():
    print key
    neweq = dict()    
    for l in range(0,10):
    	# print l
    	neweq[l] = EFG.index(allTreesb[key][l])
    allTreesbNumbers[EFG.index(key)] = neweq

# We compute the orbits for the chosen maximal cell in the Naruki fan:

allTreesbOrbitaa2a3bNumbers = dict()
for p in finalCandidatesaa2a3b:
    neweq = dict()
    for key in allTreesbNumbers.keys():
    	neweq[p[key]] = {l:p[allTreesbNumbers[key][l]] for l in range(0,10)}
    allTreesbOrbitaa2a3bNumbers[p] = neweq

# Next, we translate back to the labelings coming from the lines
allTreesbOrbitaa2a3b = dict()
for p in finalCandidatesaa2a3b:
    neweq = dict()
    for key in allTreesbOrbitaa2a3bNumbers[p].keys():
    	neweq[EFG[key]] = {l:EFG[allTreesbOrbitaa2a3bNumbers[p][key][l]] for l in range(0,10)}
    allTreesbOrbitaa2a3b[p] = neweq


###################
# Orbits by types #
###################

# We record the set of numbers for each type from our convex hull computations:

typeIaa2a3b = convHConeaa2a3bNumbers[0]
typeIIaa2a3b = convHConeaa2a3bNumbers[1]
typeIIIaa2a3b = convHConeaa2a3bNumbers[2]

# We compute the orbits for the given maximal cell in the Naruki fan:

##########
# aa2a3b #
##########

allTreesbOrbitTypeIaa2a3bNumbers = dict()
for p in finalCandidatesaa2a3b:
# for p in allTuplesRepresentatives:
    neweq = dict()
    for key in typeIaa2a3b:
    	neweq[(key,p[key])] = {l:p[allTreesbNumbers[key][l]] for l in range(0,10)}
    allTreesbOrbitTypeIaa2a3bNumbers[p] = neweq

allTreesbOrbitTypeIIaa2a3bNumbers = dict()
for p in finalCandidatesaa2a3b:
# for p in allTuplesRepresentatives:
    neweq = dict()
    for key in typeIIaa2a3b:
    	neweq[(key,p[key])] = {l:p[allTreesbNumbers[key][l]] for l in range(0,10)}
    allTreesbOrbitTypeIIaa2a3bNumbers[p] = neweq

allTreesbOrbitTypeIIIaa2a3bNumbers = dict()
for p in finalCandidatesaa2a3b:
# for p in allTuplesRepresentatives:
    neweq = dict()
    for key in typeIIIaa2a3b:
    	neweq[(key,p[key])] = {l:p[allTreesbNumbers[key][l]] for l in range(0,10)}
    allTreesbOrbitTypeIIIaa2a3bNumbers[p] = neweq


# Next, we translate back to the labelings coming from the lines
allTreesbOrbitTypeIaa2a3b = dict()
for p in finalCandidatesaa2a3b:
    neweq = dict()
    for key in allTreesbOrbitTypeIaa2a3bNumbers[p].keys():
    	neweq[(EFG[key[0]], EFG[key[1]])] = {l:EFG[allTreesbOrbitTypeIaa2a3bNumbers[p][key][l]] for l in range(0,10)}
    allTreesbOrbitTypeIaa2a3b[p] = neweq

allTreesbOrbitTypeIIaa2a3b = dict()
for p in finalCandidatesaa2a3b:
    neweq = dict()
    for key in allTreesbOrbitTypeIIaa2a3bNumbers[p].keys():
    	neweq[(EFG[key[0]], EFG[key[1]])] = {l:EFG[allTreesbOrbitTypeIIaa2a3bNumbers[p][key][l]] for l in range(0,10)}
    allTreesbOrbitTypeIIaa2a3b[p] = neweq

allTreesbOrbitTypeIIIaa2a3b = dict()
for p in finalCandidatesaa2a3b:
    neweq = dict()
    for key in allTreesbOrbitTypeIIIaa2a3bNumbers[p].keys():
    	neweq[(EFG[key[0]], EFG[key[1]])] = {l:EFG[allTreesbOrbitTypeIIIaa2a3bNumbers[p][key][l]] for l in range(0,10)}
    allTreesbOrbitTypeIIIaa2a3b[p] = neweq


# We check that all the keys agree with the lines coming from our configuration

# all([set([y[1] for y in x.keys()]) == set([EFG[j] for j in confConeaa2a3bNumbers[0]]) for x in allTreesbOrbitTypeIaa2a3b.values()])
# True

# all([set([y[1] for y in x.keys()]) == set([EFG[j] for j in confConeaa2a3bNumbers[1]]) for x in allTreesbOrbitTypeIIaa2a3b.values()])
# True

# all([set([y[1] for y in x.keys()]) == set([EFG[j] for j in confConeaa2a3bNumbers[2]]) for x in allTreesbOrbitTypeIIIaa2a3b.values()])
# True


# We write dictionaries with easier keys in range(0,64) for each of the dictionaries above:

testIaa2a3b = dict()
for k in range(0,len(finalCandidatesaa2a3b)):
    # testIaa2a3b[k] = {line: allTreesbOrbitTypeIaa2a3b[finalCandidatesaa2a3b[k]][line] for line in confConeaa2a3bTuples[0]}
    testIaa2a3b[k] = allTreesbOrbitTypeIaa2a3b[finalCandidatesaa2a3b[k]]

testIIaa2a3b = dict()
for k in range(0,len(finalCandidatesaa2a3b)):
    # testIIaa2a3b[k] = {line: allTreesbOrbitTypeIIaa2a3b[finalCandidatesaa2a3b[k]][line] for line in confConeaa2a3bTuples[1]}
    testIIaa2a3b[k] = allTreesbOrbitTypeIIaa2a3b[finalCandidatesaa2a3b[k]]

testIIIaa2a3b = dict()
for k in range(0,len(finalCandidatesaa2a3b)):
    # testIIIaa2a3b[k] = {line: allTreesbOrbitTypeIIIaa2a3b[finalCandidatesaa2a3b[k]][line] for line in confConeaa2a3bTuples[2]}
    testIIIaa2a3b[k] = allTreesbOrbitTypeIIIaa2a3b[finalCandidatesaa2a3b[k]]



########################
# Labelling for Orbits #
########################

dictOrb = allTreesbOrbitTypeIaa2a3b
topType = typeIaa2a3bTop
orbitQuartetsIaa2a3b = computeLabelingOrbits(dictOrb, topType)

keysMapsaa2a3b = orbitQuartetsIaa2a3b.keys()
# print len(keysMapsaa2a3b)
# 96

dictOrb = allTreesbOrbitTypeIIaa2a3b
topType = typeIIaa2a3bTop
orbitQuartetsIIaa2a3b = computeLabelingOrbits(dictOrb, topType)
# orbitQuartetsIIaa2a3b.keys() == keysMapsaa2a3b
# True


dictOrb = allTreesbOrbitTypeIIIaa2a3b
topType = typeIIIaa2a3bTop
orbitQuartetsIIIaa2a3b = computeLabelingOrbits(dictOrb, topType)
# orbitQuartetsIIIaa2a3b.keys() == keysMapsaa2a3b
# True



##########
# Type II #
##########

l = F23
test = [key for key in keysMapsaa2a3b if True == all([x in orbitQuartetsIaa2a3b[key][l].values()[0] for x in aa2a3bConfI[l]])]
len(test) 
48

l = G1
test1 = [key for key in keysMapsaa2a3b if True == all([x in orbitQuartetsIaa2a3b[key][l].values()[0] for x in aa2a3bConfI[l]])]
len(test1) 
48

test = [x for x in test1 if x in test]
len(test)
48

l = G4
test1 = [key for key in keysMapsaa2a3b if True == all([x in orbitQuartetsIaa2a3b[key][l].values()[0] for x in aa2a3bConfI[l]])]
len(test1) 
48

test = [x for x in test1 if x in test]
len(test)
48

l = G5
test1 = [key for key in keysMapsaa2a3b if True == all([x in orbitQuartetsIaa2a3b[key][l].values()[0] for x in aa2a3bConfI[l]])]
len(test1) 
48

test = [x for x in test1 if x in test]
len(test)
48



l = F45
test1 = [key for key in keysMapsaa2a3b if True == all([x in orbitQuartetsIaa2a3b[key][l].values()[0] for x in aa2a3bConfI[l]])]
len(test1) 
48

test = [x for x in test1 if x in test]
len(test)
48


l = F14
test1 = [key for key in keysMapsaa2a3b if True == all([x in orbitQuartetsIaa2a3b[key][l].values()[0] for x in aa2a3bConfI[l]])]
len(test1) 
48

test = [x for x in test1 if x in test]
len(test)
48


l = F15
test1 = [key for key in keysMapsaa2a3b if True == all([x in orbitQuartetsIaa2a3b[key][l].values()[0] for x in aa2a3bConfI[l]])]
len(test1)
48

test = [x for x in test1 if x in test]
len(test)
48


l = F26
test1 = [key for key in keysMapsaa2a3b if True == all([x in orbitQuartetsIaa2a3b[key][l].values()[0] for x in aa2a3bConfI[l]])]
len(test1)
48

test = [x for x in test1 if x in test]
len(test)
48


l = F36
test1 = [key for key in keysMapsaa2a3b if True == all([x in orbitQuartetsIaa2a3b[key][l].values()[0] for x in aa2a3bConfI[l]])]
len(test1)
48

test = [x for x in test1 if x in test]
len(test)
48


l = E2
test1 = [key for key in keysMapsaa2a3b if True == all([x in orbitQuartetsIaa2a3b[key][l].values()[0] for x in aa2a3bConfI[l]])]
len(test1)
48

test = [x for x in test1 if x in test]
len(test)
48


l = E3
test1 = [key for key in keysMapsaa2a3b if True == all([x in orbitQuartetsIaa2a3b[key][l].values()[0] for x in aa2a3bConfI[l]])]
len(test1)
48

test = [x for x in test1 if x in test]
len(test)
48

# Conclusion: we are left with 16 candidates.
aa2a3bIMaps = test 
print len(aa2a3bIMaps)
48

###########
# Type II #
###########

l = F12
test1 = [key for key in aa2a3bIMaps if True == all([x in orbitQuartetsIIaa2a3b[key][l].values()[0] for x in aa2a3bConfII[l]])]
len(test1)
24


l = F13
test2 = [key for key in aa2a3bIMaps if True == all([x in orbitQuartetsIIaa2a3b[key][l].values()[0] for x in aa2a3bConfII[l]])]
len(test2)
24

test1 = [x for x in test2 if x in test1]
len(test1)
16

l = G2
test2 = [key for key in aa2a3bIMaps if True == all([x in orbitQuartetsIIaa2a3b[key][l].values()[0] for x in aa2a3bConfII[l]])]
len(test2)
24

test1 = [x for x in test2 if x in test1]
len(test1)
8

#####
l = G6
test2 = [key for key in aa2a3bIMaps if True == all([x in orbitQuartetsIIaa2a3b[key][l].values()[0] for x in aa2a3bConfII[l]])]
len(test2)
24

test1 = [x for x in test2 if x in test1]
len(test1)
8

l = F46
test2 = [key for key in aa2a3bIMaps if True == all([x in orbitQuartetsIIaa2a3b[key][l].values()[0] for x in aa2a3bConfII[l]])]
len(test2)
24

test1 = [x for x in test2 if x in test1]
len(test1)
8

l = F56
test2 = [key for key in aa2a3bIMaps if True == all([x in orbitQuartetsIIaa2a3b[key][l].values()[0] for x in aa2a3bConfII[l]])]
len(test2)
24

test1 = [x for x in test2 if x in test1]
len(test1)
8

l = F24
test2 = [key for key in aa2a3bIMaps if True == all([x in orbitQuartetsIIaa2a3b[key][l].values()[0] for x in aa2a3bConfII[l]])]
len(test2)
24

test1 = [x for x in test2 if x in test1]
len(test1)
8

l = F34
test2 = [key for key in aa2a3bIMaps if True == all([x in orbitQuartetsIIaa2a3b[key][l].values()[0] for x in aa2a3bConfII[l]])]
len(test2)
24

test1 = [x for x in test2 if x in test1]
len(test1)
8


l = F25
test2 = [key for key in aa2a3bIMaps if True == all([x in orbitQuartetsIIaa2a3b[key][l].values()[0] for x in aa2a3bConfII[l]])]
len(test2)
24

test1 = [x for x in test2 if x in test1]
len(test1)
8

l = F16
test2 = [key for key in aa2a3bIMaps if True == all([x in orbitQuartetsIIaa2a3b[key][l].values()[0] for x in aa2a3bConfII[l]])]
len(test2)
24

test1 = [x for x in test2 if x in test1]
len(test1)
8


l = E1
test2 = [key for key in aa2a3bIMaps if True == all([x in orbitQuartetsIIaa2a3b[key][l].values()[0] for x in aa2a3bConfII[l]])]
len(test2)
24

test1 = [x for x in test2 if x in test1]
len(test1)
8

# aa2a3bConfII[E1]

# Conclusion: we are left with 8 candidates.
aa2a3bIIMaps = test1 
print len(aa2a3bIIMaps)
8


############
# Type III #
############


l = G3
test = [key for key in aa2a3bIIMaps if True == all([x in orbitQuartetsIIIaa2a3b[key][l].values()[0] for x in aa2a3bConfIII[l]])]
len(test) 
8

test == aa2a3bIIMaps
True

l = F35
test1 = [key for key in aa2a3bIIMaps if True == all([x in orbitQuartetsIIIaa2a3b[key][l].values()[0] for x in aa2a3bConfIII[l]])]
len(test1) 
8

test == test1
True


# Conclusion: we are left with 8 candidates as we expected.
aa2a3bMaps = aa2a3bIIMaps

# Missing lines to check: E4, E5, E6

# # We record the maps
# print aa2a3bMaps 
# [(0, 3, 14, 11, 17, 4, 25, 7, 10, 6, 24, 15, 19, 12, 21, 1, 5, 16, 2, 20, 13, 18, 9, 23, 26, 22, 8), (7, 15, 25, 11, 17, 4, 14, 0, 19, 12, 21, 3, 10, 6, 24, 1, 5, 16, 8, 22, 26, 9, 18, 23, 13, 20, 2), (3, 0, 14, 17, 11, 4, 25, 15, 12, 19, 21, 7, 6, 10, 24, 5, 1, 16, 2, 13, 20, 9, 18, 23, 22, 26, 8), (3, 0, 14, 11, 17, 4, 25, 15, 19, 12, 21, 7, 10, 6, 24, 1, 5, 16, 2, 20, 13, 9, 18, 23, 26, 22, 8), (0, 3, 14, 17, 11, 4, 25, 7, 6, 10, 24, 15, 12, 19, 21, 5, 1, 16, 2, 13, 20, 18, 9, 23, 22, 26, 8), (15, 7, 25, 17, 11, 4, 14, 3, 6, 10, 24, 0, 12, 19, 21, 5, 1, 16, 8, 26, 22, 18, 9, 23, 20, 13, 2), (15, 7, 25, 11, 17, 4, 14, 3, 10, 6, 24, 0, 19, 12, 21, 1, 5, 16, 8, 22, 26, 18, 9, 23, 13, 20, 2), (7, 15, 25, 17, 11, 4, 14, 0, 12, 19, 21, 3, 6, 10, 24, 5, 1, 16, 8, 26, 22, 9, 18, 23, 20, 13, 2)]

################################################
# Finding the candidates for the missing trees #
################################################


# Next, we take the 16 valid maps and determine the possible outputs for each of the three undertermined trees E4, E5, E6. In particular, we determine in which Type they land. In all cases, we have E4 is of type II, E5 is of type III, whereas E6 is of type I.


findTypesForMissingTreesb = dict()
for key in aa2a3bMaps:
    findTypesForMissingTreesb[key] = dict()
    for j in set(threeMissingTrees):
    	if j in orbitQuartetsIaa2a3b[key].keys():
	   findTypesForMissingTreesb[key][j] = str('I')
	elif j in    orbitQuartetsIIaa2a3b[key].keys():
	     findTypesForMissingTreesb[key][j] = str('II')
	else:   
             	   findTypesForMissingTreesb[key][j] = str('III')

test = findTypesForMissingTreesb.values()[0]
all([x == test for x in findTypesForMissingTreesb.values()])
True
print test
{E6: 'I', E5: 'III', E4: 'II'}


missingLinesb = dict()
for key in aa2a3bMaps:
    missingLinesb[key] = dict()
    missingLinesb[key][E6] = orbitQuartetsIaa2a3b[key][E6]
    missingLinesb[key][E4] = orbitQuartetsIIaa2a3b[key][E4]
    missingLinesb[key][E5] = orbitQuartetsIIIaa2a3b[key][E5]

# We record the lines acted on for each valid W(E6) element:
# [missingLinesb.values()[k][E4].keys() for k in range(0,len(missingLinesb.values()))]
# [[E2], [E1], [E2], [E1], [F23], [F13], [F23], [F13]]

# [missingLinesb.values()[k][E5].keys() for k in range(0,len(missingLinesb.values()))]
# [[E6], [E6], [E6], [E6], [E6], [E6], [E6], [E6]]

# [missingLinesb.values()[k][E6].keys() for k in range(0,len(missingLinesb.values()))]
# [[F35], [F34], [F34], [F35], [F34], [F35], [F35], [F34]]

#################
# Missing trees #
#################

# Next, we check that we always get the same labeling for each of E4, E5, and E6.

# We check that the values are all the same for E4:
allE4b = [missingLinesb[key][E4].values()[0] for key in missingLinesb.keys()]
x = allE4b[0]
all([all([y in allE4b[k] for y in allE4b[0]]) for k in range(0,len(allE4b))])
True


# We check that the values are all the same for E5:
allE5b = [missingLinesb[key][E5].values()[0] for key in missingLinesb.keys()]
x = allE5b[0]
all([all([y in allE5b[k] for y in allE5b[0]]) for k in range(0,len(allE5b))])
True


# We check that the values are all the same for E6:
allE6b = [missingLinesb[key][E6].values()[0] for key in missingLinesb.keys()]
x = allE6b[0]
all([all([y in allE6b[k] for y in allE6b[0]]) for k in range(0,len(allE6b))])
True


# We record the quartets of the 3 missing trees:


##############
# Type I: E6 #
##############


allE6b[0]
[({F46, F16}, {F26, F36, G1, F56, G4, G3, G2, G5}),
 ({G2, F56}, {F26, F36, G1, F16, G4, G3, F46, G5}),
 ({F26, G5}, {F36, G1, F56, F16, G4, G3, G2, F46}),
 ({G1, G4}, {F26, F36, F56, F16, G3, G2, F46, G5}),
 ({G2, F56, F36}, {F26, G1, F16, G4, G3, F46, G5}),
 ({F26, G5, G3}, {F36, G1, F56, F16, G4, G2, F46}),
 ({G2, F56, F46, F16, F36}, {F26, G1, G5, G4, G3}),
 ({F26, G1, G5, G4, G3}, {G2, F56, F46, F16, F36})]

aa2a3bConfI[E6] = allE6b[0]

###############
# Type II: E4 #
###############

allE4b[0]
[({G2, G6}, {F45, G1, G3, F24, F34, F46, G5, F14}),
 ({G2, G6, F14}, {F45, G1, G3, F24, F34, F46, G5}),
 ({G2, G6, G5, F14}, {F45, G1, G3, F24, F34, F46}),
 ({G2, G6, G5, F14, G3}, {G1, F24, F46, F45, F34}),
 ({G1, F24, F46, F45, F34}, {G2, G6, G5, F14, G3}),
 ({G1, F24, F46, F45}, {G3, F34, G2, G6, G5, F14}),
 ({G1, F24, F46}, {F45, G3, F34, G2, G6, G5, F14}),
 ({F24, F46}, {F45, G1, G3, F34, G2, G6, G5, F14})]

aa2a3bConfII[E4] = allE4b[0]

################
# Type III: E5 #
################

allE5b[0]
[({G2, F56}, {F45, G1, F15, G4, G3, F25, F35, G6}),
 ({F25, G6}, {F45, G1, F56, F15, G4, G3, F35, G2}),
 ({G1, G4}, {F45, F56, F15, G3, F25, F35, G2, G6}),
 ({F45, F15}, {G1, F56, G4, G3, F25, F35, G2, G6}),
 ({G1, G4, F35}, {F45, F56, F15, G3, F25, G2, G6}),
 ({F45, F15, G3}, {G1, F56, G4, F25, F35, G2, G6}),
 ({G2, F25, F56, G6}, {F45, G1, F15, G4, G3, F35})]


aa2a3bConfIII[E5] = allE5b[0]

aa2a3bConf = (aa2a3bConfI ,aa2a3bConfII ,aa2a3bConfIII)

# We record the tuple of splits for each tree, classified by types:

# save(aa2a3bConf, "../../TropicalConvexHulls/Output/aa2a3bLinesFromPlanarConfiguration.sobj")

# # We record these splittings as a plain text file:
# f =file('../../TropicalConvexHulls/Output/aa2a3bLinesFromPlanarConfiguration.txt','w')
# f.write('Type I Trees for (aa2a3b):' + '\n'+'\n')
# for k in aa2a3bConfI.keys():
#     f.write('Line ' + str(k) + ': ' +'\n')
#     f.write(str(aa2a3bConfI[k]))
#     f.write('\n')
# f.write('\n')
# f.write('Type II Trees for (aa2a3b):' + '\n' + '\n')
# for k in aa2a3bConfII.keys():
#     f.write('Line ' + str(k) + ': ' +'\n')
#     f.write(str(aa2a3bConfII[k]))
#     f.write('\n')
# f.write('\n')
# f.write('Type III Trees for (aa2a3b):' + '\n' + '\n')
# for k in aa2a3bConfIII.keys():
#     f.write('Line ' + str(k) + ': ' +'\n')
#     f.write(str(aa2a3bConfIII[k]))
#     f.write('\n')
# f.close()



# We record the elements of the Weyl group giving these generators:

aa2a3bMapsAsWE6 = {x: [y[1] for y in allTuplesRepresentatives if y[0] == x][0] for x in aa2a3bMaps}

# # We record the output. Each value yields an element of WE6 by composing the corresponding W(E6) generators from left to right.

# print aa2a3bMapsAsWE6
# {(0, 3, 14, 11, 17, 4, 25, 7, 10, 6, 24, 15, 19, 12, 21, 1, 5, 16, 2, 20, 13, 18, 9, 23, 26, 22, 8): (5, 4, 3, 5, 4, 3, 6, 3, 4, 2, 6, 3), (3, 0, 14, 17, 11, 4, 25, 15, 12, 19, 21, 7, 6, 10, 24, 5, 1, 16, 2, 13, 20, 9, 18, 23, 22, 26, 8): (1, 6, 3, 5, 4, 3, 6, 2, 3, 2), (0, 3, 14, 17, 11, 4, 25, 7, 6, 10, 24, 15, 12, 19, 21, 5, 1, 16, 2, 13, 20, 18, 9, 23, 22, 26, 8): (3, 6, 3, 5, 4, 3, 5, 6, 2, 5, 3), (3, 0, 14, 11, 17, 4, 25, 15, 19, 12, 21, 7, 10, 6, 24, 1, 5, 16, 2, 20, 13, 9, 18, 23, 26, 22, 8): (1, 6, 3, 5, 4, 3, 6, 2, 5, 4, 5, 3, 2), (7, 15, 25, 17, 11, 4, 14, 0, 12, 19, 21, 3, 6, 10, 24, 5, 1, 16, 8, 26, 22, 9, 18, 23, 20, 13, 2): (5, 2, 4, 3, 2, 6, 4, 1, 6, 3, 2, 4, 6, 1, 3, 5, 4, 6, 2, 3, 1, 6, 2, 5, 3, 4, 6, 1, 3), (15, 7, 25, 11, 17, 4, 14, 3, 10, 6, 24, 0, 19, 12, 21, 1, 5, 16, 8, 22, 26, 18, 9, 23, 13, 20, 2): (5, 4, 3, 5, 4, 3, 6, 5, 2, 3, 1, 6, 2, 3, 4, 1, 3, 6, 5, 4, 2, 3, 4, 6, 3, 6, 1), (7, 15, 25, 11, 17, 4, 14, 0, 19, 12, 21, 3, 10, 6, 24, 1, 5, 16, 8, 22, 26, 9, 18, 23, 13, 20, 2): (3, 6, 1, 4, 3, 2, 3, 6, 5, 1, 4, 3, 4, 2, 3, 1, 6, 2, 3, 4, 2, 1, 5, 3, 4, 1, 6, 3), (15, 7, 25, 17, 11, 4, 14, 3, 6, 10, 24, 0, 12, 19, 21, 5, 1, 16, 8, 26, 22, 18, 9, 23, 20, 13, 2): (5, 4, 3, 6, 2, 1, 4, 3, 4, 6, 5, 1, 2, 4, 3, 5, 1, 2, 1, 3, 4, 5, 6, 4, 3, 4)}

allTuplesaa2a3bWE6 = {y: composeAll(allAction,list(aa2a3bMapsAsWE6[y])) for y in aa2a3bMapsAsWE6.keys()}

allValuesaa2a3bWE6 ={y: dict({k: alphas[k].substitute(allTuplesaa2a3bWE6[y]) for k in range(0,len(alphas))}) for y in allTuplesaa2a3bWE6.keys() }

# allValuesaa2a3bWE6.values()[0]
# {0: -d1 - d3 - d4,
#  1: d1 - d4,
#  2: d3 - d5,
#  3: d2 + d4 + d5,
#  4: -d2 + d6,
#  5: -d3 - d5 - d6}

test = allValuesaa2a3bWE6.values()[0]

aa2a3bMapOnPosRoots = {j: [k for k in range(0,len(roots)) if SR(test[j]) == SR(roots[k])] for j in range(0,6)}

aa2a3bMapOnNegRoots = {j: [k for k in range(0,len(roots)) if SR(test[j]) == SR(-1*roots[k])] for j in range(0,6)}

aa2a3bMapOnPosRoots
{0: [], 1: [], 2: [], 3: [26], 4: [18], 5: []}
aa2a3bMapOnNegRoots
{0: [15], 1: [12], 2: [10], 3: [], 4: [], 5: [33]}

# The following records one of the 8 Weyl group elements used for the cone (aa2a3b)
[-1*positive_roots[15], -1*positive_roots[12], -1*positive_roots[10], positive_roots[26], positive_roots[18], -1*positive_roots[33]]
# [-alpha[2] - alpha[3] - alpha[4],
#  -alpha[1] - alpha[3] - alpha[4],
#  -alpha[4] - alpha[5],
#  alpha[1] + alpha[2] + alpha[3] + 2*alpha[4] + alpha[5],
#  alpha[3] + alpha[4] + alpha[5] + alpha[6],
#  -alpha[1] - alpha[2] - 2*alpha[3] - 2*alpha[4] - 2*alpha[5] - alpha[6]]


# The following records the three trees needed from the Table to give the labelling of the missing trees E4 and E5, E6.
k0 = [key for key in  allTuplesaa2a3bWE6.keys() if allValuesaa2a3bWE6[key] == allValuesaa2a3bWE6.values()[0]][0]

# print [missingLinesb[k0][E4].keys()[0], missingLinesb[k0][E5].keys()[0], missingLinesb[k0][E6].keys()[0]]
# [E2, E6, F35]