Struct Verifier 

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

Verifier-side layout and claim registry.

Implementations

impl<F: Field, EF: ExtensionField<F>> Verifier<F, EF>

pub fn new(tables: &[TableShape], strategy: LayoutStrategy) -> Self

Reconstructs the verifier-side layout from table shapes.

Algorithm

• Sort table indices by arity ascending.
• Iterate reversed, so largest tables get placed first.
• Each column occupies one slot of size 2^arity.
• Stacked arity equals log2 of total stacked size, rounded up.

pub const fn strategy(&self) -> LayoutStrategy

Return the layout strategy this verifier was constructed with.

Downstream protocols read it to dispatch on the binding direction without threading the strategy through their own state.

pub fn num_variables_table(&self, table_idx: usize) -> usize

Returns the arity of the source table at the given index.

pub fn add_claim<Ch>( &mut self, table_idx: usize, polys: &[usize], evals: &[EF], challenger: &mut Ch, )

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

Records concrete opening claims for one table.

Arguments

• table_idx — source table index.
• polys — column indices that were opened; must be non-empty.
• evals — claimed evaluations, aligned with the column list.
• challenger — Fiat–Shamir transcript.

Fiat–Shamir

• Samples the opening point internally from the challenger.
• Absorbs the evaluations into the transcript.
• Mirrors exactly the prover’s eval absorption order.

Panics

• Columns list must be non-empty.
• Column list and evaluation list must have equal length.
• Every column index must be in range for this table.

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

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

Records a virtual evaluation claim on the full stacked polynomial.

Fiat–Shamir

• Samples the opening point from the challenger.
• Absorbs the evaluation into the transcript.
• Mirrors exactly the prover’s add_virtual_eval absorption order.

pub fn sum(&self, alpha: EF) -> EF

Computes the batched claimed sum across concrete and virtual openings.

    sum = sum_{i}  alpha^i * eval_i

Traversal order

• Concrete openings first, walked in stacked-polynomial order.
• Virtual claims continue the alpha sequence after the concrete ones.

pub fn constraint(&self, alpha: EF) -> Constraint<F, EF>

Builds the verifier-side equality constraint batching every claim.

Contributions

• Concrete opening: equality at the selector-lifted claim point.
• Virtual claim: equality at the full stacked point.

Trait Implementations

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

fn clone(&self) -> Verifier<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 Verifier<F, EF>

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

Formats the value using the given formatter.