Struct winter_verifier::BoundaryConstraint

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

The numerator portion of a boundary constraint.

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(b)$ is the value polynomial for this constraint.
• $z(x)$ is the constraint divisor polynomial.

In addition to the value polynomial, a BoundaryConstraint also contains info needed to evaluate the constraint and to compose constraint evaluations with other constraints (i.e., constraint composition coefficients).

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.

Boundary constraints cannot be instantiated directly, they are created internally from Assertions.

Implementations

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

pub fn column(&self) -> usize

Returns index of the column against which this constraint applies.

pub fn poly(&self) -> &[F]

Returns a value polynomial for this constraint.

pub fn poly_offset(&self) -> (usize, <F as FieldElement>::BaseField)

Returns offset by which we need to shift the domain before evaluating this constraint.

The offset is returned as a tuple describing both, the number of steps by which the domain needs to be shifted, and field element by which a domain element needs to be multiplied to achieve the desired shift.

pub fn cc(&self) -> &(E, E)

Returns composition coefficients for this constraint.

pub fn evaluate_at(&self, x: E, trace_value: E) -> E

Evaluates this constraint at the specified point x.

The constraint is evaluated by computing $f(x) - b(x)$, where:

• $f$ is a trace polynomial for the column against which the constraint is placed.
• $f(x)$ = trace_value
• $b$ is the value polynomial for this constraint.

For boundary constraints derived from single and periodic assertions, $b(x)$ is a constant.

Trait Implementations

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

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<F, E> Debug for BoundaryConstraint<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.

impl<F, E> PartialEq<BoundaryConstraint<F, E>> for BoundaryConstraint<F, E>where
    F: PartialEq<F> + FieldElement,
    E: PartialEq<E> + FieldElement<BaseField = <F as FieldElement>::BaseField> + ExtensionOf<F>,
    <F as FieldElement>::BaseField: PartialEq<<F as FieldElement>::BaseField>,

fn eq(&self, other: &BoundaryConstraint<F, E>) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

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

impl<F, E> Eq for BoundaryConstraint<F, E>where
    F: Eq + FieldElement,
    E: Eq + FieldElement<BaseField = <F as FieldElement>::BaseField> + ExtensionOf<F>,
    <F as FieldElement>::BaseField: Eq,

impl<F, E> StructuralEq for BoundaryConstraint<F, E>where
    F: FieldElement,
    E: FieldElement<BaseField = <F as FieldElement>::BaseField> + ExtensionOf<F>,

impl<F, E> StructuralPartialEq for BoundaryConstraint<F, E>where
    F: FieldElement,
    E: FieldElement<BaseField = <F as FieldElement>::BaseField> + ExtensionOf<F>,