zk::gadget::less_than: Test non-strict mode

src/zk/gadget/less_than.rs

@@ -280,7 +280,7 @@ mod tests {
     };
 
     macro_rules! test_circuit {
-        ($k: expr, $window_size:expr, $num_bits:expr, $num_windows:expr, $valid_pairs:expr, $invalid_pairs:expr) => {
+        ($k: expr, $strict:expr, $window_size:expr, $num_bits:expr, $num_windows:expr, $valid_pairs:expr, $invalid_pairs:expr) => {
             #[derive(Default)]
             struct LessThanCircuit {
                 a: Value<pallas::Base>,
@@ -346,7 +346,7 @@ mod tests {
                         self.a,
                         self.b,
                         0,
-                        true,
+                        $strict,
                     )?;
 
                     Ok(())
@@ -362,15 +362,16 @@ mod tests {
             let root = BitMapBackend::new(file_name.as_str(), (3840, 2160)).into_drawing_area();
             CircuitLayout::default().render($k, &circuit, &root).unwrap();
 
+            let check = if $strict { "<" } else { "<=" };
             for (a, b) in $valid_pairs {
-                println!("{:?} bit (valid) {:?} < {:?} check", $num_bits, a, b);
+                println!("{:?} bit (valid) {:?} {} {:?} check", $num_bits, a, check, b);
                 let circuit = LessThanCircuit { a: Value::known(a), b: Value::known(b) };
                 let prover = MockProver::run($k, &circuit, vec![]).unwrap();
                 prover.assert_satisfied();
             }
 
             for (a, b) in $invalid_pairs {
-                println!("{:?} bit (invalid) {:?} < {:?} check", $num_bits, a, b);
+                println!("{:?} bit (invalid) {:?} {} {:?} check", $num_bits, a, check, b);
                 let circuit = LessThanCircuit { a: Value::known(a), b: Value::known(b) };
                 let prover = MockProver::run($k, &circuit, vec![]).unwrap();
                 assert!(prover.verify().is_err())
@@ -378,6 +379,39 @@ mod tests {
         };
     }
 
+    #[test]
+    fn leq_64() {
+        let k = 5;
+        const WINDOW_SIZE: usize = 3;
+        const NUM_OF_BITS: usize = 64;
+        const NUM_OF_WINDOWS: usize = 22;
+
+        let valid_pairs = [
+            (pallas::Base::ZERO, pallas::Base::ZERO),
+            (pallas::Base::ONE, pallas::Base::ONE),
+            (pallas::Base::from(13), pallas::Base::from(15)),
+            (pallas::Base::ZERO, pallas::Base::from(u64::MAX)),
+            (pallas::Base::ONE, pallas::Base::from(rand::random::<u64>())),
+            (pallas::Base::from(u64::MAX), pallas::Base::from(u64::MAX) + pallas::Base::ONE),
+            (pallas::Base::from(u64::MAX), pallas::Base::from(u64::MAX)),
+        ];
+
+        let invalid_pairs = [
+            (pallas::Base::from(14), pallas::Base::from(11)),
+            (pallas::Base::from(u64::MAX), pallas::Base::ZERO),
+            (pallas::Base::ONE, pallas::Base::ZERO),
+        ];
+        test_circuit!(
+            k,
+            false,
+            WINDOW_SIZE,
+            NUM_OF_BITS,
+            NUM_OF_WINDOWS,
+            valid_pairs,
+            invalid_pairs
+        );
+    }
+
     #[test]
     fn less_than_64() {
         let k = 5;
@@ -400,7 +434,75 @@ mod tests {
             (pallas::Base::ONE, pallas::Base::ZERO),
             (pallas::Base::from(u64::MAX), pallas::Base::from(u64::MAX)),
         ];
-        test_circuit!(k, WINDOW_SIZE, NUM_OF_BITS, NUM_OF_WINDOWS, valid_pairs, invalid_pairs);
+        test_circuit!(
+            k,
+            true,
+            WINDOW_SIZE,
+            NUM_OF_BITS,
+            NUM_OF_WINDOWS,
+            valid_pairs,
+            invalid_pairs
+        );
+    }
+
+    #[test]
+    fn leq_253() {
+        let k = 7;
+        const WINDOW_SIZE: usize = 3;
+        const NUM_OF_BITS: usize = 253;
+        const NUM_OF_WINDOWS: usize = 85;
+
+        const P_MINUS_1: pallas::Base = pallas::Base::from_raw([
+            0x992d30ed00000000,
+            0x224698fc094cf91b,
+            0x0000000000000000,
+            0x4000000000000000,
+        ]);
+
+        // 2^253 - 1. This is the maximum we can check.
+        const MAX_253: pallas::Base = pallas::Base::from_raw([
+            0xFFFFFFFFFFFFFFFF,
+            0xFFFFFFFFFFFFFFFF,
+            0xFFFFFFFFFFFFFFFF,
+            0x1FFFFFFFFFFFFFFF,
+        ]);
+
+        let valid_pairs = [
+            (pallas::Base::ZERO, pallas::Base::ZERO),
+            (pallas::Base::ZERO, pallas::Base::ONE),
+            (pallas::Base::from(u64::MAX), pallas::Base::from(u64::MAX) + pallas::Base::ONE),
+            (
+                pallas::Base::from_u128(u128::MAX),
+                pallas::Base::from_u128(u128::MAX) + pallas::Base::ONE,
+            ),
+            (MAX_253, MAX_253),
+            (MAX_253 - pallas::Base::from(2), MAX_253 - pallas::Base::ONE),
+            (MAX_253 - pallas::Base::ONE, MAX_253),
+            (MAX_253, MAX_253 + pallas::Base::ONE),
+        ];
+
+        let invalid_pairs = [
+            (pallas::Base::ONE, pallas::Base::ZERO),
+            (P_MINUS_1 - pallas::Base::ONE, P_MINUS_1),
+            (P_MINUS_1, pallas::Base::ZERO),
+            (P_MINUS_1, P_MINUS_1),
+            (MAX_253, pallas::Base::ZERO),
+            (MAX_253, pallas::Base::ONE),
+            (MAX_253 + pallas::Base::ONE, pallas::Base::ZERO),
+            (MAX_253 + pallas::Base::ONE, pallas::Base::ONE),
+            (MAX_253 + pallas::Base::ONE, MAX_253 + pallas::Base::ONE),
+            (MAX_253 + pallas::Base::ONE, MAX_253 + pallas::Base::from(2)),
+        ];
+
+        test_circuit!(
+            k,
+            false,
+            WINDOW_SIZE,
+            NUM_OF_BITS,
+            NUM_OF_WINDOWS,
+            valid_pairs,
+            invalid_pairs
+        );
     }
 
     #[test]
@@ -452,6 +554,14 @@ mod tests {
             (MAX_253 + pallas::Base::ONE, MAX_253 + pallas::Base::from(2)),
         ];
 
-        test_circuit!(k, WINDOW_SIZE, NUM_OF_BITS, NUM_OF_WINDOWS, valid_pairs, invalid_pairs);
+        test_circuit!(
+            k,
+            true,
+            WINDOW_SIZE,
+            NUM_OF_BITS,
+            NUM_OF_WINDOWS,
+            valid_pairs,
+            invalid_pairs
+        );
     }
 }