def bruhat_operator(g, alpha, perm_vector):
	sign = 1
	if sum(alpha) < 0:
		alpha = (-1)*alpha
		sign = -1
		
	perm_alpha = root2perm(alpha)
	new_vector = np.array([0 for i in perm_vector])
	for i in (np.nonzero(perm_vector))[0]:
		possible = pf.perm_mult(g.perm_list[i], perm_alpha)
		if pf.perm_length(possible) == pf.perm_length(g.perm_list[i]) + 1:
			new_vector[g.perm_list.index(possible)] += sign*perm_vector[i]
	return new_vector
Beispiel #2
0
	def __init__(self, classical_type, m1, m2, n):
		if m1+m2>=n:
			raise ValueError('Invalid input: m1 + m2 must be less than n.')

		self.type = classical_type
		self.m1 = m1
		self.m2 = m2
		self.n = n
		self.perm_list = []
		self.left_multiplication = True
		
		f = lambda x: [[y for j, y in enumerate(x) if (i >> j) & 1] for i in range(2**len(x))]
		def add_negs(L):
			return [sorted([-x for x in neg_set])+sorted(list_minus(L, neg_set)) for neg_set in f(L)]

		if self.type in ['B','C']:
			base_set = range(1,n+1)
			left = combinations(base_set, m1)
			for L in left:
				middle = combinations(list_minus(base_set,L), m2)
				for pos_M in middle:
					remaining = list_minus(base_set,L+pos_M)
					for M in add_negs(pos_M):
						for R in add_negs(remaining):
							self.perm_list.append(list(L)+list(M)+list(R))

		if self.type == 'A':
			base_set = range(1,n+1)
			left = combinations(base_set, m1)
			for L in left:
				middle = combinations(list_minus(base_set,L), m2)
				for M in middle:
					self.perm_list.append(list(L)+list(M)+sorted(list_minus(base_set,L+M)))

		self.dimension = pf.perm_length(self.type,self.perm_list[len(self.perm_list)-1])
		if query_yes_no('Build intersection matrix for this flag variety?'):
			self.build_intersection_matrix()
Beispiel #3
0
def simple_neighbors(g,sigma):
 	print str(sigma) + ' has length ' + str(pf.perm_length(g.type,sigma))
 	for u in simple_reflections():
 		v = pf.perm_mult(u,sigma)
 		print 'left multiplication by ' + str(u) + ' yields ' + str(v) + ' which has length ' + str(pf.perm_length(g.type,v))  
Beispiel #4
0
	def codim(self, P):
		if self.involve:
			return self.dimension - self.dim(P)
		else: 
			return pf.perm_length(self.type,self.index2perm(P))
Beispiel #5
0
	def dim(self, V):
		return pf.perm_length(self.type,V)