Add gt ge functions for uints

simf/lib/u128.simf

@@ -119,6 +119,16 @@ pub fn le_128(a: u128, b: u128) -> bool {
     } 
 }
 
+/// Check if an integer is greater than another integer
+pub fn gt_128(a: u128, b: u128) -> bool {
+    lt_128(b, a)
+}
+
+/// Check if an integer is greater than or equal to another integer
+pub fn ge_128(a: u128, b: u128) -> bool {
+    le_128(b, a)
+}
+
 /// Adds two integers and returns the carry
 pub fn add_128(a: u128, b: u128) -> (bool, u128) {
     let (a_high, a_low): (u64, u64) = <u128>::into(a);

simf/lib/u16.simf

@@ -57,3 +57,13 @@ pub fn checked_div_16(a: u16, b: u16) -> Option<u16> {
 pub fn safe_div_16(a: u16, b: u16) -> u16 {
     unwrap(checked_div_16(a, b))
 }
+
+/// Check if an integer is greater than another integer
+pub fn gt_16(a: u16, b: u16) -> bool {
+    jet::lt_16(b, a)
+}
+
+/// Check if an integer is greater than or equal to another integer
+pub fn ge_16(a: u16, b: u16) -> bool {
+    jet::le_16(b, a)
+}

simf/lib/u32.simf

@@ -57,3 +57,13 @@ pub fn checked_div_32(a: u32, b: u32) -> Option<u32> {
 pub fn safe_div_32(a: u32, b: u32) -> u32 {
     unwrap(checked_div_32(a, b))
 }
+
+/// Check if an integer is greater than another integer
+pub fn gt_32(a: u32, b: u32) -> bool {
+    jet::lt_32(b, a)
+}
+
+/// Check if an integer is greater than or equal to another integer
+pub fn ge_32(a: u32, b: u32) -> bool {
+    jet::le_32(b, a)
+}

simf/lib/u64.simf

@@ -57,3 +57,13 @@ pub fn checked_div_64(a: u64, b: u64) -> Option<u64> {
 pub fn safe_div_64(a: u64, b: u64) -> u64 {
     unwrap(checked_div_64(a, b))
 }
+
+/// Check if an integer is greater than another integer
+pub fn gt_64(a: u64, b: u64) -> bool {
+    jet::lt_64(b, a)
+}
+
+/// Check if an integer is greater than or equal to another integer
+pub fn ge_64(a: u64, b: u64) -> bool {
+    jet::le_64(b, a)
+}

simf/lib/u8.simf

@@ -57,3 +57,13 @@ pub fn checked_div_8(a: u8, b: u8) -> Option<u8> {
 pub fn safe_div_8(a: u8, b: u8) -> u8 {
     unwrap(checked_div_8(a, b))
 }
+
+/// Check if an integer is greater than another integer
+pub fn gt_8(a: u8, b: u8) -> bool {
+    jet::lt_8(b, a)
+}
+
+/// Check if an integer is greater than or equal to another integer
+pub fn ge_8(a: u8, b: u8) -> bool {
+    jet::le_8(b, a)
+}

simf/u128_test.simf

@@ -1,5 +1,6 @@
-use crate::lib::u128::{ checked_add_128, safe_add_128, checked_sub_128, safe_sub_128, checked_mul_128, safe_mul_128, checked_div_128, safe_div_128, eq_128 };
+use crate::lib::u128::{ checked_add_128, safe_add_128, checked_sub_128, safe_sub_128, checked_mul_128, safe_mul_128, checked_div_128, safe_div_128, eq_128, gt_128, ge_128 };
 use crate::lib::asserts::{assert_none_128, assert_eq_128};
+use crate::lib::logical_operations::not;
 use crate::helper::if_test_this_function;
 
 /// Asserts a `checked_*` result equals the expected Option.
@@ -12,6 +13,15 @@ fn assert_eq_opt(result: Option<u128>, expected: Option<u128>) {
     }
 }
 
+/// Asserts a result equals the expected bool value.
+/// `None` encodes `false`, and `Some(_)` encodes `true`.
+fn assert_bool_by_opt(result: bool, expected: Option<u128>) {
+    match expected {
+        Some(_: u128) => assert!(result),
+        None => assert!(not(result)),
+    }
+}
+
 fn main() {
     let fn_idx: u8 = witness::FUNCTION_INDEX;
 
@@ -36,4 +46,8 @@ fn main() {
     // div
     match if_test_this_function(6, fn_idx) { true => { assert_eq_opt(checked_div_128(a, b), expected); }, false => (), };
     match if_test_this_function(7, fn_idx) { true => { assert!(eq_128(safe_div_128(a, b), unwrap(expected))); }, false => (), };
+
+    // gt, ge
+    match if_test_this_function(8, fn_idx) { true => { assert_bool_by_opt(gt_128(a, b), expected); }, false => (), };
+    match if_test_this_function(9, fn_idx) { true => { assert_bool_by_opt(ge_128(a, b), expected); }, false => (), };
 }

simf/u16_test.simf

@@ -1,5 +1,6 @@
-use crate::lib::u16::{checked_add_16, safe_add_16, checked_sub_16, safe_sub_16, checked_mul_16, safe_mul_16, checked_div_16, safe_div_16};
+use crate::lib::u16::{checked_add_16, safe_add_16, checked_sub_16, safe_sub_16, checked_mul_16, safe_mul_16, checked_div_16, safe_div_16, gt_16, ge_16};
 use crate::lib::asserts::{assert_none_16, assert_eq_16};
+use crate::lib::logical_operations::not;
 use crate::helper::if_test_this_function;
 
 /// Asserts a `checked_*` result equals the expected Option.
@@ -12,6 +13,15 @@ fn assert_eq_opt(result: Option<u16>, expected: Option<u16>) {
     }
 }
 
+/// Asserts a result equals the expected bool value.
+/// `None` encodes `false`, and `Some(_)` encodes `true`.
+fn assert_bool_by_opt(result: bool, expected: Option<u16>) {
+    match expected {
+        Some(_: u16) => assert!(result),
+        None => assert!(not(result)),
+    }
+}
+
 fn main() {
     let fn_idx: u8 = witness::FUNCTION_INDEX;
 
@@ -34,4 +44,8 @@ fn main() {
     // div
     match if_test_this_function(6, fn_idx) { true => { assert_eq_opt(checked_div_16(a, b), expected); }, false => (), };
     match if_test_this_function(7, fn_idx) { true => { assert!(jet::eq_16(safe_div_16(a, b), unwrap(expected))); }, false => (), };
+
+    // gt, ge
+    match if_test_this_function(8, fn_idx) { true => { assert_bool_by_opt(gt_16(a, b), expected); }, false => (), };
+    match if_test_this_function(9, fn_idx) { true => { assert_bool_by_opt(ge_16(a, b), expected); }, false => (), };
 }

simf/u32_test.simf

@@ -1,5 +1,6 @@
-use crate::lib::u32::{checked_add_32, safe_add_32, checked_sub_32, safe_sub_32, checked_mul_32, safe_mul_32, checked_div_32, safe_div_32};
+use crate::lib::u32::{checked_add_32, safe_add_32, checked_sub_32, safe_sub_32, checked_mul_32, safe_mul_32, checked_div_32, safe_div_32, gt_32, ge_32};
 use crate::lib::asserts::{assert_none_32, assert_eq_32};
+use crate::lib::logical_operations::not;
 use crate::helper::if_test_this_function;
 
 /// Asserts a `checked_*` result equals the expected Option.
@@ -12,6 +13,15 @@ fn assert_eq_opt(result: Option<u32>, expected: Option<u32>) {
     }
 }
 
+/// Asserts a result equals the expected bool value.
+/// `None` encodes `false`, and `Some(_)` encodes `true`.
+fn assert_bool_by_opt(result: bool, expected: Option<u32>) {
+    match expected {
+        Some(_: u32) => assert!(result),
+        None => assert!(not(result)),
+    }
+}
+
 fn main() {
     let fn_idx: u8 = witness::FUNCTION_INDEX;
 
@@ -34,4 +44,8 @@ fn main() {
     // div
     match if_test_this_function(6, fn_idx) { true => { assert_eq_opt(checked_div_32(a, b), expected); }, false => (), };
     match if_test_this_function(7, fn_idx) { true => { assert!(jet::eq_32(safe_div_32(a, b), unwrap(expected))); }, false => (), };
+
+    // gt, ge
+    match if_test_this_function(8, fn_idx) { true => { assert_bool_by_opt(gt_32(a, b), expected); }, false => (), };
+    match if_test_this_function(9, fn_idx) { true => { assert_bool_by_opt(ge_32(a, b), expected); }, false => (), };
 }

simf/u64_test.simf

@@ -1,5 +1,6 @@
-use crate::lib::u64::{checked_add_64, safe_add_64, checked_sub_64, safe_sub_64, checked_mul_64, safe_mul_64, checked_div_64, safe_div_64};
+use crate::lib::u64::{checked_add_64, safe_add_64, checked_sub_64, safe_sub_64, checked_mul_64, safe_mul_64, checked_div_64, safe_div_64, gt_64, ge_64};
 use crate::lib::asserts::{assert_none_64, assert_eq_64};
+use crate::lib::logical_operations::not;
 use crate::helper::if_test_this_function;
 
 /// Asserts a `checked_*` result equals the expected Option.
@@ -12,6 +13,15 @@ fn assert_eq_opt(result: Option<u64>, expected: Option<u64>) {
     }
 }
 
+/// Asserts a result equals the expected bool value.
+/// `None` encodes `false`, and `Some(_)` encodes `true`.
+fn assert_bool_by_opt(result: bool, expected: Option<u64>) {
+    match expected {
+        Some(_: u64) => assert!(result),
+        None => assert!(not(result)),
+    }
+}
+
 fn main() {
     let fn_idx: u8 = witness::FUNCTION_INDEX;
 
@@ -35,4 +45,7 @@ fn main() {
     match if_test_this_function(6, fn_idx) { true => { assert_eq_opt(checked_div_64(a, b), expected); }, false => (), };
     match if_test_this_function(7, fn_idx) { true => { assert!(jet::eq_64(safe_div_64(a, b), unwrap(expected))); }, false => (), };
 
+    // gt, ge
+    match if_test_this_function(8, fn_idx) { true => { assert_bool_by_opt(gt_64(a, b), expected); }, false => (), };
+    match if_test_this_function(9, fn_idx) { true => { assert_bool_by_opt(ge_64(a, b), expected); }, false => (), };
 }

simf/u8_test.simf

@@ -1,5 +1,6 @@
-use crate::lib::u8::{checked_add_8, safe_add_8, checked_sub_8, safe_sub_8, checked_mul_8, safe_mul_8, checked_div_8, safe_div_8};
+use crate::lib::u8::{checked_add_8, safe_add_8, checked_sub_8, safe_sub_8, checked_mul_8, safe_mul_8, checked_div_8, safe_div_8, gt_8, ge_8};
 use crate::lib::asserts::{assert_none_8, assert_eq_8};
+use crate::lib::logical_operations::not;
 use crate::helper::if_test_this_function;
 
 /// Asserts a `checked_*` result equals the expected Option.
@@ -12,6 +13,15 @@ fn assert_eq_opt(result: Option<u8>, expected: Option<u8>) {
     }
 }
 
+/// Asserts a result equals the expected bool value.
+/// `None` encodes `false`, and `Some(_)` encodes `true`.
+fn assert_bool_by_opt(result: bool, expected: Option<u8>) {
+    match expected {
+        Some(_: u8) => assert!(result),
+        None => assert!(not(result)),
+    }
+}
+
 fn main() {
     let fn_idx: u8 = witness::FUNCTION_INDEX;
 
@@ -34,4 +44,8 @@ fn main() {
     // div
     match if_test_this_function(6, fn_idx) { true => { assert_eq_opt(checked_div_8(a, b), expected); }, false => (), };
     match if_test_this_function(7, fn_idx) { true => { assert!(jet::eq_8(safe_div_8(a, b), unwrap(expected))); }, false => (), };
+
+    // gt, ge
+    match if_test_this_function(8, fn_idx) { true => { assert_bool_by_opt(gt_8(a, b), expected); }, false => (), };
+    match if_test_this_function(9, fn_idx) { true => { assert_bool_by_opt(ge_8(a, b), expected); }, false => (), };
 }

tests/common/uint.rs

@@ -23,6 +23,8 @@ pub enum CommonOp {
     SafeMul,
     CheckedDiv,
     SafeDiv,
+    Gt,
+    Ge,
 }
 
 /// Width-specific operations number their dispatch indices from here.
@@ -237,6 +239,76 @@ pub fn safe_div_by_zero<T: TestUint>(context: simplex::TestContext) -> anyhow::R
     )
 }
 
+pub fn gt_greater<T: TestUint>(context: simplex::TestContext) -> anyhow::Result<()> {
+    let b = rand::thread_rng().gen_range(T::ZERO..T::MAX);
+    let a = rand::thread_rng().gen_range(b + T::ONE..=T::MAX);
+
+    run(
+        &context,
+        T::program(),
+        T::witness(op(CommonOp::Gt), a, b, Some(T::ZERO)),
+        Expect::Ok,
+    )
+}
+
+pub fn gt_equal<T: TestUint>(context: simplex::TestContext) -> anyhow::Result<()> {
+    let a = rand::thread_rng().gen_range(T::ZERO..T::MAX);
+
+    run(
+        &context,
+        T::program(),
+        T::witness(op(CommonOp::Gt), a, a, None),
+        Expect::Ok,
+    )
+}
+
+pub fn gt_less<T: TestUint>(context: simplex::TestContext) -> anyhow::Result<()> {
+    let a = rand::thread_rng().gen_range(T::ZERO..T::MAX);
+    let b = rand::thread_rng().gen_range(a + T::ONE..=T::MAX);
+
+    run(
+        &context,
+        T::program(),
+        T::witness(op(CommonOp::Gt), a, b, None),
+        Expect::Ok,
+    )
+}
+
+pub fn ge_greater<T: TestUint>(context: simplex::TestContext) -> anyhow::Result<()> {
+    let b = rand::thread_rng().gen_range(T::ZERO..T::MAX);
+    let a = rand::thread_rng().gen_range(b + T::ONE..=T::MAX);
+
+    run(
+        &context,
+        T::program(),
+        T::witness(op(CommonOp::Ge), a, b, Some(T::ZERO)),
+        Expect::Ok,
+    )
+}
+
+pub fn ge_equal<T: TestUint>(context: simplex::TestContext) -> anyhow::Result<()> {
+    let a = rand::thread_rng().gen_range(T::ZERO..T::MAX);
+
+    run(
+        &context,
+        T::program(),
+        T::witness(op(CommonOp::Ge), a, a, Some(T::ZERO)),
+        Expect::Ok,
+    )
+}
+
+pub fn ge_less<T: TestUint>(context: simplex::TestContext) -> anyhow::Result<()> {
+    let a = rand::thread_rng().gen_range(T::ZERO..T::MAX);
+    let b = rand::thread_rng().gen_range(a + T::ONE..=T::MAX);
+
+    run(
+        &context,
+        T::program(),
+        T::witness(op(CommonOp::Ge), a, b, None),
+        Expect::Ok,
+    )
+}
+
 /// Stamps the `#[simplex::test]` entry points for one width.
 ///
 /// It contains NO test logic. It only maps each scenario name to a concrete
@@ -278,6 +350,9 @@ macro_rules! uint_tests {
             safe_mul_fitting    safe_mul_overflow
             checked_div_fitting checked_div_by_zero
             safe_div_fitting    safe_div_by_zero
+            gt_greater          gt_equal
+            gt_less             ge_greater
+            ge_equal            ge_less
         );
     };
     (@stub $t:ty; $($name:ident)+) => {