Struct SharedMleCheckProver 

pub struct SharedMleCheckProver<'a, A: Allocator, F: Field, P: PackedField<Scalar = F>, Evaluator> { /* private fields */ }

A MleCheckProver over a shared MleStore and a group of MleCheckRoundEvaluators.

This is the MLE-check counterpart of SharedSumcheckProver: every evaluator’s claim shares the prover’s evaluation point, and the round polynomials are the eq-factored prime polynomials of the MLE-check protocol. Because the point is shared, the prover owns its eq-indicator tracker and hands the round’s eq chunk and coordinate to the evaluators, which therefore store no tracker id.

Implementations

impl<'a, A, F, P, Evaluator> SharedMleCheckProver<'a, A, F, P, Evaluator>

where A: Allocator, F: Field, P: PackedField<Scalar = F>, Evaluator: MleCheckRoundEvaluator<F, P>,

pub fn new( store: MleStore<'a, A, P>, claims_with_evaluators: impl IntoIterator<Item = (F, Evaluator)>, eval_point: Vec<F>, ) -> Self

Creates a prover from a store, the evaluators reading its columns each paired with its initial claim — one (claim, evaluator) per claim — and the evaluation point shared by all of the evaluators’ claims.

pub fn into_shared_sumcheck( self, ) -> SharedSumcheckProver<'a, A, P, Box<dyn SumcheckRoundEvaluator<F, P> + 'a>>

where Evaluator: 'a,

Converts this MLE-check prover into a plain SharedSumcheckProver by folding each claim’s equality factor into its emitted round polynomials — the Gruen24 technique of MleToSumCheckEvaluator.

This lets an eq-weighted claim batch in one evaluator group alongside plain sumcheck claims over the same store: the logUp* pushforward reduction converts its evaluation claim on Y, then adds the eq-free product evaluator to it. The store and its columns carry over untouched; only the evaluators are wrapped, sharing this prover’s eq tracker.

Trait Implementations

impl<A, F, P, Evaluator> MleCheckProver<F> for SharedMleCheckProver<'_, A, F, P, Evaluator>

where A: Allocator, F: Field, P: PackedField<Scalar = F>, Evaluator: MleCheckRoundEvaluator<F, P>,

fn n_vars(&self) -> usize

The number of variables still free.

fn execute(&mut self) -> Vec<RoundCoeffs<F>>

Computes this round’s message, one univariate polynomial per claim.

fn fold(&mut self, challenge: F)

Binds this round’s variable to the verifier challenge.

fn finish(self) -> Vec<F>

Consumes the prover and returns every multilinear’s evaluation at the challenge point.

fn eval_point(&self) -> &[F]

The still-unbound part of the evaluation point, one coordinate per free variable.