Coxeter types - Combinatorics

Skip to content
Back to top
View this page
Edit this page

# Coxeter types

class sage.combinat.root_system.coxeter_type.CoxeterType

  Bases: `SageObject`

  Abstract class for Coxeter types.

  bilinear_form(R=None)

    Return the bilinear form over `R` associated to `self`.

    INPUT:

    - `R` – (default: universal cyclotomic field) a ring used to compute the bilinear form

    EXAMPLES:

    Sage

        sage: # needs sage.graphs sage.libs.gap
        sage: CoxeterType(['A', 2, 1]).bilinear_form()
        [   1 -1/2 -1/2]
        [-1/2    1 -1/2]
        [-1/2 -1/2    1]
        sage: CoxeterType(['H', 3]).bilinear_form()
        [                      1                    -1/2                       0]
        [                   -1/2                       1 1/2*E(5)^2 + 1/2*E(5)^3]
        [                      0 1/2*E(5)^2 + 1/2*E(5)^3                       1]
        sage: C = CoxeterMatrix([[1,-1,-1],[-1,1,-1],[-1,-1,1]])
        sage: C.bilinear_form()
        [ 1 -1 -1]
        [-1  1 -1]
        [-1 -1  1]

    Python

        >>> from sage.all import *
        >>> # needs sage.graphs sage.libs.gap
        >>> CoxeterType(['A', Integer(2), Integer(1)]).bilinear_form()
        [   1 -1/2 -1/2]
        [-1/2    1 -1/2]
        [-1/2 -1/2    1]
        >>> CoxeterType(['H', Integer(3)]).bilinear_form()
        [                      1                    -1/2                       0]
        [                   -1/2                       1 1/2*E(5)^2 + 1/2*E(5)^3]
        [                      0 1/2*E(5)^2 + 1/2*E(5)^3                       1]
        >>> C = CoxeterMatrix([[Integer(1),-Integer(1),-Integer(1)],[-Integer(1),Integer(1),-Integer(1)],[-Integer(1),-Integer(1),Integer(1)]])
        >>> C.bilinear_form()
        [ 1 -1 -1]
        [-1  1 -1]
        [-1 -1  1]

  coxeter_graph()

    Return the Coxeter graph associated to `self`.

    EXAMPLES:

    Sage

        sage: CoxeterType(['A', 3]).coxeter_graph()                                 # needs sage.graphs
        Graph on 3 vertices
        sage: CoxeterType(['A', 3, 1]).coxeter_graph()                              # needs sage.graphs
        Graph on 4 vertices

    Python

        >>> from sage.all import *
        >>> CoxeterType(['A', Integer(3)]).coxeter_graph()                                 # needs sage.graphs
        Graph on 3 vertices
        >>> CoxeterType(['A', Integer(3), Integer(1)]).coxeter_graph()                              # needs sage.graphs
        Graph on 4 vertices

  coxeter_matrix()

    Return the Coxeter matrix associated to `self`.

    EXAMPLES:

    Sage

        sage: CoxeterType(['A', 3]).coxeter_matrix()                                # needs sage.graphs
        [1 3 2]
        [3 1 3]
        [2 3 1]
        sage: CoxeterType(['A', 3, 1]).coxeter_matrix()                             # needs sage.graphs
        [1 3 2 3]
        [3 1 3 2]
        [2 3 1 3]
        [3 2 3 1]

    Python

        >>> from sage.all import *
        >>> CoxeterType(['A', Integer(3)]).coxeter_matrix()                                # needs sage.graphs
        [1 3 2]
        [3 1 3]
        [2 3 1]
        >>> CoxeterType(['A', Integer(3), Integer(1)]).coxeter_matrix()                             # needs sage.graphs
        [1 3 2 3]
        [3 1 3 2]
        [2 3 1 3]
        [3 2 3 1]

  index_set()

    Return the index set for `self`.

    This is the list of the nodes of the associated Coxeter graph.

    EXAMPLES:

    Sage

        sage: CoxeterType(['A', 3, 1]).index_set()
        (0, 1, 2, 3)
        sage: CoxeterType(['D', 4]).index_set()
        (1, 2, 3, 4)
        sage: CoxeterType(['A', 7, 2]).index_set()
        (0, 1, 2, 3, 4)
        sage: CoxeterType(['A', 7, 2]).index_set()
        (0, 1, 2, 3, 4)
        sage: CoxeterType(['A', 6, 2]).index_set()
        (0, 1, 2, 3)
        sage: CoxeterType(['D', 6, 2]).index_set()
        (0, 1, 2, 3, 4, 5)
        sage: CoxeterType(['E', 6, 1]).index_set()
        (0, 1, 2, 3, 4, 5, 6)
        sage: CoxeterType(['E', 6, 2]).index_set()
        (0, 1, 2, 3, 4)
        sage: CoxeterType(['A', 2, 2]).index_set()
        (0, 1)
        sage: CoxeterType(['G', 2, 1]).index_set()
        (0, 1, 2)
        sage: CoxeterType(['F', 4, 1]).index_set()
        (0, 1, 2, 3, 4)

    Python

        >>> from sage.all import *
        >>> CoxeterType(['A', Integer(3), Integer(1)]).index_set()
        (0, 1, 2, 3)
        >>> CoxeterType(['D', Integer(4)]).index_set()
        (1, 2, 3, 4)
        >>> CoxeterType(['A', Integer(7), Integer(2)]).index_set()
        (0, 1, 2, 3, 4)
        >>> CoxeterType(['A', Integer(7), Integer(2)]).index_set()
        (0, 1, 2, 3, 4)
        >>> CoxeterType(['A', Integer(6), Integer(2)]).index_set()
        (0, 1, 2, 3)
        >>> CoxeterType(['D', Integer(6), Integer(2)]).index_set()
        (0, 1, 2, 3, 4, 5)
        >>> CoxeterType(['E', Integer(6), Integer(1)]).index_set()
        (0, 1, 2, 3, 4, 5, 6)
        >>> CoxeterType(['E', Integer(6), Integer(2)]).index_set()
        (0, 1, 2, 3, 4)
        >>> CoxeterType(['A', Integer(2), Integer(2)]).index_set()
        (0, 1)
        >>> CoxeterType(['G', Integer(2), Integer(1)]).index_set()
        (0, 1, 2)
        >>> CoxeterType(['F', Integer(4), Integer(1)]).index_set()
        (0, 1, 2, 3, 4)

  is_affine()

    Return whether `self` is affine.

    EXAMPLES:

    Sage

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

    Python

        >>> from sage.all import *
        >>> CoxeterType(['A', Integer(3)]).is_affine()
        False
        >>> CoxeterType(['A', Integer(3), Integer(1)]).is_affine()
        True

  is_crystallographic()

    Return whether `self` is crystallographic.

    This returns `False` by default. Derived class should override this appropriately.

    EXAMPLES:

    Sage

        sage: [ [t, t.is_crystallographic() ] for t in CartanType.samples(finite=True) ]
        [[['A', 1], True], [['A', 5], True],
         [['B', 1], True], [['B', 5], True],
         [['C', 1], True], [['C', 5], True],
         [['D', 2], True], [['D', 3], 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]]

    Python

        >>> from sage.all import *
        >>> [ [t, t.is_crystallographic() ] for t in CartanType.samples(finite=True) ]
        [[['A', 1], True], [['A', 5], True],
         [['B', 1], True], [['B', 5], True],
         [['C', 1], True], [['C', 5], True],
         [['D', 2], True], [['D', 3], 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]]

  is_finite()

    Return whether `self` is finite.

    EXAMPLES:

    Sage

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

    Python

        >>> from sage.all import *
        >>> CoxeterType(['A',Integer(4)]).is_finite()
        True
        >>> CoxeterType(['A',Integer(4), Integer(1)]).is_finite()
        False

  is_simply_laced()

    Return whether `self` is simply laced.

    This returns `False` by default. Derived class should override this appropriately.

    EXAMPLES:

    Sage

        sage: [ [t, t.is_simply_laced() ] for t in CartanType.samples() ]
        [[['A', 1], True], [['A', 5], True],
         [['B', 1], True], [['B', 5], False],
         [['C', 1], True], [['C', 5], False],
         [['D', 2], True], [['D', 3], True], [['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', 1, 1], False], [['B', 5, 1], False],
         [['C', 1, 1], False], [['C', 5, 1], False],
         [['D', 3, 1], True], [['D', 5, 1], True],
         [['E', 6, 1], True], [['E', 7, 1], True], [['E', 8, 1], True],
         [['F', 4, 1], False], [['G', 2, 1], False],
         [['BC', 1, 2], False], [['BC', 5, 2], False],
         [['B', 5, 1]^*, False], [['C', 4, 1]^*, False],
         [['F', 4, 1]^*, False], [['G', 2, 1]^*, False],
         [['BC', 1, 2]^*, False], [['BC', 5, 2]^*, False]]

    Python

        >>> from sage.all import *
        >>> [ [t, t.is_simply_laced() ] for t in CartanType.samples() ]
        [[['A', 1], True], [['A', 5], True],
         [['B', 1], True], [['B', 5], False],
         [['C', 1], True], [['C', 5], False],
         [['D', 2], True], [['D', 3], True], [['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', 1, 1], False], [['B', 5, 1], False],
         [['C', 1, 1], False], [['C', 5, 1], False],
         [['D', 3, 1], True], [['D', 5, 1], True],
         [['E', 6, 1], True], [['E', 7, 1], True], [['E', 8, 1], True],
         [['F', 4, 1], False], [['G', 2, 1], False],
         [['BC', 1, 2], False], [['BC', 5, 2], False],
         [['B', 5, 1]^*, False], [['C', 4, 1]^*, False],
         [['F', 4, 1]^*, False], [['G', 2, 1]^*, False],
         [['BC', 1, 2]^*, False], [['BC', 5, 2]^*, False]]

  rank()

    Return the rank of `self`.

    This is the number of nodes of the associated Coxeter graph.

    EXAMPLES:

    Sage

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

    Python

        >>> from sage.all import *
        >>> CoxeterType(['A', Integer(4)]).rank()
        4
        >>> CoxeterType(['A', Integer(7), Integer(2)]).rank()
        5
        >>> CoxeterType(['I', Integer(8)]).rank()
        2

  classmethod samples(finite=None, affine=None, crystallographic=None)

    Return a sample of the available Coxeter types.

    INPUT:

    - `finite` – boolean or `None` (default: `None`)

    - `affine` – boolean or `None` (default: `None`)

    - `crystallographic` – boolean or `None` (default: `None`)

    The sample contains all the exceptional finite and affine Coxeter types, as well as typical representatives of the infinite families.

    EXAMPLES:

    Sage

        sage: CoxeterType.samples()
        [Coxeter type of ['A', 1], Coxeter type of ['A', 5],
         Coxeter type of ['B', 1], Coxeter type of ['B', 5],
         Coxeter type of ['C', 1], Coxeter type of ['C', 5],
         Coxeter type of ['D', 4], Coxeter type of ['D', 5],
         Coxeter type of ['E', 6], Coxeter type of ['E', 7],
         Coxeter type of ['E', 8], Coxeter type of ['F', 4],
         Coxeter type of ['H', 3], Coxeter type of ['H', 4],
         Coxeter type of ['I', 10], Coxeter type of ['A', 2, 1],
         Coxeter type of ['B', 5, 1], Coxeter type of ['C', 5, 1],
         Coxeter type of ['D', 5, 1], Coxeter type of ['E', 6, 1],
         Coxeter type of ['E', 7, 1], Coxeter type of ['E', 8, 1],
         Coxeter type of ['F', 4, 1], Coxeter type of ['G', 2, 1],
         Coxeter type of ['A', 1, 1]]

    Python

        >>> from sage.all import *
        >>> CoxeterType.samples()
        [Coxeter type of ['A', 1], Coxeter type of ['A', 5],
         Coxeter type of ['B', 1], Coxeter type of ['B', 5],
         Coxeter type of ['C', 1], Coxeter type of ['C', 5],
         Coxeter type of ['D', 4], Coxeter type of ['D', 5],
         Coxeter type of ['E', 6], Coxeter type of ['E', 7],
         Coxeter type of ['E', 8], Coxeter type of ['F', 4],
         Coxeter type of ['H', 3], Coxeter type of ['H', 4],
         Coxeter type of ['I', 10], Coxeter type of ['A', 2, 1],
         Coxeter type of ['B', 5, 1], Coxeter type of ['C', 5, 1],
         Coxeter type of ['D', 5, 1], Coxeter type of ['E', 6, 1],
         Coxeter type of ['E', 7, 1], Coxeter type of ['E', 8, 1],
         Coxeter type of ['F', 4, 1], Coxeter type of ['G', 2, 1],
         Coxeter type of ['A', 1, 1]]

    The finite, affine and crystallographic options allow respectively for restricting to (non) finite, (non) affine, and (non) crystallographic Cartan types:

    Sage

        sage: CoxeterType.samples(finite=True)
        [Coxeter type of ['A', 1], Coxeter type of ['A', 5],
         Coxeter type of ['B', 1], Coxeter type of ['B', 5],
         Coxeter type of ['C', 1], Coxeter type of ['C', 5],
         Coxeter type of ['D', 4], Coxeter type of ['D', 5],
         Coxeter type of ['E', 6], Coxeter type of ['E', 7],
         Coxeter type of ['E', 8], Coxeter type of ['F', 4],
         Coxeter type of ['H', 3], Coxeter type of ['H', 4],
         Coxeter type of ['I', 10]]

        sage: CoxeterType.samples(affine=True)
        [Coxeter type of ['A', 2, 1], Coxeter type of ['B', 5, 1],
         Coxeter type of ['C', 5, 1], Coxeter type of ['D', 5, 1],
         Coxeter type of ['E', 6, 1], Coxeter type of ['E', 7, 1],
         Coxeter type of ['E', 8, 1], Coxeter type of ['F', 4, 1],
         Coxeter type of ['G', 2, 1], Coxeter type of ['A', 1, 1]]

        sage: CoxeterType.samples(crystallographic=True)
        [Coxeter type of ['A', 1], Coxeter type of ['A', 5],
         Coxeter type of ['B', 1], Coxeter type of ['B', 5],
         Coxeter type of ['C', 1], Coxeter type of ['C', 5],
         Coxeter type of ['D', 4], Coxeter type of ['D', 5],
         Coxeter type of ['E', 6], Coxeter type of ['E', 7],
         Coxeter type of ['E', 8], Coxeter type of ['F', 4],
         Coxeter type of ['A', 2, 1], Coxeter type of ['B', 5, 1],
         Coxeter type of ['C', 5, 1], Coxeter type of ['D', 5, 1],
         Coxeter type of ['E', 6, 1], Coxeter type of ['E', 7, 1],
         Coxeter type of ['E', 8, 1], Coxeter type of ['F', 4, 1],
         Coxeter type of ['G', 2, 1], Coxeter type of ['A', 1, 1]]

        sage: CoxeterType.samples(crystallographic=False)
        [Coxeter type of ['H', 3],
         Coxeter type of ['H', 4],
         Coxeter type of ['I', 10]]

    [Python]

        >>> from sage.all import *
        >>> CoxeterType.samples(finite=True)
        [Coxeter type of ['A', 1], Coxeter type of ['A', 5],
         Coxeter type of ['B', 1], Coxeter type of ['B', 5],
         Coxeter type of ['C', 1], Coxeter type of ['C', 5],
         Coxeter type of ['D', 4], Coxeter type of ['D', 5],
         Coxeter type of ['E', 6], Coxeter type of ['E', 7],
         Coxeter type of ['E', 8], Coxeter type of ['F', 4],
         Coxeter type of ['H', 3], Coxeter type of ['H', 4],
         Coxeter type of ['I', 10]]

        >>> CoxeterType.samples(affine=True)
        [Coxeter type of ['A', 2, 1], Coxeter type of ['B', 5, 1],
         Coxeter type of ['C', 5, 1], Coxeter type of ['D', 5, 1],
         Coxeter type of ['E', 6, 1], Coxeter type of ['E', 7, 1],
         Coxeter type of ['E', 8, 1], Coxeter type of ['F', 4, 1],
         Coxeter type of ['G', 2, 1], Coxeter type of ['A', 1, 1]]

        >>> CoxeterType.samples(crystallographic=True)
        [Coxeter type of ['A', 1], Coxeter type of ['A', 5],
         Coxeter type of ['B', 1], Coxeter type of ['B', 5],
         Coxeter type of ['C', 1], Coxeter type of ['C', 5],
         Coxeter type of ['D', 4], Coxeter type of ['D', 5],
         Coxeter type of ['E', 6], Coxeter type of ['E', 7],
         Coxeter type of ['E', 8], Coxeter type of ['F', 4],
         Coxeter type of ['A', 2, 1], Coxeter type of ['B', 5, 1],
         Coxeter type of ['C', 5, 1], Coxeter type of ['D', 5, 1],
         Coxeter type of ['E', 6, 1], Coxeter type of ['E', 7, 1],
         Coxeter type of ['E', 8, 1], Coxeter type of ['F', 4, 1],
         Coxeter type of ['G', 2, 1], Coxeter type of ['A', 1, 1]]

        >>> CoxeterType.samples(crystallographic=False)
        [Coxeter type of ['H', 3],
         Coxeter type of ['H', 4],
         Coxeter type of ['I', 10]]

    Todo

    add some reducible Coxeter types (suggestions?)

class sage.combinat.root_system.coxeter_type.CoxeterTypeFromCartanType(cartan_type)

  Bases: `UniqueRepresentation`, `CoxeterType`

  A Coxeter type associated to a Cartan type.

  cartan_type()

    Return the Cartan type used to construct `self`.

    EXAMPLES:

    Sage

        sage: C = CoxeterType(['C',3])
        sage: C.cartan_type()
        ['C', 3]

    Python

        >>> from sage.all import *
        >>> C = CoxeterType(['C',Integer(3)])
        >>> C.cartan_type()
        ['C', 3]

  component_types()

    A list of Coxeter types making up the reducible type.

    EXAMPLES:

    Sage

        sage: CoxeterType(['A',2],['B',2]).component_types()
        [Coxeter type of ['A', 2], Coxeter type of ['B', 2]]

        sage: CoxeterType('A4xB3').component_types()
        [Coxeter type of ['A', 4], Coxeter type of ['B', 3]]

        sage: CoxeterType(['A', 2]).component_types()
        Traceback (most recent call last):
        ...
        ValueError: component types only defined for reducible types

    Python

        >>> from sage.all import *
        >>> CoxeterType(['A',Integer(2)],['B',Integer(2)]).component_types()
        [Coxeter type of ['A', 2], Coxeter type of ['B', 2]]

        >>> CoxeterType('A4xB3').component_types()
        [Coxeter type of ['A', 4], Coxeter type of ['B', 3]]

        >>> CoxeterType(['A', Integer(2)]).component_types()
        Traceback (most recent call last):
        ...
        ValueError: component types only defined for reducible types

  coxeter_graph()

    Return the Coxeter graph of `self`.

    EXAMPLES:

    Sage

        sage: C = CoxeterType(['H',3])
        sage: C.coxeter_graph().edges(sort=True)                                    # needs sage.graphs
        [(1, 2, 3), (2, 3, 5)]

    Python

        >>> from sage.all import *
        >>> C = CoxeterType(['H',Integer(3)])
        >>> C.coxeter_graph().edges(sort=True)                                    # needs sage.graphs
        [(1, 2, 3), (2, 3, 5)]

  coxeter_matrix()

    Return the Coxeter matrix associated to `self`.

    EXAMPLES:

    Sage

        sage: C = CoxeterType(['H',3])
        sage: C.coxeter_matrix()                                                    # needs sage.graphs
        [1 3 2]
        [3 1 5]
        [2 5 1]

    Python

        >>> from sage.all import *
        >>> C = CoxeterType(['H',Integer(3)])
        >>> C.coxeter_matrix()                                                    # needs sage.graphs
        [1 3 2]
        [3 1 5]
        [2 5 1]

  index_set()

    Return the index set of `self`.

    EXAMPLES:

    Sage

        sage: C = CoxeterType(['A', 4])
        sage: C.index_set()
        (1, 2, 3, 4)

    Python

        >>> from sage.all import *
        >>> C = CoxeterType(['A', Integer(4)])
        >>> C.index_set()
        (1, 2, 3, 4)

  is_affine()

    Return if `self` is an affine type.

    EXAMPLES:

    Sage

        sage: C = CoxeterType(['F', 4, 1])
        sage: C.is_affine()
        True

    Python

        >>> from sage.all import *
        >>> C = CoxeterType(['F', Integer(4), Integer(1)])
        >>> C.is_affine()
        True

  is_crystallographic()

    Return if `self` is crystallographic.

    EXAMPLES:

    Sage

        sage: C = CoxeterType(['C', 3])
        sage: C.is_crystallographic()
        True

        sage: C = CoxeterType(['H', 3])
        sage: C.is_crystallographic()
        False

    Python

        >>> from sage.all import *
        >>> C = CoxeterType(['C', Integer(3)])
        >>> C.is_crystallographic()
        True

        >>> C = CoxeterType(['H', Integer(3)])
        >>> C.is_crystallographic()
        False

  is_finite()

    Return if `self` is a finite type.

    EXAMPLES:

    Sage

        sage: C = CoxeterType(['E', 6])
        sage: C.is_finite()
        True

    Python

        >>> from sage.all import *
        >>> C = CoxeterType(['E', Integer(6)])
        >>> C.is_finite()
        True

  is_irreducible()

    Return if `self` is irreducible.

    EXAMPLES:

    Sage

        sage: C = CoxeterType(['A', 5])
        sage: C.is_irreducible()
        True

        sage: C = CoxeterType('B3xB3')
        sage: C.is_irreducible()
        False

    Python

        >>> from sage.all import *
        >>> C = CoxeterType(['A', Integer(5)])
        >>> C.is_irreducible()
        True

        >>> C = CoxeterType('B3xB3')
        >>> C.is_irreducible()
        False

  is_reducible()

    Return if `self` is reducible.

    EXAMPLES:

    Sage

        sage: C = CoxeterType(['A', 5])
        sage: C.is_reducible()
        False

        sage: C = CoxeterType('A2xA2')
        sage: C.is_reducible()
        True

    Python

        >>> from sage.all import *
        >>> C = CoxeterType(['A', Integer(5)])
        >>> C.is_reducible()
        False

        >>> C = CoxeterType('A2xA2')
        >>> C.is_reducible()
        True

  is_simply_laced()

    Return if `self` is simply-laced.

    EXAMPLES:

    Sage

        sage: C = CoxeterType(['A', 5])
        sage: C.is_simply_laced()
        True

        sage: C = CoxeterType(['B', 3])
        sage: C.is_simply_laced()
        False

    Python

        >>> from sage.all import *
        >>> C = CoxeterType(['A', Integer(5)])
        >>> C.is_simply_laced()
        True

        >>> C = CoxeterType(['B', Integer(3)])
        >>> C.is_simply_laced()
        False

  rank()

    Return the rank of `self`.

    EXAMPLES:

    Sage

        sage: C = CoxeterType(['I', 16])
        sage: C.rank()
        2

    Python

        >>> from sage.all import *
        >>> C = CoxeterType(['I', Integer(16)])
        >>> C.rank()
        2

  relabel(relabelling)

    Return a relabelled copy of `self`.

    EXAMPLES:

    Sage

        sage: ct = CoxeterType(['A',2])
        sage: ct.relabel({1:-1, 2:-2})
        Coxeter type of ['A', 2] relabelled by {1: -1, 2: -2}

    Python

        >>> from sage.all import *
        >>> ct = CoxeterType(['A',Integer(2)])
        >>> ct.relabel({Integer(1):-Integer(1), Integer(2):-Integer(2)})
        Coxeter type of ['A', 2] relabelled by {1: -1, 2: -2}

  type()

    Return the type of `self`.

    EXAMPLES:

    Sage

        sage: C = CoxeterType(['A', 4])
        sage: C.type()
        'A'

    Python

        >>> from sage.all import *
        >>> C = CoxeterType(['A', Integer(4)])
        >>> C.type()
        'A'