Struct RegularLayer 

pub struct RegularLayer<F: Field> {
    id: LayerId,
    pub(crate) expression: Expression<F, ProverExpr>,
    sumcheck_rounds: Vec<usize>,
    beta_vals_vec: Option<Vec<BetaValues<F>>>,
}

The most common implementation of crate::layer::Layer.

A regular layer is made up of a structured polynomial relationship between MLEs of previous layers.

Proofs are generated with the Sumcheck protocol.

Fields

id: LayerId

This layer’s ID.

expression: Expression<F, ProverExpr>

The polynomial expression defining this layer. It includes information on how this layer relates to the others.

sumcheck_rounds: Vec<usize>

Stores the indices of the sumcheck rounds in this GKR layer so we only produce sumcheck proofs over those. When we use interpolative claim aggregation, this is all of the nonlinear variables in the expression. When we use RLC claim aggregation, this is all of the variables in the expression.

beta_vals_vec: Option<Vec<BetaValues<F>>>

Stores the beta values associated with the expression. Initially set to None. Computed during initialization.

Implementations

impl<F: Field> RegularLayer<F>

pub fn new_raw(id: LayerId, expression: Expression<F, ProverExpr>) -> Self

Creates a new RegularLayer from an Expression and a LayerId

The Expression is the relationship this Layer proves and the LayerId is the location of this Layer in the overall circuit

pub fn get_expression(&self) -> &Expression<F, ProverExpr>

Returns a reference to the expression that this layer is proving.

pub fn append_leaf_mles_to_transcript( &self, transcript_writer: &mut impl ProverTranscript<F>, ) -> Result<()>

Traverse the fully-bound self.expression and append all MLE values to the trascript.

Trait Implementations

impl<F: Clone + Field> Clone for RegularLayer<F>

fn clone(&self) -> RegularLayer<F>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<F: Debug + Field> Debug for RegularLayer<F>

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

Formats the value using the given formatter.

impl<'de, F> Deserialize<'de> for RegularLayer<F>

where F: Field,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<F: Field> From<RegularLayer<F>> for LayerEnum<F>

fn from(var: RegularLayer<F>) -> LayerEnum<F>

Converts to this type from the input type.

impl<F: Field> Layer<F> for RegularLayer<F>

fn initialize(&mut self, claim_point: &[F]) -> Result<()>

Initialize all necessary information in order to start sumcheck within a layer of GKR. This includes pre-fixing all of the rounds within the layer which are linear, and then appropriately initializing the necessary beta values over the nonlinear rounds.

fn sumcheck_round_indices(&self) -> Vec<usize>

Returns the round indices (with respect to the indices of all relevant variables within the layer) which are nonlinear. For example, if the current layer’s Expression looks something like V_{i + 1}(x_1, x_2, x_3) * V_{i + 2}(x_1, x_2) then the sumcheck_round_indices of this layer would be [1, 2].

fn get_post_sumcheck_layer( &self, round_challenges: &[F], claim_challenges: &[&[F]], random_coefficients: &[F], ) -> PostSumcheckLayer<F, F>

Get the PostSumcheckLayer for a regular layer, which represents the fully bound expression. Relevant for the Hyrax IP, where we need commitments to fully bound MLEs as well as their intermediate products.

fn layer_id(&self) -> LayerId

Gets this layer’s ID.

fn prove( &mut self, claims: &[&RawClaim<F>], transcript_writer: &mut impl ProverTranscript<F>, ) -> Result<()>

Tries to prove claims for this layer. There is only a single aggregated claim if our [shared_types::config::ClaimAggregationStrategy] is [shared_types::config::ClaimAggregationStrategy::Interpolative], otherwise we have several claims we take the random linear combination over.

fn initialize_rlc( &mut self, _random_coefficients: &[F], claims: &[&RawClaim<F>], )

Transforms the underlying expression in the layer to the expression that must be sumchecked over to verify claims combined using the RLC claim aggregation method presented in Libra (2019).

fn compute_round_sumcheck_message( &mut self, round_index: usize, random_coefficients: &[F], ) -> Result<Vec<F>>

Return the evaluations of the univariate polynomial generated during this round of sumcheck.

fn bind_round_variable( &mut self, round_index: usize, challenge: F, ) -> Result<()>

Mutate the underlying bookkeeping tables to “bind” the given challenge to the bit. labeled with that round_index.

fn max_degree(&self) -> usize

The maximum degree for any univariate in the sumcheck protocol.

fn get_claims(&self) -> Result<Vec<Claim<F>>>

Generates and returns all claims that this layer makes onto previous layers.

impl<F> Serialize for RegularLayer<F>

where F: Field,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.