Cartan matrices

Cartan matrices can be constructed from a Cartan type, and are represented as a square ZZMatrix.

Many functions taking a Cartan matrix as input (like root_system and weyl_group) will also accept a Cartan type as input. Both cases are semantically equivalent, but the latter may be more efficient.

Note

The convention for Cartan matrices in OSCAR is $(a_{ij}) = (\langle \alpha_i^\vee, \alpha_j \rangle)$ for simple roots $\alpha_i$.

Note

See Cartan types for our conventions on Cartan types and ordering of simple roots.

Table of contents
Constructors
Properties
Cartan types

Constructors

cartan_matrix — Method

cartan_matrix(fam::Symbol, rk::Int) -> ZZMatrix

Return the Cartan matrix of finite type, where fam is the family ($A$, $B$, $C$, $D$, $E$, $F$ $G$) and rk is the rank of the associated the root system.

The input must be a valid Cartan type, see is_cartan_type(::Symbol, ::Int).

Examples

julia> cartan_matrix(:B, 2)
[ 2   -1]
[-2    2]

julia> cartan_matrix(:C, 2)
[ 2   -2]
[-1    2]

source

cartan_matrix — Method

cartan_matrix(type::Vector{Tuple{Symbol,Int}}) -> ZZMatrix
cartan_matrix(type::Tuple{Symbol,Int}...) -> ZZMatrix

Construct a block diagonal matrix of indecomposable Cartan matrices as defined by type that are constructed by cartan_matrix(::Symbol, ::Int).

Each element of type must be a valid Cartan type, see is_cartan_type(::Symbol, ::Int). The vararg version needs at least one element.

Examples

julia> cartan_matrix([(:A, 2), (:B, 2)])
[ 2   -1    0    0]
[-1    2    0    0]
[ 0    0    2   -1]
[ 0    0   -2    2]

julia> cartan_matrix((:C, 2), (:A, 2))
[ 2   -2    0    0]
[-1    2    0    0]
[ 0    0    2   -1]
[ 0    0   -1    2]

source

Properties

is_cartan_matrix — Method

is_cartan_matrix(mat::ZZMatrix; generalized::Bool=true) -> Bool

Check if mat is a generalized Cartan matrix. If generalized=false this check is restricted to Cartan matrices of finite type.

Examples

julia> is_cartan_matrix(ZZ[2 -2; -2 2])
true

julia> is_cartan_matrix(ZZ[2 -2; -2 2]; generalized=false)
false

source

cartan_symmetrizer — Method

cartan_symmetrizer(gcm::ZZMatrix; check::Bool=true) -> Vector{ZZRingElem}

Return a vector $d$ of coprime integers such that $(d_i a_{ij})_{ij}$ is a symmetric matrix, where $a_{ij}$ are the entries of the Cartan matrix gcm.

If check=true the function will verify that gcm is indeed a generalized Cartan matrix.

Warning

Currently only Cartan matrices of finite type are supported.

Examples

julia> cartan_symmetrizer(cartan_matrix(:B, 2))
2-element Vector{ZZRingElem}:
 2
 1

source

cartan_bilinear_form — Method

cartan_bilinear_form(gcm::ZZMatrix; check::Bool=true) -> ZZMatrix

Return the matrix of the symmetric bilinear form associated to the Cartan matrix from cartan_symmetrizer.

If check=true the function will verify that gcm is indeed a generalized Cartan matrix.

Examples

julia> bil = cartan_bilinear_form(cartan_matrix(:B, 2))
[ 4   -2]
[-2    2]

julia> is_symmetric(bil)
true

source

Cartan types

Cartan types and, in particular, the ordering of simple roots are used differently in the literature. OSCAR follows the conventions of [Bou02, Plates I-IX] and [Hum72, Thm 11.4], i.e. we consider the following Dynkin diagrams for the Cartan types (where the ordering of simple roots is given by the numbering of the vertices):

$A_n$ (for $n \geq 1$):
```
1 - 2 - 3 - ... - n-1 - n
```
$B_n$ (for $n \geq 2$):
```
1 - 2 - 3 - ... - n-1 >=> n
```
$C_n$ (for $n \geq 2$):
```
1 - 2 - 3 - ... - n-1 <=< n
```

$D_n$ (for $n \geq 4$):

                      n-1
                    /
1 - 2 - 3 - ... - n-2
                    \
                      n

$E_6$:
```
1 - 3 - 4 - 5 - 6
        |
        2
```

$E_7$:

1 - 3 - 4 - 5 - 6 - 7
        |
        2

$E_8$:

1 - 3 - 4 - 5 - 6 - 7 - 8
        |
        2

$F_4$:
```
1 - 2 >=> 3 - 4
```
$G_2$:
```
1 <<< 2
```

The following function is used to verify the validity of a Cartan type, and is thus used in input sanitization.

is_cartan_type — Method

is_cartan_type(fam::Symbol, rk::Int) -> Bool

Check if the pair (fam, rk) is a valid Cartan type, i.e., one of

A_l ($l >= 1$),
B_l ($l >= 2$),
C_l ($l >= 2$),
D_l ($l >= 4$),
E_6, E_7, E_8,
F_4,
G_2.

source

Given a Cartan matrix, the following functions can be used to determine its Cartan type.

cartan_type — Method

cartan_type(gcm::ZZMatrix; check::Bool=true) -> Vector{Tuple{Symbol, Int}}

Return the Cartan type of a Cartan matrix gcm.

This function is left inverse to cartan_matrix, i.e., in the case of isomorphic types (e.g. $B_2$ and $C_2$) the ordering of the roots does matter (see the example below).

If check=true the function will verify that gcm is indeed a Cartan matrix.

Note

The order of returned components is, in general, not unique and might change between versions. But we guarantee that if this function is called with the output of cartan_matrix(::Vector{Tuple{Symbol,Int}}), it will keep the order of type.

Warning

Currently only Cartan matrices of finite type are supported.

Examples

julia> cartan_type(ZZ[2 -1; -2 2])
1-element Vector{Tuple{Symbol, Int64}}:
 (:B, 2)

julia> cartan_type(ZZ[2 -2; -1 2])
1-element Vector{Tuple{Symbol, Int64}}:
 (:C, 2)

source

cartan_type_with_ordering — Method

cartan_type_with_ordering(gcm::ZZMatrix; check::Bool=true) -> Vector{Tuple{Symbol, Int}}, Vector{Int}

Return the Cartan type of a Cartan matrix gcm together with a vector indicating a canonical ordering of the roots in the Dynkin diagram.

If check=true the function will verify that gcm is indeed a Cartan matrix.

Note

Warning

Currently only Cartan matrices of finite type are supported.

Examples

julia> cartan_type_with_ordering(cartan_matrix(:E, 6))
([(:E, 6)], [1, 2, 3, 4, 5, 6])

julia> cartan_type_with_ordering(ZZ[2 0 -2; 0 2 -1; -1 -1 2]) # type B_3, with rows and columns permuted with perm([2, 3, 1])
([(:B, 3)], [2, 3, 1])

julia> cartan_type_with_ordering(ZZ[2 0 -1 0; 0 2 0 -2; -2 0 2 0; 0 -1 0 2])
([(:B, 2), (:C, 2)], [1, 3, 2, 4])

source

Cartan matrices

Table of contents

Constructors

Properties

Cartan types