Refactor checking slightly for multithreading.

src/spairs.rs

@@ -388,23 +388,19 @@ where Group1: Pairing<Group2> {
     a.f.pairing(b.fs) == a.fs.pairing(b.f)
 }
 
-/// This performs a check to see if a large number of (p,q) pairs in G
+pub fn checkvec<R: Rng, Group1: Group, Group2: Group>(
-/// have the same power, with only one pairing.
+    rng: &mut R, v1: &[Group1], v2: &[Group1], a: &Spair<Group2>
-pub fn check<'a,
+) -> bool
-         R: Rng,
-         Group1: Group,
-         Group2: Group,
-         I: IntoIterator<Item=(&'a Group1, &'a Group1)>>
-         (rng: &mut R, i: I, a: &Spair<Group2>) -> bool
 where Group1: Pairing<Group2>
 {
+    assert!(v1.len() == v2.len());
     let mut p = Group1::zero();
     let mut q = Group1::zero();
 
-    for v in i {
+    for i in v1.iter().zip(v2.iter()) {
         let alpha = Fr::random(rng);
-        p = p + *v.0 * alpha;
+        p = p + *i.0 * alpha;
-        q = q + *v.1 * alpha;
+        q = q + *i.1 * alpha;
     }
 
     if p.is_zero() || q.is_zero() { return false; }
@@ -412,15 +408,12 @@ where Group1: Pairing<Group2>
     same_power(&Spair::new(p, q).unwrap(), &a)
 }
 
-pub fn checkseq<'a,
+pub fn checkseq<R: Rng, Group1: Group, Group2: Group>(
-            R: Rng,
+    rng: &mut R, v: &[Group1], a: &Spair<Group2>
-            Group1: Group,
+) -> bool
-            Group2: Group,
-            I: Iterator<Item=&'a Group1>>
-            (rng: &mut R, i: I, a: &Spair<Group2>) -> bool
 where Group1: Pairing<Group2>
 {
-    check(rng, Sequences::new(i), a)
+    checkvec(rng, &v[0..v.len()-1], &v[1..], a)
 }
 
 #[test]
@@ -458,7 +451,7 @@ fn samepower_seq() {
                 a.push(n);
             }
 
-            assert!(checkseq(rng, a.iter(), &p));
+            assert!(checkseq(rng, &a, &p));
         }
 
         // Test not working.
@@ -478,7 +471,7 @@ fn samepower_seq() {
                 }
             }
 
-            assert!(!checkseq(rng, a.iter(), &p));
+            assert!(!checkseq(rng, &a, &p));
         }
     }
 

src/transcript.rs

@@ -111,9 +111,9 @@ impl<'a, R: Rng> Transcript<'a, R, PowersOfTau> {
                 &spairs.tau
             ) &&
             // Check that all G1 elements are exponentiated the same as G2 elements
-            checkseq(&mut self.rng, g1.iter(), &Spair::new(g2[0], g2[1]).unwrap()) &&
+            checkseq(&mut self.rng, &g1, &Spair::new(g2[0], g2[1]).unwrap()) &&
             // Check that all G2 elements are exponentiated the same as G1 elements
-            checkseq(&mut self.rng, g2.iter(), &Spair::new(g1[0], g1[1]).unwrap())
+            checkseq(&mut self.rng, &g2, &Spair::new(g1[0], g1[1]).unwrap())
         {
             self.meta.prev_g1 = g1;
             self.meta.prev_g2 = g2;
@@ -197,39 +197,46 @@ impl<'a, R: Rng> Transcript<'a, R, RandomCoeffStage1> {
                 &self.meta.spairs[self.meta.curplayer].pApB
             ) ||
             // Check parts of the proving key
-            !check(
+            !checkvec(
                 &mut self.rng,
-                self.meta.values.pk_a.iter().zip(new_values.pk_a.iter()),
+                &self.meta.values.pk_a,
+                &new_values.pk_a,
                 &self.meta.spairs[self.meta.curplayer].rho_a()
             ) ||
-            !check(
+            !checkvec(
                 &mut self.rng,
-                self.meta.values.pk_a_prime.iter().zip(new_values.pk_a_prime.iter()),
+                &self.meta.values.pk_a_prime,
+                &new_values.pk_a_prime,
                 &self.meta.spairs[self.meta.curplayer].alpha_a_rho_a()
             ) ||
-            !check(
+            !checkvec(
                 &mut self.rng,
-                self.meta.values.pk_b.iter().zip(new_values.pk_b.iter()),
+                &self.meta.values.pk_b,
+                &new_values.pk_b,
                 &self.meta.spairs[self.meta.curplayer].pB
             ) ||
-            !check(
+            !checkvec(
                 &mut self.rng,
-                self.meta.values.pk_b_temp.iter().zip(new_values.pk_b_temp.iter()),
+                &self.meta.values.pk_b_temp,
+                &new_values.pk_b_temp,
                 &self.meta.spairs[self.meta.curplayer].rho_b()
             ) ||
-            !check(
+            !checkvec(
                 &mut self.rng,
-                self.meta.values.pk_b_prime.iter().zip(new_values.pk_b_prime.iter()),
+                &self.meta.values.pk_b_prime,
+                &new_values.pk_b_prime,
                 &self.meta.spairs[self.meta.curplayer].alpha_b_rho_b()
             ) ||
-            !check(
+            !checkvec(
                 &mut self.rng,
-                self.meta.values.pk_c.iter().zip(new_values.pk_c.iter()),
+                &self.meta.values.pk_c,
+                &new_values.pk_c,
                 &self.meta.spairs[self.meta.curplayer].rho_a_rho_b()
             ) ||
-            !check(
+            !checkvec(
                 &mut self.rng,
-                self.meta.values.pk_c_prime.iter().zip(new_values.pk_c_prime.iter()),
+                &self.meta.values.pk_c_prime,
+                &new_values.pk_c_prime,
                 &self.meta.spairs[self.meta.curplayer].alpha_c_rho_a_rho_b()
             )
         {
@@ -303,9 +310,10 @@ impl<'a, R: Rng> Transcript<'a, R, RandomCoeffStage2> {
                 &Spair::new(self.meta.values.vk_beta_gamma_two, new_values.vk_beta_gamma_two).unwrap(),
                 &Spair::new(self.meta.values.vk_beta_gamma_one, new_values.vk_beta_gamma_one).unwrap()
             ) ||
-            !check(
+            !checkvec(
                 &mut self.rng,
-                self.meta.values.pk_k.iter().zip(new_values.pk_k.iter()),
+                &self.meta.values.pk_k,
+                &new_values.pk_k,
                 &self.meta.spairs[self.meta.curplayer].beta()
             )
         {