From 50d8fa0fee0db31aef4aadf6a9ebfb7a4731ce3b Mon Sep 17 00:00:00 2001 From: ashWhiteHat Date: Tue, 14 Nov 2023 11:36:17 +0900 Subject: [PATCH] refactor: improve visibilities --- src/r1csinstance.rs | 23 ++++---- src/sparse_mlpoly.rs | 128 ++++++++++++++++++++----------------------- 2 files changed, 69 insertions(+), 82 deletions(-) diff --git a/src/r1csinstance.rs b/src/r1csinstance.rs index e4bb992f..80499c4e 100644 --- a/src/r1csinstance.rs +++ b/src/r1csinstance.rs @@ -110,21 +110,24 @@ impl R1CSInstance { let num_poly_vars_x = num_cons.log_2(); let num_poly_vars_y = (2 * num_vars).log_2(); - let mat_A = (0..A.len()) - .map(|i| SparseMatEntry::new(A[i].0, A[i].1, A[i].2)) + let mat_A = A + .iter() + .map(|(row, col, val)| SparseMatEntry::new(*row, *col, *val)) .collect::>(); - let mat_B = (0..B.len()) - .map(|i| SparseMatEntry::new(B[i].0, B[i].1, B[i].2)) + let mat_B = B + .iter() + .map(|(row, col, val)| SparseMatEntry::new(*row, *col, *val)) .collect::>(); - let mat_C = (0..C.len()) - .map(|i| SparseMatEntry::new(C[i].0, C[i].1, C[i].2)) + let mat_C = C + .iter() + .map(|(row, col, val)| SparseMatEntry::new(*row, *col, *val)) .collect::>(); let poly_A = SparseMatPolynomial::new(num_poly_vars_x, num_poly_vars_y, mat_A); let poly_B = SparseMatPolynomial::new(num_poly_vars_x, num_poly_vars_y, mat_B); let poly_C = SparseMatPolynomial::new(num_poly_vars_x, num_poly_vars_y, mat_C); - R1CSInstance { + Self { num_cons, num_vars, num_inputs, @@ -257,11 +260,7 @@ impl R1CSInstance { assert_eq!(Az.len(), self.num_cons); assert_eq!(Bz.len(), self.num_cons); assert_eq!(Cz.len(), self.num_cons); - let res: usize = (0..self.num_cons) - .map(|i| usize::from(Az[i] * Bz[i] != Cz[i])) - .sum(); - - res == 0 + (0..self.num_cons).all(|i| Az[i] * Bz[i] == Cz[i]) } pub fn multiply_vec( diff --git a/src/sparse_mlpoly.rs b/src/sparse_mlpoly.rs index 1e10f6a3..57375c1c 100644 --- a/src/sparse_mlpoly.rs +++ b/src/sparse_mlpoly.rs @@ -51,18 +51,14 @@ impl Derefs { pub fn new(row_ops_val: Vec, col_ops_val: Vec) -> Self { assert_eq!(row_ops_val.len(), col_ops_val.len()); - let derefs = { - // combine all polynomials into a single polynomial (used below to produce a single commitment) - let comb = DensePolynomial::merge(row_ops_val.iter().chain(col_ops_val.iter())); - - Derefs { - row_ops_val, - col_ops_val, - comb, - } - }; + // combine all polynomials into a single polynomial (used below to produce a single commitment) + let comb = DensePolynomial::merge(row_ops_val.iter().chain(col_ops_val.iter())); - derefs + Derefs { + row_ops_val, + col_ops_val, + comb, + } } pub fn commit(&self, gens: &PolyCommitmentGens) -> DerefsCommitment { @@ -343,7 +339,7 @@ impl AppendToTranscript for SparseMatPolyCommitment { impl SparseMatPolynomial { pub fn new(num_vars_x: usize, num_vars_y: usize, M: Vec) -> Self { - SparseMatPolynomial { + Self { num_vars_x, num_vars_y, M, @@ -430,13 +426,10 @@ impl SparseMatPolynomial { assert_eq!(self.num_vars_x.pow2(), eval_table_rx.len()); assert_eq!(self.num_vars_y.pow2(), eval_table_ry.len()); - (0..self.M.len()) - .map(|i| { - let row = self.M[i].row; - let col = self.M[i].col; - let val = &self.M[i].val; - eval_table_rx[row] * eval_table_ry[col] * val - }) + self + .M + .iter() + .map(|SparseMatEntry { row, col, val }| eval_table_rx[*row] * eval_table_ry[*col] * val) .sum() } @@ -448,25 +441,22 @@ impl SparseMatPolynomial { let eval_table_rx = EqPolynomial::new(rx.to_vec()).evals(); let eval_table_ry = EqPolynomial::new(ry.to_vec()).evals(); - (0..polys.len()) - .map(|i| polys[i].evaluate_with_tables(&eval_table_rx, &eval_table_ry)) + polys + .iter() + .map(|poly| poly.evaluate_with_tables(&eval_table_rx, &eval_table_ry)) .collect::>() } pub fn multiply_vec(&self, num_rows: usize, num_cols: usize, z: &[Scalar]) -> Vec { assert_eq!(z.len(), num_cols); - (0..self.M.len()) - .map(|i| { - let row = self.M[i].row; - let col = self.M[i].col; - let val = &self.M[i].val; - (row, val * z[col]) - }) - .fold(vec![Scalar::zero(); num_rows], |mut Mz, (r, v)| { - Mz[r] += v; + self.M.iter().fold( + vec![Scalar::zero(); num_rows], + |mut Mz, SparseMatEntry { row, col, val }| { + Mz[*row] += val * z[*col]; Mz - }) + }, + ) } pub fn compute_eval_table_sparse( @@ -477,13 +467,13 @@ impl SparseMatPolynomial { ) -> Vec { assert_eq!(rx.len(), num_rows); - let mut M_evals: Vec = vec![Scalar::zero(); num_cols]; - - for i in 0..self.M.len() { - let entry = &self.M[i]; - M_evals[entry.col] += rx[entry.row] * entry.val; - } - M_evals + self.M.iter().fold( + vec![Scalar::zero(); num_cols], + |mut M_evals, SparseMatEntry { row, col, val }| { + M_evals[*col] += rx[*row] * val; + M_evals + }, + ) } pub fn multi_commit( @@ -706,18 +696,18 @@ impl HashLayerProof { let (rand_mem, rand_ops) = rand; // decommit ops-addr at rand_ops - let mut eval_ops_addr_vec: Vec = Vec::new(); - for i in 0..addr_timestamps.ops_addr.len() { - let eval_ops_addr = addr_timestamps.ops_addr[i].evaluate(rand_ops); - eval_ops_addr_vec.push(eval_ops_addr); - } + let eval_ops_addr_vec = addr_timestamps + .ops_addr + .iter() + .map(|addr| addr.evaluate(rand_ops)) + .collect(); // decommit read_ts at rand_ops - let mut eval_read_ts_vec: Vec = Vec::new(); - for i in 0..addr_timestamps.read_ts.len() { - let eval_read_ts = addr_timestamps.read_ts[i].evaluate(rand_ops); - eval_read_ts_vec.push(eval_read_ts); - } + let eval_read_ts_vec = addr_timestamps + .read_ts + .iter() + .map(|addr| addr.evaluate(rand_ops)) + .collect(); // decommit audit-ts at rand_mem let eval_audit_ts = addr_timestamps.audit_ts.evaluate(rand_mem); @@ -738,11 +728,15 @@ impl HashLayerProof { let (rand_mem, rand_ops) = rand; // decommit derefs at rand_ops - let eval_row_ops_val = (0..derefs.row_ops_val.len()) - .map(|i| derefs.row_ops_val[i].evaluate(rand_ops)) + let eval_row_ops_val = derefs + .row_ops_val + .iter() + .map(|row| row.evaluate(rand_ops)) .collect::>(); - let eval_col_ops_val = (0..derefs.col_ops_val.len()) - .map(|i| derefs.col_ops_val[i].evaluate(rand_ops)) + let eval_col_ops_val = derefs + .col_ops_val + .iter() + .map(|col| col.evaluate(rand_ops)) .collect::>(); let proof_derefs = DerefsEvalProof::prove( derefs, @@ -1581,15 +1575,9 @@ impl SparsePolynomial { fn compute_chi(a: &[bool], r: &[Scalar]) -> Scalar { assert_eq!(a.len(), r.len()); - let mut chi_i = Scalar::one(); - for j in 0..r.len() { - if a[j] { - chi_i *= r[j]; - } else { - chi_i *= Scalar::one() - r[j]; - } - } - chi_i + a.iter().zip(r.iter()).fold(Scalar::one(), |sum, (a, r)| { + sum * if *a { *r } else { Scalar::one() - r } + }) } // Takes O(n log n). TODO: do this in O(n) where n is the number of entries in Z @@ -1620,15 +1608,15 @@ mod tests { let num_vars_x: usize = num_rows.log_2(); let num_vars_y: usize = num_cols.log_2(); - let mut M: Vec = Vec::new(); - - for _i in 0..num_nz_entries { - M.push(SparseMatEntry::new( - (csprng.next_u64() % (num_rows as u64)) as usize, - (csprng.next_u64() % (num_cols as u64)) as usize, - Scalar::random(&mut csprng), - )); - } + let M = (0..num_nz_entries) + .map(|_i| { + SparseMatEntry::new( + (csprng.next_u64() % (num_rows as u64)) as usize, + (csprng.next_u64() % (num_cols as u64)) as usize, + Scalar::random(&mut csprng), + ) + }) + .collect(); let poly_M = SparseMatPolynomial::new(num_vars_x, num_vars_y, M); let gens = SparseMatPolyCommitmentGens::new(