Struct BoundaryConstraintGroup 

pub struct BoundaryConstraintGroup<F, E>
where
    F: FieldElement,
    E: FieldElement<BaseField = <F as FieldElement>::BaseField> + ExtensionOf<F>,
{ /* private fields */ }

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

When the protocol is run in a large field, types F and E are the same. However, when working with small fields, F and E can be set as follows:

• F could be the base field of the protocol, in which case E is the extension field used.
• F could be the extension field, in which case F and E are the same type.

The above arrangement allows us to describe boundary constraints for main and auxiliary segments of the execution trace. Specifically:

• For the constraints against columns of the main execution trace, F is set to the base field of the protocol, and E is set to the extension field.
• For the constraints against columns of the auxiliary trace segment, both F and E are set to the extension field.

Implementations

impl<F, E> BoundaryConstraintGroup<F, E>

where F: FieldElement, E: FieldElement<BaseField = <F as FieldElement>::BaseField> + ExtensionOf<F>,

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

Returns a list of boundary constraints in this group.

pub fn divisor(&self) -> &ConstraintDivisor<<F as FieldElement>::BaseField>

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

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

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

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}{\alpha_i \cdot C_i(x)}}{z(x)} $$ where:

• $C_i(x)$ is the evaluation of the $i$th constraint at x computed as $f(x) - b(x)$.
• $\alpha_i$ are random field elements. In the interactive version of the protocol, these are provided by the verifier.

Trait Implementations

impl<F, E> Clone for BoundaryConstraintGroup<F, E>

where F: Clone + FieldElement, E: Clone + FieldElement<BaseField = <F as FieldElement>::BaseField> + ExtensionOf<F>, <F as FieldElement>::BaseField: Clone,

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<F, E> Debug for BoundaryConstraintGroup<F, E>

where F: Debug + FieldElement, E: Debug + FieldElement<BaseField = <F as FieldElement>::BaseField> + ExtensionOf<F>, <F as FieldElement>::BaseField: Debug,

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

Formats the value using the given formatter.