Cartan types

class sage.combinat.root_system.cartan_type.CartanTypeFactory
__call__(*args)

Returns an object corresponding to the Cartan type t.

INPUT: [letter, rank] where letter is one of ‘A’,’B’,’C’,’D’,’E’,’F’,’G’ and rank is the rank. An alternative string notation is allowed. A third optional parameter is permitted for affine types. Reducible types may be entered by giving a list of irreducible types or by a single string

EXAMPLES:

sage: CartanType(['A',4])
['A', 4]
sage: CartanType("A4")
['A', 4]
sage: CartanType(['A',2],['B',2])
A2xB2
sage: CartanType(['A',2],['B',2]).is_reducible()
True
sage: CartanType("A2xB2")
A2xB2
sage: CartanType("A2","B2") == CartanType("A2xB2")
True
sage: CartanType(['A',4,1])
['A', 4, 1]
sage: CartanType(['A',4,1]).is_affine()
True
__weakref__
list of weak references to the object (if defined)
samples(finite=False, affine=False, crystalographic=False)

Returns a sample of the implemented cartan types

With finite=True resp. affine=True, one can restrict to finite resp. affine only cartan types

EXAMPLES:

sage: CartanType.samples(finite=True)
[['A', 1], ['A', 5], ['B', 5], ['C', 5], ['D', 5], ['E', 6], ['E', 7], ['E', 8], ['F', 4], ['G', 2], ['I', 5], ['H', 3], ['H', 4]]
sage: CartanType.samples(affine=True)
[['A', 1, 1], ['A', 5, 1], ['B', 5, 1], ['C', 5, 1], ['D', 5, 1], ['E', 6, 1], ['E', 7, 1], ['E', 8, 1], ['F', 4, 1], ['G', 2, 1], ['A', 2, 2], ['A', 10, 2], ['A', 9, 2], ['D', 5, 2], ['D', 4, 3], ['E', 6, 2]]
sage: CartanType.samples()
[['A', 1], ['A', 5], ['B', 5], ['C', 5], ['D', 5], ['E', 6], ['E', 7], ['E', 8], ['F', 4], ['G', 2], ['I', 5], ['H', 3], ['H', 4], ['A', 1, 1], ['A', 5, 1], ['B', 5, 1], ['C', 5, 1], ['D', 5, 1], ['E', 6, 1], ['E', 7, 1], ['E', 8, 1], ['F', 4, 1], ['G', 2, 1], ['A', 2, 2], ['A', 10, 2], ['A', 9, 2], ['D', 5, 2], ['D', 4, 3], ['E', 6, 2]]
sage: CartanType.samples(crystalographic=True)
[['A', 1], ['A', 5], ['B', 5], ['C', 5], ['D', 5], ['E', 6], ['E', 7], ['E', 8], ['F', 4], ['G', 2], ['A', 1, 1], ['A', 5, 1], ['B', 5, 1], ['C', 5, 1], ['D', 5, 1], ['E', 6, 1], ['E', 7, 1], ['E', 8, 1], ['F', 4, 1], ['G', 2, 1], ['A', 2, 2], ['A', 10, 2], ['A', 9, 2], ['D', 5, 2], ['D', 4, 3], ['E', 6, 2]]
class sage.combinat.root_system.cartan_type.CartanType_abstract

Abstract class for cartan types

Subclasses should implement:

  • type()
  • type_string()
  • dynkin_diagram()
  • cartan_matrix()
  • is_finite()
  • is_affine()
  • is_irreducible()
__weakref__
list of weak references to the object (if defined)
dual()

Returns the dual cartan type, possibly just as a formal dual.

EXAMPLES:

sage: CartanType(['F',4]).dual()
['F', 4]^*
index_set()

Returns the index set for self.

EXAMPLES:

sage: CartanType(['A', 3, 1]).index_set()
[0, 1, 2, 3]
sage: CartanType(['D', 4]).index_set()
[1, 2, 3, 4]
is_affine()

Returns whether self is affine.

EXAMPLES:

sage: CartanType(['A', 3]).is_affine()
False
sage: CartanType(['A', 3, 1]).is_affine()
True
is_crystalographic()

Returns whether this Cartan type is simple laced

EXAMPLES:

sage: [ [t, t.is_crystalographic() ] for t in CartanType.samples(finite=True) ]
[[['A', 1], True], [['A', 5], True],
[['B', 5], True], [['C', 5], True], [['D', 5], True],
[['E', 6], True], [['E', 7], True], [['E', 8], True],
[['F', 4], True], [['G', 2], True],
[['I', 5], False], [['H', 3], False], [['H', 4], False]]

TESTS:

sage: all(t.is_crystalographic() for t in CartanType.samples(affine=True))
True
is_finite()

Returns whether this Cartan type is finite. This should be overridden in any subclass.

EXAMPLES:

sage: from sage.combinat.root_system.cartan_type import CartanType_abstract
sage: C = CartanType_abstract()
sage: C.is_irreducible()
...
NotImplementedError
sage: CartanType(['A',4]).is_finite()
True
sage: CartanType(['A',4, 1]).is_finite()
False
is_irreducible()

Report whether this Cartan type is irreducible (i.e. simple). This should be overridden in any subclass.

EXAMPLES:

sage: from sage.combinat.root_system.cartan_type import CartanType_abstract
sage: C = CartanType_abstract()
sage: C.is_irreducible()
...
NotImplementedError
is_reducible()

Report whether the root system is reducible (i.e. not simple), that is whether it can be factored as a product of root systems.

EXAMPLES:

sage: CartanType("A2xB3").is_reducible()
True
sage: CartanType(['A',2]).is_reducible()
False
is_simple_laced()

Returns whether this Cartan type is simple laced

EXAMPLES:

sage: [ [t, t.is_simply_laced() ] for t in CartanType.samples() ]
[[['A', 1], True], [['A', 5], True],
[['B', 5], False], [['C', 5], False], [['D', 5], True],
[['E', 6], True], [['E', 7], True], [['E', 8], True],
[['F', 4], False], [['G', 2], False], [['I', 5], False], [['H', 3], False], [['H', 4], False],
[['A', 1, 1], False], [['A', 5, 1], True],
[['B', 5, 1], False], [['C', 5, 1], False], [['D', 5, 1], True],
[['E', 6, 1], True], [['E', 7, 1], True], [['E', 8, 1], True],
[['F', 4, 1], False], [['G', 2, 1], False],
[['A', 2, 2], False], [['A', 10, 2], False], [['A', 9, 2], False], [['D', 5, 2], False], [['D', 4, 3], False], [['E', 6, 2], False]]
rank()

Returns the rank of self.

EXAMPLES:

sage: CartanType(['A', 4]).rank()
4
sage: CartanType(['A', 7, 2]).rank()
4
sage: CartanType(['I', 8]).rank()
2
root_system()

Returns the root system associated to self.

EXAMPLES:

sage: CartanType(['A',4]).root_system()
Root system of type ['A', 4]
type()

Returns the type of self, or None if unknown. This method should be overridden in any subclass.

EXAMPLES:

sage: from sage.combinat.root_system.cartan_type import CartanType_abstract
sage: C = CartanType_abstract()
sage: C.type() is None
True
class sage.combinat.root_system.cartan_type.CartanType_simple
__cmp__(other)

TESTS:

sage: ct1 = CartanType(['A',4])
sage: ct2 = CartanType(['A',4])
sage: ct3 = CartanType(['A',5])
sage: ct1 == ct2
True
sage: ct1 != ct3
True
__getitem__(x)

EXAMPLES:

sage: t = CartanType(['A', 3, 1])
sage: t[0]
'A'
sage: t[1]
3
sage: t[2]
1
sage: t[3]
...
IndexError: list index out of range
__hash__()

EXAMPLES:

sage: ct = CartanType(['A',2])
sage: hash(ct) #random
-5684143898951441983
cartan_matrix()

Returns the Cartan matrix associated with self.

EXAMPLES:

sage: CartanType(['A',4]).cartan_matrix()
[ 2 -1  0  0]
[-1  2 -1  0]
[ 0 -1  2 -1]
[ 0  0 -1  2]
dual()

EXAMPLES:

sage: CartanType(["A", 3]).dual()
['A', 3]
sage: CartanType(["B", 3]).dual()
['C', 3]
dynkin_diagram()

Returns the Dynkin diagram associated with self.

EXAMPLES:

sage: CartanType(['A',4]).dynkin_diagram()
O---O---O---O
1   2   3   4
A4
is_irreducible()

EXAMPLES:

sage: CartanType(['A', 3]).is_irreducible()
True
type()

Returns the type of self.

EXAMPLES:

sage: CartanType(['A', 4]).type()
'A'
sage: CartanType(['A', 4, 1]).type()
'A'
class sage.combinat.root_system.cartan_type.CartanType_simple_affine(t)

A class for affine simple Cartan types

__cmp__(other)

EXAMPLES:

sage: ct1 = CartanType(['A',3, 1])
sage: ct2 = CartanType(['B',3, 1])
sage: ct3 = CartanType(['A',3])
sage: ct1 == ct1
True
sage: ct1 == ct2
False
sage: ct1 == ct3
False
__init__(t)

EXAMPLES:

sage: ct = CartanType(['A',4])
sage: ct == loads(dumps(ct))
True
__len__()

EXAMPLES:

sage: len(CartanType(['A',4,1]))
3
__repr__()

TESTS:

sage: ct = CartanType(['A',3, 1])
sage: repr(ct)
"['A', 3, 1]"
classical()

Returns the classical Cartan type associated with self (which should be affine)

Caveat: only implemented for untwisted

EXAMPLES:

sage: CartanType(['A', 3, 1]).classical()
['A', 3]
sage: CartanType(['B', 3, 1]).classical()
['B', 3]
is_affine()

EXAMPLES:

sage: CartanType(['A', 3, 1]).is_affine()
True
is_crystalographic()

EXAMPLES:

sage: CartanType(['A', 3, 1]).is_crystalographic()
True
is_finite()

EXAMPLES:

sage: CartanType(['A', 3, 1]).is_finite()
False
is_simply_laced()

EXAMPLES:

sage: CartanType(['A', 3, 1]).is_simply_laced()
True
sage: CartanType(['D', 4, 3]).is_simply_laced()
False
sage: CartanType(['D', 4, 1]).is_simply_laced()
True
sage: CartanType(['B', 4, 1]).is_simply_laced()
False
rank()

EXAMPLES:

sage: CartanType(['D', 4, 3]).rank()
3
sage: CartanType(['B', 4, 1]).rank()
4
class sage.combinat.root_system.cartan_type.CartanType_simple_finite(t)

A class for finite simple Cartan types

__init__(t)

EXAMPLES:

sage: ct = CartanType(['A',4])
sage: ct == loads(dumps(ct))
True
__len__()

EXAMPLES:

sage: len(CartanType(['A',4]))
2
__repr__()

TESTS:

sage: ct = CartanType(['A',3])
sage: repr(ct)
"['A', 3]"
affine()

Returns the corresponding untwisted affine Cartan type

EXAMPLES:

sage: CartanType(['A',3]).affine()
['A', 3, 1]
dual()

EXAMPLES:

sage: CartanType(['A',3]).dual()
['A', 3]
sage: CartanType(['D',4]).dual()
['D', 4]
sage: CartanType(['E',8]).dual()
['E', 8]
sage: CartanType(['B',3]).dual()
['C', 3]
sage: CartanType(['C',2]).dual()
['B', 2]
is_affine()

EXAMPLES:

sage: CartanType(["A", 3]).is_affine()
False
is_crystalographic()

EXAMPLES:

sage: CartanType(["A", 3]).is_crystalographic()
True
sage: CartanType(["I", 2]).is_crystalographic()
False
is_finite()

EXAMPLES:

sage: CartanType(["A", 3]).is_finite()
True
is_simply_laced()

EXAMPLES:

sage: CartanType(['A',3]).is_simply_laced()
True
sage: CartanType(['B',3]).is_simply_laced()
False
rank()

EXAMPLES:

sage: CartanType(["A", 3]).rank()
3

Previous topic

Root Systems

Next topic

Dynkin diagrams

This Page