Struct MatMult 

pub struct MatMult<F: Field> {
    layer_id: LayerId,
    matrix_a: Matrix<F>,
    matrix_b: Matrix<F>,
    num_vars_middle_ab: usize,
}

Used to represent a matrix multiplication layer.

#Attributes:

• layer_id - the LayerId of this MatMult layer.
• matrix_a - the lefthand side matrix in the multiplication.
• matrix_b - the righthand side matrix in the multiplication.

Fields

layer_id: LayerId

matrix_a: Matrix<F>

matrix_b: Matrix<F>

num_vars_middle_ab: usize

Implementations

impl<F: Field> MatMult<F>

pub fn new( layer_id: LayerId, matrix_a: Matrix<F>, matrix_b: Matrix<F>, ) -> MatMult<F>

Create a new matrix multiplication layer.

fn pre_processing_step(&mut self, claim_a: Vec<F>, claim_b: Vec<F>)

The step, according to Tha13, which makes the matmult algorithm super-efficient.

Given the claim on the output of the matrix multiplication, we bind the variables representing the “rows” of matrix_a to the first log(num_rows_a) vars in this claim, and we bind the variables representing the “columns” of matrix_b to the last log(num_cols_b) vars in the claim.

#Arguments

• claim_a: the first log_num_rows variables of the claim made on the MLE representing the output of this layer.
• claim_b: the last log_num_cols variables of the claim made on the MLE representing the output of this layer.

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

Trait Implementations

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

fn clone(&self) -> MatMult<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 MatMult<F>

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

Formats the value using the given formatter.

impl<'de, F> Deserialize<'de> for MatMult<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<MatMult<F>> for LayerEnum<F>

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

Converts to this type from the input type.

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

fn get_post_sumcheck_layer( &self, _round_challenges: &[F], _claim_challenges: &[&[F]], _random_coefficients: &[F], ) -> PostSumcheckLayer<F, F>

Return the PostSumcheckLayer, panicking if either of the MLE refs is not fully bound. Relevant for the Hyrax IP, where we need commitments to fully bound MLEs as well as their intermediate products.

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

Get the claims that this layer makes on other layers

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 layer_id(&self) -> LayerId

Gets this layer’s ID.

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

Initialize this layer and perform any necessary pre-computation: beta table, number of rounds, etc.

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 sumcheck_round_indices(&self) -> Vec<usize>

The list of sumcheck rounds this layer will prove, by index.

fn max_degree(&self) -> usize

The maximum degree for any univariate in the sumcheck protocol.

impl<F> Serialize for MatMult<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.