Struct Su3Algebra 

pub struct Su3Algebra(/* private fields */);

Lie algebra su(3) - 8-dimensional space of traceless anti-Hermitian 3×3 matrices

Elements are represented by 8 real coefficients [a₁, a₂, …, a₈] corresponding to the linear combination:

X = i·∑ⱼ aⱼ·λⱼ

where λⱼ are the Gell-Mann matrices (j = 1..8).

Basis Elements

The 8 Gell-Mann matrices form a basis for su(3). They satisfy:

• Hermitian: λⱼ† = λⱼ
• Traceless: Tr(λⱼ) = 0
• Normalized: Tr(λⱼ λₖ) = 2δⱼₖ

Examples

use lie_groups::su3::Su3Algebra;
use lie_groups::traits::LieAlgebra;

// First basis element (λ₁)
let e1 = Su3Algebra::basis_element(0);
assert_eq!(*e1.components(), [1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]);

Implementations

impl Su3Algebra

pub fn new(components: [f64; 8]) -> Self

Create a new su(3) algebra element from components.

The 8 components correspond to coefficients in the Gell-Mann basis: X = i·∑ⱼ aⱼ·λⱼ

pub fn components(&self) -> &[f64; 8]

Returns the components as a fixed-size array reference.

impl Su3Algebra

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

Convert algebra element to 3×3 anti-Hermitian matrix

Returns X = i·∑ⱼ aⱼ·(λⱼ/2) where λⱼ are Gell-Mann matrices. Convention: tr(Tₐ†Tᵦ) = ½δₐᵦ where Tₐ = iλₐ/2.

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

Extract algebra element from 3×3 anti-Hermitian matrix

Inverse of to_matrix(). Uses the normalization Tr(λⱼ λₖ) = 2δⱼₖ.

Given X = i·∑ⱼ aⱼ·(λⱼ/2), we have Tr(X·λⱼ) = i·aⱼ, so aⱼ = -i·Tr(X·λⱼ).

pub fn gell_mann_matrix(j: usize) -> Array2<Complex64>

Get the j-th Gell-Mann matrix (j = 0..7 for λ₁..λ₈)

Returns the Hermitian Gell-Mann matrix λⱼ (not i·λⱼ).

Trait Implementations

impl AbsDiffEq for Su3Algebra

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 Add<&Su3Algebra> for &Su3Algebra

type Output = Su3Algebra

The resulting type after applying the + operator.

fn add(self, rhs: &Su3Algebra) -> Su3Algebra

Performs the + operation.

impl Add<&Su3Algebra> for Su3Algebra

type Output = Su3Algebra

The resulting type after applying the + operator.

fn add(self, rhs: &Su3Algebra) -> Su3Algebra

Performs the + operation.

impl Add<Su3Algebra> for &Su3Algebra

type Output = Su3Algebra

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add for Su3Algebra

type Output = Su3Algebra

The resulting type after applying the + operator.

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

Performs the + operation.

impl Casimir for Su3Algebra

fn higher_casimir_eigenvalues(irrep: &Self::Representation) -> Vec<f64>

Cubic Casimir eigenvalue for SU(3).

For representation (p, q), the cubic Casimir eigenvalue is:

c₃(p,q) = (1/18)(p - q)(2p + q + 3)(p + 2q + 3)

Properties

• Conjugation: c₃(p,q) = -c₃(q,p). Conjugate representations have opposite c₃.
• Self-conjugate representations: c₃ = 0 when p = q (e.g., adjoint (1,1)).
• Physical interpretation: In QCD, distinguishes quarks (positive c₃) from antiquarks (negative c₃) beyond the quadratic Casimir.

Examples

(0,0): c₃ = 0         (trivial)
(1,0): c₃ = 10/9      (fundamental)
(0,1): c₃ = -10/9     (antifundamental)
(1,1): c₃ = 0         (adjoint, self-conjugate)
(2,0): c₃ = 70/9      (symmetric tensor)

Reference

Georgi, “Lie Algebras in Particle Physics” (1999), Chapter 7.

type Representation = Su3Irrep

Type representing irreducible representations of this algebra.

fn quadratic_casimir_eigenvalue(irrep: &Self::Representation) -> f64

Eigenvalue of the quadratic Casimir operator in a given irrep.

fn rank() -> usize

Dimension of the Cartan subalgebra (rank of the algebra).

fn num_casimirs() -> usize

Number of independent Casimir operators.

impl Clone for Su3Algebra

fn clone(&self) -> Su3Algebra

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Su3Algebra

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

Formats the value using the given formatter.

impl Display for Su3Algebra

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

Formats the value using the given formatter.

impl LieAlgebra for Su3Algebra

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

Lie bracket for su(3): [X, Y] = XY - YX

Computed using structure constants fᵢⱼₖ for O(1) performance.

Mathematical Formula

For X = i·∑ᵢ aᵢ·(λᵢ/2) and Y = i·∑ⱼ bⱼ·(λⱼ/2):

[X, Y] = -i·∑ₖ (∑ᵢⱼ aᵢ·bⱼ·fᵢⱼₖ)·(λₖ/2)

Performance

Uses pre-computed table of non-zero structure constants.

• Old implementation: O(512) iterations with conditional checks
• New implementation: O(54) direct lookups
• Speedup: ~10× fewer operations

Complexity

O(1) - constant time (54 multiply-adds)

Properties

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

const DIM: usize = 8

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 Mul<Su3Algebra> for f64

type Output = Su3Algebra

The resulting type after applying the * operator.

fn mul(self, rhs: Su3Algebra) -> Su3Algebra

Performs the * operation.

impl Mul<f64> for Su3Algebra

type Output = Su3Algebra

The resulting type after applying the * operator.

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

Performs the * operation.

impl Neg for Su3Algebra

type Output = Su3Algebra

The resulting type after applying the - operator.

fn neg(self) -> Self

Performs the unary - operation.

impl PartialEq for Su3Algebra

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

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 Sub for Su3Algebra

type Output = Su3Algebra

The resulting type after applying the - operator.

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

Performs the - operation.

impl AntiHermitianByConstruction for Su3Algebra

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

The representation uses {iλⱼ} where λⱼ are Hermitian Gell-Mann matrices.

impl Copy for Su3Algebra

impl StructuralPartialEq for Su3Algebra

impl TracelessByConstruction for Su3Algebra

su(3) algebra elements are traceless by construction.

The representation Su3Algebra::new([f64; 8]) stores coefficients in the Gell-Mann basis {iλ₁, …, iλ₈}. All Gell-Mann matrices are traceless.