Trait MleCheckRoundEvaluator 

pub trait MleCheckRoundEvaluator<F: Field, P: PackedField<Scalar = F>>: Send + Sync {
    // Required methods
    fn degree(&self) -> usize;
    fn accumulate(
        &self,
        chunk: &EvaluationChunk<'_, P>,
        eq_ind: FieldSlice<'_, P>,
        accum: &mut [<P as WideMul>::Output],
    );
    fn interpolate(
        &self,
        ctx: &RoundContext<'_, P>,
        accum: &[P],
        claim: F,
        alpha: F,
    ) -> RoundCoeffs<F>;
}

Per-round-polynomial logic for one MLE-check claim over store columns.

This is the MLE-check counterpart of SumcheckRoundEvaluator. It emits the prime, equality-factored round polynomials of the MLE-check protocol.

Every claim of one such prover shares a single evaluation point. The prover, not the evaluator, owns that point’s equality indicator. Two arguments follow from that:

• Accumulation receives the round’s equality-indicator chunk.
• Interpolation receives the round’s equality coordinate.

So the evaluator stores no tracker identifier and no copy of the point. The accumulator contract is the one above: wide slots in, reduced slots out.

Required Methods

fn degree(&self) -> usize

The number of accumulator slots this evaluator’s claim uses. See SumcheckRoundEvaluator::degree.

fn accumulate( &self, chunk: &EvaluationChunk<'_, P>, eq_ind: FieldSlice<'_, P>, accum: &mut [<P as WideMul>::Output], )

Accumulates one chunk of the halved hypercube into accum.

eq_ind is the round’s eq-indicator chunk (the prover looks it up once and hands it to every evaluator); the evaluator weights its composition by it. Otherwise as SumcheckRoundEvaluator::accumulate.

fn interpolate( &self, ctx: &RoundContext<'_, P>, accum: &[P], claim: F, alpha: F, ) -> RoundCoeffs<F>

Interpolates this round’s prime polynomial from the accumulator and the round claim.

As SumcheckRoundEvaluator::interpolate, with one difference. The round’s equality coordinate arrives as an argument rather than from a tracker. So ctx supplies only the unbound-variable count.

Dyn Compatibility

This trait is dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementations on Foreign Types

impl<F: Field, P: PackedField<Scalar = F>, T: MleCheckRoundEvaluator<F, P> + ?Sized> MleCheckRoundEvaluator<F, P> for Box<T>

where Box<T>: Send + Sync,

fn degree(&self) -> usize

fn accumulate( &self, chunk: &EvaluationChunk<'_, P>, eq_ind: FieldSlice<'_, P>, accum: &mut [<P as WideMul>::Output], )

fn interpolate( &self, ctx: &RoundContext<'_, P>, accum: &[P], claim: F, alpha: F, ) -> RoundCoeffs<F>

Implementors

impl<F, P, Composition, InfinityComposition, const N: usize> MleCheckRoundEvaluator<F, P> for QuadraticMleEvaluator<Composition, InfinityComposition, N>

where F: Field, P: PackedField<Scalar = F>, Composition: Fn([P; N]) -> P + Send + Sync, InfinityComposition: Fn([P; N]) -> P + Send + Sync,

impl<F, P> MleCheckRoundEvaluator<F, P> for MultilinearEvalEvaluator

where F: Field, P: PackedField<Scalar = F>,