Struct RoundEvals 

pub struct RoundEvals<T, const D: usize>(pub [T; D]);

The D sampled evaluations of one claim’s round polynomial.

A degree-D polynomial needs D + 1 values. The round claim supplies the one at 0, so only D are sampled:

    D = 1    [ R(1) ]
    D = 2    [ R(1), R(inf) ]

Invariant: slot 0 is R(1), which every recovery of R(0) reads.

R(inf) is the leading coefficient, at one addition per element. Any finite node past 1 would cost a full extrapolation.

T narrows as the round advances:

    accumulate    wide, unreduced
    reduce        packed
    sum_scalars   scalar

Tuple Fields

0: [T; D]

Implementations

impl<T, const D: usize> RoundEvals<T, D>

pub fn from_slots(slots: &[T]) -> Self

where T: Copy,

Reads one evaluator’s run of accumulator slots.

Panics

Panics unless the run holds exactly D slots. A mismatch means the evaluator’s reported degree disagrees with the D its body uses.

pub fn add_to(self, slots: &mut [T])

where T: AddAssign,

Adds these evaluations into one evaluator’s run of accumulator slots.

An evaluator sums into locals through its hot loop, then calls this once per chunk. The running sums therefore stay in registers, not in the shared accumulator buffer.

Panics

Panics unless the run holds exactly D slots, as in Self::from_slots.

pub fn reduce<P: PackedField + WideMul<Output = T>>(self) -> RoundEvals<P, D>

Reduces every wide slot, once the round’s accumulation is complete.

Accumulation sums unreduced products. So the modular reduction is paid once per round, not once per hypercube element.

impl<P: PackedField, const D: usize> RoundEvals<P, D>

pub fn sum_scalars(self, n_vars: usize) -> RoundEvals<P::Scalar, D>

Sums the packed lanes of every slot into a scalar.

A round narrower than one packed word leaves the trailing lanes dead. So only the first 2^n_vars are summed.

impl<F: Field> RoundEvals<F, 1>

pub fn interpolate_eq(self, claim: F, alpha: F) -> RoundCoeffs<F>

Interpolates the prime round polynomial of an MLE-check.

Arguments

• claim - This round’s claim on the prime polynomial.
• alpha - The coordinate of the evaluation point that this round binds.

impl<F: Field> RoundEvals<F, 2>

pub fn interpolate(self, claim: F) -> RoundCoeffs<F>

Interpolates a plain sumcheck round polynomial.

Arguments

• claim - This round’s sum claim.

pub fn interpolate_eq(self, claim: F, alpha: F) -> RoundCoeffs<F>

Interpolates the prime round polynomial of an MLE-check.

Arguments

• claim - This round’s claim on the prime polynomial.
• alpha - The coordinate of the evaluation point that this round binds.

Trait Implementations

impl<T: AddAssign + Copy, const D: usize> Add<&RoundEvals<T, D>> for RoundEvals<T, D>

type Output = RoundEvals<T, D>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T: AddAssign + Copy, const D: usize> AddAssign<&RoundEvals<T, D>> for RoundEvals<T, D>

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

Performs the += operation.

impl<T: Clone, const D: usize> Clone for RoundEvals<T, D>

fn clone(&self) -> RoundEvals<T, D>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Copy, const D: usize> Copy for RoundEvals<T, D>

impl<T: Debug, const D: usize> Debug for RoundEvals<T, D>

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

Formats the value using the given formatter.

impl<T: Default, const D: usize> Default for RoundEvals<T, D>

fn default() -> Self

Returns the “default value” for a type.

impl<P: PackedField, const D: usize> Mul<<P as FieldOps>::Scalar> for RoundEvals<P, D>

type Output = RoundEvals<P, D>

The resulting type after applying the * operator.

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

Performs the * operation.