remove clone term_1 and term_2

Author: nicole-graus

crates/provers/gkr/src/prover.rs

@@ -53,8 +53,10 @@ impl Prover {
     ///
     /// See our blog post: <https://blog.lambdaclass.com/gkr-protocol-a-step-by-step-example/>
     ///
-    /// This function is only known to the prover. It returns the components of `f` grouped
-    /// into two terms, ready to be used by the sumcheck prover, which expects a product of multilinear polynomials.
+    /// This function is only known to the prover.
+    ///
+    /// It returns the components of `f` grouped into two terms, ready to be used by the sumcheck prover, which expects
+    /// a product of multilinear polynomials.
     /// Both terms are the product of two multilinear polynomials.
     /// The first term is  `add_i(r_i, b, c) * (W_{i+1}(b) + W_{i+1}(c))`.
     /// And the second term is `mul_i(r_i, b, c) * (W_{i+1}(b) * W_{i+1}(c))`.
@@ -63,7 +65,13 @@ impl Prover {
         r_i: &[FieldElement<F>],
         w_next_evals: &[FieldElement<F>],
         layer_idx: usize,
-    ) -> Result<Vec<Vec<DenseMultilinearPolynomial<F>>>, ProverError>
+    ) -> Result<
+        (
+            Vec<DenseMultilinearPolynomial<F>>,
+            Vec<DenseMultilinearPolynomial<F>>,
+        ),
+        ProverError,
+    >
     where
         <F as IsField>::BaseType: Send + Sync + Copy,
     {
@@ -98,7 +106,7 @@ impl Prover {
         // Corresponds to mul_i(r_i,b,c) * W_{i+1}(b) * W_{i+1}(c)
         let term2 = vec![mul_i_ext, w_mul_ext];
 
-        Ok(vec![term1, term2])
+        Ok((term1, term2))
     }
 
     /// Given `b` and `c` (challenges for the input of the gates),
@@ -179,10 +187,10 @@ impl Prover {
             let w_next_evals = &evaluation.layers[layer_idx + 1];
 
             // Build the GKR polynomial terms
-            let gkr_poly_terms =
+            let (term_1, term_2) =
                 Prover::build_gkr_polynomial(circuit, &r_i, w_next_evals, layer_idx)?;
 
-            let sumcheck_proof = gkr_sumcheck_prove(gkr_poly_terms, &mut transcript)?;
+            let sumcheck_proof = gkr_sumcheck_prove(term_1, term_2, &mut transcript)?;
 
             let sumcheck_challenges = &sumcheck_proof.challenges;
 

crates/provers/gkr/src/sumcheck.rs

@@ -19,11 +19,12 @@ pub struct GKRSumcheckProof<F: IsField> {
 }
 
 /// GKR-specific sumcheck prover.
-/// This function will recieve a vector of two terms. Each term contains two multilinear polynomials.
+/// This function will recieves two terms. Each term contains two multilinear polynomials.
 /// This separation of terms is necessary because the classic/original sumcheck only accepts a product of multilinear polynomials.
-/// In this way, we apply the sumcheck to two products, each consisting of two factors.
+/// In this way, we apply the sumcheck to two terms, each consisting of two factors.
 pub fn gkr_sumcheck_prove<F, T>(
-    terms: Vec<Vec<DenseMultilinearPolynomial<F>>>,
+    term_1: Vec<DenseMultilinearPolynomial<F>>,
+    term_2: Vec<DenseMultilinearPolynomial<F>>,
     transcript: &mut T,
 ) -> Result<GKRSumcheckProof<F>, ProverError>
 where
@@ -32,16 +33,9 @@ where
     FieldElement<F>: ByteConversion,
     T: IsTranscript<F> + Channel<F>,
 {
-    if terms.len() != 2 {
-        return Err(ProverError::SumcheckError);
-    }
-
-    let factors_term_1 = terms[0].clone();
-    let factors_term_2 = terms[1].clone();
-
     // Create two separate sumcheck provers for each term.
-    let mut prover_term_1 = Prover::new(factors_term_1).map_err(|_| ProverError::SumcheckError)?;
-    let mut prover_term_2 = Prover::new(factors_term_2).map_err(|_| ProverError::SumcheckError)?;
+    let mut prover_term_1 = Prover::new(term_1).map_err(|_| ProverError::SumcheckError)?;
+    let mut prover_term_2 = Prover::new(term_2).map_err(|_| ProverError::SumcheckError)?;
 
     // Both terms have the same number of variables.
     let num_vars = prover_term_1.num_vars();