From b590427085cd25921e51b500f72d1bc8378ff76d Mon Sep 17 00:00:00 2001 From: dante <45801863+alexander-camuto@users.noreply.github.com> Date: Fri, 25 Aug 2023 15:39:50 +0100 Subject: [PATCH] feat: public cells to allow for implementations of custom `Layouter` (#192) * feat: public cells * Update mds.rs * Update mds.rs * Update single_pass.rs Co-authored-by: Han * bump toolchain to resolve errors * fix clippy errors for CI run * rustfmt post clippy * plz let it be the last lint * patch clippy lints in gadgets * clippy lints for sha256 bench * patch halo2proof benches * Update assigned.rs * Update halo2_gadgets/src/poseidon/primitives/mds.rs Co-authored-by: Han * Update halo2_gadgets/src/poseidon/primitives/mds.rs Co-authored-by: Han --------- Co-authored-by: Han --- halo2_gadgets/benches/poseidon.rs | 2 +- halo2_gadgets/benches/sha256.rs | 12 +-- halo2_gadgets/src/ecc/chip/constants.rs | 12 +-- halo2_gadgets/src/ecc/chip/mul_fixed.rs | 8 +- halo2_gadgets/src/poseidon/pow5.rs | 6 +- .../src/poseidon/primitives/p128pow5t3.rs | 4 +- halo2_proofs/benches/commit_zk.rs | 64 +++++++++++++ halo2_proofs/src/circuit.rs | 1 + .../src/circuit/floor_planner/single_pass.rs | 10 +- halo2_proofs/src/circuit/floor_planner/v1.rs | 4 +- halo2_proofs/src/dev.rs | 9 +- halo2_proofs/src/plonk/assigned.rs | 2 +- halo2_proofs/src/plonk/circuit.rs | 3 +- halo2_proofs/src/plonk/evaluation.rs | 4 +- halo2_proofs/src/plonk/lookup/prover.rs | 2 +- halo2_proofs/src/plonk/permutation/keygen.rs | 8 +- .../src/plonk/permutation/verifier.rs | 2 +- halo2_proofs/src/plonk/prover.rs | 6 +- halo2_proofs/src/plonk/verifier.rs | 92 ++++++++----------- halo2_proofs/src/poly/domain.rs | 8 +- halo2_proofs/src/poly/kzg/commitment.rs | 2 +- halo2_proofs/src/transcript.rs | 20 ++-- rust-toolchain | 2 +- 23 files changed, 163 insertions(+), 120 deletions(-) create mode 100644 halo2_proofs/benches/commit_zk.rs diff --git a/halo2_gadgets/benches/poseidon.rs b/halo2_gadgets/benches/poseidon.rs index 03e595fe0f..4175318399 100644 --- a/halo2_gadgets/benches/poseidon.rs +++ b/halo2_gadgets/benches/poseidon.rs @@ -135,7 +135,7 @@ impl Spec for MySpec Fp { - val.pow_vartime(&[5]) + val.pow_vartime([5]) } fn secure_mds() -> usize { diff --git a/halo2_gadgets/benches/sha256.rs b/halo2_gadgets/benches/sha256.rs index 0e14d61946..4afceacd82 100644 --- a/halo2_gadgets/benches/sha256.rs +++ b/halo2_gadgets/benches/sha256.rs @@ -90,18 +90,18 @@ fn bench(name: &str, k: u32, c: &mut Criterion) { // Initialize the polynomial commitment parameters let params_path = Path::new("./benches/sha256_assets/sha256_params"); - if File::open(¶ms_path).is_err() { + if File::open(params_path).is_err() { let params: ParamsIPA = ParamsIPA::new(k); let mut buf = Vec::new(); params.write(&mut buf).expect("Failed to write params"); - let mut file = File::create(¶ms_path).expect("Failed to create sha256_params"); + let mut file = File::create(params_path).expect("Failed to create sha256_params"); file.write_all(&buf[..]) .expect("Failed to write params to file"); } - let params_fs = File::open(¶ms_path).expect("couldn't load sha256_params"); + let params_fs = File::open(params_path).expect("couldn't load sha256_params"); let params: ParamsIPA = ParamsIPA::read::<_>(&mut BufReader::new(params_fs)).expect("Failed to read params"); @@ -128,7 +128,7 @@ fn bench(name: &str, k: u32, c: &mut Criterion) { // Create a proof let proof_path = Path::new("./benches/sha256_assets/sha256_proof"); - if File::open(&proof_path).is_err() { + if File::open(proof_path).is_err() { let mut transcript = Blake2bWrite::<_, _, Challenge255<_>>::init(vec![]); create_proof::, ProverIPA<_>, _, _, _, _>( ¶ms, @@ -140,11 +140,11 @@ fn bench(name: &str, k: u32, c: &mut Criterion) { ) .expect("proof generation should not fail"); let proof: Vec = transcript.finalize(); - let mut file = File::create(&proof_path).expect("Failed to create sha256_proof"); + let mut file = File::create(proof_path).expect("Failed to create sha256_proof"); file.write_all(&proof[..]).expect("Failed to write proof"); } - let mut proof_fs = File::open(&proof_path).expect("couldn't load sha256_proof"); + let mut proof_fs = File::open(proof_path).expect("couldn't load sha256_proof"); let mut proof = Vec::::new(); proof_fs .read_to_end(&mut proof) diff --git a/halo2_gadgets/src/ecc/chip/constants.rs b/halo2_gadgets/src/ecc/chip/constants.rs index 6296165464..82ed952ceb 100644 --- a/halo2_gadgets/src/ecc/chip/constants.rs +++ b/halo2_gadgets/src/ecc/chip/constants.rs @@ -49,7 +49,7 @@ fn compute_window_table(base: C, num_windows: usize) -> Vec<[C; .map(|k| { // scalar = (k+2)*(8^w) let scalar = C::Scalar::from(k as u64 + 2) - * C::Scalar::from(H as u64).pow(&[w as u64, 0, 0, 0]); + * C::Scalar::from(H as u64).pow([w as u64, 0, 0, 0]); (base * scalar).to_affine() }) .collect::>() @@ -62,14 +62,14 @@ fn compute_window_table(base: C, num_windows: usize) -> Vec<[C; // For the last window, we compute [k * (2^3)^w - sum]B, where sum is defined // as sum = \sum_{j = 0}^{`num_windows - 2`} 2^{3j+1} let sum = (0..(num_windows - 1)).fold(C::Scalar::ZERO, |acc, j| { - acc + C::Scalar::from(2).pow(&[FIXED_BASE_WINDOW_SIZE as u64 * j as u64 + 1, 0, 0, 0]) + acc + C::Scalar::from(2).pow([FIXED_BASE_WINDOW_SIZE as u64 * j as u64 + 1, 0, 0, 0]) }); window_table.push( (0..H) .map(|k| { // scalar = k * (2^3)^w - sum, where w = `num_windows - 1` let scalar = C::Scalar::from(k as u64) - * C::Scalar::from(H as u64).pow(&[(num_windows - 1) as u64, 0, 0, 0]) + * C::Scalar::from(H as u64).pow([(num_windows - 1) as u64, 0, 0, 0]) - sum; (base * scalar).to_affine() }) @@ -197,7 +197,7 @@ pub fn test_lagrange_coeffs(base: C, num_windows: usize) { // Compute the actual x-coordinate of the multiple [(k+2)*(8^w)]B. let point = base * C::Scalar::from(bits as u64 + 2) - * C::Scalar::from(H as u64).pow(&[idx as u64, 0, 0, 0]); + * C::Scalar::from(H as u64).pow([idx as u64, 0, 0, 0]); let x = *point.to_affine().coordinates().unwrap().x(); // Check that the interpolated x-coordinate matches the actual one. @@ -214,10 +214,10 @@ pub fn test_lagrange_coeffs(base: C, num_windows: usize) { // Compute the actual x-coordinate of the multiple [k * (8^84) - offset]B, // where offset = \sum_{j = 0}^{83} 2^{3j+1} let offset = (0..(num_windows - 1)).fold(C::Scalar::ZERO, |acc, w| { - acc + C::Scalar::from(2).pow(&[FIXED_BASE_WINDOW_SIZE as u64 * w as u64 + 1, 0, 0, 0]) + acc + C::Scalar::from(2).pow([FIXED_BASE_WINDOW_SIZE as u64 * w as u64 + 1, 0, 0, 0]) }); let scalar = C::Scalar::from(bits as u64) - * C::Scalar::from(H as u64).pow(&[(num_windows - 1) as u64, 0, 0, 0]) + * C::Scalar::from(H as u64).pow([(num_windows - 1) as u64, 0, 0, 0]) - offset; let point = base * scalar; let x = *point.to_affine().coordinates().unwrap().x(); diff --git a/halo2_gadgets/src/ecc/chip/mul_fixed.rs b/halo2_gadgets/src/ecc/chip/mul_fixed.rs index 0005a108bb..b22f2b66e7 100644 --- a/halo2_gadgets/src/ecc/chip/mul_fixed.rs +++ b/halo2_gadgets/src/ecc/chip/mul_fixed.rs @@ -372,7 +372,7 @@ impl> Config { base: &F, ) -> Result { // `scalar = [(k_w + 2) ⋅ 8^w] - let scalar = k.map(|k| (k + *TWO_SCALAR) * (*H_SCALAR).pow(&[w as u64, 0, 0, 0])); + let scalar = k.map(|k| (k + *TWO_SCALAR) * (*H_SCALAR).pow([w as u64, 0, 0, 0])); self.process_window::<_, NUM_WINDOWS>(region, offset, w, k_usize, scalar, base) } @@ -389,12 +389,12 @@ impl> Config { // offset_acc = \sum_{j = 0}^{NUM_WINDOWS - 2} 2^{FIXED_BASE_WINDOW_SIZE*j + 1} let offset_acc = (0..(NUM_WINDOWS - 1)).fold(pallas::Scalar::zero(), |acc, w| { - acc + (*TWO_SCALAR).pow(&[FIXED_BASE_WINDOW_SIZE as u64 * w as u64 + 1, 0, 0, 0]) + acc + (*TWO_SCALAR).pow([FIXED_BASE_WINDOW_SIZE as u64 * w as u64 + 1, 0, 0, 0]) }); // `scalar = [k * 8^(NUM_WINDOWS - 1) - offset_acc]`. let scalar = scalar.windows_field()[scalar.windows_field().len() - 1] - .map(|k| k * (*H_SCALAR).pow(&[(NUM_WINDOWS - 1) as u64, 0, 0, 0]) - offset_acc); + .map(|k| k * (*H_SCALAR).pow([(NUM_WINDOWS - 1) as u64, 0, 0, 0]) - offset_acc); self.process_window::<_, NUM_WINDOWS>( region, @@ -490,7 +490,7 @@ impl ScalarFixed { .by_vals() .take(FIXED_BASE_WINDOW_SIZE) .rev() - .fold(0, |acc, b| 2 * acc + if b { 1 } else { 0 }) + .fold(0, |acc, b| 2 * acc + usize::from(b)) }) }) .collect::>() diff --git a/halo2_gadgets/src/poseidon/pow5.rs b/halo2_gadgets/src/poseidon/pow5.rs index 7abd86329d..e8ea7abf69 100644 --- a/halo2_gadgets/src/poseidon/pow5.rs +++ b/halo2_gadgets/src/poseidon/pow5.rs @@ -444,7 +444,7 @@ impl Pow5State { .value() .map(|v| *v + config.round_constants[round][idx]) }); - let r: Value> = q.map(|q| q.map(|q| q.pow(&config.alpha))).collect(); + let r: Value> = q.map(|q| q.map(|q| q.pow(config.alpha))).collect(); let m = &config.m_reg; let state = m.iter().map(|m_i| { r.as_ref().map(|r| { @@ -470,7 +470,7 @@ impl Pow5State { let p: Value> = self.0.iter().map(|word| word.0.value().cloned()).collect(); let r: Value> = p.map(|p| { - let r_0 = (p[0] + config.round_constants[round][0]).pow(&config.alpha); + let r_0 = (p[0] + config.round_constants[round][0]).pow(config.alpha); let r_i = p[1..] .iter() .enumerate() @@ -510,7 +510,7 @@ impl Pow5State { } let r_mid: Value> = p_mid.map(|p| { - let r_0 = (p[0] + config.round_constants[round + 1][0]).pow(&config.alpha); + let r_0 = (p[0] + config.round_constants[round + 1][0]).pow(config.alpha); let r_i = p[1..] .iter() .enumerate() diff --git a/halo2_gadgets/src/poseidon/primitives/p128pow5t3.rs b/halo2_gadgets/src/poseidon/primitives/p128pow5t3.rs index c8d54d9afd..e31ce04263 100644 --- a/halo2_gadgets/src/poseidon/primitives/p128pow5t3.rs +++ b/halo2_gadgets/src/poseidon/primitives/p128pow5t3.rs @@ -22,7 +22,7 @@ impl Spec for P128Pow5T3 { } fn sbox(val: Fp) -> Fp { - val.pow_vartime(&[5]) + val.pow_vartime([5]) } fn secure_mds() -> usize { @@ -48,7 +48,7 @@ impl Spec for P128Pow5T3 { } fn sbox(val: Fq) -> Fq { - val.pow_vartime(&[5]) + val.pow_vartime([5]) } fn secure_mds() -> usize { diff --git a/halo2_proofs/benches/commit_zk.rs b/halo2_proofs/benches/commit_zk.rs new file mode 100644 index 0000000000..3496dbd4be --- /dev/null +++ b/halo2_proofs/benches/commit_zk.rs @@ -0,0 +1,64 @@ +extern crate criterion; + +use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion}; +use group::ff::Field; +use halo2_proofs::*; +use halo2curves::pasta::pallas::Scalar; +use rand_chacha::rand_core::RngCore; +use rand_chacha::ChaCha20Rng; +use rand_core::SeedableRng; +use rayon::{current_num_threads, prelude::*}; + +fn rand_poly_serial(mut rng: ChaCha20Rng, domain: usize) -> Vec { + // Sample a random polynomial of degree n - 1 + let mut random_poly = vec![Scalar::zero(); 1 << domain]; + for coeff in random_poly.iter_mut() { + *coeff = Scalar::random(&mut rng); + } + + random_poly +} + +fn rand_poly_par(mut rng: ChaCha20Rng, domain: usize) -> Vec { + // Sample a random polynomial of degree n - 1 + let n_threads = current_num_threads(); + let n = 1usize << domain; + let n_chunks = n_threads + usize::from(n % n_threads != 0); + let mut rand_vec = vec![Scalar::zero(); n]; + + let mut thread_seeds: Vec = (0..n_chunks) + .map(|_| { + let mut seed = [0u8; 32]; + rng.fill_bytes(&mut seed); + ChaCha20Rng::from_seed(seed) + }) + .collect(); + + thread_seeds + .par_iter_mut() + .zip_eq(rand_vec.par_chunks_mut(n / n_threads)) + .for_each(|(mut rng, chunk)| chunk.iter_mut().for_each(|v| *v = Scalar::random(&mut rng))); + + rand_vec +} + +fn bench_commit(c: &mut Criterion) { + let mut group = c.benchmark_group("Blinder_poly"); + let rand = ChaCha20Rng::from_seed([1u8; 32]); + for i in [ + 18usize, 19usize, 20usize, 21usize, 22usize, 23usize, 24usize, 25usize, + ] + .iter() + { + group.bench_with_input(BenchmarkId::new("serial", i), i, |b, i| { + b.iter(|| rand_poly_serial(rand.clone(), *i)) + }); + group.bench_with_input(BenchmarkId::new("parallel", i), i, |b, i| { + b.iter(|| rand_poly_par(rand.clone(), *i)) + }); + } + group.finish(); +} + +criterion_group!(benches, bench_commit); +criterion_main!(benches); diff --git a/halo2_proofs/src/circuit.rs b/halo2_proofs/src/circuit.rs index 508820f029..969e27d24c 100644 --- a/halo2_proofs/src/circuit.rs +++ b/halo2_proofs/src/circuit.rs @@ -14,6 +14,7 @@ pub use value::Value; pub mod floor_planner; pub use floor_planner::single_pass::SimpleFloorPlanner; +pub use floor_planner::single_pass::SimpleTableLayouter; pub mod layouter; diff --git a/halo2_proofs/src/circuit/floor_planner/single_pass.rs b/halo2_proofs/src/circuit/floor_planner/single_pass.rs index 96242b0b34..25b498470c 100644 --- a/halo2_proofs/src/circuit/floor_planner/single_pass.rs +++ b/halo2_proofs/src/circuit/floor_planner/single_pass.rs @@ -600,11 +600,12 @@ impl<'r, 'a, F: Field, CS: Assignment + 'a + SyncDeps> RegionLayouter /// witnesses or not. type DefaultTableValue = Option>>; -pub(crate) struct SimpleTableLayouter<'r, 'a, F: Field, CS: Assignment + 'a> { +/// A table layouter that can be used to assign values to a table. +pub struct SimpleTableLayouter<'r, 'a, F: Field, CS: Assignment + 'a> { cs: &'a mut CS, used_columns: &'r [TableColumn], - // maps from a fixed column to a pair (default value, vector saying which rows are assigned) - pub(crate) default_and_assigned: HashMap, Vec)>, + /// maps from a fixed column to a pair (default value, vector saying which rows are assigned) + pub default_and_assigned: HashMap, Vec)>, } impl<'r, 'a, F: Field, CS: Assignment + 'a> fmt::Debug for SimpleTableLayouter<'r, 'a, F, CS> { @@ -617,7 +618,8 @@ impl<'r, 'a, F: Field, CS: Assignment + 'a> fmt::Debug for SimpleTableLayoute } impl<'r, 'a, F: Field, CS: Assignment + 'a> SimpleTableLayouter<'r, 'a, F, CS> { - pub(crate) fn new(cs: &'a mut CS, used_columns: &'r [TableColumn]) -> Self { + /// Returns a new SimpleTableLayouter + pub fn new(cs: &'a mut CS, used_columns: &'r [TableColumn]) -> Self { SimpleTableLayouter { cs, used_columns, diff --git a/halo2_proofs/src/circuit/floor_planner/v1.rs b/halo2_proofs/src/circuit/floor_planner/v1.rs index 27beaafa47..5cff85f5ba 100644 --- a/halo2_proofs/src/circuit/floor_planner/v1.rs +++ b/halo2_proofs/src/circuit/floor_planner/v1.rs @@ -90,8 +90,8 @@ impl FloorPlanner for V1 { // - Determine how many rows our planned circuit will require. let first_unassigned_row = column_allocations - .iter() - .map(|(_, a)| a.unbounded_interval_start()) + .values() + .map(|a| a.unbounded_interval_start()) .max() .unwrap_or(0); diff --git a/halo2_proofs/src/dev.rs b/halo2_proofs/src/dev.rs index 879ffa2b86..c2b65cf8f8 100644 --- a/halo2_proofs/src/dev.rs +++ b/halo2_proofs/src/dev.rs @@ -1219,11 +1219,7 @@ impl<'a, F: FromUniformBytes<64> + Ord> MockProver<'a, F> { .flat_map(|(gate_index, gate)| { let blinding_rows = (self.n as usize - (self.cs.blinding_factors() + 1))..(self.n as usize); - (gate_row_ids - .clone() - .into_iter() - .chain(blinding_rows.into_iter())) - .flat_map(move |row| { + (gate_row_ids.clone().chain(blinding_rows.into_iter())).flat_map(move |row| { let row = row as i32 + n; gate.polynomials().iter().enumerate().filter_map( move |(poly_index, poly)| match poly.evaluate_lazy( @@ -1387,7 +1383,6 @@ impl<'a, F: FromUniformBytes<64> + Ord> MockProver<'a, F> { let mut inputs: Vec<(Vec<_>, usize)> = lookup_input_row_ids .clone() - .into_iter() .filter_map(|input_row| { let t = lookup .input_expressions @@ -1458,7 +1453,6 @@ impl<'a, F: FromUniformBytes<64> + Ord> MockProver<'a, F> { let mut input_rows: Vec<(Vec>, usize)> = self .usable_rows .clone() - .into_iter() .map(|input_row| { let t = shuffle .input_expressions @@ -1896,7 +1890,6 @@ impl<'a, F: FromUniformBytes<64> + Ord> MockProver<'a, F> { let mut input_rows: Vec<(Vec>, usize)> = self .usable_rows .clone() - .into_iter() .map(|input_row| { let t = shuffle .input_expressions diff --git a/halo2_proofs/src/plonk/assigned.rs b/halo2_proofs/src/plonk/assigned.rs index 46d527b915..919ddcdfb5 100644 --- a/halo2_proofs/src/plonk/assigned.rs +++ b/halo2_proofs/src/plonk/assigned.rs @@ -613,7 +613,7 @@ mod proptests { // Ensure that: // - we have at least one value to apply unary operators to. // - we can apply every binary operator pairwise sequentially. - cmp::max(if num_unary > 0 { 1 } else { 0 }, num_binary + 1)), + cmp::max(usize::from(num_unary > 0), num_binary + 1)), operations in arb_operators(num_unary, num_binary).prop_shuffle(), ) -> (Vec>, Vec) { (values, operations) diff --git a/halo2_proofs/src/plonk/circuit.rs b/halo2_proofs/src/plonk/circuit.rs index 144a53d956..7651da5e98 100644 --- a/halo2_proofs/src/plonk/circuit.rs +++ b/halo2_proofs/src/plonk/circuit.rs @@ -591,7 +591,8 @@ pub struct TableColumn { } impl TableColumn { - pub(crate) fn inner(&self) -> Column { + /// Returns inner column + pub fn inner(&self) -> Column { self.inner } } diff --git a/halo2_proofs/src/plonk/evaluation.rs b/halo2_proofs/src/plonk/evaluation.rs index d31f671003..2a41286594 100644 --- a/halo2_proofs/src/plonk/evaluation.rs +++ b/halo2_proofs/src/plonk/evaluation.rs @@ -451,8 +451,8 @@ impl Evaluator { // Permutation constraints parallelize(&mut values, |values, start| { - let mut beta_term = current_extended_omega - * omega.pow_vartime(&[start as u64, 0, 0, 0]); + let mut beta_term = + current_extended_omega * omega.pow_vartime([start as u64, 0, 0, 0]); for (i, value) in values.iter_mut().enumerate() { let idx = start + i; let r_next = get_rotation_idx(idx, 1, rot_scale, isize); diff --git a/halo2_proofs/src/plonk/lookup/prover.rs b/halo2_proofs/src/plonk/lookup/prover.rs index 0f0c85d7e3..6a5f883a03 100644 --- a/halo2_proofs/src/plonk/lookup/prover.rs +++ b/halo2_proofs/src/plonk/lookup/prover.rs @@ -443,7 +443,7 @@ fn permute_expression_pair<'params, C: CurveAffine, P: Params<'params, C>, R: Rn // Populate permuted table at unfilled rows with leftover table elements for (coeff, count) in leftover_table_map.iter() { for _ in 0..*count { - permuted_table_coeffs[repeated_input_rows.pop().unwrap() as usize] = *coeff; + permuted_table_coeffs[repeated_input_rows.pop().unwrap()] = *coeff; } } assert!(repeated_input_rows.is_empty()); diff --git a/halo2_proofs/src/plonk/permutation/keygen.rs b/halo2_proofs/src/plonk/permutation/keygen.rs index 1a4af204dc..0ae12df4a2 100644 --- a/halo2_proofs/src/plonk/permutation/keygen.rs +++ b/halo2_proofs/src/plonk/permutation/keygen.rs @@ -327,7 +327,7 @@ pub(crate) fn build_pk<'params, C: CurveAffine, P: Params<'params, C>>( { let omega = domain.get_omega(); parallelize(&mut omega_powers, |o, start| { - let mut cur = omega.pow_vartime(&[start as u64]); + let mut cur = omega.pow_vartime([start as u64]); for v in o.iter_mut() { *v = cur; cur *= ω @@ -339,7 +339,7 @@ pub(crate) fn build_pk<'params, C: CurveAffine, P: Params<'params, C>>( let mut deltaomega = vec![omega_powers; p.columns.len()]; { parallelize(&mut deltaomega, |o, start| { - let mut cur = C::Scalar::DELTA.pow_vartime(&[start as u64]); + let mut cur = C::Scalar::DELTA.pow_vartime([start as u64]); for omega_powers in o.iter_mut() { for v in omega_powers { *v *= &cur; @@ -403,7 +403,7 @@ pub(crate) fn build_vk<'params, C: CurveAffine, P: Params<'params, C>>( { let omega = domain.get_omega(); parallelize(&mut omega_powers, |o, start| { - let mut cur = omega.pow_vartime(&[start as u64]); + let mut cur = omega.pow_vartime([start as u64]); for v in o.iter_mut() { *v = cur; cur *= ω @@ -415,7 +415,7 @@ pub(crate) fn build_vk<'params, C: CurveAffine, P: Params<'params, C>>( let mut deltaomega = vec![omega_powers; p.columns.len()]; { parallelize(&mut deltaomega, |o, start| { - let mut cur = C::Scalar::DELTA.pow_vartime(&[start as u64]); + let mut cur = C::Scalar::DELTA.pow_vartime([start as u64]); for omega_powers in o.iter_mut() { for v in omega_powers { *v *= &cur; diff --git a/halo2_proofs/src/plonk/permutation/verifier.rs b/halo2_proofs/src/plonk/permutation/verifier.rs index ecdef3f59a..d0491b852f 100644 --- a/halo2_proofs/src/plonk/permutation/verifier.rs +++ b/halo2_proofs/src/plonk/permutation/verifier.rs @@ -183,7 +183,7 @@ impl Evaluated { let mut right = set.permutation_product_eval; let mut current_delta = (*beta * &*x) * &(::DELTA - .pow_vartime(&[(chunk_index * chunk_len) as u64])); + .pow_vartime([(chunk_index * chunk_len) as u64])); for eval in columns.iter().map(|&column| match column.column_type() { Any::Advice(_) => { advice_evals[vk.cs.get_any_query_index(column, Rotation::cur())] diff --git a/halo2_proofs/src/plonk/prover.rs b/halo2_proofs/src/plonk/prover.rs index 7ff5867138..4f8d9ec730 100644 --- a/halo2_proofs/src/plonk/prover.rs +++ b/halo2_proofs/src/plonk/prover.rs @@ -667,7 +667,7 @@ where let vanishing = vanishing.construct(params, domain, h_poly, &mut rng, transcript)?; let x: ChallengeX<_> = transcript.squeeze_challenge_scalar(); - let xn = x.pow(&[params.n() as u64, 0, 0, 0]); + let xn = x.pow([params.n(), 0, 0, 0]); if P::QUERY_INSTANCE { // Compute and hash instance evals for each circuit instance @@ -790,8 +790,8 @@ where }), ) .chain(permutation.open(pk, x)) - .chain(lookups.iter().flat_map(move |p| p.open(pk, x)).into_iter()) - .chain(shuffles.iter().flat_map(move |p| p.open(pk, x)).into_iter()) + .chain(lookups.iter().flat_map(move |p| p.open(pk, x))) + .chain(shuffles.iter().flat_map(move |p| p.open(pk, x))) }) .chain( pk.vk diff --git a/halo2_proofs/src/plonk/verifier.rs b/halo2_proofs/src/plonk/verifier.rs index b92c3dbef6..1e431be41b 100644 --- a/halo2_proofs/src/plonk/verifier.rs +++ b/halo2_proofs/src/plonk/verifier.rs @@ -188,7 +188,7 @@ where }) .collect::, _>>()? } else { - let xn = x.pow(&[params.n() as u64, 0, 0, 0]); + let xn = x.pow([params.n(), 0, 0, 0]); let (min_rotation, max_rotation) = vk.cs .instance_queries @@ -267,7 +267,7 @@ where // commitments open to the correct values. let vanishing = { // x^n - let xn = x.pow(&[params.n() as u64, 0, 0, 0]); + let xn = x.pow([params.n(), 0, 0, 0]); let blinding_factors = vk.cs.blinding_factors(); let l_evals = vk @@ -325,47 +325,39 @@ where gamma, x, )) - .chain( - lookups - .iter() - .zip(vk.cs.lookups.iter()) - .flat_map(move |(p, argument)| { - p.expressions( - l_0, - l_last, - l_blind, - argument, - theta, - beta, - gamma, - advice_evals, - fixed_evals, - instance_evals, - challenges, - ) - }) - .into_iter(), - ) - .chain( - shuffles - .iter() - .zip(vk.cs.shuffles.iter()) - .flat_map(move |(p, argument)| { - p.expressions( - l_0, - l_last, - l_blind, - argument, - theta, - gamma, - advice_evals, - fixed_evals, - instance_evals, - challenges, - ) - }) - .into_iter(), - ) + .chain(lookups.iter().zip(vk.cs.lookups.iter()).flat_map( + move |(p, argument)| { + p.expressions( + l_0, + l_last, + l_blind, + argument, + theta, + beta, + gamma, + advice_evals, + fixed_evals, + instance_evals, + challenges, + ) + }, + )) + .chain(shuffles.iter().zip(vk.cs.shuffles.iter()).flat_map( + move |(p, argument)| { + p.expressions( + l_0, + l_last, + l_blind, + argument, + theta, + gamma, + advice_evals, + fixed_evals, + instance_evals, + challenges, + ) + }, + )) }, ); @@ -419,18 +411,8 @@ where }, )) .chain(permutation.queries(vk, x)) - .chain( - lookups - .iter() - .flat_map(move |p| p.queries(vk, x)) - .into_iter(), - ) - .chain( - shuffles - .iter() - .flat_map(move |p| p.queries(vk, x)) - .into_iter(), - ) + .chain(lookups.iter().flat_map(move |p| p.queries(vk, x))) + .chain(shuffles.iter().flat_map(move |p| p.queries(vk, x))) }, ) .chain( diff --git a/halo2_proofs/src/poly/domain.rs b/halo2_proofs/src/poly/domain.rs index 63be6d654f..494e39a9da 100644 --- a/halo2_proofs/src/poly/domain.rs +++ b/halo2_proofs/src/poly/domain.rs @@ -88,8 +88,8 @@ impl> EvaluationDomain { { // Compute the evaluations of t(X) = X^n - 1 in the coset evaluation domain. // We don't have to compute all of them, because it will repeat. - let orig = F::ZETA.pow_vartime(&[n as u64, 0, 0, 0]); - let step = extended_omega.pow_vartime(&[n as u64, 0, 0, 0]); + let orig = F::ZETA.pow_vartime([n, 0, 0, 0]); + let step = extended_omega.pow_vartime([n, 0, 0, 0]); let mut cur = orig; loop { t_evaluations.push(cur); @@ -651,7 +651,7 @@ fn test_l_i() { let mut l = vec![]; let mut points = vec![]; for i in 0..8 { - points.push(domain.omega.pow(&[i, 0, 0, 0])); + points.push(domain.omega.pow([i, 0, 0, 0])); } for i in 0..8 { let mut l_i = vec![Scalar::ZERO; 8]; @@ -661,7 +661,7 @@ fn test_l_i() { } let x = Scalar::random(OsRng); - let xn = x.pow(&[8, 0, 0, 0]); + let xn = x.pow([8, 0, 0, 0]); let evaluations = domain.l_i_range(x, xn, -7..=7); for i in 0..8 { diff --git a/halo2_proofs/src/poly/kzg/commitment.rs b/halo2_proofs/src/poly/kzg/commitment.rs index 73b7510efc..e8f6bb1529 100644 --- a/halo2_proofs/src/poly/kzg/commitment.rs +++ b/halo2_proofs/src/poly/kzg/commitment.rs @@ -109,7 +109,7 @@ where } let n_inv = Option::::from(E::Scalar::from(n).invert()) .expect("inversion should be ok for n = 1<, { fn squeeze_challenge(&mut self) -> Challenge255 { - self.state.update(&[KECCAK256_PREFIX_CHALLENGE]); + self.state.update([KECCAK256_PREFIX_CHALLENGE]); let mut state_lo = self.state.clone(); let mut state_hi = self.state.clone(); - state_lo.update(&[KECCAK256_PREFIX_CHALLENGE_LO]); - state_hi.update(&[KECCAK256_PREFIX_CHALLENGE_HI]); + state_lo.update([KECCAK256_PREFIX_CHALLENGE_LO]); + state_hi.update([KECCAK256_PREFIX_CHALLENGE_HI]); let result_lo: [u8; 32] = state_lo.finalize().as_slice().try_into().unwrap(); let result_hi: [u8; 32] = state_hi.finalize().as_slice().try_into().unwrap(); @@ -270,7 +270,7 @@ where } fn common_point(&mut self, point: C) -> io::Result<()> { - self.state.update(&[KECCAK256_PREFIX_POINT]); + self.state.update([KECCAK256_PREFIX_POINT]); let coords: Coordinates = Option::from(point.coordinates()).ok_or_else(|| { io::Error::new( io::ErrorKind::Other, @@ -284,7 +284,7 @@ where } fn common_scalar(&mut self, scalar: C::Scalar) -> io::Result<()> { - self.state.update(&[KECCAK256_PREFIX_SCALAR]); + self.state.update([KECCAK256_PREFIX_SCALAR]); self.state.update(scalar.to_repr().as_ref()); Ok(()) @@ -427,12 +427,12 @@ where C::Scalar: FromUniformBytes<64>, { fn squeeze_challenge(&mut self) -> Challenge255 { - self.state.update(&[KECCAK256_PREFIX_CHALLENGE]); + self.state.update([KECCAK256_PREFIX_CHALLENGE]); let mut state_lo = self.state.clone(); let mut state_hi = self.state.clone(); - state_lo.update(&[KECCAK256_PREFIX_CHALLENGE_LO]); - state_hi.update(&[KECCAK256_PREFIX_CHALLENGE_HI]); + state_lo.update([KECCAK256_PREFIX_CHALLENGE_LO]); + state_hi.update([KECCAK256_PREFIX_CHALLENGE_HI]); let result_lo: [u8; 32] = state_lo.finalize().as_slice().try_into().unwrap(); let result_hi: [u8; 32] = state_hi.finalize().as_slice().try_into().unwrap(); @@ -444,7 +444,7 @@ where } fn common_point(&mut self, point: C) -> io::Result<()> { - self.state.update(&[KECCAK256_PREFIX_POINT]); + self.state.update([KECCAK256_PREFIX_POINT]); let coords: Coordinates = Option::from(point.coordinates()).ok_or_else(|| { io::Error::new( io::ErrorKind::Other, @@ -458,7 +458,7 @@ where } fn common_scalar(&mut self, scalar: C::Scalar) -> io::Result<()> { - self.state.update(&[KECCAK256_PREFIX_SCALAR]); + self.state.update([KECCAK256_PREFIX_SCALAR]); self.state.update(scalar.to_repr().as_ref()); Ok(()) diff --git a/rust-toolchain b/rust-toolchain index 9405730420..902c74186f 100644 --- a/rust-toolchain +++ b/rust-toolchain @@ -1 +1 @@ -1.64.0 +1.65.0