many fixes

src/gadgets/biguint.rs

@@ -190,7 +190,7 @@ impl<F: RichField + Extendable<D>, const D: usize> CircuitBuilder<F, D> {
         self.connect_biguint(a, div_b_plus_rem);
 
         let cmp_rem_b = self.cmp_biguint(rem.clone(), b);
-        self.assert_one(cmp_rem_b.target);
+        self.assert_zero(cmp_rem_b.target);
 
         (div, rem)
     }
@@ -232,11 +232,7 @@ mod tests {
     use anyhow::Result;
     use num::{BigUint, FromPrimitive, Integer};
 
-    use crate::{
-        field::crandall_field::CrandallField,
-        iop::witness::PartialWitness,
-        plonk::{circuit_builder::CircuitBuilder, circuit_data::CircuitConfig, verifier::verify},
-    };
+    use crate::{field::{crandall_field::CrandallField, field_types::PrimeField}, iop::witness::PartialWitness, plonk::{circuit_builder::CircuitBuilder, circuit_data::CircuitConfig, verifier::verify}};
 
     #[test]
     fn test_biguint_add() -> Result<()> {
@@ -320,7 +316,7 @@ mod tests {
         let x = builder.constant_biguint(x_value);
         let y = builder.constant_biguint(y_value);
         let cmp = builder.cmp_biguint(x, y);
-        let expected_cmp = builder.constant_bool(true);
+        let expected_cmp = builder.constant_bool(false);
 
         builder.connect(cmp.target, expected_cmp.target);
 
@@ -347,8 +343,8 @@ mod tests {
         let expected_div = builder.constant_biguint(expected_div_value);
         let expected_rem = builder.constant_biguint(expected_rem_value);
 
-        //builder.connect_biguint(div, expected_div);
-        //builder.connect_biguint(rem, expected_rem);
+        builder.connect_biguint(div, expected_div);
+        builder.connect_biguint(rem, expected_rem);
 
         let data = builder.build();
         let proof = data.prove(pw).unwrap();

src/gadgets/multiple_comparison.rs

@@ -80,7 +80,7 @@ mod tests {
         let lst2: Vec<u32> = (0..size)
             .map(|i| {
                 let mut res = rng.gen();
-                while res < lst1[i] {
+                while res <= lst1[i] {
                     res = rng.gen();
                 }
                 res
@@ -103,4 +103,19 @@ mod tests {
     fn test_multiple_comparison_trivial() -> Result<()> {
         test_list_le(1)
     }
+
+    #[test]
+    fn test_multiple_comparison_small() -> Result<()> {
+        test_list_le(3)
+    }
+
+    #[test]
+    fn test_multiple_comparison_medium() -> Result<()> {
+        test_list_le(6)
+    }
+
+    #[test]
+    fn test_multiple_comparison_large() -> Result<()> {
+        test_list_le(10)
+    }
 }

src/gates/comparison.rs

@@ -119,10 +119,10 @@ impl<F: RichField + Extendable<D>, const D: usize> Gate<F, D> for ComparisonGate
 
         for i in 0..self.num_chunks {
             // Range-check the chunks to be less than `chunk_size`.
-            let first_product = (0..chunk_size)
+            let first_product: F::Extension = (0..chunk_size)
                 .map(|x| first_chunks[i] - F::Extension::from_canonical_usize(x))
                 .product();
-            let second_product = (0..chunk_size)
+            let second_product: F::Extension = (0..chunk_size)
                 .map(|x| second_chunks[i] - F::Extension::from_canonical_usize(x))
                 .product();
             constraints.push(first_product);
@@ -200,10 +200,10 @@ impl<F: RichField + Extendable<D>, const D: usize> Gate<F, D> for ComparisonGate
 
         for i in 0..self.num_chunks {
             // Range-check the chunks to be less than `chunk_size`.
-            let first_product = (0..chunk_size)
+            let first_product: F = (0..chunk_size)
                 .map(|x| first_chunks[i] - F::from_canonical_usize(x))
                 .product();
-            let second_product = (0..chunk_size)
+            let second_product: F = (0..chunk_size)
                 .map(|x| second_chunks[i] - F::from_canonical_usize(x))
                 .product();
             constraints.push(first_product);
@@ -447,15 +447,17 @@ impl<F: RichField + Extendable<D>, const D: usize> SimpleGenerator<F>
         }
         let most_significant_diff = most_significant_diff_so_far;
 
-        let two_n_plus_msd =
-            (1 << self.gate.chunk_bits()) as u64 + most_significant_diff.to_canonical_u64();
-        let msd_bits: Vec<F> = (0..self.gate.chunk_bits() + 1)
+        let two_n = F::from_canonical_usize(1 << self.gate.chunk_bits());
+        let two_n_plus_msd = (two_n + most_significant_diff).to_canonical_u64();
+
+        let msd_bits_u64: Vec<u64> = (0..self.gate.chunk_bits() + 1)
             .scan(two_n_plus_msd, |acc, _| {
                 let tmp = *acc % 2;
                 *acc /= 2;
-                Some(F::from_canonical_u64(tmp))
+                Some(tmp)
             })
             .collect();
+        let msd_bits: Vec<F> = msd_bits_u64.iter().map(|x| F::from_canonical_u64(*x)).collect();
 
         out_buffer.set_wire(local_wire(self.gate.wire_result_bool()), result);
         out_buffer.set_wire(

src/plonk/circuit_builder.rs

@@ -202,6 +202,7 @@ impl<F: RichField + Extendable<D>, const D: usize> CircuitBuilder<F, D> {
             gate_ref,
             constants,
         });
+
         index
     }