Struct CartanMatrix 

pub struct CartanMatrix<const N: usize> { /* private fields */ }

Cartan matrix for a Lie algebra

The type parameter N encodes the rank at compile time. All entries are exact integers (no floating point).

Implementations

impl<const N: usize> CartanMatrix<N>

pub const fn new(entries: [[i8; N]; N]) -> Self

Create a new Cartan matrix

Examples

use atlas_embeddings::cartan::CartanMatrix;

let g2 = CartanMatrix::new([
    [ 2, -3],
    [-1,  2],
]);

pub const fn rank(&self) -> usize

Get the rank (dimension) of the Cartan matrix

pub const fn get(&self, i: usize, j: usize) -> i8

Get entry at position (i, j)

Panics

Panics if indices are out of bounds

pub const fn entries(&self) -> &[[i8; N]; N]

Get all entries as a 2D array

pub fn is_valid(&self) -> bool

Check if this is a valid Cartan matrix

Verifies:

1. Diagonal entries = 2
2. Off-diagonal entries ≤ 0
3. Symmetry condition: C[i][j] = 0 ⟺ C[j][i] = 0

pub fn is_simply_laced(&self) -> bool

Check if the Cartan matrix is simply-laced

A Cartan matrix is simply-laced if all off-diagonal entries are in {0, -1}. The simply-laced exceptional groups are E₆, E₇, E₈.

pub fn is_symmetric(&self) -> bool

Check if the matrix is symmetric

A symmetric Cartan matrix corresponds to a simply-laced group.

pub fn determinant(&self) -> i64

Compute determinant of the Cartan matrix

Uses exact integer arithmetic (no floating point). For small ranks (≤ 8), uses direct computation.

pub fn num_connected_components(&self) -> usize

Find connected components in Dynkin diagram

Returns the number of connected components. A connected Cartan matrix has exactly 1 component.

pub fn is_connected(&self) -> bool

Check if Cartan matrix is connected (indecomposable)

pub fn to_dynkin_diagram(&self, group_name: &str) -> DynkinDiagram<N>

Extract Dynkin diagram from Cartan matrix

Computes bonds between simple roots based on Cartan matrix entries. Bond multiplicity is determined by |Cᵢⱼ × Cⱼᵢ|:

• 1 = single bond (—)
• 2 = double bond (⇒) for F₄
• 3 = triple bond (≡) for G₂

Examples

use atlas_embeddings::cartan::CartanMatrix;

let g2 = CartanMatrix::g2();
let dynkin = g2.to_dynkin_diagram("G₂");

assert_eq!(dynkin.rank(), 2);
assert_eq!(dynkin.bonds().len(), 1);
assert_eq!(dynkin.bonds()[0].2, 3); // Triple bond

impl CartanMatrix<2>

Standard Cartan matrices for exceptional groups

pub const fn g2() -> Self

G₂ Cartan matrix

[ 2  -3]
[-1   2]

impl CartanMatrix<4>

pub const fn f4() -> Self

F₄ Cartan matrix

[ 2  -1   0   0]
[-1   2  -2   0]
[ 0  -1   2  -1]
[ 0   0  -1   2]

impl CartanMatrix<6>

pub const fn e6() -> Self

E₆ Cartan matrix

[ 2  -1   0   0   0   0]
[-1   2  -1   0   0   0]
[ 0  -1   2  -1   0  -1]
[ 0   0  -1   2  -1   0]
[ 0   0   0  -1   2   0]
[ 0   0  -1   0   0   2]

impl CartanMatrix<7>

pub const fn e7() -> Self

E₇ Cartan matrix

[ 2  -1   0   0   0   0   0]
[-1   2  -1   0   0   0   0]
[ 0  -1   2  -1   0   0   0]
[ 0   0  -1   2  -1   0  -1]
[ 0   0   0  -1   2  -1   0]
[ 0   0   0   0  -1   2   0]
[ 0   0   0  -1   0   0   2]

impl CartanMatrix<8>

pub const fn e8() -> Self

E₈ Cartan matrix

[ 2  -1   0   0   0   0   0   0]
[-1   2  -1   0   0   0   0   0]
[ 0  -1   2  -1   0   0   0   0]
[ 0   0  -1   2  -1   0   0   0]
[ 0   0   0  -1   2  -1   0  -1]
[ 0   0   0   0  -1   2  -1   0]
[ 0   0   0   0   0  -1   2   0]
[ 0   0   0   0  -1   0   0   2]

Trait Implementations

impl<const N: usize> Clone for CartanMatrix<N>

fn clone(&self) -> CartanMatrix<N>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<const N: usize> Debug for CartanMatrix<N>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<const N: usize> Hash for CartanMatrix<N>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<const N: usize> PartialEq for CartanMatrix<N>

fn eq(&self, other: &CartanMatrix<N>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<const N: usize> Copy for CartanMatrix<N>

impl<const N: usize> Eq for CartanMatrix<N>

impl<const N: usize> StructuralPartialEq for CartanMatrix<N>