Struct risc0_zkp::field::goldilocks::Elem

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

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) -> Elem

Create a new Goldilocks field Elem from a raw integer.

Trait Implementations

impl Add for Elem

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

Addition for Goldilocks field Elem

type Output = Elem

The resulting type after applying the + operator.

impl AddAssign for Elem

fn add_assign(&mut self, rhs: Elem)

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<(), Error>

Formats the value using the given formatter.

impl Default for Elem

fn default() -> Elem

As a default, return the zero Elem.

impl Elem for Elem

fn inv(self) -> Elem

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) -> Elem

Generate a random value within the Goldilocks field

const INVALID: Elem = _

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

Zero, the additive identity.

const ONE: Elem = _

One, the multiplicative identity.

const WORDS: usize = 2usize

How many u32 words are required to hold a single element

fn from_u64(x0: u64) -> Elem

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

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 is_reduced(&self) -> bool

Returns true if this element is represented in reduced/normalized form. Every element has exactly one reduced form. For a field of prime order P, this typically means the underlying data is < P, and for an extension field, this typically means every component is in reduced form.

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 ensure_reduced(&self) -> &Self

Returns this element, but checks to make sure it’s in reduced form.

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.

impl From<Elem> for ExtElem

fn from(x: Elem) -> ExtElem

Converts to this type from the input type.

impl From<u64> for Elem

fn from(x: u64) -> Elem

Converts to this type from the input type.

impl Mul<Elem> for ExtElem

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

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 Mul for Elem

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

Multiplication for Goldilocks field Elem

type Output = Elem

The resulting type after applying the * operator.

impl MulAssign<Elem> for ExtElem

fn mul_assign(&mut self, rhs: Elem)

Simple multiplication case for Goldilocks ExtElem

impl MulAssign for Elem

fn mul_assign(&mut self, rhs: Elem)

Simple multiplication case for Goldilocks field Elem

impl Neg for Elem

fn neg(self) -> Elem

Negation for Goldilocks field Elem

type Output = Elem

The resulting type after applying the - operator.

impl PartialEq 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 for Elem

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

Subtraction for Goldilocks field Elem

type Output = Elem

The resulting type after applying the - operator.

impl SubAssign for Elem

fn sub_assign(&mut self, rhs: Elem)

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 StructuralPartialEq for Elem