Struct risc0_zkp::field::baby_bear::ExtElem

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

Instances of ExtElem are elements of a finite field F_p^4. They are represented as elements of F_p[X] / (X^4 + 11). This large finite field (about 2^128 elements) is used when the security of operations depends on the size of the field. The field extension ExtElem has Elem as a subfield, so operations on elements of each are compatible. The irreducible polynomial x^4 + 11 was chosen because 11 is the simplest choice of BETA for x^4 + BETA that makes this polynomial irreducible.

Implementations

impl ExtElem

pub const fn new(x0: Elem, x1: Elem, x2: Elem, x3: Elem) -> ExtElem

Explicitly construct an ExtElem from parts.

pub fn from_fp(x: Elem) -> ExtElem

Create an ExtElem from an Elem.

pub const fn from_u32(x0: u32) -> ExtElem

Create an ExtElem from a raw integer.

pub fn const_part(self) -> Elem

Return the base field term of an Elem.

pub fn elems(&self) -> &[Elem]

Return Elem as a vector of base field values.

Trait Implementations

impl Add for ExtElem

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

Addition for Baby Bear ExtElem

type Output = ExtElem

The resulting type after applying the + operator.

impl AddAssign for ExtElem

fn add_assign(&mut self, rhs: ExtElem)

Simple addition case for Baby Bear ExtElem

impl Clone for ExtElem

fn clone(&self) -> ExtElem

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for ExtElem

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

Formats the value using the given formatter.

impl Default for ExtElem

fn default() -> ExtElem

Returns the “default value” for a type.

impl Elem for ExtElem

fn random(rng: &mut impl RngCore) -> ExtElem

Generate a random field element uniformly.

fn pow(self, n: usize) -> ExtElem

Raise a ExtElem to a power of n.

fn inv(self) -> ExtElem

Compute the multiplicative inverse of an ExtElem.

const INVALID: ExtElem = _

Invalid, a value that is not a member of the field. This should only be used with the “is_valid” or “unwrap_or_zero” methods.

const ZERO: ExtElem = _

Zero, the additive identity.

const ONE: ExtElem = _

One, the multiplicative identity.

const WORDS: usize = 4usize

How many u32 words are required to hold a single element

fn from_u64(val: u64) -> ExtElem

Import a number into the field from the natural numbers.

fn to_u32_words(&self) -> Vec<u32>

Represent a field element as a sequence of u32s

fn from_u32_words(val: &[u32]) -> ExtElem

Interpret a sequence of u32s as a field element

fn is_valid(&self) -> bool

Returns true if this element is not INVALID. Unlike most methods, this may be called on an INVALID element.

fn valid_or_zero(&self) -> Self

Returns 0 if this element is INVALID, else the value of this element. Unlike most methods, this may be called on an INVALID element.

fn ensure_valid(&self) -> &Self

Returns this element, but checks to make sure it’s valid.

fn as_u32_slice(elems: &[Self]) -> &[u32]

Interprets a slice of these elements as u32s. These elements may not be INVALID.

fn as_u32_slice_unchecked(elems: &[Self]) -> &[u32]

Interprets a slice of these elements as u32s. These elements may potentially be INVALID.

fn from_u32_slice(u32s: &[u32]) -> &[Self]

Interprets a slice of u32s as a slice of these elements. These elements may not be INVALID.

fn from_u32_slice_unchecked(u32s: &[u32]) -> &[Self]

Interprets a slice of u32s as a slice of these elements. These elements may be INVALID.

impl ExtElem for ExtElem

fn subelems(&self) -> &[Elem]

Returns the subelements of a Elem.

const EXT_SIZE: usize = 4usize

The degree of the field extension

type SubElem = Elem

An element of the base field

fn from_subfield(elem: &Elem) -> ExtElem

Interpret a base field element as an extension field element

fn from_subelems( elems: impl IntoIterator<Item = <ExtElem as ExtElem>::SubElem> ) -> ExtElem

Construct an extension field element

impl From<[Elem; 4]> for ExtElem

fn from(val: [Elem; 4]) -> ExtElem

Converts to this type from the input type.

impl From<Elem> for ExtElem

fn from(x: Elem) -> ExtElem

Converts to this type from the input type.

impl From<u32> for ExtElem

fn from(x: u32) -> ExtElem

Converts to this type from the input type.

impl Mul<Elem> for ExtElem

fn mul(self, rhs: Elem) -> ExtElem

Multiplication by a Baby Bear Elem

type Output = ExtElem

The resulting type after applying the * operator.

impl Mul<ExtElem> for Elem

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

Multiplication for a subfield Elem by an ExtElem

type Output = ExtElem

The resulting type after applying the * operator.

impl Mul for ExtElem

type Output = ExtElem

The resulting type after applying the * operator.

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

Performs the * operation.

impl MulAssign<Elem> for ExtElem

fn mul_assign(&mut self, rhs: Elem)

Simple multiplication case by a Baby Bear Elem

impl MulAssign for ExtElem

fn mul_assign(&mut self, rhs: ExtElem)

Performs the *= operation.

impl Neg for ExtElem

type Output = ExtElem

The resulting type after applying the - operator.

fn neg(self) -> ExtElem

Performs the unary - operation.

impl PartialEq for ExtElem

fn eq(&self, rhs: &ExtElem) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Sub for ExtElem

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

Subtraction for Baby Bear ExtElem

type Output = ExtElem

The resulting type after applying the - operator.

impl SubAssign for ExtElem

fn sub_assign(&mut self, rhs: ExtElem)

Simple subtraction case for Baby Bear ExtElem

impl Zeroable for ExtElem

fn zeroed() -> Self

Calls zeroed.

impl Copy for ExtElem

impl Eq for ExtElem

impl Pod for ExtElem