Ambient lattices and ambient spaces#

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

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: AL = RootSystem(['A',2]).ambient_lattice()

>>> 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: e = AL.basis()
sage: e[0], e[1], e[2]
((1, 0, 0), (0, 1, 0), (0, 0, 1))

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

Element[source]#

alias of AmbientSpaceElement

coroot_lattice()[source]#

EXAMPLES:

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

>>> 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()[source]#

Return 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 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')[source]#

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)

>>> 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)[source]#

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)

>>> 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)[source]#

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)

>>> 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)[source]#

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)

>>> 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)[source]#

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

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

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

>>> 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[source]#

Bases: IndexedFreeModuleElement

associated_coroot()[source]#

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)

>>> 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()[source]#

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

>>> 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()[source]#

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

>>> 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()[source]#

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)

>>> 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)[source]#

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

>>> 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
inner_product(lambdacheck)[source]#

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

>>> 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()[source]#

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

>>> 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)[source]#

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

>>> 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
to_ambient()[source]#

Map self to the ambient space.

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

EXAMPLES:

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

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