Struct ZeroCheckPoly 

pub struct ZeroCheckPoly<K, F, EF, A> {
    pub air_data: ZerocheckCpuProver<F, EF, A>,
    pub zeta: Point<EF>,
    pub preprocessed_columns: Option<PaddedMle<K>>,
    pub main_columns: PaddedMle<K>,
    pub eq_adjustment: EF,
    pub geq_value: EF,
    pub padded_row_adjustment: EF,
    pub virtual_geq: VirtualGeq<K>,
}

Zerocheck sumcheck polynomial.

Fields

air_data: ZerocheckCpuProver<F, EF, A>

The data that contains the constraint polynomial.

zeta: Point<EF>

The random challenge point at which the polynomial is evaluated.

preprocessed_columns: Option<PaddedMle<K>>

The preprocessed trace.

main_columns: PaddedMle<K>

The main trace.

eq_adjustment: EF

The adjustment factor from the constant part of the eq polynomial.

geq_value: EF

The geq polynomial value. This will be 0 for all zerocheck polys that are at least one non-padded variable.

padded_row_adjustment: EF

Num padded variables. These padded variables are the first-most (e.g. the most significant) variables. The padded row adjustment.

virtual_geq: VirtualGeq<K>

A virtual materialization keeping track the geq polynomial which is used to adjust the sums for airs in which the zero row doesn’t satisfy the constraints.

Implementations

impl<K: Field, F: Field, EF: ExtensionField<F>, AirData> ZeroCheckPoly<K, F, EF, AirData>

pub fn new( air_data: ZerocheckCpuProver<F, EF, AirData>, zeta: Point<EF>, preprocessed_values: Option<PaddedMle<K>>, main_values: PaddedMle<K>, eq_adjustment: EF, geq_value: EF, padded_row_adjustment: EF, virtual_geq: VirtualGeq<K>, ) -> Self

Creates a new ZeroCheckPoly.

Trait Implementations

impl<K: Clone, F: Clone, EF: Clone, A: Clone> Clone for ZeroCheckPoly<K, F, EF, A>

fn clone(&self) -> ZeroCheckPoly<K, F, EF, A>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<K, F, EF, AirData> ComponentPolyEvalBackend<ZeroCheckPoly<K, F, EF, AirData>, EF> for CpuBackend

where K: Field, F: Field, EF: ExtensionField<F> + ExtensionField<K>, AirData: Sync + Send,

fn get_component_poly_evals(poly: &ZeroCheckPoly<K, F, EF, AirData>) -> Vec<EF>

impl<K, F, EF, AirData> HasBackend for ZeroCheckPoly<K, F, EF, AirData>

type Backend = CpuBackend

fn backend(&self) -> &Self::Backend

impl<F, EF, A> SumCheckPolyFirstRoundBackend<ZeroCheckPoly<F, F, EF, A>, EF> for CpuBackend

where F: Field, EF: ExtensionField<F>, A: ZerocheckAir<F, EF> + Send + Sync,

type NextRoundPoly = ZeroCheckPoly<EF, F, EF, A>

fn fix_t_variables( poly: ZeroCheckPoly<F, F, EF, A>, alpha: EF, t: usize, ) -> Self::NextRoundPoly

fn sum_as_poly_in_last_t_variables( poly: &ZeroCheckPoly<F, F, EF, A>, claim: Option<EF>, t: usize, ) -> UnivariatePolynomial<EF>

impl<F, EF, A> SumcheckPolyBackend<ZeroCheckPoly<EF, F, EF, A>, EF> for CpuBackend

where F: Field, EF: ExtensionField<F>, A: ZerocheckAir<F, EF> + Send + Sync,

fn fix_last_variable( poly: ZeroCheckPoly<EF, F, EF, A>, alpha: EF, ) -> ZeroCheckPoly<EF, F, EF, A>

fn sum_as_poly_in_last_variable( poly: &ZeroCheckPoly<EF, F, EF, A>, claim: Option<EF>, ) -> UnivariatePolynomial<EF>

impl<K, F: Field, EF, AirData> SumcheckPolyBase for ZeroCheckPoly<K, F, EF, AirData>

where K: Field,

fn num_variables(&self) -> u32