# This file allows to compute the orbits of a flat of the hyperplane arrangement associated to the root system E6. The functions are general and can be used for other root systems.


############################
# Coordinates from a basis #
############################

# The following function calculations the coordinates of an expression in terms of the basis. We use it for E6, where the basis is given by the positive simple roots.

def coordinateOfRoots(begin,basis):
	return [[v.coefficient(i) for i in range(1,len(basis)+1)] for v in begin]

######################
# Orbit calculations #
######################


# The following function computes the orbit of a set of flats. Each flat is given as a list of ALL positive roots of E6 contained in the flat. 
# The action on a flat is obtained by transforming each one of its generators. We use the simple reflections stored on sage.
# We compare flats by their linear span. Each new flat obtained by the action of an element of W(E6) is given as a list of positive roots generating the flat. We write these as their coordinate vectors with respect to the simple roots alphai's. We do so because it is easy to evaluate the simple-reflections on the simple roots.

# begin must be a  set representing all positive roots of a flat, e.g. set([alpha[1], alpha[2]]) or set([alpha[1],alpha[3],alpha[1]+alpha[3])
# homs we pick are homsStdE6.

import copy

def orbitOfFlat(begin, basis, homs):
	n = len(basis)	
	# "Symmetrizing" flat means adding to the list above the flats obtained by applying to flat the actions of the generators of the W(E6) action.

	# we assume begin is set associated to a list of generators of a flat, and that the generators are (positive) roots. At each step we also pick the generators to be positive roots, and we check  that they generate a new linear space, using rowspan function, but we like to keep the generators as positive roots.

	# toSymmetrize keeps a list of flats that are yet to be symmetrized in this way. In the beginning, it is just a copy of the singleton list of flats. 
	#We keep the flats in terms of expressions in the alphas because we can easily evaluate the simple-reflections on them.
	flats = [begin.copy()]
	toSymmetrize = [begin.copy()]
	print flats
	print toSymmetrize	
	print toSymmetrize[-1]

	# Keep track of the linear spans
#	LinearSpans = set(span(coordinateOfRoots(x,basis),QQ).basis() for x in flats[0])


	LinearSpans = set([span(coordinateOfRoots([x for x in flats[0]],basis),QQ).basis()])
#	LinearSpans = set([span(coordinateOfRoots([x for x in flats[0]],alpha),QQ).basis()])

#	print LinearSpans	

	symmetrized  =[]

	print len(toSymmetrize)
	while len(toSymmetrize)>0:
		# Pick the first flat to be symmetrized
		flat = toSymmetrize.pop(-1)
#		print flat

	# Add to flats the (previously unseen) flats obtained by applying the homomorphisms to flat (we will take the simple_reflections). 
	#Here, previously unseen meens that we have not encounter its linear span before. Also add to toSymmetrize these flats and a basis to LinearSpans
		for h in set(homs):
			newFlat = [expand(h(x))*sign(sum([coordinateOfRoots([h(x)],basis)[0][i] for i in range(0,n)])) for x in flat]
#			print newFlat
			newLinear = span(coordinateOfRoots(newFlat,basis),QQ).basis()
#			print newLinear
			if newLinear not in LinearSpans:
				flats.append(set(newFlat))
				LinearSpans.add(newLinear)
#				print flats
#				print LinearSpans
#				print len(toSymmetrize)
			if set(newFlat) not in toSymmetrize and set(newFlat) not in symmetrized:
				toSymmetrize.append(set(newFlat))
#				print toSymmetrize
		#Add flat to the list of symmetrized flats
#		print [flat]
		symmetrized.append(flat)

		print "Found: " + str(len(LinearSpans))
	        print "To symmetrize: " + str(len(toSymmetrize))
	        print "Symmetrized: " + str(len(symmetrized))
	        print " "

	return flats