def basis(self, degree=None): r""" The basis elements (optionally: of the specified degree). OUTPUT: Family EXAMPLES:: sage: FSym = algebras.FSym(QQ) sage: TG = FSym.G() sage: TG.basis() Lazy family (Term map from Standard tableaux to Hopf algebra of standard tableaux over the Rational Field in the Fundamental basis(i))_{i in Standard tableaux} sage: TG.basis().keys() Standard tableaux sage: TG.basis(degree=3).keys() Standard tableaux of size 3 sage: TG.basis(degree=3).list() [G[123], G[13|2], G[12|3], G[1|2|3]] """ from sage.combinat.family import Family if degree is None: return Family(self._indices, self.monomial) else: return Family(StandardTableaux(degree), self.monomial)
def fundamental_weights(self): """ EXAMPLES:: sage: e = RootSystem(['E',6]).ambient_space() sage: e.fundamental_weights() Finite family {1: (0, 0, 0, 0, 0, -2/3, -2/3, 2/3), 2: (1/2, 1/2, 1/2, 1/2, 1/2, -1/2, -1/2, 1/2), 3: (-1/2, 1/2, 1/2, 1/2, 1/2, -5/6, -5/6, 5/6), 4: (0, 0, 1, 1, 1, -1, -1, 1), 5: (0, 0, 0, 1, 1, -2/3, -2/3, 2/3), 6: (0, 0, 0, 0, 1, -1/3, -1/3, 1/3)} """ v2 = ZZ(1)/ZZ(2) v3 = ZZ(1)/ZZ(3) if self.rank == 6: return Family({ 1: 2*v3*self.root(7,6,5,p2=1,p3=1), 2: v2*self.root(0,1,2,3,4,5,6,7,p6=1,p7=1), 3: 5*v2*v3*self.root(7,6,5,p2=1,p3=1)+v2*self.root(0,1,2,3,4,p1=1), 4: self.root(2,3,4,5,6,7,p4=1,p5=1), 5: 2*v3*self.root(7,6,5,p2=1,p3=1)+self.root(3,4), 6: v3*self.root(7,6,5,p2=1,p3=1)+self.root(4)}) elif self.rank == 7: return Family({ 1: self.root(7,6,p2=1), 2: v2*self.root(0,1,2,3,4,5)+self.root(6,7,p1=1), 3: v2*(self.root(0,1,2,3,4,5,p1=1)+3*self.root(6,7,p1=1)), 4: self.root(2,3,4,5)+2*self.root(6,7,p1=1), 5: 3*v2*self.root(6,7,p1=1)+self.root(3,4,5), 6: self.root(4,5,6,7,p3=1), 7: self.root(5)+v2*self.root(6,7,p1=1)}) elif self.rank == 8: return Family({ 1: 2*self.root(7), 2: v2*(self.root(0,1,2,3,4,5,6)+5*self.root(7)), 3: v2*(self.root(0,1,2,3,4,5,6,p1=1)+7*self.root(7)), 4: self.root(2,3,4,5,6)+5*self.root(7), 5: self.root(3,4,5,6)+4*self.root(7), 6: self.root(4,5,6)+3*self.root(7), 7: self.root(5,6)+2*self.root(7), 8: self.root(6,7)})
def inverse_generators(self): """ This method is only available if q1 and q2 are invertible. In that case, the algebra generators are also invertible and this method returns their inverses. EXAMPLES:: sage: P.<q> = PolynomialRing(QQ) sage: F = Frac(P) sage: H = IwahoriHeckeAlgebraT("A2",q,base_ring=F) sage: [T1,T2]=H.algebra_generators() sage: [U1,U2]=H.inverse_generators() sage: U1*T1,T1*U1 (1, 1) sage: P1.<q> = LaurentPolynomialRing(QQ) sage: H1 = IwahoriHeckeAlgebraT("A2",q,base_ring=P1,prefix="V") sage: [V1,V2]=H1.algebra_generators() sage: [W1,W2]=H1.inverse_generators() sage: [W1,W2] [(q^-1)*V1 + (-1+q^-1), (q^-1)*V2 + (-1+q^-1)] sage: V1*W1, W2*V2 (1, 1) """ return Family(self.index_set(), self.inverse_generator)
def fundamental_weights(self): """ EXAMPLES:: sage: CartanType(['G',2]).root_system().ambient_space().fundamental_weights() Finite family {1: (1, 0, -1), 2: (2, -1, -1)} """ return Family({1: self([1, 0, -1]), 2: self([2, -1, -1])})
def fundamental_weights(self): r""" Returns the family `(\Lambda_i)_{i\in I}` of the fundamental weights. EXAMPLES:: sage: e = RootSystem(['A',3]).ambient_lattice() sage: f = e.fundamental_weights() sage: [f[i] for i in [1,2,3]] [(1, 0, 0, 0), (1, 1, 0, 0), (1, 1, 1, 0)] """ return Family(self.index_set(), self.fundamental_weight)
def simple_reflections(self): """ Return the family of generators for this Coxeter group. EXAMPLES:: sage: W = CoxeterGroup(['A', 3], implementation='coxeter3') # optional - coxeter3 sage: s = W.simple_reflections() # optional - coxeter3 sage: s[2]*s[1]*s[2] # optional - coxeter3 [2, 1, 2] """ from sage.combinat.family import Family return Family(self.index_set(), lambda i: self([i]))
def fundamental_weights(self): """ Return the fundamental weights of ``self``. EXAMPLES:: sage: e = RootSystem(['F',4]).ambient_space() sage: e.fundamental_weights() Finite family {1: (1, 1, 0, 0), 2: (2, 1, 1, 0), 3: (3/2, 1/2, 1/2, 1/2), 4: (1, 0, 0, 0)} """ v = ZZ(1)/ZZ(2) return Family({ 1: self.monomial(0)+self.monomial(1), 2: 2*self.monomial(0)+self.monomial(1)+self.monomial(2), 3: v*(3*self.monomial(0)+self.monomial(1)+self.monomial(2)+self.monomial(3)), 4: self.monomial(0)})
def fundamental_weights(self): r""" Returns the family `(\Lambda_i)_{i\in I}` of the fundamental weights. EXAMPLES:: sage: e = RootSystem(['A',3]).ambient_lattice() sage: f = e.fundamental_weights() sage: [f[i] for i in [1,2,3]] [(1, 0, 0, 0), (1, 1, 0, 0), (1, 1, 1, 0)] """ if not hasattr(self,"_fundamental_weights"): self._fundamental_weights = Family(self.index_set(), self.fundamental_weight) # self._fundamental_weights.rename("Lambda") # break some doctests. return self._fundamental_weights