Struct ChunkedEqTracker 

pub struct ChunkedEqTracker<P: PackedField> { /* private fields */ }

Equality-indicator state for one point, holding the expansion as an outer product.

A prover walking the hypercube in chunks reads the two factors at different rates:

    expansion[s * chunk_len + c]  =  chunk[c] * suffix[s]

    chunk    read per element, so it should stay in cache
    suffix   read once per chunk, as a single scalar

Keeping the per-element factor small is what lets it stay resident.

Implementations

impl<F: Field, P: PackedField<Scalar = F>> ChunkedEqTracker<P>

pub fn new(max_chunk_vars: usize, eval_point: &[F]) -> Self

Expands the indicator as two factors, for every coordinate bar the highest.

Arguments

• max_chunk_vars - Ceiling on the inner factor’s variable count.
• eval_point - The point the claim is weighted at.

pub fn next_coordinate(&self) -> F

Returns the coordinate of the variable the next round binds.

pub const fn chunk(&self) -> &FieldBuffer<P>

Returns the inner factor, indexed within one chunk.

pub const fn suffix(&self) -> &FieldBuffer<P>

Returns the outer factor, indexed by chunk.

pub fn interpolate2( &self, sum: F, prime_evals: RoundEvals<F, 2>, ) -> (RoundCoeffs<F>, RoundCoeffs<F>)

Interpolates a degree-2 round polynomial from its sampled evaluations.

Arguments

• sum - The claim this round’s polynomial must satisfy.
• prime_evals - Sampled evaluations, with the equality factors removed.

Returns

• The polynomial without its equality factors, which the next claim reduces.
• The same polynomial carrying both factors, which goes on the wire.

pub fn fold(&mut self, challenge: F)

Advances one round, contracting whichever factor holds the bound coordinate.

Trait Implementations

impl<P: Clone + PackedField> Clone for ChunkedEqTracker<P>

where P::Scalar: Clone,

fn clone(&self) -> ChunkedEqTracker<P>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<P: Debug + PackedField> Debug for ChunkedEqTracker<P>

where P::Scalar: Debug,

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

Formats the value using the given formatter.