remove: Unused CommitmentKeys passed to some fn

src/ccs/cccs.rs

@@ -105,7 +105,6 @@ impl<G: Group> CCCS<G> {
     &self,
     ccs: &CCS<G>,
     ccs_mles: &[MultilinearPolynomial<G::Scalar>],
-    ck: &CommitmentKey<G>,
     beta: &[G::Scalar],
   ) -> Result<VirtualPolynomial<G::Scalar>, NovaError> {
     let q = self.compute_q(ccs, ccs_mles)?;
@@ -205,7 +204,7 @@ mod tests {
     let beta: Vec<G::Scalar> = (0..ccs.s).map(|_| G::Scalar::random(&mut rng)).collect();
     // Compute Q(x) = eq(beta, x) * q(x).
     let Q = cccs
-      .compute_Q(&ccs, &mles, &ck, &beta)
+      .compute_Q(&ccs, &mles, &beta)
       .expect("Computation of Q should not fail");
 
     // Let's consider the multilinear polynomial G(x) = \sum_{y \in {0, 1}^s} eq(x, y) q(y)
@@ -247,7 +246,7 @@ mod tests {
 
     for d in BooleanHypercube::new(ccs.s) {
       let Q_at_d = cccs
-        .compute_Q(&ccs, &mles, &ck, &d)
+        .compute_Q(&ccs, &mles, &d)
         .expect("Computing Q_at_d shouldn't fail");
 
       // Get G(d) by summing over Q_d(x) over the hypercube
@@ -260,7 +259,7 @@ mod tests {
     // Now test that they should disagree outside of the hypercube
     let r: Vec<G::Scalar> = (0..ccs.s).map(|_| G::Scalar::random(&mut rng)).collect();
     let Q_at_r = cccs
-      .compute_Q(&ccs, &mles, &ck, &r)
+      .compute_Q(&ccs, &mles, &r)
       .expect("Computing Q_at_r shouldn't fail");
 
     // Get G(d) by summing over Q_d(x) over the hypercube

src/ccs/lcccs.rs

@@ -92,7 +92,6 @@ impl<G: Group> LCCCS<G> {
     &self,
     ccs: &CCS<G>,
     ccs_m_mle: &[MultilinearPolynomial<G::Scalar>],
-    ck: &CommitmentKey<G>,
   ) -> Vec<VirtualPolynomial<G::Scalar>> {
     let z_mle = dense_vec_to_mle(ccs.s_prime, self.z.as_slice());
 
@@ -149,7 +148,7 @@ mod tests {
     // Get LCCCS
     let lcccs = LCCCS::new(&ccs, &mles, &ck, z, &mut OsRng);
 
-    let vec_L_j_x = lcccs.compute_Ls(&ccs, &mles, &ck);
+    let vec_L_j_x = lcccs.compute_Ls(&ccs, &mles);
     assert_eq!(vec_L_j_x.len(), lcccs.v.len());
 
     for (v_i, L_j_x) in lcccs.v.into_iter().zip(vec_L_j_x) {
@@ -179,7 +178,7 @@ mod tests {
 
     // Compute L_j(x) with the bad z
     lcccs.z = bad_z;
-    let vec_L_j_x = lcccs.compute_Ls(&ccs, &mles, &ck);
+    let vec_L_j_x = lcccs.compute_Ls(&ccs, &mles);
     assert_eq!(vec_L_j_x.len(), lcccs.v.len());
     // Assert LCCCS is not satisfied with the bad Z
     assert!(lcccs.is_sat(&ccs, &mles, &ck).is_err());

src/ccs/multifolding.rs

@@ -152,10 +152,10 @@ impl<G: Group> NIMFS<G> {
     gamma: G::Scalar,
     beta: &[G::Scalar],
   ) -> VirtualPolynomial<G::Scalar> {
-    let mut vec_L = self.lcccs.compute_Ls(&self.ccs, &self.ccs_mle, &self.ck);
+    let mut vec_L = self.lcccs.compute_Ls(&self.ccs, &self.ccs_mle);
 
     let mut Q = cccs_instance
-      .compute_Q(&self.ccs, &self.ccs_mle, &self.ck, beta)
+      .compute_Q(&self.ccs, &self.ccs_mle, beta)
       .expect("Q comp should not fail");
 
     let mut g = vec_L[0].clone();
@@ -270,7 +270,7 @@ mod tests {
 
     // evaluate sum_{j \in [t]} (gamma^j * Lj(x)) over x \in {0,1}^s
     let mut sum_Lj_on_bhc = G::Scalar::ZERO;
-    let vec_L = lcccs.compute_Ls(&ccs, &mles, &ck);
+    let vec_L = lcccs.compute_Ls(&ccs, &mles);
     for x in BooleanHypercube::new(ccs.s) {
       for (j, coeff) in vec_L.iter().enumerate() {
         let gamma_j = gamma.pow([j as u64]);
@@ -324,7 +324,7 @@ mod tests {
       }
       // evaluate sum_{j \in [t]} (gamma^j * Lj(x)) over x \in {0,1}^s
       let mut sum_Lj_on_bhc = G::Scalar::ZERO;
-      let vec_L = nimfs.lcccs.compute_Ls(&ccs, &mles, &ck);
+      let vec_L = nimfs.lcccs.compute_Ls(&ccs, &mles);
       for x in BooleanHypercube::new(ccs.s) {
         for (j, coeff) in vec_L.iter().enumerate() {
           let gamma_j = gamma.pow([j as u64]);