Enum Metric 

pub enum Metric {
    Euclidean(usize),
    NonEuclidean(usize),
    Minkowski(usize),
    Lorentzian(usize),
    PGA(usize),
    Generic {
        p: usize,
        q: usize,
        r: usize,
    },
    Custom {
        dim: usize,
        neg_mask: u64,
        zero_mask: u64,
    },
}

Defines the metric signature of the Clifford Algebra Cl(p, q, r).

The metric determines the squaring behavior of the basis vectors $e_i$:

• $e_i^2 = +1$ (positive, timelike in West Coast)
• $e_i^2 = -1$ (negative, timelike in East Coast)
• $e_i^2 = 0$ (degenerate, null)

The dimension $N = p + q + r$ is the total number of basis vectors.

Variants

Euclidean(usize)

All basis vectors square to +1. Signature: (N, 0, 0)

NonEuclidean(usize)

All basis vectors square to -1. Signature: (0, N, 0)

Minkowski(usize)

West Coast Minkowski: e₀² = +1, others = -1. Signature: (1, N-1, 0) Also known as: Weinberg, Particle Physics, “mostly minus”

Lorentzian(usize)

East Coast Lorentzian: e₀² = -1, others = +1. Signature: (N-1, 1, 0) Also known as: GR, “mostly plus”

PGA(usize)

Projective Geometric Algebra (PGA). Convention: e₀² = 0 (degenerate), others +1. Signature: (N-1, 0, 1) where the first vector is the zero vector.

Generic

Explicit generic signature Cl(p, q, r). Order of generators assumed: First p are (+), next q are (-), last r are (0).

Fields

p: usize

q: usize

r: usize

Custom

Fully arbitrary signature defined by bitmasks. dim: Total dimension neg_mask: bit is 1 if e_i² = -1 zero_mask: bit is 1 if e_i² = 0 (If both bits are 0, default is +1)

Fields

dim: usize

neg_mask: u64

zero_mask: u64

Implementations

impl Metric

pub fn dimension(&self) -> usize

Returns the total dimension of the vector space (N = p + q + r)

pub fn sign_of_sq(&self, i: usize) -> i32

Returns the value of the basis vector squared: $e_i^2$. Possible return values: 1, -1, or 0.

Arguments

• i - The 0-indexed generator index (0..N-1).

pub fn signature(&self) -> (usize, usize, usize)

Returns the signature tuple (p, q, r) where:

• p: number of +1 eigenvalues
• q: number of -1 eigenvalues
• r: number of 0 eigenvalues (degenerate)

pub fn flip_time_space(&self) -> Metric

Flip time and space signs (convert between East Coast and West Coast conventions).

This swaps +1 ↔ -1 for all basis vectors while preserving degenerate (0) vectors. Minkowski(n) becomes Custom with East Coast convention (-+++…).

pub fn tensor_product(&self, other: &Metric) -> Metric

Merges two metrics during a Tensor Product (Monad bind). e.g., Euclidean(2) + Euclidean(2) -> Euclidean(4)

pub fn is_compatible(&self, other: &Metric) -> bool

Check if two metrics are compatible for operations.

Two metrics are compatible if they have the same dimension and signature.

pub fn to_generic(&self) -> Metric

Normalize to Generic form for comparison.

This converts any Metric variant to its Generic equivalent, allowing comparison of metrics with different representations.

pub fn from_signature(p: usize, q: usize, r: usize) -> Metric

Create a Metric from (p, q, r) signature.

This creates the most appropriate Metric variant based on the signature:

• (n, 0, 0) -> Euclidean(n)
• (0, n, 0) -> NonEuclidean(n)
• (1, n-1, 0) -> Minkowski(n)
• (n-1, 0, 1) -> PGA(n)
• otherwise -> Generic { p, q, r }

pub fn from_signs(signs: &[i32]) -> Result<Metric, MetricError>

Create a Custom Metric from an explicit signs array.

Arguments

• signs - Array of signs for each basis vector (+1, -1, or 0)

Returns

• Ok(Metric) - A Custom metric with the specified signs
• Err(MetricError) - If dimension is 0 or exceeds 64

pub fn to_signs(&self) -> Vec<i32>

Extract signs as a vector.

Returns a Vec containing the sign (+1, -1, or 0) of each basis vector.

Trait Implementations

impl Adjunction<CausalMultiVectorWitness, CausalMultiVectorWitness, Metric> for CausalMultiVectorWitness

fn unit<A>(ctx: &Metric, a: A) -> CausalMultiVector<CausalMultiVector<A>>

where A: Satisfies<NoConstraint> + Clone,

The Unit of the Adjunction: A → R<L>

fn counit<B>(_ctx: &Metric, lrb: CausalMultiVector<CausalMultiVector<B>>) -> B

where B: Satisfies<NoConstraint> + Clone,

The Counit of the Adjunction: L<R> → B

fn left_adjunct<A, B, F>(ctx: &Metric, a: A, f: F) -> CausalMultiVector<B>

where A: Satisfies<NoConstraint> + Clone, B: Satisfies<NoConstraint>, F: Fn(CausalMultiVector<A>) -> B,

The Left Adjunct: (L → B) → (A → R)

fn right_adjunct<A, B, F>(_ctx: &Metric, la: CausalMultiVector<A>, f: F) -> B

where A: Satisfies<NoConstraint> + Clone, B: Satisfies<NoConstraint>, F: FnMut(A) -> CausalMultiVector<B>,

The Right Adjunct: (A → R) → (L → B)

impl Clone for Metric

fn clone(&self) -> Metric

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Metric

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

Formats the value using the given formatter.

impl Display for Metric

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

Formats the value using the given formatter.

impl Hash for Metric

fn hash<H>(&self, state: &mut H)

where H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for Metric

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

impl Eq for Metric

impl StructuralPartialEq for Metric