Struct SunAlgebra 

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

Lie algebra su(N) - (N²-1)-dimensional space of traceless anti-Hermitian matrices

Type Parameter

• N: Matrix dimension (must be ≥ 2)

Representation

Elements are stored as (N²-1) real coefficients corresponding to the generalized Gell-Mann basis. The basis is constructed systematically:

1. Symmetric generators (N(N-1)/2 elements):

   • λᵢⱼ with i < j: has 1 at (i,j) and (j,i)

2. Antisymmetric generators (N(N-1)/2 elements):

   • λᵢⱼ with i < j: has -i at (i,j) and +i at (j,i)

3. Diagonal generators (N-1 elements):

   • λₖ diagonal with first k entries = 1, (k+1)-th entry = -k

This generalizes the Pauli matrices (N=2) and Gell-Mann matrices (N=3).

Mathematical Properties

• Hermitian generators: λⱼ† = λⱼ
• Traceless: Tr(λⱼ) = 0
• Normalized: Tr(λᵢλⱼ) = 2δᵢⱼ
• Completeness: {λⱼ/√2} form orthonormal basis for traceless Hermitian matrices

Memory Layout

For SU(N), we store (N²-1) f64 values in a heap-allocated Vec for N > 4, or stack-allocated array for N ≤ 4 (common cases).

Implementations

impl<const N: usize> SunAlgebra<N>

pub fn new(coefficients: Vec<f64>) -> Self

Create new algebra element from coefficients

Panics

Panics if coefficients.len() != N² - 1

pub fn coefficients(&self) -> &[f64]

Returns the coefficients in the generalized Gell-Mann basis.

pub fn to_matrix(&self) -> Array2<Complex64>

Convert to N×N anti-Hermitian matrix: X = i·∑ⱼ aⱼ·(λⱼ/2)

This is the fundamental representation in ℂᴺˣᴺ. Convention: tr(Tₐ†Tᵦ) = ½δₐᵦ where Tₐ = iλₐ/2.

Performance

• Time: O(N²)
• Space: O(N²)
• Lazy: Only computed when called

Mathematical Formula

Given coefficients [a₁, …, a_{N²-1}], returns:

X = i·∑ⱼ aⱼ·(λⱼ/2)

where λⱼ are the generalized Gell-Mann matrices with tr(λₐλᵦ) = 2δₐᵦ.

pub fn from_matrix(matrix: &Array2<Complex64>) -> Self

Construct algebra element from matrix

Given X ∈ su(N), extract coefficients in Gell-Mann basis.

Performance

O(N²) time via inner products with basis elements.

Trait Implementations

impl<const N: usize> AbsDiffEq for SunAlgebra<N>

type Epsilon = f64

Used for specifying relative comparisons.

fn default_epsilon() -> Self::Epsilon

The default tolerance to use when testing values that are close together.

fn abs_diff_eq(&self, other: &Self, epsilon: Self::Epsilon) -> bool

A test for equality that uses the absolute difference to compute the approximate equality of two numbers.

fn abs_diff_ne(&self, other: &Rhs, epsilon: Self::Epsilon) -> bool

The inverse of AbsDiffEq::abs_diff_eq.

impl<const N: usize> Add<&SunAlgebra<N>> for &SunAlgebra<N>

type Output = SunAlgebra<N>

The resulting type after applying the + operator.

fn add(self, rhs: &SunAlgebra<N>) -> SunAlgebra<N>

Performs the + operation.

impl<const N: usize> Add<&SunAlgebra<N>> for SunAlgebra<N>

type Output = SunAlgebra<N>

The resulting type after applying the + operator.

fn add(self, rhs: &SunAlgebra<N>) -> SunAlgebra<N>

Performs the + operation.

impl<const N: usize> Add<SunAlgebra<N>> for &SunAlgebra<N>

type Output = SunAlgebra<N>

The resulting type after applying the + operator.

fn add(self, rhs: SunAlgebra<N>) -> SunAlgebra<N>

Performs the + operation.

impl<const N: usize> Add for SunAlgebra<N>

type Output = SunAlgebra<N>

The resulting type after applying the + operator.

fn add(self, rhs: Self) -> Self

Performs the + operation.

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

fn clone(&self) -> SunAlgebra<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 SunAlgebra<N>

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

Formats the value using the given formatter.

impl<const N: usize> Display for SunAlgebra<N>

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

Formats the value using the given formatter.

impl<const N: usize> LieAlgebra for SunAlgebra<N>

fn bracket(&self, other: &Self) -> Self

Lie bracket: [X, Y] = XY - YX

Computed via matrix commutator for generality.

Performance

• Time: O(N³) [matrix multiplication]
• Space: O(N²)

Note

For N=2,3, specialized implementations with structure constants would be faster (O(1) and O(1) respectively). This generic version prioritizes correctness and simplicity.

Mathematical Formula

[X, Y] = XY - YX

This satisfies:

• Antisymmetry: [X,Y] = -[Y,X]
• Jacobi identity: [X,[Y,Z]] + [Y,[Z,X]] + [Z,[X,Y]] = 0
• Bilinearity

const DIM: usize

Dimension of the Lie algebra as a compile-time constant.

fn zero() -> Self

Zero element (additive identity) 0 ∈ 𝔤.

fn add(&self, other: &Self) -> Self

Add two algebra elements: v + w

fn scale(&self, scalar: f64) -> Self

Scalar multiplication: α · v

fn norm(&self) -> f64

Euclidean norm of the coefficient vector: ||v|| = √(Σᵢ vᵢ²)

fn basis_element(i: usize) -> Self

Get the i-th basis element of the Lie algebra.

fn from_components(components: &[f64]) -> Self

Construct algebra element from basis coordinates.

fn to_components(&self) -> Vec<f64>

Extract basis coordinates from algebra element.

fn inner(&self, other: &Self) -> f64

Inner product on coefficient space: ⟨v, w⟩ = Σᵢ vᵢ wᵢ

impl<const N: usize> Mul<SunAlgebra<N>> for f64

type Output = SunAlgebra<N>

The resulting type after applying the * operator.

fn mul(self, rhs: SunAlgebra<N>) -> SunAlgebra<N>

Performs the * operation.

impl<const N: usize> Mul<f64> for SunAlgebra<N>

type Output = SunAlgebra<N>

The resulting type after applying the * operator.

fn mul(self, scalar: f64) -> Self

Performs the * operation.

impl<const N: usize> Neg for SunAlgebra<N>

type Output = SunAlgebra<N>

The resulting type after applying the - operator.

fn neg(self) -> Self

Performs the unary - operation.

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

fn eq(&self, other: &SunAlgebra<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> RelativeEq for SunAlgebra<N>

fn default_max_relative() -> Self::Epsilon

The default relative tolerance for testing values that are far-apart.

fn relative_eq( &self, other: &Self, epsilon: Self::Epsilon, max_relative: Self::Epsilon, ) -> bool

A test for equality that uses a relative comparison if the values are far apart.

fn relative_ne( &self, other: &Rhs, epsilon: Self::Epsilon, max_relative: Self::Epsilon, ) -> bool

The inverse of RelativeEq::relative_eq.

impl<const N: usize> Sub for SunAlgebra<N>

type Output = SunAlgebra<N>

The resulting type after applying the - operator.

fn sub(self, rhs: Self) -> Self

Performs the - operation.

impl<const N: usize> AntiHermitianByConstruction for SunAlgebra<N>

su(N) algebra elements are anti-Hermitian by construction.

The representation uses i·λⱼ where λⱼ are Hermitian generators.

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

impl<const N: usize> TracelessByConstruction for SunAlgebra<N>

su(N) algebra elements are traceless by construction.

The representation SunAlgebra<N> stores N²-1 coefficients in a generalized Gell-Mann basis. All generators are traceless by definition.