Struct BatchVerifier

pub struct BatchVerifier<F: Field, C> { /* private fields */ }

Verifier for a front-loaded batch sumcheck protocol execution.

The sumcheck protocol over can be batched over multiple instances by taking random linear combinations over the claimed sums and polynomials. When the sumcheck instances are not all over polynomials with the same number of variables, we can still batch them together.

This version of the protocols sharing the round challenges of the early rounds across sumcheck claims with different numbers of variables. In contrast, the crate::protocols::sumcheck::verify module implements batches sumcheck sharing later round challenges. We call this version a “front-loaded” sumcheck.

For each sumcheck claim, we sample one random mixing coefficient. The multiple composite claims within each claim over a group of multilinears are mixed using the powers of the mixing coefficient.

This exposes a round-by-round interface so that the protocol call be interleaved with other interactive protocols, sharing the same sequence of challenges. The verification logic must be invoked with a specific sequence of calls, continuing for as many rounds as necessary until all claims are finished.

1. construct a new verifier with BatchVerifier::new
2. call BatchVerifier::try_finish_claim until it returns None
3. if BatchVerifier::remaining_claims is 0, call BatchVerifier::finish, otherwise proceed to step 4
4. call BatchVerifier::receive_round_proof
5. sample a random challenge and call BatchVerifier::finish_round with it
6. repeat from step 2

Implementations

impl<F, C> BatchVerifier<F, C>

where F: TowerField, C: CompositionPolyOS<F> + Clone,

pub fn new<Transcript>( claims: &[SumcheckClaim<F, C>], transcript: &mut Transcript, ) -> Result<Self, Error>

where Transcript: CanSample<F>,

Constructs a new verifier for the front-loaded batched sumcheck.

The constructor samples batching coefficients from the proof transcript.

Throws

• if the claims are not sorted in ascending order by number of variables

pub fn remaining_claims(&self) -> usize

Returns the number of sumcheck claims that have not finished.

pub fn try_finish_claim<Transcript>( &mut self, transcript: &mut Transcript, ) -> Result<Option<Vec<F>>, Error>

where Transcript: CanRead,

Processes the next finished sumcheck claim, if all of its rounds are complete.

pub fn receive_round_proof<Transcript>( &mut self, transcript: &mut Transcript, ) -> Result<(), Error>

where Transcript: CanRead,

Reads the round message from the proof transcript.

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

Finishes an interaction round by reducing the instance with a random challenge.

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

Performs the final sumcheck verification checks, consuming the verifier.

Trait Implementations

impl<F: Debug + Field, C: Debug> Debug for BatchVerifier<F, C>

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

Formats the value using the given formatter.