Root system data for dual Cartan types#

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

Bases: AmbientSpace

Ambient space for a dual finite Cartan type.

It is constructed in the canonical way from the ambient space of the original Cartan type by switching the roles of simple roots, fundamental weights, etc.

Note

Recall that, for any finite Cartan type, and in particular the a simply laced one, the dual Cartan type is constructed as another preexisting Cartan type. Furthermore the ambient space for an affine type is constructed from the ambient space for its classical type. Thus this code is not actually currently used.

It is kept for cross-checking and for reference in case it could become useful, e.g., for dual of general Kac-Moody types.

For the doctests, we need to explicitly create a dual type. Subsequently, since reconstruction of the dual of type \(F_4\) is the relabelled Cartan type, pickling fails on the TestSuite run.

EXAMPLES:

sage: ct = sage.combinat.root_system.type_dual.CartanType(CartanType(['F',4]))
sage: L = ct.root_system().ambient_space(); L
Ambient space of the Root system of type ['F', 4]^*
sage: TestSuite(L).run(skip=["_test_elements","_test_pickling"])                # needs sage.graphs

>>> from sage.all import *
>>> ct = sage.combinat.root_system.type_dual.CartanType(CartanType(['F',Integer(4)]))
>>> L = ct.root_system().ambient_space(); L
Ambient space of the Root system of type ['F', 4]^*
>>> TestSuite(L).run(skip=["_test_elements","_test_pickling"])                # needs sage.graphs
dimension()[source]#

Return the dimension of this ambient space.

See also

sage.combinat.root_system.ambient_space.AmbientSpace.dimension()

EXAMPLES:

sage: ct = sage.combinat.root_system.type_dual.CartanType(CartanType(['F',4]))
sage: L = ct.root_system().ambient_space()
sage: L.dimension()
4

>>> from sage.all import *
>>> ct = sage.combinat.root_system.type_dual.CartanType(CartanType(['F',Integer(4)]))
>>> L = ct.root_system().ambient_space()
>>> L.dimension()
4
fundamental_weights()[source]#

Return the fundamental weights.

They are computed from the simple roots by inverting the Cartan matrix. This is acceptable since this is only about ambient spaces for finite Cartan types. Also, we do not have to worry about the usual \(GL_n\) vs \(SL_n\) catch because type \(A\) is self dual.

An alternative would have been to start from the fundamental coweights in the dual ambient space, but those are not yet implemented.

EXAMPLES:

sage: ct = sage.combinat.root_system.type_dual.CartanType(CartanType(['F',4]))
sage: L = ct.root_system().ambient_space()
sage: L.fundamental_weights()                                               # needs sage.graphs
Finite family {1: (1, 1, 0, 0), 2: (2, 1, 1, 0), 3: (3, 1, 1, 1), 4: (2, 0, 0, 0)}

>>> from sage.all import *
>>> ct = sage.combinat.root_system.type_dual.CartanType(CartanType(['F',Integer(4)]))
>>> L = ct.root_system().ambient_space()
>>> L.fundamental_weights()                                               # needs sage.graphs
Finite family {1: (1, 1, 0, 0), 2: (2, 1, 1, 0), 3: (3, 1, 1, 1), 4: (2, 0, 0, 0)}

Note that this ambient space is isomorphic, but not equal, to that obtained by constructing \(F_4\) dual by relabelling:

sage: ct = CartanType(['F',4]).dual(); ct
['F', 4] relabelled by {1: 4, 2: 3, 3: 2, 4: 1}
sage: ct.root_system().ambient_space().fundamental_weights()
Finite family {1: (1, 0, 0, 0), 2: (3/2, 1/2, 1/2, 1/2), 3: (2, 1, 1, 0), 4: (1, 1, 0, 0)}

>>> from sage.all import *
>>> ct = CartanType(['F',Integer(4)]).dual(); ct
['F', 4] relabelled by {1: 4, 2: 3, 3: 2, 4: 1}
>>> ct.root_system().ambient_space().fundamental_weights()
Finite family {1: (1, 0, 0, 0), 2: (3/2, 1/2, 1/2, 1/2), 3: (2, 1, 1, 0), 4: (1, 1, 0, 0)}
simple_root(i)[source]#

Return the i-th simple root.

It is constructed by looking up the corresponding simple coroot in the ambient space for the dual Cartan type.

EXAMPLES:

sage: ct = sage.combinat.root_system.type_dual.CartanType(CartanType(['F',4]))
sage: ct.root_system().ambient_space().simple_root(1)
(0, 1, -1, 0)

sage: ct.root_system().ambient_space().simple_roots()
Finite family {1: (0, 1, -1, 0), 2: (0, 0, 1, -1), 3: (0, 0, 0, 2), 4: (1, -1, -1, -1)}

sage: ct.dual().root_system().ambient_space().simple_coroots()
Finite family {1: (0, 1, -1, 0), 2: (0, 0, 1, -1), 3: (0, 0, 0, 2), 4: (1, -1, -1, -1)}

>>> from sage.all import *
>>> ct = sage.combinat.root_system.type_dual.CartanType(CartanType(['F',Integer(4)]))
>>> ct.root_system().ambient_space().simple_root(Integer(1))
(0, 1, -1, 0)

>>> ct.root_system().ambient_space().simple_roots()
Finite family {1: (0, 1, -1, 0), 2: (0, 0, 1, -1), 3: (0, 0, 0, 2), 4: (1, -1, -1, -1)}

>>> ct.dual().root_system().ambient_space().simple_coroots()
Finite family {1: (0, 1, -1, 0), 2: (0, 0, 1, -1), 3: (0, 0, 0, 2), 4: (1, -1, -1, -1)}

Note that this ambient space is isomorphic, but not equal, to that obtained by constructing \(F_4\) dual by relabelling:

sage: ct = CartanType(['F',4]).dual(); ct
['F', 4] relabelled by {1: 4, 2: 3, 3: 2, 4: 1}
sage: ct.root_system().ambient_space().simple_roots()
Finite family {1: (1/2, -1/2, -1/2, -1/2), 2: (0, 0, 0, 1), 3: (0, 0, 1, -1), 4: (0, 1, -1, 0)}

>>> from sage.all import *
>>> ct = CartanType(['F',Integer(4)]).dual(); ct
['F', 4] relabelled by {1: 4, 2: 3, 3: 2, 4: 1}
>>> ct.root_system().ambient_space().simple_roots()
Finite family {1: (1/2, -1/2, -1/2, -1/2), 2: (0, 0, 0, 1), 3: (0, 0, 1, -1), 4: (0, 1, -1, 0)}
class sage.combinat.root_system.type_dual.CartanType(type)[source]#

Bases: CartanType_decorator, CartanType_crystallographic

A class for dual Cartan types.

The dual of a (crystallographic) Cartan type is a Cartan type with the same index set, but all arrows reversed in the Dynkin diagram (otherwise said, the Cartan matrix is transposed). It shares a lot of properties in common with its dual. In particular, the Weyl group is isomorphic to that of the dual as a Coxeter group.

EXAMPLES:

For all finite Cartan types, and in particular the simply laced ones, the dual Cartan type is given by another preexisting Cartan type:

sage: CartanType(['A',4]).dual()
['A', 4]
sage: CartanType(['B',4]).dual()
['C', 4]
sage: CartanType(['C',4]).dual()
['B', 4]
sage: CartanType(['F',4]).dual()
['F', 4] relabelled by {1: 4, 2: 3, 3: 2, 4: 1}

>>> from sage.all import *
>>> CartanType(['A',Integer(4)]).dual()
['A', 4]
>>> CartanType(['B',Integer(4)]).dual()
['C', 4]
>>> CartanType(['C',Integer(4)]).dual()
['B', 4]
>>> CartanType(['F',Integer(4)]).dual()
['F', 4] relabelled by {1: 4, 2: 3, 3: 2, 4: 1}

So to exercise this class we consider some non simply laced affine Cartan types and also create explicitly \(F_4^*\) as a dual cartan type:

sage: from sage.combinat.root_system.type_dual import CartanType as CartanTypeDual
sage: F4d = CartanTypeDual(CartanType(['F',4])); F4d
['F', 4]^*
sage: G21d = CartanType(['G',2,1]).dual(); G21d
['G', 2, 1]^*

>>> from sage.all import *
>>> from sage.combinat.root_system.type_dual import CartanType as CartanTypeDual
>>> F4d = CartanTypeDual(CartanType(['F',Integer(4)])); F4d
['F', 4]^*
>>> G21d = CartanType(['G',Integer(2),Integer(1)]).dual(); G21d
['G', 2, 1]^*

They share many properties with their original Cartan types:

sage: F4d.is_irreducible()
True
sage: F4d.is_crystallographic()
True
sage: F4d.is_simply_laced()
False
sage: F4d.is_finite()
True
sage: G21d.is_finite()
False
sage: F4d.is_affine()
False
sage: G21d.is_affine()
True

>>> from sage.all import *
>>> F4d.is_irreducible()
True
>>> F4d.is_crystallographic()
True
>>> F4d.is_simply_laced()
False
>>> F4d.is_finite()
True
>>> G21d.is_finite()
False
>>> F4d.is_affine()
False
>>> G21d.is_affine()
True

Note

F4d is pickled by construction as F4.dual() hence the above failure.

ascii_art(label=None, node=None)[source]#

Return an ascii art representation of this Cartan type

(by hacking the ascii art representation of the dual Cartan type)

EXAMPLES:

sage: print(CartanType(["B", 3, 1]).dual().ascii_art())
    O 0
    |
    |
O---O=<=O
1   2   3
sage: print(CartanType(["C", 4, 1]).dual().ascii_art())
O=<=O---O---O=>=O
0   1   2   3   4
sage: print(CartanType(["G", 2, 1]).dual().ascii_art())
  3
O=>=O---O
1   2   0
sage: print(CartanType(["F", 4, 1]).dual().ascii_art())
O---O---O=<=O---O
0   1   2   3   4
sage: print(CartanType(["BC", 4, 2]).dual().ascii_art())
O=>=O---O---O=>=O
0   1   2   3   4

>>> from sage.all import *
>>> print(CartanType(["B", Integer(3), Integer(1)]).dual().ascii_art())
    O 0
    |
    |
O---O=<=O
1   2   3
>>> print(CartanType(["C", Integer(4), Integer(1)]).dual().ascii_art())
O=<=O---O---O=>=O
0   1   2   3   4
>>> print(CartanType(["G", Integer(2), Integer(1)]).dual().ascii_art())
  3
O=>=O---O
1   2   0
>>> print(CartanType(["F", Integer(4), Integer(1)]).dual().ascii_art())
O---O---O=<=O---O
0   1   2   3   4
>>> print(CartanType(["BC", Integer(4), Integer(2)]).dual().ascii_art())
O=>=O---O---O=>=O
0   1   2   3   4
dual()[source]#

EXAMPLES:

sage: ct = CartanType(['F', 4, 1]).dual()
sage: ct.dual()
['F', 4, 1]

>>> from sage.all import *
>>> ct = CartanType(['F', Integer(4), Integer(1)]).dual()
>>> ct.dual()
['F', 4, 1]
dynkin_diagram()[source]#

EXAMPLES:

sage: ct = CartanType(['F', 4, 1]).dual()
sage: ct.dynkin_diagram()                                                   # needs sage.graphs
O---O---O=<=O---O
0   1   2   3   4
F4~*

>>> from sage.all import *
>>> ct = CartanType(['F', Integer(4), Integer(1)]).dual()
>>> ct.dynkin_diagram()                                                   # needs sage.graphs
O---O---O=<=O---O
0   1   2   3   4
F4~*
class sage.combinat.root_system.type_dual.CartanType_affine(type)[source]#

Bases: CartanType, CartanType_affine

basic_untwisted()[source]#

Return the basic untwisted Cartan type associated with this affine Cartan type.

Given an affine type \(X_n^{(r)}\), the basic untwisted type is \(X_n\). In other words, it is the classical Cartan type that is twisted to obtain self.

EXAMPLES:

sage: CartanType(['A', 7, 2]).basic_untwisted()
['A', 7]
sage: CartanType(['E', 6, 2]).basic_untwisted()
['E', 6]
sage: CartanType(['D', 4, 3]).basic_untwisted()
['D', 4]

>>> from sage.all import *
>>> CartanType(['A', Integer(7), Integer(2)]).basic_untwisted()
['A', 7]
>>> CartanType(['E', Integer(6), Integer(2)]).basic_untwisted()
['E', 6]
>>> CartanType(['D', Integer(4), Integer(3)]).basic_untwisted()
['D', 4]
classical()[source]#

Return the classical Cartan type associated with self (which should be affine).

EXAMPLES:

sage: CartanType(['A',3,1]).dual().classical()
['A', 3]
sage: CartanType(['B',3,1]).dual().classical()
['C', 3]
sage: CartanType(['F',4,1]).dual().classical()
['F', 4] relabelled by {1: 4, 2: 3, 3: 2, 4: 1}
sage: CartanType(['BC',4,2]).dual().classical()
['B', 4]

>>> from sage.all import *
>>> CartanType(['A',Integer(3),Integer(1)]).dual().classical()
['A', 3]
>>> CartanType(['B',Integer(3),Integer(1)]).dual().classical()
['C', 3]
>>> CartanType(['F',Integer(4),Integer(1)]).dual().classical()
['F', 4] relabelled by {1: 4, 2: 3, 3: 2, 4: 1}
>>> CartanType(['BC',Integer(4),Integer(2)]).dual().classical()
['B', 4]
special_node()[source]#

Implement CartanType_affine.special_node()

The special node of the dual of an affine type \(T\) is the special node of \(T\).

EXAMPLES:

sage: CartanType(['A',3,1]).dual().special_node()
0
sage: CartanType(['B',3,1]).dual().special_node()
0
sage: CartanType(['F',4,1]).dual().special_node()
0
sage: CartanType(['BC',4,2]).dual().special_node()
0

>>> from sage.all import *
>>> CartanType(['A',Integer(3),Integer(1)]).dual().special_node()
0
>>> CartanType(['B',Integer(3),Integer(1)]).dual().special_node()
0
>>> CartanType(['F',Integer(4),Integer(1)]).dual().special_node()
0
>>> CartanType(['BC',Integer(4),Integer(2)]).dual().special_node()
0
class sage.combinat.root_system.type_dual.CartanType_finite(type)[source]#

Bases: CartanType, CartanType_finite

AmbientSpace[source]#

alias of AmbientSpace