Struct Fp5 

pub struct Fp5(pub [Fp; 5]);

An element of Fp5 = GF(p^5).

Tuple Fields

0: [Fp; 5]

Implementations

impl Fp5

pub const ZERO: Self

Additive identity.

pub const ONE: Self

Multiplicative identity.

pub const fn from_u64s_reduce(c: [u64; 5]) -> Self

Build an element from five u64 coefficients (low-to-high degree), each reduced mod p.

pub fn from_u64s_canonical(c: [u64; 5]) -> Option<Self>

Build an element from five canonical u64 coefficients; returns None if any coefficient is >= p.

pub fn try_from_le_bytes(bytes: [u8; 40]) -> Option<Self>

Decode an element from 40 little-endian bytes (5 x 8-byte canonical limbs).

Returns None if any limb is non-canonical (>= p).

pub fn to_le_bytes(self) -> [u8; 40]

Canonical 40-byte little-endian encoding (5 x 8-byte limbs, low-to-high degree).

pub fn is_zero(self) -> bool

Test whether the element is zero.

pub fn ct_eq(self, rhs: Self) -> u64

Constant-time equality: returns 0xFFFF_FFFF_FFFF_FFFF on equality, 0 otherwise.

pub fn ct_select(mask: u64, a: Self, b: Self) -> Self

Branch-free select: returns a when mask == 0 and b when mask == u64::MAX. Composed coefficient-wise from Fp::ct_select; the secret-scalar curve primitives only ever pass full-bit masks.

pub fn square(self) -> Self

Squaring in Fp5.

pub fn msquare(self, n: u32) -> Self

Repeated squaring: returns self^(2^n).

pub fn double(self) -> Self

Double in Fp5: returns self + self.

pub fn sgn0(self) -> bool

Sign indicator following the elliottech Go reference convention. Used by Self::canonical_sqrt to fix the sign of square roots.

The latch sign = sign || (zero && sign_i) with sign_i = (limb is even) reproduces the upstream behaviour bit-for-bit, including a known wrinkle: an element whose first non-zero coefficient is preceded by zero coefficients (e.g. [0, 1, 0, 0, 0]) reports true because a leading zero satisfies sign_i. This wrinkle has no observable effect on super::super::curve’s Point::decode: a flipped r swaps x1/x2 contents, the subsequent Legendre check then re-selects the same non-square root, and the resulting x is identical. Phase E Layer 2 oracle tests against the Lighter Python SDK gate any divergence from the closed-source mainnet signer.

pub fn legendre(self) -> Fp

Legendre symbol of self in Fp5, returned as a base-field element.

Returns Fp::ZERO for the zero element, Fp::ONE for non-zero squares, and Fp::MINUS_ONE for non-squares. Uses the Itoh-Tsujii descent into Fp followed by Euler’s criterion split as x^(2^63) / x^(2^31).

pub fn sqrt(self) -> Option<Self>

Square root in Fp5 via descent to Fp.

Returns Some(s) such that s^2 == self when one exists (Some(ZERO) for the zero input); returns None for non-squares. The chosen root is arbitrary within the two square roots; use Self::canonical_sqrt for a deterministic sign.

pub fn canonical_sqrt(self) -> Option<Self>

Canonical-sign square root: same as Self::sqrt, with the result negated whenever its first non-zero coefficient is even (per Self::sgn0).

pub fn invert(self) -> Self

Multiplicative inverse via Itoh-Tsujii. Returns Fp5::ZERO on input zero.

With r = 1 + p + p^2 + p^3 + p^4, the value x^r lands in the base field Fp, so we compute x^(r-1) cheaply via Frobenius, recover x^r = x_0 * x^(r-1)|_0 inside Fp, and divide. The branch-free shape preserves the module’s constant-time contract: a zero input flows through the Frobenius cascade as zero and Fp::invert(0) = 0 folds back into a zero result without an early return.

pub fn pow(self, exp: u64) -> Self

Exponentiation by an unsigned 64-bit integer, via right-to-left square-and-multiply.

Trait Implementations

impl Add for Fp5

type Output = Fp5

The resulting type after applying the + operator.

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

Performs the + operation.

impl AddAssign for Fp5

fn add_assign(&mut self, rhs: Self)

Performs the += operation.

impl Clone for Fp5

fn clone(&self) -> Fp5

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Fp5

impl Debug for Fp5

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

Formats the value using the given formatter.

impl Default for Fp5

fn default() -> Self

Returns the “default value” for a type.

impl Eq for Fp5

impl Hash for Fp5

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Mul for Fp5

type Output = Fp5

The resulting type after applying the * operator.

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

Performs the * operation.

impl MulAssign for Fp5

fn mul_assign(&mut self, rhs: Self)

Performs the *= operation.

impl Neg for Fp5

type Output = Fp5

The resulting type after applying the - operator.

fn neg(self) -> Self

Performs the unary - operation.

impl PartialEq for Fp5

fn eq(&self, other: &Fp5) -> bool

Tests for self and other values to be equal, and is used by ==.

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

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

impl StructuralPartialEq for Fp5

impl Sub for Fp5

type Output = Fp5

The resulting type after applying the - operator.

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

Performs the - operation.

impl SubAssign for Fp5

fn sub_assign(&mut self, rhs: Self)

Performs the -= operation.