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/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 97ed8b2..cf6e503 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" } + diff --git a/src/bin/benchmark.rs b/src/bin/benchmark.rs index f8d735d..d63e1f7 100644 --- a/src/bin/benchmark.rs +++ b/src/bin/benchmark.rs @@ -348,7 +348,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 c63620f..848878f 100644 --- a/src/bin/main.rs +++ b/src/bin/main.rs @@ -5,7 +5,7 @@ use ark_crypto_primitives::{ merkle_tree::Config, }; use ark_ff::FftField; -use ark_serialize::{CanonicalDeserialize, CanonicalSerialize}; +use ark_serialize::CanonicalSerialize; use nimue::{DefaultHash, IOPattern}; use whir::{ cmdline_utils::{AvailableFields, AvailableMerkle, WhirType}, @@ -202,7 +202,7 @@ fn run_whir_as_ldt( { use whir::whir::{ committer::Committer, iopattern::WhirIOPattern, parameters::WhirConfig, prover::Prover, - verifier::Verifier, WhirProof, + verifier::Verifier, }; // Runs as a LDT @@ -369,7 +369,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 new file mode 100644 index 0000000..e435b99 --- /dev/null +++ b/src/whir/fs_utils.rs @@ -0,0 +1,26 @@ +use crate::utils::dedup; +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 5c1314a..06e478a 100644 --- a/src/whir/iopattern.rs +++ b/src/whir/iopattern.rs @@ -57,18 +57,24 @@ where .pow(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; } + 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/mod.rs b/src/whir/mod.rs index 3a9cf3b..51bab88 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, Default)] pub struct Statement { diff --git a/src/whir/parameters.rs b/src/whir/parameters.rs index 1758ee0..7a9d711 100644 --- a/src/whir/parameters.rs +++ b/src/whir/parameters.rs @@ -401,7 +401,8 @@ 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(); @@ -410,9 +411,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( @@ -504,7 +503,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, @@ -545,7 +544,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, @@ -569,7 +568,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, @@ -587,7 +586,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, )?; @@ -597,7 +596,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 c1064a3..53264df 100644 --- a/src/whir/prover.rs +++ b/src/whir/prover.rs @@ -15,12 +15,11 @@ 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")] use rayon::prelude::*; @@ -167,13 +166,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()) @@ -255,13 +254,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 20f5259..77bf893 100644 --- a/src/whir/verifier.rs +++ b/src/whir/verifier.rs @@ -5,20 +5,19 @@ 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; 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}, }; -use super::{parameters::WhirConfig, Statement, WhirProof}; - pub struct Verifier where F: FftField, @@ -166,13 +165,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])) @@ -241,13 +240,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])) @@ -355,7 +353,7 @@ where .map(|(point, rand)| point * rand) .sum(); - value = value + sum_of_claims; + value += sum_of_claims; } value