Struct risc0_core::field::goldilocks::ExtElem

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

Instances of ExtElem are elements of a finite field F_p^2. They are represented as elements of F_p[X] / (X^2 - 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^2 - 11 was chosen because 11 is the simplest choice of BETA for x^2 - BETA that makes this polynomial irreducible.

Implementations

impl ExtElem

pub const fn new(x0: Elem, x1: Elem) -> Self

Explicitly construct an ExtElem from parts.

pub fn from_fp(x: Elem) -> Self

Create a ExtElem from an Elem.

pub const fn from_u64(x0: u64) -> Self

Create a 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: Self) -> Self

Addition for Goldilocks ExtElem

type Output = ExtElem

The resulting type after applying the + operator.

impl AddAssign for ExtElem

fn add_assign(&mut self, rhs: Self)

Simple addition case for Goldilocks 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

Formats the value using the given formatter.

impl Default for ExtElem

fn default() -> Self

Returns the “default value” for a type.

impl Elem for ExtElem

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

Generate a random ExtElem uniformly.

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

Raise an ExtElem to a power of n.

fn inv(self) -> Self

Compute the multiplicative inverse of a field element ExtElem.

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 = 4usize

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 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 = 2usize

The degree of the field extension

type SubElem = Elem

An element of the base field

fn from_subfield(elem: &Elem) -> Self

Interpret a base field element as an extension field element

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

Construct an extension field element

impl From<[Elem; 2]> for ExtElem

fn from(val: [Elem; 2]) -> Self

Create field element from subfield element

impl From<Elem> for ExtElem

fn from(x: Elem) -> Self

Converts to this type from the input type.

impl From<u64> for ExtElem

fn from(x: u64) -> Self

Converts to this type from the input type.

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

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

Multiplication for Goldilocks ExtElem

type Output = ExtElem

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 ExtElem

fn mul_assign(&mut self, rhs: Self)

Simple multiplication case for Goldilocks ExtElem

impl Neg for ExtElem

fn neg(self) -> Self

Unary negation for Goldilocks ExtElem

type Output = ExtElem

The resulting type after applying the - operator.

impl PartialEq for ExtElem

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

Subtraction for Goldilocks ExtElem

type Output = ExtElem

The resulting type after applying the - operator.

impl SubAssign for ExtElem

fn sub_assign(&mut self, rhs: Self)

Simple subtraction case for Goldilocks ExtElem

impl Zeroable for ExtElem

fn zeroed() -> Self

Calls zeroed.

impl Copy for ExtElem

impl Eq for ExtElem

impl Pod for ExtElem

impl StructuralEq for ExtElem

impl StructuralPartialEq for ExtElem