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
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]]
Abstract class for cartan types
Subclasses should implement:
Returns the dual cartan type, possibly just as a formal dual.
EXAMPLES:
sage: CartanType(['F',4]).dual()
['F', 4]^*
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]
Returns whether self is affine.
EXAMPLES:
sage: CartanType(['A', 3]).is_affine()
False
sage: CartanType(['A', 3, 1]).is_affine()
True
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
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
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
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
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]]
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
Returns the root system associated to self.
EXAMPLES:
sage: CartanType(['A',4]).root_system()
Root system of type ['A', 4]
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
TESTS:
sage: ct1 = CartanType(['A',4])
sage: ct2 = CartanType(['A',4])
sage: ct3 = CartanType(['A',5])
sage: ct1 == ct2
True
sage: ct1 != ct3
True
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
EXAMPLES:
sage: ct = CartanType(['A',2])
sage: hash(ct) #random
-5684143898951441983
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]
EXAMPLES:
sage: CartanType(["A", 3]).dual()
['A', 3]
sage: CartanType(["B", 3]).dual()
['C', 3]
Returns the Dynkin diagram associated with self.
EXAMPLES:
sage: CartanType(['A',4]).dynkin_diagram()
O---O---O---O
1 2 3 4
A4
EXAMPLES:
sage: CartanType(['A', 3]).is_irreducible()
True
Returns the type of self.
EXAMPLES:
sage: CartanType(['A', 4]).type()
'A'
sage: CartanType(['A', 4, 1]).type()
'A'
A class for affine simple Cartan types
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
EXAMPLES:
sage: ct = CartanType(['A',4])
sage: ct == loads(dumps(ct))
True
EXAMPLES:
sage: len(CartanType(['A',4,1]))
3
TESTS:
sage: ct = CartanType(['A',3, 1])
sage: repr(ct)
"['A', 3, 1]"
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]
EXAMPLES:
sage: CartanType(['A', 3, 1]).is_affine()
True
EXAMPLES:
sage: CartanType(['A', 3, 1]).is_crystalographic()
True
EXAMPLES:
sage: CartanType(['A', 3, 1]).is_finite()
False
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
EXAMPLES:
sage: CartanType(['D', 4, 3]).rank()
3
sage: CartanType(['B', 4, 1]).rank()
4
A class for finite simple Cartan types
EXAMPLES:
sage: ct = CartanType(['A',4])
sage: ct == loads(dumps(ct))
True
EXAMPLES:
sage: len(CartanType(['A',4]))
2
TESTS:
sage: ct = CartanType(['A',3])
sage: repr(ct)
"['A', 3]"
Returns the corresponding untwisted affine Cartan type
EXAMPLES:
sage: CartanType(['A',3]).affine()
['A', 3, 1]
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]
EXAMPLES:
sage: CartanType(["A", 3]).is_affine()
False
EXAMPLES:
sage: CartanType(["A", 3]).is_crystalographic()
True
sage: CartanType(["I", 2]).is_crystalographic()
False
EXAMPLES:
sage: CartanType(["A", 3]).is_finite()
True
EXAMPLES:
sage: CartanType(['A',3]).is_simply_laced()
True
sage: CartanType(['B',3]).is_simply_laced()
False
EXAMPLES:
sage: CartanType(["A", 3]).rank()
3