moving the value rather than reading the reference

Author: tonyfloatersu

pcs/src/orion/pcs_impl.rs

@@ -194,7 +194,7 @@ impl OrionPublicParams {
         let mut eval_row = vec![EvalF::ZERO; msg_size];
 
         let eq_col_coeffs = EqPolynomial::build_eq_x_r(&point[num_of_vars_in_msg..]);
-        luts.build(&eq_col_coeffs);
+        luts.build(eq_col_coeffs);
 
         packed_evals
             .chunks(row_num / OpenPackF::PACK_SIZE)
@@ -208,7 +208,7 @@ impl OrionPublicParams {
 
         proximity_rows.iter_mut().for_each(|row_buffer| {
             let random_coeffs = transcript.generate_challenge_field_elements(row_num);
-            luts.build(&random_coeffs);
+            luts.build(random_coeffs);
 
             packed_evals
                 .chunks(row_num / OpenPackF::PACK_SIZE)
@@ -326,9 +326,9 @@ impl OrionPublicParams {
 
         let eq_linear_combination = EqPolynomial::build_eq_x_r(&point[num_of_vars_in_msg..]);
         random_linear_combinations
-            .iter()
+            .into_iter()
             .zip(proof.proximity_rows.iter())
-            .chain(iter::once((&eq_linear_combination, &proof.eval_row)))
+            .chain(iter::once((eq_linear_combination, &proof.eval_row)))
             .all(|(rl, msg)| {
                 let codeword = match self.code_instance.encode(msg) {
                     Ok(c) => c,

pcs/src/orion/tests.rs

@@ -11,17 +11,18 @@ use crate::orion::{
     utils::{transpose_in_place, SubsetSumLUTs, TensorIOPPCS},
 };
 
-fn column_combination<F, PackF>(mat: &[F], combination: &[F]) -> Vec<F>
+fn column_combination<F, PackF>(mat: &[F], combination: Vec<F>) -> Vec<F>
 where
     F: Field,
     PackF: SimdField<Scalar = F>,
 {
     assert_eq!(combination.len() % PackF::PACK_SIZE, 0);
+    let combination_len = combination.len();
 
     let mut luts = SubsetSumLUTs::new(PackF::PACK_SIZE, combination.len() / PackF::PACK_SIZE);
     luts.build(combination);
 
-    mat.chunks(combination.len())
+    mat.chunks(combination_len)
         .map(|p_col| {
             let packed: Vec<_> = p_col.chunks(PackF::PACK_SIZE).map(PackF::pack).collect();
             luts.lookup_and_sum(&packed)
@@ -63,8 +64,8 @@ where
     drop(codeword_scratch);
 
     // NOTE: message and codeword matrix linear combination with weights
-    let msg_linear_combined = column_combination::<F, PackF>(&message_mat, &weights);
-    let codeword_linear_combined = column_combination::<F, PackF>(&codeword_mat, &weights);
+    let msg_linear_combined = column_combination::<F, PackF>(&message_mat, weights.clone());
+    let codeword_linear_combined = column_combination::<F, PackF>(&codeword_mat, weights);
 
     let codeword_computed = orion_code.encode(&msg_linear_combined).unwrap();
 

pcs/src/orion/utils.rs

@@ -77,9 +77,9 @@ pub trait TensorIOPPCS {
         // NOTE: use Ligero (AHIV22) or Avg-case dist to a code (BKS18)
         // version of avg case dist in unique decoding technique.
         // Here is the probability union bound
-        let code_len_over_f_bits = F::FIELD_SIZE - self.codeword_len().ilog2() as usize;
+        let single_run_soundness_bits = F::FIELD_SIZE - self.codeword_len().ilog2() as usize;
 
-        (soundness_bits as f64 / code_len_over_f_bits as f64).ceil() as usize
+        (soundness_bits as f64 / single_run_soundness_bits as f64).ceil() as usize
     }
 }
 
@@ -104,7 +104,7 @@ impl<F: Field> SubsetSumLUTs<F> {
     }
 
     #[inline]
-    pub fn build(&mut self, weights: &[F]) {
+    pub fn build(&mut self, weights: Vec<F>) {
         assert_eq!(weights.len() % self.entry_bits, 0);
         assert_eq!(weights.len() / self.entry_bits, self.tables.len());