"""
This code compute the Hodge number of the complement of graphic elliptic arrangements.
Input:  a natural number n (the number of vertexes)
	the array of edge E (each edge is a pair (i,j) with 0<i<j<n+1, the first n-1 edges must be a spanning forest!).
Output: the non-zero Hodge numbers e(p,q) for p>0.
"""

import itertools
import networkx as nx

n=8
E=[(1,2),(2,3),(3,4),(4,5),(5,6),(6,7),(7,8),(1,8),(2,4),(2,7),(4,8)]

F=[E[i] for i in range(n-1)]
AllPathsInF=nx.shortest_path(nx.Graph(F))

def f(R,k):
    "return fij in R"
    return R.gen(2*len(F)+E.index(k))

def Index(a,b):
    if a>b:
        a,b=b,a
    return F.index((a,b))

def xEdge(R,k):
    PathInF=AllPathsInF[k[0]][k[1]]
    return -sum(R.gen(Index(PathInF[j],PathInF[j+1])) for j in range(len(PathInF)-1))

def yEdge(R,k):
    PathInF=AllPathsInF[k[0]][k[1]]
    return -sum(R.gen(Index(PathInF[j],PathInF[j+1])+len(F)) for j in range(len(PathInF)-1))

def RelOfCycle(C,R):
    myPoly=R(0)
    for i in C:
        myAdd=R(1)
        for k in C:
             if k !=i:
                	myAdd*=f(R,k)
        myPoly+= (-1)**list(C).index(i)*myAdd
    return myPoly

ListOfVar=['u%s' %p for p in range(n-1)]+['v%s' %q for q in range(n-1)]+['f%s%s' %(p,q) for (p,q) in E]
TupleOfDeg=()
for i in range(2*len(F)):
    TupleOfDeg+=((1,0),)
for i in range(len(E)):
    TupleOfDeg+=((0,1),)
R = GradedCommutativeAlgebra(QQ,ListOfVar,TupleOfDeg)
R.inject_variables()

GenOfI=[RelOfCycle(aCycle,R) for aCycle in Matroid(Graph(E)).circuits()]
GenOfI+=[f(R,k)*xEdge(R,k) for k in E]
GenOfI+=[f(R,k)*yEdge(R,k) for k in E]
I=R.ideal(GenOfI)
Q=R.quotient(I)
Q.inject_variables()

DictDiff=dict(zip((f(Q,k) for k in E),(xEdge(R,k)*yEdge(R,k) for k in E )))
S=Q.cdg_algebra(DictDiff)

for i in range(1,n):
    for j in range(0,n-i):
        OutFile= open("output.txt","a+")
        OutFile.write("e (%d, %d) = %d\r\n" % (i , j , dimension(S.cohomology((i,j)))))
        OutFile.close()