Struct DebugConstraintBuilder 

pub struct DebugConstraintBuilder<'a, SC: StarkProtocolConfig> {
    pub air_name: &'a str,
    pub row_index: usize,
    pub preprocessed: ViewPair<'a, Val<SC>>,
    pub partitioned_main: Vec<ViewPair<'a, Val<SC>>>,
    pub is_first_row: Val<SC>,
    pub is_last_row: Val<SC>,
    pub is_transition: Val<SC>,
    pub public_values: &'a [Val<SC>],
    pub has_common_main: bool,
}

An AirBuilder which asserts that each constraint is zero, allowing any failed constraints to be detected early.

Fields

air_name: &'a str

row_index: usize

preprocessed: ViewPair<'a, Val<SC>>

partitioned_main: Vec<ViewPair<'a, Val<SC>>>

is_first_row: Val<SC>

is_last_row: Val<SC>

is_transition: Val<SC>

public_values: &'a [Val<SC>]

has_common_main: bool

Trait Implementations

impl<'a, SC> AirBuilder for DebugConstraintBuilder<'a, SC>

where SC: StarkProtocolConfig,

fn main(&self) -> Self::M

It is difficult to horizontally concatenate matrices when the main trace is partitioned, so we disable this method in that case.

type F = <SC as StarkProtocolConfig>::F

Underlying field type.

type Expr = <SC as StarkProtocolConfig>::F

Serves as the output type for an AIR constraint evaluation.

type Var = <SC as StarkProtocolConfig>::F

The type of the variable appearing in the trace matrix.

type M = VerticalPair<DenseMatrix<<SC as StarkProtocolConfig>::F, &'a [<SC as StarkProtocolConfig>::F]>, DenseMatrix<<SC as StarkProtocolConfig>::F, &'a [<SC as StarkProtocolConfig>::F]>>

Matrix type holding variables.

fn is_first_row(&self) -> Self::Expr

Expression evaluating to 1 on the first row, 0 elsewhere.

fn is_last_row(&self) -> Self::Expr

Expression evaluating to 1 on the last row, 0 elsewhere.

fn is_transition_window(&self, size: usize) -> Self::Expr

Expression evaluating to 1 on rows except the last size - 1 rows, 0 otherwise.

fn assert_zero<I: Into<Self::Expr>>(&mut self, x: I)

Assert that the given element is zero.

fn assert_eq<I1: Into<Self::Expr>, I2: Into<Self::Expr>>( &mut self, x: I1, y: I2, )

Assert that the given elements are equal.

fn is_transition(&self) -> Self::Expr

Expression evaluating to 1 on all transition rows (not last row), 0 on last row.

fn when<I>(&mut self, condition: I) -> FilteredAirBuilder<'_, Self>

where I: Into<Self::Expr>,

Returns a sub-builder whose constraints are enforced only when condition is nonzero.

fn when_ne<I1, I2>(&mut self, x: I1, y: I2) -> FilteredAirBuilder<'_, Self>

where I1: Into<Self::Expr>, I2: Into<Self::Expr>,

Returns a sub-builder whose constraints are enforced only when x != y.

fn when_first_row(&mut self) -> FilteredAirBuilder<'_, Self>

Returns a sub-builder whose constraints are enforced only on the first row.

fn when_last_row(&mut self) -> FilteredAirBuilder<'_, Self>

Returns a sub-builder whose constraints are enforced only on the last row.

fn when_transition(&mut self) -> FilteredAirBuilder<'_, Self>

Returns a sub-builder whose constraints are enforced on all rows except the last.

fn when_transition_window( &mut self, size: usize, ) -> FilteredAirBuilder<'_, Self>

Returns a sub-builder whose constraints are enforced on all rows except the last size - 1.

fn assert_zeros<const N: usize, I>(&mut self, array: [I; N])

where I: Into<Self::Expr>,

Assert that every element of a given array is 0.

fn assert_bools<const N: usize, I>(&mut self, array: [I; N])

where I: Into<Self::Expr>,

Assert that a given array consists of only boolean values.

fn assert_one<I>(&mut self, x: I)

where I: Into<Self::Expr>,

Assert that x element is equal to 1.

fn assert_bool<I>(&mut self, x: I)

where I: Into<Self::Expr>,

Assert that x is a boolean, i.e. either 0 or 1.

impl<SC> AirBuilderWithPublicValues for DebugConstraintBuilder<'_, SC>

where SC: StarkProtocolConfig,

type PublicVar = <SC as StarkProtocolConfig>::F

Type representing a public variable.

fn public_values(&self) -> &[Self::F]

Return the list of public variables.

impl<SC> ExtensionBuilder for DebugConstraintBuilder<'_, SC>

where SC: StarkProtocolConfig,

type EF = <SC as StarkProtocolConfig>::EF

Extension field type.

type ExprEF = <SC as StarkProtocolConfig>::EF

Expression type over extension field elements.

type VarEF = <SC as StarkProtocolConfig>::EF

Variable type over extension field elements.

fn assert_zero_ext<I>(&mut self, x: I)

where I: Into<Self::ExprEF>,

Assert that an extension field expression is zero.

fn assert_eq_ext<I1, I2>(&mut self, x: I1, y: I2)

where I1: Into<Self::ExprEF>, I2: Into<Self::ExprEF>,

Assert that two extension field expressions are equal.

fn assert_one_ext<I>(&mut self, x: I)

where I: Into<Self::ExprEF>,

Assert that an extension field expression is equal to one.

impl<SC> InteractionBuilder for DebugConstraintBuilder<'_, SC>

where SC: StarkProtocolConfig,

fn push_interaction<E: Into<Self::Expr>>( &mut self, _bus_index: BusIndex, _fields: impl IntoIterator<Item = E>, _count: impl Into<Self::Expr>, _count_weight: u32, )

Stores a new interaction in the builder.

fn num_interactions(&self) -> usize

Returns the current number of interactions.

fn all_interactions(&self) -> &[Interaction<Self::Expr>]

Returns all interactions stored.

fn assert_tern(&mut self, x: impl Into<Self::Expr>)

impl<SC> PairBuilder for DebugConstraintBuilder<'_, SC>

where SC: StarkProtocolConfig,

fn preprocessed(&self) -> Self::M

Return a matrix of preprocessed registers.

impl<SC> PartitionedAirBuilder for DebugConstraintBuilder<'_, SC>

where SC: StarkProtocolConfig,

fn cached_mains(&self) -> &[Self::M]

Cached main trace matrix.

fn common_main(&self) -> &Self::M

Common main trace matrix. Panic if there is no common main trace.