Struct SuffixProver 

pub struct SuffixProver<F: Field, EF: ExtensionField<F>> { /* private fields */ }

Stacked-sumcheck prover with suffix-first variable binding.

Flow

• SVO accumulators are precomputed at claim-recording time.
• Each preprocessing round reads its slice of those accumulators.
• The residual product polynomial is built once, after all rounds.

Trait Implementations

impl<F: Clone + Field, EF: Clone + ExtensionField<F>> Clone for SuffixProver<F, EF>

fn clone(&self) -> SuffixProver<F, EF>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<F: Debug + Field, EF: Debug + ExtensionField<F>> Debug for SuffixProver<F, EF>

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

Formats the value using the given formatter.

impl<F: TwoAdicField, EF: ExtensionField<F>> Layout<F, EF> for SuffixProver<F, EF>

fn num_variables(&self) -> usize

Returns the number of variables of the stacked polynomial.

fn num_variables_table(&self, id: usize) -> usize

Returns the number of variables of table id.

fn eval<Ch>( &mut self, table_idx: usize, polys: &[usize], challenger: &mut Ch, ) -> Vec<EF>

where Ch: FieldChallenger<F> + GrindingChallenger<Witness = F>,

Records opening claims for the selected columns of table_idx.

Arguments

• table_idx — source table index.
• polys — columns to open; must be non-empty.
• challenger — Fiat–Shamir transcript.

Fiat–Shamir

• Samples the opening point internally from the challenger.
• Absorbs the evaluations into the transcript before returning.
• The verifier’s add_claim performs the symmetric absorption.

Panics

• Columns list must be non-empty.

fn add_virtual_eval<Ch>(&mut self, challenger: &mut Ch) -> EF

where Ch: FieldChallenger<F> + GrindingChallenger<Witness = F>,

Samples a virtual evaluation on the full stacked polynomial.

Why heavier than prefix binding

The stacked evaluation factors per column via the selector:

    stacked(point) = sum_{i}  eq(selector_i, point_selector_part)
                              * col_i(point_local_part)

Flow

• Each column is evaluated at its local sub-point.
• Per-column partials are collected on the fly.
• Those partials feed the SVO accumulator batcher.

fn into_sumcheck<Ch>( self, sumcheck_data: &mut SumcheckData<F, EF>, pow_bits: usize, challenger: &mut Ch, ) -> (SumcheckProver<F, EF>, Point<EF>)

where Ch: FieldChallenger<F> + GrindingChallenger<Witness = F>,

Finalises SVO preprocessing and returns the residual sumcheck prover.

Returns

• Residual sumcheck prover over the unpacked product polynomial.
• Folding challenges sampled during preprocessing.

Algorithm

    Phase | Action
    ------+------------------------------------------------------------
      1   | Sample batching challenge  a; flatten alphas by opening_idx.
      2   | Pre-batch per-claim accumulators with the a-powers.
      3   | Loop over preprocessing rounds:
              a. (h(0), h(inf)) = dot(accumulators, Lagrange weights).
              b. Sample challenge r; extrapolate the running sum.
      4   | Compose the residual product polynomial from compressed slots.

fn num_claims(&self) -> usize

Returns the total number of concrete openings recorded so far.

fn from_witness(witness: Witness<F>) -> Self

Builds this layout from a committed witness.

fn new_witness(tables: Vec<Table<F>>, folding: usize) -> Witness<F>

Builds a witness structure for this layout from source tables.

fn commit<Dft, MT, Challenger>( dft: &Dft, mmcs: &MT, challenger: &mut Challenger, witness: Witness<F>, folding: usize, starting_log_inv_rate: usize, ) -> (Self, MT::Commitment, MT::ProverData<DenseMatrix<F>>)

where Dft: TwoAdicSubgroupDft<F>, MT: Mmcs<F>, Challenger: CanObserve<MT::Commitment>,

Commits to the witness and returns the layout.

fn folding(&self) -> usize

Returns the number of variables of first round

fn strategy() -> LayoutStrategy

Returns the verifier strategy required to replay this committed layout.

fn variable_order() -> VariableOrder

Returns the variable order.

impl<F, EF> ZkLayout<F, EF> for SuffixProver<F, EF>

where F: TwoAdicField, EF: ExtensionField<F>,

fn concrete_claims(&self) -> impl Iterator<Item = &ProverMultiClaim<F, EF>>

Walks concrete claims in placement order.

fn virtual_claims(&self) -> &[ProverVirtualClaim<EF>]

Returns the virtual-claim slice.

fn batched_sum(&self, alpha: EF) -> EF

Returns the alpha-batched plain sum.

fn zk_residual_handoff( self, rs: &Point<EF>, alpha: EF, eps: EF, ) -> ProductPolynomial<F, EF>

where EF: TwoAdicField,

Builds the residual product polynomial, scaled by the combining challenge.