fix poly degree 0 underflow

halo2_proofs/benches/fft.rs

@@ -1,8 +1,8 @@
 #[macro_use]
 extern crate criterion;
 
-use halo2_proofs::{arithmetic::best_fft, poly::EvaluationDomain};
 use group::ff::Field;
+use halo2_proofs::{arithmetic::best_fft, poly::EvaluationDomain};
 use halo2curves::bn256::Fr as Scalar;
 
 use criterion::{BenchmarkId, Criterion};
@@ -12,16 +12,18 @@
     let j = 5;
     let mut group = c.benchmark_group("fft");
     for k in 3..19 {
-        let domain = EvaluationDomain::new(j,k);
+        let domain = EvaluationDomain::new(j, k);
         let omega = domain.get_omega();
-        let l = 1<<k;
+        let l = 1 << k;
         let data = domain.get_fft_data(l);
 
         group.bench_function(BenchmarkId::new("k", k), |b| {
-            let mut a = (0..(1 << k)).map(|_| Scalar::random(OsRng)).collect::<Vec<_>>();
+            let mut a = (0..(1 << k))
+                .map(|_| Scalar::random(OsRng))
+                .collect::<Vec<_>>();
 
             b.iter(|| {
                 best_fft(&mut a, omega, k as u32, data, false);
             });
         });
     }

halo2_proofs/src/arithmetic.rs

@@ -210,7 +210,7 @@
 
 /// Convert coefficient bases group elements to lagrange basis by inverse FFT.
 pub fn g_to_lagrange<C: CurveAffine>(g_projective: Vec<C::Curve>, k: u32) -> Vec<C> {
     let n_inv = C::Scalar::TWO_INV.pow_vartime(&[k as u64, 0, 0, 0]);
     let omega = C::Scalar::ROOT_OF_UNITY;
     let mut omega_inv = C::Scalar::ROOT_OF_UNITY_INV;
     for _ in k..C::Scalar::S {
@@ -221,13 +221,7 @@
     let n = g_lagrange_projective.len();
     let fft_data = FFTData::new(n, omega, omega_inv);
 
-    best_fft(
-        &mut g_lagrange_projective,
-        omega_inv,
-        k,
-        &fft_data,
-        false,
-    );
+    best_fft(&mut g_lagrange_projective, omega_inv, k, &fft_data, false);
     parallelize(&mut g_lagrange_projective, |g, _| {
         for g in g.iter_mut() {
             *g *= n_inv;
@@ -265,7 +259,7 @@
             {
                 scope.spawn(move |_| {
                     let start = chunk_idx * chunk_size;
                     out[0] = evaluate(poly, point) * point.pow_vartime(&[start as u64, 0, 0, 0]);
                 });
             }
         });
@@ -316,7 +310,7 @@
 pub fn parallelize<T: Send, F: Fn(&mut [T], usize) + Send + Sync + Clone>(v: &mut [T], f: F) {
     let n = v.len();
     let num_threads = multicore::current_num_threads();
     let mut chunk = (n as usize) / num_threads;
     if chunk < num_threads {
         chunk = 1;
     }

halo2_proofs/src/fft.rs

@@ -25,7 +25,7 @@
             log_info("=== Parallel FFT ===".to_string());
             parallel::fft(a, omega, log_n, data, inverse)
         }
-        Ok(fft_impl) if fft_impl == "baseline"=> {
+        Ok(fft_impl) if fft_impl == "baseline" => {
             log_info("=== Baseline FFT ===".to_string());
             baseline::fft(a, omega, log_n, data, inverse)
         }
@@ -45,17 +45,17 @@
 
 #[cfg(test)]
 mod tests {
-    use std::{time::Instant, env::var};
+    use std::{env::var, time::Instant};
 
     use ff::Field;
     use halo2curves::bn256::Fr as Scalar;
     use rand_core::OsRng;
 
     use crate::{
+        arithmetic::{best_fft, eval_polynomial, lagrange_interpolate},
         fft::{self, recursive::FFTData},
         multicore,
-        arithmetic::{eval_polynomial, lagrange_interpolate, best_fft},
-        plonk::{start_measure, log_info, stop_measure},
+        plonk::{log_info, start_measure, stop_measure},
         poly::EvaluationDomain,
     };
 
@@ -67,7 +67,6 @@
             .expect("Cannot parse DEGREE env var as usize")
     }
 
-
     #[test]
     fn test_fft_parallel() {
         let max_log_n = 22;
@@ -126,18 +125,30 @@
         let num_threads = multicore::current_num_threads();
 
         let mut a = input.clone();
-        let l_a= a.len();
+        let l_a = a.len();
         let start = start_measure(format!("best fft {} ({})", a.len(), num_threads), false);
-        fft::baseline::fft(&mut a, domain.get_omega(), k, domain.get_fft_data(l_a), false);
+        fft::baseline::fft(
+            &mut a,
+            domain.get_omega(),
+            k,
+            domain.get_fft_data(l_a),
+            false,
+        );
         stop_measure(start);
 
         let mut b = input;
-        let l_b= b.len();
+        let l_b = b.len();
         let start = start_measure(
             format!("recursive fft {} ({})", a.len(), num_threads),
             false,
         );
-        fft::recursive::fft(&mut b, domain.get_omega(), k, domain.get_fft_data(l_b), false);
+        fft::recursive::fft(
+            &mut b,
+            domain.get_omega(),
+            k,
+            domain.get_fft_data(l_b),
+            false,
+        );
         stop_measure(start);
 
         for i in 0..n {
@@ -165,7 +176,13 @@
             format!("baseline  fft {} ({})", data_baseline.len(), num_threads),
             false,
         );
-        fft::baseline::fft(&mut data_baseline, domain.get_omega(), k, domain.get_fft_data(l_baseline), false);
+        fft::baseline::fft(
+            &mut data_baseline,
+            domain.get_omega(),
+            k,
+            domain.get_fft_data(l_baseline),
+            false,
+        );
         stop_measure(start);
 
         let mut data_parallel = input.clone();
@@ -174,7 +191,13 @@
             format!("parallel  fft {} ({})", data_parallel.len(), num_threads),
             false,
         );
-        fft::parallel::fft(&mut data_parallel, domain.get_omega(), k, domain.get_fft_data(l_parallel), false);
+        fft::parallel::fft(
+            &mut data_parallel,
+            domain.get_omega(),
+            k,
+            domain.get_fft_data(l_parallel),
+            false,
+        );
         stop_measure(start);
 
         let mut data_recursive = input;
@@ -215,21 +238,28 @@
         let num_threads = multicore::current_num_threads();
 
         let start = start_measure(format!("fft {} ({})", input.len(), num_threads), false);
-        fft::fft(&mut input, domain.get_omega(), k, domain.get_fft_data(l), false);
+        fft::fft(
+            &mut input,
+            domain.get_omega(),
+            k,
+            domain.get_fft_data(l),
+            false,
+        );
         stop_measure(start);
     }
 
     #[test]
     fn test_mem_leak() {
         let j = 1;
         let k = 3;
-        let domain = EvaluationDomain::new(j,k);
+        let domain = EvaluationDomain::new(j, k);
         let omega = domain.get_omega();
-        let l = 1<<k;
+        let l = 1 << k;
         let data = domain.get_fft_data(l);
-        let mut a = (0..(1 << k)).map(|_| Scalar::random(OsRng)).collect::<Vec<_>>();
+        let mut a = (0..(1 << k))
+            .map(|_| Scalar::random(OsRng))
+            .collect::<Vec<_>>();
 
         best_fft(&mut a, omega, k as u32, data, false);
-}
-
+    }
 }

halo2_proofs/src/fft/parallel.rs

@@ -21,7 +21,7 @@
 fn best_fft_opt<Scalar: Field, G: FftGroup<Scalar>>(a: &mut [G], omega: Scalar, log_n: u32) {
     let threads = multicore::current_num_threads();
     let log_split = log2_floor(threads) as usize;
     let n = a.len() as usize;
     let sub_n = n >> log_split;
     let split_m = 1 << log_split;
 
@@ -39,13 +39,13 @@
     for k in 0..n as usize {
         let rk = arithmetic::bitreverse(k, log_n as usize);
         if k < rk {
             a.swap(rk as usize, k as usize);
         }
     }
 
     let mut m = 1;
     for _ in 0..log_n {
         let w_m: Scalar = omega.pow_vartime(&[u64::from(n / (2 * m)), 0, 0, 0]);
 
         let mut k = 0;
         while k < n {
@@ -120,12 +120,12 @@
     let tmp_filler_val = tmp[0];
     let mut t1 = vec![tmp_filler_val; split_m];
     for i in 0..split_m {
-        t1[arithmetic::bitreverse(i, log_split)] = a[(i * sub_n + sub_fft_offset)];
+        t1[arithmetic::bitreverse(i, log_split)] = a[i * sub_n + sub_fft_offset];
     }
     serial_split_fft(&mut t1, twiddle_lut, sub_n, log_split as u32);
 
     let sparse_degree = SPARSE_TWIDDLE_DEGREE;
     let omega_idx = sub_fft_offset as usize;
     let low_idx = omega_idx % (1 << sparse_degree);
     let high_idx = omega_idx >> sparse_degree;
     let mut omega = twiddle_lut[low_idx];
@@ -154,7 +154,7 @@
     if is_lut_len_large {
         let mut twiddle_lut = vec![F::ZERO; (1 << log_n) as usize];
         parallelize(&mut twiddle_lut, |twiddle_lut, start| {
             let mut w_n = omega.pow_vartime(&[start as u64, 0, 0, 0]);
             for twiddle_lut in twiddle_lut.iter_mut() {
                 *twiddle_lut = w_n;
                 w_n = w_n * omega;
@@ -166,22 +166,22 @@
     // sparse
     let low_degree_lut_len = 1 << sparse_degree;
     let high_degree_lut_len = 1 << (log_n - sparse_degree - without_last_level as u32);
     let mut twiddle_lut = vec![F::ZERO; (low_degree_lut_len + high_degree_lut_len) as usize];
     parallelize(
         &mut twiddle_lut[..low_degree_lut_len],
         |twiddle_lut, start| {
             let mut w_n = omega.pow_vartime(&[start as u64, 0, 0, 0]);
             for twiddle_lut in twiddle_lut.iter_mut() {
                 *twiddle_lut = w_n;
                 w_n = w_n * omega;
             }
         },
     );
     let high_degree_omega = omega.pow_vartime(&[(1 << sparse_degree) as u64, 0, 0, 0]);
     parallelize(
         &mut twiddle_lut[low_degree_lut_len..],
         |twiddle_lut, start| {
             let mut w_n = high_degree_omega.pow_vartime(&[start as u64, 0, 0, 0]);
             for twiddle_lut in twiddle_lut.iter_mut() {
                 *twiddle_lut = w_n;
                 w_n = w_n * high_degree_omega;
@@ -193,12 +193,12 @@
 
 /// The parallel implementation
 fn parallel_fft<Scalar: Field, G: FftGroup<Scalar>>(a: &mut [G], omega: Scalar, log_n: u32) {
     let n = a.len() as usize;
     assert_eq!(n, 1 << log_n);
 
     let log_split = log2_floor(multicore::current_num_threads()) as usize;
     let split_m = 1 << log_split;
     let sub_n = n >> log_split as usize;
     let twiddle_lut = generate_twiddle_lookup_table(omega, log_n, SPARSE_TWIDDLE_DEGREE, true);
 
     // split fft
@@ -229,7 +229,7 @@
     });
 
     // sub fft
     let new_omega = omega.pow_vartime(&[split_m as u64, 0, 0, 0]);
     multicore::scope(|scope| {
         for a in a.chunks_mut(sub_n) {
             scope.spawn(move |_| {
@@ -259,9 +259,9 @@
 fn parallelize<T: Send, F: Fn(&mut [T], usize) + Send + Sync + Clone>(v: &mut [T], f: F) {
     let n = v.len();
     let num_threads = multicore::current_num_threads();
     let mut chunk = (n as usize) / num_threads;
     if chunk < num_threads {
         chunk = n as usize;
     }
 
     multicore::scope(|scope| {

halo2_proofs/src/fft/recursive.rs

@@ -84,7 +84,7 @@
 impl<F: arithmetic::Field> FFTData<F> {
     /// Create FFT data
     pub fn new(n: usize, omega: F, omega_inv: F) -> Self {
         let stages = get_stages(n as usize, vec![]);
         let mut f_twiddles = vec![];
         let mut inv_twiddles = vec![];
         let mut scratch = vec![F::ZERO; n];
@@ -104,7 +104,7 @@
             // Twiddles
             parallelize(twiddles, |twiddles, start| {
                 let w_m = o;
                 let mut w = o.pow_vartime(&[start as u64, 0, 0, 0]);
                 for value in twiddles.iter_mut() {
                     *value = w;
                     w *= w_m;
@@ -145,7 +145,9 @@
     }
 
     /// Return private field `n`
-    pub fn get_n(&self) -> usize { self.n }
+    pub fn get_n(&self) -> usize {
+        self.n
+    }
 }
 
 /// Radix 2 butterfly
@@ -180,9 +182,9 @@
     num_threads: usize,
 ) {
     let n = out.len();
     let mut chunk = (n as usize) / num_threads;
     if chunk < num_threads {
         chunk = n as usize;
     }
 
     multicore::scope(|scope| {
@@ -273,9 +275,9 @@
     let j = twiddles[twiddles.len() - 1];
 
     let n = out.len();
     let mut chunk = (n as usize) / num_threads;
     if chunk < num_threads {
         chunk = n as usize;
     }
     multicore::scope(|scope| {
         //let mut parts: Vec<&mut [F]> = out.chunks_mut(4).collect();
@@ -436,9 +438,9 @@
     f: F,
 ) {
     let n = v.len();
     let mut chunk = (n as usize) / num_threads;
     if chunk < num_threads {
         chunk = n as usize;
     }
 
     multicore::scope(|scope| {

halo2_proofs/src/plonk/evaluation.rs

@@ -434,7 +434,7 @@
             .enumerate()
             .take(num_clusters)
         {
-             cluster.resize(1 << cluster_idx, domain.empty_lagrange());
+            cluster.resize(1 << cluster_idx, domain.empty_lagrange());
         }
 
         // Calculate the quotient polynomial for each part
@@ -539,7 +539,6 @@
                 constraint_idx += self.num_custom_gate_constraints;
                 stop_measure(start);
 
-
                 // Permutations
                 let start = start_measure("permutations", false);
                 let sets = &permutation.sets;
@@ -692,7 +691,7 @@
                                 [compute_part_idx_in_cluster(part_idx, running_prod_cluster)],
                             |values, start| {
                                 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);
@@ -976,10 +975,15 @@
     }
 
     fn compute_cluster_idx(degree: usize, max_cluster_idx: usize) -> usize {
-        let mut idx = (31 - (degree as u32).leading_zeros()) as usize;
-        if 1 << idx < degree {
-            idx = idx + 1;
+        let mut idx = 0;
+        if degree != 0 {
+            // same as unstable degree.ilog()
+            idx = (degree as f32).log2().floor() as usize;
+            if !degree.is_power_of_two() {
+                idx += 1;
+            }
         }
+
         std::cmp::min(max_cluster_idx, idx)
     }
 }
@@ -1245,3 +1249,23 @@
     });
     values
 }
+
+mod test {
+    use halo2curves::{secp256k1::Secp256k1Affine, CurveAffine};
+
+    #[test]
+    #[should_panic(expected = "attempt to subtract with overflow")]
+    fn compute_cluster_idx_underflow() {
+        let degree = 0;
+        let idx = (31 - (degree as u32).leading_zeros()) as usize;
+        println!("idx = {}", idx);
+    }
+
+    #[test]
+    fn compute_cluster_idx_new() {
+        for degree in 0..17usize {
+            let idx = super::Evaluator::<Secp256k1Affine>::compute_cluster_idx(degree, 10);
+            println!("degree = {}, idx = {}", degree, idx);
+        }
+    }
+}

halo2_proofs/src/plonk/permutation.rs

@@ -159,7 +159,6 @@ where
 impl<C: CurveAffine> ProvingKey<C> {
     /// Gets the total number of bytes in the serialization of `self`
     pub(super) fn bytes_length(&self) -> usize {
-        polynomial_slice_byte_length(&self.permutations)
-            + polynomial_slice_byte_length(&self.polys)
+        polynomial_slice_byte_length(&self.permutations) + polynomial_slice_byte_length(&self.polys)
     }
 }

halo2_proofs/src/plonk/prover.rs

@@ -19,7 +19,7 @@
     ChallengeY, Error, Expression, ProvingKey,
 };
 use crate::arithmetic::MULTIEXP_TOTAL_TIME;
-use crate::plonk::{start_measure, stop_measure, log_info};
+use crate::plonk::{log_info, start_measure, stop_measure};
 use crate::poly::FFT_TOTAL_TIME;
 use crate::{
     arithmetic::{eval_polynomial, CurveAffine},
@@ -551,7 +551,7 @@
     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 start = start_measure("instance eval_polynomial", false);
     if P::QUERY_INSTANCE {
@@ -697,7 +697,10 @@
     #[allow(unsafe_code)]
     unsafe {
         log_info(format!("·FFT: {}s", (FFT_TOTAL_TIME as f32) / 1000000.0));
-        log_info(format!("·MultiExps: {}s", (MULTIEXP_TOTAL_TIME as f32) / 1000000.0));
+        log_info(format!(
+            "·MultiExps: {}s",
+            (MULTIEXP_TOTAL_TIME as f32) / 1000000.0
+        ));
     }
 
     proof

halo2_proofs/src/poly/domain.rs

@@ -99,8 +99,8 @@
         {
             // 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 mut cur = orig;
             loop {
                 t_evaluations.push(cur);
@@ -192,7 +192,7 @@
         &self,
         values: Vec<Polynomial<F, LagrangeCoeff>>,
     ) -> Polynomial<F, ExtendedLagrangeCoeff> {
         assert_eq!(values.len(), (self.extended_len() >> self.k) as usize);
         assert_eq!(values[0].len(), self.n as usize);
 
         // transpose the values in parallel
@@ -474,15 +474,21 @@
 
             parallelize(&mut result[0..(self.n << i) as usize], |result, start| {
                 for (other, current) in result.iter_mut().zip(a_poly[start..].iter()) {
-                    * other += current;
+                    *other += current;
                 }
             });
         }
         let data = self.get_fft_data(result.len());
-        best_fft(&mut result, self.extended_omega, self.extended_k, data, false);
+        best_fft(
+            &mut result,
+            self.extended_omega,
+            self.extended_k,
+            data,
+            false,
+        );
         parallelize(&mut result_poly.values, |values, start| {
             for (value, other) in values.iter_mut().zip(result[start..].iter()) {
-                * value += other;
+                *value += other;
             }
         });
         result_poly
@@ -541,9 +547,9 @@
     ///
     fn distribute_powers(&self, a: &mut [F], c: F) {
         parallelize(a, |a, index| {
             let mut c_power = c.pow_vartime(&[index as u64, 0, 0, 0]);
             for a in a {
-                * a *= c_power;
+                *a *= c_power;
                 c_power = c_power * c;
             }
         });
@@ -607,11 +613,11 @@
     pub fn rotate_omega(&self, value: F, rotation: Rotation) -> F {
         let mut point = value;
         if rotation.0 >= 0 {
             point *= &self.get_omega().pow_vartime(&[rotation.0 as u64]);
         } else {
             point *= &self
                 .get_omega_inv()
                 .pow_vartime(&[(rotation.0 as i64).unsigned_abs()]);
         }
         point
     }
@@ -687,7 +693,9 @@
     }
 
     /// Get the private field `n`
-    pub fn get_n(&self) -> u64 { self.n }
+    pub fn get_n(&self) -> u64 {
+        self.n
+    }
 
     /// Get the private `fft_data`
     pub fn get_fft_data(&self, l: usize) -> &FFTData<F> {
@@ -709,10 +717,7 @@
 }
 
 #[cfg(test)]
-use std::{
-    env,
-    time::Instant,
-};
+use std::{env, time::Instant};
 
 #[test]
 fn test_rotate() {
@@ -766,7 +771,7 @@
     let mut l = vec![];
     let mut points = vec![];
     for i in 0..8 {
         points.push(domain.omega.pow(&[i, 0, 0, 0]));
     }
     for i in 0..8 {
         let mut l_i = vec![Scalar::zero(); 8];
@@ -776,7 +781,7 @@
     }
 
     let x = Scalar::random(OsRng);
     let xn = x.pow(&[8, 0, 0, 0]);
 
     let evaluations = domain.l_i_range(x, xn, -7..=7);
     for i in 0..8 {
@@ -872,9 +877,15 @@
             .collect();
         poly_lagrange_vecs.push(transposed_poly);
         // poly under extended representation.
         poly.resize(domain.extended_len() as usize, Scalar::zero());
         let data = domain.get_fft_data(poly.len());
-        best_fft(&mut poly, domain.extended_omega, domain.extended_k, data, false);
+        best_fft(
+            &mut poly,
+            domain.extended_omega,
+            domain.extended_k,
+            data,
+            false,
+        );
         let poly = {
             let mut p = domain.empty_extended();
             p.values = poly;
@@ -924,9 +935,15 @@
             .collect();
         poly_lagrange_vecs.push(transposed_poly);
         // poly under extended representation.
         poly.resize(domain.extended_len() as usize, Scalar::zero());
         let data = domain.get_fft_data(poly.len());
-        best_fft(&mut poly, domain.extended_omega, domain.extended_k, data, false);
+        best_fft(
+            &mut poly,
+            domain.extended_omega,
+            domain.extended_k,
+            data,
+            false,
+        );
         let poly = {
             let mut p = domain.empty_extended();
             p.values = poly;

rust-toolchain

@@ -1 +1 @@
-1.64.0
+1.66.0