Some optimizations in constraint synthesis. (#407)

* Switch cmp

* New `Variable` formatting to save 64 bits per `Variable`, and introduce `LcMap`

* Remove redundant comments

* Format

* Optimize new `Variable`

* Fix

* Add interning

* Add comments

* Rename

* Switch to correct ordering for variables

* Clippy comments

* More clippy comments

* More clippy comments

* Fix assertion

* Fix comment

Author: Pratyush

relations/examples/bench-no-finalize.rs

@@ -29,13 +29,13 @@ impl ConstraintSynthesizer<Fr> for BenchCircuit {
         variables.reserve(3 * self.num_constraints);
         let mut lcs = Vec::with_capacity(self.num_constraints);
 
-        let mut rng_a = ark_std::rand::rngs::StdRng::seed_from_u64(0 as u64);
+        let mut rng_a = ark_std::rand::rngs::StdRng::seed_from_u64(0_u64);
         let mut rng_b = ark_std::rand::rngs::StdRng::seed_from_u64(rng_a.gen::<u64>());
         let mut rng_c = ark_std::rand::rngs::StdRng::seed_from_u64(rng_a.gen::<u64>());
 
         for i in 0..self.num_constraints {
             let cur_num_vars = ark_std::cmp::min(variables.len(), 10);
-            let lower = variables.len().checked_sub(cur_num_vars).unwrap_or(0);
+            let lower = variables.len().saturating_sub(cur_num_vars);
             let upper = variables.len();
 
             let a_i_lc_size = rng_a.gen_range(1..=NUM_COEFFS_IN_LC);

relations/examples/bench.rs

@@ -34,7 +34,7 @@ impl ConstraintSynthesizer<Fr> for BenchCircuit {
 
         for i in 0..self.num_constraints {
             let cur_num_vars = ark_std::cmp::min(variables.len(), 10);
-            let lower = variables.len().checked_sub(cur_num_vars).unwrap_or(0);
+            let lower = variables.len().saturating_sub(cur_num_vars);
             let upper = variables.len();
 
             let a_i_lc_size = rng_a.gen_range(1..=NUM_COEFFS_IN_LC);

relations/src/gr1cs/assignment.rs

@@ -0,0 +1,53 @@
+use ark_ff::Field;
+use ark_std::vec::Vec;
+
+use crate::{
+    gr1cs::{field_interner::FieldInterner, lc_map::LcMap, Variable},
+    utils::variable::VarKind,
+};
+
+/// Assignments for a GR1CS constraint system.
+#[derive(Debug, Clone)]
+pub struct Assignments<F> {
+    /// Assignments to the public input variables. This is empty if `self.mode
+    /// == SynthesisMode::Setup`.
+    pub instance_assignment: Vec<F>,
+    /// Assignments to the private input variables. This is empty if `self.mode
+    /// == SynthesisMode::Setup`.
+    pub witness_assignment: Vec<F>,
+    /// A cache for the linear combination assignments. It shows evaluation
+    /// result of each linear combination
+    pub lc_assignment: Vec<F>,
+}
+
+impl<F: Field> Assignments<F> {
+    /// Obtain the assignment corresponding to the `Variable` `v`.
+    #[inline]
+    pub fn assigned_value(&self, v: Variable) -> Option<F> {
+        let idx = v.index();
+        match v.kind() {
+            VarKind::Zero => Some(F::ZERO),
+            VarKind::One => Some(F::ONE),
+            VarKind::Instance => self.instance_assignment.get(idx?).copied(),
+            VarKind::Witness => self.witness_assignment.get(idx?).copied(),
+            VarKind::SymbolicLc => self.lc_assignment.get(idx?).copied(),
+        }
+    }
+
+    /// Evaluate the linear combination `lc` with the assigned values and return
+    /// the result.
+    #[inline]
+    pub(super) fn eval_lc(
+        &self,
+        lc: usize,
+        lc_map: &LcMap<F>,
+        f_interner: &FieldInterner<F>,
+    ) -> Option<F> {
+        lc_map.get(lc).map(|lc| {
+            lc.map(|(&coeff, &var)| {
+                f_interner.value(coeff).unwrap() * self.assigned_value(var).unwrap()
+            })
+            .sum()
+        })
+    }
+}