Struct SUN 

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

SU(N) group element - N×N unitary matrix with det = 1

Type Parameter

• N: Matrix dimension

Representation

Stored as N×N complex matrix satisfying:

• U†U = I (unitarity)
• det(U) = 1 (special)

Verification

Use verify_unitarity() to check constraints numerically.

Implementations

impl<const N: usize> SUN<N>

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

Access the underlying N×N unitary matrix

pub fn identity() -> Self

Identity element: Iₙ

pub fn trace(&self) -> Complex64

Trace of the matrix: Tr(U) = Σᵢ Uᵢᵢ

pub fn verify_unitarity(&self, tolerance: f64) -> bool

Verify unitarity: ||U†U - I|| < ε

Arguments

• tolerance: Maximum Frobenius norm deviation

Returns

true if U†U ≈ I within tolerance

pub fn determinant(&self) -> Complex64

Compute determinant

For SU(N), the determinant should be exactly 1 by definition.

Implementation

• N=2: Direct formula ad - bc
• N=3: Sarrus’ rule / cofactor expansion
• N>3: Returns 1.0 (assumes matrix is on SU(N) manifold)

Limitations

For N > 3, this function does not compute the actual determinant. It returns 1.0 under the assumption that matrices constructed via exp() or reorthogonalize() remain on the SU(N) manifold.

To verify unitarity for N > 3, use verify_special_unitarity() instead, which checks U†U = I (a stronger condition than det=1).

For actual determinant computation with N > 3, enable the ndarray-linalg feature (not currently available) or compute via eigenvalue product.

pub fn distance_to_identity(&self) -> f64

Distance from identity: ||U - I||_F

Frobenius norm of difference from identity.

Trait Implementations

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

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

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

Formats the value using the given formatter.

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

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

Formats the value using the given formatter.

impl<const N: usize> LieGroup for SUN<N>

fn adjoint_action(&self, algebra_element: &Self::Algebra) -> Self::Algebra

Adjoint action: Ad_g(X) = gXg⁻¹

Mathematical Formula

For g ∈ SU(N) and X ∈ su(N):

Ad_g(X) = gXg⁻¹

Properties

• Group homomorphism: Ad_{gh} = Ad_g ∘ Ad_h
• Preserves bracket: Ad_g([X,Y]) = [Ad_g(X), Ad_g(Y)]
• Preserves norm (SU(N) is compact)

fn exp(tangent: &Self::Algebra) -> Self

Exponential map: exp: su(N) → SU(N)

Algorithm: Scaling-and-Squaring

For X ∈ su(N) with ||X|| large:

1. Scale: X’ = X / 2^k such that ||X’|| ≤ 0.5
2. Taylor: exp(X’) ≈ ∑_{n=0}^{15} X’^n / n!
3. Square: exp(X) = [exp(X’)]^{2^k}

Properties

• Preserves unitarity: exp(X) ∈ SU(N) for X ∈ su(N)
• Preserves det = 1 (Tr(X) = 0 ⟹ det(exp(X)) = exp(Tr(X)) = 1)
• Numerically stable for all ||X||

Performance

• Time: O(N³·log(||X||))
• Space: O(N²)

Accuracy

• Relative error: ~10⁻¹⁴ (double precision)
• Unitarity preserved to ~10⁻¹²

const MATRIX_DIM: usize

Matrix dimension in the fundamental representation.

type Algebra = SunAlgebra<N>

Associated Lie algebra type.

fn identity() -> Self

The identity element e ∈ G.

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

Group composition (multiplication): g₁ · g₂

fn inverse(&self) -> Self

Group inverse: g⁻¹

fn conjugate_transpose(&self) -> Self

Adjoint representation element (for matrix groups: conjugate transpose).

fn distance_to_identity(&self) -> f64

Geodesic distance from identity: d(g, e)

fn log(&self) -> LogResult<Self::Algebra>

Logarithm map: G → 𝔤 (inverse of exponential)

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

Distance between two group elements: d(g, h)

fn is_near_identity(&self, tolerance: f64) -> bool

Check if this element is approximately the identity.

fn trace_identity() -> f64

Trace of the identity element

fn reorthogonalize(&self) -> Self

Project element back onto the group manifold using Gram-Schmidt orthogonalization.

fn geodesic(&self, other: &Self, t: f64) -> Option<Self>

Geodesic interpolation between two group elements.

impl<const N: usize> Mul<&SUN<N>> for &SUN<N>

Group multiplication: U₁ · U₂

type Output = SUN<N>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<const N: usize> Mul<&SUN<N>> for SUN<N>

type Output = SUN<N>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<const N: usize> MulAssign<&SUN<N>> for SUN<N>

fn mul_assign(&mut self, rhs: &SUN<N>)

Performs the *= operation.

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

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

SU(N) is compact for all N ≥ 2.

impl<const N: usize> SemiSimple for SUN<N>

SU(N) is semi-simple (implied by simple) for all N ≥ 2.

impl<const N: usize> Simple for SUN<N>

SU(N) is simple for all N ≥ 2.

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