Coxeter Matrices

class sage.combinat.root_system.coxeter_matrix.CoxeterMatrix(parent, data, coxeter_type, index_set)

Bases: sage.combinat.root_system.coxeter_type.CoxeterType

A Coxeter matrix.

A Coxeter matrix \(M = (m_{ij})_{i,j \in I}\) is a matrix encoding a Coxeter system \((W, S)\), where the relations are given by \((s_i s_j)^{m_{ij}}\). Thus \(M\) is symmetric and has entries in \(\{1, 2, 3, \ldots, \infty\}\) with \(m_{ij} = 1\) if and only if \(i = j\).

We represent \(m_{ij} = \infty\) by any number \(m_{ij} \leq -1\). In particular, we can construct a bilinear form \(B = (b_{ij})_{i,j \in I}\) from \(M\) by

\[\begin{split}b_{ij} = \begin{cases} m_{ij} & m_{ij} < 0\ (\text{i.e., } m_{ij} = \infty), \\ -\cos\left( \frac{\pi}{m_{ij}} \right) & \text{otherwise}. \end{cases}\end{split}\]

EXAMPLES:

sage: CoxeterMatrix(['A', 4])
[1 3 2 2]
[3 1 3 2]
[2 3 1 3]
[2 2 3 1]
sage: CoxeterMatrix(['B', 4])
[1 3 2 2]
[3 1 3 2]
[2 3 1 4]
[2 2 4 1]
sage: CoxeterMatrix(['C', 4])
[1 3 2 2]
[3 1 3 2]
[2 3 1 4]
[2 2 4 1]
sage: CoxeterMatrix(['D', 4])
[1 3 2 2]
[3 1 3 3]
[2 3 1 2]
[2 3 2 1]

sage: CoxeterMatrix(['E', 6])
[1 2 3 2 2 2]
[2 1 2 3 2 2]
[3 2 1 3 2 2]
[2 3 3 1 3 2]
[2 2 2 3 1 3]
[2 2 2 2 3 1]

sage: CoxeterMatrix(['F', 4])
[1 3 2 2]
[3 1 4 2]
[2 4 1 3]
[2 2 3 1]

sage: CoxeterMatrix(['G', 2])
[1 6]
[6 1]

By default, entries representing \(\infty\) are given by \(-1\) in the Coxeter matrix:

sage: G = Graph([(0,1,None), (1,2,4), (0,2,oo)])
sage: CoxeterMatrix(G)
[ 1  3 -1]
[ 3  1  4]
[-1  4  1]

It is possible to give a number \(\leq -1\) to represent an infinite label:

sage: CoxeterMatrix([[1,-1],[-1,1]])
[ 1 -1]
[-1  1]
sage: CoxeterMatrix([[1,-3/2],[-3/2,1]])
[   1 -3/2]
[-3/2    1]
bilinear_form(R=None)

Return the bilinear form of self.

EXAMPLES:

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]
coxeter_graph()

Return the Coxeter graph of self.

EXAMPLES:

sage: C = CoxeterMatrix(['A',3])
sage: C.coxeter_graph()
Graph on 3 vertices

sage: C = CoxeterMatrix([['A',3],['A',1]])
sage: C.coxeter_graph()
Graph on 4 vertices
coxeter_matrix()

Return the Coxeter matrix of self.

EXAMPLES:

sage: CoxeterMatrix(['C',3]).coxeter_matrix()
[1 3 2]
[3 1 4]
[2 4 1]
coxeter_type()

Return the Coxeter type of self or self if unknown.

EXAMPLES:

sage: C = CoxeterMatrix(['A',4,1])
sage: C.coxeter_type()
Coxeter type of ['A', 4, 1]

If the Coxeter type is unknown:

sage: C = CoxeterMatrix([[1,3,4], [3,1,-1], [4,-1,1]])
sage: C.coxeter_type()
[ 1  3  4]
[ 3  1 -1]
[ 4 -1  1]
index_set()

Return the index set of self.

EXAMPLES:

sage: C = CoxeterMatrix(['A',1,1])
sage: C.index_set()
(0, 1)
sage: C = CoxeterMatrix(['E',6])
sage: C.index_set()
(1, 2, 3, 4, 5, 6)
is_affine()

Return if self is an affine type or False if unknown.

EXAMPLES:

sage: M = CoxeterMatrix(['C',4])
sage: M.is_affine()
False
sage: M = CoxeterMatrix(['D',4,1])
sage: M.is_affine()
True
sage: M = CoxeterMatrix([[1, 3],[3,1]])
sage: M.is_affine()
False
sage: M = CoxeterMatrix([[1, -1, 7], [-1, 1, 3], [7, 3, 1]])
sage: M.is_affine()
False
is_crystallographic()

Return if self is crystallographic.

A Coxeter matrix is crystallographic if all non-diagonal entries are either 2, 4, or 6.

EXAMPLES:

sage: CoxeterMatrix(['F',4]).is_crystallographic()
True
sage: CoxeterMatrix(['H',3]).is_crystallographic()
False
is_finite()

Return if self is a finite type or False if unknown.

EXAMPLES:

sage: M = CoxeterMatrix(['C',4])
sage: M.is_finite()
True
sage: M = CoxeterMatrix(['D',4,1])
sage: M.is_finite()
False
sage: M = CoxeterMatrix([[1, -1], [-1, 1]])
sage: M.is_finite()
False
is_simply_laced()

Return if self is simply-laced.

A Coxeter matrix is simply-laced if all non-diagonal entries are either 2 or 3.

EXAMPLES:

sage: cm = CoxeterMatrix([[1,3,3,3], [3,1,3,3], [3,3,1,3], [3,3,3,1]])
sage: cm.is_simply_laced()
True
rank()

Return the rank of self.

EXAMPLES:

sage: CoxeterMatrix(['C',3]).rank()
3
sage: CoxeterMatrix(["A2","B2","F4"]).rank()
8
relabel(relabelling)

Return a relabelled copy of this Coxeter matrix.

INPUT:

  • relabelling – a function (or dictionary)

OUTPUT:

an isomorphic Coxeter type obtained by relabelling the nodes of the Coxeter graph. Namely, the node with label i is relabelled f(i) (or, by f[i] if f is a dictionary).

EXAMPLES:

sage: CoxeterMatrix(['F',4]).relabel({ 1:2, 2:3, 3:4, 4:1})
[1 4 2 3]
[4 1 3 2]
[2 3 1 2]
[3 2 2 1]
sage: CoxeterMatrix(['F',4]).relabel(lambda x: x+1 if x<4 else 1)
[1 4 2 3]
[4 1 3 2]
[2 3 1 2]
[3 2 2 1]
classmethod samples(finite=None, affine=None, crystallographic=None, higher_rank=None)

Return a sample of the available Coxeter types.

INPUT:

  • finite – (default: None) a boolean or None
  • affine – (default: None) a boolean or None
  • crystallographic – (default: None) a boolean or None
  • higher_rank – (default: None) a boolean or None

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

Here the higher_rank term denotes non-finite, non-affine, Coxeter groups (including hyperbolic types).

Todo

Implement the hyperbolic and compact hyperbolic in the samples.

EXAMPLES:

sage: [CM.coxeter_type() for CM in CoxeterMatrix.samples()]
[
Coxeter type of ['A', 1], Coxeter type of ['A', 5],

Coxeter type of ['B', 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],

                                                          [ 1 -1 -1]
                                                          [-1  1 -1]
Coxeter type of ['G', 2, 1], Coxeter type of ['A', 1, 1], [-1 -1  1],

         [ 1 -2  3  2]
[1 2 3]  [-2  1  2  3]
[2 1 7]  [ 3  2  1 -8]
[3 7 1], [ 2  3 -8  1]
]

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

sage: [CM.coxeter_type() for CM in CoxeterMatrix.samples(finite=True)]
[Coxeter type of ['A', 1], Coxeter type of ['A', 5],
 Coxeter type of ['B', 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: [CM.coxeter_type() for CM in CoxeterMatrix.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: [CM.coxeter_type() for CM in CoxeterMatrix.samples(crystallographic=True)]
[Coxeter type of ['A', 1], Coxeter type of ['A', 5],
 Coxeter type of ['B', 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]]

sage: CoxeterMatrix.samples(crystallographic=False)
[
         [1 3 2 2]                                       
[1 3 2]  [3 1 3 2]                    [ 1 -1 -1]  [1 2 3]
[3 1 5]  [2 3 1 5]  [ 1 10]  [ 1 -1]  [-1  1 -1]  [2 1 7]
[2 5 1], [2 2 5 1], [10  1], [-1  1], [-1 -1  1], [3 7 1],

[ 1 -2  3  2]
[-2  1  2  3]
[ 3  2  1 -8]
[ 2  3 -8  1]
]

Todo

add some reducible Coxeter types (suggestions?)

sage.combinat.root_system.coxeter_matrix.check_coxeter_matrix(m)

Check if m represents a generalized Coxeter matrix and raise and error if not.

EXAMPLES:

sage: from sage.combinat.root_system.coxeter_matrix import check_coxeter_matrix
sage: m = matrix([[1,3,2],[3,1,-1],[2,-1,1]])
sage: check_coxeter_matrix(m)

sage: m = matrix([[1,3],[3,1],[2,-1]])
sage: check_coxeter_matrix(m)
Traceback (most recent call last):
...
ValueError: not a square matrix

sage: m = matrix([[1,3,2],[3,1,-1],[2,-1,2]])
sage: check_coxeter_matrix(m)
Traceback (most recent call last):
...
ValueError: the matrix diagonal is not all 1

sage: m = matrix([[1,3,3],[3,1,-1],[2,-1,1]])
sage: check_coxeter_matrix(m)
Traceback (most recent call last):
...
ValueError: the matrix is not symmetric

sage: m = matrix([[1,3,1/2],[3,1,-1],[1/2,-1,1]])
sage: check_coxeter_matrix(m)
Traceback (most recent call last):
...
ValueError: invalid Coxeter label 1/2

sage: m = matrix([[1,3,1],[3,1,-1],[1,-1,1]])
sage: check_coxeter_matrix(m)
Traceback (most recent call last):
...
ValueError: invalid Coxeter label 1
sage.combinat.root_system.coxeter_matrix.coxeter_matrix(t)

This was deprecated in trac ticket #17798 for CartanMatrix.

EXAMPLES:

sage: coxeter_matrix(['A', 4])
doctest:...: DeprecationWarning: coxeter_matrix() is deprecated. Use CoxeterMatrix() instead
See http://trac.sagemath.org/17798 for details.
[1 3 2 2]
[3 1 3 2]
[2 3 1 3]
[2 2 3 1]
sage.combinat.root_system.coxeter_matrix.coxeter_matrix_as_function(t)

Return the Coxeter matrix, as a function.

INPUT:

  • t – a Cartan type

EXAMPLES:

sage: from sage.combinat.root_system.coxeter_matrix import coxeter_matrix_as_function
sage: f = coxeter_matrix_as_function(['A',4])
sage: matrix([[f(i,j) for j in range(1,5)] for i in range(1,5)])
[1 3 2 2]
[3 1 3 2]
[2 3 1 3]
[2 2 3 1]
sage.combinat.root_system.coxeter_matrix.recognize_coxeter_type_from_matrix(coxeter_matrix, index_set)

Return the Coxeter type of coxeter_matrix if known, otherwise return None.

EXAMPLES:

Some infinite ones:

sage: C = CoxeterMatrix([[1,3,2],[3,1,-1],[2,-1,1]])
sage: C.is_finite()  # indirect doctest
False
sage: C = CoxeterMatrix([[1,-1,-1],[-1,1,-1],[-1,-1,1]])
sage: C.is_finite()  # indirect doctest
False

Some finite ones:

sage: m = matrix(CoxeterMatrix(['D', 4]))
sage: CoxeterMatrix(m).is_finite()  # indirect doctest
True
sage: m = matrix(CoxeterMatrix(['H', 4]))
sage: CoxeterMatrix(m).is_finite()  # indirect doctest
True

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

Some affine graphs:

sage: CoxeterMatrix(CoxeterType(['A',1,1]).coxeter_graph()).coxeter_type()
Coxeter type of ['A', 1, 1]
sage: CoxeterMatrix(CoxeterType(['A',10,1]).coxeter_graph()).coxeter_type()
Coxeter type of ['A', 10, 1]
sage: CoxeterMatrix(CoxeterType(['B',10,1]).coxeter_graph()).coxeter_type()
Coxeter type of ['B', 10, 1]
sage: CoxeterMatrix(CoxeterType(['C',10,1]).coxeter_graph()).coxeter_type()
Coxeter type of ['C', 10, 1]
sage: CoxeterMatrix(CoxeterType(['D',10,1]).coxeter_graph()).coxeter_type()
Coxeter type of ['D', 10, 1]
sage: CoxeterMatrix(CoxeterType(['E',6,1]).coxeter_graph()).coxeter_type()
Coxeter type of ['E', 6, 1]
sage: CoxeterMatrix(CoxeterType(['E',7,1]).coxeter_graph()).coxeter_type()
Coxeter type of ['E', 7, 1]
sage: CoxeterMatrix(CoxeterType(['E',8,1]).coxeter_graph()).coxeter_type()
Coxeter type of ['E', 8, 1]
sage: CoxeterMatrix(CoxeterType(['F',4,1]).coxeter_graph()).coxeter_type()
Coxeter type of ['F', 4, 1]
sage: CoxeterMatrix(CoxeterType(['G',2,1]).coxeter_graph()).coxeter_type()
Coxeter type of ['G', 2, 1]