Struct WeightLattice 

pub struct WeightLattice { /* private fields */ }

Weight lattice for a root system.

Weights are elements λ ∈ 𝔥* such that ⟨λ, α^∨⟩ ∈ ℤ for all roots α. The weight lattice contains the root lattice as a sublattice.

Fundamental Weights

For simple roots α₁, …, αₙ, the fundamental weights ω₁, …, ωₙ satisfy:

⟨ωᵢ, αⱼ^∨⟩ = δᵢⱼ

Every dominant weight can be written λ = Σ mᵢ ωᵢ with mᵢ ∈ ℤ≥₀.

Implementations

impl WeightLattice

pub fn from_root_system(root_system: RootSystem) -> Self

Create weight lattice from root system.

pub fn fundamental_weights(&self) -> &[Root]

Fundamental weights.

pub fn dynkin_to_weight(&self, dynkin_labels: &[usize]) -> Root

Convert Dynkin labels (m₁, …, mₙ) to weight λ = Σ mᵢ ωᵢ.

pub fn root_system(&self) -> &RootSystem

Get the root system.

pub fn rho(&self) -> Root

Compute ρ (half-sum of positive roots) = sum of fundamental weights.

For type Aₙ: ρ = ω₁ + ω₂ + … + ωₙ

pub fn kostant_multiplicity( &self, highest_weight: &Root, weight: &Root, ) -> usize

Compute weight multiplicity using Kostant’s formula.

Kostant’s formula (exact, not recursive like Freudenthal):

m_Λ(λ) = Σ_{w ∈ W} ε(w) · P(w·(Λ+ρ) - (λ+ρ))

where:

• Λ = highest weight of the representation
• λ = weight whose multiplicity we compute
• W = Weyl group
• ε(w) = sign of w (+1 for even, -1 for odd)
• P(γ) = partition function counting ways to write γ as sum of positive roots

Mathematical Background

This is the most general multiplicity formula, working for all weights in all representations. Unlike Freudenthal (which requires dominance), Kostant works directly.

Performance

O(|W| × P_cost) where |W| = (n+1)! for type A_n and P_cost is partition function cost. For SU(3): 6 Weyl group elements. For SU(4): 24 Weyl group elements.

References

• Humphreys, “Introduction to Lie Algebras and Representation Theory”, §24.3
• Kostant (1959), “A Formula for the Multiplicity of a Weight”

pub fn weyl_dimension(&self, highest_weight: &Root) -> usize

Compute dimension of irreducible representation using Weyl dimension formula.

For type Aₙ with highest weight λ:

dim(λ) = ∏_{α>0} ⟨λ + ρ, α⟩ / ⟨ρ, α⟩

This is the EXACT dimension - no approximation.

pub fn weights_of_irrep(&self, highest_weight: &Root) -> Vec<(Root, usize)>

Generate all weights in an irreducible representation.

Uses the CORRECT, GENERAL algorithm:

1. Generate candidate weights by exploring from highest weight with ALL positive roots
2. Add Weyl orbit of highest weight to ensure completeness
3. Use Kostant’s formula to compute accurate multiplicities
4. Return only weights with multiplicity > 0

This works for ALL representations, including adjoint where negative roots appear.

pub fn weight_diagram_string(&self, highest_weight: &Root) -> String

Generate a string representation of a weight diagram for rank 2.

For SU(3) representations, this creates a 2D triangular lattice showing all weights with their multiplicities.

Example

use lie_groups::{RootSystem, WeightLattice};

let rs = RootSystem::type_a(2);
let wl = WeightLattice::from_root_system(rs);
let highest = wl.dynkin_to_weight(&[1, 1]); // Adjoint rep

let diagram = wl.weight_diagram_string(&highest);
// Should show 8 weights (8-dimensional rep)