Struct ProverState

pub struct ProverState<'a, FDomain, P, M, Backend>
where
    FDomain: Field,
    P: PackedField,
    M: MultilinearPoly<P> + Send + Sync,
    Backend: ComputationBackend,
{ /* private fields */ }

The stored state of a sumcheck prover, which encapsulates common implementation logic.

We expect that CPU sumcheck provers will internally maintain a ProverState instance and customize the sumcheck logic through different SumcheckEvaluator implementations passed to the common state object.

Implementations

impl<'a, FDomain, P, M, Backend> ProverState<'a, FDomain, P, M, Backend>

where FDomain: Field, P: PackedField, M: MultilinearPoly<P> + Send + Sync, Backend: ComputationBackend,

pub fn n_vars(&self) -> usize

The number of variables in the folded multilinears. This value decrements each round the state is folded.

impl<'a, FDomain, F, P, M, Backend> ProverState<'a, FDomain, P, M, Backend>

where FDomain: Field, F: Field + ExtensionField<FDomain>, P: PackedField<Scalar = F> + PackedExtension<FDomain>, M: MultilinearPoly<P> + Send + Sync, Backend: ComputationBackend,

pub fn new( multilinears: Vec<M>, claimed_sums: Vec<F>, evaluation_points: Vec<FDomain>, switchover_fn: impl Fn(usize) -> usize, backend: &'a Backend, ) -> Result<Self, Error>

pub fn new_with_switchover_rounds( multilinears: Vec<M>, switchover_rounds: &[usize], claimed_sums: Vec<F>, evaluation_points: Vec<FDomain>, backend: &'a Backend, ) -> Result<Self, Error>

pub fn fold(&mut self, challenge: F) -> Result<(), Error>

pub fn finish(self) -> Result<Vec<F>, Error>

pub fn calculate_first_round_evals<PBase, Evaluator, Composition>( &self, evaluators: &[Evaluator], ) -> Result<Vec<RoundEvals<F>>, Error>

where PBase: PackedField<Scalar: ExtensionField<FDomain>> + PackedExtension<FDomain>, P: PackedField<Scalar: ExtensionField<PBase::Scalar>> + RepackedExtension<PBase>, Evaluator: SumcheckEvaluator<PBase, P, Composition> + Sync, Composition: CompositionPolyOS<P>,

Calculate the accumulated evaluations for the first sumcheck round.

pub fn calculate_later_round_evals<Evaluator, Composition>( &self, evaluators: &[Evaluator], ) -> Result<Vec<RoundEvals<F>>, Error>

where Evaluator: SumcheckEvaluator<P, P, Composition> + Sync, Composition: CompositionPolyOS<P>,

Calculate the accumulated evaluations for an arbitrary sumcheck round.

See Self::calculate_first_round_evals for an optimized version of this method that operates over small fields in the first round.

pub fn calculate_round_coeffs_from_evals<Interpolator: SumcheckInterpolator<F>>( &mut self, interpolators: &[Interpolator], batch_coeff: F, evals: Vec<RoundEvals<F>>, ) -> Result<RoundCoeffs<F>, Error>

Calculate the batched round coefficients from the domain evaluations.

This both performs the polynomial interpolation over the evaluations and the mixing with the batching coefficient.

Trait Implementations

impl<'a, FDomain, P, M, Backend> Debug for ProverState<'a, FDomain, P, M, Backend>

where FDomain: Field + Debug, P: PackedField + Debug, M: MultilinearPoly<P> + Send + Sync + Debug, Backend: ComputationBackend + Debug, P::Scalar: Debug,

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

Formats the value using the given formatter.