Root system data for type F

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

Bases: AmbientSpace

The lattice behind \(F_4\). The computations are based on Bourbaki, Groupes et Algèbres de Lie, Ch. 4,5,6 (planche VIII).

dimension()

Return the dimension of self.

EXAMPLES:

Sage

sage: e = RootSystem(['F',4]).ambient_space()
sage: e.dimension()
4

Python

>>> from sage.all import *
>>> e = RootSystem(['F',Integer(4)]).ambient_space()
>>> e.dimension()
4

fundamental_weights()

Return the fundamental weights of self.

EXAMPLES:

Sage

sage: e =  RootSystem(['F',4]).ambient_space()
sage: e.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)}

Python

>>> from sage.all import *
>>> e =  RootSystem(['F',Integer(4)]).ambient_space()
>>> e.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)}

negative_roots()

Return the negative roots.

EXAMPLES:

Sage

sage: e = RootSystem(['F',4]).ambient_space()
sage: e.negative_roots()
[(-1, 0, 0, 0),
(0, -1, 0, 0),
(0, 0, -1, 0),
(0, 0, 0, -1),
(-1, -1, 0, 0),
(-1, 0, -1, 0),
(-1, 0, 0, -1),
(0, -1, -1, 0),
(0, -1, 0, -1),
(0, 0, -1, -1),
(-1, 1, 0, 0),
(-1, 0, 1, 0),
(-1, 0, 0, 1),
(0, -1, 1, 0),
(0, -1, 0, 1),
(0, 0, -1, 1),
(-1/2, -1/2, -1/2, -1/2),
(-1/2, -1/2, -1/2, 1/2),
(-1/2, -1/2, 1/2, -1/2),
(-1/2, -1/2, 1/2, 1/2),
(-1/2, 1/2, -1/2, -1/2),
(-1/2, 1/2, -1/2, 1/2),
(-1/2, 1/2, 1/2, -1/2),
(-1/2, 1/2, 1/2, 1/2)]

Python

>>> from sage.all import *
>>> e = RootSystem(['F',Integer(4)]).ambient_space()
>>> e.negative_roots()
[(-1, 0, 0, 0),
(0, -1, 0, 0),
(0, 0, -1, 0),
(0, 0, 0, -1),
(-1, -1, 0, 0),
(-1, 0, -1, 0),
(-1, 0, 0, -1),
(0, -1, -1, 0),
(0, -1, 0, -1),
(0, 0, -1, -1),
(-1, 1, 0, 0),
(-1, 0, 1, 0),
(-1, 0, 0, 1),
(0, -1, 1, 0),
(0, -1, 0, 1),
(0, 0, -1, 1),
(-1/2, -1/2, -1/2, -1/2),
(-1/2, -1/2, -1/2, 1/2),
(-1/2, -1/2, 1/2, -1/2),
(-1/2, -1/2, 1/2, 1/2),
(-1/2, 1/2, -1/2, -1/2),
(-1/2, 1/2, -1/2, 1/2),
(-1/2, 1/2, 1/2, -1/2),
(-1/2, 1/2, 1/2, 1/2)]

positive_roots()

Return the positive roots.

These are the roots which are positive with respect to the lexicographic ordering of the basis elements (\(\epsilon_1<\epsilon_2<\epsilon_3<\epsilon_4\)).

EXAMPLES:

Sage

sage: e = RootSystem(['F',4]).ambient_space()
sage: e.positive_roots()
[(1, 0, 0, 0),
(0, 1, 0, 0),
(0, 0, 1, 0),
(0, 0, 0, 1),
(1, 1, 0, 0),
(1, 0, 1, 0),
(1, 0, 0, 1),
(0, 1, 1, 0),
(0, 1, 0, 1),
(0, 0, 1, 1),
(1, -1, 0, 0),
(1, 0, -1, 0),
(1, 0, 0, -1),
(0, 1, -1, 0),
(0, 1, 0, -1),
(0, 0, 1, -1),
(1/2, 1/2, 1/2, 1/2),
(1/2, 1/2, 1/2, -1/2),
(1/2, 1/2, -1/2, 1/2),
(1/2, 1/2, -1/2, -1/2),
(1/2, -1/2, 1/2, 1/2),
(1/2, -1/2, 1/2, -1/2),
(1/2, -1/2, -1/2, 1/2),
(1/2, -1/2, -1/2, -1/2)]
sage: e.rho()
(11/2, 5/2, 3/2, 1/2)

Python

>>> from sage.all import *
>>> e = RootSystem(['F',Integer(4)]).ambient_space()
>>> e.positive_roots()
[(1, 0, 0, 0),
(0, 1, 0, 0),
(0, 0, 1, 0),
(0, 0, 0, 1),
(1, 1, 0, 0),
(1, 0, 1, 0),
(1, 0, 0, 1),
(0, 1, 1, 0),
(0, 1, 0, 1),
(0, 0, 1, 1),
(1, -1, 0, 0),
(1, 0, -1, 0),
(1, 0, 0, -1),
(0, 1, -1, 0),
(0, 1, 0, -1),
(0, 0, 1, -1),
(1/2, 1/2, 1/2, 1/2),
(1/2, 1/2, 1/2, -1/2),
(1/2, 1/2, -1/2, 1/2),
(1/2, 1/2, -1/2, -1/2),
(1/2, -1/2, 1/2, 1/2),
(1/2, -1/2, 1/2, -1/2),
(1/2, -1/2, -1/2, 1/2),
(1/2, -1/2, -1/2, -1/2)]
>>> e.rho()
(11/2, 5/2, 3/2, 1/2)

root(i, j=None, k=None, l=None, p1=0, p2=0, p3=0, p4=0)

Compute a root from base elements of the underlying lattice. The arguments specify the basis elements and the signs. Sadly, the base elements are indexed zero-based. We assume that if one of the indices is not given, the rest are not as well.

EXAMPLES:

Sage

sage: e = RootSystem(['F',4]).ambient_space()
sage: [ e.root(i,j,p2=1) for i in range(e.n) for j in range(i+1,e.n) ]
[(1, -1, 0, 0), (1, 0, -1, 0), (1, 0, 0, -1), (0, 1, -1, 0), (0, 1, 0, -1), (0, 0, 1, -1)]

Python

>>> from sage.all import *
>>> e = RootSystem(['F',Integer(4)]).ambient_space()
>>> [ e.root(i,j,p2=Integer(1)) for i in range(e.n) for j in range(i+Integer(1),e.n) ]
[(1, -1, 0, 0), (1, 0, -1, 0), (1, 0, 0, -1), (0, 1, -1, 0), (0, 1, 0, -1), (0, 0, 1, -1)]

simple_root(i)

Return the \(i\)-th simple root.

It is computed according to what Bourbaki calls the Base:

\[\alpha_1 = \epsilon_2-\epsilon_3, \alpha_2 = \epsilon_3-\epsilon_4, \alpha_3 = \epsilon_4, \alpha_4 = \frac{1}{2} \left( \epsilon_1-\epsilon_2-\epsilon_3-\epsilon_4 \right).\]

EXAMPLES:

Sage

sage: e = RootSystem(['F',4]).ambient_space()
sage: e.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)}

Python

>>> from sage.all import *
>>> e = RootSystem(['F',Integer(4)]).ambient_space()
>>> e.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)}

class sage.combinat.root_system.type_F.CartanType

Bases: CartanType_standard_finite, CartanType_simple, CartanType_crystallographic

EXAMPLES:

Sage

sage: ct = CartanType(['F',4])
sage: ct
['F', 4]
sage: ct._repr_(compact = True)
'F4'

sage: ct.is_irreducible()
True
sage: ct.is_finite()
True
sage: ct.is_crystallographic()
True
sage: ct.is_simply_laced()
False
sage: ct.dual()
['F', 4] relabelled by {1: 4, 2: 3, 3: 2, 4: 1}
sage: ct.affine()
['F', 4, 1]

Python

>>> from sage.all import *
>>> ct = CartanType(['F',Integer(4)])
>>> ct
['F', 4]
>>> ct._repr_(compact = True)
'F4'

>>> ct.is_irreducible()
True
>>> ct.is_finite()
True
>>> ct.is_crystallographic()
True
>>> ct.is_simply_laced()
False
>>> ct.dual()
['F', 4] relabelled by {1: 4, 2: 3, 3: 2, 4: 1}
>>> ct.affine()
['F', 4, 1]

AmbientSpace

alias of AmbientSpace

ascii_art(label=None, node=None)

Return an ascii art representation of the extended Dynkin diagram.

EXAMPLES:

Sage

sage: print(CartanType(['F',4]).ascii_art(label = lambda x: x+2))
O---O=>=O---O
3   4   5   6
sage: print(CartanType(['F',4]).ascii_art(label = lambda x: x-2))
O---O=>=O---O
-1  0   1   2

Python

>>> from sage.all import *
>>> print(CartanType(['F',Integer(4)]).ascii_art(label = lambda x: x+Integer(2)))
O---O=>=O---O
3   4   5   6
>>> print(CartanType(['F',Integer(4)]).ascii_art(label = lambda x: x-Integer(2)))
O---O=>=O---O
-1  0   1   2

coxeter_number()

Return the Coxeter number associated with self.

EXAMPLES:

Sage

sage: CartanType(['F',4]).coxeter_number()
12

Python

>>> from sage.all import *
>>> CartanType(['F',Integer(4)]).coxeter_number()
12

dual()

Return the dual Cartan type.

This uses that \(F_4\) is self-dual up to relabelling.

EXAMPLES:

Sage

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

sage: F4.dynkin_diagram()                                                   # needs sage.graphs
O---O=>=O---O
1   2   3   4
F4
sage: F4.dual().dynkin_diagram()                                            # needs sage.graphs
O---O=>=O---O
4   3   2   1
F4 relabelled by {1: 4, 2: 3, 3: 2, 4: 1}

Python

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

>>> F4.dynkin_diagram()                                                   # needs sage.graphs
O---O=>=O---O
1   2   3   4
F4
>>> F4.dual().dynkin_diagram()                                            # needs sage.graphs
O---O=>=O---O
4   3   2   1
F4 relabelled by {1: 4, 2: 3, 3: 2, 4: 1}

dual_coxeter_number()

Return the dual Coxeter number associated with self.

EXAMPLES:

Sage

sage: CartanType(['F',4]).dual_coxeter_number()
9

Python

>>> from sage.all import *
>>> CartanType(['F',Integer(4)]).dual_coxeter_number()
9

dynkin_diagram()

Return a Dynkin diagram for type F.

EXAMPLES:

Sage

sage: f = CartanType(['F',4]).dynkin_diagram(); f                           # needs sage.graphs
O---O=>=O---O
1   2   3   4
F4
sage: f.edges(sort=True)                                                    # needs sage.graphs
[(1, 2, 1), (2, 1, 1), (2, 3, 2), (3, 2, 1), (3, 4, 1), (4, 3, 1)]

Python

>>> from sage.all import *
>>> f = CartanType(['F',Integer(4)]).dynkin_diagram(); f                           # needs sage.graphs
O---O=>=O---O
1   2   3   4
F4
>>> f.edges(sort=True)                                                    # needs sage.graphs
[(1, 2, 1), (2, 1, 1), (2, 3, 2), (3, 2, 1), (3, 4, 1), (4, 3, 1)]