Implement ASSERT_LT_FELT hint

cairo_programs/assert_lt_felt.cairo

@@ -0,0 +1,49 @@
+%builtins range_check
+
+from starkware.cairo.common.math import assert_lt
+from starkware.cairo.common.math import split_felt
+from starkware.cairo.common.math import assert_lt_felt
+
+func assert_lt_felt_manual_implementation{range_check_ptr}(a, b) {
+    %{
+        from starkware.cairo.common.math_utils import assert_integer
+        assert_integer(ids.a)
+        assert_integer(ids.b)
+        assert (ids.a % PRIME) < (ids.b % PRIME), \
+            f'a = {ids.a % PRIME} is not less than b = {ids.b % PRIME}.'
+    %}
+    alloc_locals;
+    let (local a_high, local a_low) = split_felt(a);
+    let (b_high, b_low) = split_felt(b);
+
+    if (a_high == b_high) {
+        assert_lt(a_low, b_low);
+        return ();
+    }
+    assert_lt(a_high, b_high);
+    return ();
+}
+
+func main{range_check_ptr: felt}() {
+    let x = 5;
+    let y = 6;
+
+    tempvar m = 7;
+    tempvar n = 7 * 7;
+
+    assert_lt_felt(1, 2);
+    assert_lt_felt(-2, -1);
+    assert_lt_felt(1, -1);
+    assert_lt_felt(0, 1);
+    assert_lt_felt(x, y);
+    assert_lt_felt(m, n);
+
+    assert_lt_felt_manual_implementation(1, 2);
+    assert_lt_felt_manual_implementation(-2, -1);
+    assert_lt_felt_manual_implementation(1, -1);
+    assert_lt_felt_manual_implementation(0, 1);
+    assert_lt_felt_manual_implementation(x, y);
+    assert_lt_felt_manual_implementation(m, n);
+
+    return ();
+}

pkg/hints/hint_codes/math_hint_codes.go

@@ -29,6 +29,8 @@ const ASSERT_LE_FELT_EXCLUDED_1 = "memory[ap] = 1 if excluded != 1 else 0"
 
 const ASSERT_LE_FELT_EXCLUDED_2 = "assert excluded == 2"
 
+const ASSERT_LT_FELT = "from starkware.cairo.common.math_utils import assert_integer\nassert_integer(ids.a)\nassert_integer(ids.b)\nassert (ids.a % PRIME) < (ids.b % PRIME), \\\n    f'a = {ids.a % PRIME} is not less than b = {ids.b % PRIME}.'"
+
 const ASSERT_250_BITS = "from starkware.cairo.common.math_utils import as_int\n\n# Correctness check.\nvalue = as_int(ids.value, PRIME) % PRIME\nassert value < ids.UPPER_BOUND, f'{value} is outside of the range [0, 2**250).'\n\n# Calculation for the assertion.\nids.high, ids.low = divmod(ids.value, ids.SHIFT)"
 
 const SPLIT_FELT = "from starkware.cairo.common.math_utils import assert_integer\nassert ids.MAX_HIGH < 2**128 and ids.MAX_LOW < 2**128\nassert PRIME - 1 == ids.MAX_HIGH * 2**128 + ids.MAX_LOW\nassert_integer(ids.value)\nids.low = ids.value & ((1 << 128) - 1)\nids.high = ids.value >> 128"

pkg/hints/hint_processor.go

@@ -114,6 +114,8 @@ func (p *CairoVmHintProcessor) ExecuteHint(vm *vm.VirtualMachine, hintData *any,
 		return assertLeFeltExcluded1(vm, execScopes)
 	case ASSERT_LE_FELT_EXCLUDED_2:
 		return assertLeFeltExcluded2(vm, execScopes)
+	case ASSERT_LT_FELT:
+		return assertLtFelt(data.Ids, vm)
 	case IS_NN:
 		return isNN(data.Ids, vm)
 	case IS_NN_OUT_OF_RANGE:

pkg/hints/math_hints.go

@@ -303,6 +303,22 @@ func assertLeFeltExcluded2(vm *VirtualMachine, scopes *ExecutionScopes) error {
 	if excluded != 2 {
 		return errors.New("Assertion Failed: excluded == 2")
 	}
+	return nil
+}
+
+func assertLtFelt(ids IdsManager, vm *VirtualMachine) error {
+	// Fetch ids variables
+	a, err := ids.GetFelt("a", vm)
+	if err != nil {
+		return err
+	}
+	b, err := ids.GetFelt("b", vm)
+	if err != nil {
+		return err
+	}
+	if a.Cmp(b) != -1 {
+		return errors.Errorf("Assertion failed, a = %s %% PRIME is not less than b = %s %% PRIME", a.ToHexString(), b.ToHexString())
+	}
 
 	return nil
 }

pkg/hints/math_hints_test.go

@@ -535,6 +535,48 @@ func TestAssertLeFeltExcluded2Err(t *testing.T) {
 		t.Errorf("ASSERT_LE_FELT_EXCLUDED_2 hint test should have failed")
 	}
 }
+
+func TestAssertLeFeltHintOk(t *testing.T) {
+	vm := NewVirtualMachine()
+	vm.Segments.AddSegment()
+	idsManager := SetupIdsForTest(
+		map[string][]*MaybeRelocatable{
+			"a": {NewMaybeRelocatableFelt(FeltFromUint64(17))},
+			"b": {NewMaybeRelocatableFelt(FeltFromUint64(18))},
+		},
+		vm,
+	)
+	hintProcessor := CairoVmHintProcessor{}
+	hintData := any(HintData{
+		Ids:  idsManager,
+		Code: ASSERT_LT_FELT,
+	})
+	err := hintProcessor.ExecuteHint(vm, &hintData, nil, nil)
+	if err != nil {
+		t.Errorf("ASSERT_LT_FELT hint test failed with error %s", err)
+	}
+}
+
+func TestAssertLeFeltHintErr(t *testing.T) {
+	vm := NewVirtualMachine()
+	vm.Segments.AddSegment()
+	idsManager := SetupIdsForTest(
+		map[string][]*MaybeRelocatable{
+			"a": {NewMaybeRelocatableFelt(FeltFromUint64(17))},
+			"b": {NewMaybeRelocatableFelt(FeltFromUint64(16))},
+		},
+		vm,
+	)
+	hintProcessor := CairoVmHintProcessor{}
+	hintData := any(HintData{
+		Ids:  idsManager,
+		Code: ASSERT_LT_FELT,
+	})
+	err := hintProcessor.ExecuteHint(vm, &hintData, nil, nil)
+	if err == nil {
+		t.Errorf("ASSERT_LT_FELT hint test should have failed")
+	}
+}
 func TestAssert250BitHintSuccess(t *testing.T) {
 	vm := NewVirtualMachine()
 	vm.Segments.AddSegment()

pkg/vm/cairo_run/cairo_run_test.go

@@ -224,6 +224,14 @@ func TestAssertLeFelt(t *testing.T) {
 		t.Errorf("Program execution failed with error: %s", err)
 	}
 }
+
+func TestAssertLtFelt(t *testing.T) {
+	cairoRunConfig := cairo_run.CairoRunConfig{DisableTracePadding: false, Layout: "all_cairo", ProofMode: false}
+	_, err := cairo_run.CairoRun("../../../cairo_programs/assert_lt_felt.json", cairoRunConfig)
+	if err != nil {
+		t.Errorf("Program execution failed with error: %s", err)
+	}
+}
 func TestMemsetHint(t *testing.T) {
 	cairoRunConfig := cairo_run.CairoRunConfig{DisableTracePadding: false, Layout: "all_cairo", ProofMode: false}
 	_, err := cairo_run.CairoRun("../../../cairo_programs/memset.json", cairoRunConfig)