Trait miden_air::FieldElement

pub trait FieldElement: Copy + Clone + Debug + Display + Default + Send + Sync + Eq + PartialEq<Self> + Sized + Add<Self, Output = Self> + Sub<Self, Output = Self> + Mul<Self, Output = Self> + Div<Self, Output = Self> + AddAssign<Self> + SubAssign<Self> + MulAssign<Self> + DivAssign<Self> + Neg<Output = Self> + From<u128> + From<u64> + From<u32> + From<u16> + From<u8> + for<'a> TryFrom<&'a [u8]> + ExtensionOf<Self::BaseField> + AsBytes + Randomizable + Serializable + Deserializable {
    type PositiveInteger: Debug + Copy + PartialEq<Self::PositiveInteger> + PartialOrd<Self::PositiveInteger> + ShrAssign<Self::PositiveInteger> + Shl<u32, Output = Self::PositiveInteger> + Shr<u32, Output = Self::PositiveInteger> + BitAnd<Self::PositiveInteger, Output = Self::PositiveInteger> + From<u32> + From<u64>;
    type BaseField: StarkField;

    const EXTENSION_DEGREE: usize;
    const ELEMENT_BYTES: usize;
    const IS_CANONICAL: bool;
    const ZERO: Self;
    const ONE: Self;

    // Required methods
    fn inv(self) -> Self;
    fn conjugate(&self) -> Self;
    fn base_element(&self, i: usize) -> Self::BaseField;
    fn slice_as_base_elements(elements: &[Self]) -> &[Self::BaseField];
    fn slice_from_base_elements(elements: &[Self::BaseField]) -> &[Self];
    fn elements_as_bytes(elements: &[Self]) -> &[u8] ;
    unsafe fn bytes_as_elements(
        bytes: &[u8]
    ) -> Result<&[Self], DeserializationError>;

    // Provided methods
    fn double(self) -> Self { ... }
    fn square(self) -> Self { ... }
    fn cube(self) -> Self { ... }
    fn exp(self, power: Self::PositiveInteger) -> Self { ... }
    fn exp_vartime(self, power: Self::PositiveInteger) -> Self { ... }
    fn zeroed_vector(n: usize) -> Vec<Self, Global> { ... }
}

Defines an element in a finite field.

This trait defines basic arithmetic operations for elements in finite fields (e.g. addition subtraction, multiplication, division) as well as several convenience functions (e.g. double, square cube). Moreover, it defines interfaces for serializing and deserializing field elements.

The elements could be in a prime field or an extension of a prime field. Currently, only quadratic and cubic field extensions are supported.

Required Associated Types

type PositiveInteger: Debug + Copy + PartialEq<Self::PositiveInteger> + PartialOrd<Self::PositiveInteger> + ShrAssign<Self::PositiveInteger> + Shl<u32, Output = Self::PositiveInteger> + Shr<u32, Output = Self::PositiveInteger> + BitAnd<Self::PositiveInteger, Output = Self::PositiveInteger> + From<u32> + From<u64>

A type defining positive integers big enough to describe a field modulus for Self::BaseField with no loss of precision.

type BaseField: StarkField

Base field type for this finite field. For prime fields, BaseField should be set to Self.

Required Associated Constants

const EXTENSION_DEGREE: usize

Extension degree of this field with respect to Self::BaseField. For prime fields, extension degree should be set to 1.

const ELEMENT_BYTES: usize

Number of bytes needed to encode an element

const IS_CANONICAL: bool

True if internal representation of the element is the same as its canonical representation.

const ZERO: Self

The additive identity.

const ONE: Self

The multiplicative identity.

Required Methods

fn inv(self) -> Self

Returns a multiplicative inverse of this field element. If this element is ZERO, ZERO is returned.

fn conjugate(&self) -> Self

Returns a conjugate of this field element.

fn base_element(&self, i: usize) -> Self::BaseField

Return base filed element component of this field element at the specified index i.

Panics

Panics if the specified index is greater than or equal to Self::EXTENSION_DEGREE.

fn slice_as_base_elements(elements: &[Self]) -> &[Self::BaseField]

Converts a slice of field elements into a slice of elements in the underlying base field.

For base STARK fields, the input and output slices are the same. For extension fields, the output slice will contain decompositions of each extension element into underlying base field elements.

fn slice_from_base_elements(elements: &[Self::BaseField]) -> &[Self]

Convert a slice of base field elements into a slice of field elements.

For base STARK fields, the input and output slices are the same. For extension fields, the output slice will contain a composition of base field elements into extension field elements.

Panics

Panics if the the length of the provided slice is not divisible by Self::EXTENSION_DEGREE.

fn elements_as_bytes(elements: &[Self]) -> &[u8]

Converts a list of elements into a list of bytes.

The elements may be in the internal representation rather than in the canonical representation. This conversion is intended to be zero-copy (i.e. by re-interpreting the underlying memory).

unsafe fn bytes_as_elements( bytes: &[u8] ) -> Result<&[Self], DeserializationError>

Converts a list of bytes into a list of field elements.

The elements are assumed to encoded in the internal representation rather than in the canonical representation. The conversion is intended to be zero-copy (i.e. by re-interpreting the underlying memory).

Errors

An error is returned if:

• Memory alignment of bytes does not match memory alignment of field element data.
• Length of bytes does not divide into whole number of elements.

Safety

This function is unsafe because it does not check whether underlying bytes represent valid field elements according to their internal representation.

Provided Methods

fn double(self) -> Self

Returns this field element added to itself.

fn square(self) -> Self

Returns this field element raised to power 2.

fn cube(self) -> Self

Returns this field element raised to power 3.

fn exp(self, power: Self::PositiveInteger) -> Self

Exponentiates this field element by power parameter.

fn exp_vartime(self, power: Self::PositiveInteger) -> Self

Exponentiates this field element by power parameter. This function is expressly variable time, to speed-up verifier computations.

fn zeroed_vector(n: usize) -> Vec<Self, Global>

Returns a vector of length n initialized with all ZERO elements.

Specialized implementations of this function may be faster than the generic implementation.

Implementors

impl FieldElement for miden_air::Felt

type PositiveInteger = u64

type BaseField = BaseElement

const EXTENSION_DEGREE: usize = 1usize

const ZERO: BaseElement = Self::new(0)

const ONE: BaseElement = Self::new(1)

const ELEMENT_BYTES: usize = 8usize

const IS_CANONICAL: bool = false

impl FieldElement for BaseElement

type PositiveInteger = u64

type BaseField = BaseElement

const EXTENSION_DEGREE: usize = 1usize

const ZERO: BaseElement = BaseElement::new(0)

const ONE: BaseElement = BaseElement::new(1)

const ELEMENT_BYTES: usize = 8usize

const IS_CANONICAL: bool = false

impl FieldElement for BaseElement

type PositiveInteger = u128

type BaseField = BaseElement

const EXTENSION_DEGREE: usize = 1usize

const ZERO: BaseElement = BaseElement(0)

const ONE: BaseElement = BaseElement(1)

const ELEMENT_BYTES: usize = 16usize

const IS_CANONICAL: bool = true

impl<B> FieldElement for CubeExtension<B>where B: ExtensibleField<3>,

type PositiveInteger = <B as FieldElement>::PositiveInteger

type BaseField = B

const EXTENSION_DEGREE: usize = 3usize

const ELEMENT_BYTES: usize = B::ELEMENT_BYTES * Self::EXTENSION_DEGREE

const IS_CANONICAL: bool = B::IS_CANONICAL

const ZERO: CubeExtension<B> = Self(B::ZERO, B::ZERO, B::ZERO)

const ONE: CubeExtension<B> = Self(B::ONE, B::ZERO, B::ZERO)

impl<B> FieldElement for QuadExtension<B>where B: ExtensibleField<2>,

type PositiveInteger = <B as FieldElement>::PositiveInteger

type BaseField = B

const EXTENSION_DEGREE: usize = 2usize

const ELEMENT_BYTES: usize = B::ELEMENT_BYTES * Self::EXTENSION_DEGREE

const IS_CANONICAL: bool = B::IS_CANONICAL

const ZERO: QuadExtension<B> = Self(B::ZERO, B::ZERO)

const ONE: QuadExtension<B> = Self(B::ONE, B::ZERO)