Root lattice realizations#
- class sage.combinat.root_system.root_lattice_realizations.RootLatticeRealizations(base, name=None)[source]#
Bases:
Category_over_base_ringThe category of root lattice realizations over a given base ring
A root lattice realization \(L\) over a base ring \(R\) is a free module (or vector space if \(R\) is a field) endowed with an embedding of the root lattice of some root system.
Typical root lattice realizations over \(\ZZ\) include the root lattice, weight lattice, and ambient lattice. Typical root lattice realizations over \(\QQ\) include the root space, weight space, and ambient space.
To describe the embedding, a root lattice realization must implement a method
simple_root()returning for each \(i\) in the index set the image of the simple root \(\alpha_i\) under the embedding.A root lattice realization must further implement a method on elements
scalar(), computing the scalar product with elements of the coroot lattice or coroot space.Using those, this category provides tools for reflections, roots, the Weyl group and its action, …
EXAMPLES:
Here, we consider the root system of type \(A_7\), and embed the root lattice element \(x = \alpha_2 + 2 \alpha_6\) in several root lattice realizations:
sage: R = RootSystem(["A",7]) sage: alpha = R.root_lattice().simple_roots() sage: x = alpha[2] + 2 * alpha[5] sage: L = R.root_space() sage: L(x) alpha[2] + 2*alpha[5] sage: L = R.weight_lattice() sage: L(x) # needs sage.graphs -Lambda[1] + 2*Lambda[2] - Lambda[3] - 2*Lambda[4] + 4*Lambda[5] - 2*Lambda[6] sage: L = R.ambient_space() sage: L(x) (0, 1, -1, 0, 2, -2, 0, 0)
>>> from sage.all import * >>> R = RootSystem(["A",Integer(7)]) >>> alpha = R.root_lattice().simple_roots() >>> x = alpha[Integer(2)] + Integer(2) * alpha[Integer(5)] >>> L = R.root_space() >>> L(x) alpha[2] + 2*alpha[5] >>> L = R.weight_lattice() >>> L(x) # needs sage.graphs -Lambda[1] + 2*Lambda[2] - Lambda[3] - 2*Lambda[4] + 4*Lambda[5] - 2*Lambda[6] >>> L = R.ambient_space() >>> L(x) (0, 1, -1, 0, 2, -2, 0, 0)
We embed the root space element \(x = \alpha_2 + 1/2 \alpha_6\) in several root lattice realizations:
sage: alpha = R.root_space().simple_roots() sage: x = alpha[2] + 1/2 * alpha[5] sage: L = R.weight_space() sage: L(x) # needs sage.graphs -Lambda[1] + 2*Lambda[2] - Lambda[3] - 1/2*Lambda[4] + Lambda[5] - 1/2*Lambda[6] sage: L = R.ambient_space() sage: L(x) (0, 1, -1, 0, 1/2, -1/2, 0, 0)
>>> from sage.all import * >>> alpha = R.root_space().simple_roots() >>> x = alpha[Integer(2)] + Integer(1)/Integer(2) * alpha[Integer(5)] >>> L = R.weight_space() >>> L(x) # needs sage.graphs -Lambda[1] + 2*Lambda[2] - Lambda[3] - 1/2*Lambda[4] + Lambda[5] - 1/2*Lambda[6] >>> L = R.ambient_space() >>> L(x) (0, 1, -1, 0, 1/2, -1/2, 0, 0)
Of course, one can’t embed the root space in the weight lattice:
sage: L = R.weight_lattice() sage: L(x) Traceback (most recent call last): ... TypeError: do not know how to make x (= alpha[2] + 1/2*alpha[5]) an element of self (=Weight lattice of the Root system of type ['A', 7])
>>> from sage.all import * >>> L = R.weight_lattice() >>> L(x) Traceback (most recent call last): ... TypeError: do not know how to make x (= alpha[2] + 1/2*alpha[5]) an element of self (=Weight lattice of the Root system of type ['A', 7])
If \(K_1\) is a subring of \(K_2\), then one could in theory have an embedding from the root space over \(K_1\) to any root lattice realization over \(K_2\); this is not implemented:
sage: K1 = QQ sage: K2 = QQ['q'] sage: L = R.weight_space(K2) sage: alpha = R.root_space(K2).simple_roots() sage: L(alpha[1]) # needs sage.graphs 2*Lambda[1] - Lambda[2] sage: alpha = R.root_space(K1).simple_roots() sage: L(alpha[1]) Traceback (most recent call last): ... TypeError: do not know how to make x (= alpha[1]) an element of self (=Weight space over the Univariate Polynomial Ring in q over Rational Field of the Root system of type ['A', 7])
>>> from sage.all import * >>> K1 = QQ >>> K2 = QQ['q'] >>> L = R.weight_space(K2) >>> alpha = R.root_space(K2).simple_roots() >>> L(alpha[Integer(1)]) # needs sage.graphs 2*Lambda[1] - Lambda[2] >>> alpha = R.root_space(K1).simple_roots() >>> L(alpha[Integer(1)]) Traceback (most recent call last): ... TypeError: do not know how to make x (= alpha[1]) an element of self (=Weight space over the Univariate Polynomial Ring in q over Rational Field of the Root system of type ['A', 7])
By a slight abuse, the embedding of the root lattice is not actually required to be faithful. Typically for an affine root system, the null root of the root lattice is killed in the non extended weight lattice:
sage: R = RootSystem(["A", 3, 1]) sage: delta = R.root_lattice().null_root() # needs sage.graphs sage: L = R.weight_lattice() sage: L(delta) # needs sage.graphs 0
>>> from sage.all import * >>> R = RootSystem(["A", Integer(3), Integer(1)]) >>> delta = R.root_lattice().null_root() # needs sage.graphs >>> L = R.weight_lattice() >>> L(delta) # needs sage.graphs 0
- class ElementMethods[source]#
Bases:
object- affine_orbit()[source]#
The orbit of
selfunder the dot or affine action of the Weyl group.EXAMPLES:
sage: L = RootSystem(['A', 2]).ambient_lattice() sage: sorted(L.rho().dot_orbit()) # the output order is not specified # needs sage.graphs [(-2, 1, 4), (-2, 3, 2), (2, -1, 2), (2, 1, 0), (0, -1, 4), (0, 3, 0)] sage: L = RootSystem(['B',2]).weight_lattice() sage: sorted(L.fundamental_weights()[1].dot_orbit()) # the output order is not specified # needs sage.graphs [-4*Lambda[1], -4*Lambda[1] + 4*Lambda[2], -3*Lambda[1] - 2*Lambda[2], -3*Lambda[1] + 4*Lambda[2], Lambda[1], Lambda[1] - 6*Lambda[2], 2*Lambda[1] - 6*Lambda[2], 2*Lambda[1] - 2*Lambda[2]]
>>> from sage.all import * >>> L = RootSystem(['A', Integer(2)]).ambient_lattice() >>> sorted(L.rho().dot_orbit()) # the output order is not specified # needs sage.graphs [(-2, 1, 4), (-2, 3, 2), (2, -1, 2), (2, 1, 0), (0, -1, 4), (0, 3, 0)] >>> L = RootSystem(['B',Integer(2)]).weight_lattice() >>> sorted(L.fundamental_weights()[Integer(1)].dot_orbit()) # the output order is not specified # needs sage.graphs [-4*Lambda[1], -4*Lambda[1] + 4*Lambda[2], -3*Lambda[1] - 2*Lambda[2], -3*Lambda[1] + 4*Lambda[2], Lambda[1], Lambda[1] - 6*Lambda[2], 2*Lambda[1] - 6*Lambda[2], 2*Lambda[1] - 2*Lambda[2]]
We compare the dot action orbit to the regular orbit:
sage: # needs sage.graphs sage: L = RootSystem(['A', 3]).weight_lattice() sage: len(L.rho().dot_orbit()) 24 sage: len((-L.rho()).dot_orbit()) 1 sage: La = L.fundamental_weights() sage: len(La[1].dot_orbit()) 24 sage: len(La[1].orbit()) 4 sage: len((-L.rho() + La[1]).dot_orbit()) 4 sage: len(La[2].dot_orbit()) 24 sage: len(La[2].orbit()) 6 sage: len((-L.rho() + La[2]).dot_orbit()) 6
>>> from sage.all import * >>> # needs sage.graphs >>> L = RootSystem(['A', Integer(3)]).weight_lattice() >>> len(L.rho().dot_orbit()) 24 >>> len((-L.rho()).dot_orbit()) 1 >>> La = L.fundamental_weights() >>> len(La[Integer(1)].dot_orbit()) 24 >>> len(La[Integer(1)].orbit()) 4 >>> len((-L.rho() + La[Integer(1)]).dot_orbit()) 4 >>> len(La[Integer(2)].dot_orbit()) 24 >>> len(La[Integer(2)].orbit()) 6 >>> len((-L.rho() + La[Integer(2)]).dot_orbit()) 6
- associated_coroot()[source]#
Return the coroot associated to this root.
EXAMPLES:
sage: alpha = RootSystem(["A", 3]).root_space().simple_roots() sage: alpha[1].associated_coroot() # needs sage.graphs alphacheck[1]
>>> from sage.all import * >>> alpha = RootSystem(["A", Integer(3)]).root_space().simple_roots() >>> alpha[Integer(1)].associated_coroot() # needs sage.graphs alphacheck[1]
- associated_reflection()[source]#
Given a positive root
self, return a reduced word for the reflection orthogonal toself.Since the answer is cached, it is a tuple instead of a list.
EXAMPLES:
sage: C3_rl = RootSystem(['C',3]).root_lattice() # needs sage.graphs sage: C3_rl.simple_root(3).weyl_action([1,2]).associated_reflection() # needs sage.graphs (1, 2, 3, 2, 1) sage: C3_rl.simple_root(2).associated_reflection() # needs sage.graphs (2,)
>>> from sage.all import * >>> C3_rl = RootSystem(['C',Integer(3)]).root_lattice() # needs sage.graphs >>> C3_rl.simple_root(Integer(3)).weyl_action([Integer(1),Integer(2)]).associated_reflection() # needs sage.graphs (1, 2, 3, 2, 1) >>> C3_rl.simple_root(Integer(2)).associated_reflection() # needs sage.graphs (2,)
- descents(index_set=None, positive=False)[source]#
Return the descents of pt
EXAMPLES:
sage: space=RootSystem(['A',5]).weight_space() sage: alpha = space.simple_roots() # needs sage.graphs sage: (alpha[1]+alpha[2]+alpha[4]).descents() # needs sage.graphs [3, 5]
>>> from sage.all import * >>> space=RootSystem(['A',Integer(5)]).weight_space() >>> alpha = space.simple_roots() # needs sage.graphs >>> (alpha[Integer(1)]+alpha[Integer(2)]+alpha[Integer(4)]).descents() # needs sage.graphs [3, 5]
- dot_action(w, inverse=False)[source]#
Act on
selfbywusing the dot or affine action.Let \(w\) be an element of the Weyl group. The dot action or affine action is given by:
\[w \bullet \lambda = w (\lambda + \rho) - \rho,\]where \(\rho\) is the sum of the fundamental weights.
INPUT:
w– an element of a Coxeter or Weyl group of the same Cartan type, or a tuple or a list (such as a reduced word) of elements from the index setinverse– a boolean (default:False); whether to act by the inverse element
EXAMPLES:
sage: P = RootSystem(['B',3]).weight_lattice() sage: La = P.fundamental_weights() sage: mu = La[1] + 2*La[2] - 3*La[3] sage: mu.dot_action([1]) # needs sage.graphs -3*Lambda[1] + 4*Lambda[2] - 3*Lambda[3] sage: mu.dot_action([3]) # needs sage.graphs Lambda[1] + Lambda[3] sage: mu.dot_action([1,2,3]) # needs sage.graphs -4*Lambda[1] + Lambda[2] + 3*Lambda[3]
>>> from sage.all import * >>> P = RootSystem(['B',Integer(3)]).weight_lattice() >>> La = P.fundamental_weights() >>> mu = La[Integer(1)] + Integer(2)*La[Integer(2)] - Integer(3)*La[Integer(3)] >>> mu.dot_action([Integer(1)]) # needs sage.graphs -3*Lambda[1] + 4*Lambda[2] - 3*Lambda[3] >>> mu.dot_action([Integer(3)]) # needs sage.graphs Lambda[1] + Lambda[3] >>> mu.dot_action([Integer(1),Integer(2),Integer(3)]) # needs sage.graphs -4*Lambda[1] + Lambda[2] + 3*Lambda[3]
We check that the origin of this action is at \(-\rho\):
sage: all((-P.rho()).dot_action([i]) == -P.rho() # needs sage.graphs ....: for i in P.index_set()) True
>>> from sage.all import * >>> all((-P.rho()).dot_action([i]) == -P.rho() # needs sage.graphs ... for i in P.index_set()) True
REFERENCES:
- dot_orbit()[source]#
The orbit of
selfunder the dot or affine action of the Weyl group.EXAMPLES:
sage: L = RootSystem(['A', 2]).ambient_lattice() sage: sorted(L.rho().dot_orbit()) # the output order is not specified # needs sage.graphs [(-2, 1, 4), (-2, 3, 2), (2, -1, 2), (2, 1, 0), (0, -1, 4), (0, 3, 0)] sage: L = RootSystem(['B',2]).weight_lattice() sage: sorted(L.fundamental_weights()[1].dot_orbit()) # the output order is not specified # needs sage.graphs [-4*Lambda[1], -4*Lambda[1] + 4*Lambda[2], -3*Lambda[1] - 2*Lambda[2], -3*Lambda[1] + 4*Lambda[2], Lambda[1], Lambda[1] - 6*Lambda[2], 2*Lambda[1] - 6*Lambda[2], 2*Lambda[1] - 2*Lambda[2]]
>>> from sage.all import * >>> L = RootSystem(['A', Integer(2)]).ambient_lattice() >>> sorted(L.rho().dot_orbit()) # the output order is not specified # needs sage.graphs [(-2, 1, 4), (-2, 3, 2), (2, -1, 2), (2, 1, 0), (0, -1, 4), (0, 3, 0)] >>> L = RootSystem(['B',Integer(2)]).weight_lattice() >>> sorted(L.fundamental_weights()[Integer(1)].dot_orbit()) # the output order is not specified # needs sage.graphs [-4*Lambda[1], -4*Lambda[1] + 4*Lambda[2], -3*Lambda[1] - 2*Lambda[2], -3*Lambda[1] + 4*Lambda[2], Lambda[1], Lambda[1] - 6*Lambda[2], 2*Lambda[1] - 6*Lambda[2], 2*Lambda[1] - 2*Lambda[2]]
We compare the dot action orbit to the regular orbit:
sage: # needs sage.graphs sage: L = RootSystem(['A', 3]).weight_lattice() sage: len(L.rho().dot_orbit()) 24 sage: len((-L.rho()).dot_orbit()) 1 sage: La = L.fundamental_weights() sage: len(La[1].dot_orbit()) 24 sage: len(La[1].orbit()) 4 sage: len((-L.rho() + La[1]).dot_orbit()) 4 sage: len(La[2].dot_orbit()) 24 sage: len(La[2].orbit()) 6 sage: len((-L.rho() + La[2]).dot_orbit()) 6
>>> from sage.all import * >>> # needs sage.graphs >>> L = RootSystem(['A', Integer(3)]).weight_lattice() >>> len(L.rho().dot_orbit()) 24 >>> len((-L.rho()).dot_orbit()) 1 >>> La = L.fundamental_weights() >>> len(La[Integer(1)].dot_orbit()) 24 >>> len(La[Integer(1)].orbit()) 4 >>> len((-L.rho() + La[Integer(1)]).dot_orbit()) 4 >>> len(La[Integer(2)].dot_orbit()) 24 >>> len(La[Integer(2)].orbit()) 6 >>> len((-L.rho() + La[Integer(2)]).dot_orbit()) 6
- extraspecial_pair()[source]#
Return the extraspecial pair of
selfunder the ordering defined bypositive_roots_by_height().The extraspecial pair of a positive root \(\gamma\) with some total ordering \(<\) of the root lattice that respects height is the pair of positive roots \((\alpha, \beta)\) such that \(\gamma = \alpha + \beta\) and \(\alpha\) is as small as possible.
EXAMPLES:
sage: Q = RootSystem(['G', 2]).root_lattice() sage: Q.highest_root().extraspecial_pair() # needs sage.graphs (alpha[2], 3*alpha[1] + alpha[2])
>>> from sage.all import * >>> Q = RootSystem(['G', Integer(2)]).root_lattice() >>> Q.highest_root().extraspecial_pair() # needs sage.graphs (alpha[2], 3*alpha[1] + alpha[2])
- first_descent(index_set=None, positive=False)[source]#
Return the first descent of pt
One can use the
index_setoption to restrict to the parabolic subgroup indexed byindex_set.EXAMPLES:
sage: # needs sage.graphs sage: space = RootSystem(['A',5]).weight_space() sage: alpha = space.simple_roots() sage: (alpha[1]+alpha[2]+alpha[4]).first_descent() 3 sage: (alpha[1]+alpha[2]+alpha[4]).first_descent([1,2,5]) 5 sage: (alpha[1]+alpha[2]+alpha[4]).first_descent([1,2,5,3,4]) 5
>>> from sage.all import * >>> # needs sage.graphs >>> space = RootSystem(['A',Integer(5)]).weight_space() >>> alpha = space.simple_roots() >>> (alpha[Integer(1)]+alpha[Integer(2)]+alpha[Integer(4)]).first_descent() 3 >>> (alpha[Integer(1)]+alpha[Integer(2)]+alpha[Integer(4)]).first_descent([Integer(1),Integer(2),Integer(5)]) 5 >>> (alpha[Integer(1)]+alpha[Integer(2)]+alpha[Integer(4)]).first_descent([Integer(1),Integer(2),Integer(5),Integer(3),Integer(4)]) 5
- greater()[source]#
Return the elements in the orbit of
selfwhich are greater thanselfin the weak order.EXAMPLES:
sage: L = RootSystem(['A',3]).ambient_lattice() sage: e = L.basis() sage: e[2].greater() [(0, 0, 1, 0), (0, 0, 0, 1)] sage: len(L.rho().greater()) 24 sage: len((-L.rho()).greater()) 1 sage: sorted([len(x.greater()) for x in L.rho().orbit()]) [1, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 5, 5, 6, 6, 6, 8, 8, 8, 8, 12, 12, 12, 24]
>>> from sage.all import * >>> L = RootSystem(['A',Integer(3)]).ambient_lattice() >>> e = L.basis() >>> e[Integer(2)].greater() [(0, 0, 1, 0), (0, 0, 0, 1)] >>> len(L.rho().greater()) 24 >>> len((-L.rho()).greater()) 1 >>> sorted([len(x.greater()) for x in L.rho().orbit()]) [1, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 5, 5, 6, 6, 6, 8, 8, 8, 8, 12, 12, 12, 24]
- has_descent(i, positive=False)[source]#
Test if
selfhas a descent at position \(i\), that is, ifselfis on the strict negative side of the \(i\)-th simple reflection hyperplane.If positive is
True, tests if it is on the strict positive side instead.EXAMPLES:
sage: # needs sage.graphs sage: space = RootSystem(['A',5]).weight_space() sage: alpha = RootSystem(['A',5]).weight_space().simple_roots() sage: [alpha[i].has_descent(1) for i in space.index_set()] [False, True, False, False, False] sage: [(-alpha[i]).has_descent(1) for i in space.index_set()] [True, False, False, False, False] sage: [alpha[i].has_descent(1, True) for i in space.index_set()] [True, False, False, False, False] sage: [(-alpha[i]).has_descent(1, True) for i in space.index_set()] [False, True, False, False, False] sage: (alpha[1]+alpha[2]+alpha[4]).has_descent(3) True sage: (alpha[1]+alpha[2]+alpha[4]).has_descent(1) False sage: (alpha[1]+alpha[2]+alpha[4]).has_descent(1, True) True
>>> from sage.all import * >>> # needs sage.graphs >>> space = RootSystem(['A',Integer(5)]).weight_space() >>> alpha = RootSystem(['A',Integer(5)]).weight_space().simple_roots() >>> [alpha[i].has_descent(Integer(1)) for i in space.index_set()] [False, True, False, False, False] >>> [(-alpha[i]).has_descent(Integer(1)) for i in space.index_set()] [True, False, False, False, False] >>> [alpha[i].has_descent(Integer(1), True) for i in space.index_set()] [True, False, False, False, False] >>> [(-alpha[i]).has_descent(Integer(1), True) for i in space.index_set()] [False, True, False, False, False] >>> (alpha[Integer(1)]+alpha[Integer(2)]+alpha[Integer(4)]).has_descent(Integer(3)) True >>> (alpha[Integer(1)]+alpha[Integer(2)]+alpha[Integer(4)]).has_descent(Integer(1)) False >>> (alpha[Integer(1)]+alpha[Integer(2)]+alpha[Integer(4)]).has_descent(Integer(1), True) True
- height()[source]#
Return the height of
self.The height of a root \(\alpha = \sum_i a_i \alpha_i\) is defined to be \(h(\alpha) := \sum_i a_i\).
EXAMPLES:
sage: Q = RootSystem(['G', 2]).root_lattice() sage: Q.highest_root().height() # needs sage.graphs 5
>>> from sage.all import * >>> Q = RootSystem(['G', Integer(2)]).root_lattice() >>> Q.highest_root().height() # needs sage.graphs 5
- is_dominant(index_set=None, positive=True)[source]#
Return whether
selfis dominant.This is done with respect to the sub–root system indicated by the subset of Dynkin nodes
index_set. Ifindex_setisNone, then the entire Dynkin node set is used. If positive isFalse, then the dominance condition is replaced by antidominance.EXAMPLES:
sage: L = RootSystem(['A',2]).ambient_lattice() sage: Lambda = L.fundamental_weights() sage: [x.is_dominant() for x in Lambda] [True, True] sage: [x.is_dominant(positive=False) for x in Lambda] [False, False] sage: (Lambda[1]-Lambda[2]).is_dominant() False sage: (-Lambda[1]+Lambda[2]).is_dominant() False sage: (Lambda[1]-Lambda[2]).is_dominant([1]) True sage: (Lambda[1]-Lambda[2]).is_dominant([2]) False sage: [x.is_dominant() for x in L.roots()] [False, True, False, False, False, False] sage: [x.is_dominant(positive=False) for x in L.roots()] [False, False, False, False, True, False]
>>> from sage.all import * >>> L = RootSystem(['A',Integer(2)]).ambient_lattice() >>> Lambda = L.fundamental_weights() >>> [x.is_dominant() for x in Lambda] [True, True] >>> [x.is_dominant(positive=False) for x in Lambda] [False, False] >>> (Lambda[Integer(1)]-Lambda[Integer(2)]).is_dominant() False >>> (-Lambda[Integer(1)]+Lambda[Integer(2)]).is_dominant() False >>> (Lambda[Integer(1)]-Lambda[Integer(2)]).is_dominant([Integer(1)]) True >>> (Lambda[Integer(1)]-Lambda[Integer(2)]).is_dominant([Integer(2)]) False >>> [x.is_dominant() for x in L.roots()] [False, True, False, False, False, False] >>> [x.is_dominant(positive=False) for x in L.roots()] [False, False, False, False, True, False]
- is_dominant_weight()[source]#
Test whether
selfis a dominant element of the weight lattice.EXAMPLES:
sage: L = RootSystem(['A',2]).ambient_lattice() sage: Lambda = L.fundamental_weights() sage: [x.is_dominant() for x in Lambda] [True, True] sage: (3*Lambda[1]+Lambda[2]).is_dominant() True sage: (Lambda[1]-Lambda[2]).is_dominant() False sage: (-Lambda[1]+Lambda[2]).is_dominant() False
>>> from sage.all import * >>> L = RootSystem(['A',Integer(2)]).ambient_lattice() >>> Lambda = L.fundamental_weights() >>> [x.is_dominant() for x in Lambda] [True, True] >>> (Integer(3)*Lambda[Integer(1)]+Lambda[Integer(2)]).is_dominant() True >>> (Lambda[Integer(1)]-Lambda[Integer(2)]).is_dominant() False >>> (-Lambda[Integer(1)]+Lambda[Integer(2)]).is_dominant() False
Tests that the scalar products with the coroots are all nonnegative integers. For example, if \(x\) is the sum of a dominant element of the weight lattice plus some other element orthogonal to all coroots, then the implementation correctly reports \(x\) to be a dominant weight:
sage: x = Lambda[1] + L([-1,-1,-1]) sage: x.is_dominant_weight() True
>>> from sage.all import * >>> x = Lambda[Integer(1)] + L([-Integer(1),-Integer(1),-Integer(1)]) >>> x.is_dominant_weight() True
- is_imaginary_root()[source]#
Return
Trueifselfis an imaginary root.A root \(\alpha\) is imaginary if it is not \(W\)-conjugate to a simple root where \(W\) is the corresponding Weyl group.
EXAMPLES:
sage: Q = RootSystem(['B',2,1]).root_lattice() sage: alpha = Q.simple_roots() sage: alpha[0].is_imaginary_root() # needs sage.graphs False sage: elt = alpha[0] + alpha[1] + 2*alpha[2] sage: elt.is_imaginary_root() # needs sage.graphs True
>>> from sage.all import * >>> Q = RootSystem(['B',Integer(2),Integer(1)]).root_lattice() >>> alpha = Q.simple_roots() >>> alpha[Integer(0)].is_imaginary_root() # needs sage.graphs False >>> elt = alpha[Integer(0)] + alpha[Integer(1)] + Integer(2)*alpha[Integer(2)] >>> elt.is_imaginary_root() # needs sage.graphs True
- is_long_root()[source]#
Return
Trueifselfis a long (real) root.EXAMPLES:
sage: Q = RootSystem(['B',2,1]).root_lattice() sage: alpha = Q.simple_roots() sage: alpha[0].is_long_root() # needs sage.graphs True sage: alpha[1].is_long_root() # needs sage.graphs True sage: alpha[2].is_long_root() # needs sage.graphs False
>>> from sage.all import * >>> Q = RootSystem(['B',Integer(2),Integer(1)]).root_lattice() >>> alpha = Q.simple_roots() >>> alpha[Integer(0)].is_long_root() # needs sage.graphs True >>> alpha[Integer(1)].is_long_root() # needs sage.graphs True >>> alpha[Integer(2)].is_long_root() # needs sage.graphs False
- is_parabolic_root(index_set)[source]#
Return whether
rootis in the parabolic subsystem with Dynkin nodesindex_set.This assumes that
selfis a root.INPUT:
index_set– the Dynkin node set of the parabolic subsystem.
Todo
This implementation is only valid in the root or weight lattice
EXAMPLES:
sage: alpha = RootSystem(['A',3]).root_lattice().from_vector(vector([1,1,0])) sage: alpha.is_parabolic_root([1,3]) False sage: alpha.is_parabolic_root([1,2]) True sage: alpha.is_parabolic_root([2]) False
>>> from sage.all import * >>> alpha = RootSystem(['A',Integer(3)]).root_lattice().from_vector(vector([Integer(1),Integer(1),Integer(0)])) >>> alpha.is_parabolic_root([Integer(1),Integer(3)]) False >>> alpha.is_parabolic_root([Integer(1),Integer(2)]) True >>> alpha.is_parabolic_root([Integer(2)]) False
- is_real_root()[source]#
Return
Trueifselfis a real root.A root \(\alpha\) is real if it is \(W\)-conjugate to a simple root where \(W\) is the corresponding Weyl group.
EXAMPLES:
sage: Q = RootSystem(['B',2,1]).root_lattice() sage: alpha = Q.simple_roots() sage: alpha[0].is_real_root() # needs sage.graphs True sage: elt = alpha[0] + alpha[1] + 2*alpha[2] sage: elt.is_real_root() # needs sage.graphs False
>>> from sage.all import * >>> Q = RootSystem(['B',Integer(2),Integer(1)]).root_lattice() >>> alpha = Q.simple_roots() >>> alpha[Integer(0)].is_real_root() # needs sage.graphs True >>> elt = alpha[Integer(0)] + alpha[Integer(1)] + Integer(2)*alpha[Integer(2)] >>> elt.is_real_root() # needs sage.graphs False
- is_short_root()[source]#
Return
Trueifselfis a short (real) root.Returns
Falseunless the parent is an irreducible root system of finite type having two root lengths andselfis of the shorter length. There is no check of whetherselfis actually a root.EXAMPLES:
sage: # needs sage.graphs sage: Q = RootSystem(['C',2]).root_lattice() sage: al = Q.simple_root(1).weyl_action([1,2]); al alpha[1] + alpha[2] sage: al.is_short_root() True sage: bt = Q.simple_root(2).weyl_action([2,1,2]); bt -2*alpha[1] - alpha[2] sage: bt.is_short_root() False sage: RootSystem(['A',2]).root_lattice().simple_root(1).is_short_root() False
>>> from sage.all import * >>> # needs sage.graphs >>> Q = RootSystem(['C',Integer(2)]).root_lattice() >>> al = Q.simple_root(Integer(1)).weyl_action([Integer(1),Integer(2)]); al alpha[1] + alpha[2] >>> al.is_short_root() True >>> bt = Q.simple_root(Integer(2)).weyl_action([Integer(2),Integer(1),Integer(2)]); bt -2*alpha[1] - alpha[2] >>> bt.is_short_root() False >>> RootSystem(['A',Integer(2)]).root_lattice().simple_root(Integer(1)).is_short_root() False
An example in affine type:
sage: # needs sage.graphs sage: Q = RootSystem(['B',2,1]).root_lattice() sage: alpha = Q.simple_roots() sage: alpha[0].is_short_root() False sage: alpha[1].is_short_root() False sage: alpha[2].is_short_root() True
>>> from sage.all import * >>> # needs sage.graphs >>> Q = RootSystem(['B',Integer(2),Integer(1)]).root_lattice() >>> alpha = Q.simple_roots() >>> alpha[Integer(0)].is_short_root() False >>> alpha[Integer(1)].is_short_root() False >>> alpha[Integer(2)].is_short_root() True
- level()[source]#
EXAMPLES:
sage: L = RootSystem(['A',2,1]).weight_lattice() sage: L.rho().level() # needs sage.graphs 3
>>> from sage.all import * >>> L = RootSystem(['A',Integer(2),Integer(1)]).weight_lattice() >>> L.rho().level() # needs sage.graphs 3
- norm_squared()[source]#
Return the norm squared of
selfwith respect to the symmetric form.EXAMPLES:
sage: # needs sage.graphs sage: Q = RootSystem(['B',2,1]).root_lattice() sage: alpha = Q.simple_roots() sage: alpha[1].norm_squared() 4 sage: alpha[2].norm_squared() 2 sage: elt = alpha[0] - 3*alpha[1] + alpha[2] sage: elt.norm_squared() 50 sage: elt = alpha[0] + alpha[1] + 2*alpha[2] sage: elt.norm_squared() 0 sage: Q = RootSystem(CartanType(['A',4,2]).dual()).root_lattice() sage: Qc = RootSystem(['A',4,2]).coroot_lattice() sage: alpha = Q.simple_roots() sage: alphac = Qc.simple_roots() sage: elt = alpha[0] + 2*alpha[1] + 2*alpha[2] sage: eltc = alphac[0] + 2*alphac[1] + 2*alphac[2] sage: elt.norm_squared() # needs sage.graphs 0 sage: eltc.norm_squared() # needs sage.graphs 0
>>> from sage.all import * >>> # needs sage.graphs >>> Q = RootSystem(['B',Integer(2),Integer(1)]).root_lattice() >>> alpha = Q.simple_roots() >>> alpha[Integer(1)].norm_squared() 4 >>> alpha[Integer(2)].norm_squared() 2 >>> elt = alpha[Integer(0)] - Integer(3)*alpha[Integer(1)] + alpha[Integer(2)] >>> elt.norm_squared() 50 >>> elt = alpha[Integer(0)] + alpha[Integer(1)] + Integer(2)*alpha[Integer(2)] >>> elt.norm_squared() 0 >>> Q = RootSystem(CartanType(['A',Integer(4),Integer(2)]).dual()).root_lattice() >>> Qc = RootSystem(['A',Integer(4),Integer(2)]).coroot_lattice() >>> alpha = Q.simple_roots() >>> alphac = Qc.simple_roots() >>> elt = alpha[Integer(0)] + Integer(2)*alpha[Integer(1)] + Integer(2)*alpha[Integer(2)] >>> eltc = alphac[Integer(0)] + Integer(2)*alphac[Integer(1)] + Integer(2)*alphac[Integer(2)] >>> elt.norm_squared() # needs sage.graphs 0 >>> eltc.norm_squared() # needs sage.graphs 0
- orbit()[source]#
The orbit of
selfunder the action of the Weyl group.EXAMPLES:
\(\rho\) is a regular element whose orbit is in bijection with the Weyl group. In particular, it has 6 elements for the symmetric group \(S_3\):
sage: L = RootSystem(["A", 2]).ambient_lattice() sage: sorted(L.rho().orbit()) # the output order is not specified [(1, 2, 0), (1, 0, 2), (2, 1, 0), (2, 0, 1), (0, 1, 2), (0, 2, 1)] sage: L = RootSystem(["A", 3]).weight_lattice() sage: len(L.rho().orbit()) # needs sage.graphs 24 sage: len(L.fundamental_weights()[1].orbit()) # needs sage.graphs 4 sage: len(L.fundamental_weights()[2].orbit()) # needs sage.graphs 6
>>> from sage.all import * >>> L = RootSystem(["A", Integer(2)]).ambient_lattice() >>> sorted(L.rho().orbit()) # the output order is not specified [(1, 2, 0), (1, 0, 2), (2, 1, 0), (2, 0, 1), (0, 1, 2), (0, 2, 1)] >>> L = RootSystem(["A", Integer(3)]).weight_lattice() >>> len(L.rho().orbit()) # needs sage.graphs 24 >>> len(L.fundamental_weights()[Integer(1)].orbit()) # needs sage.graphs 4 >>> len(L.fundamental_weights()[Integer(2)].orbit()) # needs sage.graphs 6
- pred(index_set=None)[source]#
Return the immediate predecessors of
selffor the weak order.INPUT:
index_set– a subset (as a list or iterable) of the nodes of the Dynkin diagram; (default:Nonefor all of them)
If
index_setis specified, the successors for the corresponding parabolic subsystem are returned.EXAMPLES:
sage: L = RootSystem(['A',3]).weight_lattice() sage: Lambda = L.fundamental_weights() sage: Lambda[1].pred() [] sage: L.rho().pred() [] sage: (-L.rho()).pred() # needs sage.graphs [Lambda[1] - 2*Lambda[2] - Lambda[3], -2*Lambda[1] + Lambda[2] - 2*Lambda[3], -Lambda[1] - 2*Lambda[2] + Lambda[3]] sage: (-L.rho()).pred(index_set=[1]) # needs sage.graphs [Lambda[1] - 2*Lambda[2] - Lambda[3]]
>>> from sage.all import * >>> L = RootSystem(['A',Integer(3)]).weight_lattice() >>> Lambda = L.fundamental_weights() >>> Lambda[Integer(1)].pred() [] >>> L.rho().pred() [] >>> (-L.rho()).pred() # needs sage.graphs [Lambda[1] - 2*Lambda[2] - Lambda[3], -2*Lambda[1] + Lambda[2] - 2*Lambda[3], -Lambda[1] - 2*Lambda[2] + Lambda[3]] >>> (-L.rho()).pred(index_set=[Integer(1)]) # needs sage.graphs [Lambda[1] - 2*Lambda[2] - Lambda[3]]
- reduced_word(index_set=None, positive=True)[source]#
Return a reduced word for the inverse of the shortest Weyl group element that sends the vector
selfinto the dominant chamber.With the
index_setoptional parameter, this is done with respect to the corresponding parabolic subgroup.If
positiveis False, use the antidominant chamber instead.EXAMPLES:
sage: space = RootSystem(['A',5]).weight_space() sage: alpha = RootSystem(['A',5]).weight_space().simple_roots() # needs sage.graphs sage: alpha[1].reduced_word() # needs sage.graphs [2, 3, 4, 5] sage: alpha[1].reduced_word([1,2]) # needs sage.graphs [2]
>>> from sage.all import * >>> space = RootSystem(['A',Integer(5)]).weight_space() >>> alpha = RootSystem(['A',Integer(5)]).weight_space().simple_roots() # needs sage.graphs >>> alpha[Integer(1)].reduced_word() # needs sage.graphs [2, 3, 4, 5] >>> alpha[Integer(1)].reduced_word([Integer(1),Integer(2)]) # needs sage.graphs [2]
- reflection(root, use_coroot=False)[source]#
Reflect
selfacross the hyperplane orthogonal toroot.If
use_corootisTrue,rootis interpreted as a coroot.EXAMPLES:
sage: R = RootSystem(['C',4]) sage: weight_lattice = R.weight_lattice() sage: mu = weight_lattice.from_vector(vector([0,0,1,2])) sage: coroot_lattice = R.coroot_lattice() sage: alphavee = coroot_lattice.from_vector(vector([0,0,1,1])) sage: mu.reflection(alphavee, use_coroot=True) # needs sage.graphs 6*Lambda[2] - 5*Lambda[3] + 2*Lambda[4] sage: root_lattice = R.root_lattice() sage: beta = root_lattice.from_vector(vector([0,1,1,0])) sage: mu.reflection(beta) # needs sage.graphs Lambda[1] - Lambda[2] + 3*Lambda[4]
>>> from sage.all import * >>> R = RootSystem(['C',Integer(4)]) >>> weight_lattice = R.weight_lattice() >>> mu = weight_lattice.from_vector(vector([Integer(0),Integer(0),Integer(1),Integer(2)])) >>> coroot_lattice = R.coroot_lattice() >>> alphavee = coroot_lattice.from_vector(vector([Integer(0),Integer(0),Integer(1),Integer(1)])) >>> mu.reflection(alphavee, use_coroot=True) # needs sage.graphs 6*Lambda[2] - 5*Lambda[3] + 2*Lambda[4] >>> root_lattice = R.root_lattice() >>> beta = root_lattice.from_vector(vector([Integer(0),Integer(1),Integer(1),Integer(0)])) >>> mu.reflection(beta) # needs sage.graphs Lambda[1] - Lambda[2] + 3*Lambda[4]
- scalar(lambdacheck)[source]#
Implement the natural pairing with the coroot lattice.
INPUT:
self– an element of a root lattice realizationlambdacheck– an element of the coroot lattice or coroot space
OUTPUT: the scalar product of
selfandlambdacheckEXAMPLES:
sage: L = RootSystem(['A',4]).root_lattice() sage: alpha = L.simple_roots() sage: alphacheck = L.simple_coroots() sage: alpha[1].scalar(alphacheck[1]) # needs sage.graphs 2 sage: alpha[1].scalar(alphacheck[2]) # needs sage.graphs -1 sage: matrix([ [ alpha[i].scalar(alphacheck[j]) # needs sage.graphs ....: for i in L.index_set() ] ....: for j in L.index_set() ]) [ 2 -1 0 0] [-1 2 -1 0] [ 0 -1 2 -1] [ 0 0 -1 2]
>>> from sage.all import * >>> L = RootSystem(['A',Integer(4)]).root_lattice() >>> alpha = L.simple_roots() >>> alphacheck = L.simple_coroots() >>> alpha[Integer(1)].scalar(alphacheck[Integer(1)]) # needs sage.graphs 2 >>> alpha[Integer(1)].scalar(alphacheck[Integer(2)]) # needs sage.graphs -1 >>> matrix([ [ alpha[i].scalar(alphacheck[j]) # needs sage.graphs ... for i in L.index_set() ] ... for j in L.index_set() ]) [ 2 -1 0 0] [-1 2 -1 0] [ 0 -1 2 -1] [ 0 0 -1 2]
- simple_reflection(i)[source]#
Return the image of
selfby the \(i\)-th simple reflection.EXAMPLES:
sage: alpha = RootSystem(["A", 3]).root_lattice().alpha() sage: alpha[1].simple_reflection(2) # needs sage.graphs alpha[1] + alpha[2] sage: Q = RootSystem(['A', 3, 1]).weight_lattice(extended=True) sage: Lambda = Q.fundamental_weights() sage: L = Lambda[0] + Q.null_root() # needs sage.graphs sage: L.simple_reflection(0) # needs sage.graphs -Lambda[0] + Lambda[1] + Lambda[3]
>>> from sage.all import * >>> alpha = RootSystem(["A", Integer(3)]).root_lattice().alpha() >>> alpha[Integer(1)].simple_reflection(Integer(2)) # needs sage.graphs alpha[1] + alpha[2] >>> Q = RootSystem(['A', Integer(3), Integer(1)]).weight_lattice(extended=True) >>> Lambda = Q.fundamental_weights() >>> L = Lambda[Integer(0)] + Q.null_root() # needs sage.graphs >>> L.simple_reflection(Integer(0)) # needs sage.graphs -Lambda[0] + Lambda[1] + Lambda[3]
- simple_reflections()[source]#
The images of
selfby all the simple reflectionsEXAMPLES:
sage: alpha = RootSystem(["A", 3]).root_lattice().alpha() sage: alpha[1].simple_reflections() # needs sage.graphs [-alpha[1], alpha[1] + alpha[2], alpha[1]]
>>> from sage.all import * >>> alpha = RootSystem(["A", Integer(3)]).root_lattice().alpha() >>> alpha[Integer(1)].simple_reflections() # needs sage.graphs [-alpha[1], alpha[1] + alpha[2], alpha[1]]
- smaller()[source]#
Return the elements in the orbit of
selfwhich are smaller thanselfin the weak order.EXAMPLES:
sage: L = RootSystem(['A',3]).ambient_lattice() sage: e = L.basis() sage: e[2].smaller() [(0, 0, 1, 0), (0, 1, 0, 0), (1, 0, 0, 0)] sage: len(L.rho().smaller()) 1 sage: len((-L.rho()).smaller()) 24 sage: sorted([len(x.smaller()) for x in L.rho().orbit()]) [1, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 5, 5, 6, 6, 6, 8, 8, 8, 8, 12, 12, 12, 24]
>>> from sage.all import * >>> L = RootSystem(['A',Integer(3)]).ambient_lattice() >>> e = L.basis() >>> e[Integer(2)].smaller() [(0, 0, 1, 0), (0, 1, 0, 0), (1, 0, 0, 0)] >>> len(L.rho().smaller()) 1 >>> len((-L.rho()).smaller()) 24 >>> sorted([len(x.smaller()) for x in L.rho().orbit()]) [1, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 5, 5, 6, 6, 6, 8, 8, 8, 8, 12, 12, 12, 24]
- succ(index_set=None)[source]#
Return the immediate successors of
selffor the weak order.INPUT:
index_set– a subset (as a list or iterable) of the nodes of the Dynkin diagram; (default:Nonefor all of them)
If
index_setis specified, the successors for the corresponding parabolic subsystem are returned.EXAMPLES:
sage: # needs sage.graphs sage: L = RootSystem(['A',3]).weight_lattice() sage: Lambda = L.fundamental_weights() sage: Lambda[1].succ() [-Lambda[1] + Lambda[2]] sage: L.rho().succ() [-Lambda[1] + 2*Lambda[2] + Lambda[3], 2*Lambda[1] - Lambda[2] + 2*Lambda[3], Lambda[1] + 2*Lambda[2] - Lambda[3]] sage: (-L.rho()).succ() [] sage: L.rho().succ(index_set=[1]) [-Lambda[1] + 2*Lambda[2] + Lambda[3]] sage: L.rho().succ(index_set=[2]) [2*Lambda[1] - Lambda[2] + 2*Lambda[3]]
>>> from sage.all import * >>> # needs sage.graphs >>> L = RootSystem(['A',Integer(3)]).weight_lattice() >>> Lambda = L.fundamental_weights() >>> Lambda[Integer(1)].succ() [-Lambda[1] + Lambda[2]] >>> L.rho().succ() [-Lambda[1] + 2*Lambda[2] + Lambda[3], 2*Lambda[1] - Lambda[2] + 2*Lambda[3], Lambda[1] + 2*Lambda[2] - Lambda[3]] >>> (-L.rho()).succ() [] >>> L.rho().succ(index_set=[Integer(1)]) [-Lambda[1] + 2*Lambda[2] + Lambda[3]] >>> L.rho().succ(index_set=[Integer(2)]) [2*Lambda[1] - Lambda[2] + 2*Lambda[3]]
- symmetric_form(alpha)[source]#
Return the symmetric form of
selfwithalpha.Consider the simple roots \(\alpha_i\) and let \((b_{ij})_{ij}\) denote the symmetrized Cartan matrix \((a_{ij})_{ij}\), we have
\[(\alpha_i | \alpha_j) = b_{ij}\]and extended bilinearly. See Chapter 6 in Kac, Infinite Dimensional Lie Algebras for more details.
EXAMPLES:
sage: # needs sage.graphs sage: Q = RootSystem(['B',2,1]).root_lattice() sage: alpha = Q.simple_roots() sage: alpha[1].symmetric_form(alpha[0]) 0 sage: alpha[1].symmetric_form(alpha[1]) 4 sage: elt = alpha[0] - 3*alpha[1] + alpha[2] sage: elt.symmetric_form(alpha[1]) -14 sage: elt.symmetric_form(alpha[0]+2*alpha[2]) 14 sage: Q = RootSystem(CartanType(['A',4,2]).dual()).root_lattice() sage: Qc = RootSystem(['A',4,2]).coroot_lattice() sage: alpha = Q.simple_roots() sage: alphac = Qc.simple_roots() sage: elt = alpha[0] + 2*alpha[1] + 2*alpha[2] sage: eltc = alphac[0] + 2*alphac[1] + 2*alphac[2] sage: elt.symmetric_form(alpha[1]) # needs sage.graphs 0 sage: eltc.symmetric_form(alphac[1]) # needs sage.graphs 0
>>> from sage.all import * >>> # needs sage.graphs >>> Q = RootSystem(['B',Integer(2),Integer(1)]).root_lattice() >>> alpha = Q.simple_roots() >>> alpha[Integer(1)].symmetric_form(alpha[Integer(0)]) 0 >>> alpha[Integer(1)].symmetric_form(alpha[Integer(1)]) 4 >>> elt = alpha[Integer(0)] - Integer(3)*alpha[Integer(1)] + alpha[Integer(2)] >>> elt.symmetric_form(alpha[Integer(1)]) -14 >>> elt.symmetric_form(alpha[Integer(0)]+Integer(2)*alpha[Integer(2)]) 14 >>> Q = RootSystem(CartanType(['A',Integer(4),Integer(2)]).dual()).root_lattice() >>> Qc = RootSystem(['A',Integer(4),Integer(2)]).coroot_lattice() >>> alpha = Q.simple_roots() >>> alphac = Qc.simple_roots() >>> elt = alpha[Integer(0)] + Integer(2)*alpha[Integer(1)] + Integer(2)*alpha[Integer(2)] >>> eltc = alphac[Integer(0)] + Integer(2)*alphac[Integer(1)] + Integer(2)*alphac[Integer(2)] >>> elt.symmetric_form(alpha[Integer(1)]) # needs sage.graphs 0 >>> eltc.symmetric_form(alphac[Integer(1)]) # needs sage.graphs 0
- to_ambient()[source]#
Map
selfto the ambient space.EXAMPLES:
sage: B4_rs = CartanType(['B',4]).root_system() sage: alpha = B4_rs.root_lattice().an_element(); alpha 2*alpha[1] + 2*alpha[2] + 3*alpha[3] sage: alpha.to_ambient() (2, 0, 1, -3) sage: mu = B4_rs.weight_lattice().an_element(); mu 2*Lambda[1] + 2*Lambda[2] + 3*Lambda[3] sage: mu.to_ambient() (7, 5, 3, 0) sage: v = B4_rs.ambient_space().an_element(); v (2, 2, 3, 0) sage: v.to_ambient() (2, 2, 3, 0) sage: alphavee = B4_rs.coroot_lattice().an_element(); alphavee 2*alphacheck[1] + 2*alphacheck[2] + 3*alphacheck[3] sage: alphavee.to_ambient() (2, 0, 1, -3)
>>> from sage.all import * >>> B4_rs = CartanType(['B',Integer(4)]).root_system() >>> alpha = B4_rs.root_lattice().an_element(); alpha 2*alpha[1] + 2*alpha[2] + 3*alpha[3] >>> alpha.to_ambient() (2, 0, 1, -3) >>> mu = B4_rs.weight_lattice().an_element(); mu 2*Lambda[1] + 2*Lambda[2] + 3*Lambda[3] >>> mu.to_ambient() (7, 5, 3, 0) >>> v = B4_rs.ambient_space().an_element(); v (2, 2, 3, 0) >>> v.to_ambient() (2, 2, 3, 0) >>> alphavee = B4_rs.coroot_lattice().an_element(); alphavee 2*alphacheck[1] + 2*alphacheck[2] + 3*alphacheck[3] >>> alphavee.to_ambient() (2, 0, 1, -3)
- to_classical()[source]#
Map
selfto the classical lattice/space.Only makes sense for affine type.
EXAMPLES:
sage: R = CartanType(['A',3,1]).root_system() sage: alpha = R.root_lattice().an_element(); alpha 2*alpha[0] + 2*alpha[1] + 3*alpha[2] sage: alb = alpha.to_classical(); alb # needs sage.graphs alpha[2] - 2*alpha[3] sage: alb.parent() # needs sage.graphs Root lattice of the Root system of type ['A', 3] sage: v = R.ambient_space().an_element(); v 2*e[0] + 2*e[1] + 3*e[2] sage: v.to_classical() # needs sage.graphs (2, 2, 3, 0)
>>> from sage.all import * >>> R = CartanType(['A',Integer(3),Integer(1)]).root_system() >>> alpha = R.root_lattice().an_element(); alpha 2*alpha[0] + 2*alpha[1] + 3*alpha[2] >>> alb = alpha.to_classical(); alb # needs sage.graphs alpha[2] - 2*alpha[3] >>> alb.parent() # needs sage.graphs Root lattice of the Root system of type ['A', 3] >>> v = R.ambient_space().an_element(); v 2*e[0] + 2*e[1] + 3*e[2] >>> v.to_classical() # needs sage.graphs (2, 2, 3, 0)
- to_dominant_chamber(index_set=None, positive=True, reduced_word=False)[source]#
Return the unique dominant element in the Weyl group orbit of the vector
self.If
positiveisFalse, returns the antidominant orbit element.With the
index_setoptional parameter, this is done with respect to the corresponding parabolic subgroup.If
reduced_wordisTrue, returns the 2-tuple (weight,direction) whereweightis the (anti)dominant orbit element anddirectionis a reduced word for the Weyl group element sendingweighttoself.Warning
In infinite type, an orbit may not contain a dominant element. In this case the function may go into an infinite loop.
For affine root systems, errors are generated if the orbit does not contain the requested kind of representative. If the input vector is of positive (resp. negative) level, then there is a dominant (resp. antidominant) element in its orbit but not an antidominant (resp. dominant) one. If the vector is of level zero, then there are neither dominant nor antidominant orbit representatives, except for multiples of the null root, which are themselves both dominant and antidominant orbit representatives.
EXAMPLES:
sage: # needs sage.graphs sage: space = RootSystem(['A',5]).weight_space() sage: alpha = RootSystem(['A',5]).weight_space().simple_roots() sage: alpha[1].to_dominant_chamber() Lambda[1] + Lambda[5] sage: alpha[1].to_dominant_chamber([1,2]) Lambda[1] + Lambda[2] - Lambda[3] sage: wl = RootSystem(['A',2,1]).weight_lattice(extended=True) sage: mu = wl.from_vector(vector([1,-3,0])) sage: mu.to_dominant_chamber(positive=False, reduced_word=True) (-Lambda[1] - Lambda[2] - delta, [0, 2]) sage: # needs sage.graphs sage: R = RootSystem(['A',1,1]) sage: rl = R.root_lattice() sage: nu = rl.zero() sage: nu.to_dominant_chamber() 0 sage: nu.to_dominant_chamber(positive=False) 0 sage: mu = rl.from_vector(vector([0,1])) sage: mu.to_dominant_chamber() Traceback (most recent call last): ... ValueError: alpha[1] is not in the orbit of the fundamental chamber sage: mu.to_dominant_chamber(positive=False) Traceback (most recent call last): ... ValueError: alpha[1] is not in the orbit of the negative of the fundamental chamber
>>> from sage.all import * >>> # needs sage.graphs >>> space = RootSystem(['A',Integer(5)]).weight_space() >>> alpha = RootSystem(['A',Integer(5)]).weight_space().simple_roots() >>> alpha[Integer(1)].to_dominant_chamber() Lambda[1] + Lambda[5] >>> alpha[Integer(1)].to_dominant_chamber([Integer(1),Integer(2)]) Lambda[1] + Lambda[2] - Lambda[3] >>> wl = RootSystem(['A',Integer(2),Integer(1)]).weight_lattice(extended=True) >>> mu = wl.from_vector(vector([Integer(1),-Integer(3),Integer(0)])) >>> mu.to_dominant_chamber(positive=False, reduced_word=True) (-Lambda[1] - Lambda[2] - delta, [0, 2]) >>> # needs sage.graphs >>> R = RootSystem(['A',Integer(1),Integer(1)]) >>> rl = R.root_lattice() >>> nu = rl.zero() >>> nu.to_dominant_chamber() 0 >>> nu.to_dominant_chamber(positive=False) 0 >>> mu = rl.from_vector(vector([Integer(0),Integer(1)])) >>> mu.to_dominant_chamber() Traceback (most recent call last): ... ValueError: alpha[1] is not in the orbit of the fundamental chamber >>> mu.to_dominant_chamber(positive=False) Traceback (most recent call last): ... ValueError: alpha[1] is not in the orbit of the negative of the fundamental chamber
- to_dual_type_cospace()[source]#
Map
selfto the dual type cospace.For example, if
selfis in the root lattice of type \(['B',2]\), send it to the coroot lattice of type \(['C',2]\).EXAMPLES:
sage: v = CartanType(['C',3]).root_system().weight_lattice().an_element(); v 2*Lambda[1] + 2*Lambda[2] + 3*Lambda[3] sage: w = v.to_dual_type_cospace(); w 2*Lambdacheck[1] + 2*Lambdacheck[2] + 3*Lambdacheck[3] sage: w.parent() Coweight lattice of the Root system of type ['B', 3]
>>> from sage.all import * >>> v = CartanType(['C',Integer(3)]).root_system().weight_lattice().an_element(); v 2*Lambda[1] + 2*Lambda[2] + 3*Lambda[3] >>> w = v.to_dual_type_cospace(); w 2*Lambdacheck[1] + 2*Lambdacheck[2] + 3*Lambdacheck[3] >>> w.parent() Coweight lattice of the Root system of type ['B', 3]
- to_simple_root(reduced_word=False)[source]#
Return (the index of) a simple root in the orbit of the positive root
self.INPUT:
self– a positive rootreduced_word– a boolean (default:False)
OUTPUT:
The index \(i\) of a simple root \(\alpha_i\). If
reduced_wordisTrue, this returns instead a pair(i, word), where word is a sequence of reflections mapping \(\alpha_i\) up the root poset toself.
EXAMPLES:
sage: L = RootSystem(["A",3]).root_lattice() sage: positive_roots = L.positive_roots() sage: for alpha in sorted(positive_roots): # needs sage.graphs ....: print("{} {}".format(alpha, alpha.to_simple_root())) alpha[1] 1 alpha[1] + alpha[2] 2 alpha[1] + alpha[2] + alpha[3] 3 alpha[2] 2 alpha[2] + alpha[3] 3 alpha[3] 3 sage: for alpha in sorted(positive_roots): # needs sage.graphs ....: print("{} {}".format(alpha, alpha.to_simple_root(reduced_word=True))) alpha[1] (1, ()) alpha[1] + alpha[2] (2, (1,)) alpha[1] + alpha[2] + alpha[3] (3, (1, 2)) alpha[2] (2, ()) alpha[2] + alpha[3] (3, (2,)) alpha[3] (3, ())
>>> from sage.all import * >>> L = RootSystem(["A",Integer(3)]).root_lattice() >>> positive_roots = L.positive_roots() >>> for alpha in sorted(positive_roots): # needs sage.graphs ... print("{} {}".format(alpha, alpha.to_simple_root())) alpha[1] 1 alpha[1] + alpha[2] 2 alpha[1] + alpha[2] + alpha[3] 3 alpha[2] 2 alpha[2] + alpha[3] 3 alpha[3] 3 >>> for alpha in sorted(positive_roots): # needs sage.graphs ... print("{} {}".format(alpha, alpha.to_simple_root(reduced_word=True))) alpha[1] (1, ()) alpha[1] + alpha[2] (2, (1,)) alpha[1] + alpha[2] + alpha[3] (3, (1, 2)) alpha[2] (2, ()) alpha[2] + alpha[3] (3, (2,)) alpha[3] (3, ())
ALGORITHM:
This method walks from
selfdown to the antidominant chamber by applying successively the simple reflection given by the first descent. Sinceselfis a positive root, each step goes down the root poset, and one must eventually cross a simple root \(\alpha_i\).See also
Warning
The behavior is not specified if the input is not a positive root. For a finite root system, this is currently caught (albeit with a not perfect message):
sage: alpha = L.simple_roots() # needs sage.graphs sage: (2*alpha[1]).to_simple_root() # needs sage.graphs Traceback (most recent call last): ... ValueError: -2*alpha[1] - 2*alpha[2] - 2*alpha[3] is not a positive root
>>> from sage.all import * >>> alpha = L.simple_roots() # needs sage.graphs >>> (Integer(2)*alpha[Integer(1)]).to_simple_root() # needs sage.graphs Traceback (most recent call last): ... ValueError: -2*alpha[1] - 2*alpha[2] - 2*alpha[3] is not a positive root
For an infinite root system, this method may run into an infinite recursion if the input is not a positive root.
- translation(x)[source]#
Return \(x\) translated by \(t\), that is, \(x+level(x) t\).
INPUT:
self– an element \(t\) at level \(0\)x– an element of the same space
EXAMPLES:
sage: L = RootSystem(['A',2,1]).weight_lattice() sage: alpha = L.simple_roots() # needs sage.graphs sage: Lambda = L.fundamental_weights() # needs sage.graphs sage: t = alpha[2] # needs sage.graphs
>>> from sage.all import * >>> L = RootSystem(['A',Integer(2),Integer(1)]).weight_lattice() >>> alpha = L.simple_roots() # needs sage.graphs >>> Lambda = L.fundamental_weights() # needs sage.graphs >>> t = alpha[Integer(2)] # needs sage.graphs
Let us look at the translation of an element of level \(1\):
sage: Lambda[1].level() # needs sage.graphs 1 sage: t.translation(Lambda[1]) # needs sage.graphs -Lambda[0] + 2*Lambda[2] sage: Lambda[1] + t # needs sage.graphs -Lambda[0] + 2*Lambda[2]
>>> from sage.all import * >>> Lambda[Integer(1)].level() # needs sage.graphs 1 >>> t.translation(Lambda[Integer(1)]) # needs sage.graphs -Lambda[0] + 2*Lambda[2] >>> Lambda[Integer(1)] + t # needs sage.graphs -Lambda[0] + 2*Lambda[2]
and of an element of level \(0\):
sage: alpha[1].level() # needs sage.graphs 0 sage: t.translation(alpha [1]) # needs sage.graphs -Lambda[0] + 2*Lambda[1] - Lambda[2] sage: alpha[1] + 0*t # needs sage.graphs -Lambda[0] + 2*Lambda[1] - Lambda[2]
>>> from sage.all import * >>> alpha[Integer(1)].level() # needs sage.graphs 0 >>> t.translation(alpha [Integer(1)]) # needs sage.graphs -Lambda[0] + 2*Lambda[1] - Lambda[2] >>> alpha[Integer(1)] + Integer(0)*t # needs sage.graphs -Lambda[0] + 2*Lambda[1] - Lambda[2]
The arguments are given in this seemingly unnatural order to make it easy to construct the translation function:
sage: f = t.translation # needs sage.graphs sage: f(Lambda[1]) # needs sage.graphs -Lambda[0] + 2*Lambda[2]
>>> from sage.all import * >>> f = t.translation # needs sage.graphs >>> f(Lambda[Integer(1)]) # needs sage.graphs -Lambda[0] + 2*Lambda[2]
- weyl_action(element, inverse=False)[source]#
Act on
selfby an element of the Coxeter or Weyl group.INPUT:
element– an element of a Coxeter or Weyl group of the same Cartan type, or a tuple or a list (such as a reduced word) of elements from the index setinverse– a boolean (default:False); whether to act by the inverse element
EXAMPLES:
sage: wl = RootSystem(['A',3]).weight_lattice() sage: mu = wl.from_vector(vector([1,0,-2])) sage: mu Lambda[1] - 2*Lambda[3] sage: mudom, rw = mu.to_dominant_chamber(positive=False, # needs sage.graphs ....: reduced_word=True) sage: mudom, rw # needs sage.graphs (-Lambda[2] - Lambda[3], [1, 2])
>>> from sage.all import * >>> wl = RootSystem(['A',Integer(3)]).weight_lattice() >>> mu = wl.from_vector(vector([Integer(1),Integer(0),-Integer(2)])) >>> mu Lambda[1] - 2*Lambda[3] >>> mudom, rw = mu.to_dominant_chamber(positive=False, # needs sage.graphs ... reduced_word=True) >>> mudom, rw # needs sage.graphs (-Lambda[2] - Lambda[3], [1, 2])
Acting by a (reduced) word:
sage: mudom.weyl_action(rw) # needs sage.graphs Lambda[1] - 2*Lambda[3] sage: mu.weyl_action(rw, inverse=True) # needs sage.graphs -Lambda[2] - Lambda[3]
>>> from sage.all import * >>> mudom.weyl_action(rw) # needs sage.graphs Lambda[1] - 2*Lambda[3] >>> mu.weyl_action(rw, inverse=True) # needs sage.graphs -Lambda[2] - Lambda[3]
Acting by an element of the Coxeter or Weyl group on a vector in its own lattice of definition (implemented by matrix multiplication on a vector):
sage: w = wl.weyl_group().from_reduced_word([1, 2]) # needs sage.graphs sage.libs.gap sage: mudom.weyl_action(w) # needs sage.graphs sage.libs.gap Lambda[1] - 2*Lambda[3]
>>> from sage.all import * >>> w = wl.weyl_group().from_reduced_word([Integer(1), Integer(2)]) # needs sage.graphs sage.libs.gap >>> mudom.weyl_action(w) # needs sage.graphs sage.libs.gap Lambda[1] - 2*Lambda[3]
Acting by an element of an isomorphic Coxeter or Weyl group (implemented by the action of a corresponding reduced word):
sage: # needs sage.libs.gap sage: W = WeylGroup(['A',3], prefix="s") sage: w = W.from_reduced_word([1, 2]) sage: wl.weyl_group() == W False sage: mudom.weyl_action(w) # needs sage.graphs Lambda[1] - 2*Lambda[3]
>>> from sage.all import * >>> # needs sage.libs.gap >>> W = WeylGroup(['A',Integer(3)], prefix="s") >>> w = W.from_reduced_word([Integer(1), Integer(2)]) >>> wl.weyl_group() == W False >>> mudom.weyl_action(w) # needs sage.graphs Lambda[1] - 2*Lambda[3]
- weyl_stabilizer(index_set=None)[source]#
Return the subset of Dynkin nodes whose reflections fix
self.If
index_setis notNone, only consider nodes in this set. Note that ifselfis dominant or antidominant, then its stabilizer is the parabolic subgroup defined by the returned node set.EXAMPLES:
sage: wl = RootSystem(['A',2,1]).weight_lattice(extended=True) sage: al = wl.null_root() # needs sage.graphs sage: al.weyl_stabilizer() # needs sage.graphs [0, 1, 2] sage: wl = RootSystem(['A',4]).weight_lattice() sage: mu = wl.from_vector(vector([1,1,0,0])) sage: mu.weyl_stabilizer() [3, 4] sage: mu.weyl_stabilizer(index_set = [1,2,3]) [3]
>>> from sage.all import * >>> wl = RootSystem(['A',Integer(2),Integer(1)]).weight_lattice(extended=True) >>> al = wl.null_root() # needs sage.graphs >>> al.weyl_stabilizer() # needs sage.graphs [0, 1, 2] >>> wl = RootSystem(['A',Integer(4)]).weight_lattice() >>> mu = wl.from_vector(vector([Integer(1),Integer(1),Integer(0),Integer(0)])) >>> mu.weyl_stabilizer() [3, 4] >>> mu.weyl_stabilizer(index_set = [Integer(1),Integer(2),Integer(3)]) [3]
- class ParentMethods[source]#
Bases:
object- a_long_simple_root()[source]#
Return a long simple root, corresponding to the highest outgoing edge in the Dynkin diagram.
Warning
This may be broken in affine type \(A_{2n}^{(2)}\)
Is it meaningful/broken for non irreducible?
Todo
implement CartanType.nodes_by_length as in MuPAD-Combinat (using CartanType.symmetrizer), and use it here.
- almost_positive_roots()[source]#
Return the almost positive roots of
self.These are the positive roots together with the simple negative roots.
See also
almost_positive_root_decomposition(),tau_plus_minus()EXAMPLES:
sage: L = RootSystem(['A',2]).root_lattice() sage: L.almost_positive_roots() # needs sage.graphs [-alpha[1], alpha[1], alpha[1] + alpha[2], -alpha[2], alpha[2]]
>>> from sage.all import * >>> L = RootSystem(['A',Integer(2)]).root_lattice() >>> L.almost_positive_roots() # needs sage.graphs [-alpha[1], alpha[1], alpha[1] + alpha[2], -alpha[2], alpha[2]]
- almost_positive_roots_decomposition()[source]#
Return the decomposition of the almost positive roots of
self.This is the list of the orbits of the almost positive roots under the action of the dihedral group generated by the operators \(\tau_+\) and \(\tau_-\).
See also
EXAMPLES:
sage: RootSystem(['A',2]).root_lattice().almost_positive_roots_decomposition() # needs sage.graphs sage.libs.gap [[-alpha[1], alpha[1], alpha[1] + alpha[2], alpha[2], -alpha[2]]] sage: RootSystem(['B',2]).root_lattice().almost_positive_roots_decomposition() # needs sage.graphs sage.libs.gap [[-alpha[1], alpha[1], alpha[1] + 2*alpha[2]], [-alpha[2], alpha[2], alpha[1] + alpha[2]]] sage: RootSystem(['D',4]).root_lattice().almost_positive_roots_decomposition() # needs sage.graphs sage.libs.gap [[-alpha[1], alpha[1], alpha[1] + alpha[2], alpha[2] + alpha[3] + alpha[4]], [-alpha[2], alpha[2], alpha[1] + alpha[2] + alpha[3] + alpha[4], alpha[1] + 2*alpha[2] + alpha[3] + alpha[4]], [-alpha[3], alpha[3], alpha[2] + alpha[3], alpha[1] + alpha[2] + alpha[4]], [-alpha[4], alpha[4], alpha[2] + alpha[4], alpha[1] + alpha[2] + alpha[3]]]
>>> from sage.all import * >>> RootSystem(['A',Integer(2)]).root_lattice().almost_positive_roots_decomposition() # needs sage.graphs sage.libs.gap [[-alpha[1], alpha[1], alpha[1] + alpha[2], alpha[2], -alpha[2]]] >>> RootSystem(['B',Integer(2)]).root_lattice().almost_positive_roots_decomposition() # needs sage.graphs sage.libs.gap [[-alpha[1], alpha[1], alpha[1] + 2*alpha[2]], [-alpha[2], alpha[2], alpha[1] + alpha[2]]] >>> RootSystem(['D',Integer(4)]).root_lattice().almost_positive_roots_decomposition() # needs sage.graphs sage.libs.gap [[-alpha[1], alpha[1], alpha[1] + alpha[2], alpha[2] + alpha[3] + alpha[4]], [-alpha[2], alpha[2], alpha[1] + alpha[2] + alpha[3] + alpha[4], alpha[1] + 2*alpha[2] + alpha[3] + alpha[4]], [-alpha[3], alpha[3], alpha[2] + alpha[3], alpha[1] + alpha[2] + alpha[4]], [-alpha[4], alpha[4], alpha[2] + alpha[4], alpha[1] + alpha[2] + alpha[3]]]
- alpha()[source]#
Return the family \((\alpha_i)_{i\in I}\) of the simple roots, with the extra feature that, for simple irreducible root systems, \(\alpha_0\) yields the opposite of the highest root.
EXAMPLES:
sage: alpha = RootSystem(["A",2]).root_lattice().alpha() sage: alpha[1] alpha[1] sage: alpha[0] # needs sage.graphs -alpha[1] - alpha[2]
>>> from sage.all import * >>> alpha = RootSystem(["A",Integer(2)]).root_lattice().alpha() >>> alpha[Integer(1)] alpha[1] >>> alpha[Integer(0)] # needs sage.graphs -alpha[1] - alpha[2]
- alphacheck()[source]#
Return the family \((\alpha^\vee_i)_{i \in I}\) of the simple coroots, with the extra feature that, for simple irreducible root systems, \(\alpha^\vee_0\) yields the coroot associated to the opposite of the highest root (caveat: for non-simply-laced root systems, this is not the opposite of the highest coroot!).
EXAMPLES:
sage: alphacheck = RootSystem(["A",2]).ambient_space().alphacheck() sage: alphacheck Finite family {1: (1, -1, 0), 2: (0, 1, -1)}
>>> from sage.all import * >>> alphacheck = RootSystem(["A",Integer(2)]).ambient_space().alphacheck() >>> alphacheck Finite family {1: (1, -1, 0), 2: (0, 1, -1)}
Here is now \(\alpha^\vee_0\):
(-1, 0, 1)
Todo
add a non simply laced example
Finally, here is an affine example:
sage: RootSystem(["A",2,1]).weight_space().alphacheck() Finite family {0: alphacheck[0], 1: alphacheck[1], 2: alphacheck[2]} sage: RootSystem(["A",3]).ambient_space().alphacheck() Finite family {1: (1, -1, 0, 0), 2: (0, 1, -1, 0), 3: (0, 0, 1, -1)}
>>> from sage.all import * >>> RootSystem(["A",Integer(2),Integer(1)]).weight_space().alphacheck() Finite family {0: alphacheck[0], 1: alphacheck[1], 2: alphacheck[2]} >>> RootSystem(["A",Integer(3)]).ambient_space().alphacheck() Finite family {1: (1, -1, 0, 0), 2: (0, 1, -1, 0), 3: (0, 0, 1, -1)}
- basic_imaginary_roots()[source]#
Return the basic imaginary roots of
self.The basic imaginary roots \(\delta\) are the set of imaginary roots in \(-C^{\vee}\) where \(C\) is the dominant chamber (i.e., \(\langle \beta, \alpha_i^{\vee} \rangle \leq 0\) for all \(i \in I\)). All imaginary roots are \(W\)-conjugate to a simple imaginary root.
EXAMPLES:
sage: RootSystem(['A', 2]).root_lattice().basic_imaginary_roots() () sage: Q = RootSystem(['A', 2, 1]).root_lattice() sage: Q.basic_imaginary_roots() # needs sage.graphs (alpha[0] + alpha[1] + alpha[2],) sage: delta = Q.basic_imaginary_roots()[0] # needs sage.graphs sage: all(delta.scalar(Q.simple_coroot(i)) <= 0 # needs sage.graphs ....: for i in Q.index_set()) True
>>> from sage.all import * >>> RootSystem(['A', Integer(2)]).root_lattice().basic_imaginary_roots() () >>> Q = RootSystem(['A', Integer(2), Integer(1)]).root_lattice() >>> Q.basic_imaginary_roots() # needs sage.graphs (alpha[0] + alpha[1] + alpha[2],) >>> delta = Q.basic_imaginary_roots()[Integer(0)] # needs sage.graphs >>> all(delta.scalar(Q.simple_coroot(i)) <= Integer(0) # needs sage.graphs ... for i in Q.index_set()) True
- cartan_type()[source]#
EXAMPLES:
sage: r = RootSystem(['A',4]).root_space() sage: r.cartan_type() ['A', 4]
>>> from sage.all import * >>> r = RootSystem(['A',Integer(4)]).root_space() >>> r.cartan_type() ['A', 4]
- classical()[source]#
Return the corresponding root/weight/ambient lattice/space.
EXAMPLES:
sage: RootSystem(["A",4,1]).root_lattice().classical() Root lattice of the Root system of type ['A', 4] sage: RootSystem(["A",4,1]).weight_lattice().classical() Weight lattice of the Root system of type ['A', 4] sage: RootSystem(["A",4,1]).ambient_space().classical() Ambient space of the Root system of type ['A', 4]
>>> from sage.all import * >>> RootSystem(["A",Integer(4),Integer(1)]).root_lattice().classical() Root lattice of the Root system of type ['A', 4] >>> RootSystem(["A",Integer(4),Integer(1)]).weight_lattice().classical() Weight lattice of the Root system of type ['A', 4] >>> RootSystem(["A",Integer(4),Integer(1)]).ambient_space().classical() Ambient space of the Root system of type ['A', 4]
- cohighest_root()[source]#
Return the associated coroot of the highest root.
Note
this is usually not the highest coroot.
EXAMPLES:
sage: RootSystem(['A', 3]).ambient_space().cohighest_root() (1, 0, 0, -1)
>>> from sage.all import * >>> RootSystem(['A', Integer(3)]).ambient_space().cohighest_root() (1, 0, 0, -1)
- coroot_lattice()[source]#
Return the coroot lattice.
EXAMPLES:
sage: RootSystem(['A',2]).root_lattice().coroot_lattice() Coroot lattice of the Root system of type ['A', 2]
>>> from sage.all import * >>> RootSystem(['A',Integer(2)]).root_lattice().coroot_lattice() Coroot lattice of the Root system of type ['A', 2]
- coroot_space(base_ring=Rational Field)[source]#
Return the coroot space over
base_ring.INPUT:
base_ring– a ring (default: \(\QQ\))
EXAMPLES:
sage: RootSystem(['A',2]).root_lattice().coroot_space() Coroot space over the Rational Field of the Root system of type ['A', 2] sage: RootSystem(['A',2]).root_lattice().coroot_space(QQ['q']) Coroot space over the Univariate Polynomial Ring in q over Rational Field of the Root system of type ['A', 2]
>>> from sage.all import * >>> RootSystem(['A',Integer(2)]).root_lattice().coroot_space() Coroot space over the Rational Field of the Root system of type ['A', 2] >>> RootSystem(['A',Integer(2)]).root_lattice().coroot_space(QQ['q']) Coroot space over the Univariate Polynomial Ring in q over Rational Field of the Root system of type ['A', 2]
- dual_type_cospace()[source]#
Return the cospace of dual type.
For example, if invoked on the root lattice of type \(['B',2]\), returns the coroot lattice of type \(['C',2]\).
Warning
Not implemented for ambient spaces.
EXAMPLES:
sage: CartanType(['B',2]).root_system().root_lattice().dual_type_cospace() Coroot lattice of the Root system of type ['C', 2] sage: CartanType(['F',4]).root_system().coweight_lattice().dual_type_cospace() Weight lattice of the Root system of type ['F', 4] relabelled by {1: 4, 2: 3, 3: 2, 4: 1}
>>> from sage.all import * >>> CartanType(['B',Integer(2)]).root_system().root_lattice().dual_type_cospace() Coroot lattice of the Root system of type ['C', 2] >>> CartanType(['F',Integer(4)]).root_system().coweight_lattice().dual_type_cospace() Weight lattice of the Root system of type ['F', 4] relabelled by {1: 4, 2: 3, 3: 2, 4: 1}
- dynkin_diagram()[source]#
EXAMPLES:
sage: r = RootSystem(['A',4]).root_space() sage: r.dynkin_diagram() # needs sage.graphs O---O---O---O 1 2 3 4 A4
>>> from sage.all import * >>> r = RootSystem(['A',Integer(4)]).root_space() >>> r.dynkin_diagram() # needs sage.graphs O---O---O---O 1 2 3 4 A4
- fundamental_weights_from_simple_roots()[source]#
Return the fundamental weights.
This is computed from the simple roots by using the inverse of the Cartan matrix. This method is therefore only valid for finite types and if this realization of the root lattice is large enough to contain them.
EXAMPLES:
In the root space, we retrieve the inverse of the Cartan matrix:
sage: L = RootSystem(["B",3]).root_space() sage: L.fundamental_weights_from_simple_roots() # needs sage.graphs Finite family {1: alpha[1] + alpha[2] + alpha[3], 2: alpha[1] + 2*alpha[2] + 2*alpha[3], 3: 1/2*alpha[1] + alpha[2] + 3/2*alpha[3]} sage: ~L.cartan_type().cartan_matrix() # needs sage.graphs [ 1 1 1/2] [ 1 2 1] [ 1 2 3/2]
>>> from sage.all import * >>> L = RootSystem(["B",Integer(3)]).root_space() >>> L.fundamental_weights_from_simple_roots() # needs sage.graphs Finite family {1: alpha[1] + alpha[2] + alpha[3], 2: alpha[1] + 2*alpha[2] + 2*alpha[3], 3: 1/2*alpha[1] + alpha[2] + 3/2*alpha[3]} >>> ~L.cartan_type().cartan_matrix() # needs sage.graphs [ 1 1 1/2] [ 1 2 1] [ 1 2 3/2]
In the weight lattice and the ambient space, we retrieve the fundamental weights:
sage: L = RootSystem(["B",3]).weight_lattice() sage: L.fundamental_weights_from_simple_roots() # needs sage.graphs Finite family {1: Lambda[1], 2: Lambda[2], 3: Lambda[3]} sage: L = RootSystem(["B",3]).ambient_space() sage: L.fundamental_weights() Finite family {1: (1, 0, 0), 2: (1, 1, 0), 3: (1/2, 1/2, 1/2)} sage: L.fundamental_weights_from_simple_roots() # needs sage.graphs Finite family {1: (1, 0, 0), 2: (1, 1, 0), 3: (1/2, 1/2, 1/2)}
>>> from sage.all import * >>> L = RootSystem(["B",Integer(3)]).weight_lattice() >>> L.fundamental_weights_from_simple_roots() # needs sage.graphs Finite family {1: Lambda[1], 2: Lambda[2], 3: Lambda[3]} >>> L = RootSystem(["B",Integer(3)]).ambient_space() >>> L.fundamental_weights() Finite family {1: (1, 0, 0), 2: (1, 1, 0), 3: (1/2, 1/2, 1/2)} >>> L.fundamental_weights_from_simple_roots() # needs sage.graphs Finite family {1: (1, 0, 0), 2: (1, 1, 0), 3: (1/2, 1/2, 1/2)}
However the fundamental weights do not belong to the root lattice:
sage: L = RootSystem(["B",3]).root_lattice() sage: L.fundamental_weights_from_simple_roots() # needs sage.graphs Traceback (most recent call last): ... ValueError: The fundamental weights do not live in this realization of the root lattice
>>> from sage.all import * >>> L = RootSystem(["B",Integer(3)]).root_lattice() >>> L.fundamental_weights_from_simple_roots() # needs sage.graphs Traceback (most recent call last): ... ValueError: The fundamental weights do not live in this realization of the root lattice
Beware of the usual \(GL_n\) vs \(SL_n\) catch in type \(A\):
sage: L = RootSystem(["A",3]).ambient_space() sage: L.fundamental_weights() Finite family {1: (1, 0, 0, 0), 2: (1, 1, 0, 0), 3: (1, 1, 1, 0)} sage: L.fundamental_weights_from_simple_roots() # needs sage.graphs Finite family {1: (3/4, -1/4, -1/4, -1/4), 2: (1/2, 1/2, -1/2, -1/2), 3: (1/4, 1/4, 1/4, -3/4)} sage: L = RootSystem(["A",3]).ambient_lattice() sage: L.fundamental_weights_from_simple_roots() # needs sage.graphs Traceback (most recent call last): ... ValueError: The fundamental weights do not live in this realization of the root lattice
>>> from sage.all import * >>> L = RootSystem(["A",Integer(3)]).ambient_space() >>> L.fundamental_weights() Finite family {1: (1, 0, 0, 0), 2: (1, 1, 0, 0), 3: (1, 1, 1, 0)} >>> L.fundamental_weights_from_simple_roots() # needs sage.graphs Finite family {1: (3/4, -1/4, -1/4, -1/4), 2: (1/2, 1/2, -1/2, -1/2), 3: (1/4, 1/4, 1/4, -3/4)} >>> L = RootSystem(["A",Integer(3)]).ambient_lattice() >>> L.fundamental_weights_from_simple_roots() # needs sage.graphs Traceback (most recent call last): ... ValueError: The fundamental weights do not live in this realization of the root lattice
- generalized_nonnesting_partition_lattice(m, facade=False)[source]#
Return the lattice of \(m\)-nonnesting partitions.
This has been defined by Athanasiadis, see chapter 5 of [Arm06].
INPUT:
\(m\) – integer
See also
EXAMPLES:
sage: R = RootSystem(['A', 2]) sage: RS = R.root_lattice() sage: P = RS.generalized_nonnesting_partition_lattice(2); P # needs sage.graphs Finite lattice containing 12 elements sage: P.coxeter_transformation()**20 == 1 # needs sage.graphs sage.libs.flint True
>>> from sage.all import * >>> R = RootSystem(['A', Integer(2)]) >>> RS = R.root_lattice() >>> P = RS.generalized_nonnesting_partition_lattice(Integer(2)); P # needs sage.graphs Finite lattice containing 12 elements >>> P.coxeter_transformation()**Integer(20) == Integer(1) # needs sage.graphs sage.libs.flint True
- highest_root()[source]#
Return the highest root (for an irreducible finite root system).
EXAMPLES:
sage: RootSystem(['A',4]).ambient_space().highest_root() (1, 0, 0, 0, -1) sage: RootSystem(['E',6]).weight_space().highest_root() # needs sage.graphs Lambda[2]
>>> from sage.all import * >>> RootSystem(['A',Integer(4)]).ambient_space().highest_root() (1, 0, 0, 0, -1) >>> RootSystem(['E',Integer(6)]).weight_space().highest_root() # needs sage.graphs Lambda[2]
- index_set()[source]#
EXAMPLES:
sage: r = RootSystem(['A',4]).root_space() sage: r.index_set() (1, 2, 3, 4)
>>> from sage.all import * >>> r = RootSystem(['A',Integer(4)]).root_space() >>> r.index_set() (1, 2, 3, 4)
- long_roots()[source]#
Return a list of the long roots of
self.EXAMPLES:
sage: L = RootSystem(['B',3]).root_lattice() sage: sorted(L.long_roots()) # needs sage.graphs [-alpha[1], -alpha[1] - 2*alpha[2] - 2*alpha[3], -alpha[1] - alpha[2], -alpha[1] - alpha[2] - 2*alpha[3], alpha[1], alpha[1] + alpha[2], alpha[1] + alpha[2] + 2*alpha[3], alpha[1] + 2*alpha[2] + 2*alpha[3], -alpha[2], -alpha[2] - 2*alpha[3], alpha[2], alpha[2] + 2*alpha[3]]
>>> from sage.all import * >>> L = RootSystem(['B',Integer(3)]).root_lattice() >>> sorted(L.long_roots()) # needs sage.graphs [-alpha[1], -alpha[1] - 2*alpha[2] - 2*alpha[3], -alpha[1] - alpha[2], -alpha[1] - alpha[2] - 2*alpha[3], alpha[1], alpha[1] + alpha[2], alpha[1] + alpha[2] + 2*alpha[3], alpha[1] + 2*alpha[2] + 2*alpha[3], -alpha[2], -alpha[2] - 2*alpha[3], alpha[2], alpha[2] + 2*alpha[3]]
- negative_roots()[source]#
Return the negative roots of
self.EXAMPLES:
sage: L = RootSystem(['A', 2]).weight_lattice() sage: sorted(L.negative_roots()) # needs sage.graphs [-2*Lambda[1] + Lambda[2], -Lambda[1] - Lambda[2], Lambda[1] - 2*Lambda[2]]
>>> from sage.all import * >>> L = RootSystem(['A', Integer(2)]).weight_lattice() >>> sorted(L.negative_roots()) # needs sage.graphs [-2*Lambda[1] + Lambda[2], -Lambda[1] - Lambda[2], Lambda[1] - 2*Lambda[2]]
Algorithm: negate the positive roots
- nonnesting_partition_lattice(facade=False)[source]#
Return the lattice of nonnesting partitions.
This is the lattice of order ideals of the root poset.
This has been defined by Postnikov, see Remark 2 in [Reiner97].
EXAMPLES:
sage: R = RootSystem(['A', 3]) sage: RS = R.root_lattice() sage: P = RS.nonnesting_partition_lattice(); P # needs sage.graphs Finite lattice containing 14 elements sage: P.coxeter_transformation()**10 == 1 # needs sage.graphs sage.libs.flint True sage: # needs sage.graphs sage: R = RootSystem(['B', 3]) sage: RS = R.root_lattice() sage: P = RS.nonnesting_partition_lattice(); P Finite lattice containing 20 elements sage: P.coxeter_transformation()**7 == 1 # needs sage.libs.flint True
>>> from sage.all import * >>> R = RootSystem(['A', Integer(3)]) >>> RS = R.root_lattice() >>> P = RS.nonnesting_partition_lattice(); P # needs sage.graphs Finite lattice containing 14 elements >>> P.coxeter_transformation()**Integer(10) == Integer(1) # needs sage.graphs sage.libs.flint True >>> # needs sage.graphs >>> R = RootSystem(['B', Integer(3)]) >>> RS = R.root_lattice() >>> P = RS.nonnesting_partition_lattice(); P Finite lattice containing 20 elements >>> P.coxeter_transformation()**Integer(7) == Integer(1) # needs sage.libs.flint True
REFERENCES:
[Reiner97]Victor Reiner. Non-crossing partitions for classical reflection groups. Discrete Mathematics 177 (1997)
[Arm06]Drew Armstrong. Generalized Noncrossing Partitions and Combinatorics of Coxeter Groups. arXiv math/0611106
- nonparabolic_positive_root_sum(index_set=None)[source]#
Return the sum of positive roots not in a parabolic subsystem.
The conventions for
index_setare as innonparabolic_positive_roots().EXAMPLES:
sage: Q = RootSystem(['A',3]).root_lattice() sage: Q.nonparabolic_positive_root_sum((1,2)) # needs sage.graphs alpha[1] + 2*alpha[2] + 3*alpha[3] sage: Q.nonparabolic_positive_root_sum() # needs sage.graphs 0 sage: Q.nonparabolic_positive_root_sum(()) # needs sage.graphs 3*alpha[1] + 4*alpha[2] + 3*alpha[3]
>>> from sage.all import * >>> Q = RootSystem(['A',Integer(3)]).root_lattice() >>> Q.nonparabolic_positive_root_sum((Integer(1),Integer(2))) # needs sage.graphs alpha[1] + 2*alpha[2] + 3*alpha[3] >>> Q.nonparabolic_positive_root_sum() # needs sage.graphs 0 >>> Q.nonparabolic_positive_root_sum(()) # needs sage.graphs 3*alpha[1] + 4*alpha[2] + 3*alpha[3]
- nonparabolic_positive_roots(index_set=None)[source]#
Return the positive roots of
selfthat are not in the parabolic subsystem indicated byindex_set.If
index_setisNone, as inpositive_roots()it is assumed to be the entire Dynkin node set. Then the parabolic subsystem consists of all positive roots and the empty list is returned.EXAMPLES:
sage: L = RootSystem(['A',3]).root_lattice() sage: L.nonparabolic_positive_roots() # needs sage.graphs [] sage: sorted(L.nonparabolic_positive_roots((1,2))) # needs sage.graphs [alpha[1] + alpha[2] + alpha[3], alpha[2] + alpha[3], alpha[3]] sage: sorted(L.nonparabolic_positive_roots(())) # needs sage.graphs [alpha[1], alpha[1] + alpha[2], alpha[1] + alpha[2] + alpha[3], alpha[2], alpha[2] + alpha[3], alpha[3]]
>>> from sage.all import * >>> L = RootSystem(['A',Integer(3)]).root_lattice() >>> L.nonparabolic_positive_roots() # needs sage.graphs [] >>> sorted(L.nonparabolic_positive_roots((Integer(1),Integer(2)))) # needs sage.graphs [alpha[1] + alpha[2] + alpha[3], alpha[2] + alpha[3], alpha[3]] >>> sorted(L.nonparabolic_positive_roots(())) # needs sage.graphs [alpha[1], alpha[1] + alpha[2], alpha[1] + alpha[2] + alpha[3], alpha[2], alpha[2] + alpha[3], alpha[3]]
- null_coroot()[source]#
Return the null coroot of
self.The null coroot is the smallest non trivial positive coroot which is orthogonal to all simple roots. It exists for any affine root system.
EXAMPLES:
sage: RootSystem(['C',2,1]).root_lattice().null_coroot() # needs sage.graphs alphacheck[0] + alphacheck[1] + alphacheck[2] sage: RootSystem(['D',4,1]).root_lattice().null_coroot() # needs sage.graphs alphacheck[0] + alphacheck[1] + 2*alphacheck[2] + alphacheck[3] + alphacheck[4] sage: RootSystem(['F',4,1]).root_lattice().null_coroot() # needs sage.graphs alphacheck[0] + 2*alphacheck[1] + 3*alphacheck[2] + 2*alphacheck[3] + alphacheck[4]
>>> from sage.all import * >>> RootSystem(['C',Integer(2),Integer(1)]).root_lattice().null_coroot() # needs sage.graphs alphacheck[0] + alphacheck[1] + alphacheck[2] >>> RootSystem(['D',Integer(4),Integer(1)]).root_lattice().null_coroot() # needs sage.graphs alphacheck[0] + alphacheck[1] + 2*alphacheck[2] + alphacheck[3] + alphacheck[4] >>> RootSystem(['F',Integer(4),Integer(1)]).root_lattice().null_coroot() # needs sage.graphs alphacheck[0] + 2*alphacheck[1] + 3*alphacheck[2] + 2*alphacheck[3] + alphacheck[4]
- null_root()[source]#
Return the null root of
self.The null root is the smallest non trivial positive root which is orthogonal to all simple coroots. It exists for any affine root system.
EXAMPLES:
sage: RootSystem(['C',2,1]).root_lattice().null_root() # needs sage.graphs alpha[0] + 2*alpha[1] + alpha[2] sage: RootSystem(['D',4,1]).root_lattice().null_root() # needs sage.graphs alpha[0] + alpha[1] + 2*alpha[2] + alpha[3] + alpha[4] sage: RootSystem(['F',4,1]).root_lattice().null_root() # needs sage.graphs alpha[0] + 2*alpha[1] + 3*alpha[2] + 4*alpha[3] + 2*alpha[4]
>>> from sage.all import * >>> RootSystem(['C',Integer(2),Integer(1)]).root_lattice().null_root() # needs sage.graphs alpha[0] + 2*alpha[1] + alpha[2] >>> RootSystem(['D',Integer(4),Integer(1)]).root_lattice().null_root() # needs sage.graphs alpha[0] + alpha[1] + 2*alpha[2] + alpha[3] + alpha[4] >>> RootSystem(['F',Integer(4),Integer(1)]).root_lattice().null_root() # needs sage.graphs alpha[0] + 2*alpha[1] + 3*alpha[2] + 4*alpha[3] + 2*alpha[4]
- plot(roots='simple', coroots=False, reflection_hyperplanes='simple', fundamental_weights=None, fundamental_chamber=None, alcoves=None, alcove_labels=False, alcove_walk=None, **options)[source]#
Return a picture of this root lattice realization.
INPUT:
roots– which roots to display, if any. Can be one of the following:"simple"– The simple roots (the default)"classical"– Not yet implemented"all"– Only works in the finite caseA list or tuple of roots
False
coroots– which coroots to display, if any. Can be one of the following:"simple"– The simple coroots (the default)"classical"– Not yet implemented"all"– Only works in the finite caseA list or tuple of coroots
False
fundamental_weights– a boolean orNone(default:None) whether to display the fundamental weights. IfNone, the fundamental weights are drawn if available.reflection_hyperplanes– which reflection hyperplanes to display, if any. Can be one of the following:"simple"– The simple roots"classical"– Not yet implemented"all"– Only works in the finite caseA list or tuple of roots
False(the default)
fundamental_chamber– whether and how to draw the fundamental chamber. Can be one of the following:A boolean – Set to
Trueto draw the fundamental chamber"classical"– Draw the classical fundamental chamberNone– (the default) The fundamental chamber is drawn except in the root lattice where this is not yet implemented. For affine types the classical fundamental chamber is drawn instead.
alcoves– one of the following (default:True):A boolean – Whether to display the alcoves
A list of alcoves – The alcoves to be drawn. Each alcove is specified by the coordinates of its center in the root lattice (affine type only). Otherwise the alcoves that intersect the bounding box are drawn.
alcove_labels– one of the following (default:False):A boolean – Whether to display the elements of the Weyl group indexing the alcoves. This currently requires to also set the
alcovesoption.A number \(l\) – The label is drawn at level \(l\) (affine type only), which only makes sense if
affineisFalse.
bounding_box– a rational number or a list of pairs thereof (default: 3)Specifies a bounding box, in the coordinate system for this plot, in which to plot alcoves and other infinite objects. If the bounding box is a number \(a\), then the bounding box is of the form \([-a,a]\) in all directions. Beware that there can be some border effects and the returned graphic is not necessarily strictly contained in the bounding box.
alcove_walk– an alcove walk orNone(default:None)The alcove walk is described by a list (or iterable) of vertices of the Dynkin diagram which specifies which wall is crossed at each step, starting from the fundamental alcove.
projection– one of the following (default:True):True– The default projection for the root lattice realization is used.False– No projection is used.barycentric– A barycentric projection is used.A function – If a function is specified, it should implement a linear (or affine) map taking as input an element of this root lattice realization and returning its desired coordinates in the plot, as a vector with rational coordinates.
color– a function mapping vertices of the Dynkin diagram to colors (default:"black"for 0,"blue"for 1,"red"for 2,"green"for 3)This is used to set the color for the simple roots, fundamental weights, reflection hyperplanes, alcove facets, etc. If the color is
None, the object is not drawn.labels– a boolean (default:True) whether to display labels on the simple roots, fundamental weights, etc.
EXAMPLES:
sage: L = RootSystem(["A",2,1]).ambient_space().plot() # long time, needs sage.plot sage.symbolic
>>> from sage.all import * >>> L = RootSystem(["A",Integer(2),Integer(1)]).ambient_space().plot() # long time, needs sage.plot sage.symbolic
- plot_alcove_walk(word, start=None, foldings=None, color='orange', **options)[source]#
Plot an alcove walk.
INPUT:
word– a list of elements of the index setfoldings– a list of booleans orNone(default:None)start– an element of this space (default:Nonefor \(\rho\))**options– plotting options
See also
plot()for a description of the plotting optionsTutorial: visualizing root systems for a tutorial on root system plotting
EXAMPLES:
An alcove walk of type \(A_2^{(1)}\):
sage: L = RootSystem(["A",2,1]).ambient_space() sage: w1 = [0,2,1,2,0,2,1,0,2,1,2,1,2,0,2,0,1,2,0] sage: p = L.plot_alcoves(bounding_box=5) # long time (5s) # needs sage.plot sage.symbolic sage: p += L.plot_alcove_walk(w1) # long time # needs sage.plot sage.symbolic sage: p # long time # needs sage.plot sage.symbolic Graphics object consisting of 375 graphics primitives
>>> from sage.all import * >>> L = RootSystem(["A",Integer(2),Integer(1)]).ambient_space() >>> w1 = [Integer(0),Integer(2),Integer(1),Integer(2),Integer(0),Integer(2),Integer(1),Integer(0),Integer(2),Integer(1),Integer(2),Integer(1),Integer(2),Integer(0),Integer(2),Integer(0),Integer(1),Integer(2),Integer(0)] >>> p = L.plot_alcoves(bounding_box=Integer(5)) # long time (5s) # needs sage.plot sage.symbolic >>> p += L.plot_alcove_walk(w1) # long time # needs sage.plot sage.symbolic >>> p # long time # needs sage.plot sage.symbolic Graphics object consisting of 375 graphics primitives
The same plot with another alcove walk:
sage: w2 = [2,1,2,0,2,0,2,1,2,0,1,2,1,2,1,0,1,2,0,2,0,1,2,0,2] sage: p += L.plot_alcove_walk(w2, color="orange") # long time, needs sage.plot sage.symbolic
>>> from sage.all import * >>> w2 = [Integer(2),Integer(1),Integer(2),Integer(0),Integer(2),Integer(0),Integer(2),Integer(1),Integer(2),Integer(0),Integer(1),Integer(2),Integer(1),Integer(2),Integer(1),Integer(0),Integer(1),Integer(2),Integer(0),Integer(2),Integer(0),Integer(1),Integer(2),Integer(0),Integer(2)] >>> p += L.plot_alcove_walk(w2, color="orange") # long time, needs sage.plot sage.symbolic
And another with some foldings:
sage: pic = L.plot_alcoves(bounding_box=3) # long time, needs sage.plot sage.symbolic sage: pic += L.plot_alcove_walk([0,1,2,0,2,0,1,2,0,1], # long time (3s), needs sage.plot sage.symbolic ....: foldings=[False, False, True, False, False, ....: False, True, False, True, False], ....: color="green"); pic Graphics object consisting of 155 graphics primitives
>>> from sage.all import * >>> pic = L.plot_alcoves(bounding_box=Integer(3)) # long time, needs sage.plot sage.symbolic >>> pic += L.plot_alcove_walk([Integer(0),Integer(1),Integer(2),Integer(0),Integer(2),Integer(0),Integer(1),Integer(2),Integer(0),Integer(1)], # long time (3s), needs sage.plot sage.symbolic ... foldings=[False, False, True, False, False, ... False, True, False, True, False], ... color="green"); pic Graphics object consisting of 155 graphics primitives
- plot_alcoves(alcoves=True, alcove_labels=False, wireframe=False, **options)[source]#
Plot the alcoves and optionally their labels.
INPUT:
alcoves– a list of alcoves orTrue(default:True)alcove_labels– a boolean or a number specifying at which level to put the label (default:False)**options– Plotting options
See also
plot()for a description of the plotting optionsTutorial: visualizing root systems for a tutorial on root system plotting, and in particular how the alcoves can be specified.
EXAMPLES:
2D plots:
sage: RootSystem(["B",2,1]).ambient_space().plot_alcoves() # long time (3s), needs sage.plot sage.symbolic Graphics object consisting of 228 graphics primitives
>>> from sage.all import * >>> RootSystem(["B",Integer(2),Integer(1)]).ambient_space().plot_alcoves() # long time (3s), needs sage.plot sage.symbolic Graphics object consisting of 228 graphics primitives
3D plots:
sage: RootSystem(["A",2,1]).weight_space() .plot_alcoves(affine=False) # long time (3s), needs sage.plot sage.symbolic Graphics3d Object sage: RootSystem(["G",2,1]).ambient_space().plot_alcoves(affine=False, level=1) # long time (3s), needs sage.plot sage.symbolic Graphics3d Object
>>> from sage.all import * >>> RootSystem(["A",Integer(2),Integer(1)]).weight_space() .plot_alcoves(affine=False) # long time (3s), needs sage.plot sage.symbolic Graphics3d Object >>> RootSystem(["G",Integer(2),Integer(1)]).ambient_space().plot_alcoves(affine=False, level=Integer(1)) # long time (3s), needs sage.plot sage.symbolic Graphics3d Object
Here we plot a single alcove:
sage: L = RootSystem(["A",3,1]).ambient_space() sage: W = L.weyl_group() # needs sage.libs.gap sage: L.plot(alcoves=[W.one()], reflection_hyperplanes=False, bounding_box=2) # needs sage.libs.gap sage.plot sage.symbolic Graphics3d Object
>>> from sage.all import * >>> L = RootSystem(["A",Integer(3),Integer(1)]).ambient_space() >>> W = L.weyl_group() # needs sage.libs.gap >>> L.plot(alcoves=[W.one()], reflection_hyperplanes=False, bounding_box=Integer(2)) # needs sage.libs.gap sage.plot sage.symbolic Graphics3d Object
- plot_bounding_box(**options)[source]#
Plot the bounding box.
INPUT:
**options– Plotting options
This is mostly for testing purposes.
See also
plot()for a description of the plotting optionsTutorial: visualizing root systems for a tutorial on root system plotting
EXAMPLES:
sage: L = RootSystem(["A",2,1]).ambient_space() sage: L.plot_bounding_box() # needs sage.plot sage.symbolic Graphics object consisting of 1 graphics primitive
>>> from sage.all import * >>> L = RootSystem(["A",Integer(2),Integer(1)]).ambient_space() >>> L.plot_bounding_box() # needs sage.plot sage.symbolic Graphics object consisting of 1 graphics primitive
- plot_coroots(collection='simple', **options)[source]#
Plot the (simple/classical) coroots of this root lattice.
INPUT:
collection– which coroots to display. Can be one of the following:"simple"(the default)"classical""all"
**options– Plotting options
See also
plot()for a description of the plotting optionsTutorial: visualizing root systems for a tutorial on root system plotting
EXAMPLES:
sage: RootSystem(["B",3]).ambient_space().plot_coroots() # needs sage.plot sage.symbolic Graphics3d Object
>>> from sage.all import * >>> RootSystem(["B",Integer(3)]).ambient_space().plot_coroots() # needs sage.plot sage.symbolic Graphics3d Object
- plot_crystal(crystal, plot_labels=True, label_color='black', edge_labels=False, circle_size=0.06, circle_thickness=1.6, **options)[source]#
Plot a finite crystal.
INPUT:
crystal– the finite crystal to plotplot_labels– (default:True) can be one of the following:True– use the latex labels'circles'– use circles for multiplicity up to 4; if the multiplicity is larger, then it uses the multiplicity'multiplicities'– use the multiplicities
label_color– (default:'black') the color of the labelsedge_labels– (default:False) ifTrue, then draw in the edge labelcircle_size– (default: 0.06) the size of the circlescircle_thickness– (default: 1.6) the thinkness of the extra rings of circles**options– plotting options
See also
plot()for a description of the plotting optionsTutorial: visualizing root systems for a tutorial on root system plotting
EXAMPLES:
sage: # needs sage.combinat sage.plot sage.symbolic sage: L = RootSystem(['A',2]).ambient_space() sage: C = crystals.Tableaux(['A',2], shape=[2,1]) sage: L.plot_crystal(C, plot_labels='multiplicities') Graphics object consisting of 15 graphics primitives sage: C = crystals.Tableaux(['A',2], shape=[8,4]) sage: p = L.plot_crystal(C, plot_labels='circles') sage: p.show(figsize=15)
>>> from sage.all import * >>> # needs sage.combinat sage.plot sage.symbolic >>> L = RootSystem(['A',Integer(2)]).ambient_space() >>> C = crystals.Tableaux(['A',Integer(2)], shape=[Integer(2),Integer(1)]) >>> L.plot_crystal(C, plot_labels='multiplicities') Graphics object consisting of 15 graphics primitives >>> C = crystals.Tableaux(['A',Integer(2)], shape=[Integer(8),Integer(4)]) >>> p = L.plot_crystal(C, plot_labels='circles') >>> p.show(figsize=Integer(15))
A 3-dimensional example:
sage: L = RootSystem(['B',3]).ambient_space() sage: C = crystals.Tableaux(['B',3], shape=[2,1]) # needs sage.combinat sage: L.plot_crystal(C, plot_labels='circles', # long time # needs sage.combinat sage.plot sage.symbolic ....: edge_labels=True) Graphics3d Object
>>> from sage.all import * >>> L = RootSystem(['B',Integer(3)]).ambient_space() >>> C = crystals.Tableaux(['B',Integer(3)], shape=[Integer(2),Integer(1)]) # needs sage.combinat >>> L.plot_crystal(C, plot_labels='circles', # long time # needs sage.combinat sage.plot sage.symbolic ... edge_labels=True) Graphics3d Object
- plot_fundamental_chamber(style='normal', **options)[source]#
Plot the (classical) fundamental chamber.
INPUT:
style–"normal"or"classical"(default:"normal")**options– Plotting options
See also
plot()for a description of the plotting optionsTutorial: visualizing root systems for a tutorial on root system plotting
EXAMPLES:
2D plots:
sage: RootSystem(["B",2]).ambient_space().plot_fundamental_chamber() # needs sage.plot Graphics object consisting of 1 graphics primitive sage: RootSystem(["B",2,1]).ambient_space().plot_fundamental_chamber() # needs sage.plot Graphics object consisting of 1 graphics primitive sage: RootSystem(["B",2,1]).ambient_space().plot_fundamental_chamber("classical") # needs sage.plot Graphics object consisting of 1 graphics primitive
>>> from sage.all import * >>> RootSystem(["B",Integer(2)]).ambient_space().plot_fundamental_chamber() # needs sage.plot Graphics object consisting of 1 graphics primitive >>> RootSystem(["B",Integer(2),Integer(1)]).ambient_space().plot_fundamental_chamber() # needs sage.plot Graphics object consisting of 1 graphics primitive >>> RootSystem(["B",Integer(2),Integer(1)]).ambient_space().plot_fundamental_chamber("classical") # needs sage.plot Graphics object consisting of 1 graphics primitive
3D plots:
sage: RootSystem(["A",3,1]).weight_space() .plot_fundamental_chamber() # needs sage.plot Graphics3d Object sage: RootSystem(["B",3,1]).ambient_space().plot_fundamental_chamber() # needs sage.plot Graphics3d Object
>>> from sage.all import * >>> RootSystem(["A",Integer(3),Integer(1)]).weight_space() .plot_fundamental_chamber() # needs sage.plot Graphics3d Object >>> RootSystem(["B",Integer(3),Integer(1)]).ambient_space().plot_fundamental_chamber() # needs sage.plot Graphics3d Object
This feature is currently not available in the root lattice/space:
sage: list(RootSystem(["A",2]).root_lattice().plot_fundamental_chamber()) # needs sage.plot Traceback (most recent call last): ... TypeError: classical fundamental chamber not yet available in the root lattice
>>> from sage.all import * >>> list(RootSystem(["A",Integer(2)]).root_lattice().plot_fundamental_chamber()) # needs sage.plot Traceback (most recent call last): ... TypeError: classical fundamental chamber not yet available in the root lattice
- plot_fundamental_weights(**options)[source]#
Plot the fundamental weights of this root lattice.
INPUT:
**options– Plotting options
See also
plot()for a description of the plotting optionsTutorial: visualizing root systems for a tutorial on root system plotting
EXAMPLES:
sage: RootSystem(["B",3]).ambient_space().plot_fundamental_weights() # needs sage.plot Graphics3d Object
>>> from sage.all import * >>> RootSystem(["B",Integer(3)]).ambient_space().plot_fundamental_weights() # needs sage.plot Graphics3d Object
- plot_hedron(**options)[source]#
Plot the polyhedron whose vertices are given by the orbit of \(\rho\).
In type \(A\), this is the usual permutohedron.
See also
plot()for a description of the plotting optionsTutorial: visualizing root systems for a tutorial on root system plotting
EXAMPLES:
sage: # needs sage.plot sage.symbolic sage: RootSystem(["A",2]).ambient_space().plot_hedron() Graphics object consisting of 8 graphics primitives sage: RootSystem(["A",3]).ambient_space().plot_hedron() Graphics3d Object sage: RootSystem(["B",3]).ambient_space().plot_hedron() Graphics3d Object sage: RootSystem(["C",3]).ambient_space().plot_hedron() Graphics3d Object sage: RootSystem(["D",3]).ambient_space().plot_hedron() Graphics3d Object
>>> from sage.all import * >>> # needs sage.plot sage.symbolic >>> RootSystem(["A",Integer(2)]).ambient_space().plot_hedron() Graphics object consisting of 8 graphics primitives >>> RootSystem(["A",Integer(3)]).ambient_space().plot_hedron() Graphics3d Object >>> RootSystem(["B",Integer(3)]).ambient_space().plot_hedron() Graphics3d Object >>> RootSystem(["C",Integer(3)]).ambient_space().plot_hedron() Graphics3d Object >>> RootSystem(["D",Integer(3)]).ambient_space().plot_hedron() Graphics3d Object
Surprise: polyhedra of large dimension know how to project themselves nicely:
sage: RootSystem(["F",4]).ambient_space().plot_hedron() # long time, needs sage.plot sage.symbolic Graphics3d Object
>>> from sage.all import * >>> RootSystem(["F",Integer(4)]).ambient_space().plot_hedron() # long time, needs sage.plot sage.symbolic Graphics3d Object
- plot_ls_paths(paths, plot_labels=None, colored_labels=True, **options)[source]#
Plot LS paths.
INPUT:
paths– a finite crystal or list of LS pathsplot_labels– (default:None) the distance to plot the LS labels from the endpoint of the path; set toNoneto not display the labelscolored_labels– (default:True) ifTrue, then color the labels the same color as the LS path**options– plotting options
See also
plot()for a description of the plotting optionsTutorial: visualizing root systems for a tutorial on root system plotting
EXAMPLES:
sage: B = crystals.LSPaths(['A',2], [1,1]) # needs sage.combinat sage: L = RootSystem(['A',2]).ambient_space() sage: L.plot_fundamental_weights() + L.plot_ls_paths(B) # needs sage.combinat sage.plot sage.symbolic Graphics object consisting of 14 graphics primitives
>>> from sage.all import * >>> B = crystals.LSPaths(['A',Integer(2)], [Integer(1),Integer(1)]) # needs sage.combinat >>> L = RootSystem(['A',Integer(2)]).ambient_space() >>> L.plot_fundamental_weights() + L.plot_ls_paths(B) # needs sage.combinat sage.plot sage.symbolic Graphics object consisting of 14 graphics primitives
This also works in 3 dimensions:
sage: B = crystals.LSPaths(['B',3], [2,0,0]) # needs sage.combinat sage: L = RootSystem(['B',3]).ambient_space() sage: L.plot_ls_paths(B) # needs sage.combinat sage.plot sage.symbolic Graphics3d Object
>>> from sage.all import * >>> B = crystals.LSPaths(['B',Integer(3)], [Integer(2),Integer(0),Integer(0)]) # needs sage.combinat >>> L = RootSystem(['B',Integer(3)]).ambient_space() >>> L.plot_ls_paths(B) # needs sage.combinat sage.plot sage.symbolic Graphics3d Object
- plot_mv_polytope(mv_polytope, mark_endpoints=True, circle_size=0.06, circle_thickness=1.6, wireframe='blue', fill='green', alpha=1, **options)[source]#
Plot an MV polytope.
INPUT:
mv_polytope– an MV polytopemark_endpoints– (default:True) mark the endpoints of the MV polytopecircle_size– (default: 0.06) the size of the circlescircle_thickness– (default: 1.6) the thinkness of the extra rings of circleswireframe– (default:'blue') color to draw the wireframe of the polytope withfill– (default:'green') color to fill the polytope withalpha– (default: 1) the alpha value (opacity) of the fill**options– plotting options
See also
plot()for a description of the plotting optionsTutorial: visualizing root systems for a tutorial on root system plotting
EXAMPLES:
sage: B = crystals.infinity.MVPolytopes(['C',2]) # needs sage.combinat sage: L = RootSystem(['C',2]).ambient_space() sage: p = B.highest_weight_vector().f_string([1,2,1,2]) # needs sage.combinat sage: L.plot_fundamental_weights() + L.plot_mv_polytope(p) # needs sage.combinat sage.geometry.polyhedron sage.plot sage.symbolic Graphics object consisting of 14 graphics primitives
>>> from sage.all import * >>> B = crystals.infinity.MVPolytopes(['C',Integer(2)]) # needs sage.combinat >>> L = RootSystem(['C',Integer(2)]).ambient_space() >>> p = B.highest_weight_vector().f_string([Integer(1),Integer(2),Integer(1),Integer(2)]) # needs sage.combinat >>> L.plot_fundamental_weights() + L.plot_mv_polytope(p) # needs sage.combinat sage.geometry.polyhedron sage.plot sage.symbolic Graphics object consisting of 14 graphics primitives
This also works in 3 dimensions:
sage: B = crystals.infinity.MVPolytopes(['A',3]) # needs sage.combinat sage: L = RootSystem(['A',3]).ambient_space() sage: p = B.highest_weight_vector().f_string([2,1,3,2]) # needs sage.combinat sage: L.plot_mv_polytope(p) # needs sage.combinat sage.geometry.polyhedron sage.plot sage.symbolic Graphics3d Object
>>> from sage.all import * >>> B = crystals.infinity.MVPolytopes(['A',Integer(3)]) # needs sage.combinat >>> L = RootSystem(['A',Integer(3)]).ambient_space() >>> p = B.highest_weight_vector().f_string([Integer(2),Integer(1),Integer(3),Integer(2)]) # needs sage.combinat >>> L.plot_mv_polytope(p) # needs sage.combinat sage.geometry.polyhedron sage.plot sage.symbolic Graphics3d Object
- plot_parse_options(**args)[source]#
Return an option object to be used for root system plotting.
EXAMPLES:
sage: L = RootSystem(["A",2,1]).ambient_space() sage: options = L.plot_parse_options(); options # needs sage.symbolic <sage.combinat.root_system.plot.PlotOptions object at ...>
>>> from sage.all import * >>> L = RootSystem(["A",Integer(2),Integer(1)]).ambient_space() >>> options = L.plot_parse_options(); options # needs sage.symbolic <sage.combinat.root_system.plot.PlotOptions object at ...>
See also
plot()for a description of the plotting optionsTutorial: visualizing root systems for a tutorial on root system plotting
- plot_reflection_hyperplanes(collection='simple', **options)[source]#
Plot the simple reflection hyperplanes.
INPUT:
collection– which reflection hyperplanes to display. Can be one of the following:"simple"(the default)"classical""all"
**options– Plotting options
See also
plot()for a description of the plotting optionsTutorial: visualizing root systems for a tutorial on root system plotting
EXAMPLES:
sage: # needs sage.plot sage.symbolic sage: RootSystem(["A",2,1]).ambient_space().plot_reflection_hyperplanes() Graphics object consisting of 6 graphics primitives sage: RootSystem(["G",2,1]).ambient_space().plot_reflection_hyperplanes() Graphics object consisting of 6 graphics primitives sage: RootSystem(["A",3]).weight_space().plot_reflection_hyperplanes() Graphics3d Object sage: RootSystem(["B",3]).ambient_space().plot_reflection_hyperplanes() Graphics3d Object sage: RootSystem(["A",3,1]).weight_space().plot_reflection_hyperplanes() Graphics3d Object sage: RootSystem(["B",3,1]).ambient_space().plot_reflection_hyperplanes() Graphics3d Object sage: RootSystem(["A",2,1]).weight_space().plot_reflection_hyperplanes(affine=False, level=1) Graphics3d Object sage: RootSystem(["A",2]).root_lattice().plot_reflection_hyperplanes() Graphics object consisting of 4 graphics primitives
>>> from sage.all import * >>> # needs sage.plot sage.symbolic >>> RootSystem(["A",Integer(2),Integer(1)]).ambient_space().plot_reflection_hyperplanes() Graphics object consisting of 6 graphics primitives >>> RootSystem(["G",Integer(2),Integer(1)]).ambient_space().plot_reflection_hyperplanes() Graphics object consisting of 6 graphics primitives >>> RootSystem(["A",Integer(3)]).weight_space().plot_reflection_hyperplanes() Graphics3d Object >>> RootSystem(["B",Integer(3)]).ambient_space().plot_reflection_hyperplanes() Graphics3d Object >>> RootSystem(["A",Integer(3),Integer(1)]).weight_space().plot_reflection_hyperplanes() Graphics3d Object >>> RootSystem(["B",Integer(3),Integer(1)]).ambient_space().plot_reflection_hyperplanes() Graphics3d Object >>> RootSystem(["A",Integer(2),Integer(1)]).weight_space().plot_reflection_hyperplanes(affine=False, level=Integer(1)) Graphics3d Object >>> RootSystem(["A",Integer(2)]).root_lattice().plot_reflection_hyperplanes() Graphics object consisting of 4 graphics primitives
Todo
Provide an option for transparency?
- plot_roots(collection='simple', **options)[source]#
Plot the (simple/classical) roots of this root lattice.
INPUT:
collection– which roots to display can be one of the following:"simple"(the default)"classical""all"
**options– Plotting options
See also
plot()for a description of the plotting optionsTutorial: visualizing root systems for a tutorial on root system plotting
EXAMPLES:
sage: RootSystem(["B",3]).ambient_space().plot_roots() # needs sage.plot Graphics3d Object sage: RootSystem(["B",3]).ambient_space().plot_roots("all") # needs sage.plot Graphics3d Object
>>> from sage.all import * >>> RootSystem(["B",Integer(3)]).ambient_space().plot_roots() # needs sage.plot Graphics3d Object >>> RootSystem(["B",Integer(3)]).ambient_space().plot_roots("all") # needs sage.plot Graphics3d Object
- positive_imaginary_roots()[source]#
Return the positive imaginary roots of
self.EXAMPLES:
sage: L = RootSystem(['A',3]).root_lattice() sage: L.positive_imaginary_roots() () sage: L = RootSystem(['A',3,1]).root_lattice() sage: PIR = L.positive_imaginary_roots(); PIR # needs sage.graphs Positive imaginary roots of type ['A', 3, 1] sage: [PIR.unrank(i) for i in range(5)] # needs sage.graphs [alpha[0] + alpha[1] + alpha[2] + alpha[3], 2*alpha[0] + 2*alpha[1] + 2*alpha[2] + 2*alpha[3], 3*alpha[0] + 3*alpha[1] + 3*alpha[2] + 3*alpha[3], 4*alpha[0] + 4*alpha[1] + 4*alpha[2] + 4*alpha[3], 5*alpha[0] + 5*alpha[1] + 5*alpha[2] + 5*alpha[3]]
>>> from sage.all import * >>> L = RootSystem(['A',Integer(3)]).root_lattice() >>> L.positive_imaginary_roots() () >>> L = RootSystem(['A',Integer(3),Integer(1)]).root_lattice() >>> PIR = L.positive_imaginary_roots(); PIR # needs sage.graphs Positive imaginary roots of type ['A', 3, 1] >>> [PIR.unrank(i) for i in range(Integer(5))] # needs sage.graphs [alpha[0] + alpha[1] + alpha[2] + alpha[3], 2*alpha[0] + 2*alpha[1] + 2*alpha[2] + 2*alpha[3], 3*alpha[0] + 3*alpha[1] + 3*alpha[2] + 3*alpha[3], 4*alpha[0] + 4*alpha[1] + 4*alpha[2] + 4*alpha[3], 5*alpha[0] + 5*alpha[1] + 5*alpha[2] + 5*alpha[3]]
- positive_real_roots()[source]#
Return the positive real roots of
self.EXAMPLES:
sage: L = RootSystem(['A',3]).root_lattice() sage: sorted(L.positive_real_roots()) # needs sage.graphs [alpha[1], alpha[1] + alpha[2], alpha[1] + alpha[2] + alpha[3], alpha[2], alpha[2] + alpha[3], alpha[3]] sage: L = RootSystem(['A',3,1]).root_lattice() sage: PRR = L.positive_real_roots(); PRR # needs sage.graphs Positive real roots of type ['A', 3, 1] sage: [PRR.unrank(i) for i in range(10)] # needs sage.graphs [alpha[1], alpha[2], alpha[3], alpha[1] + alpha[2], alpha[2] + alpha[3], alpha[1] + alpha[2] + alpha[3], alpha[0] + 2*alpha[1] + alpha[2] + alpha[3], alpha[0] + alpha[1] + 2*alpha[2] + alpha[3], alpha[0] + alpha[1] + alpha[2] + 2*alpha[3], alpha[0] + 2*alpha[1] + 2*alpha[2] + alpha[3]] sage: Q = RootSystem(['A',4,2]).root_lattice() sage: PR = Q.positive_roots() # needs sage.graphs sage: [PR.unrank(i) for i in range(5)] # needs sage.graphs [alpha[1], alpha[2], alpha[1] + alpha[2], 2*alpha[1] + alpha[2], alpha[0] + alpha[1] + alpha[2]] sage: Q = RootSystem(['D',3,2]).root_lattice() sage: PR = Q.positive_roots() # needs sage.graphs sage: [PR.unrank(i) for i in range(5)] # needs sage.graphs [alpha[1], alpha[2], alpha[1] + 2*alpha[2], alpha[1] + alpha[2], alpha[0] + alpha[1] + 2*alpha[2]]
>>> from sage.all import * >>> L = RootSystem(['A',Integer(3)]).root_lattice() >>> sorted(L.positive_real_roots()) # needs sage.graphs [alpha[1], alpha[1] + alpha[2], alpha[1] + alpha[2] + alpha[3], alpha[2], alpha[2] + alpha[3], alpha[3]] >>> L = RootSystem(['A',Integer(3),Integer(1)]).root_lattice() >>> PRR = L.positive_real_roots(); PRR # needs sage.graphs Positive real roots of type ['A', 3, 1] >>> [PRR.unrank(i) for i in range(Integer(10))] # needs sage.graphs [alpha[1], alpha[2], alpha[3], alpha[1] + alpha[2], alpha[2] + alpha[3], alpha[1] + alpha[2] + alpha[3], alpha[0] + 2*alpha[1] + alpha[2] + alpha[3], alpha[0] + alpha[1] + 2*alpha[2] + alpha[3], alpha[0] + alpha[1] + alpha[2] + 2*alpha[3], alpha[0] + 2*alpha[1] + 2*alpha[2] + alpha[3]] >>> Q = RootSystem(['A',Integer(4),Integer(2)]).root_lattice() >>> PR = Q.positive_roots() # needs sage.graphs >>> [PR.unrank(i) for i in range(Integer(5))] # needs sage.graphs [alpha[1], alpha[2], alpha[1] + alpha[2], 2*alpha[1] + alpha[2], alpha[0] + alpha[1] + alpha[2]] >>> Q = RootSystem(['D',Integer(3),Integer(2)]).root_lattice() >>> PR = Q.positive_roots() # needs sage.graphs >>> [PR.unrank(i) for i in range(Integer(5))] # needs sage.graphs [alpha[1], alpha[2], alpha[1] + 2*alpha[2], alpha[1] + alpha[2], alpha[0] + alpha[1] + 2*alpha[2]]
- positive_roots(index_set=None)[source]#
Return the positive roots of
self.If
index_setis notNone, returns the positive roots of the parabolic subsystem with simple roots inindex_set.Algorithm for finite type: generate them from the simple roots by applying successive reflections toward the positive chamber.
EXAMPLES:
sage: L = RootSystem(['A',3]).root_lattice() sage: sorted(L.positive_roots()) # needs sage.graphs [alpha[1], alpha[1] + alpha[2], alpha[1] + alpha[2] + alpha[3], alpha[2], alpha[2] + alpha[3], alpha[3]] sage: sorted(L.positive_roots((1,2))) # needs sage.graphs [alpha[1], alpha[1] + alpha[2], alpha[2]] sage: sorted(L.positive_roots(())) # needs sage.graphs [] sage: L = RootSystem(['A',3,1]).root_lattice() sage: PR = L.positive_roots(); PR # needs sage.graphs Disjoint union of Family (Positive real roots of type ['A', 3, 1], Positive imaginary roots of type ['A', 3, 1]) sage: [PR.unrank(i) for i in range(10)] # needs sage.graphs [alpha[1], alpha[2], alpha[3], alpha[1] + alpha[2], alpha[2] + alpha[3], alpha[1] + alpha[2] + alpha[3], alpha[0] + 2*alpha[1] + alpha[2] + alpha[3], alpha[0] + alpha[1] + 2*alpha[2] + alpha[3], alpha[0] + alpha[1] + alpha[2] + 2*alpha[3], alpha[0] + 2*alpha[1] + 2*alpha[2] + alpha[3]]
>>> from sage.all import * >>> L = RootSystem(['A',Integer(3)]).root_lattice() >>> sorted(L.positive_roots()) # needs sage.graphs [alpha[1], alpha[1] + alpha[2], alpha[1] + alpha[2] + alpha[3], alpha[2], alpha[2] + alpha[3], alpha[3]] >>> sorted(L.positive_roots((Integer(1),Integer(2)))) # needs sage.graphs [alpha[1], alpha[1] + alpha[2], alpha[2]] >>> sorted(L.positive_roots(())) # needs sage.graphs [] >>> L = RootSystem(['A',Integer(3),Integer(1)]).root_lattice() >>> PR = L.positive_roots(); PR # needs sage.graphs Disjoint union of Family (Positive real roots of type ['A', 3, 1], Positive imaginary roots of type ['A', 3, 1]) >>> [PR.unrank(i) for i in range(Integer(10))] # needs sage.graphs [alpha[1], alpha[2], alpha[3], alpha[1] + alpha[2], alpha[2] + alpha[3], alpha[1] + alpha[2] + alpha[3], alpha[0] + 2*alpha[1] + alpha[2] + alpha[3], alpha[0] + alpha[1] + 2*alpha[2] + alpha[3], alpha[0] + alpha[1] + alpha[2] + 2*alpha[3], alpha[0] + 2*alpha[1] + 2*alpha[2] + alpha[3]]
- positive_roots_by_height(increasing=True)[source]#
Return a list of positive roots in increasing order by height.
If
increasingis False, returns them in decreasing order.Warning
Raise an error if the Cartan type is not finite.
EXAMPLES:
sage: L = RootSystem(['C',2]).root_lattice() sage: L.positive_roots_by_height() # needs sage.graphs [alpha[2], alpha[1], alpha[1] + alpha[2], 2*alpha[1] + alpha[2]] sage: L.positive_roots_by_height(increasing=False) # needs sage.graphs [2*alpha[1] + alpha[2], alpha[1] + alpha[2], alpha[2], alpha[1]] sage: L = RootSystem(['A',2,1]).root_lattice() sage: L.positive_roots_by_height() # needs sage.graphs Traceback (most recent call last): ... NotImplementedError: Only implemented for finite Cartan type
>>> from sage.all import * >>> L = RootSystem(['C',Integer(2)]).root_lattice() >>> L.positive_roots_by_height() # needs sage.graphs [alpha[2], alpha[1], alpha[1] + alpha[2], 2*alpha[1] + alpha[2]] >>> L.positive_roots_by_height(increasing=False) # needs sage.graphs [2*alpha[1] + alpha[2], alpha[1] + alpha[2], alpha[2], alpha[1]] >>> L = RootSystem(['A',Integer(2),Integer(1)]).root_lattice() >>> L.positive_roots_by_height() # needs sage.graphs Traceback (most recent call last): ... NotImplementedError: Only implemented for finite Cartan type
- positive_roots_nonparabolic(index_set=None)[source]#
Return the set of positive roots outside the parabolic subsystem with Dynkin node set
index_set.INPUT:
index_set– (default:None) the Dynkin node set of the parabolic subsystem. It should be a tuple. The default value implies the entire Dynkin node set
EXAMPLES:
sage: # needs sage.graphs sage: lattice = RootSystem(['A',3]).root_lattice() sage: sorted(lattice.positive_roots_nonparabolic((1,3)), key=str) [alpha[1] + alpha[2], alpha[1] + alpha[2] + alpha[3], alpha[2], alpha[2] + alpha[3]] sage: sorted(lattice.positive_roots_nonparabolic((2,3)), key=str) [alpha[1], alpha[1] + alpha[2], alpha[1] + alpha[2] + alpha[3]] sage: lattice.positive_roots_nonparabolic() [] sage: lattice.positive_roots_nonparabolic((1,2,3)) []
>>> from sage.all import * >>> # needs sage.graphs >>> lattice = RootSystem(['A',Integer(3)]).root_lattice() >>> sorted(lattice.positive_roots_nonparabolic((Integer(1),Integer(3))), key=str) [alpha[1] + alpha[2], alpha[1] + alpha[2] + alpha[3], alpha[2], alpha[2] + alpha[3]] >>> sorted(lattice.positive_roots_nonparabolic((Integer(2),Integer(3))), key=str) [alpha[1], alpha[1] + alpha[2], alpha[1] + alpha[2] + alpha[3]] >>> lattice.positive_roots_nonparabolic() [] >>> lattice.positive_roots_nonparabolic((Integer(1),Integer(2),Integer(3))) []
Warning
This returns an error if the Cartan type is not finite.
- positive_roots_nonparabolic_sum(index_set=None)[source]#
Return the sum of positive roots outside the parabolic subsystem with Dynkin node set
index_set.INPUT:
index_set– (default:None) the Dynkin node set of the parabolic subsystem. It should be a tuple. The default value implies the entire Dynkin node set
EXAMPLES:
sage: # needs sage.graphs sage: lattice = RootSystem(['A',3]).root_lattice() sage: lattice.positive_roots_nonparabolic_sum((1,3)) 2*alpha[1] + 4*alpha[2] + 2*alpha[3] sage: lattice.positive_roots_nonparabolic_sum((2,3)) 3*alpha[1] + 2*alpha[2] + alpha[3] sage: lattice.positive_roots_nonparabolic_sum(()) 3*alpha[1] + 4*alpha[2] + 3*alpha[3] sage: lattice.positive_roots_nonparabolic_sum() 0 sage: lattice.positive_roots_nonparabolic_sum((1,2,3)) 0
>>> from sage.all import * >>> # needs sage.graphs >>> lattice = RootSystem(['A',Integer(3)]).root_lattice() >>> lattice.positive_roots_nonparabolic_sum((Integer(1),Integer(3))) 2*alpha[1] + 4*alpha[2] + 2*alpha[3] >>> lattice.positive_roots_nonparabolic_sum((Integer(2),Integer(3))) 3*alpha[1] + 2*alpha[2] + alpha[3] >>> lattice.positive_roots_nonparabolic_sum(()) 3*alpha[1] + 4*alpha[2] + 3*alpha[3] >>> lattice.positive_roots_nonparabolic_sum() 0 >>> lattice.positive_roots_nonparabolic_sum((Integer(1),Integer(2),Integer(3))) 0
Warning
This returns an error if the Cartan type is not finite.
- positive_roots_parabolic(index_set=None)[source]#
Return the set of positive roots for the parabolic subsystem with Dynkin node set
index_set.INPUT:
index_set– (default:None) the Dynkin node set of the parabolic subsystem. It should be a tuple. The default value implies the entire Dynkin node set
EXAMPLES:
sage: lattice = RootSystem(['A',3]).root_lattice() sage: sorted(lattice.positive_roots_parabolic((1,3)), key=str) # needs sage.graphs [alpha[1], alpha[3]] sage: sorted(lattice.positive_roots_parabolic((2,3)), key=str) # needs sage.graphs [alpha[2], alpha[2] + alpha[3], alpha[3]] sage: sorted(lattice.positive_roots_parabolic(), key=str) # needs sage.graphs [alpha[1], alpha[1] + alpha[2], alpha[1] + alpha[2] + alpha[3], alpha[2], alpha[2] + alpha[3], alpha[3]]
>>> from sage.all import * >>> lattice = RootSystem(['A',Integer(3)]).root_lattice() >>> sorted(lattice.positive_roots_parabolic((Integer(1),Integer(3))), key=str) # needs sage.graphs [alpha[1], alpha[3]] >>> sorted(lattice.positive_roots_parabolic((Integer(2),Integer(3))), key=str) # needs sage.graphs [alpha[2], alpha[2] + alpha[3], alpha[3]] >>> sorted(lattice.positive_roots_parabolic(), key=str) # needs sage.graphs [alpha[1], alpha[1] + alpha[2], alpha[1] + alpha[2] + alpha[3], alpha[2], alpha[2] + alpha[3], alpha[3]]
Warning
This returns an error if the Cartan type is not finite.
- projection(root, coroot=None, to_negative=True)[source]#
Return the projection along the
root, and across the hyperplane defined bycoroot, as a function \(\pi\) fromselftoself.\(\pi\) is a half-linear map which stabilizes the negative half space and acts by reflection on the positive half space.
If
to_negativeisFalse, then project onto the positive half space instead.EXAMPLES:
sage: # needs sage.graphs sage: space = RootSystem(['A',2]).weight_lattice() sage: x = space.simple_roots()[1] sage: y = space.simple_coroots()[1] sage: pi = space.projection(x,y) sage: x 2*Lambda[1] - Lambda[2] sage: pi(x) -2*Lambda[1] + Lambda[2] sage: pi(-x) -2*Lambda[1] + Lambda[2] sage: pi = space.projection(x,y,False) sage: pi(-x) 2*Lambda[1] - Lambda[2]
>>> from sage.all import * >>> # needs sage.graphs >>> space = RootSystem(['A',Integer(2)]).weight_lattice() >>> x = space.simple_roots()[Integer(1)] >>> y = space.simple_coroots()[Integer(1)] >>> pi = space.projection(x,y) >>> x 2*Lambda[1] - Lambda[2] >>> pi(x) -2*Lambda[1] + Lambda[2] >>> pi(-x) -2*Lambda[1] + Lambda[2] >>> pi = space.projection(x,y,False) >>> pi(-x) 2*Lambda[1] - Lambda[2]
- reflection(root, coroot=None)[source]#
Return the reflection along the
root, and across the hyperplane defined bycoroot, as a function fromselftoself.EXAMPLES:
sage: # needs sage.graphs sage: space = RootSystem(['A',2]).weight_lattice() sage: x = space.simple_roots()[1] sage: y = space.simple_coroots()[1] sage: s = space.reflection(x,y) sage: x 2*Lambda[1] - Lambda[2] sage: s(x) -2*Lambda[1] + Lambda[2] sage: s(-x) 2*Lambda[1] - Lambda[2]
>>> from sage.all import * >>> # needs sage.graphs >>> space = RootSystem(['A',Integer(2)]).weight_lattice() >>> x = space.simple_roots()[Integer(1)] >>> y = space.simple_coroots()[Integer(1)] >>> s = space.reflection(x,y) >>> x 2*Lambda[1] - Lambda[2] >>> s(x) -2*Lambda[1] + Lambda[2] >>> s(-x) 2*Lambda[1] - Lambda[2]
- root_poset(restricted=False, facade=False)[source]#
Return the (restricted) root poset associated to
self.The elements are given by the positive roots (resp. non-simple, positive roots), and \(\alpha \leq \beta\) iff \(\beta - \alpha\) is a non-negative linear combination of simple roots.
INPUT:
restricted– (default:False) ifTrue, only non-simple roots are considered.facade– (default:False) passes facade option to the poset generator.
EXAMPLES:
sage: # needs sage.graphs sage: Phi = RootSystem(['A',1]).root_poset(); Phi Finite poset containing 1 elements sage: Phi.cover_relations() [] sage: Phi = RootSystem(['A',2]).root_poset(); Phi Finite poset containing 3 elements sage: sorted(Phi.cover_relations(), key=str) [[alpha[1], alpha[1] + alpha[2]], [alpha[2], alpha[1] + alpha[2]]] sage: Phi = RootSystem(['A',3]).root_poset(restricted=True); Phi Finite poset containing 3 elements sage: sorted(Phi.cover_relations(), key=str) [[alpha[1] + alpha[2], alpha[1] + alpha[2] + alpha[3]], [alpha[2] + alpha[3], alpha[1] + alpha[2] + alpha[3]]] sage: Phi = RootSystem(['B',2]).root_poset(); Phi Finite poset containing 4 elements sage: sorted(Phi.cover_relations(), key=str) [[alpha[1] + alpha[2], alpha[1] + 2*alpha[2]], [alpha[1], alpha[1] + alpha[2]], [alpha[2], alpha[1] + alpha[2]]]
>>> from sage.all import * >>> # needs sage.graphs >>> Phi = RootSystem(['A',Integer(1)]).root_poset(); Phi Finite poset containing 1 elements >>> Phi.cover_relations() [] >>> Phi = RootSystem(['A',Integer(2)]).root_poset(); Phi Finite poset containing 3 elements >>> sorted(Phi.cover_relations(), key=str) [[alpha[1], alpha[1] + alpha[2]], [alpha[2], alpha[1] + alpha[2]]] >>> Phi = RootSystem(['A',Integer(3)]).root_poset(restricted=True); Phi Finite poset containing 3 elements >>> sorted(Phi.cover_relations(), key=str) [[alpha[1] + alpha[2], alpha[1] + alpha[2] + alpha[3]], [alpha[2] + alpha[3], alpha[1] + alpha[2] + alpha[3]]] >>> Phi = RootSystem(['B',Integer(2)]).root_poset(); Phi Finite poset containing 4 elements >>> sorted(Phi.cover_relations(), key=str) [[alpha[1] + alpha[2], alpha[1] + 2*alpha[2]], [alpha[1], alpha[1] + alpha[2]], [alpha[2], alpha[1] + alpha[2]]]
- roots()[source]#
Return the roots of
self.EXAMPLES:
sage: RootSystem(['A',2]).ambient_lattice().roots() [(1, -1, 0), (1, 0, -1), (0, 1, -1), (-1, 1, 0), (-1, 0, 1), (0, -1, 1)]
>>> from sage.all import * >>> RootSystem(['A',Integer(2)]).ambient_lattice().roots() [(1, -1, 0), (1, 0, -1), (0, 1, -1), (-1, 1, 0), (-1, 0, 1), (0, -1, 1)]
This matches with Wikipedia article Root_systems:
sage: for T in CartanType.samples(finite=True, crystallographic=True): # needs sage.graphs ....: print("%s %3s %3s"%(T, len(RootSystem(T).root_lattice().roots()), ....: len(RootSystem(T).weight_lattice().roots()))) ['A', 1] 2 2 ['A', 5] 30 30 ['B', 1] 2 2 ['B', 5] 50 50 ['C', 1] 2 2 ['C', 5] 50 50 ['D', 2] 4 4 ['D', 3] 12 12 ['D', 5] 40 40 ['E', 6] 72 72 ['E', 7] 126 126 ['E', 8] 240 240 ['F', 4] 48 48 ['G', 2] 12 12
>>> from sage.all import * >>> for T in CartanType.samples(finite=True, crystallographic=True): # needs sage.graphs ... print("%s %3s %3s"%(T, len(RootSystem(T).root_lattice().roots()), ... len(RootSystem(T).weight_lattice().roots()))) ['A', 1] 2 2 ['A', 5] 30 30 ['B', 1] 2 2 ['B', 5] 50 50 ['C', 1] 2 2 ['C', 5] 50 50 ['D', 2] 4 4 ['D', 3] 12 12 ['D', 5] 40 40 ['E', 6] 72 72 ['E', 7] 126 126 ['E', 8] 240 240 ['F', 4] 48 48 ['G', 2] 12 12
Todo
The result should be an enumerated set, and handle infinite root systems.
- s()[source]#
Return the family \((s_i)_{i\in I}\) of the simple reflections of this root system.
EXAMPLES:
sage: r = RootSystem(["A", 2]).root_lattice() sage: s = r.simple_reflections() sage: s[1]( r.simple_root(1) ) # needs sage.graphs -alpha[1]
>>> from sage.all import * >>> r = RootSystem(["A", Integer(2)]).root_lattice() >>> s = r.simple_reflections() >>> s[Integer(1)]( r.simple_root(Integer(1)) ) # needs sage.graphs -alpha[1]
- short_roots()[source]#
Return a list of the short roots of
self.EXAMPLES:
sage: L = RootSystem(['B',3]).root_lattice() sage: sorted(L.short_roots()) # needs sage.graphs [-alpha[1] - alpha[2] - alpha[3], alpha[1] + alpha[2] + alpha[3], -alpha[2] - alpha[3], alpha[2] + alpha[3], -alpha[3], alpha[3]]
>>> from sage.all import * >>> L = RootSystem(['B',Integer(3)]).root_lattice() >>> sorted(L.short_roots()) # needs sage.graphs [-alpha[1] - alpha[2] - alpha[3], alpha[1] + alpha[2] + alpha[3], -alpha[2] - alpha[3], alpha[2] + alpha[3], -alpha[3], alpha[3]]
- simple_coroot(i)[source]#
Returns the \(i^{th}\) simple coroot.
EXAMPLES:
sage: RootSystem(['A',2]).root_lattice().simple_coroot(1) alphacheck[1]
>>> from sage.all import * >>> RootSystem(['A',Integer(2)]).root_lattice().simple_coroot(Integer(1)) alphacheck[1]
- simple_coroots()[source]#
Returns the family \(( \alpha^\vee_i)_{i\in I}\) of the simple coroots.
EXAMPLES:
sage: alphacheck = RootSystem(['A',3]).root_lattice().simple_coroots() sage: [alphacheck[i] for i in [1, 2, 3]] [alphacheck[1], alphacheck[2], alphacheck[3]]
>>> from sage.all import * >>> alphacheck = RootSystem(['A',Integer(3)]).root_lattice().simple_coroots() >>> [alphacheck[i] for i in [Integer(1), Integer(2), Integer(3)]] [alphacheck[1], alphacheck[2], alphacheck[3]]
- simple_projection(i, to_negative=True)[source]#
Return the projection along the \(i\)-th simple root, and across the hyperplane define by the \(i\)-th simple coroot, as a function from
selftoself.INPUT:
i– an element of the index set ofself
EXAMPLES:
sage: # needs sage.graphs sage: space = RootSystem(['A',2]).weight_lattice() sage: x = space.simple_roots()[1] sage: pi = space.simple_projection(1) sage: x 2*Lambda[1] - Lambda[2] sage: pi(x) -2*Lambda[1] + Lambda[2] sage: pi(-x) -2*Lambda[1] + Lambda[2] sage: pi = space.simple_projection(1,False) sage: pi(-x) 2*Lambda[1] - Lambda[2]
>>> from sage.all import * >>> # needs sage.graphs >>> space = RootSystem(['A',Integer(2)]).weight_lattice() >>> x = space.simple_roots()[Integer(1)] >>> pi = space.simple_projection(Integer(1)) >>> x 2*Lambda[1] - Lambda[2] >>> pi(x) -2*Lambda[1] + Lambda[2] >>> pi(-x) -2*Lambda[1] + Lambda[2] >>> pi = space.simple_projection(Integer(1),False) >>> pi(-x) 2*Lambda[1] - Lambda[2]
- simple_projections(to_negative=True)[source]#
Return the family \((s_i)_{i\in I}\) of the simple projections of this root system.
EXAMPLES:
sage: space = RootSystem(['A',2]).weight_lattice() sage: pi = space.simple_projections() # needs sage.graphs sage: x = space.simple_roots() # needs sage.graphs sage: pi[1](x[2]) # needs sage.graphs -Lambda[1] + 2*Lambda[2]
>>> from sage.all import * >>> space = RootSystem(['A',Integer(2)]).weight_lattice() >>> pi = space.simple_projections() # needs sage.graphs >>> x = space.simple_roots() # needs sage.graphs >>> pi[Integer(1)](x[Integer(2)]) # needs sage.graphs -Lambda[1] + 2*Lambda[2]
- simple_reflection(i)[source]#
Return the \(i\)-th simple reflection, as a function from
selftoself.INPUT:
i– an element of the index set ofself
EXAMPLES:
sage: space = RootSystem(['A',2]).ambient_lattice() sage: s = space.simple_reflection(1) sage: x = space.simple_roots()[1]; x (1, -1, 0) sage: s(x) (-1, 1, 0)
>>> from sage.all import * >>> space = RootSystem(['A',Integer(2)]).ambient_lattice() >>> s = space.simple_reflection(Integer(1)) >>> x = space.simple_roots()[Integer(1)]; x (1, -1, 0) >>> s(x) (-1, 1, 0)
- simple_reflections()[source]#
Return the family \((s_i)_{i\in I}\) of the simple reflections of this root system.
EXAMPLES:
sage: r = RootSystem(["A", 2]).root_lattice() sage: s = r.simple_reflections() sage: s[1]( r.simple_root(1) ) # needs sage.graphs -alpha[1]
>>> from sage.all import * >>> r = RootSystem(["A", Integer(2)]).root_lattice() >>> s = r.simple_reflections() >>> s[Integer(1)]( r.simple_root(Integer(1)) ) # needs sage.graphs -alpha[1]
- simple_root(i)[source]#
Return the \(i\)-th simple root.
This should be overridden by any subclass, and typically implemented as a cached method for efficiency.
EXAMPLES:
sage: r = RootSystem(["A",3]).root_lattice() sage: r.simple_root(1) alpha[1]
>>> from sage.all import * >>> r = RootSystem(["A",Integer(3)]).root_lattice() >>> r.simple_root(Integer(1)) alpha[1]
- simple_roots()[source]#
Return the family \((\alpha_i)_{i\in I}\) of the simple roots.
EXAMPLES:
sage: alpha = RootSystem(["A",3]).root_lattice().simple_roots() sage: [alpha[i] for i in [1,2,3]] [alpha[1], alpha[2], alpha[3]]
>>> from sage.all import * >>> alpha = RootSystem(["A",Integer(3)]).root_lattice().simple_roots() >>> [alpha[i] for i in [Integer(1),Integer(2),Integer(3)]] [alpha[1], alpha[2], alpha[3]]
- simple_roots_tilde()[source]#
Return the family \((\tilde\alpha_i)_{i\in I}\) of the simple roots.
INPUT:
self– an affine root lattice realization
The \(\tilde \alpha_i\) give the embedding of the root lattice of the other affinization of the same classical root lattice into this root lattice (space?).
This uses the fact that \(\alpha_i = \tilde \alpha_i\) for \(i\) not a special node, and that
\[\delta = \sum a_i \alpha_i = \sum b_i \tilde \alpha_i\]EXAMPLES:
In simply laced cases, this is boring:
sage: RootSystem(["A",3, 1]).root_lattice().simple_roots_tilde() # needs sage.graphs Finite family {0: alpha[0], 1: alpha[1], 2: alpha[2], 3: alpha[3]}
>>> from sage.all import * >>> RootSystem(["A",Integer(3), Integer(1)]).root_lattice().simple_roots_tilde() # needs sage.graphs Finite family {0: alpha[0], 1: alpha[1], 2: alpha[2], 3: alpha[3]}
This was checked by hand:
sage: RootSystem(["C",2,1]).coroot_lattice().simple_roots_tilde() # needs sage.graphs Finite family {0: alphacheck[0] - alphacheck[2], 1: alphacheck[1], 2: alphacheck[2]} sage: RootSystem(["B",2,1]).coroot_lattice().simple_roots_tilde() # needs sage.graphs Finite family {0: alphacheck[0] - alphacheck[1], 1: alphacheck[1], 2: alphacheck[2]}
>>> from sage.all import * >>> RootSystem(["C",Integer(2),Integer(1)]).coroot_lattice().simple_roots_tilde() # needs sage.graphs Finite family {0: alphacheck[0] - alphacheck[2], 1: alphacheck[1], 2: alphacheck[2]} >>> RootSystem(["B",Integer(2),Integer(1)]).coroot_lattice().simple_roots_tilde() # needs sage.graphs Finite family {0: alphacheck[0] - alphacheck[1], 1: alphacheck[1], 2: alphacheck[2]}
What about type BC?
- some_elements()[source]#
Return some elements of this root lattice realization.
EXAMPLES:
sage: L = RootSystem(["A",2]).weight_lattice() sage: L.some_elements() # needs sage.graphs [2*Lambda[1] + 2*Lambda[2], 2*Lambda[1] - Lambda[2], -Lambda[1] + 2*Lambda[2], Lambda[1], Lambda[2]] sage: L = RootSystem(["A",2]).root_lattice() sage: L.some_elements() [2*alpha[1] + 2*alpha[2], alpha[1], alpha[2]]
>>> from sage.all import * >>> L = RootSystem(["A",Integer(2)]).weight_lattice() >>> L.some_elements() # needs sage.graphs [2*Lambda[1] + 2*Lambda[2], 2*Lambda[1] - Lambda[2], -Lambda[1] + 2*Lambda[2], Lambda[1], Lambda[2]] >>> L = RootSystem(["A",Integer(2)]).root_lattice() >>> L.some_elements() [2*alpha[1] + 2*alpha[2], alpha[1], alpha[2]]
- tau_epsilon_operator_on_almost_positive_roots(J)[source]#
The \(\tau_\epsilon\) operator on almost positive roots.
Given a subset \(J\) of non adjacent vertices of the Dynkin diagram, this constructs the operator on the almost positive roots which fixes the negative simple roots \(\alpha_i\) for \(i\) not in \(J\), and acts otherwise by:
\[\tau_+( \beta ) = (\prod_{i \in J} s_i) (\beta)\]See Equation (1.2) of [CFZ2002].
EXAMPLES:
sage: L = RootSystem(['A',4]).root_lattice() sage: tau = L.tau_epsilon_operator_on_almost_positive_roots([1,3]) # needs sage.libs.gap sage: alpha = L.simple_roots() # needs sage.graphs
>>> from sage.all import * >>> L = RootSystem(['A',Integer(4)]).root_lattice() >>> tau = L.tau_epsilon_operator_on_almost_positive_roots([Integer(1),Integer(3)]) # needs sage.libs.gap >>> alpha = L.simple_roots() # needs sage.graphs
The action on a negative simple root not in \(J\):
sage: tau(-alpha[2]) # needs sage.graphs sage.libs.gap -alpha[2]
>>> from sage.all import * >>> tau(-alpha[Integer(2)]) # needs sage.graphs sage.libs.gap -alpha[2]
The action on a negative simple root in \(J\):
sage: tau(-alpha[1]) # needs sage.graphs sage.libs.gap alpha[1]
>>> from sage.all import * >>> tau(-alpha[Integer(1)]) # needs sage.graphs sage.libs.gap alpha[1]
The action on all almost positive roots:
sage: for root in L.almost_positive_roots(): # needs sage.graphs sage.libs.gap ....: print('tau({:<41}) = {}'.format(str(root), tau(root))) tau(-alpha[1] ) = alpha[1] tau(alpha[1] ) = -alpha[1] tau(alpha[1] + alpha[2] ) = alpha[2] + alpha[3] tau(alpha[1] + alpha[2] + alpha[3] ) = alpha[2] tau(alpha[1] + alpha[2] + alpha[3] + alpha[4]) = alpha[2] + alpha[3] + alpha[4] tau(-alpha[2] ) = -alpha[2] tau(alpha[2] ) = alpha[1] + alpha[2] + alpha[3] tau(alpha[2] + alpha[3] ) = alpha[1] + alpha[2] tau(alpha[2] + alpha[3] + alpha[4] ) = alpha[1] + alpha[2] + alpha[3] + alpha[4] tau(-alpha[3] ) = alpha[3] tau(alpha[3] ) = -alpha[3] tau(alpha[3] + alpha[4] ) = alpha[4] tau(-alpha[4] ) = -alpha[4] tau(alpha[4] ) = alpha[3] + alpha[4]
>>> from sage.all import * >>> for root in L.almost_positive_roots(): # needs sage.graphs sage.libs.gap ... print('tau({:<41}) = {}'.format(str(root), tau(root))) tau(-alpha[1] ) = alpha[1] tau(alpha[1] ) = -alpha[1] tau(alpha[1] + alpha[2] ) = alpha[2] + alpha[3] tau(alpha[1] + alpha[2] + alpha[3] ) = alpha[2] tau(alpha[1] + alpha[2] + alpha[3] + alpha[4]) = alpha[2] + alpha[3] + alpha[4] tau(-alpha[2] ) = -alpha[2] tau(alpha[2] ) = alpha[1] + alpha[2] + alpha[3] tau(alpha[2] + alpha[3] ) = alpha[1] + alpha[2] tau(alpha[2] + alpha[3] + alpha[4] ) = alpha[1] + alpha[2] + alpha[3] + alpha[4] tau(-alpha[3] ) = alpha[3] tau(alpha[3] ) = -alpha[3] tau(alpha[3] + alpha[4] ) = alpha[4] tau(-alpha[4] ) = -alpha[4] tau(alpha[4] ) = alpha[3] + alpha[4]
This method works on any root lattice realization:
sage: L = RootSystem(['B',3]).ambient_space() sage: tau = L.tau_epsilon_operator_on_almost_positive_roots([1,3]) # needs sage.libs.gap sage: for root in L.almost_positive_roots(): # needs sage.graphs sage.libs.gap ....: print('tau({:<41}) = {}'.format(str(root), tau(root))) tau((-1, 1, 0) ) = (1, -1, 0) tau((1, 0, 0) ) = (0, 1, 0) tau((1, -1, 0) ) = (-1, 1, 0) tau((1, 1, 0) ) = (1, 1, 0) tau((1, 0, -1) ) = (0, 1, 1) tau((1, 0, 1) ) = (0, 1, -1) tau((0, -1, 1) ) = (0, -1, 1) tau((0, 1, 0) ) = (1, 0, 0) tau((0, 1, -1) ) = (1, 0, 1) tau((0, 1, 1) ) = (1, 0, -1) tau((0, 0, -1) ) = (0, 0, 1) tau((0, 0, 1) ) = (0, 0, -1)
>>> from sage.all import * >>> L = RootSystem(['B',Integer(3)]).ambient_space() >>> tau = L.tau_epsilon_operator_on_almost_positive_roots([Integer(1),Integer(3)]) # needs sage.libs.gap >>> for root in L.almost_positive_roots(): # needs sage.graphs sage.libs.gap ... print('tau({:<41}) = {}'.format(str(root), tau(root))) tau((-1, 1, 0) ) = (1, -1, 0) tau((1, 0, 0) ) = (0, 1, 0) tau((1, -1, 0) ) = (-1, 1, 0) tau((1, 1, 0) ) = (1, 1, 0) tau((1, 0, -1) ) = (0, 1, 1) tau((1, 0, 1) ) = (0, 1, -1) tau((0, -1, 1) ) = (0, -1, 1) tau((0, 1, 0) ) = (1, 0, 0) tau((0, 1, -1) ) = (1, 0, 1) tau((0, 1, 1) ) = (1, 0, -1) tau((0, 0, -1) ) = (0, 0, 1) tau((0, 0, 1) ) = (0, 0, -1)
See also
- tau_plus_minus()[source]#
Return the \(\tau^+\) and \(\tau^-\) piecewise linear operators on
self.Those operators are induced by the bipartition \(\{L,R\}\) of the simple roots of
self, and stabilize the almost positive roots. Namely, \(\tau_+\) fixes the negative simple roots \(\alpha_i\) for \(i\) in \(R\), and acts otherwise by:\[\tau_+( \beta ) = (\prod_{i \in L} s_i) (\beta)\]\(\tau_-\) acts analogously, with \(L\) and \(R\) interchanged.
Those operators are used to construct the associahedron, a polytopal realization of the cluster complex (see
Associahedron).EXAMPLES:
We explore the example of [CFZ2002] Eq.(1.3):
sage: S = RootSystem(['A',2]).root_lattice() sage: taup, taum = S.tau_plus_minus() # needs sage.graphs sage.libs.gap sage: for beta in S.almost_positive_roots(): # needs sage.graphs sage.libs.gap ....: print("{} , {} , {}".format(beta, taup(beta), taum(beta))) -alpha[1] , alpha[1] , -alpha[1] alpha[1] , -alpha[1] , alpha[1] + alpha[2] alpha[1] + alpha[2] , alpha[2] , alpha[1] -alpha[2] , -alpha[2] , alpha[2] alpha[2] , alpha[1] + alpha[2] , -alpha[2]
>>> from sage.all import * >>> S = RootSystem(['A',Integer(2)]).root_lattice() >>> taup, taum = S.tau_plus_minus() # needs sage.graphs sage.libs.gap >>> for beta in S.almost_positive_roots(): # needs sage.graphs sage.libs.gap ... print("{} , {} , {}".format(beta, taup(beta), taum(beta))) -alpha[1] , alpha[1] , -alpha[1] alpha[1] , -alpha[1] , alpha[1] + alpha[2] alpha[1] + alpha[2] , alpha[2] , alpha[1] -alpha[2] , -alpha[2] , alpha[2] alpha[2] , alpha[1] + alpha[2] , -alpha[2]
- to_ambient_space_morphism()[source]#
Return the morphism to the ambient space.
EXAMPLES:
sage: B2rs = CartanType(['B',2]).root_system() sage: B2rs.root_lattice().to_ambient_space_morphism() Generic morphism: From: Root lattice of the Root system of type ['B', 2] To: Ambient space of the Root system of type ['B', 2] sage: B2rs.coroot_lattice().to_ambient_space_morphism() Generic morphism: From: Coroot lattice of the Root system of type ['B', 2] To: Ambient space of the Root system of type ['B', 2] sage: B2rs.weight_lattice().to_ambient_space_morphism() Generic morphism: From: Weight lattice of the Root system of type ['B', 2] To: Ambient space of the Root system of type ['B', 2]
>>> from sage.all import * >>> B2rs = CartanType(['B',Integer(2)]).root_system() >>> B2rs.root_lattice().to_ambient_space_morphism() Generic morphism: From: Root lattice of the Root system of type ['B', 2] To: Ambient space of the Root system of type ['B', 2] >>> B2rs.coroot_lattice().to_ambient_space_morphism() Generic morphism: From: Coroot lattice of the Root system of type ['B', 2] To: Ambient space of the Root system of type ['B', 2] >>> B2rs.weight_lattice().to_ambient_space_morphism() Generic morphism: From: Weight lattice of the Root system of type ['B', 2] To: Ambient space of the Root system of type ['B', 2]
- weyl_group(prefix=None)[source]#
Return the Weyl group associated to
self.EXAMPLES:
sage: RootSystem(['F',4]).ambient_space().weyl_group() # needs sage.libs.gap Weyl Group of type ['F', 4] (as a matrix group acting on the ambient space) sage: RootSystem(['F',4]).root_space().weyl_group() # needs sage.libs.gap Weyl Group of type ['F', 4] (as a matrix group acting on the root space)
>>> from sage.all import * >>> RootSystem(['F',Integer(4)]).ambient_space().weyl_group() # needs sage.libs.gap Weyl Group of type ['F', 4] (as a matrix group acting on the ambient space) >>> RootSystem(['F',Integer(4)]).root_space().weyl_group() # needs sage.libs.gap Weyl Group of type ['F', 4] (as a matrix group acting on the root space)
- super_categories()[source]#
EXAMPLES:
sage: from sage.combinat.root_system.root_lattice_realizations import RootLatticeRealizations sage: RootLatticeRealizations(QQ).super_categories() [Category of vector spaces with basis over Rational Field]
>>> from sage.all import * >>> from sage.combinat.root_system.root_lattice_realizations import RootLatticeRealizations >>> RootLatticeRealizations(QQ).super_categories() [Category of vector spaces with basis over Rational Field]