Trait FieldAlgebra

Source

pub trait FieldAlgebra:
    Sized
    + Default
    + Clone
    + Add<Output = Self>
    + AddAssign
    + Sub<Output = Self>
    + SubAssign
    + Neg<Output = Self>
    + Mul<Output = Self>
    + MulAssign
    + Sum
    + Product
    + Debug {
    type F: Field;

    const ZERO: Self;
    const ONE: Self;
    const TWO: Self;
    const NEG_ONE: Self;
Show 22 methods
    // Required methods
    fn from_f(f: Self::F) -> Self;
    fn from_bool(b: bool) -> Self;
    fn from_canonical_u8(n: u8) -> Self;
    fn from_canonical_u16(n: u16) -> Self;
    fn from_canonical_u32(n: u32) -> Self;
    fn from_canonical_u64(n: u64) -> Self;
    fn from_canonical_usize(n: usize) -> Self;
    fn from_wrapped_u32(n: u32) -> Self;
    fn from_wrapped_u64(n: u64) -> Self;

    // Provided methods
    fn double(&self) -> Self { ... }
    fn square(&self) -> Self { ... }
    fn cube(&self) -> Self { ... }
    fn exp_u64(&self, power: u64) -> Self { ... }
    fn exp_const_u64<const POWER: u64>(&self) -> Self { ... }
    fn exp_power_of_2(&self, power_log: usize) -> Self { ... }
    fn mul_2exp_u64(&self, exp: u64) -> Self { ... }
    fn powers(&self) -> Powers<Self> ⓘ { ... }
    fn shifted_powers(&self, start: Self) -> Powers<Self> ⓘ { ... }
    fn powers_packed<P: PackedField<Scalar = Self>>(&self) -> Powers<P> ⓘ { ... }
    fn shifted_powers_packed<P: PackedField<Scalar = Self>>(
        &self,
        start: Self,
    ) -> Powers<P> ⓘ { ... }
    fn dot_product<const N: usize>(u: &[Self; N], v: &[Self; N]) -> Self { ... }
    fn zero_vec(len: usize) -> Vec<Self> { ... }
}

Expand description

A commutative algebra over a finite field.

This permits elements like:

an actual field element
a symbolic expression which would evaluate to a field element
an array of field elements

Mathematically speaking, this is an algebraic structure with addition, multiplication and scalar multiplication. The addition and multiplication maps must be both commutative and associative, and there must exist identity elements for both (named ZERO and ONE respectively). Furthermore, multiplication must distribute over addition. Finally, the scalar multiplication must be realized by a ring homomorphism from the field to the algebra.

Required Associated Constants§

Source

const ZERO: Self

The additive identity of the algebra.

For every element a in the algebra we require the following properties:

a + ZERO = ZERO + a = a,

a + (-a) = (-a) + a = ZERO.

Source

const ONE: Self

The multiplicative identity of the Algebra

For every element a in the algebra we require the following property:

a*ONE = ONE*a = a.

Source

const TWO: Self

The element in the algebra given by ONE + ONE.

This is provided as a convenience as TWO occurs regularly in the proving system. This also is slightly faster than computing it via addition. Note that multiplication by TWO is discouraged. Instead of a * TWO use a.double() which will be faster.

If the field has characteristic 2 this is equal to ZERO.

Source

const NEG_ONE: Self

The element in the algebra given by -ONE.

This is provided as a convenience as NEG_ONE occurs regularly in the proving system. This also is slightly faster than computing it via negation. Note that where possible NEG_ONE should be absorbed into mathematical operations. For example a - b will be faster than a + NEG_ONE * b and similarly (-b) is faster than NEG_ONE * b.

If the field has characteristic 2 this is equal to ONE.

Required Associated Types§

Source

type F: Field

Required Methods§

Source

fn from_f(f: Self::F) -> Self

Interpret a field element as a commutative algebra element.

Mathematically speaking, this map is a ring homomorphism from the base field to the commutative algebra. The existence of this map makes this structure an algebra and not simply a commutative ring.

Source

fn from_bool(b: bool) -> Self

Convert from a bool.

Source