Root system data for dual Cartan types

class sage.combinat.root_system.type_dual.AmbientSpace(root_system, base_ring)

Bases: sage.combinat.root_system.ambient_space.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"])
dimension()

Return the dimension of this ambient space.

EXAMPLES:

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

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()
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)}
simple_root(i)

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

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)}
class sage.combinat.root_system.type_dual.CartanType(type)

Bases: sage.structure.unique_representation.UniqueRepresentation, sage.structure.sage_object.SageObject, sage.combinat.root_system.cartan_type.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}

So to exercise this class we consider some non simply laced affine Cartan types and also create explicitely \(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]^*

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

TESTS:

sage: TestSuite(F4d).run(skip=["_test_pickling"])
sage: TestSuite(G21d).run()

Note

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

ascii_art(label=<function <lambda> at 0x7f51a4f4d140>)

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

EXAMPLES:

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

EXAMPLES:

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

EXAMPLES:

sage: ct = CartanType(['F', 4, 1]).dual()
sage: ct.index_set()
(0, 1, 2, 3, 4)
rank()

EXAMPLES:

sage: ct = CartanType(['F', 4, 1]).dual()
sage: ct.rank()
5
class sage.combinat.root_system.type_dual.CartanType_affine(type)

Bases: sage.combinat.root_system.type_dual.CartanType, sage.combinat.root_system.cartan_type.CartanType_affine

INPUT:

  • type – a Cartan type

EXAMPLES:

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

TESTS:

sage: ct1 = CartanType(['B',3,1]).dual()
sage: ct2 = CartanType(['B',3,1]).dual()
sage: ct3 = CartanType(['D',4,1]).dual()
sage: ct1 == ct2
True
sage: ct1 == ct3
False

Test that the produced Cartan type is in the appropriate abstract classes (see trac ticket #13724):

sage: from sage.combinat.root_system import cartan_type
sage: ct = CartanType(['B',3,1]).dual()
sage: TestSuite(ct).run()
sage: isinstance(ct, cartan_type.CartanType_simple)
True
sage: isinstance(ct, cartan_type.CartanType_finite)
False
sage: isinstance(ct, cartan_type.CartanType_affine)
True
sage: isinstance(ct, cartan_type.CartanType_crystallographic)
True
sage: isinstance(ct, cartan_type.CartanType_simply_laced)
False

By default, the dual of a reducible and finite type is not constructed as such:

sage: ct = CartanType([['B',4],['A',2]]).dual(); ct
C4xA2

In order to exercise the dual infrastructure we force the construction as a dual:

sage: from sage.combinat.root_system import type_dual
sage: ct = type_dual.CartanType(CartanType([['B',4],['A',2]])); ct
B4xA2^*
sage: isinstance(ct, type_dual.CartanType)
True
sage: TestSuite(ct).run(skip=["_test_pickling"])
sage: isinstance(ct, cartan_type.CartanType_finite)
True
sage: isinstance(ct, cartan_type.CartanType_simple)
False
sage: isinstance(ct, cartan_type.CartanType_affine)
False
sage: isinstance(ct, cartan_type.CartanType_crystallographic)
True
sage: isinstance(ct, cartan_type.CartanType_simply_laced)
False
basic_untwisted()

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

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

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
class sage.combinat.root_system.type_dual.CartanType_finite(type)

Bases: sage.combinat.root_system.type_dual.CartanType, sage.combinat.root_system.cartan_type.CartanType_finite

INPUT:

  • type – a Cartan type

EXAMPLES:

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

TESTS:

sage: ct1 = CartanType(['B',3,1]).dual()
sage: ct2 = CartanType(['B',3,1]).dual()
sage: ct3 = CartanType(['D',4,1]).dual()
sage: ct1 == ct2
True
sage: ct1 == ct3
False

Test that the produced Cartan type is in the appropriate abstract classes (see trac ticket #13724):

sage: from sage.combinat.root_system import cartan_type
sage: ct = CartanType(['B',3,1]).dual()
sage: TestSuite(ct).run()
sage: isinstance(ct, cartan_type.CartanType_simple)
True
sage: isinstance(ct, cartan_type.CartanType_finite)
False
sage: isinstance(ct, cartan_type.CartanType_affine)
True
sage: isinstance(ct, cartan_type.CartanType_crystallographic)
True
sage: isinstance(ct, cartan_type.CartanType_simply_laced)
False

By default, the dual of a reducible and finite type is not constructed as such:

sage: ct = CartanType([['B',4],['A',2]]).dual(); ct
C4xA2

In order to exercise the dual infrastructure we force the construction as a dual:

sage: from sage.combinat.root_system import type_dual
sage: ct = type_dual.CartanType(CartanType([['B',4],['A',2]])); ct
B4xA2^*
sage: isinstance(ct, type_dual.CartanType)
True
sage: TestSuite(ct).run(skip=["_test_pickling"])
sage: isinstance(ct, cartan_type.CartanType_finite)
True
sage: isinstance(ct, cartan_type.CartanType_simple)
False
sage: isinstance(ct, cartan_type.CartanType_affine)
False
sage: isinstance(ct, cartan_type.CartanType_crystallographic)
True
sage: isinstance(ct, cartan_type.CartanType_simply_laced)
False
AmbientSpace

alias of AmbientSpace

Previous topic

Root system data for affine Cartan types

Next topic

Root system data for reducible Cartan types

This Page