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()
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)
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 vs
catch because type
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)}
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)}
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()
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
EXAMPLES:
sage: ct = CartanType(['F', 4]).dual()
sage: ct.dual()
['F', 4]
EXAMPLES:
sage: ct = CartanType(['F', 4]).dual()
sage: ct.dynkin_diagram()
O---O=<=O---O
1 2 3 4
F4*
EXAMPLES:
sage: ct = CartanType(['F', 4]).dual()
sage: ct.index_set()
[1, 2, 3, 4]
EXAMPLES:
sage: ct = CartanType(['F', 4]).dual()
sage: ct.rank()
4
Bases: sage.combinat.root_system.cartan_type.CartanType_affine
x.__init__(...) initializes x; see help(type(x)) for signature
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]
Implement CartanType_affine.special_node()
The special node of the dual of an affine type is the
special node of
.
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
Bases: sage.combinat.root_system.cartan_type.CartanType_finite
x.__init__(...) initializes x; see help(type(x)) for signature
alias of AmbientSpace