Struct risc0_zkp::field::goldilocks::Elem

#[repr(transparent)]
pub struct Elem(_);

The Goldilocks class is an element of the finite field F_p, where P is the prime number 2^64 - 2^32 + 1. Here we implement integer arithmetic modulo P for both Goldilocks and for a field extension of Goldilocks.

The Fp datatype is the core type of all of the operations done within the zero knowledge proofs, and is the smallest ‘addressable’ datatype, and the base type of which all composite types are built. In many ways, one can imagine it as the word size of a strange architecture, and its operations as wrapping operations which respect word size P.

The Fp class wraps all standard arithmetic operations to make finite field elements appear like ordinary numbers (which, for the most part, they are).

Implementations

impl Elem

pub const fn new(x: u64) -> Self

Create a new Goldilocks field Elem from a raw integer.

Trait Implementations

impl Add<Elem> for Elem

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

Addition for Goldilocks field Elem

type Output = Elem

The resulting type after applying the + operator.

impl AddAssign<Elem> for Elem

fn add_assign(&mut self, rhs: Self)

Simple addition case for Goldilocks field Elem

impl Clone for Elem

fn clone(&self) -> Elem

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Elem

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

Formats the value using the given formatter.

impl Default for Elem

fn default() -> Self

As a default, return the zero Elem.

impl Elem for Elem

fn inv(self) -> Self

Compute the multiplicative inverse of x, or 1 / x in finite field terms. Since we know by Fermat’s Little Theorem that x ^ (P - 1) == 1 % P for any x != 0, it follows that x * x ^ (P - 2) == 1 % P for x != 0. That is, x ^ (P - 2) is the multiplicative inverse of x. Note that if computed this way, the inverse of zero comes out as zero, which we allow because it is convenient in many cases.

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

Generate a random value within the Goldilocks field

const INVALID: Self = _

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: Self = _

Zero, the additive identity.

const ONE: Self = _

One, the multiplicative identity.

const WORDS: usize = 2usize

How many u32 words are required to hold a single element

fn from_u64(x0: u64) -> Self

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]) -> Self

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 pow(self, exp: usize) -> Self

Return an element raised to the given power.

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 From<&Elem> for u64

fn from(x: &Elem) -> Self

Converts to this type from the input type.

impl From<Elem> for ExtElem

fn from(x: Elem) -> Self

Converts to this type from the input type.

impl From<Elem> for u64

fn from(x: Elem) -> Self

Converts to this type from the input type.

impl From<u64> for Elem

fn from(x: u64) -> Self

Converts to this type from the input type.

impl Mul<Elem> for Elem

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

Multiplication for Goldilocks field Elem

type Output = Elem

The resulting type after applying the * operator.

impl Mul<Elem> for ExtElem

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

Multiplication for ExtElem

type Output = ExtElem

The resulting type after applying the * operator.

impl Mul<ExtElem> for Elem

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

Multiplication of Elem by Goldilocks ExtElem

type Output = ExtElem

The resulting type after applying the * operator.

impl MulAssign<Elem> for Elem

fn mul_assign(&mut self, rhs: Self)

Simple multiplication case for Goldilocks field Elem

impl MulAssign<Elem> for ExtElem

fn mul_assign(&mut self, rhs: Elem)

Simple multiplication case for Goldilocks ExtElem

impl Neg for Elem

fn neg(self) -> Self

Negation for Goldilocks field Elem

type Output = Elem

The resulting type after applying the - operator.

impl PartialEq<Elem> for Elem

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

const MAX_ROU_PO2: usize = 32usize

Maximum power of two for which we have a root of unity using Goldilocks field

const ROU_FWD: &'static [Elem] = _

‘Forward’ root of unity for each power of two.

const ROU_REV: &'static [Elem] = _

‘Reverse’ root of unity for each power of two.

impl Sub<Elem> for Elem

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

Subtraction for Goldilocks field Elem

type Output = Elem

The resulting type after applying the - operator.

impl SubAssign<Elem> for Elem

fn sub_assign(&mut self, rhs: Self)

Simple subtraction case for Goldilocks field Elem

impl Zeroable for Elem

fn zeroed() -> Self

Calls zeroed.

impl Copy for Elem

impl Eq for Elem

impl Pod for Elem

impl StructuralEq for Elem

impl StructuralPartialEq for Elem