Brakedown++

README.md

@@ -128,13 +128,13 @@ let (ck, vk) = PCS::trim(&pp, degree, 2, Some(&[degree])).unwrap();
 
 // 3. PolynomialCommitment::commit
 // The prover commits to the polynomial using their committer key `ck`.
-let (comms, rands) = PCS::commit(&ck, [&labeled_poly], Some(rng)).unwrap(); 
+let (comms, states) = PCS::commit(&ck, [&labeled_poly], Some(rng)).unwrap(); 
 
 let challenge_generator: ChallengeGenerator<<Bls12_377 as Pairing>::ScalarField, Sponge_Bls12_377> = ChallengeGenerator::new_univariate(&mut test_sponge);
 
 // 4a. PolynomialCommitment::open
 // Opening proof at a single point.
-let proof_single = PCS::open(&ck, [&labeled_poly], &comms, &point_1, &mut (challenge_generator.clone()), &rands, None).unwrap(); 
+let proof_single = PCS::open(&ck, [&labeled_poly], &comms, &point_1, &mut (challenge_generator.clone()), &states, None).unwrap(); 
 
 // 5a. PolynomialCommitment::check
 // Verifying the proof at a single point, given the commitment, the point, the claimed evaluation, and the proof.
@@ -156,7 +156,7 @@ let proof_batched = PCS::batch_open(
    &comms,
    &query_set,
    &mut (challenge_generator.clone()),
-   &rands,
+   &states,
    Some(rng),
 ).unwrap();
 

bench-templates/src/lib.rs

@@ -131,7 +131,7 @@ where
     let labeled_poly =
         LabeledPolynomial::new("test".to_string(), rand_poly(num_vars, rng), None, None);
 
-    let (coms, randomness) = PCS::commit(&ck, [&labeled_poly], Some(rng)).unwrap();
+    let (coms, states) = PCS::commit(&ck, [&labeled_poly], Some(rng)).unwrap();
     let point = rand_point(num_vars, rng);
 
     let start = Instant::now();
@@ -141,7 +141,7 @@ where
         &coms,
         &point,
         &mut ChallengeGenerator::new_univariate(&mut test_sponge()),
-        &randomness,
+        &states,
         Some(rng),
     )
     .unwrap();
@@ -165,7 +165,7 @@ where
     let labeled_poly =
         LabeledPolynomial::new("test".to_string(), rand_poly(num_vars, rng), None, None);
 
-    let (coms, randomness) = PCS::commit(&ck, [&labeled_poly], Some(rng)).unwrap();
+    let (coms, states) = PCS::commit(&ck, [&labeled_poly], Some(rng)).unwrap();
     let point = P::Point::rand(rng);
 
     let proofs = PCS::open(
@@ -174,7 +174,7 @@ where
         &coms,
         &point,
         &mut ChallengeGenerator::new_univariate(&mut test_sponge()),
-        &randomness,
+        &states,
         Some(rng),
     )
     .unwrap();
@@ -202,7 +202,7 @@ where
     let labeled_poly =
         LabeledPolynomial::new("test".to_string(), rand_poly(num_vars, rng), None, None);
 
-    let (coms, randomness) = PCS::commit(&ck, [&labeled_poly], Some(rng)).unwrap();
+    let (coms, states) = PCS::commit(&ck, [&labeled_poly], Some(rng)).unwrap();
     let point = rand_point(num_vars, rng);
     let claimed_eval = labeled_poly.evaluate(&point);
     let proof = PCS::open(
@@ -211,7 +211,7 @@ where
         &coms,
         &point,
         &mut ChallengeGenerator::new_univariate(&mut test_sponge()),
-        &randomness,
+        &states,
         Some(rng),
     )
     .unwrap();

poly-commit/src/data_structures.rs

@@ -70,9 +70,9 @@ pub trait PCPreparedCommitment<UNPREPARED: PCCommitment>: Clone {
     fn prepare(comm: &UNPREPARED) -> Self;
 }
 
-/// Defines the minimal interface of commitment randomness for any polynomial
-/// commitment scheme.
-pub trait PCRandomness: Clone + CanonicalSerialize + CanonicalDeserialize {
+/// Defines the minimal interface of commitment state for any polynomial
+/// commitment scheme. It might be randomness etc.
+pub trait PCCommitmentState: Clone + CanonicalSerialize + CanonicalDeserialize {
     /// Outputs empty randomness that does not hide the commitment.
     fn empty() -> Self;
 

poly-commit/src/ipa_pc/data_structures.rs

@@ -146,7 +146,7 @@ pub struct Randomness<G: AffineRepr> {
     pub shifted_rand: Option<G::ScalarField>,
 }
 
-impl<G: AffineRepr> PCRandomness for Randomness<G> {
+impl<G: AffineRepr> PCCommitmentState for Randomness<G> {
     fn empty() -> Self {
         Self {
             rand: G::ScalarField::zero(),

poly-commit/src/ipa_pc/mod.rs

@@ -1,7 +1,7 @@
 use crate::{BTreeMap, BTreeSet, String, ToString, Vec, CHALLENGE_SIZE};
 use crate::{BatchLCProof, DenseUVPolynomial, Error, Evaluations, QuerySet};
 use crate::{LabeledCommitment, LabeledPolynomial, LinearCombination};
-use crate::{PCCommitterKey, PCRandomness, PCUniversalParams, PolynomialCommitment};
+use crate::{PCCommitmentState, PCCommitterKey, PCUniversalParams, PolynomialCommitment};
 
 use ark_ec::{AffineRepr, CurveGroup, VariableBaseMSM};
 use ark_ff::{Field, One, PrimeField, UniformRand, Zero};
@@ -347,7 +347,7 @@ where
     type CommitterKey = CommitterKey<G>;
     type VerifierKey = VerifierKey<G>;
     type Commitment = Commitment<G>;
-    type Randomness = Randomness<G>;
+    type CommitmentState = Randomness<G>;
     type Proof = Proof<G>;
     type BatchProof = Vec<Self::Proof>;
     type Error = Error;
@@ -418,7 +418,7 @@ where
     ) -> Result<
         (
             Vec<LabeledCommitment<Self::Commitment>>,
-            Vec<Self::Randomness>,
+            Vec<Self::CommitmentState>,
         ),
         Self::Error,
     >
@@ -489,12 +489,12 @@ where
         commitments: impl IntoIterator<Item = &'a LabeledCommitment<Self::Commitment>>,
         point: &'a P::Point,
         opening_challenges: &mut ChallengeGenerator<G::ScalarField, S>,
-        rands: impl IntoIterator<Item = &'a Self::Randomness>,
+        rands: impl IntoIterator<Item = &'a Self::CommitmentState>,
         rng: Option<&mut dyn RngCore>,
     ) -> Result<Self::Proof, Self::Error>
     where
         Self::Commitment: 'a,
-        Self::Randomness: 'a,
+        Self::CommitmentState: 'a,
         P: 'a,
     {
         let mut combined_polynomial = P::zero();
@@ -877,11 +877,11 @@ where
         commitments: impl IntoIterator<Item = &'a LabeledCommitment<Self::Commitment>>,
         query_set: &QuerySet<P::Point>,
         opening_challenges: &mut ChallengeGenerator<G::ScalarField, S>,
-        rands: impl IntoIterator<Item = &'a Self::Randomness>,
+        rands: impl IntoIterator<Item = &'a Self::CommitmentState>,
         rng: Option<&mut dyn RngCore>,
     ) -> Result<BatchLCProof<G::ScalarField, Self::BatchProof>, Self::Error>
     where
-        Self::Randomness: 'a,
+        Self::CommitmentState: 'a,
         Self::Commitment: 'a,
         P: 'a,
     {

poly-commit/src/kzg10/data_structures.rs

@@ -420,7 +420,7 @@ impl<F: PrimeField, P: DenseUVPolynomial<F>> Randomness<F, P> {
     }
 }
 
-impl<F: PrimeField, P: DenseUVPolynomial<F>> PCRandomness for Randomness<F, P> {
+impl<F: PrimeField, P: DenseUVPolynomial<F>> PCCommitmentState for Randomness<F, P> {
     fn empty() -> Self {
         Self {
             blinding_polynomial: P::zero(),

poly-commit/src/kzg10/mod.rs

@@ -5,7 +5,7 @@
 //! proposed by Kate, Zaverucha, and Goldberg ([KZG10](http://cacr.uwaterloo.ca/techreports/2010/cacr2010-10.pdf)).
 //! This construction achieves extractability in the algebraic group model (AGM).
 
-use crate::{BTreeMap, Error, LabeledPolynomial, PCRandomness, ToString, Vec};
+use crate::{BTreeMap, Error, LabeledPolynomial, PCCommitmentState, ToString, Vec};
 use ark_ec::AffineRepr;
 use ark_ec::{pairing::Pairing, CurveGroup};
 use ark_ec::{scalar_mul::fixed_base::FixedBase, VariableBaseMSM};

poly-commit/src/lib.rs

@@ -165,8 +165,8 @@ pub trait PolynomialCommitment<F: PrimeField, P: Polynomial<F>, S: Cryptographic
     type VerifierKey: PCVerifierKey;
     /// The commitment to a polynomial.
     type Commitment: PCCommitment + Default;
-    /// The commitment randomness.
-    type Randomness: PCRandomness;
+    /// The state of commitment
+    type CommitmentState: PCCommitmentState;
     /// The evaluation proof for a single point.
     type Proof: Clone;
     /// The evaluation proof for a query set.
@@ -212,7 +212,7 @@ pub trait PolynomialCommitment<F: PrimeField, P: Polynomial<F>, S: Cryptographic
     ) -> Result<
         (
             Vec<LabeledCommitment<Self::Commitment>>,
-            Vec<Self::Randomness>,
+            Vec<Self::CommitmentState>,
         ),
         Self::Error,
     >
@@ -226,12 +226,12 @@ pub trait PolynomialCommitment<F: PrimeField, P: Polynomial<F>, S: Cryptographic
         commitments: impl IntoIterator<Item = &'a LabeledCommitment<Self::Commitment>>,
         point: &'a P::Point,
         challenge_generator: &mut ChallengeGenerator<F, S>,
-        rands: impl IntoIterator<Item = &'a Self::Randomness>,
+        states: impl IntoIterator<Item = &'a Self::CommitmentState>,
         rng: Option<&mut dyn RngCore>,
     ) -> Result<Self::Proof, Self::Error>
     where
         P: 'a,
-        Self::Randomness: 'a,
+        Self::CommitmentState: 'a,
         Self::Commitment: 'a;
 
     /// check but with individual challenges
@@ -262,29 +262,29 @@ pub trait PolynomialCommitment<F: PrimeField, P: Polynomial<F>, S: Cryptographic
         commitments: impl IntoIterator<Item = &'a LabeledCommitment<Self::Commitment>>,
         query_set: &QuerySet<P::Point>,
         challenge_generator: &mut ChallengeGenerator<F, S>,
-        rands: impl IntoIterator<Item = &'a Self::Randomness>,
+        states: impl IntoIterator<Item = &'a Self::CommitmentState>,
         rng: Option<&mut dyn RngCore>,
     ) -> Result<Self::BatchProof, Self::Error>
     where
         P: 'a,
-        Self::Randomness: 'a,
+        Self::CommitmentState: 'a,
         Self::Commitment: 'a,
     {
         // The default implementation achieves proceeds by rearranging the queries in
         // order to gather (i.e. batch) all polynomials that should be queried at
         // the same point, then opening their commitments simultaneously with a
         // single call to `open` (per point)
         let rng = &mut crate::optional_rng::OptionalRng(rng);
-        let poly_rand_comm: BTreeMap<_, _> = labeled_polynomials
+        let poly_st_comm: BTreeMap<_, _> = labeled_polynomials
             .into_iter()
-            .zip(rands)
+            .zip(states)
             .zip(commitments.into_iter())
-            .map(|((poly, r), comm)| (poly.label(), (poly, r, comm)))
+            .map(|((poly, st), comm)| (poly.label(), (poly, st, comm)))
             .collect();
 
         let open_time = start_timer!(|| format!(
             "Opening {} polynomials at query set of size {}",
-            poly_rand_comm.len(),
+            poly_st_comm.len(),
             query_set.len(),
         ));
 
@@ -307,20 +307,20 @@ pub trait PolynomialCommitment<F: PrimeField, P: Polynomial<F>, S: Cryptographic
         let mut proofs = Vec::new();
         for (_point_label, (point, labels)) in query_to_labels_map.into_iter() {
             let mut query_polys: Vec<&'a LabeledPolynomial<_, _>> = Vec::new();
-            let mut query_rands: Vec<&'a Self::Randomness> = Vec::new();
+            let mut query_states: Vec<&'a Self::CommitmentState> = Vec::new();
             let mut query_comms: Vec<&'a LabeledCommitment<Self::Commitment>> = Vec::new();
 
             // Constructing matching vectors with the polynomial, commitment
             // randomness and actual commitment for each polynomial being
             // queried at `point`
             for label in labels {
-                let (polynomial, rand, comm) =
-                    poly_rand_comm.get(label).ok_or(Error::MissingPolynomial {
+                let (polynomial, state, comm) =
+                    poly_st_comm.get(label).ok_or(Error::MissingPolynomial {
                         label: label.to_string(),
                     })?;
 
                 query_polys.push(polynomial);
-                query_rands.push(rand);
+                query_states.push(state);
                 query_comms.push(comm);
             }
 
@@ -334,7 +334,7 @@ pub trait PolynomialCommitment<F: PrimeField, P: Polynomial<F>, S: Cryptographic
                 query_comms,
                 &point,
                 challenge_generator,
-                query_rands,
+                query_states,
                 Some(rng),
             )?;
 
@@ -447,11 +447,11 @@ pub trait PolynomialCommitment<F: PrimeField, P: Polynomial<F>, S: Cryptographic
         commitments: impl IntoIterator<Item = &'a LabeledCommitment<Self::Commitment>>,
         query_set: &QuerySet<P::Point>,
         challenge_generator: &mut ChallengeGenerator<F, S>,
-        rands: impl IntoIterator<Item = &'a Self::Randomness>,
+        states: impl IntoIterator<Item = &'a Self::CommitmentState>,
         rng: Option<&mut dyn RngCore>,
     ) -> Result<BatchLCProof<F, Self::BatchProof>, Self::Error>
     where
-        Self::Randomness: 'a,
+        Self::CommitmentState: 'a,
         Self::Commitment: 'a,
         P: 'a,
     {
@@ -473,7 +473,7 @@ pub trait PolynomialCommitment<F: PrimeField, P: Polynomial<F>, S: Cryptographic
             commitments,
             &poly_query_set,
             challenge_generator,
-            rands,
+            states,
             rng,
         )?;
         Ok(BatchLCProof {
@@ -724,7 +724,7 @@ pub mod tests {
                 )?;
                 println!("Trimmed");
 
-                let (comms, rands) = PC::commit(&ck, &polynomials, Some(rng))?;
+                let (comms, states) = PC::commit(&ck, &polynomials, Some(rng))?;
 
                 let mut query_set = QuerySet::new();
                 let mut values = Evaluations::new();
@@ -742,7 +742,7 @@ pub mod tests {
                     &comms,
                     &query_set,
                     &mut (challenge_gen.clone()),
-                    &rands,
+                    &states,
                     Some(rng),
                 )?;
                 let result = PC::batch_check(
@@ -857,7 +857,7 @@ pub mod tests {
                 )?;
                 println!("Trimmed");
 
-                let (comms, rands) = PC::commit(&ck, &polynomials, Some(rng))?;
+                let (comms, states) = PC::commit(&ck, &polynomials, Some(rng))?;
 
                 // Construct query set
                 let mut query_set = QuerySet::new();
@@ -878,7 +878,7 @@ pub mod tests {
                     &comms,
                     &query_set,
                     &mut (challenge_gen.clone()),
-                    &rands,
+                    &states,
                     Some(rng),
                 )?;
                 let result = PC::batch_check(
@@ -1005,7 +1005,7 @@ pub mod tests {
                 )?;
                 println!("Trimmed");
 
-                let (comms, rands) = PC::commit(&ck, &polynomials, Some(rng))?;
+                let (comms, states) = PC::commit(&ck, &polynomials, Some(rng))?;
 
                 // Let's construct our equations
                 let mut linear_combinations = Vec::new();
@@ -1057,7 +1057,7 @@ pub mod tests {
                     &comms,
                     &query_set,
                     &mut (challenge_gen.clone()),
-                    &rands,
+                    &states,
                     Some(rng),
                 )?;
                 println!("Generated proof");

poly-commit/src/linear_codes/brakedown.rs

@@ -78,11 +78,13 @@ where
         (self.n, self.m)
     }
 
-    fn leaf_hash_params(&self) -> &<<C as Config>::LeafHash as CRHScheme>::Parameters {
+    fn leaf_hash_param(&self) -> &<<C as Config>::LeafHash as CRHScheme>::Parameters {
         &self.leaf_hash_params
     }
 
-    fn two_to_one_params(&self) -> &<<C as Config>::TwoToOneHash as TwoToOneCRHScheme>::Parameters {
+    fn two_to_one_hash_param(
+        &self,
+    ) -> &<<C as Config>::TwoToOneHash as TwoToOneCRHScheme>::Parameters {
         &self.two_to_one_params
     }