merge non-native name change

Author: npwardberkeley

Cargo.toml

@@ -27,14 +27,15 @@ ark-ec = { git = "https://github.com/arkworks-rs/algebra", default-features = fa
 ark-poly = { git = "https://github.com/arkworks-rs/algebra", default-features = false }
 
 ark-std = { git = "https://github.com/arkworks-rs/utils", default-features = false }
-
 ark-relations = { git = "https://github.com/arkworks-rs/snark", default-features = false }
+ark-r1cs-std = { git = "https://github.com/arkworks-rs/r1cs-std", default-features = false  }
 
 ark-r1cs-std = { git = "https://github.com/arkworks-rs/r1cs-std" }
 
 ark-nonnative-field = { git = "ssh://git@github.com/arkworks-rs/nonnative.git" }
 
-bench-utils = { git = "https://github.com/arkworks-rs/utils" }
+bench-utils = { git = "https://github.com/arkworks-rs/utils", default-features = false  }
+
 rand_core = { version = "0.5", default-features = false }
 digest = "0.8"
 rayon = { version = "1", optional = true }

src/kzg10/data_structures.rs

@@ -92,7 +92,7 @@ impl<E: PairingEngine> ToBytes for VerifierKey<E> {
 #[derive(Derivative)]
 #[derivative(Default(bound = ""), Clone(bound = ""), Debug(bound = ""))]
 pub struct PreparedVerifierKey<E: PairingEngine> {
-    /// The generator of G1.
+    /// The generator of G1, prepared for power series.
     pub prepared_g: Vec<E::G1Affine>,
     /// The generator of G2, prepared for use in pairings.
     pub prepared_h: E::G2Prepared,

src/lib.rs

@@ -82,8 +82,9 @@ pub mod sonic_pc;
 pub mod ipa_pc;
 
 /// `QuerySet` is the set of queries that are to be made to a set of labeled polynomials/equations
-/// `p` that have previously been committed to. Each element of a `QuerySet` is a `(label, query)`
-/// pair, where `label` is the label of a polynomial in `p`, and `query` is the field element
+/// `p` that have previously been committed to. Each element of a `QuerySet` is a pair of
+/// `(label, (point_label, point))`, where `label` is the label of a polynomial in `p`,
+/// `point_label` is the label for the point (e.g., "beta"), and  and `point` is the field element
 /// that `p[label]` is to be queried at.
 pub type QuerySet<'a, F> = BTreeSet<(String, (String, F))>;
 
@@ -114,9 +115,9 @@ pub trait PolynomialCommitment<F: Field>: Sized {
     /// open the commitment to produce an evaluation proof.
     type CommitterKey: PCCommitterKey;
     /// The verifier key for the scheme; used to check an evaluation proof.
-    type VerifierKey: PCVerifierKey + Default;
+    type VerifierKey: PCVerifierKey;
     /// The prepared verifier key for the scheme; used to check an evaluation proof.
-    type PreparedVerifierKey: PCPreparedVerifierKey<Self::VerifierKey> + Default + Clone;
+    type PreparedVerifierKey: PCPreparedVerifierKey<Self::VerifierKey> + Clone;
     /// The commitment to a polynomial.
     type Commitment: PCCommitment + Default;
     /// The prepared commitment to a polynomial.
@@ -445,7 +446,9 @@ pub trait PolynomialCommitment<F: Field>: Sized {
     }
 
     /// open but with individual challenges
-    /// By default, we downgrade them to only use the first individual opening challenges
+    /// the non-individual version `open` should call this method with
+    /// `opening_challenges = |pow| opening_challenge.pow(&[pow]);`,
+    /// i.e., the same impl as in MarlinKZG.
     fn open_individual_opening_challenges<'a>(
         ck: &Self::CommitterKey,
         labeled_polynomials: impl IntoIterator<Item = &'a LabeledPolynomial<F>>,
@@ -471,7 +474,9 @@ pub trait PolynomialCommitment<F: Field>: Sized {
     }
 
     /// check but with individual challenges
-    /// By default, we downgrade them to only use the first individual opening challenges
+    /// The non-individual version `check` should call this method with
+    /// `opening_challenges = |pow| opening_challenge.pow(&[pow]);`,
+    /// i.e., the same impl as in MarlinKZG.
     fn check_individual_opening_challenges<'a>(
         vk: &Self::VerifierKey,
         commitments: impl IntoIterator<Item = &'a LabeledCommitment<Self::Commitment>>,
@@ -496,7 +501,9 @@ pub trait PolynomialCommitment<F: Field>: Sized {
     }
 
     /// batch_check but with individual challenges
-    /// By default, we downgrade them to only use the first individual opening challenges
+    /// The non-individual version `batch_check` should call this method with
+    /// `opening_challenges = |pow| opening_challenge.pow(&[pow]);`,
+    /// i.e., the same impl as in MarlinKZG.
     fn batch_check_individual_opening_challenges<'a, R: RngCore>(
         vk: &Self::VerifierKey,
         commitments: impl IntoIterator<Item = &'a LabeledCommitment<Self::Commitment>>,
@@ -521,7 +528,9 @@ pub trait PolynomialCommitment<F: Field>: Sized {
     }
 
     /// open_combinations but with individual challenges
-    /// By default, we downgrade them to only use the first individual opening challenges
+    /// The non-individual version `open_combinations` should call this method with
+    /// `opening_challenges = |pow| opening_challenge.pow(&[pow]);`,
+    /// i.e., the same impl as in MarlinKZG.
     fn open_combinations_individual_opening_challenges<'a>(
         ck: &Self::CommitterKey,
         lc_s: impl IntoIterator<Item = &'a LinearCombination<F>>,
@@ -549,7 +558,9 @@ pub trait PolynomialCommitment<F: Field>: Sized {
     }
 
     /// check_combinations but with individual challenges
-    /// By default, we downgrade them to only use the first individual opening challenges
+    /// The non-individual version `check_combinations` should call this method with
+    /// `opening_challenges = |pow| opening_challenge.pow(&[pow]);`,
+    /// i.e., the same impl as in MarlinKZG.
     fn check_combinations_individual_opening_challenges<'a, R: RngCore>(
         vk: &Self::VerifierKey,
         lc_s: impl IntoIterator<Item = &'a LinearCombination<F>>,
@@ -576,7 +587,9 @@ pub trait PolynomialCommitment<F: Field>: Sized {
     }
 
     /// batch_open but with individual challenges
-    /// By default, we downgrade them to only use the first individual opening challenges
+    /// The non-individual version `batch_open` should call this method with
+    /// `opening_challenges = |pow| opening_challenge.pow(&[pow]);`,
+    /// i.e., the same impl as in MarlinKZG.
     fn batch_open_individual_opening_challenges<'a>(
         ck: &Self::CommitterKey,
         labeled_polynomials: impl IntoIterator<Item = &'a LabeledPolynomial<F>>,

src/marlin_pc/data_structures.rs

@@ -148,7 +148,7 @@ impl<E: PairingEngine> ToBytes for VerifierKey<E> {
 
 /// `PreparedVerifierKey` is used to check evaluation proofs for a given commitment.
 #[derive(Derivative)]
-#[derivative(Default(bound = ""), Clone(bound = ""), Debug(bound = ""))]
+#[derivative(Clone(bound = ""), Debug(bound = ""))]
 pub struct PreparedVerifierKey<E: PairingEngine> {
     /// The verification key for the underlying KZG10 scheme.
     pub prepared_vk: kzg10::PreparedVerifierKey<E>,
@@ -259,7 +259,6 @@ impl<E: PairingEngine> PCCommitment for Commitment<E> {
 /// Prepared commitment to a polynomial that optionally enforces a degree bound.
 #[derive(Derivative)]
 #[derivative(
-    Default(bound = ""),
     Hash(bound = ""),
     Clone(bound = ""),
     Debug(bound = ""),

src/marlin_pc/mod.rs

@@ -539,26 +539,26 @@ impl<E: PairingEngine> PolynomialCommitment<E::Fr> for MarlinKZG10<E> {
 
             assert_eq!(degree_bound.is_some(), rand.shifted_rand.is_some());
 
-            p += (challenge_j.clone(), polynomial.polynomial());
-            r += (challenge_j.clone(), &rand.rand);
+            p += (challenge_j, polynomial.polynomial());
+            r += (challenge_j, &rand.rand);
 
             if let Some(degree_bound) = degree_bound {
                 enforce_degree_bound = true;
                 let shifted_rand = rand.shifted_rand.as_ref().unwrap();
                 let (witness, shifted_rand_witness) = kzg10::KZG10::compute_witness_polynomial(
                     polynomial.polynomial(),
-                    point.clone(),
+                    point,
                     &shifted_rand,
                 )?;
                 let challenge_j_1 = opening_challenges(opening_challenge_counter);
                 opening_challenge_counter += 1;
 
                 let shifted_witness = shift_polynomial(ck, &witness, degree_bound);
 
-                shifted_w += (challenge_j_1.clone(), &shifted_witness);
-                shifted_r += (challenge_j_1.clone(), shifted_rand);
+                shifted_w += (challenge_j_1, &shifted_witness);
+                shifted_r += (challenge_j_1, shifted_rand);
                 if let Some(shifted_rand_witness) = shifted_rand_witness {
-                    shifted_r_witness += (challenge_j_1.clone(), &shifted_rand_witness);
+                    shifted_r_witness += (challenge_j_1, &shifted_rand_witness);
                 }
             }
         }