#######################################################
# 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))
# S = PolynomialRing(basering, Xs+Ys)
T = PolynomialRing(QQ, ds+Es+Fs+Gs)

YM = load("../Output/Yoshida_matrix.sobj")
#Yoshidas = [VectorToYoshida(YM[i],positive_roots) for i in range(0,40)]
YRing = PolynomialRing(QQ, Yoshidas)
YField = FractionField(YRing)

load("Yoshida.sage")


# Correspondence between X_{ij}, Y_{ijklmn} and anti-canonical triangles.
# X_{ij} = E_i F_{ij} G_j
# Y_{ijklmn} = F_{ij} F_{kl} F_{mn}
# correspondence = dict([])
# for i in range(1,7):
#     for j in range(1,7):
#         if i < j:
#             correspondence[S("X%s%s"%(i,j))] = T("E%s"%i)*T("F%s%s"%(i,j))*T("G%s"%j)
#         if j < i:
#             correspondence[S("X%s%s"%(i,j))] = T("E%s"%i)*T("F%s%s"%(j,i))*T("G%s"%j)
    
# 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:
#                             correspondence[S("Y%s%s%s%s%s%s"%(i,j,k,l,m,n))] =  T("F%s%s"%(i,j)) *  T("F%s%s"%(k,l)) * T("F%s%s"%(m,n))

#Note: the variables are missing the Eckardt quintic denominators.

#save(correspondence, "Input/XYEFG_correspondence.sobj")
correspondence = load("Input/XYEFG_correspondence.sobj")

######################################################################################
# Calculation of four factors that give the Cross Functions for each Eckhart quintic #
######################################################################################


################################################
# 1) Functions involved in the action of W(E6) #
################################################

# The action will be computing first on the d's (by the usual 5 generating transpositions plus the exceptional homomorphism (computed on ../../General/settingsAndPermutations.sage".) Once the action on the d's is computed we can easily get the action on the Yoshidas and the Cross functions they are polynomials in the ds's).

# The challenge in the computation is to compute the action on the anticanononical coordinates Xij and Yijklmn, since they might aquire a sign: they are obtained as products of three EFG curves (as indicated in the correspondence above), but they contain an Eckardt quintic in the denominator. The action sends one quintic to another by acting on the labeling. However, if the action on the labeling aquires a sign, the sign is then applied to the quintic, i.e. quintics[-k]= (-1)*quintics[k] for k in quintics.keys().
# The function "action_on_new_x" takes care of this sign adjustment.


#The result is saved as a dictionary called allAction.

#allAction is a dictionary indexed by the 6 generators of W(E6). Working with dictionaries is faster than working with homomorphisms.  The commands SR() converts all the variables and expressions to Symbolic Ring. It is easier to manipulate symbolic expressions than keeping track of the various parental rings.

#################################################################
# The following functions define the action using homomorphisms #
#################################################################


################
# ACTION ON Ds #
################


# We intent to use the following natural order to generate the W(E6), in agreement with "../../General/settingsAndPermutations.sage".
# allAction[1] = (12)
# allAction[2] = (23)
# allAction[3] = (34)
# allAction[4] = (45)
# allAction[5] = (56)
# allAction[6] = Exceptional switch
# [d1 + 1/3*d4 + 1/3*d5 + 1/3*d6,
#  d2 + 1/3*d4 + 1/3*d5 + 1/3*d6,
#  d3 + 1/3*d4 + 1/3*d5 + 1/3*d6,
#  1/3*d4 - 2/3*d5 - 2/3*d6,
#  -2/3*d4 + 1/3*d5 - 2/3*d6,
#  -2/3*d4 - 2/3*d5 + 1/3*d6]   

#The action on ds and on Xs+Ys (correct up to sign) is already stored in "../../General/settingsAndPermutations.sage". We only need to load it.

# Notice that on that file, S is given as:
# # A polynomial ring on all these generators
# S = PolynomialRing(QQ, ds+Xs+Ys)


cd ../../General/

load("settingsAndPermutations.sage")

cd ../Yoshida/Scripts/


def action_on_ds(permutation, ds):
    return {ds[i-1]:ds[permutation(i)-1] for i in range(1, len(ds)+1)}

allAction = {}
for i in range(1,7):
    perm = permsStd[i]
    allAction[i]={}
    for k in range(1,7):
        allAction[i][ds[k-1]]=perm[k-1]


###################
# ACTION ON ROOTS #
###################

def action_on_roots(homOfDs, roots):
    if homOfDs in SymmetricGroup(6):
        ad = action_on_ds(homOfDs, ds)
        base = basering.hom([basering(ad[x]) for x in ds])
    else:
        base = homOfDs;
    return {r:base(r) for r in roots}    

######################
# ACTION ON YOSHIDAS #
######################

# Assumption Yoshidas[i] corresponds to i th row of YM

def action_on_yoshidas(homOfDs,  yoshidas, YM, roots):
    ar = action_on_roots(homOfDs, roots)
    root_permutation = Permutation([roots.index(ar[roots[i]])+1 if ar[roots[i]] in roots else roots.index(-ar[roots[i]])+1 for i in range(0, len(roots))])
    rp_matrix = root_permutation.to_matrix()
    ym_perm = {i:YM.rows().index(rp_matrix*YM.rows()[i]) for i in range(0, len(YM.rows()))}

    # The next part computes the right sign. i is a number between 0 to 39 = len(YM.rows())
    def sign_of_yoshida(i):
        yoshida_i = VectorToYoshida(YM[i], roots) # In terms of d's
        yoshida_ym_perm_i = VectorToYoshida(YM[ym_perm[i]], roots) # In terms of d's

        if homOfDs in SymmetricGroup(6):
            ad = action_on_ds(homOfDs, ds)
            base = basering.hom([basering(ad[x]) for x in ds])
        else:
            base = homOfDs;        

        if expand(base(yoshida_i)) == expand(yoshida_ym_perm_i):
            return +1
        elif expand(base(yoshida_i)) == expand(-1*yoshida_ym_perm_i):
            return -1
        else:
            print "Error in action on Yoshida functions."

    return {yoshidas[i]:sign_of_yoshida(i)*yoshidas[ym_perm[i]] for i in range(0, len(yoshidas))}


# We add the action on Yoshidas to allAction, but only for the first 5 generators (corresponding to the elements coming from the SymmetricGroup(6)):
for i in range(0,6):
    print str(i)
    a_yoshidas = action_on_yoshidas(homsStd[i], Yoshidas, YM, roots)    
    for k in Yoshidas:
    	print str(k.index(Yoshidas))
	allAction[i][k]= a_yoshidas[k]


# We generate the action for HomsStd[6] by hand, using the functions described above:

ar = action_on_roots(homsStd[6], roots)
root_permutation = Permutation([roots.index(ar[roots[i]])+1 if ar[roots[i]] in roots else roots.index(-ar[roots[i]])+1 for i in range(0, len(roots))])
rp_matrix = root_permutation.to_matrix()
ym_perm = {i:YM.rows().index(rp_matrix*YM.rows()[i]) for i in range(0, len(YM.rows()))}

def sign_of_yoshida(i):
    yoshida_i = VectorToYoshida(YM[i], roots) # In terms of d's
    yoshida_ym_perm_i = VectorToYoshida(YM[ym_perm[i]], roots) # In terms of d's

    base = homsStd[6];        
    if expand(base(yoshida_i)) == expand(yoshida_ym_perm_i):
       return +1
    elif expand(base(yoshida_i)) == expand(-1*yoshida_ym_perm_i):
       return -1
    else:
       print "Error in action on Yoshida functions."

for i in range(0, len(Yoshidas)):
    print str(i)
    allAction[6][Yoshidas[i]] =sign_of_yoshida(i)*Yoshidas[ym_perm[i]] 


for k in range(0,len(Yoshidas)):
    print str(k)
    print SR(allAction[6][Yoshidas[k]]) == SR(sign_of_yoshida(k)*Yoshidas[ym_perm[k]])




# We save the action on ds and Yoshidas since we will use it to compute the Crosses:
# save(allAction, "Input/action_on_d_yoshida.sobj")

# This action will be used to construct the cross functions (in "four_factors.sage"))

#####################
# ACTION ON CROSSES #
#####################

allAction = load("Input/action_on_d_yoshida.sobj")

crosses = load("Input/binomial_yoshidas.sobj")
cross_variables = [var("Cross%s"%i) for i in range(0,135)]
cross_to_yoshidas = load("Input/cross_to_yoshidas.sobj")

cross_to_y = {c : cross_to_yoshidas[c][0] for c in cross_to_yoshidas.keys()}

def action_on_crosses(action_on_yoshidas):
    answer = {}
    for c in cross_variables:
        yoshida_expression = cross_to_yoshidas[c][0]
        new_yoshida_expression = yoshida_expression.substitute(action_on_yoshidas)
        new_c = [cp for cp in cross_to_yoshidas.keys() if new_yoshida_expression in cross_to_yoshidas[cp]][0]
        answer[c] = new_c
    return answer


# We add the action on Crosses to allAction:
for i in allAction.keys():
    print str(i)
    a_cross = action_on_crosses(allAction[i])
    for k in a_cross:
        allAction[i][k] = a_cross[k]

######################
# ACTION ON X and Ys #
######################

# The action on XYs is registered in homsStd above.
#We record the action before we adjust the signs:
xys = Xs+Ys
for i in allAction.keys():
    for k in xys:
        allAction[i][k]=homsStd[i](k)



################################################################################
# The following functions allow us to consider actions on the keys indexing the coordinates of P^45 and take the sign of the result into account. For example, if the action sends X12 to -X23, we would add the sign to the coordinate indexed by X23. 
################################################################################

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

def action_on_new_x(old_action):
    answer = {}
    daction = {S(d):old_action[d] for d in ds}
    for X in Xs+Ys:
        newX = X.substitute(old_action)
        oldQuintic = expand(quintics[S(X)].substitute(daction))
        newQuintic = expand(quintics[S(newX)])
        if oldQuintic == newQuintic:
            answer[X] = newX
        elif oldQuintic == -newQuintic:
            answer[X] = -newX
        else:
            print "Something is wrong for: X = " + str(X)
    return answer

for i in allAction.keys():
    newXs = action_on_new_x(allAction[i])
    for x in newXs.keys():
        if S(allAction[i][x]) != newXs[x]:
            allAction[i][x] = newXs[x]
            print "Sign change for (i,x) = " + str((i,x))

# # We record the sign changes:
# Sign change for (i,x) = (1, Y142536)
# Sign change for (i,x) = (1, Y152436)
# Sign change for (i,x) = (2, Y162534)
# Sign change for (i,x) = (2, Y132645)
# Sign change for (i,x) = (2, Y162435)
# Sign change for (i,x) = (2, Y123645)
# Sign change for (i,x) = (3, Y142536)
# Sign change for (i,x) = (3, Y132456)
# Sign change for (i,x) = (3, Y132546)
# Sign change for (i,x) = (3, Y142356)
# Sign change for (i,x) = (5, Y142536)
# Sign change for (i,x) = (5, Y162534)
# Sign change for (i,x) = (5, Y142635)
# Sign change for (i,x) = (5, Y152634)
# Sign change for (i,x) = (5, Y123546)
# Sign change for (i,x) = (5, Y123645)
# Sign change for (i,x) = (6, X31)
# Sign change for (i,x) = (6, X32)
# Sign change for (i,x) = (6, X12)
# Sign change for (i,x) = (6, X63)
# Sign change for (i,x) = (6, X21)
# Sign change for (i,x) = (6, X13)
# Sign change for (i,x) = (6, X65)
# Sign change for (i,x) = (6, X45)
# Sign change for (i,x) = (6, X64)
# Sign change for (i,x) = (6, X23)
# Sign change for (i,x) = (6, X54)
# Sign change for (i,x) = (6, X46)
# Sign change for (i,x) = (6, X56)
# Sign change for (i,x) = (6, Y123645)

  
# # We record the action as a Sage object:          
# save(allAction, "Input/action_on_d_XY_yoshida_cross.sobj")

# # We record the action as a plain text file:
# f = file("Input/action_on_d_XY_yoshida_cross.txt", 'w')
# f.write(str(allAction))
# f.close()

# We define newAllAction as a dictionary indexed by the 6 generators of W(E6). Working with dictionaries is faster than working with homomorphisms.  The commands SR() converts all the variables and expressions to Symbolic Ring. It is easier to manipulate symbolic expressions than keeping track of the various parental rings.

newAllAction = {i: {SR(k):SR(allAction[i][k]) for k in allAction[i].keys()} for i in range(1,7)}
save(newAllAction, "Input/Symbolic_action_on_everything.sobj")