### Navigation

- index
- modules |
- next |
- previous |
- Combinatorics »
- Root Systems »

# Root lattices and root spaces

class `sage.combinat.root_system.root_space.``RootSpace`(root_system, base_ring)

  Bases: `sage.misc.cachefunc.ClearCacheOnPickle`, `sage.combinat.free_module.CombinatorialFreeModule`

  The root space of a root system over a given base ring

  INPUT:

  - `root_system` - a root system
  - `base_ring`: a ring \(R\)

  The root space (or lattice if `base_ring` is \(\ZZ\)) of a root system is the formal free module \(\bigoplus_i R \alpha_i\) generated by the simple roots \((\alpha_i)_{i\in I}\) of the root system.

  This class is also used for coroot spaces (or lattices).

  See also

  - `RootSystem()`
  - `RootSystem.root_lattice()` and `RootSystem.root_space()`
  - `RootLatticeRealizations()`

  Todo: standardize the variable used for the root space in the examples (P?)

  TESTS:

      sage: for ct in CartanType.samples(crystallographic=True)+[CartanType(["A",2],["C",5,1])]:
      ...       TestSuite(ct.root_system().root_lattice()).run()
      ...       TestSuite(ct.root_system().root_space()).run()
      sage: r = RootSystem(['A',4]).root_lattice()
      sage: r.simple_root(1)
      alpha[1]
      sage: latex(r.simple_root(1))
      \alpha_{1}

  `Element`

    alias of `RootSpaceElement`

  `simple_root`()

    INPUT:

    > - ‘’i’‘

    Returns the basis element indexed by i

    EXAMPLES:

        sage: F = CombinatorialFreeModule(QQ, ['a', 'b', 'c'])
        sage: F.monomial('a')
        B['a']

    F.monomial is in fact (almost) a map:

        sage: F.monomial
        Term map from {'a', 'b', 'c'} to Free module generated by {'a', 'b', 'c'} over Rational Field

  `to_coroot_space_morphism`()

    Returns the `nu` map to the coroot space over the same base ring, using the symmetrizer of the Cartan matrix

    It does not map the root lattice to the coroot lattice, but has the property that any root is mapped to some scalar multiple of its associated coroot.

    EXAMPLES:

        sage: R = RootSystem(['A',3]).root_space()
        sage: alpha = R.simple_roots()
        sage: f = R.to_coroot_space_morphism()
        sage: f(alpha[1])
        alphacheck[1]
        sage: f(alpha[1]+alpha[2])
        alphacheck[1] + alphacheck[2]

        sage: R = RootSystem(['A',3]).root_lattice()
        sage: alpha = R.simple_roots()
        sage: f = R.to_coroot_space_morphism()
        sage: f(alpha[1])
        alphacheck[1]
        sage: f(alpha[1]+alpha[2])
        alphacheck[1] + alphacheck[2]

        sage: S = RootSystem(['G',2]).root_space()
        sage: alpha = S.simple_roots()
        sage: f = S.to_coroot_space_morphism()
        sage: f(alpha[1])
        alphacheck[1]
        sage: f(alpha[1]+alpha[2])
        alphacheck[1] + 3*alphacheck[2]

class `sage.combinat.root_system.root_space.``RootSpaceElement`(M, x)

  Bases: `sage.combinat.free_module.CombinatorialFreeModuleElement`

  Create a combinatorial module element. This should never be called directly, but only through the parent combinatorial free module’s `__call__()` method.

  TESTS:

      sage: F = CombinatorialFreeModule(QQ, ['a','b','c'])
      sage: B = F.basis()
      sage: f = B['a'] + 3*B['c']; f
      B['a'] + 3*B['c']
      sage: f == loads(dumps(f))
      True

  `associated_coroot`()

    Returns the coroot associated to this root

    OUTPUT:

    An element of the coroot space over the same base ring; in particular the result is in the coroot lattice whenever `self` is in the root lattice.

    EXAMPLES:

        sage: L = RootSystem(["B", 3]).root_space()
        sage: alpha = L.simple_roots()
        sage: alpha[1].associated_coroot()
        alphacheck[1]
        sage: alpha[1].associated_coroot().parent()
        Coroot space over the Rational Field of the Root system of type ['B', 3]

        sage: L.highest_root()
        alpha[1] + 2*alpha[2] + 2*alpha[3]
        sage: L.highest_root().associated_coroot()
        alphacheck[1] + 2*alphacheck[2] + alphacheck[3]

        sage: alpha = RootSystem(["B", 3]).root_lattice().simple_roots()
        sage: alpha[1].associated_coroot()
        alphacheck[1]
        sage: alpha[1].associated_coroot().parent()
        Coroot lattice of the Root system of type ['B', 3]

  `is_positive_root`()

    Checks whether an element in the root space lies in the nonnegative cone spanned by the simple roots.

    EXAMPLES:

        sage: R=RootSystem(['A',3,1]).root_space()
        sage: B=R.basis()
        sage: w=B[0]+B[3]
        sage: w.is_positive_root()
        True
        sage: w=B[1]-B[2]
        sage: w.is_positive_root()
        False

  `max_coroot_le`()

    Returns the highest positive coroot whose associated root is less than or equal to `self`.

    INPUT:

    - `self` – an element of the nonnegative integer span of simple roots.

    Returns None for the zero element.

    Really `self` is an element of a coroot lattice and this method returns the highest root whose associated coroot is <= `self`.

    Warning

    This implementation only handles finite Cartan types

    EXAMPLES:

        sage: root_lattice = RootSystem(['C',2]).root_lattice()
        sage: root_lattice.from_vector(vector([1,1])).max_coroot_le()
        alphacheck[1] + 2*alphacheck[2]
        sage: root_lattice.from_vector(vector([2,1])).max_coroot_le()
        alphacheck[1] + 2*alphacheck[2]
        sage: root_lattice = RootSystem(['B',2]).root_lattice()
        sage: root_lattice.from_vector(vector([1,1])).max_coroot_le()
        2*alphacheck[1] + alphacheck[2]
        sage: root_lattice.from_vector(vector([1,2])).max_coroot_le()
        2*alphacheck[1] + alphacheck[2]

        sage: root_lattice.zero().max_coroot_le() is None
        True
        sage: root_lattice.from_vector(vector([-1,0])).max_coroot_le()
        Traceback (most recent call last):
        ...
        ValueError: -alpha[1] is not in the positive cone of roots
        sage: root_lattice = RootSystem(['A',2,1]).root_lattice()
        sage: root_lattice.simple_root(1).max_coroot_le()
        Traceback (most recent call last):
        ...
        NotImplementedError: Only implemented for finite Cartan type

  `max_quantum_element`()

    Returns a reduced word for the longest element of the Weyl group whose shortest path in the quantum Bruhat graph to the identity, has sum of quantum coroots at most `self`.

    INPUT:

    - `self` – an element of the nonnegative integer span of simple roots.

    Really `self` is an element of a coroot lattice.

    Warning

    This implementation only handles finite Cartan types

    EXAMPLES:

        sage: Qvee = RootSystem(['C',2]).coroot_lattice()
        sage: Qvee.from_vector(vector([1,2])).max_quantum_element()
        [2, 1, 2, 1]
        sage: Qvee.from_vector(vector([1,1])).max_quantum_element()
        [1, 2, 1]
        sage: Qvee.from_vector(vector([0,2])).max_quantum_element()
        [2]

  `quantum_root`()

    Returns True if `self` is a quantum root and False otherwise.

    INPUT:

    - `self` – an element of the nonnegative integer span of simple roots.

    A root \(\alpha\) is a quantum root if \(\ell(s_\alpha) = \langle 2 \rho, \alpha^\vee \rangle - 1\) where \(\ell\) is the length function, \(s_\alpha\) is the reflection across the hyperplane orthogonal to \(\alpha\), and \(2\rho\) is the sum of positive roots.

    Warning

    This implementation only handles finite Cartan types and assumes that `self` is a root.

    Todo

    Rename to is_quantum_root

    EXAMPLES:

        sage: Q = RootSystem(['C',2]).root_lattice()
        sage: positive_roots = Q.positive_roots()
        sage: for x in positive_roots:
        ....:     print x, x.quantum_root()
        alpha[1] True
        alpha[2] True
        2*alpha[1] + alpha[2] True
        alpha[1] + alpha[2] False

  `scalar`(lambdacheck)

    The scalar product between the root lattice and the coroot lattice.

    EXAMPLES:

        sage: L = RootSystem(['B',4]).root_lattice()
        sage: alpha      = L.simple_roots()
        sage: alphacheck = L.simple_coroots()
        sage: alpha[1].scalar(alphacheck[1])
        2
        sage: alpha[1].scalar(alphacheck[2])
        -1

    The scalar products between the roots and coroots are given by the Cartan matrix:

        sage: matrix([ [ alpha[i].scalar(alphacheck[j])
        ...              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 -2  2]

        sage: L.cartan_type().cartan_matrix()
        [ 2 -1  0  0]
        [-1  2 -1  0]
        [ 0 -1  2 -1]
        [ 0  0 -2  2]

### Navigation

- index
- modules |
- next |
- previous |
- Combinatorics »
- Root Systems »