20.1 Cartan types

Module: sage.combinat.root_system.cartan_type

Cartan types

Class: CartanType_abstract

class CartanType_abstract

Abstract class for cartan types

Subclasses should implement:

type() type_string() dynkin_diagram() cartan_matrix() is_finite() is_affine() is_irreducible()

Functions: dual, $\,$ index_set, $\,$ is_affine, $\,$ is_crystalographic, $\,$ is_finite, $\,$ is_irreducible, $\,$ is_reducible, $\,$ is_simple_laced, $\,$ rank, $\,$ root_system, $\,$ type

dual( self)

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

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

index_set( self)

Returns the index set for self.

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

is_affine( self)

Returns whether self is affine.

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

is_crystalographic( self)

Returns whether this Cartan type is simple laced

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( self)

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

sage: from sage.combinat.root_system.cartan_type import CartanType_abstract
sage: C = CartanType_abstract()
sage: C.is_irreducible()
Traceback (most recent call last):
...
NotImplementedError

sage: CartanType(['A',4]).is_finite()
True
sage: CartanType(['A',4, 1]).is_finite()
False

is_irreducible( self)

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

sage: from sage.combinat.root_system.cartan_type import CartanType_abstract
sage: C = CartanType_abstract()
sage: C.is_irreducible()
Traceback (most recent call last):
...
NotImplementedError

is_reducible( self)

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

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

is_simple_laced( self)

Returns whether this Cartan type is simple laced

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( self)

Returns the rank of self.

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

root_system( self)

Returns the root system associated to self.

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

type( self)

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

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

Class: CartanType_simple

class CartanType_simple

Functions: cartan_matrix, $\,$ dual, $\,$ dynkin_diagram, $\,$ is_irreducible, $\,$ type

cartan_matrix( self)

Returns the Cartan matrix associated with self.

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

dual( self)

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

dynkin_diagram( self)

Returns the Dynkin diagram associated with self.

sage: CartanType(['A',4]).dynkin_diagram()
Dynkin diagram of type ['A', 4]

is_irreducible( self)

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

type( self)

Returns the type of self.

sage: CartanType(['A', 4]).type()
'A'
sage: CartanType(['A', 4, 1]).type()
'A'

Special Functions: __cmp__, $\,$ __getitem__

__cmp__( self, 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__( self, x)

sage: t = CartanType(['A', 3, 1])
sage: t[0]
'A'
sage: t[1]
3
sage: t[2]
1
sage: t[3]
Traceback (most recent call last):
...
IndexError: list index out of range

Class: CartanType_simple_affine

class CartanType_simple_affine: A class for affine simple Cartan types

CartanType_simple_affine( self, t)

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

Functions: classical, $\,$ is_affine, $\,$ is_crystalographic, $\,$ is_finite, $\,$ is_simply_laced, $\,$ rank

classical( self)

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

Caveat: only implemented for untwisted

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

is_affine( self)

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

is_crystalographic( self)

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

is_finite( self)

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

is_simply_laced( self)

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( self)

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

Special Functions: __cmp__, $\,$ __init__, $\,$ __len__, $\,$ __repr__

__cmp__( self, other)

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

__len__( self)

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

__repr__( self)

TESTS:

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

Class: CartanType_simple_finite

class CartanType_simple_finite: A class for finite simple Cartan types

CartanType_simple_finite( self, t)

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

Functions: affine, $\,$ dual, $\,$ is_affine, $\,$ is_crystalographic, $\,$ is_finite, $\,$ is_simply_laced, $\,$ rank

affine( self)

Returns the corresponding untwisted affine Cartan type

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

dual( self)

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( self)

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

is_crystalographic( self)

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

is_finite( self)

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

is_simply_laced( self)

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

rank( self)

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

Special Functions: __init__, $\,$ __len__, $\,$ __repr__

__len__( self)

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

__repr__( self)

TESTS:

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

Class: CartanTypeFactory

class CartanTypeFactory

Functions: samples

samples( self, [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

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]]

Special Functions: __call__

__call__( self)

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

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

See About this document... for information on suggesting changes.