Adopt a CSR Representation for Sparse Matrices (Arecibo backport) (#232)

* CSR Representation for Sparse Matrices (#38)

* add csr feature

* remove feature

remove conversions

* cleanup

* avoid iter() and go row-by-row

* cleanup and apply suggestions

* add R1CSShape padding test

* add more suggestions

* refactor: Refactor sparse namespace and SparseMatrix visibility

- Modifies the visibility of `sparse` module from public to private
- Makes `SparseMatrix` class within `sparse` module public
- Updates `SparseMatrix` import across several files to accommodate visibility changes

* fix: define matrix inputs in idiomatic Nova style

* chore: Refactor dependencies for r1cs module

- Shifted `proptest` and `rand` dependencies to dev-dependencies in `Cargo.toml`
- Introduced testing flag for `util` module under `r1cs`

---------

Co-authored-by: Hanting Zhang <[email protected]>

Author: huitseeker

Cargo.toml

@@ -45,13 +45,13 @@ getrandom = { version = "0.2.0", default-features = false, features = ["js"] }
 
 [dev-dependencies]
 criterion = { version = "0.4", features = ["html_reports"] }
-rand = "0.8.4"
 flate2 = "1.0"
 hex = "0.4.3"
 pprof = { version = "0.11" }
 cfg-if = "1.0.0"
 sha2 = "0.10.7"
 proptest = "1.2.0"
+rand = "0.8.5"
 
 [[bench]]
 name = "recursive-snark"

examples/minroot.rs

@@ -129,12 +129,13 @@ where
   }
 }
 
+/// cargo run --release --example minroot
 fn main() {
   println!("Nova-based VDF with MinRoot delay function");
   println!("=========================================================");
 
   let num_steps = 10;
-  for num_iters_per_step in [1024, 2048, 4096, 8192, 16384, 32768, 65535] {
+  for num_iters_per_step in [1024, 2048, 4096, 8192, 16384, 32768, 65536] {
     // number of iterations of MinRoot per Nova's recursive step
     let circuit_primary = MinRootCircuit {
       seq: vec![

src/bellpepper/r1cs.rs

@@ -5,7 +5,7 @@
 use super::{shape_cs::ShapeCS, solver::SatisfyingAssignment, test_shape_cs::TestShapeCS};
 use crate::{
   errors::NovaError,
-  r1cs::{R1CSInstance, R1CSShape, R1CSWitness, R1CS},
+  r1cs::{R1CSInstance, R1CSShape, R1CSWitness, SparseMatrix, R1CS},
   traits::Group,
   CommitmentKey,
 };
@@ -52,13 +52,12 @@ macro_rules! impl_nova_shape {
       G::Scalar: PrimeField,
     {
       fn r1cs_shape(&self) -> (R1CSShape<G>, CommitmentKey<G>) {
-        let mut A: Vec<(usize, usize, G::Scalar)> = Vec::new();
-        let mut B: Vec<(usize, usize, G::Scalar)> = Vec::new();
-        let mut C: Vec<(usize, usize, G::Scalar)> = Vec::new();
+        let mut A = SparseMatrix::<G::Scalar>::empty();
+        let mut B = SparseMatrix::<G::Scalar>::empty();
+        let mut C = SparseMatrix::<G::Scalar>::empty();
 
         let mut num_cons_added = 0;
         let mut X = (&mut A, &mut B, &mut C, &mut num_cons_added);
-
         let num_inputs = self.num_inputs();
         let num_constraints = self.num_constraints();
         let num_vars = self.num_aux();
@@ -72,15 +71,14 @@ macro_rules! impl_nova_shape {
             &constraint.2,
           );
         }
-
         assert_eq!(num_cons_added, num_constraints);
 
-        let S: R1CSShape<G> = {
-          // Don't count One as an input for shape's purposes.
-          let res = R1CSShape::new(num_constraints, num_vars, num_inputs - 1, &A, &B, &C);
-          res.unwrap()
-        };
+        A.cols = num_vars + num_inputs;
+        B.cols = num_vars + num_inputs;
+        C.cols = num_vars + num_inputs;
 
+        // Don't count One as an input for shape's purposes.
+        let S = R1CSShape::new(num_constraints, num_vars, num_inputs - 1, A, B, C).unwrap();
         let ck = R1CS::<G>::commitment_key(&S);
 
         (S, ck)
@@ -94,9 +92,9 @@ impl_nova_shape!(TestShapeCS);
 
 fn add_constraint<S: PrimeField>(
   X: &mut (
-    &mut Vec<(usize, usize, S)>,
-    &mut Vec<(usize, usize, S)>,
-    &mut Vec<(usize, usize, S)>,
+    &mut SparseMatrix<S>,
+    &mut SparseMatrix<S>,
+    &mut SparseMatrix<S>,
     &mut usize,
   ),
   num_vars: usize,
@@ -106,29 +104,40 @@ fn add_constraint<S: PrimeField>(
 ) {
   let (A, B, C, nn) = X;
   let n = **nn;
-  let one = S::ONE;
+  assert_eq!(n + 1, A.indptr.len(), "A: invalid shape");
+  assert_eq!(n + 1, B.indptr.len(), "B: invalid shape");
+  assert_eq!(n + 1, C.indptr.len(), "C: invalid shape");
 
-  let add_constraint_component = |index: Index, coeff, V: &mut Vec<_>| {
+  let add_constraint_component = |index: Index, coeff: &S, M: &mut SparseMatrix<S>| {
     match index {
       Index::Input(idx) => {
         // Inputs come last, with input 0, reprsenting 'one',
         // at position num_vars within the witness vector.
-        let i = idx + num_vars;
-        V.push((n, i, one * coeff))
+        let idx = idx + num_vars;
+        M.data.push(*coeff);
+        M.indices.push(idx);
+      }
+      Index::Aux(idx) => {
+        M.data.push(*coeff);
+        M.indices.push(idx);
       }
-      Index::Aux(idx) => V.push((n, idx, one * coeff)),
     }
   };
 
   for (index, coeff) in a_lc.iter() {
     add_constraint_component(index.0, coeff, A);
   }
+  A.indptr.push(A.indices.len());
+
   for (index, coeff) in b_lc.iter() {
     add_constraint_component(index.0, coeff, B)
   }
+  B.indptr.push(B.indices.len());
+
   for (index, coeff) in c_lc.iter() {
     add_constraint_component(index.0, coeff, C)
   }
+  C.indptr.push(C.indices.len());
 
   **nn += 1;
 }

src/lib.rs

@@ -906,13 +906,13 @@ mod tests {
     test_pp_digest_with::<G1, G2, _, _>(
       &trivial_circuit1,
       &trivial_circuit2,
-      "fe14a77d74cb8b8bb13105cea9c5b98b621b42c8d61da8f2adce8b9dd0d51b03",
+      "117ac6f33d66d377346e420f0d8caa09f8f4ec7db0c336dcc65995bf3058bf01",
     );
 
     test_pp_digest_with::<G1, G2, _, _>(
       &cubic_circuit1,
       &trivial_circuit2,
-      "21ac840e52c75a62823cfdda4ca77aae2f07e4b6f5aa0eba80135492b2fbd003",
+      "583c9964e180332e63a59450870a72b4cbf663ce0d274ac5bd0d052d4cd92903",
     );
 
     let trivial_circuit1_grumpkin = TrivialCircuit::<<bn256::Point as Group>::Scalar>::default();
@@ -922,12 +922,12 @@ mod tests {
     test_pp_digest_with::<bn256::Point, grumpkin::Point, _, _>(
       &trivial_circuit1_grumpkin,
       &trivial_circuit2_grumpkin,
-      "0b25debdc99cef04b6d113a9a2814de89b3fad239aea90b29f2bdb27d95afa02",
+      "fb6805b7197f41ae2af71dc0130d4bfd1d28fa63b8221741b597dfbb2e48d603",
     );
     test_pp_digest_with::<bn256::Point, grumpkin::Point, _, _>(
       &cubic_circuit1_grumpkin,
       &trivial_circuit2_grumpkin,
-      "0747f68f8d1c4bac4c3fb82689a1488b5835bbc97d6f6023fbe2760bb0053b00",
+      "684b2f7151031a79310f6fb553ab1480e290d73731fa34e74c27e004d589f102",
     );
 
     let trivial_circuit1_secp = TrivialCircuit::<<secp256k1::Point as Group>::Scalar>::default();
@@ -937,12 +937,12 @@ mod tests {
     test_pp_digest_with::<secp256k1::Point, secq256k1::Point, _, _>(
       &trivial_circuit1_secp,
       &trivial_circuit2_secp,
-      "0cf0880fa8debe42b7789474f6787062f8118ef251450dd5a7a4b5430f4bb902",
+      "dbffd48ae0d05f3aeb217e971fbf3b2b7a759668221f6d6cb9032cfa0445aa01",
     );
     test_pp_digest_with::<secp256k1::Point, secq256k1::Point, _, _>(
       &cubic_circuit1_secp,
       &trivial_circuit2_secp,
-      "623a1dd99f3c906e79397f3de0dc1565b35fcb69abf2da51847bc9879a0a6000",
+      "24e4e8044310e3167196276cc66b4f71b5d0e3e57701dddb17695ae968fba802",
     );
   }
 

src/nifs.rs

@@ -113,7 +113,7 @@ impl<G: Group> NIFS<G> {
 #[cfg(test)]
 mod tests {
   use super::*;
-  use crate::{r1cs::R1CS, traits::Group};
+  use crate::{r1cs::SparseMatrix, r1cs::R1CS, traits::Group};
   use ::bellpepper_core::{num::AllocatedNum, ConstraintSystem, SynthesisError};
   use ff::{Field, PrimeField};
   use rand::rngs::OsRng;
@@ -310,8 +310,18 @@ mod tests {
     };
 
     // create a shape object
+    let rows = num_cons;
+    let num_inputs = num_io + 1;
+    let cols = num_vars + num_inputs;
     let S = {
-      let res = R1CSShape::new(num_cons, num_vars, num_io, &A, &B, &C);
+      let res = R1CSShape::new(
+        num_cons,
+        num_vars,
+        num_inputs - 1,
+        SparseMatrix::new(&A, rows, cols),
+        SparseMatrix::new(&B, rows, cols),
+        SparseMatrix::new(&C, rows, cols),
+      );
       assert!(res.is_ok());
       res.unwrap()
     };