Trait binius_core::protocols::abstract_sumcheck::AbstractSumcheckProversState

pub trait AbstractSumcheckProversState<F: Field> {
    type Error: Error + From<Error>;
    type PackedWitnessField: PackedField<Scalar: From<F> + Into<F>>;
    type Claim: AbstractSumcheckClaim<F>;
    type Witness: AbstractSumcheckWitness<Self::PackedWitnessField>;
    type Prover;

    // Required methods
    fn pre_execute_rounds(
        &mut self,
        prev_rd_challenge: Option<F>
    ) -> Result<(), Self::Error>;
    fn new_prover(
        &mut self,
        claim: Self::Claim,
        witness: Self::Witness,
        seq_id: usize
    ) -> Result<Self::Prover, Self::Error>;
    fn prover_execute_round(
        &self,
        prover: &mut Self::Prover,
        prev_rd_challenge: Option<F>
    ) -> Result<AbstractSumcheckRound<F>, Self::Error>;
    fn prover_finalize(
        prover: Self::Prover,
        prev_rd_challenge: Option<F>
    ) -> Result<ReducedClaim<F>, Self::Error>;
}

A trait that oversees the batched sumcheck execution

Implementations are expected to be used to:

• Manage common witness state (typically by perusing super::CommonProversState)
• Create new prover instances at the beginning of a each round (via new_prover)
• Perform common pre-round update steps (via pre_execute_rounds)
• Advance the state of individual prover instances (via prover_execute_round and prover_finalize)

See the implementation super::batch_prove for more details.

Required Associated Types

type Error: Error + From<Error>

type PackedWitnessField: PackedField<Scalar: From<F> + Into<F>>

type Claim: AbstractSumcheckClaim<F>

type Witness: AbstractSumcheckWitness<Self::PackedWitnessField>

type Prover

Required Methods

fn pre_execute_rounds( &mut self, prev_rd_challenge: Option<F> ) -> Result<(), Self::Error>

fn new_prover( &mut self, claim: Self::Claim, witness: Self::Witness, seq_id: usize ) -> Result<Self::Prover, Self::Error>

fn prover_execute_round( &self, prover: &mut Self::Prover, prev_rd_challenge: Option<F> ) -> Result<AbstractSumcheckRound<F>, Self::Error>

fn prover_finalize( prover: Self::Prover, prev_rd_challenge: Option<F> ) -> Result<ReducedClaim<F>, Self::Error>

Object Safety

This trait is not object safe.

Implementors

impl<'a, F, PW, DomainField, EDF, CW, M, Backend> AbstractSumcheckProversState<F> for GkrSumcheckProversState<'a, F, PW, DomainField, EDF, CW, M, Backend>

where F: Field, PW: PackedExtension<DomainField, Scalar: From<F> + Into<F> + ExtensionField<DomainField>>, DomainField: Field, EDF: EvaluationDomainFactory<DomainField>, CW: CompositionPoly<PW>, M: MultilinearPoly<PW> + Clone + Send + Sync, Backend: ComputationBackend,

type Error = Error

type PackedWitnessField = PW

type Claim = GkrSumcheckClaim<F>

type Witness = GkrSumcheckWitness<PW, CW, M>

type Prover = GkrSumcheckProver<'a, F, PW, DomainField, CW, M>

impl<'a, F, PW, DomainField, EDF, W, Backend> AbstractSumcheckProversState<F> for ZerocheckProversState<'a, F, PW, DomainField, EDF, W, Backend>

where F: Field, PW: PackedExtension<DomainField, Scalar: From<F> + Into<F> + ExtensionField<DomainField>>, DomainField: Field, EDF: EvaluationDomainFactory<DomainField>, W: AbstractSumcheckWitness<PW, MultilinearId = OracleId>, Backend: ComputationBackend,

type Error = Error

type PackedWitnessField = PW

type Claim = ZerocheckClaim<F>

type Witness = W

type Prover = ZerocheckProver<'a, F, PW, DomainField, W>

impl<F, PW, DomainField, EDF, W, Backend> AbstractSumcheckProversState<F> for SumcheckProversState<F, PW, DomainField, EDF, W, Backend>

where F: Field, PW: PackedExtension<DomainField, Scalar: From<F> + Into<F> + ExtensionField<DomainField>>, DomainField: Field, EDF: EvaluationDomainFactory<DomainField>, W: AbstractSumcheckWitness<PW, MultilinearId = OracleId>, Backend: ComputationBackend,

type Error = Error

type PackedWitnessField = PW

type Claim = SumcheckClaim<F>

type Witness = W

type Prover = SumcheckProver<F, PW, DomainField, W>