Struct winter_verifier::BoundaryConstraintGroup

pub struct BoundaryConstraintGroup<B, E> where
    E: FieldElement<BaseField = B>,
    B: StarkField,  { /* fields omitted */ }

A group of boundary constraints all having the same divisor.

A boundary constraint is described by a rational function $\frac{f(x) - b(x)}{z(x)}$, where:

• $f(x)$ is a trace polynomial for the register against which the constraint is placed.
• $b(x)$ is the value polynomial for the constraint.
• $z(x)$ is the constraint divisor polynomial.

A boundary constraint group groups together all boundary constraints where polynomial $z$ is the same. The constraints stored in the group describe polynomials $b$. At the time of constraint evaluation, a prover or a verifier provides evaluations of the relevant polynomial $f$ so that the value of the constraint can be computed.

Implementations

impl<B, E> BoundaryConstraintGroup<B, E> where
    E: FieldElement<BaseField = B>,
    B: StarkField, 

pub fn constraints(&self) -> &[BoundaryConstraint<B, E>]

Returns a list of boundary constraints in this group.

pub fn divisor(&self) -> &ConstraintDivisor<B>

Returns a divisor applicable to all boundary constraints in this group.

pub fn degree_adjustment(&self) -> u32

Returns a degree adjustment factor for all boundary constraints in this group.

pub fn evaluate_at(&self, state: &[E], x: E, xp: E) -> E

Evaluates all constraints in this group at the specified point x.

xp is a degree adjustment multiplier which must be computed as x^degree_adjustment. This value is provided as an argument to this function for optimization purposes.

Constraint evaluations are merges into a single value by computing their random linear combination and dividing the result by the divisor of this constraint group as follows: $$ \frac{\sum_{i=0}^{k-1}{C_i(x) \cdot (\alpha_i + \beta_i \cdot x^d)}}{z(x)} $$ where:

• $C_i(x)$ is the evaluation of the $i$th constraint at x computed as $f(x) - b(x)$.
• $\alpha$ and $\beta$ are random field elements. In the interactive version of the protocol, these are provided by the verifier.
• $z(x)$ is the evaluation of the divisor polynomial for this group at $x$.
• $d$ is the degree adjustment factor computed as $D - deg(C_i(x)) + deg(z(x))$, where $D$ is the degree of the composition polynomial.

Thus, the merged evaluations represent a polynomial of degree $D$, as the degree of the numerator is $D + deg(z(x))$, and the division by $z(x)$ reduces the degree by $deg(z(x))$.

Trait Implementations

impl<B, E> Clone for BoundaryConstraintGroup<B, E> where
    E: Clone + FieldElement<BaseField = B>,
    B: Clone + StarkField, 

pub fn clone(&self) -> BoundaryConstraintGroup<B, E>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<B, E> Debug for BoundaryConstraintGroup<B, E> where
    E: Debug + FieldElement<BaseField = B>,
    B: Debug + StarkField, 

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

Formats the value using the given formatter.