Struct Su2Algebra 

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

Lie algebra su(2) ≅ ℝ³

The Lie algebra of SU(2) consists of 2×2 traceless anti-Hermitian matrices. We represent these using 3 real coordinates.

Convention

We identify su(2) with ℝ³ via the basis {e₀, e₁, e₂} = {iσₓ/2, iσᵧ/2, iσᵤ/2}, where σᵢ are the Pauli matrices:

σₓ = [[0, 1], [1, 0]]    e₀ = iσₓ/2 = [[0, i/2], [i/2, 0]]
σᵧ = [[0, -i], [i, 0]]   e₁ = iσᵧ/2 = [[0, 1/2], [-1/2, 0]]
σᵤ = [[1, 0], [0, -1]]   e₂ = iσᵤ/2 = [[i/2, 0], [0, -i/2]]

An element Su2Algebra::new([a, b, c]) corresponds to the matrix (a·iσₓ + b·iσᵧ + c·iσᵤ)/2, and the parameter ‖(a,b,c)‖ is the rotation angle in the exponential map.

Structure Constants

With this basis, the Lie bracket satisfies [eᵢ, eⱼ] = -εᵢⱼₖ eₖ, giving structure constants fᵢⱼₖ = -εᵢⱼₖ (negative Levi-Civita symbol). In ℝ³ coordinates, [X, Y] = -(X × Y).

Isomorphism with ℝ³

su(2) is isomorphic to ℝ³ as a vector space, and as a Lie algebra the bracket is the negative cross product. The norm ‖v‖ equals the rotation angle θ, matching the exponential map exp(v) = cos(θ/2)I + i·sin(θ/2)·v̂·σ.

Examples

use lie_groups::su2::Su2Algebra;
use lie_groups::traits::LieAlgebra;

// Create algebra element in X direction
let v = Su2Algebra::from_components(&[1.0, 0.0, 0.0]);

// Scale and add
let w = v.scale(2.0);
let sum = v.add(&w);

Implementations

impl Su2Algebra

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

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

The components [a, b, c] correspond to the element (a·iσₓ + b·iσᵧ + c·iσᵤ)/2 in the Pauli basis.

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

Returns the components as a fixed-size array reference.

Trait Implementations

impl AbsDiffEq for Su2Algebra

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<&Su2Algebra> for &Su2Algebra

type Output = Su2Algebra

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<&Su2Algebra> for Su2Algebra

type Output = Su2Algebra

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<Su2Algebra> for &Su2Algebra

type Output = Su2Algebra

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add for Su2Algebra

type Output = Su2Algebra

The resulting type after applying the + operator.

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

Performs the + operation.

impl Casimir for Su2Algebra

type Representation = Spin

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 higher_casimir_eigenvalues(_irrep: &Self::Representation) -> Vec<f64>

Eigenvalues of higher Casimir operators (optional).

fn num_casimirs() -> usize

Number of independent Casimir operators.

impl Clone for Su2Algebra

fn clone(&self) -> Su2Algebra

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Su2Algebra

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

Formats the value using the given formatter.

impl Display for Su2Algebra

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

Formats the value using the given formatter.

impl LieAlgebra for Su2Algebra

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

Lie bracket for su(2): [X, Y] = -(X × Y)

Convention

We represent su(2) as ℝ³ with basis {eᵢ} = {iσᵢ/2}. The matrix commutator gives:

[iσᵢ/2, iσⱼ/2] = (i²/4)[σᵢ, σⱼ] = -(1/4)(2iεᵢⱼₖσₖ) = -εᵢⱼₖ(iσₖ/2)

In ℝ³ coordinates, this is the negative cross product:

[X, Y] = -(X × Y)

The negative sign is the unique bracket consistent with the half-angle exponential map exp(v) = cos(‖v‖/2)I + i·sin(‖v‖/2)·v̂·σ, ensuring the BCH formula exp(X)·exp(Y) = exp(X + Y - ½(X×Y) + ...) holds.

Properties

• Structure constants: fᵢⱼₖ = -εᵢⱼₖ
• Antisymmetric: [X, Y] = -[Y, X]
• Jacobi identity: [X, [Y, Z]] + [Y, [Z, X]] + [Z, [X, Y]] = 0
• Killing form: B(X, Y) = -2(X · Y)

Examples

use lie_groups::Su2Algebra;
use lie_groups::LieAlgebra;

let e1 = Su2Algebra::basis_element(0);  // (1, 0, 0)
let e2 = Su2Algebra::basis_element(1);  // (0, 1, 0)
let bracket = e1.bracket(&e2);          // [e₁, e₂] = -e₃

// Should give -e₃ = (0, 0, -1)
assert!((bracket.components()[0]).abs() < 1e-10);
assert!((bracket.components()[1]).abs() < 1e-10);
assert!((bracket.components()[2] - (-1.0)).abs() < 1e-10);

const DIM: usize = 3

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<Su2Algebra> for f64

type Output = Su2Algebra

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<f64> for Su2Algebra

type Output = Su2Algebra

The resulting type after applying the * operator.

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

Performs the * operation.

impl Neg for Su2Algebra

type Output = Su2Algebra

The resulting type after applying the - operator.

fn neg(self) -> Self

Performs the unary - operation.

impl PartialEq for Su2Algebra

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

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 Su2Algebra

type Output = Su2Algebra

The resulting type after applying the - operator.

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

Performs the - operation.

impl AntiHermitianByConstruction for Su2Algebra

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

The representation uses {iσ₁, iσ₂, iσ₃} where σᵢ are Hermitian. Since (iσ)† = -iσ† = -iσ, each basis element is anti-Hermitian, and any real linear combination is also anti-Hermitian.

Lean Connection

Combined with exp_antiHermitian_unitary: exp(X)† · exp(X) = I. Therefore SU2::exp always produces unitary elements.

impl Copy for Su2Algebra

impl StructuralPartialEq for Su2Algebra

impl TracelessByConstruction for Su2Algebra

su(2) algebra elements are traceless by construction.

The representation Su2Algebra::new([f64; 3]) stores coefficients in the Pauli basis {iσ₁, iσ₂, iσ₃}. Since each Pauli matrix is traceless, any linear combination is also traceless.

Lean Connection

Combined with det_exp_eq_exp_trace: det(exp(X)) = exp(tr(X)) = exp(0) = 1. Therefore SU2::exp always produces elements with determinant 1.