Implement ASSERT_LT_FELT hint

cairo_programs/assert_250_bit_element_array.cairo

@@ -0,0 +1,31 @@
+%builtins range_check
+
+from starkware.cairo.common.math import assert_250_bit
+from starkware.cairo.common.alloc import alloc
+
+func assert_250_bit_element_array{range_check_ptr: felt}(
+    array: felt*, array_length: felt, iterator: felt
+) {
+    if (iterator == array_length) {
+        return ();
+    }
+    assert_250_bit(array[iterator]);
+    return assert_250_bit_element_array(array, array_length, iterator + 1);
+}
+
+func fill_array(array: felt*, base: felt, step: felt, array_length: felt, iterator: felt) {
+    if (iterator == array_length) {
+        return ();
+    }
+    assert array[iterator] = base + step * iterator;
+    return fill_array(array, base, step, array_length, iterator + 1);
+}
+
+func main{range_check_ptr: felt}() {
+    alloc_locals;
+    tempvar array_length = 10;
+    let (array: felt*) = alloc();
+    fill_array(array, 70000000000000000000, 300000000000000000, array_length, 0);
+    assert_250_bit_element_array(array, array_length, 0);
+    return ();
+}

cairo_programs/assert_le_felt.cairo

@@ -0,0 +1,10 @@
+
+%builtins range_check
+from starkware.cairo.common.math import assert_le_felt
+
+func main{range_check_ptr: felt}() {
+    assert_le_felt(1, 2);
+    assert_le_felt(-2, -1);
+    assert_le_felt(2, -1);
+    return ();
+}

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 ();
+}

cairo_programs/split_felt.cairo

@@ -0,0 +1,42 @@
+%builtins range_check
+
+from starkware.cairo.common.math import assert_le
+from starkware.cairo.common.math import split_felt
+
+func split_felt_manual_implemetation{range_check_ptr}(value) -> (high: felt, low: felt) {
+    // Note: the following code works because PRIME - 1 is divisible by 2**128.
+    const MAX_HIGH = (-1) / 2 ** 128;
+    const MAX_LOW = 0;
+
+    // Guess the low and high parts of the integer.
+    let low = [range_check_ptr];
+    let high = [range_check_ptr + 1];
+    let range_check_ptr = range_check_ptr + 2;
+
+    %{
+        from starkware.cairo.common.math_utils import assert_integer
+        assert ids.MAX_HIGH < 2**128 and ids.MAX_LOW < 2**128
+        assert PRIME - 1 == ids.MAX_HIGH * 2**128 + ids.MAX_LOW
+        assert_integer(ids.value)
+        ids.low = ids.value & ((1 << 128) - 1)
+        ids.high = ids.value >> 128
+    %}
+
+    assert value = high * (2 ** 128) + low;
+    if (high == MAX_HIGH) {
+        assert_le(low, MAX_LOW);
+    } else {
+        assert_le(high, MAX_HIGH - 1);
+    }
+    return (high=high, low=low);
+}
+
+func main{range_check_ptr: felt}() {
+    let (m, n) = split_felt_manual_implemetation(5784800237655953878877368326340059594760);
+    assert m = 17;
+    assert n = 8;
+    let (x, y) = split_felt(5784800237655953878877368326340059594760);
+    assert x = 17;
+    assert y = 8;
+    return ();
+}

pkg/hints/hint_processor.go

@@ -69,6 +69,20 @@ func (p *CairoVmHintProcessor) ExecuteHint(vm *vm.VirtualMachine, hintData *any,
 		return memcpy_enter_scope(data.Ids, vm, execScopes)
 	case VM_ENTER_SCOPE:
 		return vm_enter_scope(execScopes)
+	case ASSERT_LE_FELT:
+		return assertLeFelt(data.Ids, vm, execScopes, constants)
+	case ASSERT_LE_FELT_EXCLUDED_0:
+		return assertLeFeltExcluded0(vm, execScopes)
+	case ASSERT_LE_FELT_EXCLUDED_1:
+		return assertLeFeltExcluded1(vm, execScopes)
+	case ASSERT_LE_FELT_EXCLUDED_2:
+		return assertLeFeltExcluded2(vm, execScopes)
+	case ASSERT_LT_FELT:
+		return assertLtFelt(data.Ids, vm)
+	case ASSERT_250_BITS:
+		return Assert250Bit(data.Ids, vm, constants)
+	case SPLIT_FELT:
+		return SplitFelt(data.Ids, vm, constants)
 	default:
 		return errors.Errorf("Unknown Hint: %s", data.Code)
 	}

pkg/hints/hint_utils/hint_utils.go

@@ -0,0 +1,23 @@
+package hint_utils
+
+import (
+	"strings"
+
+	. "github.com/lambdaclass/cairo-vm.go/pkg/lambdaworks"
+	"github.com/pkg/errors"
+)
+
+func GetConstantFromVarName(name string, constants *map[string]Felt) (Felt, error) {
+	if constants == nil {
+		return Felt{}, errors.Errorf("Caled GetConstantFromVarName with a nil constants map. Var Name: %s", name)
+	}
+
+	for key, value := range *constants {
+		keySplit := strings.Split(key, ".")
+		if keySplit[len(keySplit)-1] == name {
+			return value, nil
+		}
+	}
+
+	return Felt{}, errors.Errorf("Variable name not found in constants map. Var Name: %s", name)
+}

pkg/hints/math_hint_codes.go

@@ -18,3 +18,17 @@ else:
 const ASSERT_NOT_EQUAL = "from starkware.cairo.lang.vm.relocatable import RelocatableValue\nboth_ints = isinstance(ids.a, int) and isinstance(ids.b, int)\nboth_relocatable = (\n    isinstance(ids.a, RelocatableValue) and isinstance(ids.b, RelocatableValue) and\n    ids.a.segment_index == ids.b.segment_index)\nassert both_ints or both_relocatable, \\\n    f'assert_not_equal failed: non-comparable values: {ids.a}, {ids.b}.'\nassert (ids.a - ids.b) % PRIME != 0, f'assert_not_equal failed: {ids.a} = {ids.b}.'"
 
 const SQRT = "from starkware.python.math_utils import isqrt\nvalue = ids.value % PRIME\nassert value < 2 ** 250, f\"value={value} is outside of the range [0, 2**250).\"\nassert 2 ** 250 < PRIME\nids.root = isqrt(value)"
+
+const ASSERT_LE_FELT = "import itertools\n\nfrom starkware.cairo.common.math_utils import assert_integer\nassert_integer(ids.a)\nassert_integer(ids.b)\na = ids.a % PRIME\nb = ids.b % PRIME\nassert a <= b, f'a = {a} is not less than or equal to b = {b}.'\n\n# Find an arc less than PRIME / 3, and another less than PRIME / 2.\nlengths_and_indices = [(a, 0), (b - a, 1), (PRIME - 1 - b, 2)]\nlengths_and_indices.sort()\nassert lengths_and_indices[0][0] <= PRIME // 3 and lengths_and_indices[1][0] <= PRIME // 2\nexcluded = lengths_and_indices[2][1]\n\nmemory[ids.range_check_ptr + 1], memory[ids.range_check_ptr + 0] = (\n    divmod(lengths_and_indices[0][0], ids.PRIME_OVER_3_HIGH))\nmemory[ids.range_check_ptr + 3], memory[ids.range_check_ptr + 2] = (\n    divmod(lengths_and_indices[1][0], ids.PRIME_OVER_2_HIGH))"
+
+const ASSERT_LE_FELT_EXCLUDED_0 = "memory[ap] = 1 if excluded != 0 else 0"
+
+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"