Root system data for super type A

class sage.combinat.root_system.type_super_A.AmbientSpace(root_system, base_ring, index_set=None)[source]

Bases: AmbientSpace

The ambient space for (super) type \(A(m|n)\).

EXAMPLES:

sage: R = RootSystem(['A', [2,1]])
sage: AL = R.ambient_space(); AL
Ambient space of the Root system of type ['A', [2, 1]]
sage: AL.basis()
Finite family {-3: (1, 0, 0, 0, 0),
 -2: (0, 1, 0, 0, 0),
 -1: (0, 0, 1, 0, 0),
 1: (0, 0, 0, 1, 0),
 2: (0, 0, 0, 0, 1)}

>>> from sage.all import *
>>> R = RootSystem(['A', [Integer(2),Integer(1)]])
>>> AL = R.ambient_space(); AL
Ambient space of the Root system of type ['A', [2, 1]]
>>> AL.basis()
Finite family {-3: (1, 0, 0, 0, 0),
 -2: (0, 1, 0, 0, 0),
 -1: (0, 0, 1, 0, 0),
 1: (0, 0, 0, 1, 0),
 2: (0, 0, 0, 0, 1)}
class Element[source]

Bases: AmbientSpaceElement

associated_coroot()[source]

Return the coroot associated to self.

EXAMPLES:

sage: L = RootSystem(['A', [3,2]]).ambient_space()
sage: al = L.simple_roots()
sage: al[-1].associated_coroot()
(0, 0, 1, -1, 0, 0, 0)
sage: al[0].associated_coroot()
(0, 0, 0, 1, -1, 0, 0)
sage: al[1].associated_coroot()
(0, 0, 0, 0, -1, 1, 0)

sage: a = al[-1] + al[0] + al[1]; a
(0, 0, 1, 0, 0, -1, 0)
sage: a.associated_coroot()
(0, 0, 1, 0, -2, 1, 0)
sage: h = L.simple_coroots()
sage: h[-1] + h[0] + h[1]
(0, 0, 1, 0, -2, 1, 0)

sage: (al[-1] + al[0] + al[2]).associated_coroot()
(0, 0, 1, 0, -1, -1, 1)

>>> from sage.all import *
>>> L = RootSystem(['A', [Integer(3),Integer(2)]]).ambient_space()
>>> al = L.simple_roots()
>>> al[-Integer(1)].associated_coroot()
(0, 0, 1, -1, 0, 0, 0)
>>> al[Integer(0)].associated_coroot()
(0, 0, 0, 1, -1, 0, 0)
>>> al[Integer(1)].associated_coroot()
(0, 0, 0, 0, -1, 1, 0)

>>> a = al[-Integer(1)] + al[Integer(0)] + al[Integer(1)]; a
(0, 0, 1, 0, 0, -1, 0)
>>> a.associated_coroot()
(0, 0, 1, 0, -2, 1, 0)
>>> h = L.simple_coroots()
>>> h[-Integer(1)] + h[Integer(0)] + h[Integer(1)]
(0, 0, 1, 0, -2, 1, 0)

>>> (al[-Integer(1)] + al[Integer(0)] + al[Integer(2)]).associated_coroot()
(0, 0, 1, 0, -1, -1, 1)
dot_product(lambdacheck)[source]

The scalar product with elements of the coroot lattice embedded in the ambient space.

EXAMPLES:

sage: L = RootSystem(['A', [2,1]]).ambient_space()
sage: a = L.simple_roots()
sage: matrix([[a[i].inner_product(a[j]) for j in L.index_set()] for i in L.index_set()])
[ 2 -1  0  0]
[-1  2 -1  0]
[ 0 -1  0  1]
[ 0  0  1 -2]

>>> from sage.all import *
>>> L = RootSystem(['A', [Integer(2),Integer(1)]]).ambient_space()
>>> a = L.simple_roots()
>>> matrix([[a[i].inner_product(a[j]) for j in L.index_set()] for i in L.index_set()])
[ 2 -1  0  0]
[-1  2 -1  0]
[ 0 -1  0  1]
[ 0  0  1 -2]
has_descent(i, positive=False)[source]

Test if self has a descent at position \(i\), that is if self is 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: L = RootSystem(['A', [2,1]]).ambient_space()
sage: al = L.simple_roots()
sage: [al[i].has_descent(1) for i in L.index_set()]
[False, False, True, False]
sage: [(-al[i]).has_descent(1) for i in L.index_set()]
[False, False, False, True]
sage: [al[i].has_descent(1, True) for i in L.index_set()]
[False, False, False, True]
sage: [(-al[i]).has_descent(1, True) for i in L.index_set()]
[False, False, True, False]
sage: (al[-2] + al[0] + al[1]).has_descent(-1)
True
sage: (al[-2] + al[0] + al[1]).has_descent(1)
False
sage: (al[-2] + al[0] + al[1]).has_descent(1, positive=True)
True
sage: all(all(not la.has_descent(i) for i in L.index_set())
....:     for la in L.fundamental_weights())
True

>>> from sage.all import *
>>> L = RootSystem(['A', [Integer(2),Integer(1)]]).ambient_space()
>>> al = L.simple_roots()
>>> [al[i].has_descent(Integer(1)) for i in L.index_set()]
[False, False, True, False]
>>> [(-al[i]).has_descent(Integer(1)) for i in L.index_set()]
[False, False, False, True]
>>> [al[i].has_descent(Integer(1), True) for i in L.index_set()]
[False, False, False, True]
>>> [(-al[i]).has_descent(Integer(1), True) for i in L.index_set()]
[False, False, True, False]
>>> (al[-Integer(2)] + al[Integer(0)] + al[Integer(1)]).has_descent(-Integer(1))
True
>>> (al[-Integer(2)] + al[Integer(0)] + al[Integer(1)]).has_descent(Integer(1))
False
>>> (al[-Integer(2)] + al[Integer(0)] + al[Integer(1)]).has_descent(Integer(1), positive=True)
True
>>> all(all(not la.has_descent(i) for i in L.index_set())
...     for la in L.fundamental_weights())
True
inner_product(lambdacheck)[source]

The scalar product with elements of the coroot lattice embedded in the ambient space.

EXAMPLES:

sage: L = RootSystem(['A', [2,1]]).ambient_space()
sage: a = L.simple_roots()
sage: matrix([[a[i].inner_product(a[j]) for j in L.index_set()] for i in L.index_set()])
[ 2 -1  0  0]
[-1  2 -1  0]
[ 0 -1  0  1]
[ 0  0  1 -2]

>>> from sage.all import *
>>> L = RootSystem(['A', [Integer(2),Integer(1)]]).ambient_space()
>>> a = L.simple_roots()
>>> matrix([[a[i].inner_product(a[j]) for j in L.index_set()] for i in L.index_set()])
[ 2 -1  0  0]
[-1  2 -1  0]
[ 0 -1  0  1]
[ 0  0  1 -2]
is_dominant_weight()[source]

Test whether self is 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
scalar(lambdacheck)[source]

The scalar product with elements of the coroot lattice embedded in the ambient space.

EXAMPLES:

sage: L = RootSystem(['A', [2,1]]).ambient_space()
sage: a = L.simple_roots()
sage: matrix([[a[i].inner_product(a[j]) for j in L.index_set()] for i in L.index_set()])
[ 2 -1  0  0]
[-1  2 -1  0]
[ 0 -1  0  1]
[ 0  0  1 -2]

>>> from sage.all import *
>>> L = RootSystem(['A', [Integer(2),Integer(1)]]).ambient_space()
>>> a = L.simple_roots()
>>> matrix([[a[i].inner_product(a[j]) for j in L.index_set()] for i in L.index_set()])
[ 2 -1  0  0]
[-1  2 -1  0]
[ 0 -1  0  1]
[ 0  0  1 -2]
dimension()[source]

Return the dimension of this ambient space.

EXAMPLES:

sage: e = RootSystem(['A', [4,2]]).ambient_space()
sage: e.dimension()
8

>>> from sage.all import *
>>> e = RootSystem(['A', [Integer(4),Integer(2)]]).ambient_space()
>>> e.dimension()
8
fundamental_weight(i)[source]

Return the fundamental weight \(\Lambda_i\) of self.

EXAMPLES:

sage: L = RootSystem(['A', [3,2]]).ambient_space()
sage: L.fundamental_weight(-1)
(1, 1, 1, 0, 0, 0, 0)
sage: L.fundamental_weight(0)
(1, 1, 1, 1, 0, 0, 0)
sage: L.fundamental_weight(2)
(1, 1, 1, 1, -1, -1, -2)
sage: list(L.fundamental_weights())
[(1, 0, 0, 0, 0, 0, 0),
 (1, 1, 0, 0, 0, 0, 0),
 (1, 1, 1, 0, 0, 0, 0),
 (1, 1, 1, 1, 0, 0, 0),
 (1, 1, 1, 1, -1, -2, -2),
 (1, 1, 1, 1, -1, -1, -2)]

>>> from sage.all import *
>>> L = RootSystem(['A', [Integer(3),Integer(2)]]).ambient_space()
>>> L.fundamental_weight(-Integer(1))
(1, 1, 1, 0, 0, 0, 0)
>>> L.fundamental_weight(Integer(0))
(1, 1, 1, 1, 0, 0, 0)
>>> L.fundamental_weight(Integer(2))
(1, 1, 1, 1, -1, -1, -2)
>>> list(L.fundamental_weights())
[(1, 0, 0, 0, 0, 0, 0),
 (1, 1, 0, 0, 0, 0, 0),
 (1, 1, 1, 0, 0, 0, 0),
 (1, 1, 1, 1, 0, 0, 0),
 (1, 1, 1, 1, -1, -2, -2),
 (1, 1, 1, 1, -1, -1, -2)]


sage: L = RootSystem(['A', [2,3]]).ambient_space()
sage: La = L.fundamental_weights()
sage: al = L.simple_roots()
sage: I = L.index_set()
sage: matrix([[al[i].scalar(La[j]) for i in I] for j in I])
[ 1  0  0  0  0  0]
[ 0  1  0  0  0  0]
[ 0  0  1  0  0  0]
[ 0  0  0 -1  0  0]
[ 0  0  0  0 -1  0]
[ 0  0  0  0  0 -1]

>>> from sage.all import *
>>> L = RootSystem(['A', [Integer(2),Integer(3)]]).ambient_space()
>>> La = L.fundamental_weights()
>>> al = L.simple_roots()
>>> I = L.index_set()
>>> matrix([[al[i].scalar(La[j]) for i in I] for j in I])
[ 1  0  0  0  0  0]
[ 0  1  0  0  0  0]
[ 0  0  1  0  0  0]
[ 0  0  0 -1  0  0]
[ 0  0  0  0 -1  0]
[ 0  0  0  0  0 -1]
highest_root()[source]

Return the highest root of self.

EXAMPLES:

sage: e = RootSystem(['A', [4,2]]).ambient_lattice()
sage: e.highest_root()
(1, 0, 0, 0, 0, 0, 0, -1)

>>> from sage.all import *
>>> e = RootSystem(['A', [Integer(4),Integer(2)]]).ambient_lattice()
>>> e.highest_root()
(1, 0, 0, 0, 0, 0, 0, -1)
negative_even_roots()[source]

Return the negative even roots of self.

EXAMPLES:

sage: e = RootSystem(['A', [2,1]]).ambient_lattice()
sage: e.negative_even_roots()
[(0, -1, 1, 0, 0), (-1, 0, 1, 0, 0),
 (-1, 1, 0, 0, 0), (0, 0, 0, -1, 1)]

>>> from sage.all import *
>>> e = RootSystem(['A', [Integer(2),Integer(1)]]).ambient_lattice()
>>> e.negative_even_roots()
[(0, -1, 1, 0, 0), (-1, 0, 1, 0, 0),
 (-1, 1, 0, 0, 0), (0, 0, 0, -1, 1)]
negative_odd_roots()[source]

Return the negative odd roots of self.

EXAMPLES:

sage: e = RootSystem(['A', [2,1]]).ambient_lattice()
sage: e.negative_odd_roots()
[(0, 0, -1, 1, 0),
 (0, 0, -1, 0, 1),
 (0, -1, 0, 1, 0),
 (0, -1, 0, 0, 1),
 (-1, 0, 0, 1, 0),
 (-1, 0, 0, 0, 1)]

>>> from sage.all import *
>>> e = RootSystem(['A', [Integer(2),Integer(1)]]).ambient_lattice()
>>> e.negative_odd_roots()
[(0, 0, -1, 1, 0),
 (0, 0, -1, 0, 1),
 (0, -1, 0, 1, 0),
 (0, -1, 0, 0, 1),
 (-1, 0, 0, 1, 0),
 (-1, 0, 0, 0, 1)]
negative_roots()[source]

Return the negative roots of self.

EXAMPLES:

sage: e = RootSystem(['A', [2,1]]).ambient_lattice()
sage: e.negative_roots()
[(0, -1, 1, 0, 0),
 (-1, 0, 1, 0, 0),
 (-1, 1, 0, 0, 0),
 (0, 0, 0, -1, 1),
 (0, 0, -1, 1, 0),
 (0, 0, -1, 0, 1),
 (0, -1, 0, 1, 0),
 (0, -1, 0, 0, 1),
 (-1, 0, 0, 1, 0),
 (-1, 0, 0, 0, 1)]

>>> from sage.all import *
>>> e = RootSystem(['A', [Integer(2),Integer(1)]]).ambient_lattice()
>>> e.negative_roots()
[(0, -1, 1, 0, 0),
 (-1, 0, 1, 0, 0),
 (-1, 1, 0, 0, 0),
 (0, 0, 0, -1, 1),
 (0, 0, -1, 1, 0),
 (0, 0, -1, 0, 1),
 (0, -1, 0, 1, 0),
 (0, -1, 0, 0, 1),
 (-1, 0, 0, 1, 0),
 (-1, 0, 0, 0, 1)]
positive_even_roots()[source]

Return the positive even roots of self.

EXAMPLES:

sage: e = RootSystem(['A', [2,1]]).ambient_lattice()
sage: e.positive_even_roots()
[(0, 1, -1, 0, 0), (1, 0, -1, 0, 0),
 (1, -1, 0, 0, 0), (0, 0, 0, 1, -1)]

>>> from sage.all import *
>>> e = RootSystem(['A', [Integer(2),Integer(1)]]).ambient_lattice()
>>> e.positive_even_roots()
[(0, 1, -1, 0, 0), (1, 0, -1, 0, 0),
 (1, -1, 0, 0, 0), (0, 0, 0, 1, -1)]
positive_odd_roots()[source]

Return the positive odd roots of self.

EXAMPLES:

sage: e = RootSystem(['A', [2,1]]).ambient_lattice()
sage: e.positive_odd_roots()
[(0, 0, 1, -1, 0),
 (0, 0, 1, 0, -1),
 (0, 1, 0, -1, 0),
 (0, 1, 0, 0, -1),
 (1, 0, 0, -1, 0),
 (1, 0, 0, 0, -1)]

>>> from sage.all import *
>>> e = RootSystem(['A', [Integer(2),Integer(1)]]).ambient_lattice()
>>> e.positive_odd_roots()
[(0, 0, 1, -1, 0),
 (0, 0, 1, 0, -1),
 (0, 1, 0, -1, 0),
 (0, 1, 0, 0, -1),
 (1, 0, 0, -1, 0),
 (1, 0, 0, 0, -1)]
positive_roots()[source]

Return the positive roots of self.

EXAMPLES:

sage: e = RootSystem(['A', [2,1]]).ambient_lattice()
sage: e.positive_roots()
[(0, 1, -1, 0, 0),
 (1, 0, -1, 0, 0),
 (1, -1, 0, 0, 0),
 (0, 0, 0, 1, -1),
 (0, 0, 1, -1, 0),
 (0, 0, 1, 0, -1),
 (0, 1, 0, -1, 0),
 (0, 1, 0, 0, -1),
 (1, 0, 0, -1, 0),
 (1, 0, 0, 0, -1)]

>>> from sage.all import *
>>> e = RootSystem(['A', [Integer(2),Integer(1)]]).ambient_lattice()
>>> e.positive_roots()
[(0, 1, -1, 0, 0),
 (1, 0, -1, 0, 0),
 (1, -1, 0, 0, 0),
 (0, 0, 0, 1, -1),
 (0, 0, 1, -1, 0),
 (0, 0, 1, 0, -1),
 (0, 1, 0, -1, 0),
 (0, 1, 0, 0, -1),
 (1, 0, 0, -1, 0),
 (1, 0, 0, 0, -1)]
simple_coroot(i)[source]

Return the simple coroot \(h_i\) of self.

EXAMPLES:

sage: L = RootSystem(['A', [3,2]]).ambient_space()
sage: L.simple_coroot(-2)
(0, 1, -1, 0, 0, 0, 0)
sage: L.simple_coroot(0)
(0, 0, 0, 1, -1, 0, 0)
sage: L.simple_coroot(2)
(0, 0, 0, 0, 0, -1, 1)
sage: list(L.simple_coroots())
[(1, -1, 0, 0, 0, 0, 0),
 (0, 1, -1, 0, 0, 0, 0),
 (0, 0, 1, -1, 0, 0, 0),
 (0, 0, 0, 1, -1, 0, 0),
 (0, 0, 0, 0, -1, 1, 0),
 (0, 0, 0, 0, 0, -1, 1)]

>>> from sage.all import *
>>> L = RootSystem(['A', [Integer(3),Integer(2)]]).ambient_space()
>>> L.simple_coroot(-Integer(2))
(0, 1, -1, 0, 0, 0, 0)
>>> L.simple_coroot(Integer(0))
(0, 0, 0, 1, -1, 0, 0)
>>> L.simple_coroot(Integer(2))
(0, 0, 0, 0, 0, -1, 1)
>>> list(L.simple_coroots())
[(1, -1, 0, 0, 0, 0, 0),
 (0, 1, -1, 0, 0, 0, 0),
 (0, 0, 1, -1, 0, 0, 0),
 (0, 0, 0, 1, -1, 0, 0),
 (0, 0, 0, 0, -1, 1, 0),
 (0, 0, 0, 0, 0, -1, 1)]
simple_root(i)[source]

Return the \(i\)-th simple root of self.

EXAMPLES:

sage: e = RootSystem(['A', [2,1]]).ambient_lattice()
sage: list(e.simple_roots())
[(1, -1, 0, 0, 0), (0, 1, -1, 0, 0),
 (0, 0, 1, -1, 0), (0, 0, 0, 1, -1)]

>>> from sage.all import *
>>> e = RootSystem(['A', [Integer(2),Integer(1)]]).ambient_lattice()
>>> list(e.simple_roots())
[(1, -1, 0, 0, 0), (0, 1, -1, 0, 0),
 (0, 0, 1, -1, 0), (0, 0, 0, 1, -1)]
classmethod smallest_base_ring(cartan_type=None)[source]

Return the smallest base ring the ambient space can be defined upon.

See also

smallest_base_ring()

EXAMPLES:

sage: e = RootSystem(['A', [3,1]]).ambient_space()
sage: e.smallest_base_ring()
Integer Ring

>>> from sage.all import *
>>> e = RootSystem(['A', [Integer(3),Integer(1)]]).ambient_space()
>>> e.smallest_base_ring()
Integer Ring
class sage.combinat.root_system.type_super_A.CartanType(m, n)[source]

Bases: SuperCartanType_standard

Cartan Type \(A(m|n)\).

See also

CartanType()

AmbientSpace[source]

alias of AmbientSpace

ascii_art(label=None, node=None)[source]

Return an ascii art representation of the Dynkin diagram.

EXAMPLES:

sage: t = CartanType(['A', [3,2]])
sage: print(t.ascii_art())
O---O---O---X---O---O
-3  -2  -1  0   1   2
sage: t = CartanType(['A', [3,7]])
sage: print(t.ascii_art())
O---O---O---X---O---O---O---O---O---O---O
-3  -2  -1  0   1   2   3   4   5   6   7

sage: t = CartanType(['A', [0,7]])
sage: print(t.ascii_art())
X---O---O---O---O---O---O---O
0   1   2   3   4   5   6   7
sage: t = CartanType(['A', [0,0]])
sage: print(t.ascii_art())
X
0
sage: t = CartanType(['A', [5,0]])
sage: print(t.ascii_art())
O---O---O---O---O---X
-5  -4  -3  -2  -1  0

>>> from sage.all import *
>>> t = CartanType(['A', [Integer(3),Integer(2)]])
>>> print(t.ascii_art())
O---O---O---X---O---O
-3  -2  -1  0   1   2
>>> t = CartanType(['A', [Integer(3),Integer(7)]])
>>> print(t.ascii_art())
O---O---O---X---O---O---O---O---O---O---O
-3  -2  -1  0   1   2   3   4   5   6   7

>>> t = CartanType(['A', [Integer(0),Integer(7)]])
>>> print(t.ascii_art())
X---O---O---O---O---O---O---O
0   1   2   3   4   5   6   7
>>> t = CartanType(['A', [Integer(0),Integer(0)]])
>>> print(t.ascii_art())
X
0
>>> t = CartanType(['A', [Integer(5),Integer(0)]])
>>> print(t.ascii_art())
O---O---O---O---O---X
-5  -4  -3  -2  -1  0
cartan_matrix()[source]

Return the Cartan matrix associated to self.

EXAMPLES:

sage: ct = CartanType(['A', [2,3]])
sage: ct.cartan_matrix()                                                    # needs sage.graphs
[ 2 -1  0  0  0  0]
[-1  2 -1  0  0  0]
[ 0 -1  0  1  0  0]
[ 0  0 -1  2 -1  0]
[ 0  0  0 -1  2 -1]
[ 0  0  0  0 -1  2]

>>> from sage.all import *
>>> ct = CartanType(['A', [Integer(2),Integer(3)]])
>>> ct.cartan_matrix()                                                    # needs sage.graphs
[ 2 -1  0  0  0  0]
[-1  2 -1  0  0  0]
[ 0 -1  0  1  0  0]
[ 0  0 -1  2 -1  0]
[ 0  0  0 -1  2 -1]
[ 0  0  0  0 -1  2]
dual()[source]

Return dual of self.

EXAMPLES:

sage: CartanType(['A', [2,3]]).dual()
['A', [2, 3]]

>>> from sage.all import *
>>> CartanType(['A', [Integer(2),Integer(3)]]).dual()
['A', [2, 3]]
dynkin_diagram()[source]

Return the Dynkin diagram of super type A.

EXAMPLES:

sage: a = CartanType(['A', [4,2]]).dynkin_diagram(); a                      # needs sage.graphs
O---O---O---O---X---O---O
-4  -3  -2  -1  0   1   2
A4|2
sage: a.edges(sort=True)                                                    # needs sage.graphs
[(-4, -3, 1), (-3, -4, 1), (-3, -2, 1), (-2, -3, 1),
 (-2, -1, 1), (-1, -2, 1), (-1, 0, 1), (0, -1, 1),
 (0, 1, 1), (1, 0, -1), (1, 2, 1), (2, 1, 1)]

>>> from sage.all import *
>>> a = CartanType(['A', [Integer(4),Integer(2)]]).dynkin_diagram(); a                      # needs sage.graphs
O---O---O---O---X---O---O
-4  -3  -2  -1  0   1   2
A4|2
>>> a.edges(sort=True)                                                    # needs sage.graphs
[(-4, -3, 1), (-3, -4, 1), (-3, -2, 1), (-2, -3, 1),
 (-2, -1, 1), (-1, -2, 1), (-1, 0, 1), (0, -1, 1),
 (0, 1, 1), (1, 0, -1), (1, 2, 1), (2, 1, 1)]
index_set()[source]

Return the index set of self.

EXAMPLES:

sage: CartanType(['A', [2,3]]).index_set()
(-2, -1, 0, 1, 2, 3)

>>> from sage.all import *
>>> CartanType(['A', [Integer(2),Integer(3)]]).index_set()
(-2, -1, 0, 1, 2, 3)
is_affine()[source]

Return whether self is affine or not.

EXAMPLES:

sage: CartanType(['A', [2,3]]).is_affine()
False

>>> from sage.all import *
>>> CartanType(['A', [Integer(2),Integer(3)]]).is_affine()
False
is_finite()[source]

Return whether self is finite or not.

EXAMPLES:

sage: CartanType(['A', [2,3]]).is_finite()
True

>>> from sage.all import *
>>> CartanType(['A', [Integer(2),Integer(3)]]).is_finite()
True
is_irreducible()[source]

Return whether self is irreducible, which is True.

EXAMPLES:

sage: CartanType(['A', [3,4]]).is_irreducible()
True

>>> from sage.all import *
>>> CartanType(['A', [Integer(3),Integer(4)]]).is_irreducible()
True
relabel(relabelling)[source]

Return a relabelled copy of this Cartan type.

INPUT:

  • relabelling – a function (or a list or dictionary)

OUTPUT:

an isomorphic Cartan type obtained by relabelling the nodes of the Dynkin diagram. Namely, the node with label i is relabelled f(i) (or, by f[i] if f is a list or dictionary).

EXAMPLES:

sage: ct = CartanType(['A', [1,2]])
sage: ct.dynkin_diagram()                                                   # needs sage.graphs
O---X---O---O
-1  0   1   2
A1|2
sage: f = {1:2, 2:1, 0:0, -1:-1}
sage: ct.relabel(f)
['A', [1, 2]] relabelled by {-1: -1, 0: 0, 1: 2, 2: 1}
sage: ct.relabel(f).dynkin_diagram()                                        # needs sage.graphs
O---X---O---O
-1  0   2   1
A1|2 relabelled by {-1: -1, 0: 0, 1: 2, 2: 1}

>>> from sage.all import *
>>> ct = CartanType(['A', [Integer(1),Integer(2)]])
>>> ct.dynkin_diagram()                                                   # needs sage.graphs
O---X---O---O
-1  0   1   2
A1|2
>>> f = {Integer(1):Integer(2), Integer(2):Integer(1), Integer(0):Integer(0), -Integer(1):-Integer(1)}
>>> ct.relabel(f)
['A', [1, 2]] relabelled by {-1: -1, 0: 0, 1: 2, 2: 1}
>>> ct.relabel(f).dynkin_diagram()                                        # needs sage.graphs
O---X---O---O
-1  0   2   1
A1|2 relabelled by {-1: -1, 0: 0, 1: 2, 2: 1}
root_system()[source]

Return root system of self.

EXAMPLES:

sage: CartanType(['A', [2,3]]).root_system()
Root system of type ['A', [2, 3]]

>>> from sage.all import *
>>> CartanType(['A', [Integer(2),Integer(3)]]).root_system()
Root system of type ['A', [2, 3]]
symmetrizer()[source]

Return symmetrizing matrix for self.

EXAMPLES:

sage: CartanType(['A', [2,3]]).symmetrizer()
Finite family {-2: 1, -1: 1, 0: 1, 1: -1, 2: -1, 3: -1}

>>> from sage.all import *
>>> CartanType(['A', [Integer(2),Integer(3)]]).symmetrizer()
Finite family {-2: 1, -1: 1, 0: 1, 1: -1, 2: -1, 3: -1}
type()[source]

Return type of self.

EXAMPLES:

sage: CartanType(['A', [2,3]]).type()
'A'

>>> from sage.all import *
>>> CartanType(['A', [Integer(2),Integer(3)]]).type()
'A'