### Navigation

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

# Ambient lattices and ambient spaces

class `sage.combinat.root_system.ambient_space.``AmbientSpace`(root_system, base_ring)

  Bases: `sage.misc.cachefunc.ClearCacheOnPickle`, `sage.combinat.free_module.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: AL = RootSystem(['A',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: e = AL.basis()
      sage: e[0], e[1], e[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`

  TESTS:

      sage: types = CartanType.samples(crystallographic = True)+[CartanType(["A",2],["C",5])]
      sage: for e in [ct.root_system().ambient_space() for ct in types]:
      ...            TestSuite(e).run()

  `coroot_lattice`()

    EXAMPLES:

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

  `dimension`()

    Returns the dimension of this ambient space.

    EXAMPLES:

        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

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

  `fundamental_weight`(i)

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

  `reflection`(root, coroot=None)

    EXAMPLES:

        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)

  `simple_coroot`(i)

    Returns the i-th simple coroot, as an element of this space

    EXAMPLES:

        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)

  classmethod `smallest_base_ring`(cartan_type=None)

    Returns 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: e = RootSystem(['F',4]).ambient_space()
        sage: e.smallest_base_ring()
        Rational Field

class `sage.combinat.root_system.ambient_space.``AmbientSpaceElement`(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`()

    EXAMPLES:

        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)

  `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: [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: [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: [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)

  `dot_product`(lambdacheck)

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

    EXAMPLES:

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

  `inner_product`(lambdacheck)

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

    EXAMPLES:

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

  `is_positive_root`()

    EXAMPLES:

        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

  `scalar`(lambdacheck)

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

    EXAMPLES:

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

### Navigation

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