Ambient lattices and ambient spaces - Combinatorics

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

# Ambient lattices and ambient spaces

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

  Bases: `CombinatorialFreeModule`

  Abstract class for ambient spaces.

  All subclasses should implement a class method `smallest_base_ring` taking a Cartan type as input, and a method `dimension` working on a partially initialized instance with just `root_system` as attribute. There is no safe default implementation for the later, so none is provided.

  EXAMPLES:

  Sage

      sage: AL = RootSystem(['A',2]).ambient_lattice()

  Python

      >>> from sage.all import *
      >>> AL = RootSystem(['A',Integer(2)]).ambient_lattice()

  Note

  This is only used so far for finite root systems.

  Caveat: Most of the ambient spaces currently have a basis indexed by \(0,\dots, n\), unlike the usual mathematical convention:

  Sage

      sage: e = AL.basis()
      sage: e[0], e[1], e[2]
      ((1, 0, 0), (0, 1, 0), (0, 0, 1))

  [Python]

      >>> from sage.all import *
      >>> e = AL.basis()
      >>> e[Integer(0)], e[Integer(1)], e[Integer(2)]
      ((1, 0, 0), (0, 1, 0), (0, 0, 1))

  This will be cleaned up!

  See also

  - `sage.combinat.root_system.type_A.AmbientSpace`

  - `sage.combinat.root_system.type_B.AmbientSpace`

  - `sage.combinat.root_system.type_C.AmbientSpace`

  - `sage.combinat.root_system.type_D.AmbientSpace`

  - `sage.combinat.root_system.type_E.AmbientSpace`

  - `sage.combinat.root_system.type_F.AmbientSpace`

  - `sage.combinat.root_system.type_G.AmbientSpace`

  - `sage.combinat.root_system.type_dual.AmbientSpace`

  - `sage.combinat.root_system.type_affine.AmbientSpace`

  Element

    alias of `AmbientSpaceElement`

  coroot_lattice()

    EXAMPLES:

    Sage

        sage: e = RootSystem(["A", 3]).ambient_lattice()
        sage: e.coroot_lattice()
        Ambient lattice of the Root system of type ['A', 3]

    Python

        >>> from sage.all import *
        >>> e = RootSystem(["A", Integer(3)]).ambient_lattice()
        >>> e.coroot_lattice()
        Ambient lattice of the Root system of type ['A', 3]

  dimension()

    Return the dimension of this ambient space.

    EXAMPLES:

    Sage

        sage: from sage.combinat.root_system.ambient_space import AmbientSpace
        sage: e = RootSystem(['F',4]).ambient_space()
        sage: AmbientSpace.dimension(e)
        Traceback (most recent call last):
        ...
        NotImplementedError

    Python

        >>> from sage.all import *
        >>> from sage.combinat.root_system.ambient_space import AmbientSpace
        >>> e = RootSystem(['F',Integer(4)]).ambient_space()
        >>> AmbientSpace.dimension(e)
        Traceback (most recent call last):
        ...
        NotImplementedError

  from_vector_notation(weight, style='lattice')

    INPUT:

    - `weight` – a vector or tuple representing a weight

    Returns an element of `self`. If the weight lattice is not of full rank, it coerces it into the weight lattice, or its ambient space by orthogonal projection. This arises in two cases: for SL(r+1), the weight lattice is contained in a hyperplane of codimension one in the ambient, space, and for types E6 and E7, the weight lattice is contained in a subspace of codimensions 2 or 3, respectively.

    If style=”coroots” and the data is a tuple of integers, it is assumed that the data represent a linear combination of fundamental weights. If style=’coroots’, and the root lattice is not of full rank in the ambient space, it is projected into the subspace corresponding to the semisimple derived group. This arises with Cartan type A, E6 and E7.

    EXAMPLES:

    Sage

        sage: RootSystem("A2").ambient_space().from_vector_notation((1,0,0))
        (1, 0, 0)
        sage: RootSystem("A2").ambient_space().from_vector_notation([1,0,0])
        (1, 0, 0)
        sage: RootSystem("A2").ambient_space().from_vector_notation((1,0),style='coroots')
        (2/3, -1/3, -1/3)

    Python

        >>> from sage.all import *
        >>> RootSystem("A2").ambient_space().from_vector_notation((Integer(1),Integer(0),Integer(0)))
        (1, 0, 0)
        >>> RootSystem("A2").ambient_space().from_vector_notation([Integer(1),Integer(0),Integer(0)])
        (1, 0, 0)
        >>> RootSystem("A2").ambient_space().from_vector_notation((Integer(1),Integer(0)),style='coroots')
        (2/3, -1/3, -1/3)

  fundamental_weight(i)

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

    In several of the ambient spaces, it is more convenient to construct all fundamental weights at once. To support this, we provide this default implementation of `fundamental_weight` using the method `fundamental_weights`. Beware that this will cause a loop if neither `fundamental_weight` nor `fundamental_weights` is implemented.

    EXAMPLES:

    Sage

        sage: e =  RootSystem(['F',4]).ambient_space()
        sage: e.fundamental_weight(3)
        (3/2, 1/2, 1/2, 1/2)

        sage: e =  RootSystem(['G',2]).ambient_space()
        sage: e.fundamental_weight(1)
        (1, 0, -1)

        sage: e =  RootSystem(['E',6]).ambient_space()
        sage: e.fundamental_weight(3)
        (-1/2, 1/2, 1/2, 1/2, 1/2, -5/6, -5/6, 5/6)

    Python

        >>> from sage.all import *
        >>> e =  RootSystem(['F',Integer(4)]).ambient_space()
        >>> e.fundamental_weight(Integer(3))
        (3/2, 1/2, 1/2, 1/2)

        >>> e =  RootSystem(['G',Integer(2)]).ambient_space()
        >>> e.fundamental_weight(Integer(1))
        (1, 0, -1)

        >>> e =  RootSystem(['E',Integer(6)]).ambient_space()
        >>> e.fundamental_weight(Integer(3))
        (-1/2, 1/2, 1/2, 1/2, 1/2, -5/6, -5/6, 5/6)

  reflection(root, coroot=None)

    EXAMPLES:

    Sage

        sage: e = RootSystem(["A", 3]).ambient_lattice()
        sage: a = e.simple_root(0); a
        (-1, 0, 0, 0)
        sage: b = e.simple_root(1); b
        (1, -1, 0, 0)
        sage: s_a = e.reflection(a)
        sage: s_a(b)
        (0, -1, 0, 0)

    Python

        >>> from sage.all import *
        >>> e = RootSystem(["A", Integer(3)]).ambient_lattice()
        >>> a = e.simple_root(Integer(0)); a
        (-1, 0, 0, 0)
        >>> b = e.simple_root(Integer(1)); b
        (1, -1, 0, 0)
        >>> s_a = e.reflection(a)
        >>> s_a(b)
        (0, -1, 0, 0)

  simple_coroot(i)

    Return the \(i\)-th simple coroot, as an element of this space.

    EXAMPLES:

    Sage

        sage: R = RootSystem(["A",3])
        sage: L = R.ambient_lattice()
        sage: L.simple_coroot(1)
        (1, -1, 0, 0)
        sage: L.simple_coroot(2)
        (0, 1, -1, 0)
        sage: L.simple_coroot(3)
        (0, 0, 1, -1)

    Python

        >>> from sage.all import *
        >>> R = RootSystem(["A",Integer(3)])
        >>> L = R.ambient_lattice()
        >>> L.simple_coroot(Integer(1))
        (1, -1, 0, 0)
        >>> L.simple_coroot(Integer(2))
        (0, 1, -1, 0)
        >>> L.simple_coroot(Integer(3))
        (0, 0, 1, -1)

  classmethod smallest_base_ring(cartan_type=None)

    Return the smallest ground ring over which the ambient space can be realized.

    This class method will get called with the Cartan type as input. This default implementation returns \(\QQ\); subclasses should override it as appropriate.

    EXAMPLES:

    Sage

        sage: e = RootSystem(['F',4]).ambient_space()
        sage: e.smallest_base_ring()
        Rational Field

    Python

        >>> from sage.all import *
        >>> e = RootSystem(['F',Integer(4)]).ambient_space()
        >>> e.smallest_base_ring()
        Rational Field

  to_ambient_space_morphism()

    Return the identity map on `self`.

    This is present for uniformity of use; the corresponding method for abstract root and weight lattices/spaces, is not trivial.

    EXAMPLES:

    Sage

        sage: P = RootSystem(['A',2]).ambient_space()
        sage: f = P.to_ambient_space_morphism()
        sage: p = P.an_element()
        sage: p
        (2, 2, 3)
        sage: f(p)
        (2, 2, 3)
        sage: f(p)==p
        True

    Python

        >>> from sage.all import *
        >>> P = RootSystem(['A',Integer(2)]).ambient_space()
        >>> f = P.to_ambient_space_morphism()
        >>> p = P.an_element()
        >>> p
        (2, 2, 3)
        >>> f(p)
        (2, 2, 3)
        >>> f(p)==p
        True

class sage.combinat.root_system.ambient_space.AmbientSpaceElement

  Bases: `IndexedFreeModuleElement`

  associated_coroot()

    EXAMPLES:

    Sage

        sage: e = RootSystem(['F',4]).ambient_space()
        sage: a = e.simple_root(0); a
        (1/2, -1/2, -1/2, -1/2)
        sage: a.associated_coroot()
        (1, -1, -1, -1)

    Python

        >>> from sage.all import *
        >>> e = RootSystem(['F',Integer(4)]).ambient_space()
        >>> a = e.simple_root(Integer(0)); a
        (1/2, -1/2, -1/2, -1/2)
        >>> a.associated_coroot()
        (1, -1, -1, -1)

  coerce_to_e6()

    For type E7 or E8, orthogonally projects an element of the root lattice into the E6 root lattice. This operation on weights corresponds to intersection with the semisimple subgroup E6.

    EXAMPLES:

    Sage

        sage: [b.coerce_to_e6() for b in RootSystem("E8").ambient_space().basis()]
        [(1, 0, 0, 0, 0, 0, 0, 0), (0, 1, 0, 0, 0, 0, 0, 0), (0, 0, 1, 0, 0, 0, 0, 0),
        (0, 0, 0, 1, 0, 0, 0, 0), (0, 0, 0, 0, 1, 0, 0, 0), (0, 0, 0, 0, 0, 1/3, 1/3, -1/3),
        (0, 0, 0, 0, 0, 1/3, 1/3, -1/3), (0, 0, 0, 0, 0, -1/3, -1/3, 1/3)]

    Python

        >>> from sage.all import *
        >>> [b.coerce_to_e6() for b in RootSystem("E8").ambient_space().basis()]
        [(1, 0, 0, 0, 0, 0, 0, 0), (0, 1, 0, 0, 0, 0, 0, 0), (0, 0, 1, 0, 0, 0, 0, 0),
        (0, 0, 0, 1, 0, 0, 0, 0), (0, 0, 0, 0, 1, 0, 0, 0), (0, 0, 0, 0, 0, 1/3, 1/3, -1/3),
        (0, 0, 0, 0, 0, 1/3, 1/3, -1/3), (0, 0, 0, 0, 0, -1/3, -1/3, 1/3)]

  coerce_to_e7()

    For type E8, this orthogonally projects the given element of the E8 root lattice into the E7 root lattice. This operation on weights corresponds to intersection with the semisimple subgroup E7.

    EXAMPLES:

    Sage

        sage: [b.coerce_to_e7() for b in RootSystem("E8").ambient_space().basis()]
        [(1, 0, 0, 0, 0, 0, 0, 0), (0, 1, 0, 0, 0, 0, 0, 0),
         (0, 0, 1, 0, 0, 0, 0, 0), (0, 0, 0, 1, 0, 0, 0, 0),
         (0, 0, 0, 0, 1, 0, 0, 0), (0, 0, 0, 0, 0, 1, 0, 0),
         (0, 0, 0, 0, 0, 0, 1/2, -1/2), (0, 0, 0, 0, 0, 0, -1/2, 1/2)]

    Python

        >>> from sage.all import *
        >>> [b.coerce_to_e7() for b in RootSystem("E8").ambient_space().basis()]
        [(1, 0, 0, 0, 0, 0, 0, 0), (0, 1, 0, 0, 0, 0, 0, 0),
         (0, 0, 1, 0, 0, 0, 0, 0), (0, 0, 0, 1, 0, 0, 0, 0),
         (0, 0, 0, 0, 1, 0, 0, 0), (0, 0, 0, 0, 0, 1, 0, 0),
         (0, 0, 0, 0, 0, 0, 1/2, -1/2), (0, 0, 0, 0, 0, 0, -1/2, 1/2)]

  coerce_to_sl()

    For type [‘A’,r], this coerces the element of the ambient space into the root space by orthogonal projection. The root space has codimension one and corresponds to the Lie algebra of SL(r+1,CC), whereas the full weight space corresponds to the Lie algebra of GL(r+1,CC). So this operation corresponds to multiplication by a (possibly fractional) power of the determinant to give a weight determinant one.

    EXAMPLES:

    Sage

        sage: [fw.coerce_to_sl() for fw in RootSystem("A2").ambient_space().fundamental_weights()]
        [(2/3, -1/3, -1/3), (1/3, 1/3, -2/3)]
        sage: L = RootSystem("A2xA3").ambient_space()
        sage: L([1,2,3,4,5,0,0]).coerce_to_sl()
        (-1, 0, 1, 7/4, 11/4, -9/4, -9/4)

    Python

        >>> from sage.all import *
        >>> [fw.coerce_to_sl() for fw in RootSystem("A2").ambient_space().fundamental_weights()]
        [(2/3, -1/3, -1/3), (1/3, 1/3, -2/3)]
        >>> L = RootSystem("A2xA3").ambient_space()
        >>> L([Integer(1),Integer(2),Integer(3),Integer(4),Integer(5),Integer(0),Integer(0)]).coerce_to_sl()
        (-1, 0, 1, 7/4, 11/4, -9/4, -9/4)

  dot_product(lambdacheck)

    alias of `inner_product()`.

  inner_product(lambdacheck)

    The scalar product with elements of the ambient space.

    EXAMPLES:

    Sage

        sage: e = RootSystem(['A',2]).ambient_space()
        sage: a = e.simple_root(0); a
        (-1, 0, 0)
        sage: a.inner_product(a)
        2

    Python

        >>> from sage.all import *
        >>> e = RootSystem(['A',Integer(2)]).ambient_space()
        >>> a = e.simple_root(Integer(0)); a
        (-1, 0, 0)
        >>> a.inner_product(a)
        2

  is_positive_root()

    EXAMPLES:

    Sage

        sage: R = RootSystem(['A',3]).ambient_space()
        sage: r=R.simple_root(1)+R.simple_root(2)
        sage: r.is_positive_root()
        True
        sage: r=R.simple_root(1)-R.simple_root(2)
        sage: r.is_positive_root()
        False

    Python

        >>> from sage.all import *
        >>> R = RootSystem(['A',Integer(3)]).ambient_space()
        >>> r=R.simple_root(Integer(1))+R.simple_root(Integer(2))
        >>> r.is_positive_root()
        True
        >>> r=R.simple_root(Integer(1))-R.simple_root(Integer(2))
        >>> r.is_positive_root()
        False

  scalar(lambdacheck)

    alias of `inner_product()`.

  to_ambient()

    Map `self` to the ambient space.

    This exists for uniformity. Its analogue for root and weight lattice realizations, is not trivial.

    EXAMPLES:

    Sage

        sage: v = CartanType(['C',3]).root_system().ambient_space().an_element(); v
        (2, 2, 3)
        sage: v.to_ambient()
        (2, 2, 3)

    Python

        >>> from sage.all import *
        >>> v = CartanType(['C',Integer(3)]).root_system().ambient_space().an_element(); v
        (2, 2, 3)
        >>> v.to_ambient()
        (2, 2, 3)