Implement IS_QUAD_RESIDUE hint

cairo_programs/is_quad_residue.cairo

@@ -0,0 +1,43 @@
+%builtins output
+from starkware.cairo.common.serialize import serialize_word
+from starkware.cairo.common.math import is_quad_residue
+from starkware.cairo.common.alloc import alloc
+
+func fill_array(array_start: felt*, iter: felt) -> () {
+    if (iter == 8) {
+        return ();
+    }
+    assert array_start[iter] = iter;
+    return fill_array(array_start, iter + 1);
+}
+
+func check_quad_res{output_ptr: felt*}(inputs: felt*, expected: felt*, iter: felt) {
+    if (iter == 8) {
+        return ();
+    }
+    serialize_word(inputs[iter]);
+    serialize_word(expected[iter]);
+
+    assert is_quad_residue(inputs[iter]) = expected[iter];
+    return check_quad_res(inputs, expected, iter + 1);
+}
+
+func main{output_ptr: felt*}() {
+    alloc_locals;
+    let (inputs: felt*) = alloc();
+    fill_array(inputs, 0);
+
+    let (expected: felt*) = alloc();
+    assert expected[0] = 1;
+    assert expected[1] = 1;
+    assert expected[2] = 1;
+    assert expected[3] = 0;
+    assert expected[4] = 1;
+    assert expected[5] = 1;
+    assert expected[6] = 0;
+    assert expected[7] = 1;
+
+    check_quad_res(inputs, expected, 0);
+
+    return ();
+}

cairo_programs/proof_programs/is_quad_residue.cairo

@@ -0,0 +1,43 @@
+%builtins output
+from starkware.cairo.common.serialize import serialize_word
+from starkware.cairo.common.math import is_quad_residue
+from starkware.cairo.common.alloc import alloc
+
+func fill_array(array_start: felt*, iter: felt) -> () {
+    if (iter == 8) {
+        return ();
+    }
+    assert array_start[iter] = iter;
+    return fill_array(array_start, iter + 1);
+}
+
+func check_quad_res{output_ptr: felt*}(inputs: felt*, expected: felt*, iter: felt) {
+    if (iter == 8) {
+        return ();
+    }
+    serialize_word(inputs[iter]);
+    serialize_word(expected[iter]);
+
+    assert is_quad_residue(inputs[iter]) = expected[iter];
+    return check_quad_res(inputs, expected, iter + 1);
+}
+
+func main{output_ptr: felt*}() {
+    alloc_locals;
+    let (inputs: felt*) = alloc();
+    fill_array(inputs, 0);
+
+    let (expected: felt*) = alloc();
+    assert expected[0] = 1;
+    assert expected[1] = 1;
+    assert expected[2] = 1;
+    assert expected[3] = 0;
+    assert expected[4] = 1;
+    assert expected[5] = 1;
+    assert expected[6] = 0;
+    assert expected[7] = 1;
+
+    check_quad_res(inputs, expected, 0);
+
+    return ();
+}

pkg/hints/hint_processor.go

@@ -47,6 +47,8 @@ func (p *CairoVmHintProcessor) ExecuteHint(vm *vm.VirtualMachine, hintData *any,
 		return is_positive(data.Ids, vm)
 	case ASSERT_NOT_ZERO:
 		return assert_not_zero(data.Ids, vm)
+	case IS_QUAD_RESIDUE:
+		return is_quad_residue(data.Ids, vm)
 	case DEFAULT_DICT_NEW:
 		return defaultDictNew(data.Ids, execScopes, vm)
 	case DICT_READ:

pkg/hints/math_hint_codes.go

@@ -6,6 +6,15 @@ const IS_POSITIVE = "from starkware.cairo.common.math_utils import is_positive\n
 
 const ASSERT_NOT_ZERO = "from starkware.cairo.common.math_utils import assert_integer\nassert_integer(ids.value)\nassert ids.value % PRIME != 0, f'assert_not_zero failed: {ids.value} = 0.'"
 
+const IS_QUAD_RESIDUE = `from starkware.crypto.signature.signature import FIELD_PRIME
+from starkware.python.math_utils import div_mod, is_quad_residue, sqrt
+
+x = ids.x
+if is_quad_residue(x, FIELD_PRIME):
+    ids.y = sqrt(x, FIELD_PRIME)
+else:
+    ids.y = sqrt(div_mod(x, 3, FIELD_PRIME), FIELD_PRIME)`
+
 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)"

pkg/hints/math_hints.go

@@ -3,6 +3,7 @@ package hints
 import (
 	"github.com/lambdaclass/cairo-vm.go/pkg/builtins"
 	. "github.com/lambdaclass/cairo-vm.go/pkg/hints/hint_utils"
+	"github.com/lambdaclass/cairo-vm.go/pkg/lambdaworks"
 	. "github.com/lambdaclass/cairo-vm.go/pkg/lambdaworks"
 	. "github.com/lambdaclass/cairo-vm.go/pkg/math_utils"
 	. "github.com/lambdaclass/cairo-vm.go/pkg/vm"
@@ -65,6 +66,38 @@ func assert_not_zero(ids IdsManager, vm *VirtualMachine) error {
 	return nil
 }
 
+// Implements hint:from starkware.cairo.common.math.cairo
+//
+//	%{
+//		from starkware.crypto.signature.signature import FIELD_PRIME
+//		from starkware.python.math_utils import div_mod, is_quad_residue, sqrt
+//
+//		x = ids.x
+//		if is_quad_residue(x, FIELD_PRIME):
+//		    ids.y = sqrt(x, FIELD_PRIME)
+//		else:
+//		    ids.y = sqrt(div_mod(x, 3, FIELD_PRIME), FIELD_PRIME)
+//
+// %}
+func is_quad_residue(ids IdsManager, vm *VirtualMachine) error {
+	x, err := ids.GetFelt("x", vm)
+	if err != nil {
+		return err
+	}
+	if x.IsZero() || x.IsOne() {
+		ids.Insert("y", NewMaybeRelocatableFelt(x), vm)
+
+	} else if x.Pow(SignedFeltMaxValue()) == FeltOne() {
+		num := x.Sqrt()
+		ids.Insert("y", NewMaybeRelocatableFelt(num), vm)
+
+	} else {
+		num := (x.Div(lambdaworks.FeltFromUint64(3))).Sqrt()
+		ids.Insert("y", NewMaybeRelocatableFelt(num), vm)
+	}
+	return nil
+}
+
 func assert_not_equal(ids IdsManager, vm *VirtualMachine) error {
 	// Extract Ids Variables
 	a, err := ids.Get("a", vm)

pkg/lambdaworks/lambdaworks.go

@@ -144,10 +144,21 @@ func FeltOne() Felt {
 	return fromC(result)
 }
 
+// Gets the Signed Felt max value: 0x400000000000008800000000000000000000000000000000000000000000000
+func SignedFeltMaxValue() Felt {
+	var result C.felt_t
+	C.signed_felt_max_value(&result[0])
+	return fromC(result)
+}
+
 func (f Felt) IsZero() bool {
 	return f == FeltZero()
 }
 
+func (f Felt) IsOne() bool {
+	return f == FeltOne()
+}
+
 // Writes the result variable with the sum of a and b felts.
 func (a Felt) Add(b Felt) Felt {
 	var result C.felt_t
@@ -242,6 +253,23 @@ func (a Felt) PowUint(p uint32) Felt {
 	return fromC(result)
 }
 
+func (a Felt) Pow(p Felt) Felt {
+	var result C.felt_t
+	var a_c C.felt_t = a.toC()
+	var p_c C.felt_t = p.toC()
+
+	C.felt_pow(&a_c[0], &p_c[0], &result[0])
+	return fromC(result)
+}
+
+func (a Felt) Sqrt() Felt {
+	var result C.felt_t
+	var a_c C.felt_t = a.toC()
+
+	C.felt_sqrt(&a_c[0], &result[0])
+	return fromC(result)
+}
+
 func (a Felt) Shr(b uint) Felt {
 	var result C.felt_t
 	var a_c C.felt_t = a.toC()

pkg/lambdaworks/lambdaworks_test.go

@@ -466,6 +466,128 @@ func TestPow3(t *testing.T) {
 	}
 }
 
+func TestPowFelt(t *testing.T) {
+	felt_base := lambdaworks.FeltFromUint64(1233)
+	felt_exp := lambdaworks.FeltFromUint64(1233)
+
+	expected := lambdaworks.FeltFromDecString("3418065535446855313238995939000463244303872344528900201124636596003468607918")
+	result := felt_base.Pow(felt_exp)
+
+	if expected != result {
+		t.Errorf("TestPowFelt Failed, expecte: %v, got %v", expected, result)
+	}
+
+	felt_base = lambdaworks.FeltFromDecString("12383109480418712378780123")
+	felt_exp = lambdaworks.FeltFromDecString("91872587643897123781098123")
+
+	expected = lambdaworks.FeltFromDecString("2088955439096022421017346644949649198425019274657075865926754962561596407882")
+	result = felt_base.Pow(felt_exp)
+
+	if expected != result {
+		t.Errorf("TestPowFelt Failed, expecte: %v, got %v", expected, result)
+	}
+
+	felt_base = lambdaworks.FeltFromDecString("1480418712378780123123543345665445665445")
+	felt_exp = lambdaworks.FeltFromDecString("91872587643897345876123781098124353")
+
+	expected = lambdaworks.FeltFromDecString("3250055959035395902088721634924698439245455440785258481507488871970708539723")
+	result = felt_base.Pow(felt_exp)
+
+	if expected != result {
+		t.Errorf("TestPowFelt Failed, expecte: %v, got %v", expected, result)
+	}
+
+	felt_base = lambdaworks.FeltFromDecString("3250055959035395902088721634924698439245455440785258481507488871970708539723")
+	felt_exp = lambdaworks.FeltFromDecString("2088955439096022421017346644949649198425019274657075865926754962561596407882")
+
+	expected = lambdaworks.FeltFromDecString("2222900320242877003674481253396117682567674359625426155657415083745164507492")
+	result = felt_base.Pow(felt_exp)
+
+	if expected != result {
+		t.Errorf("TestPowFelt Failed, expecte: %v, got %v", expected, result)
+	}
+
+	felt_base = lambdaworks.FeltFromDecString("3")
+	felt_exp = lambdaworks.FeltFromDecString("1809251394333065606848661391547535052811553607665798349986546028067936010240")
+
+	expected = lambdaworks.FeltFromDecString("3618502788666131213697322783095070105623107215331596699973092056135872020480")
+	result = felt_base.Pow(felt_exp)
+
+	if expected != result {
+		t.Errorf("TestPowFelt Failed, expecte: %v, got %v", expected, result)
+	}
+
+	felt_base = lambdaworks.FeltFromDecString("6")
+	felt_exp = lambdaworks.FeltFromDecString("1809251394333065606848661391547535052811553607665798349986546028067936010240")
+
+	expected = lambdaworks.FeltFromDecString("3618502788666131213697322783095070105623107215331596699973092056135872020480")
+	result = felt_base.Pow(felt_exp)
+
+	if expected != result {
+		t.Errorf("TestPowFelt Failed, expecte: %v, got %v", expected, result)
+	}
+}
+
+func TestSqrt(t *testing.T) {
+
+	sqrt := lambdaworks.FeltFromDecString("1").Sqrt()
+	expect_res := lambdaworks.FeltFromDecString("1")
+
+	if sqrt != expect_res {
+		t.Errorf("TestSqrt Failed, expecte: %v, got %v", expect_res, sqrt)
+	}
+
+	sqrt = lambdaworks.FeltFromDecString("2").Sqrt()
+	expect_res = lambdaworks.FeltFromDecString("1120755473020101814179135767224264702961552391386192943129361948990833801454")
+
+	if sqrt != expect_res {
+		t.Errorf("TestSqrt Failed, expecte: %v, got %v", expect_res, sqrt)
+	}
+
+	sqrt = lambdaworks.FeltFromDecString("231354855").Sqrt()
+	expect_res = lambdaworks.FeltFromDecString("1025311277904211196612478135732240927612998008429122495456758581279557012570")
+
+	if sqrt != expect_res {
+		t.Errorf("TestSqrt Failed, expecte: %v, got %v", expect_res, sqrt)
+	}
+
+	sqrt = lambdaworks.FeltFromDecString("2837690996375263304037947136281").Sqrt()
+	expect_res = lambdaworks.FeltFromDecString("1518810120662201067233534392916286105989903317885218522014371199182069054395")
+
+	if sqrt != expect_res {
+		t.Errorf("TestSqrt Failed, expecte: %v, got %v", expect_res, sqrt)
+	}
+
+	sqrt = lambdaworks.FeltFromDecString("2412335192444087475798215188730046737082071476887756022673614366244186268173").Sqrt()
+	expect_res = lambdaworks.FeltFromDecString("1600105265616524426130944162206101590464382512931039575828824593677922684056")
+
+	if sqrt != expect_res {
+		t.Errorf("TestSqrt Failed, expecte: %v, got %v", expect_res, sqrt)
+	}
+
+	sqrt = lambdaworks.FeltFromDecString("836397911567565091").Sqrt()
+	expect_res = lambdaworks.FeltFromDecString("1471326547166706568879530640427725594549306523774764149866072915947254299525")
+
+	if sqrt != expect_res {
+		t.Errorf("TestSqrt Failed, expecte: %v, got %v", expect_res, sqrt)
+	}
+
+	sqrt = lambdaworks.FeltFromDecString("1206167596222043737899107594365023368541035738443865566657697352047277454118").Sqrt()
+	expect_res = lambdaworks.FeltFromDecString("1052329372911162474471895538435386694104976874815914718986386439764768300074")
+
+	if sqrt != expect_res {
+		t.Errorf("TestSqrt Failed, expecte: %v, got %v", expect_res, sqrt)
+	}
+
+	sqrt = lambdaworks.FeltFromDecString("1206167596222043737899107594365023368541035738443865566948239979431619043114").Sqrt()
+	expect_res = lambdaworks.FeltFromDecString("139198744922466627270517589217125805480206233967015957629136270350373167196")
+
+	if sqrt != expect_res {
+		t.Errorf("TestSqrt Failed, expecte: %v, got %v", expect_res, sqrt)
+	}
+
+}
+
 func TestFeltNeg1ToString(t *testing.T) {
 	f_neg_1 := lambdaworks.FeltFromDecString("-1")
 	expected := "-1"
@@ -520,3 +642,15 @@ func TestRelocatableToString(t *testing.T) {
 	}
 
 }
+
+func TestSignedMaxValue(t *testing.T) {
+
+	signed_max_value := lambdaworks.SignedFeltMaxValue()
+	str := signed_max_value.ToHexString()
+	expect_str := "0x400000000000008800000000000000000000000000000000000000000000000"
+
+	if signed_max_value.ToHexString() != expect_str {
+		t.Errorf("TestSignedMaxValue Failed, expecte: %s, got %s", expect_str, str)
+	}
+
+}

pkg/lambdaworks/lib/lambdaworks.h

@@ -43,6 +43,8 @@ void zero(felt_t result);
 /* Gets a felt_t representing 1 */
 void one(felt_t result);
 
+void signed_felt_max_value(felt_t result);
+
 /* Writes the result variable with the sum of a and b felts. */
 void add(felt_t a, felt_t b, felt_t result);
 
@@ -73,6 +75,11 @@ void felt_shl(felt_t a, uint64_t num, felt_t result);
 /* writes the result variable with a.pow(num) */
 void felt_pow_uint(felt_t a, uint32_t num, felt_t result);
 
+/* writes the result variable with a.pow(exponent) */
+void felt_pow(felt_t a, felt_t p, felt_t result);
+
+void felt_sqrt(felt_t a, felt_t result);
+
 /* returns the representation of a felt to string */
 char *to_signed_felt(felt_t value);