Nova · arnaucube's git mirror

[refactorings] Leftovers (pot-pourri?) (#184)

* test: compute_path

* refactor: path computation

- Improve path concatenation by utilizing built-in `join` method

* refactor: replace `PartialEq` with derived instance

- Derive `PartialEq` for `SatisfyingAssignment` struct
- Remove redundant manual implementation of `PartialEq`

Cargo-expand generates:
```
        #[automatically_derived]
        impl<G: ::core::cmp::PartialEq + Group> ::core::cmp::PartialEq
        for SatisfyingAssignment<G>
        where
            G::Scalar: PrimeField,
            G::Scalar: ::core::cmp::PartialEq,
            G::Scalar: ::core::cmp::PartialEq,
            G::Scalar: ::core::cmp::PartialEq,
            G::Scalar: ::core::cmp::PartialEq,
            G::Scalar: ::core::cmp::PartialEq,
        {
            #[inline]
            fn eq(&self, other: &SatisfyingAssignment<G>) -> bool {
                self.a_aux_density == other.a_aux_density
                    && self.b_input_density == other.b_input_density
                    && self.b_aux_density == other.b_aux_density && self.a == other.a
                    && self.b == other.b && self.c == other.c
                    && self.input_assignment == other.input_assignment
                    && self.aux_assignment == other.aux_assignment
            }
        }
```

* refactor: avoid default for PhantomData Unit type

* refactor: replace fold with sum where applicable

- Simplify code by replacing `fold` with `sum` in various instances

* refactor: decompression method in sumcheck.rs

* refactor: test functions to use slice instead of vector conversion

* refactor: use more references in functions

- Update parameter types to use references instead of owned values in various functions that do not need them
- Replace cloning instances with references

François Garillot 4142+huitseeker@users.noreply.github.com

Mon, 19 Jun 2023 19:11:42 -0400

commit

1e6bf942e215979b0e02d5b2b83a6c4450d740e1

parent

ff0370f50678a1d4fc2b9ca2da0fc2f8253ce356

15 files changed, 109 insertions(+), 123 deletions(-)

jump to

benches/compressed-snark.rs

benches/recursive-snark.rs

examples/signature.rs

src/bellperson/shape_cs.rs

src/bellperson/solver.rs

src/circuit.rs

src/gadgets/ecc.rs

src/gadgets/nonnative/bignat.rs

src/gadgets/r1cs.rs

src/gadgets/utils.rs

src/lib.rs

src/provider/poseidon.rs

src/spartan/mod.rs

src/spartan/pp.rs

src/spartan/sumcheck.rs

M benches/compressed-snark.rs → benches/compressed-snark.rs

@@ -90,8 +90,8 @@ // verify the recursive snark at each step of recursion
       let res = recursive_snark.verify(
         &pp,
         i + 1,
-        &vec![<G1 as Group>::Scalar::from(2u64)][..],
-        &vec![<G2 as Group>::Scalar::from(2u64)][..],
+        &[<G1 as Group>::Scalar::from(2u64)],
+        &[<G2 as Group>::Scalar::from(2u64)],
       );
       assert!(res.is_ok());
     }

M benches/recursive-snark.rs → benches/recursive-snark.rs

@@ -113,8 +113,8 @@ assert!(black_box(&recursive_snark)
           .verify(
             black_box(&pp),
             black_box(num_warmup_steps),
-            black_box(&vec![<G1 as Group>::Scalar::from(2u64)][..]),
-            black_box(&vec![<G2 as Group>::Scalar::from(2u64)][..]),
+            black_box(&[<G1 as Group>::Scalar::from(2u64)]),
+            black_box(&[<G2 as Group>::Scalar::from(2u64)]),
           )
           .is_ok());
       });

M examples/signature.rs → examples/signature.rs

@@ -233,8 +233,8 @@ |lc| lc + CS::one(),
     |lc| lc + (G::Base::from_str_vartime("2").unwrap(), CS::one()),
   );
 
-  let sg = g.scalar_mul(cs.namespace(|| "[s]G"), s_bits)?;
-  let cpk = pk.scalar_mul(&mut cs.namespace(|| "[c]PK"), c_bits)?;
+  let sg = g.scalar_mul(cs.namespace(|| "[s]G"), &s_bits)?;
+  let cpk = pk.scalar_mul(&mut cs.namespace(|| "[c]PK"), &c_bits)?;
   let rcpk = cpk.add(&mut cs.namespace(|| "R + [c]PK"), &r)?;
 
   let (rcpk_x, rcpk_y, _) = rcpk.get_coordinates();

M src/bellperson/shape_cs.rs → src/bellperson/shape_cs.rs

@@ -308,17 +308,36 @@ !this.chars().any(|a| a == '/'),
     "'/' is not allowed in names"
   );
 
-  let mut name = String::new();
+  let mut name = ns.join("/");
+  if !name.is_empty() {
+    name.push('/');
+  }
+
+  name.push_str(this);
+
+  name
+}
+
+#[cfg(test)]
+mod tests {
+  use super::*;
 
-  let mut needs_separation = false;
-  for ns in ns.iter().chain(Some(this.to_string()).iter()) {
-    if needs_separation {
-      name += "/";
-    }
+  #[test]
+  fn test_compute_path() {
+    let ns = vec!["path".to_string(), "to".to_string(), "dir".to_string()];
+    let this = "file";
+    assert_eq!(compute_path(&ns, this), "path/to/dir/file");
 
-    name += ns;
-    needs_separation = true;
+    let ns = vec!["".to_string(), "".to_string(), "".to_string()];
+    let this = "file";
+    assert_eq!(compute_path(&ns, this), "///file");
   }
 
-  name
+  #[test]
+  #[should_panic(expected = "'/' is not allowed in names")]
+  fn test_compute_path_invalid() {
+    let ns = vec!["path".to_string(), "to".to_string(), "dir".to_string()];
+    let this = "fi/le";
+    compute_path(&ns, this);
+  }
 }

M src/bellperson/solver.rs → src/bellperson/solver.rs

@@ -8,6 +8,7 @@ multiexp::DensityTracker, ConstraintSystem, Index, LinearCombination, SynthesisError, Variable,
 };
 
 /// A `ConstraintSystem` which calculates witness values for a concrete instance of an R1CS circuit.
+#[derive(PartialEq)]
 pub struct SatisfyingAssignment<G: Group>
 where
   G::Scalar: PrimeField,
@@ -65,22 +66,6 @@ )
       .field("input_assignment", &self.input_assignment)
       .field("aux_assignment", &self.aux_assignment)
       .finish()
-  }
-}
-
-impl<G: Group> PartialEq for SatisfyingAssignment<G>
-where
-  G::Scalar: PrimeField,
-{
-  fn eq(&self, other: &SatisfyingAssignment<G>) -> bool {
-    self.a_aux_density == other.a_aux_density
-      && self.b_input_density == other.b_input_density
-      && self.b_aux_density == other.b_aux_density
-      && self.a == other.a
-      && self.b == other.b
-      && self.c == other.c
-      && self.input_assignment == other.input_assignment
-      && self.aux_assignment == other.aux_assignment
   }
 }

M src/circuit.rs → src/circuit.rs

@@ -158,8 +158,8 @@
     // Allocate the running instance
     let U: AllocatedRelaxedR1CSInstance<G> = AllocatedRelaxedR1CSInstance::alloc(
       cs.namespace(|| "Allocate U"),
-      self.inputs.get().map_or(None, |inputs| {
-        inputs.U.get().map_or(None, |U| Some(U.clone()))
+      self.inputs.get().as_ref().map_or(None, |inputs| {
+        inputs.U.get().as_ref().map_or(None, |U| Some(U))
       }),
       self.params.limb_width,
       self.params.n_limbs,
@@ -168,8 +168,8 @@
     // Allocate the instance to be folded in
     let u = AllocatedR1CSInstance::alloc(
       cs.namespace(|| "allocate instance u to fold"),
-      self.inputs.get().map_or(None, |inputs| {
-        inputs.u.get().map_or(None, |u| Some(u.clone()))
+      self.inputs.get().as_ref().map_or(None, |inputs| {
+        inputs.u.get().as_ref().map_or(None, |u| Some(u))
       }),
     )?;
 
@@ -219,9 +219,9 @@ params: AllocatedNum<G::Base>,
     i: AllocatedNum<G::Base>,
     z_0: Vec<AllocatedNum<G::Base>>,
     z_i: Vec<AllocatedNum<G::Base>>,
-    U: AllocatedRelaxedR1CSInstance<G>,
-    u: AllocatedR1CSInstance<G>,
-    T: AllocatedPoint<G>,
+    U: &AllocatedRelaxedR1CSInstance<G>,
+    u: &AllocatedR1CSInstance<G>,
+    T: &AllocatedPoint<G>,
     arity: usize,
   ) -> Result<(AllocatedRelaxedR1CSInstance<G>, AllocatedBit), SynthesisError> {
     // Check that u.x[0] = Hash(params, U, i, z0, zi)
@@ -240,7 +240,7 @@ }
     U.absorb_in_ro(cs.namespace(|| "absorb U"), &mut ro)?;
 
     let hash_bits = ro.squeeze(cs.namespace(|| "Input hash"), NUM_HASH_BITS)?;
-    let hash = le_bits_to_num(cs.namespace(|| "bits to hash"), hash_bits)?;
+    let hash = le_bits_to_num(cs.namespace(|| "bits to hash"), &hash_bits)?;
     let check_pass = alloc_num_equals(
       cs.namespace(|| "check consistency of u.X[0] with H(params, U, i, z0, zi)"),
       &u.X0,
@@ -290,9 +290,9 @@ params.clone(),
       i.clone(),
       z_0.clone(),
       z_i.clone(),
-      U,
-      u.clone(),
-      T,
+      &U,
+      &u,
+      &T,
       arity,
     )?;
 
@@ -312,7 +312,7 @@
     // Compute the U_new
     let Unew = Unew_base.conditionally_select(
       cs.namespace(|| "compute U_new"),
-      Unew_non_base,
+      &Unew_non_base,
       &Boolean::from(is_base_case.clone()),
     )?;
 
@@ -357,7 +357,7 @@ ro.absorb(e);
     }
     Unew.absorb_in_ro(cs.namespace(|| "absorb U_new"), &mut ro)?;
     let hash_bits = ro.squeeze(cs.namespace(|| "output hash bits"), NUM_HASH_BITS)?;
-    let hash = le_bits_to_num(cs.namespace(|| "convert hash to num"), hash_bits)?;
+    let hash = le_bits_to_num(cs.namespace(|| "convert hash to num"), &hash_bits)?;
 
     // Outputs the computed hash and u.X[1] that corresponds to the hash of the other circuit
     u.X1

M src/gadgets/ecc.rs → src/gadgets/ecc.rs

@@ -429,7 +429,7 @@ /// except we use complete addition law over affine coordinates instead of projective coordinates for the tail bits
   pub fn scalar_mul<CS: ConstraintSystem<G::Base>>(
     &self,
     mut cs: CS,
-    scalar_bits: Vec<AllocatedBit>,
+    scalar_bits: &[AllocatedBit],
   ) -> Result<Self, SynthesisError> {
     let split_len = core::cmp::min(scalar_bits.len(), (G::Base::NUM_BITS - 2) as usize);
     let (incomplete_bits, complete_bits) = scalar_bits.split_at(split_len);
@@ -968,7 +968,7 @@ .enumerate()
       .map(|(i, bit)| AllocatedBit::alloc(cs.namespace(|| format!("bit {i}")), Some(bit)))
       .collect::<Result<Vec<AllocatedBit>, SynthesisError>>()
       .unwrap();
-    let e = a.scalar_mul(cs.namespace(|| "Scalar Mul"), bits).unwrap();
+    let e = a.scalar_mul(cs.namespace(|| "Scalar Mul"), &bits).unwrap();
     inputize_allocted_point(&e, cs.namespace(|| "inputize e")).unwrap();
     (a, e, s)
   }

M src/gadgets/nonnative/bignat.rs → src/gadgets/nonnative/bignat.rs

@@ -222,7 +222,7 @@ /// The `max_word` is gauranteed to be `(2 << limb_width) - 1`.
   /// The value is provided by an allocated number
   pub fn from_num<CS: ConstraintSystem<Scalar>>(
     mut cs: CS,
-    n: Num<Scalar>,
+    n: &Num<Scalar>,
     limb_width: usize,
     n_limbs: usize,
   ) -> Result<Self, SynthesisError> {

M src/gadgets/r1cs.rs → src/gadgets/r1cs.rs

@@ -33,7 +33,7 @@ impl<G: Group> AllocatedR1CSInstance<G> {
   /// Takes the r1cs instance and creates a new allocated r1cs instance
   pub fn alloc<CS: ConstraintSystem<<G as Group>::Base>>(
     mut cs: CS,
-    u: Option<R1CSInstance<G>>,
+    u: Option<&R1CSInstance<G>>,
   ) -> Result<Self, SynthesisError> {
     // Check that the incoming instance has exactly 2 io
     let W = AllocatedPoint::alloc(
@@ -76,7 +76,7 @@ impl<G: Group> AllocatedRelaxedR1CSInstance<G> {
   /// Allocates the given RelaxedR1CSInstance as a witness of the circuit
   pub fn alloc<CS: ConstraintSystem<<G as Group>::Base>>(
     mut cs: CS,
-    inst: Option<RelaxedR1CSInstance<G>>,
+    inst: Option<&RelaxedR1CSInstance<G>>,
     limb_width: usize,
     n_limbs: usize,
   ) -> Result<Self, SynthesisError> {
@@ -104,22 +104,14 @@
     // Allocate X0 and X1. If the input instance is None, then allocate default values 0.
     let X0 = BigNat::alloc_from_nat(
       cs.namespace(|| "allocate X[0]"),
-      || {
-        Ok(f_to_nat(
-          &inst.clone().map_or(G::Scalar::ZERO, |inst| inst.X[0]),
-        ))
-      },
+      || Ok(f_to_nat(&inst.map_or(G::Scalar::ZERO, |inst| inst.X[0]))),
       limb_width,
       n_limbs,
     )?;
 
     let X1 = BigNat::alloc_from_nat(
       cs.namespace(|| "allocate X[1]"),
-      || {
-        Ok(f_to_nat(
-          &inst.clone().map_or(G::Scalar::ZERO, |inst| inst.X[1]),
-        ))
-      },
+      || Ok(f_to_nat(&inst.map_or(G::Scalar::ZERO, |inst| inst.X[1]))),
       limb_width,
       n_limbs,
     )?;
@@ -170,14 +162,14 @@ let u = alloc_one(cs.namespace(|| "one"))?;
 
     let X0 = BigNat::from_num(
       cs.namespace(|| "allocate X0 from relaxed r1cs"),
-      Num::from(inst.X0.clone()),
+      &Num::from(inst.X0),
       limb_width,
       n_limbs,
     )?;
 
     let X1 = BigNat::from_num(
       cs.namespace(|| "allocate X1 from relaxed r1cs"),
-      Num::from(inst.X1.clone()),
+      &Num::from(inst.X1),
       limb_width,
       n_limbs,
     )?;
@@ -246,8 +238,8 @@ pub fn fold_with_r1cs<CS: ConstraintSystem<<G as Group>::Base>>(
     &self,
     mut cs: CS,
     params: AllocatedNum<G::Base>, // hash of R1CSShape of F'
-    u: AllocatedR1CSInstance<G>,
-    T: AllocatedPoint<G>,
+    u: &AllocatedR1CSInstance<G>,
+    T: &AllocatedPoint<G>,
     ro_consts: ROConstantsCircuit<G>,
     limb_width: usize,
     n_limbs: usize,
@@ -261,14 +253,14 @@ ro.absorb(T.x.clone());
     ro.absorb(T.y.clone());
     ro.absorb(T.is_infinity.clone());
     let r_bits = ro.squeeze(cs.namespace(|| "r bits"), NUM_CHALLENGE_BITS)?;
-    let r = le_bits_to_num(cs.namespace(|| "r"), r_bits.clone())?;
+    let r = le_bits_to_num(cs.namespace(|| "r"), &r_bits)?;
 
     // W_fold = self.W + r * u.W
-    let rW = u.W.scalar_mul(cs.namespace(|| "r * u.W"), r_bits.clone())?;
+    let rW = u.W.scalar_mul(cs.namespace(|| "r * u.W"), &r_bits)?;
     let W_fold = self.W.add(cs.namespace(|| "self.W + r * u.W"), &rW)?;
 
     // E_fold = self.E + r * T
-    let rT = T.scalar_mul(cs.namespace(|| "r * T"), r_bits)?;
+    let rT = T.scalar_mul(cs.namespace(|| "r * T"), &r_bits)?;
     let E_fold = self.E.add(cs.namespace(|| "self.E + r * T"), &rT)?;
 
     // u_fold = u_r + r
@@ -286,7 +278,7 @@ // Fold the IO:
     // Analyze r into limbs
     let r_bn = BigNat::from_num(
       cs.namespace(|| "allocate r_bn"),
-      Num::from(r.clone()),
+      &Num::from(r),
       limb_width,
       n_limbs,
     )?;
@@ -302,7 +294,7 @@
     // Analyze X0 to bignat
     let X0_bn = BigNat::from_num(
       cs.namespace(|| "allocate X0_bn"),
-      Num::from(u.X0.clone()),
+      &Num::from(u.X0.clone()),
       limb_width,
       n_limbs,
     )?;
@@ -317,7 +309,7 @@
     // Analyze X1 to bignat
     let X1_bn = BigNat::from_num(
       cs.namespace(|| "allocate X1_bn"),
-      Num::from(u.X1.clone()),
+      &Num::from(u.X1.clone()),
       limb_width,
       n_limbs,
     )?;
@@ -342,7 +334,7 @@ /// If the condition is true then returns this otherwise it returns the other
   pub fn conditionally_select<CS: ConstraintSystem<<G as Group>::Base>>(
     &self,
     mut cs: CS,
-    other: AllocatedRelaxedR1CSInstance<G>,
+    other: &AllocatedRelaxedR1CSInstance<G>,
     condition: &Boolean,
   ) -> Result<AllocatedRelaxedR1CSInstance<G>, SynthesisError> {
     let W = AllocatedPoint::conditionally_select(

M src/gadgets/utils.rs → src/gadgets/utils.rs

@@ -15,7 +15,7 @@
 /// Gets as input the little indian representation of a number and spits out the number
 pub fn le_bits_to_num<Scalar, CS>(
   mut cs: CS,
-  bits: Vec<AllocatedBit>,
+  bits: &[AllocatedBit],
 ) -> Result<AllocatedNum<Scalar>, SynthesisError>
 where
   Scalar: PrimeField + PrimeFieldBits,

M src/lib.rs → src/lib.rs

@@ -938,8 +938,8 @@ // verify the recursive SNARK
     let res = recursive_snark.verify(
       &pp,
       num_steps,
-      &vec![<G1 as Group>::Scalar::ZERO][..],
-      &vec![<G2 as Group>::Scalar::ZERO][..],
+      &[<G1 as Group>::Scalar::ZERO],
+      &[<G2 as Group>::Scalar::ZERO],
     );
     assert!(res.is_ok());
   }
@@ -997,8 +997,8 @@ // verify the recursive snark at each step of recursion
       let res = recursive_snark.verify(
         &pp,
         i + 1,
-        &vec![<G1 as Group>::Scalar::ONE][..],
-        &vec![<G2 as Group>::Scalar::ZERO][..],
+        &[<G1 as Group>::Scalar::ONE],
+        &[<G2 as Group>::Scalar::ZERO],
       );
       assert!(res.is_ok());
     }
@@ -1007,8 +1007,8 @@ // verify the recursive SNARK
     let res = recursive_snark.verify(
       &pp,
       num_steps,
-      &vec![<G1 as Group>::Scalar::ONE][..],
-      &vec![<G2 as Group>::Scalar::ZERO][..],
+      &[<G1 as Group>::Scalar::ONE],
+      &[<G2 as Group>::Scalar::ZERO],
     );
     assert!(res.is_ok());
 
@@ -1084,8 +1084,8 @@ // verify the recursive SNARK
     let res = recursive_snark.verify(
       &pp,
       num_steps,
-      &vec![<G1 as Group>::Scalar::ONE][..],
-      &vec![<G2 as Group>::Scalar::ZERO][..],
+      &[<G1 as Group>::Scalar::ONE],
+      &[<G2 as Group>::Scalar::ZERO],
     );
     assert!(res.is_ok());
 
@@ -1178,8 +1178,8 @@ // verify the recursive SNARK
     let res = recursive_snark.verify(
       &pp,
       num_steps,
-      &vec![<G1 as Group>::Scalar::ONE][..],
-      &vec![<G2 as Group>::Scalar::ZERO][..],
+      &[<G1 as Group>::Scalar::ONE],
+      &[<G2 as Group>::Scalar::ZERO],
     );
     assert!(res.is_ok());
 
@@ -1426,8 +1426,8 @@ // verify the recursive SNARK
     let res = recursive_snark.verify(
       &pp,
       num_steps,
-      &vec![<G1 as Group>::Scalar::ONE][..],
-      &vec![<G2 as Group>::Scalar::ZERO][..],
+      &[<G1 as Group>::Scalar::ONE],
+      &[<G2 as Group>::Scalar::ZERO],
     );
     assert!(res.is_ok());

M src/provider/poseidon.rs → src/provider/poseidon.rs

@@ -65,7 +65,7 @@ state: Vec::new(),
       constants,
       num_absorbs,
       squeezed: false,
-      _p: PhantomData::default(),
+      _p: PhantomData,
     }
   }
 
@@ -236,7 +236,7 @@ ro_gadget.absorb(num_gadget);
     }
     let num = ro.squeeze(NUM_CHALLENGE_BITS);
     let num2_bits = ro_gadget.squeeze(&mut cs, NUM_CHALLENGE_BITS).unwrap();
-    let num2 = le_bits_to_num(&mut cs, num2_bits).unwrap();
+    let num2 = le_bits_to_num(&mut cs, &num2_bits).unwrap();
     assert_eq!(num.to_repr(), num2.get_value().unwrap().to_repr());
   }

M src/spartan/mod.rs → src/spartan/mod.rs

@@ -109,7 +109,7 @@ let e = e_vec
       .iter()
       .zip(powers_of_s.iter())
       .map(|(e, p)| *e * p)
-      .fold(G::Scalar::ZERO, |acc, item| acc + item);
+      .sum();
     let c = c_vec
       .iter()
       .zip(powers_of_s.iter())
@@ -378,7 +378,7 @@ let claim_batch_joint = u_vec_padded
       .iter()
       .zip(powers_of_rho.iter())
       .map(|(u, p)| u.e * p)
-      .fold(G::Scalar::ZERO, |acc, item| acc + item);
+      .sum();
 
     let mut polys_left: Vec<MultilinearPolynomial<G::Scalar>> = w_vec_padded
       .iter()
@@ -420,7 +420,7 @@ let eval_joint = claims_batch_left
       .iter()
       .zip(powers_of_gamma.iter())
       .map(|(e, g_i)| *e * *g_i)
-      .fold(G::Scalar::ZERO, |acc, item| acc + item);
+      .sum();
 
     let eval_arg = EE::prove(
       ck,
@@ -573,7 +573,7 @@ let claim_batch_joint = u_vec
       .iter()
       .zip(powers_of_rho.iter())
       .map(|(u, p)| u.e * p)
-      .fold(G::Scalar::ZERO, |acc, item| acc + item);
+      .sum();
 
     let num_rounds_z = u_vec_padded[0].x.len();
     let (claim_batch_final, r_z) =
@@ -593,7 +593,7 @@ .iter()
         .zip(self.evals_batch.iter())
         .zip(powers_of_rho.iter())
         .map(|((e_i, p_i), rho_i)| *e_i * *p_i * rho_i)
-        .fold(G::Scalar::ZERO, |acc, item| acc + item)
+        .sum()
     };
 
     if claim_batch_final != claim_batch_final_expected {
@@ -615,7 +615,7 @@ .evals_batch
       .iter()
       .zip(powers_of_gamma.iter())
       .map(|(e, g_i)| *e * *g_i)
-      .fold(G::Scalar::ZERO, |acc, item| acc + item);
+      .sum();
 
     // verify
     EE::verify(

M src/spartan/pp.rs → src/spartan/pp.rs

@@ -863,7 +863,7 @@ let claim = claims
       .iter()
       .zip(coeffs.iter())
       .map(|(c_1, c_2)| *c_1 * c_2)
-      .fold(G::Scalar::ZERO, |acc, item| acc + item);
+      .sum();
 
     let mut e = claim;
     let mut r: Vec<G::Scalar> = Vec::new();
@@ -876,15 +876,9 @@ evals.extend(outer.evaluation_points());
       evals.extend(inner.evaluation_points());
       assert_eq!(evals.len(), num_claims);
 
-      let evals_combined_0 = (0..evals.len())
-        .map(|i| evals[i][0] * coeffs[i])
-        .fold(G::Scalar::ZERO, |acc, item| acc + item);
-      let evals_combined_2 = (0..evals.len())
-        .map(|i| evals[i][1] * coeffs[i])
-        .fold(G::Scalar::ZERO, |acc, item| acc + item);
-      let evals_combined_3 = (0..evals.len())
-        .map(|i| evals[i][2] * coeffs[i])
-        .fold(G::Scalar::ZERO, |acc, item| acc + item);
+      let evals_combined_0 = (0..evals.len()).map(|i| evals[i][0] * coeffs[i]).sum();
+      let evals_combined_2 = (0..evals.len()).map(|i| evals[i][1] * coeffs[i]).sum();
+      let evals_combined_3 = (0..evals.len()).map(|i| evals[i][2] * coeffs[i]).sum();
 
       let evals = vec![
         evals_combined_0,
@@ -1242,13 +1236,13 @@ .claims
       .iter()
       .zip(powers_of_rho.iter())
       .map(|(e, p)| *e * p)
-      .fold(G::Scalar::ZERO, |acc, item| acc + item);
+      .sum();
 
     let eval_output = eval_output_vec
       .iter()
       .zip(powers_of_rho.iter())
       .map(|(e, p)| *e * p)
-      .fold(G::Scalar::ZERO, |acc, item| acc + item);
+      .sum();
 
     let comm_output = mem_sc_inst
       .comm_output_vec
@@ -1274,7 +1268,7 @@ let eval_output2 = eval_output2_vec
       .iter()
       .zip(powers_of_rho.iter())
       .map(|(e, p)| *e * p)
-      .fold(G::Scalar::ZERO, |acc, item| acc + item);
+      .sum();
 
     // eval_output = output(r_sat)
     w_u_vec.push((
@@ -1466,7 +1460,7 @@ let claim_batch_joint = u_vec_padded
       .iter()
       .zip(powers_of_rho.iter())
       .map(|(u, p)| u.e * p)
-      .fold(G::Scalar::ZERO, |acc, item| acc + item);
+      .sum();
 
     let mut polys_left: Vec<MultilinearPolynomial<G::Scalar>> = w_vec_padded
       .iter()
@@ -1508,7 +1502,7 @@ let eval_joint = claims_batch_left
       .iter()
       .zip(powers_of_gamma.iter())
       .map(|(e, g_i)| *e * *g_i)
-      .fold(G::Scalar::ZERO, |acc, item| acc + item);
+      .sum();
 
     let eval_arg = EE::prove(
       ck,
@@ -1677,13 +1671,13 @@
     // verify claim_sat_final
     let taus_bound_r_sat = EqPolynomial::new(tau.clone()).evaluate(&r_sat);
     let rand_eq_bound_r_sat = EqPolynomial::new(rand_eq).evaluate(&r_sat);
-    let claim_mem_final_expected = (0..8)
+    let claim_mem_final_expected: G::Scalar = (0..8)
       .map(|i| {
         coeffs[i]
           * rand_eq_bound_r_sat
           * (self.eval_left_arr[i] * self.eval_right_arr[i] - self.eval_output_arr[i])
       })
-      .fold(G::Scalar::ZERO, |acc, item| acc + item);
+      .sum();
     let claim_outer_final_expected = coeffs[8]
       * taus_bound_r_sat
       * (self.eval_Az * self.eval_Bz - U.u * self.eval_Cz - self.eval_E);
@@ -1753,14 +1747,14 @@ .claims_product_arr
       .iter()
       .zip(powers_of_rho.iter())
       .map(|(e, p)| *e * p)
-      .fold(G::Scalar::ZERO, |acc, item| acc + item);
+      .sum();
 
     let eval_output = self
       .eval_output_arr
       .iter()
       .zip(powers_of_rho.iter())
       .map(|(e, p)| *e * p)
-      .fold(G::Scalar::ZERO, |acc, item| acc + item);
+      .sum();
 
     let comm_output = comm_output_vec
       .iter()
@@ -1773,7 +1767,7 @@ .eval_output2_arr
       .iter()
       .zip(powers_of_rho.iter())
       .map(|(e, p)| *e * p)
-      .fold(G::Scalar::ZERO, |acc, item| acc + item);
+      .sum();
 
     // eval_output = output(r_sat)
     u_vec.push(PolyEvalInstance {
@@ -1994,7 +1988,7 @@ let claim_batch_joint = u_vec_padded
       .iter()
       .zip(powers_of_rho.iter())
       .map(|(u, p)| u.e * p)
-      .fold(G::Scalar::ZERO, |acc, item| acc + item);
+      .sum();
 
     let num_rounds_z = u_vec_padded[0].x.len();
     let (claim_batch_final, r_z) =
@@ -2014,7 +2008,7 @@ .iter()
         .zip(self.evals_batch_arr.iter())
         .zip(powers_of_rho.iter())
         .map(|((e_i, p_i), rho_i)| *e_i * *p_i * rho_i)
-        .fold(G::Scalar::ZERO, |acc, item| acc + item)
+        .sum()
     };
 
     if claim_batch_final != claim_batch_final_expected {
@@ -2036,7 +2030,7 @@ .evals_batch_arr
       .iter()
       .zip(powers_of_gamma.iter())
       .map(|(e, g_i)| *e * *g_i)
-      .fold(G::Scalar::ZERO, |acc, item| acc + item);
+      .sum();
 
     // verify
     EE::verify(

M src/spartan/sumcheck.rs → src/spartan/sumcheck.rs

@@ -163,12 +163,8 @@
         evals.push((eval_point_0, eval_point_2));
       }
 
-      let evals_combined_0 = (0..evals.len())
-        .map(|i| evals[i].0 * coeffs[i])
-        .fold(G::Scalar::ZERO, |acc, item| acc + item);
-      let evals_combined_2 = (0..evals.len())
-        .map(|i| evals[i].1 * coeffs[i])
-        .fold(G::Scalar::ZERO, |acc, item| acc + item);
+      let evals_combined_0 = (0..evals.len()).map(|i| evals[i].0 * coeffs[i]).sum();
+      let evals_combined_2 = (0..evals.len()).map(|i| evals[i].1 * coeffs[i]).sum();
 
       let evals = vec![evals_combined_0, e - evals_combined_0, evals_combined_2];
       let poly = UniPoly::from_evals(&evals);
@@ -387,9 +383,9 @@ linear_term -= self.coeffs_except_linear_term[i];
     }
 
     let mut coeffs: Vec<G::Scalar> = Vec::new();
-    coeffs.extend(vec![&self.coeffs_except_linear_term[0]]);
-    coeffs.extend(vec![&linear_term]);
-    coeffs.extend(self.coeffs_except_linear_term[1..].to_vec());
+    coeffs.push(self.coeffs_except_linear_term[0]);
+    coeffs.push(linear_term);
+    coeffs.extend(&self.coeffs_except_linear_term[1..]);
     assert_eq!(self.coeffs_except_linear_term.len() + 1, coeffs.len());
     UniPoly { coeffs }
   }