Root system data for Cartan types with marked nodes#

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

Bases: AmbientSpace

Ambient space for a marked finite Cartan type.

It is constructed in the canonical way from the ambient space of the original Cartan type.

EXAMPLES:

sage: L = CartanType(["F",4]).marked_nodes([1,3]).root_system().ambient_space(); L
Ambient space of the Root system of type ['F', 4] with nodes (1, 3) marked
sage: TestSuite(L).run()                                                        # needs sage.graphs

>>> from sage.all import *
>>> L = CartanType(["F",Integer(4)]).marked_nodes([Integer(1),Integer(3)]).root_system().ambient_space(); L
Ambient space of the Root system of type ['F', 4] with nodes (1, 3) marked
>>> TestSuite(L).run()                                                        # needs sage.graphs
dimension()[source]#

Return the dimension of this ambient space.

See also

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

EXAMPLES:

sage: L = CartanType(["F",4]).marked_nodes([1,3]).root_system().ambient_space()
sage: L.dimension()
4

>>> from sage.all import *
>>> L = CartanType(["F",Integer(4)]).marked_nodes([Integer(1),Integer(3)]).root_system().ambient_space()
>>> L.dimension()
4
fundamental_weight(i)[source]#

Return the i-th fundamental weight.

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

EXAMPLES:

sage: L = CartanType(["F",4]).marked_nodes([1,3]).root_system().ambient_space()
sage: L.fundamental_weight(1)
(1, 1, 0, 0)
sage: L.fundamental_weights()
Finite family {1: (1, 1, 0, 0), 2: (2, 1, 1, 0),
               3: (3/2, 1/2, 1/2, 1/2), 4: (1, 0, 0, 0)}

>>> from sage.all import *
>>> L = CartanType(["F",Integer(4)]).marked_nodes([Integer(1),Integer(3)]).root_system().ambient_space()
>>> L.fundamental_weight(Integer(1))
(1, 1, 0, 0)
>>> L.fundamental_weights()
Finite family {1: (1, 1, 0, 0), 2: (2, 1, 1, 0),
               3: (3/2, 1/2, 1/2, 1/2), 4: (1, 0, 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 original Cartan type.

EXAMPLES:

sage: L = CartanType(["F",4]).marked_nodes([1,3]).root_system().ambient_space()
sage: L.simple_root(1)
(0, 1, -1, 0)
sage: L.simple_roots()
Finite family {1: (0, 1, -1, 0), 2: (0, 0, 1, -1),
               3: (0, 0, 0, 1), 4: (1/2, -1/2, -1/2, -1/2)}
sage: L.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 *
>>> L = CartanType(["F",Integer(4)]).marked_nodes([Integer(1),Integer(3)]).root_system().ambient_space()
>>> L.simple_root(Integer(1))
(0, 1, -1, 0)
>>> L.simple_roots()
Finite family {1: (0, 1, -1, 0), 2: (0, 0, 1, -1),
               3: (0, 0, 0, 1), 4: (1/2, -1/2, -1/2, -1/2)}
>>> L.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_marked.CartanType(ct, marked_nodes)[source]#

Bases: CartanType_decorator

A class for Cartan types with marked nodes.

INPUT:

  • ct – a Cartan type

  • marked_nodes – a list of marked nodes

EXAMPLES:

We take the Cartan type \(B_4\):

sage: T = CartanType(['B',4])
sage: T.dynkin_diagram()                                                        # needs sage.graphs
O---O---O=>=O
1   2   3   4
B4

>>> from sage.all import *
>>> T = CartanType(['B',Integer(4)])
>>> T.dynkin_diagram()                                                        # needs sage.graphs
O---O---O=>=O
1   2   3   4
B4

And mark some of its nodes:

sage: T = T.marked_nodes([2,3])
sage: T.dynkin_diagram()                                                        # needs sage.graphs
O---X---X=>=O
1   2   3   4
B4 with nodes (2, 3) marked

>>> from sage.all import *
>>> T = T.marked_nodes([Integer(2),Integer(3)])
>>> T.dynkin_diagram()                                                        # needs sage.graphs
O---X---X=>=O
1   2   3   4
B4 with nodes (2, 3) marked

Markings are not additive:

sage: T.marked_nodes([1,4]).dynkin_diagram()                                    # needs sage.graphs
X---O---O=>=X
1   2   3   4
B4 with nodes (1, 4) marked

>>> from sage.all import *
>>> T.marked_nodes([Integer(1),Integer(4)]).dynkin_diagram()                                    # needs sage.graphs
X---O---O=>=X
1   2   3   4
B4 with nodes (1, 4) marked

And trivial relabelling are honoured nicely:

sage: T = T.marked_nodes([])
sage: T.dynkin_diagram()                                                        # needs sage.graphs
O---O---O=>=O
1   2   3   4
B4

>>> from sage.all import *
>>> T = T.marked_nodes([])
>>> T.dynkin_diagram()                                                        # needs sage.graphs
O---O---O=>=O
1   2   3   4
B4
ascii_art(label=None, node=None)[source]#

Return an ascii art representation of this Cartan type.

EXAMPLES:

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

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

Implements sage.combinat.root_system.cartan_type.CartanType_abstract.dual(), using that taking the dual and marking nodes are commuting operations.

EXAMPLES:

sage: T = CartanType(["BC",3, 2])
sage: T.marked_nodes([1,3]).dual().dynkin_diagram()                         # needs sage.graphs
O=>=X---O=>=X
0   1   2   3
BC3~* with nodes (1, 3) marked
sage: T.dual().marked_nodes([1,3]).dynkin_diagram()                         # needs sage.graphs
O=>=X---O=>=X
0   1   2   3
BC3~* with nodes (1, 3) marked

>>> from sage.all import *
>>> T = CartanType(["BC",Integer(3), Integer(2)])
>>> T.marked_nodes([Integer(1),Integer(3)]).dual().dynkin_diagram()                         # needs sage.graphs
O=>=X---O=>=X
0   1   2   3
BC3~* with nodes (1, 3) marked
>>> T.dual().marked_nodes([Integer(1),Integer(3)]).dynkin_diagram()                         # needs sage.graphs
O=>=X---O=>=X
0   1   2   3
BC3~* with nodes (1, 3) marked
dynkin_diagram()[source]#

Return the Dynkin diagram for this Cartan type.

EXAMPLES:

sage: CartanType(["G", 2]).marked_nodes([2]).dynkin_diagram()               # needs sage.graphs
  3
O=<=X
1   2
G2 with node 2 marked

>>> from sage.all import *
>>> CartanType(["G", Integer(2)]).marked_nodes([Integer(2)]).dynkin_diagram()               # needs sage.graphs
  3
O=<=X
1   2
G2 with node 2 marked
marked_nodes(marked_nodes)[source]#

Return self with nodes marked_nodes marked.

EXAMPLES:

sage: ct = CartanType(['A',12])
sage: m = ct.marked_nodes([1,4,6,7,8,12]); m
['A', 12] with nodes (1, 4, 6, 7, 8, 12) marked
sage: m.marked_nodes([2])
['A', 12] with node 2 marked
sage: m.marked_nodes([]) is ct
True

>>> from sage.all import *
>>> ct = CartanType(['A',Integer(12)])
>>> m = ct.marked_nodes([Integer(1),Integer(4),Integer(6),Integer(7),Integer(8),Integer(12)]); m
['A', 12] with nodes (1, 4, 6, 7, 8, 12) marked
>>> m.marked_nodes([Integer(2)])
['A', 12] with node 2 marked
>>> m.marked_nodes([]) is ct
True
relabel(relabelling)[source]#

Return the relabelling of self.

EXAMPLES:

sage: T = CartanType(["BC",3, 2])
sage: T.marked_nodes([1,3]).relabel(lambda x: x+2).dynkin_diagram()         # needs sage.graphs
O=<=X---O=<=X
2   3   4   5
BC3~ relabelled by {0: 2, 1: 3, 2: 4, 3: 5} with nodes (3, 5) marked
sage: T.relabel(lambda x: x+2).marked_nodes([3,5]).dynkin_diagram()         # needs sage.graphs
O=<=X---O=<=X
2   3   4   5
BC3~ relabelled by {0: 2, 1: 3, 2: 4, 3: 5} with nodes (3, 5) marked

>>> from sage.all import *
>>> T = CartanType(["BC",Integer(3), Integer(2)])
>>> T.marked_nodes([Integer(1),Integer(3)]).relabel(lambda x: x+Integer(2)).dynkin_diagram()         # needs sage.graphs
O=<=X---O=<=X
2   3   4   5
BC3~ relabelled by {0: 2, 1: 3, 2: 4, 3: 5} with nodes (3, 5) marked
>>> T.relabel(lambda x: x+Integer(2)).marked_nodes([Integer(3),Integer(5)]).dynkin_diagram()         # needs sage.graphs
O=<=X---O=<=X
2   3   4   5
BC3~ relabelled by {0: 2, 1: 3, 2: 4, 3: 5} with nodes (3, 5) marked
type()[source]#

Return the type of self or None if unknown.

EXAMPLES:

sage: ct = CartanType(['F', 4]).marked_nodes([1,3])
sage: ct.type()
'F'

>>> from sage.all import *
>>> ct = CartanType(['F', Integer(4)]).marked_nodes([Integer(1),Integer(3)])
>>> ct.type()
'F'
class sage.combinat.root_system.type_marked.CartanType_affine(ct, marked_nodes)[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]).marked_nodes([1,3]).basic_untwisted()
['A', 7] with nodes (1, 3) marked
sage: CartanType(['D', 4, 3]).marked_nodes([0,2]).basic_untwisted()
['D', 4] with node 2 marked

>>> from sage.all import *
>>> CartanType(['A', Integer(7), Integer(2)]).marked_nodes([Integer(1),Integer(3)]).basic_untwisted()
['A', 7] with nodes (1, 3) marked
>>> CartanType(['D', Integer(4), Integer(3)]).marked_nodes([Integer(0),Integer(2)]).basic_untwisted()
['D', 4] with node 2 marked
classical()[source]#

Return the classical Cartan type associated with self.

EXAMPLES:

sage: T = CartanType(['A',4,1]).marked_nodes([0,2,4])
sage: T.dynkin_diagram()                                                    # needs sage.graphs
0
X-----------+
|           |
|           |
O---X---O---X
1   2   3   4
A4~ with nodes (0, 2, 4) marked

sage: T0 = T.classical(); T0
['A', 4] with nodes (2, 4) marked
sage: T0.dynkin_diagram()                                                   # needs sage.graphs
O---X---O---X
1   2   3   4
A4 with nodes (2, 4) marked

>>> from sage.all import *
>>> T = CartanType(['A',Integer(4),Integer(1)]).marked_nodes([Integer(0),Integer(2),Integer(4)])
>>> T.dynkin_diagram()                                                    # needs sage.graphs
0
X-----------+
|           |
|           |
O---X---O---X
1   2   3   4
A4~ with nodes (0, 2, 4) marked

>>> T0 = T.classical(); T0
['A', 4] with nodes (2, 4) marked
>>> T0.dynkin_diagram()                                                   # needs sage.graphs
O---X---O---X
1   2   3   4
A4 with nodes (2, 4) marked
is_untwisted_affine()[source]#

Implement CartanType_affine.is_untwisted_affine().

A marked Cartan type is untwisted affine if the original is.

EXAMPLES:

sage: CartanType(['B', 3, 1]).marked_nodes([1,3]).is_untwisted_affine()
True

>>> from sage.all import *
>>> CartanType(['B', Integer(3), Integer(1)]).marked_nodes([Integer(1),Integer(3)]).is_untwisted_affine()
True
special_node()[source]#

Return the special node of the Cartan type.

See also

special_node()

It is the special node of the non-marked Cartan type..

EXAMPLES:

sage: CartanType(['B', 3, 1]).marked_nodes([1,3]).special_node()
0

>>> from sage.all import *
>>> CartanType(['B', Integer(3), Integer(1)]).marked_nodes([Integer(1),Integer(3)]).special_node()
0
class sage.combinat.root_system.type_marked.CartanType_finite(ct, marked_nodes)[source]#

Bases: CartanType, CartanType_finite

AmbientSpace[source]#

alias of AmbientSpace

affine()[source]#

Return the affine Cartan type associated with self.

EXAMPLES:

sage: B4 = CartanType(['B',4]).marked_nodes([1,3])
sage: B4.dynkin_diagram()                                                   # needs sage.graphs
X---O---X=>=O
1   2   3   4
B4 with nodes (1, 3) marked
sage: B4.affine().dynkin_diagram()                                          # needs sage.graphs
    O 0
    |
    |
X---O---X=>=O
1   2   3   4
B4~ with nodes (1, 3) marked

>>> from sage.all import *
>>> B4 = CartanType(['B',Integer(4)]).marked_nodes([Integer(1),Integer(3)])
>>> B4.dynkin_diagram()                                                   # needs sage.graphs
X---O---X=>=O
1   2   3   4
B4 with nodes (1, 3) marked
>>> B4.affine().dynkin_diagram()                                          # needs sage.graphs
    O 0
    |
    |
X---O---X=>=O
1   2   3   4
B4~ with nodes (1, 3) marked