From 5beecf19148273d3c1770262c605d9bf3716c528 Mon Sep 17 00:00:00 2001 From: Marcin Kostrzewa Date: Mon, 25 Nov 2024 17:39:13 +0100 Subject: [PATCH 1/4] use FS to generate STIR queries --- .gitignore | 1 + src/whir/fs_utils.rs | 30 ++++++++++++++++++++++++++++++ src/whir/iopattern.rs | 6 +++++- src/whir/mod.rs | 1 + src/whir/prover.rs | 14 +++++++------- src/whir/verifier.rs | 18 +++++++++--------- 6 files changed, 53 insertions(+), 17 deletions(-) create mode 100644 src/whir/fs_utils.rs diff --git a/.gitignore b/.gitignore index 8356b80..2ce79d2 100644 --- a/.gitignore +++ b/.gitignore @@ -7,3 +7,4 @@ outputs/temp/ *.pdf scripts/__pycache__/ .DS_Store +.idea diff --git a/src/whir/fs_utils.rs b/src/whir/fs_utils.rs new file mode 100644 index 0000000..245cbb5 --- /dev/null +++ b/src/whir/fs_utils.rs @@ -0,0 +1,30 @@ +use crate::domain::Domain; +use crate::utils::dedup; +use crate::whir::parameters::{RoundConfig, WhirConfig}; +use ark_crypto_primitives::merkle_tree; +use ark_ff::FftField; +use nimue::{ByteChallenges, ProofResult}; + +pub fn get_challenge_stir_queries( + domain_size: usize, + folding_factor: usize, + num_queries: usize, + transcript: &mut T, +) -> ProofResult> +where + T: ByteChallenges, +{ + let folded_domain_size = domain_size / (1 << folding_factor); + let domain_size_bytes = ((folded_domain_size * 2 - 1).ilog2() as usize + 7) / 8; + let mut queries = vec![0u8; num_queries * domain_size_bytes]; + transcript.fill_challenge_bytes(&mut queries)?; + let indices = queries.chunks_exact(domain_size_bytes).map(|chunk| { + let mut result = 0; + for byte in chunk { + result <<= 8; + result |= *byte as usize; + } + result % folded_domain_size + }); + Ok(dedup(indices)) +} diff --git a/src/whir/iopattern.rs b/src/whir/iopattern.rs index d0e2485..1c60346 100644 --- a/src/whir/iopattern.rs +++ b/src/whir/iopattern.rs @@ -47,14 +47,18 @@ where .challenge_scalars(1, "initial_combination_randomness") .add_sumcheck(params.folding_factor, params.starting_folding_pow_bits); + let mut folded_domain_size = params.starting_domain.folded_size(params.folding_factor); + for r in ¶ms.round_parameters { + let domain_size_bytes = ((folded_domain_size * 2 - 1).ilog2() as usize + 7) / 8; self = self .add_bytes(32, "merkle_digest") .add_ood(r.ood_samples) - .challenge_bytes(32, "stir_queries_seed") + .challenge_bytes(r.num_queries * domain_size_bytes, "stir_queries") .pow(r.pow_bits) .challenge_scalars(1, "combination_randomness") .add_sumcheck(params.folding_factor, r.folding_pow_bits); + folded_domain_size /= 2; } self.add_scalars(1 << params.final_sumcheck_rounds, "final_coeffs") diff --git a/src/whir/mod.rs b/src/whir/mod.rs index 8243508..39f14cd 100644 --- a/src/whir/mod.rs +++ b/src/whir/mod.rs @@ -8,6 +8,7 @@ pub mod iopattern; pub mod parameters; pub mod prover; pub mod verifier; +mod fs_utils; #[derive(Debug, Clone)] pub struct Statement { diff --git a/src/whir/prover.rs b/src/whir/prover.rs index e4b4591..e0066c7 100644 --- a/src/whir/prover.rs +++ b/src/whir/prover.rs @@ -21,6 +21,7 @@ use nimue::{ use nimue_pow::{self, PoWChallenge}; use rand::{Rng, SeedableRng}; +use crate::whir::fs_utils::get_challenge_stir_queries; #[cfg(feature = "parallel")] use rayon::prelude::*; @@ -214,13 +215,12 @@ where } // STIR queries - let mut stir_queries_seed = [0u8; 32]; - merlin.fill_challenge_bytes(&mut stir_queries_seed)?; - let mut stir_gen = rand_chacha::ChaCha20Rng::from_seed(stir_queries_seed); - let stir_challenges_indexes = - utils::dedup((0..round_params.num_queries).map(|_| { - stir_gen.gen_range(0..round_state.domain.folded_size(self.0.folding_factor)) - })); + let stir_challenges_indexes = get_challenge_stir_queries( + round_state.domain.size(), + self.0.folding_factor, + round_params.num_queries, + merlin, + )?; let domain_scaled_gen = round_state .domain .backing_domain diff --git a/src/whir/verifier.rs b/src/whir/verifier.rs index 2fb131b..b6d9032 100644 --- a/src/whir/verifier.rs +++ b/src/whir/verifier.rs @@ -10,6 +10,8 @@ use nimue::{ use nimue_pow::{self, PoWChallenge}; use rand::{Rng, SeedableRng}; +use super::{parameters::WhirConfig, Statement, WhirProof}; +use crate::whir::fs_utils::get_challenge_stir_queries; use crate::{ parameters::FoldType, poly_utils::{coeffs::CoefficientList, eq_poly_outside, fold::compute_fold, MultilinearPoint}, @@ -17,8 +19,6 @@ use crate::{ utils::{self, expand_randomness}, }; -use super::{parameters::WhirConfig, Statement, WhirProof}; - pub struct Verifier where F: FftField, @@ -147,13 +147,13 @@ where arthur.fill_next_scalars(&mut ood_answers)?; } - let mut stir_queries_seed = [0u8; 32]; - arthur.fill_challenge_bytes(&mut stir_queries_seed)?; - let mut stir_gen = rand_chacha::ChaCha20Rng::from_seed(stir_queries_seed); - let folded_domain_size = domain_size / (1 << self.params.folding_factor); - let stir_challenges_indexes = utils::dedup( - (0..round_params.num_queries).map(|_| stir_gen.gen_range(0..folded_domain_size)), - ); + let stir_challenges_indexes = get_challenge_stir_queries( + domain_size, + self.params.folding_factor, + round_params.num_queries, + arthur, + )?; + let stir_challenges_points = stir_challenges_indexes .iter() .map(|index| exp_domain_gen.pow([*index as u64])) From d5976a587be896e704b06bea57a045e4a139bedc Mon Sep 17 00:00:00 2001 From: Marcin Kostrzewa Date: Mon, 25 Nov 2024 17:49:49 +0100 Subject: [PATCH 2/4] FSify final queries --- src/whir/iopattern.rs | 4 +++- src/whir/prover.rs | 14 +++++++------- src/whir/verifier.rs | 13 ++++++------- 3 files changed, 16 insertions(+), 15 deletions(-) diff --git a/src/whir/iopattern.rs b/src/whir/iopattern.rs index 1c60346..74ac8ed 100644 --- a/src/whir/iopattern.rs +++ b/src/whir/iopattern.rs @@ -61,8 +61,10 @@ where folded_domain_size /= 2; } + let domain_size_bytes = ((folded_domain_size * 2 - 1).ilog2() as usize + 7) / 8; + self.add_scalars(1 << params.final_sumcheck_rounds, "final_coeffs") - .challenge_bytes(32, "final_queries_seed") + .challenge_bytes(domain_size_bytes * params.final_queries, "final_queries") .pow(params.final_pow_bits) .add_sumcheck(params.final_sumcheck_rounds, params.final_folding_pow_bits) } diff --git a/src/whir/prover.rs b/src/whir/prover.rs index e0066c7..2505050 100644 --- a/src/whir/prover.rs +++ b/src/whir/prover.rs @@ -132,13 +132,13 @@ where merlin.add_scalars(folded_coefficients.coeffs())?; // Final verifier queries and answers - let mut queries_seed = [0u8; 32]; - merlin.fill_challenge_bytes(&mut queries_seed)?; - let mut final_gen = rand_chacha::ChaCha20Rng::from_seed(queries_seed); - let final_challenge_indexes = utils::dedup((0..self.0.final_queries).map(|_| { - final_gen.gen_range(0..round_state.domain.folded_size(self.0.folding_factor)) - })); - + let final_challenge_indexes = get_challenge_stir_queries( + round_state.domain.size(), + self.0.folding_factor, + self.0.final_queries, + merlin, + )?; + let merkle_proof = round_state .prev_merkle .generate_multi_proof(final_challenge_indexes.clone()) diff --git a/src/whir/verifier.rs b/src/whir/verifier.rs index b6d9032..5f72a50 100644 --- a/src/whir/verifier.rs +++ b/src/whir/verifier.rs @@ -222,13 +222,12 @@ where let final_coefficients = CoefficientList::new(final_coefficients); // Final queries verify - let mut queries_seed = [0u8; 32]; - arthur.fill_challenge_bytes(&mut queries_seed)?; - let mut final_gen = rand_chacha::ChaCha20Rng::from_seed(queries_seed); - let folded_domain_size = domain_size / (1 << self.params.folding_factor); - let final_randomness_indexes = utils::dedup( - (0..self.params.final_queries).map(|_| final_gen.gen_range(0..folded_domain_size)), - ); + let final_randomness_indexes = get_challenge_stir_queries( + domain_size, + self.params.folding_factor, + self.params.final_queries, + arthur, + )?; let final_randomness_points = final_randomness_indexes .iter() .map(|index| exp_domain_gen.pow([*index as u64])) From 05785467824583da827e3757ba16d4e085bcbab3 Mon Sep 17 00:00:00 2001 From: Giacomo Fenzi Date: Mon, 25 Nov 2024 18:04:18 +0100 Subject: [PATCH 3/4] Update deps --- Cargo.lock | 35 ----------------------------------- Cargo.toml | 9 +-------- 2 files changed, 1 insertion(+), 43 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 9846ff1..374bd05 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1066,38 +1066,3 @@ dependencies = [ "quote", "syn 2.0.87", ] - -[[patch.unused]] -name = "ark-crypto-primitives" -version = "0.4.0" -source = "git+https://github.com/arkworks-rs/crypto-primitives#b13983815e5b3a0fbeed0e7da0edec751beac270" - -[[patch.unused]] -name = "ark-ec" -version = "0.4.2" -source = "git+https://github.com/WizardOfMenlo/algebra?branch=fft_extensions#fe932806ba46425ba8adc7536dbc20f6d61ae13a" - -[[patch.unused]] -name = "ark-ff" -version = "0.4.2" -source = "git+https://github.com/WizardOfMenlo/algebra?branch=fft_extensions#fe932806ba46425ba8adc7536dbc20f6d61ae13a" - -[[patch.unused]] -name = "ark-poly" -version = "0.4.2" -source = "git+https://github.com/WizardOfMenlo/algebra?branch=fft_extensions#fe932806ba46425ba8adc7536dbc20f6d61ae13a" - -[[patch.unused]] -name = "ark-serialize" -version = "0.4.2" -source = "git+https://github.com/WizardOfMenlo/algebra?branch=fft_extensions#fe932806ba46425ba8adc7536dbc20f6d61ae13a" - -[[patch.unused]] -name = "ark-std" -version = "0.4.0" -source = "git+https://github.com/arkworks-rs/std#db4367e68ff60da31ac759831e38f60171f4e03d" - -[[patch.unused]] -name = "ark-test-curves" -version = "0.4.2" -source = "git+https://github.com/WizardOfMenlo/algebra?branch=fft_extensions#fe932806ba46425ba8adc7536dbc20f6d61ae13a" diff --git a/Cargo.toml b/Cargo.toml index a7a466e..edb1eda 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -41,11 +41,4 @@ parallel = [ ] rayon = ["dep:rayon"] -[patch.crates-io] -ark-std = { git = "https://github.com/arkworks-rs/std" } -ark-crypto-primitives = { git = "https://github.com/arkworks-rs/crypto-primitives" } -ark-test-curves = { git = "https://github.com/WizardOfMenlo/algebra", branch = "fft_extensions" } -ark-ff = { git = "https://github.com/WizardOfMenlo/algebra", branch = "fft_extensions" } -ark-poly = { git = "https://github.com/WizardOfMenlo/algebra", branch = "fft_extensions" } -ark-serialize = { git = "https://github.com/WizardOfMenlo/algebra", branch = "fft_extensions" } -ark-ec = { git = "https://github.com/WizardOfMenlo/algebra", branch = "fft_extensions" } + From 7a55e97c9cfc0104f9544352341f9f32113a7064 Mon Sep 17 00:00:00 2001 From: Giacomo Fenzi Date: Mon, 25 Nov 2024 18:15:41 +0100 Subject: [PATCH 4/4] Clippy --- src/bin/benchmark.rs | 2 +- src/bin/main.rs | 2 +- src/crypto/merkle_tree/blake3.rs | 6 ++-- src/crypto/merkle_tree/keccak.rs | 10 +++---- src/crypto/merkle_tree/mock.rs | 12 ++++---- src/ntt/transpose.rs | 12 ++++---- src/ntt/utils.rs | 1 - src/poly_utils/fold.rs | 6 ++-- src/poly_utils/sequential_lag_poly.rs | 3 +- src/poly_utils/streaming_evaluation_helper.rs | 2 +- src/sumcheck/mod.rs | 10 +++---- src/sumcheck/proof.rs | 2 +- src/utils.rs | 10 +++---- src/whir/fs_utils.rs | 4 --- src/whir/parameters.rs | 28 +++++++++---------- src/whir/prover.rs | 4 +-- src/whir/verifier.rs | 7 ++--- src/whir_ldt/parameters.rs | 28 +++++++++---------- src/whir_ldt/verifier.rs | 2 +- 19 files changed, 73 insertions(+), 78 deletions(-) diff --git a/src/bin/benchmark.rs b/src/bin/benchmark.rs index 2a67c5d..e4a805f 100644 --- a/src/bin/benchmark.rs +++ b/src/bin/benchmark.rs @@ -339,7 +339,7 @@ fn run_whir( .collect(); let evaluations = points .iter() - .map(|point| polynomial.evaluate_at_extension(&point)) + .map(|point| polynomial.evaluate_at_extension(point)) .collect(); let statement = Statement { points, diff --git a/src/bin/main.rs b/src/bin/main.rs index a1d83b8..a90818a 100644 --- a/src/bin/main.rs +++ b/src/bin/main.rs @@ -356,7 +356,7 @@ fn run_whir_pcs( .collect(); let evaluations = points .iter() - .map(|point| polynomial.evaluate_at_extension(&point)) + .map(|point| polynomial.evaluate_at_extension(point)) .collect(); let statement = Statement { diff --git a/src/crypto/merkle_tree/blake3.rs b/src/crypto/merkle_tree/blake3.rs index 4f30592..6090915 100644 --- a/src/crypto/merkle_tree/blake3.rs +++ b/src/crypto/merkle_tree/blake3.rs @@ -122,8 +122,8 @@ pub fn default_config( as CRHScheme>::Parameters, ::Parameters, ) { - let leaf_hash_params = as CRHScheme>::setup(rng).unwrap(); - let two_to_one_params = ::setup(rng).unwrap(); + as CRHScheme>::setup(rng).unwrap(); + ::setup(rng).unwrap(); - (leaf_hash_params, two_to_one_params) + ((), ()) } diff --git a/src/crypto/merkle_tree/keccak.rs b/src/crypto/merkle_tree/keccak.rs index 93a97b9..c4f8558 100644 --- a/src/crypto/merkle_tree/keccak.rs +++ b/src/crypto/merkle_tree/keccak.rs @@ -83,8 +83,8 @@ impl TwoToOneCRHScheme for KeccakTwoToOneCRHScheme { right_input: T, ) -> Result { let mut h = sha3::Keccak256::new(); - h.update(&left_input.borrow().0); - h.update(&right_input.borrow().0); + h.update(left_input.borrow().0); + h.update(right_input.borrow().0); let mut output = [0; 32]; output.copy_from_slice(&h.finalize()[..]); HashCounter::add(); @@ -123,8 +123,8 @@ pub fn default_config( as CRHScheme>::Parameters, ::Parameters, ) { - let leaf_hash_params = as CRHScheme>::setup(rng).unwrap(); - let two_to_one_params = ::setup(rng).unwrap(); + as CRHScheme>::setup(rng).unwrap(); + ::setup(rng).unwrap(); - (leaf_hash_params, two_to_one_params) + ((), ()) } diff --git a/src/crypto/merkle_tree/mock.rs b/src/crypto/merkle_tree/mock.rs index 8ac9f3b..9102490 100644 --- a/src/crypto/merkle_tree/mock.rs +++ b/src/crypto/merkle_tree/mock.rs @@ -58,10 +58,12 @@ pub fn default_config( as CRHScheme>::Parameters, ::Parameters, ) { - let leaf_hash_params = as CRHScheme>::setup(rng).unwrap(); - let two_to_one_params = ::setup(rng) - .unwrap() - .clone(); + as CRHScheme>::setup(rng).unwrap(); + { + ::setup(rng) + .unwrap(); + + }; - (leaf_hash_params, two_to_one_params) + ((), ()) } diff --git a/src/ntt/transpose.rs b/src/ntt/transpose.rs index e6bc6c8..be81ebf 100644 --- a/src/ntt/transpose.rs +++ b/src/ntt/transpose.rs @@ -54,9 +54,9 @@ fn transpose_copy(src: MatrixMut, dst: MatrixMut) /// Sets `dst` to the transpose of `src`. This will panic if the sizes of `src` and `dst` are not compatible. #[cfg(feature = "parallel")] -fn transpose_copy_parallel<'a, 'b, F: Sized + Copy + Send>( - src: MatrixMut<'a, F>, - mut dst: MatrixMut<'b, F>, +fn transpose_copy_parallel( + src: MatrixMut<'_, F>, + mut dst: MatrixMut<'_, F>, ) { assert_eq!(src.rows(), dst.cols()); assert_eq!(src.cols(), dst.rows()); @@ -85,9 +85,9 @@ fn transpose_copy_parallel<'a, 'b, F: Sized + Copy + Send>( /// Sets `dst` to the transpose of `src`. This will panic if the sizes of `src` and `dst` are not compatible. /// This is the non-parallel version -fn transpose_copy_not_parallel<'a, 'b, F: Sized + Copy>( - src: MatrixMut<'a, F>, - mut dst: MatrixMut<'b, F>, +fn transpose_copy_not_parallel( + src: MatrixMut<'_, F>, + mut dst: MatrixMut<'_, F>, ) { assert_eq!(src.rows(), dst.cols()); assert_eq!(src.cols(), dst.rows()); diff --git a/src/ntt/utils.rs b/src/ntt/utils.rs index 11ccdc3..e177d4e 100644 --- a/src/ntt/utils.rs +++ b/src/ntt/utils.rs @@ -142,7 +142,6 @@ mod tests { ); let should_not_work = std::panic::catch_unwind(|| { as_chunks_exact_mut::<_, 2>(&mut [1, 2, 3]); - return; }); assert!(should_not_work.is_err()) } diff --git a/src/poly_utils/fold.rs b/src/poly_utils/fold.rs index 44bf9a8..69f5e90 100644 --- a/src/poly_utils/fold.rs +++ b/src/poly_utils/fold.rs @@ -179,7 +179,7 @@ mod tests { // Evaluate the polynomial on the domain let domain_evaluations: Vec<_> = (0..domain_size) - .map(|w| root_of_unity.pow([w as u64])) + .map(|w| root_of_unity.pow([w])) .map(|point| { poly.evaluate(&MultilinearPoint::expand_from_univariate( point, @@ -199,10 +199,10 @@ mod tests { ); let num = domain_size / folding_factor_exp; - let coset_gen_inv = root_of_unity_inv.pow(&[num]); + let coset_gen_inv = root_of_unity_inv.pow([num]); for index in 0..num { - let offset_inv = root_of_unity_inv.pow(&[index]); + let offset_inv = root_of_unity_inv.pow([index]); let span = (index * folding_factor_exp) as usize..((index + 1) * folding_factor_exp) as usize; diff --git a/src/poly_utils/sequential_lag_poly.rs b/src/poly_utils/sequential_lag_poly.rs index c59355f..d9a203f 100644 --- a/src/poly_utils/sequential_lag_poly.rs +++ b/src/poly_utils/sequential_lag_poly.rs @@ -6,6 +6,7 @@ use super::{hypercube::BinaryHypercubePoint, MultilinearPoint}; /// There is an alternative (possibly more efficient) implementation that iterates over the x in Gray code ordering. +/// /// LagrangePolynomialIterator for a given multilinear n-dimensional `point` iterates over pairs (x, y) /// where x ranges over all possible {0,1}^n /// and y equals the product y_1 * ... * y_n where @@ -60,7 +61,7 @@ impl Iterator for LagrangePolynomialIterator { // Iterator implementation for the struct fn next(&mut self) -> Option { // a) Check if this is the first iteration - if self.last_position == None { + if self.last_position.is_none() { // Initialize last position self.last_position = Some(0); // Return the top of the stack diff --git a/src/poly_utils/streaming_evaluation_helper.rs b/src/poly_utils/streaming_evaluation_helper.rs index 322a6e5..8b2cfe3 100644 --- a/src/poly_utils/streaming_evaluation_helper.rs +++ b/src/poly_utils/streaming_evaluation_helper.rs @@ -37,7 +37,7 @@ impl Iterator for TermPolynomialIterator { // Iterator implementation for the struct fn next(&mut self) -> Option { // a) Check if this is the first iteration - if self.last_position == None { + if self.last_position.is_none() { // Initialize last position self.last_position = Some(0); // Return the top of the stack diff --git a/src/sumcheck/mod.rs b/src/sumcheck/mod.rs index eaeac85..0c1d45a 100644 --- a/src/sumcheck/mod.rs +++ b/src/sumcheck/mod.rs @@ -99,7 +99,7 @@ mod tests { // First, check that is sums to the right value over the hypercube assert_eq!(poly_1.sum_over_hypercube(), claimed_value); - let combination_randomness = vec![F::from(293), F::from(42)]; + let combination_randomness = [F::from(293), F::from(42)]; let folding_randomness = MultilinearPoint(vec![F::from(335), F::from(222)]); let new_eval_point = MultilinearPoint(vec![F::from(32); num_variables - folding_factor]); @@ -146,7 +146,7 @@ mod tests { let [epsilon_1, epsilon_2] = [F::from(15), F::from(32)]; let folding_randomness_1 = MultilinearPoint(vec![F::from(11), F::from(31)]); let fold_point = MultilinearPoint(vec![F::from(31), F::from(15)]); - let combination_randomness = vec![F::from(31), F::from(4999)]; + let combination_randomness = [F::from(31), F::from(4999)]; let folding_randomness_2 = MultilinearPoint(vec![F::from(97), F::from(36)]); let mut prover = SumcheckCore::new( @@ -184,7 +184,7 @@ mod tests { ); let full_folding = - MultilinearPoint(vec![folding_randomness_2.0.clone(), folding_randomness_1.0].concat()); + MultilinearPoint([folding_randomness_2.0.clone(), folding_randomness_1.0].concat()); let eval_coeff = folded_poly_1.fold(&folding_randomness_2).coeffs()[0]; assert_eq!( sumcheck_poly_2.evaluate_at_point(&folding_randomness_2), @@ -217,8 +217,8 @@ mod tests { let fold_point_12 = MultilinearPoint(vec![F::from(1231), F::from(15), F::from(4231), F::from(15)]); let fold_point_2 = MultilinearPoint(vec![F::from(311), F::from(115)]); - let combination_randomness_1 = vec![F::from(1289), F::from(3281), F::from(10921)]; - let combination_randomness_2 = vec![F::from(3281), F::from(3232)]; + let combination_randomness_1 = [F::from(1289), F::from(3281), F::from(10921)]; + let combination_randomness_2 = [F::from(3281), F::from(3232)]; let mut prover = SumcheckCore::new( polynomial.clone(), diff --git a/src/sumcheck/proof.rs b/src/sumcheck/proof.rs index 36cfe27..2455541 100644 --- a/src/sumcheck/proof.rs +++ b/src/sumcheck/proof.rs @@ -90,7 +90,7 @@ mod tests { let num_evaluation_points = 3_usize.pow(num_variables as u32); let evaluations = (0..num_evaluation_points as u64).map(F::from).collect(); - let poly = SumcheckPolynomial::new(evaluations, num_variables as usize); + let poly = SumcheckPolynomial::new(evaluations, num_variables); for i in 0..num_evaluation_points { let decomp = base_decomposition(i, 3, num_variables); diff --git a/src/utils.rs b/src/utils.rs index 9fcc0aa..fc0104a 100644 --- a/src/utils.rs +++ b/src/utils.rs @@ -121,11 +121,11 @@ mod tests { #[test] fn test_is_power_of_two() { - assert_eq!(is_power_of_two(0), false); - assert_eq!(is_power_of_two(1), true); - assert_eq!(is_power_of_two(2), true); - assert_eq!(is_power_of_two(3), false); - assert_eq!(is_power_of_two(usize::MAX), false); + assert!(!is_power_of_two(0)); + assert!(is_power_of_two(1)); + assert!(is_power_of_two(2)); + assert!(!is_power_of_two(3)); + assert!(!is_power_of_two(usize::MAX)); } #[test] diff --git a/src/whir/fs_utils.rs b/src/whir/fs_utils.rs index 245cbb5..e435b99 100644 --- a/src/whir/fs_utils.rs +++ b/src/whir/fs_utils.rs @@ -1,8 +1,4 @@ -use crate::domain::Domain; use crate::utils::dedup; -use crate::whir::parameters::{RoundConfig, WhirConfig}; -use ark_crypto_primitives::merkle_tree; -use ark_ff::FftField; use nimue::{ByteChallenges, ProofResult}; pub fn get_challenge_stir_queries( diff --git a/src/whir/parameters.rs b/src/whir/parameters.rs index 9ee3476..5d45116 100644 --- a/src/whir/parameters.rs +++ b/src/whir/parameters.rs @@ -198,7 +198,7 @@ where final_pow_bits, final_sumcheck_rounds, final_folding_pow_bits, - pow_strategy: PhantomData::default(), + pow_strategy: PhantomData, fold_optimisation: whir_parameters.fold_optimisation, final_log_inv_rate: log_inv_rate, leaf_hash_params: whir_parameters.leaf_hash_params, @@ -241,13 +241,13 @@ where ) -> f64 { match soundness_type { SoundnessType::ConjectureList => { - let result = (num_variables + log_inv_rate) as f64 - log_eta; - result + + (num_variables + log_inv_rate) as f64 - log_eta } SoundnessType::ProvableList => { let log_inv_sqrt_rate: f64 = log_inv_rate as f64 / 2.; - let result = log_inv_sqrt_rate - (1. + log_eta); - result + + log_inv_sqrt_rate - (1. + log_eta) } SoundnessType::UniqueDecoding => 0.0, } @@ -385,7 +385,9 @@ where num_queries: usize, ) -> f64 { let num_queries = num_queries as f64; - let bits_of_sec_queries = match soundness_type { + + + match soundness_type { SoundnessType::UniqueDecoding => { let rate = 1. / ((1 << log_inv_rate) as f64); let denom = -(0.5 * (1. + rate)).log2(); @@ -394,9 +396,7 @@ where } SoundnessType::ProvableList => num_queries * 0.5 * log_inv_rate as f64, SoundnessType::ConjectureList => num_queries * log_inv_rate as f64, - }; - - bits_of_sec_queries + } } pub fn rbr_soundness_queries_combination( @@ -488,7 +488,7 @@ where writeln!( f, "{:.1} bits -- (x{}) prox gaps: {:.1}, sumcheck: {:.1}, pow: {:.1}", - prox_gaps_error.min(sumcheck_error) + self.starting_folding_pow_bits as f64, + prox_gaps_error.min(sumcheck_error) + self.starting_folding_pow_bits, self.folding_factor, prox_gaps_error, sumcheck_error, @@ -529,7 +529,7 @@ where writeln!( f, "{:.1} bits -- query error: {:.1}, combination: {:.1}, pow: {:.1}", - query_error.min(combination_error) + r.pow_bits as f64, + query_error.min(combination_error) + r.pow_bits, query_error, combination_error, r.pow_bits, @@ -553,7 +553,7 @@ where writeln!( f, "{:.1} bits -- (x{}) prox gaps: {:.1}, sumcheck: {:.1}, pow: {:.1}", - prox_gaps_error.min(sumcheck_error) + r.folding_pow_bits as f64, + prox_gaps_error.min(sumcheck_error) + r.folding_pow_bits, self.folding_factor, prox_gaps_error, sumcheck_error, @@ -571,7 +571,7 @@ where writeln!( f, "{:.1} bits -- query error: {:.1}, pow: {:.1}", - query_error + self.final_pow_bits as f64, + query_error + self.final_pow_bits, query_error, self.final_pow_bits, )?; @@ -581,7 +581,7 @@ where writeln!( f, "{:.1} bits -- (x{}) combination: {:.1}, pow: {:.1}", - combination_error + self.final_pow_bits as f64, + combination_error + self.final_pow_bits, self.final_sumcheck_rounds, combination_error, self.final_folding_pow_bits, diff --git a/src/whir/prover.rs b/src/whir/prover.rs index 2505050..62ed1cd 100644 --- a/src/whir/prover.rs +++ b/src/whir/prover.rs @@ -15,11 +15,9 @@ use ark_crypto_primitives::merkle_tree::{Config, MerkleTree, MultiPath}; use ark_ff::FftField; use ark_poly::EvaluationDomain; use nimue::{ - plugins::ark::{FieldChallenges, FieldWriter}, - ByteChallenges, ByteWriter, Merlin, ProofResult, + plugins::ark::{FieldChallenges, FieldWriter}, ByteWriter, Merlin, ProofResult, }; use nimue_pow::{self, PoWChallenge}; -use rand::{Rng, SeedableRng}; use crate::whir::fs_utils::get_challenge_stir_queries; #[cfg(feature = "parallel")] diff --git a/src/whir/verifier.rs b/src/whir/verifier.rs index 5f72a50..885ef53 100644 --- a/src/whir/verifier.rs +++ b/src/whir/verifier.rs @@ -5,10 +5,9 @@ use ark_ff::FftField; use ark_poly::EvaluationDomain; use nimue::{ plugins::ark::{FieldChallenges, FieldReader}, - Arthur, ByteChallenges, ByteReader, ProofError, ProofResult, + Arthur, ByteReader, ProofError, ProofResult, }; use nimue_pow::{self, PoWChallenge}; -use rand::{Rng, SeedableRng}; use super::{parameters::WhirConfig, Statement, WhirProof}; use crate::whir::fs_utils::get_challenge_stir_queries; @@ -16,7 +15,7 @@ use crate::{ parameters::FoldType, poly_utils::{coeffs::CoefficientList, eq_poly_outside, fold::compute_fold, MultilinearPoint}, sumcheck::proof::SumcheckPolynomial, - utils::{self, expand_randomness}, + utils::{expand_randomness}, }; pub struct Verifier @@ -335,7 +334,7 @@ where .map(|(point, rand)| point * rand) .sum(); - value = value + sum_of_claims; + value += sum_of_claims; } value diff --git a/src/whir_ldt/parameters.rs b/src/whir_ldt/parameters.rs index 2a579e6..72d21fd 100644 --- a/src/whir_ldt/parameters.rs +++ b/src/whir_ldt/parameters.rs @@ -181,7 +181,7 @@ where final_pow_bits, final_sumcheck_rounds, final_folding_pow_bits, - pow_strategy: PhantomData::default(), + pow_strategy: PhantomData, fold_optimisation: whir_parameters.fold_optimisation, final_log_inv_rate: log_inv_rate, leaf_hash_params: whir_parameters.leaf_hash_params, @@ -219,13 +219,13 @@ where ) -> f64 { match soundness_type { SoundnessType::ConjectureList => { - let result = (num_variables + log_inv_rate) as f64 - log_eta; - result + + (num_variables + log_inv_rate) as f64 - log_eta } SoundnessType::ProvableList => { let log_inv_sqrt_rate: f64 = log_inv_rate as f64 / 2.; - let result = log_inv_sqrt_rate - (1. + log_eta); - result + + log_inv_sqrt_rate - (1. + log_eta) } SoundnessType::UniqueDecoding => 0.0, } @@ -363,7 +363,9 @@ where num_queries: usize, ) -> f64 { let num_queries = num_queries as f64; - let bits_of_sec_queries = match soundness_type { + + + match soundness_type { SoundnessType::UniqueDecoding => { let rate = 1. / ((1 << log_inv_rate) as f64); let denom = -(0.5 * (1. + rate)).log2(); @@ -372,9 +374,7 @@ where } SoundnessType::ProvableList => num_queries * 0.5 * log_inv_rate as f64, SoundnessType::ConjectureList => num_queries * log_inv_rate as f64, - }; - - bits_of_sec_queries + } } pub fn rbr_soundness_queries_combination( @@ -445,7 +445,7 @@ where writeln!( f, "{:.1} bits -- prox gaps: {:.1}, pow: {:.1}", - prox_gaps_error + self.starting_folding_pow_bits as f64, + prox_gaps_error + self.starting_folding_pow_bits, prox_gaps_error, self.starting_folding_pow_bits, )?; @@ -484,7 +484,7 @@ where writeln!( f, "{:.1} bits -- query error: {:.1}, combination: {:.1}, pow: {:.1}", - query_error.min(combination_error) + r.pow_bits as f64, + query_error.min(combination_error) + r.pow_bits, query_error, combination_error, r.pow_bits, @@ -508,7 +508,7 @@ where writeln!( f, "{:.1} bits -- (x{}) prox gaps: {:.1}, sumcheck: {:.1}, pow: {:.1}", - prox_gaps_error.min(sumcheck_error) + r.folding_pow_bits as f64, + prox_gaps_error.min(sumcheck_error) + r.folding_pow_bits, self.folding_factor, prox_gaps_error, sumcheck_error, @@ -526,7 +526,7 @@ where writeln!( f, "{:.1} bits -- query error: {:.1}, pow: {:.1}", - query_error + self.final_pow_bits as f64, + query_error + self.final_pow_bits, query_error, self.final_pow_bits, )?; @@ -536,7 +536,7 @@ where writeln!( f, "{:.1} bits -- (x{}) combination: {:.1}, pow: {:.1}", - combination_error + self.final_pow_bits as f64, + combination_error + self.final_pow_bits, self.final_sumcheck_rounds, combination_error, self.final_folding_pow_bits, diff --git a/src/whir_ldt/verifier.rs b/src/whir_ldt/verifier.rs index e5e47f8..6b47901 100644 --- a/src/whir_ldt/verifier.rs +++ b/src/whir_ldt/verifier.rs @@ -291,7 +291,7 @@ where .map(|(point, rand)| point * rand) .sum(); - value = value + sum_of_claims; + value += sum_of_claims; } value