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
