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.

EXAMPLES:

sage: F4 = CartanType(["F",4])
sage: L = F4.dual().root_system().ambient_space(); L
Ambient space of the Root system of type ['F', 4]^*
sage: TestSuite(L).run()
dimension()

Return the dimension of this ambient space.

EXAMPLES:

sage: F4 = CartanType(["F",4])
sage: F4.dual().root_system().ambient_space().simple_root(1)
(0, 1, -1, 0)
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: L = CartanType(["F",4]).dual().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)}
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: F4 = CartanType(["F",4])
sage: F4.dual().root_system().ambient_space().simple_root(1)
(0, 1, -1, 0)

sage: F4.dual().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: F4.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)}
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_crystalographic

A class for dual Cartan types

The dual of a (crystalographic) 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 most 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]

So to exercise this class we need to consider the non simply laced exceptionnal or affine Cartan types:

sage: F4d = CartanType(['F', 4]).dual(); F4d
['F', 4]^*
sage: G21d = CartanType(['G',2,1]).dual(); G21d
['G', 2, 1]^*
sage: B41d = CartanType(['B',4,1]).dual(); B41d
['B', 4, 1]^*

They share many properties with their original Cartan types:

sage: F4d.is_irreducible()
True
sage: F4d.is_crystalographic()
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()
ascii_art(label=<function <lambda> at 0xedc2050>)

Return an ascii art representation of this Cartan type

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

EXAMPLES:

sage: print CartanType(["G", 2]).dual().ascii_art()
  3
O=>=O
1   2
sage: print CartanType(["F", 4]).dual().ascii_art()
O---O=<=O---O
1   2   3   4
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]).dual()
sage: ct.dual()
['F', 4]
dynkin_diagram()

EXAMPLES:

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

EXAMPLES:

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

EXAMPLES:

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

Bases: sage.combinat.root_system.cartan_type.CartanType_affine

x.__init__(...) initializes x; see help(type(x)) for signature

classical()

Returns 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]^*
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

Bases: sage.combinat.root_system.cartan_type.CartanType_finite

x.__init__(...) initializes x; see help(type(x)) for signature

AmbientSpace

alias of AmbientSpace

Previous topic

Root system data for affine Cartan types

Next topic

Root system data for reducible Cartan types

This Page