Root system data for super type A - Combinatorics

Skip to content
Back to top
View this page
Edit this page

# Root system data for super type A

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

  Bases: `AmbientSpace`

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

  EXAMPLES:

  Sage

      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)}

  Python

      >>> 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

    Bases: `AmbientSpaceElement`

    associated_coroot()

      Return the coroot associated to `self`.

      EXAMPLES:

      Sage

          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)

      Python

          >>> 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)

      alias of `inner_product()`.

    has_descent(i, positive=False)

      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

          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

      Python

          >>> 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)

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

      EXAMPLES:

      Sage

          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]

      Python

          >>> 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()

      Test whether `self` is a dominant element of the weight lattice.

      EXAMPLES:

      Sage

          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

      Python

          >>> 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

          sage: x = Lambda[1] + L([-1,-1,-1])
          sage: x.is_dominant_weight()
          True

      [Python]

          >>> from sage.all import *
          >>> x = Lambda[Integer(1)] + L([-Integer(1),-Integer(1),-Integer(1)])
          >>> x.is_dominant_weight()
          True

    scalar(lambdacheck)

      alias of `inner_product()`.

  dimension()

    Return the dimension of this ambient space.

    EXAMPLES:

    Sage

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

    Python

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

  fundamental_weight(i)

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

    EXAMPLES:

    Sage

        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)]

    Python

        >>> 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

        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]

    [Python]

        >>> 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()

    Return the highest root of `self`.

    EXAMPLES:

    Sage

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

    Python

        >>> 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()

    Return the negative even roots of `self`.

    EXAMPLES:

    Sage

        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)]

    Python

        >>> 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()

    Return the negative odd roots of `self`.

    EXAMPLES:

    Sage

        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)]

    Python

        >>> 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()

    Return the negative roots of `self`.

    EXAMPLES:

    Sage

        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)]

    Python

        >>> 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()

    Return the positive even roots of `self`.

    EXAMPLES:

    Sage

        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)]

    Python

        >>> 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()

    Return the positive odd roots of `self`.

    EXAMPLES:

    Sage

        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)]

    Python

        >>> 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()

    Return the positive roots of `self`.

    EXAMPLES:

    Sage

        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)]

    Python

        >>> 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)

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

    EXAMPLES:

    Sage

        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)]

    Python

        >>> 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)

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

    EXAMPLES:

    Sage

        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)]

    Python

        >>> 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)

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

    See also

    `smallest_base_ring()`

    EXAMPLES:

    Sage

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

    Python

        >>> 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)

  Bases: `SuperCartanType_standard`

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

  See also

  `CartanType()`

  AmbientSpace

    alias of `AmbientSpace`

  ascii_art(label=None, node=None)

    Return an ascii art representation of the Dynkin diagram.

    EXAMPLES:

    Sage

        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

    Python

        >>> 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()

    Return the Cartan matrix associated to `self`.

    EXAMPLES:

    Sage

        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]

    Python

        >>> 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()

    Return dual of `self`.

    EXAMPLES:

    Sage

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

    Python

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

  dynkin_diagram()

    Return the Dynkin diagram of super type A.

    EXAMPLES:

    Sage

        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)]

    Python

        >>> 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()

    Return the index set of `self`.

    EXAMPLES:

    Sage

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

    Python

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

  is_affine()

    Return whether `self` is affine or not.

    EXAMPLES:

    Sage

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

    Python

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

  is_finite()

    Return whether `self` is finite or not.

    EXAMPLES:

    Sage

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

    Python

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

  is_irreducible()

    Return whether `self` is irreducible, which is `True`.

    EXAMPLES:

    Sage

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

    Python

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

  relabel(relabelling)

    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

        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}

    Python

        >>> 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()

    Return root system of `self`.

    EXAMPLES:

    Sage

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

    Python

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

  symmetrizer()

    Return symmetrizing matrix for `self`.

    EXAMPLES:

    Sage

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

    Python

        >>> 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()

    Return type of `self`.

    EXAMPLES:

    Sage

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

    Python

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