Struct PrefixProver 

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

Stacked-sumcheck prover with prefix-first variable binding.

Flow

• Round one runs in SIMD-packed form.
• Every later round runs on the residual product polynomial.

Trait Implementations

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

fn clone(&self) -> PrefixProver<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 PrefixProver<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 PrefixProver<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

The WHIR protocol occasionally pins the stacked polynomial at a fresh random point for soundness amplification. Prefix mode evaluates the stacked polynomial directly — no per-column weighting needed.

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 preprocessing and returns the residual sumcheck prover.

Returns

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

Algorithm

    Phase | Action
    ------+-----------------------------------------------
      1   | Sample the batching challenge  a.
      2   | running sum  = sum_{i}  a^i * eval_i.
      3   | weight poly  = sum_{i}  a^i * eq(z_i, X).
      4   | Fold round 1 in SIMD-packed arithmetic.
      5   | Drive rounds 2..folding on the product polynomial.

Precondition

• Each table’s arity is at least log_2(W), with W the packing width.
• Guarantees every per-slot packed accumulation spans a whole packed element.

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 PrefixProver<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.