Enum VariableOrder 

pub enum VariableOrder {
    Prefix,
    Suffix,
}

Which side of the variable order is bound first by the sumcheck rounds.

Role

• Round-coefficient math differs in which axis is summed over.
• Variable binding differs in which coordinate is fixed to the challenge.
• Verifier constraint evaluation differs in how the final challenge is spliced.

All three dispatches go through inherent methods below, so the runtime branch sits in the outer frame and never inside the O(2^n) inner loops.

Variants

Prefix

Prefix variables are bound first (round i binds X_i).

Suffix

Suffix variables are bound first (round i binds X_{n-i}).

Implementations

impl VariableOrder

pub fn sumcheck_coefficients<B, A>(self, evals: &[B], weights: &[A]) -> (A, A)

where B: PrimeCharacteristicRing + Copy + Send + Sync, A: Algebra<B> + Copy + Send + Sync,

Computes (h(0), h(inf)) for one quadratic sumcheck round.

pub fn fix_var<A, Ch>(self, poly: &mut Poly<A>, r: Ch)

where A: Algebra<Ch> + Copy + Send + Sync, Ch: Copy + Send + Sync,

Binds the active round variable of poly to challenge r.

pub fn eval_constraints_poly<F, EF>( self, constraints: &[Constraint<F, EF>], challenge: &Point<EF>, ) -> EF

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

Evaluates the batched verifier constraints at the final challenge point.

Slicing rule

• Prefix binding folds variables low-to-high, so each constraint sees the last k original variables of the challenge.
• Suffix binding folds variables high-to-low, so each constraint sees the last k original variables of the challenge, reversed.

Trait Implementations

impl Clone for VariableOrder

fn clone(&self) -> VariableOrder

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for VariableOrder

impl Debug for VariableOrder

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

Formats the value using the given formatter.

impl Eq for VariableOrder

impl PartialEq for VariableOrder

fn eq(&self, other: &VariableOrder) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for VariableOrder