nit: improve readability of range proof example

Author: mmaker

src/tests/test_relations.rs

@@ -207,7 +207,7 @@ pub fn test_range<G: PrimeGroup, R: RngCore>(
     let G = G::generator();
     let H = G::random(&mut rng);
 
-    let bases = [1, 2, 4, 8, 16, 32, 64, 128, 256, 313, 512];
+    let bases = [1, 2, 4, 8, 16, 32, 64, 128, 256, 313, 512].map(G::Scalar::from);
     const BITS: usize = 11;
 
     let mut instance = LinearRelation::new();
@@ -216,23 +216,26 @@ pub fn test_range<G: PrimeGroup, R: RngCore>(
     let vars_b = instance.allocate_scalars::<BITS>();
     let vars_s = instance.allocate_scalars::<BITS>();
     let var_s2 = instance.allocate_scalars::<BITS>();
+    let var_Ds = instance.allocate_elements::<BITS>();
 
-    let var_C = instance.allocate_eq(var_x * var_G + var_r * var_H);
-    let mut var_Ds = Vec::new();
+    // `var_Ds[i]` are bit commitments.
     for i in 0..BITS {
-        let var_D_i = instance.allocate_eq(vars_b[i] * var_G + vars_s[i] * var_H);
-        instance.append_equation(var_D_i, vars_b[i] * var_D_i + var_s2[i] * var_H);
-        var_Ds.push(var_D_i);
+        instance.append_equation(var_Ds[i], vars_b[i] * var_G + vars_s[i] * var_H);
+        instance.append_equation(var_Ds[i], vars_b[i] * var_Ds[i] + var_s2[i] * var_H);
     }
+    // `var_C` is a Pedersen commitment to `var_x`.
+    let var_C = instance.allocate_eq(var_x * var_G + var_r * var_H);
+    // `var_x` = sum(bases[i] * var_b[i])
     instance.append_equation(
         var_C,
         (0..BITS)
-            .map(|i| var_Ds[i] * vars_b[i] * G::Scalar::from(bases[i]))
+            .map(|i| var_Ds[i] * vars_b[i] * bases[i])
             .sum::<Sum<_>>(),
     );
 
     let r = G::Scalar::random(&mut rng);
     let x = G::Scalar::from(822);
+
     let b = [
         G::Scalar::ZERO,
         G::Scalar::ONE,
@@ -251,12 +254,10 @@ pub fn test_range<G: PrimeGroup, R: RngCore>(
         .map(|_| G::Scalar::random(&mut rng))
         .collect::<Vec<_>>();
     let partial_sum = (0..BITS - 1)
-        .map(|i| b[i] * G::Scalar::from(bases[i]) * s[i])
+        .map(|i| b[i] * bases[i] * s[i])
         .sum::<G::Scalar>();
     s[BITS - 1] = r - partial_sum;
-    s[BITS - 1] *= (b[BITS - 1] * G::Scalar::from(bases[BITS - 1]))
-        .invert()
-        .unwrap();
+    s[BITS - 1] *= (b[BITS - 1] * bases[BITS - 1]).invert().unwrap();
     let s2 = (0..BITS)
         .map(|i| (G::Scalar::ONE - b[i]) * s[i])
         .collect::<Vec<_>>();