Struct RoundCoeffs 

pub struct RoundCoeffs<F>(pub Vec<F>);

A univariate polynomial in monomial basis.

The coefficient at position i in the inner vector corresponds to the term $X^i$.

Tuple Fields

0: Vec<F>

Implementations

impl<F> RoundCoeffs<F>

pub fn truncate(self) -> RoundProof<F>

Truncate the highest-degree coefficient to produce a more compact round proof.

Pre-conditions

• The coefficient vector must be non-empty.
• A round polynomial always has degree at least one, so an empty vector signals a bug.

pub fn as_slice(&self) -> &[F]

The coefficients ordered from the constant term to the highest-degree term.

impl<F: FieldOps> RoundCoeffs<F>

pub fn evaluate(&self, x: &F) -> F

Evaluate the polynomial at a point.

pub fn batch(polys: Vec<Self>, batch_coeff: &F) -> Self

Batches round polynomials into one, weighting polynomial i by batch_coeff^i.

The verifier weights the matching claims with the same coefficient. Each claim therefore stays tied to its own round polynomial.

An empty input is the zero polynomial.

pub fn sum_over_endpoints(&self) -> F

The claimed sum $R(0) + R(1)$ that this round polynomial encodes.

For a sumcheck round polynomial, this is the round’s claimed sum. The verifier expects the identity $s = R(0) + R(1)$ (see RoundProof::recover).

pub fn lerp_over_endpoints(&self, alpha: F) -> F

The claimed value $(1 - \alpha) R(0) + \alpha R(1)$ that this round polynomial encodes in an MLE-check.

This is the MLE-check analogue of Self::sum_over_endpoints. An MLE-check round polynomial satisfies $s = (1 - \alpha) R(0) + \alpha R(1)$. Here $\alpha$ is the round’s evaluation-point coordinate (see crate::mlecheck::RoundProof::recover). Equivalently, this is the linear extrapolation of $R$ from the endpoints $0$ and $1$ to $\alpha$.

impl<F: Field> RoundCoeffs<F>

pub fn mul_by_eq(&self, alpha: F) -> Self

Multiplies this polynomial by the equality factor $\text{eq}(X, \alpha)$.

$$ \text{eq}(X, \alpha) = (1 - \alpha) + (2 \alpha - 1) X $$

An MLE-check prover interpolates the prime polynomial, which carries no equality factor. This multiplies the factor back in.

Monomial form makes that one scaling and one shift. Sampling the factored polynomial instead would cost an extra evaluation point.

The factor is linear, so the result has one more coefficient than self.

Trait Implementations

impl<F: FieldOps> Add<&RoundCoeffs<F>> for RoundCoeffs<F>

type Output = RoundCoeffs<F>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<F: FieldOps> AddAssign<&RoundCoeffs<F>> for RoundCoeffs<F>

fn add_assign(&mut self, rhs: &Self)

Performs the += operation.

impl<F: Clone> Clone for RoundCoeffs<F>

fn clone(&self) -> RoundCoeffs<F>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<F: Debug> Debug for RoundCoeffs<F>

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

Formats the value using the given formatter.

impl<F> Default for RoundCoeffs<F>

fn default() -> Self

Returns the “default value” for a type.

impl<F: Eq> Eq for RoundCoeffs<F>

impl<F> Index<usize> for RoundCoeffs<F>

type Output = F

The returned type after indexing.

fn index(&self, index: usize) -> &F

Performs the indexing (container[index]) operation.

impl<F: FieldOps> Mul<F> for RoundCoeffs<F>

type Output = RoundCoeffs<F>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<F: FieldOps> MulAssign<F> for RoundCoeffs<F>

fn mul_assign(&mut self, rhs: F)

Performs the *= operation.

impl<F: PartialEq> PartialEq for RoundCoeffs<F>

fn eq(&self, other: &RoundCoeffs<F>) -> 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<F: PartialEq> StructuralPartialEq for RoundCoeffs<F>

impl<F: FieldOps> Sum for RoundCoeffs<F>

fn sum<I: Iterator<Item = Self>>(iter: I) -> Self

Takes an iterator and generates Self from the elements by “summing up” the items.