diff --git a/std/algebra/emulated/fields_bn254/e12.go b/std/algebra/emulated/fields_bn254/e12.go index f8492ee5f0..b6b65daf6e 100644 --- a/std/algebra/emulated/fields_bn254/e12.go +++ b/std/algebra/emulated/fields_bn254/e12.go @@ -1,5 +1,7 @@ package fields_bn254 +import "github.com/consensys/gnark-crypto/ecc/bn254" + type E12 struct { C0, C1 E6 } @@ -11,6 +13,25 @@ type Ext12 struct { func NewExt12(baseField *curveF) *Ext12 { return &Ext12{Ext6: NewExt6(baseField)} } + +func (e Ext12) Add(x, y *E12) *E12 { + z0 := e.Ext6.Add(&x.C0, &y.C0) // z.C0.Add(&x.A0, &y.A0) + z1 := e.Ext6.Add(&x.C1, &y.C1) // z.C1.Add(&x.A1, &y.A1) + return &E12{ + C0: *z0, + C1: *z1, + } +} + +func (e Ext12) Sub(x, y *E12) *E12 { + z0 := e.Ext6.Sub(&x.C0, &y.C0) // z.C0.Sub(&x.A0, &y.A0) + z1 := e.Ext6.Sub(&x.C1, &y.C1) // z.C1.Sub(&x.A1, &y.A1) + return &E12{ + C0: *z0, + C1: *z1, + } +} + func (e Ext12) Conjugate(x *E12) *E12 { z1 := e.Ext6.Neg(&x.C1) // z.C1.Neg(&z.C1) return &E12{ // return z @@ -224,3 +245,11 @@ func (e Ext12) AssertIsEqual(x, y *E12) { e.Ext6.AssertIsEqual(&x.C0, &y.C0) e.Ext6.AssertIsEqual(&x.C1, &y.C1) } + +func FromE12(y *bn254.E12) E12 { + return E12{ + C0: FromE6(&y.C0), + C1: FromE6(&y.C1), + } + +} diff --git a/std/algebra/emulated/fields_bn254/e12_pairing.go b/std/algebra/emulated/fields_bn254/e12_pairing.go index 59de7433e0..263f28c77f 100644 --- a/std/algebra/emulated/fields_bn254/e12_pairing.go +++ b/std/algebra/emulated/fields_bn254/e12_pairing.go @@ -43,11 +43,11 @@ func (e Ext12) MulBy034(z *E12, c0, c3, c4 *E2) *E12 { c0 = e.Ext2.Add(c0, c3) // c0.Add(c0, c3) d := e.Ext6.Add(&z.C0, &z.C1) // d.Add(&z.C0, &z.C1) d = e.Ext6.MulBy01(d, c0, c4) // d.MulBy01(c0, c4) - z1 := e.Add(a, b) // z.C1.Add(&a, &b). + z1 := e.Ext6.Add(a, b) // z.C1.Add(&a, &b). z1 = e.Neg(z1) // Neg(&z.C1). - z1 = e.Add(z1, d) // Add(&z.C1, &d) + z1 = e.Ext6.Add(z1, d) // Add(&z.C1, &d) z0 := e.MulByNonResidue(b) // z.C0.MulByNonResidue(&b). - z0 = e.Add(z0, a) // Add(&z.C0, &a) + z0 = e.Ext6.Add(z0, a) // Add(&z.C0, &a) return &E12{ // return z C0: *z0, C1: *z1, diff --git a/std/algebra/emulated/fields_bn254/e12_test.go b/std/algebra/emulated/fields_bn254/e12_test.go new file mode 100644 index 0000000000..fced3de604 --- /dev/null +++ b/std/algebra/emulated/fields_bn254/e12_test.go @@ -0,0 +1,326 @@ +package fields_bn254 + +import ( + "testing" + + "github.com/consensys/gnark-crypto/ecc" + "github.com/consensys/gnark-crypto/ecc/bn254" + "github.com/consensys/gnark/frontend" + "github.com/consensys/gnark/std/math/emulated" + "github.com/consensys/gnark/test" +) + +type e12Add struct { + A, B, C E12 +} + +func (circuit *e12Add) Define(api frontend.API) error { + ba, _ := emulated.NewField[emulated.BN254Fp](api) + e := NewExt12(ba) + expected := e.Add(&circuit.A, &circuit.B) + e.AssertIsEqual(expected, &circuit.C) + return nil +} + +func TestAddFp12(t *testing.T) { + + assert := test.NewAssert(t) + // witness values + var a, b, c bn254.E12 + _, _ = a.SetRandom() + _, _ = b.SetRandom() + c.Add(&a, &b) + + witness := e12Add{ + A: FromE12(&a), + B: FromE12(&b), + C: FromE12(&c), + } + + err := test.IsSolved(&e12Add{}, &witness, ecc.BN254.ScalarField()) + assert.NoError(err) + +} + +type e12Sub struct { + A, B, C E12 +} + +func (circuit *e12Sub) Define(api frontend.API) error { + ba, _ := emulated.NewField[emulated.BN254Fp](api) + e := NewExt12(ba) + expected := e.Sub(&circuit.A, &circuit.B) + e.AssertIsEqual(expected, &circuit.C) + return nil +} + +func TestSubFp12(t *testing.T) { + + assert := test.NewAssert(t) + // witness values + var a, b, c bn254.E12 + _, _ = a.SetRandom() + _, _ = b.SetRandom() + c.Sub(&a, &b) + + witness := e12Sub{ + A: FromE12(&a), + B: FromE12(&b), + C: FromE12(&c), + } + + err := test.IsSolved(&e12Sub{}, &witness, ecc.BN254.ScalarField()) + assert.NoError(err) + +} + +type e12Mul struct { + A, B, C E12 +} + +func (circuit *e12Mul) Define(api frontend.API) error { + ba, _ := emulated.NewField[emulated.BN254Fp](api) + e := NewExt12(ba) + + expected := e.Mul(&circuit.A, &circuit.B) + e.AssertIsEqual(expected, &circuit.C) + return nil +} + +func TestMulFp12(t *testing.T) { + + assert := test.NewAssert(t) + // witness values + var a, b, c bn254.E12 + _, _ = a.SetRandom() + _, _ = b.SetRandom() + c.Mul(&a, &b) + + witness := e12Mul{ + A: FromE12(&a), + B: FromE12(&b), + C: FromE12(&c), + } + + err := test.IsSolved(&e12Mul{}, &witness, ecc.BN254.ScalarField()) + assert.NoError(err) + +} + +type e12MulBy034by034 struct { + C0, C3, C4 E2 + D0, D3, D4 E2 + C E12 `gnark:",public"` +} + +func (circuit *e12MulBy034by034) Define(api frontend.API) error { + ba, _ := emulated.NewField[emulated.BN254Fp](api) + e := NewExt12(ba) + expected := e.MulBy034by034(&circuit.C0, &circuit.C3, &circuit.C4, &circuit.D0, &circuit.D3, &circuit.D4) + e.AssertIsEqual(expected, &circuit.C) + + return nil +} + +func TestMulFp12By034by034(t *testing.T) { + + assert := test.NewAssert(t) + // witness values + var c bn254.E12 + var c0, c3, c4, d0, d3, d4 bn254.E2 + _, _ = c0.SetRandom() + _, _ = c3.SetRandom() + _, _ = c4.SetRandom() + _, _ = d0.SetRandom() + _, _ = d3.SetRandom() + _, _ = d4.SetRandom() + c.Mul034by034(&c0, &c3, &c4, &d0, &d3, &d4) + + witness := e12MulBy034by034{ + C0: FromE2(&c0), + C3: FromE2(&c3), + C4: FromE2(&c4), + D0: FromE2(&d0), + D3: FromE2(&d3), + D4: FromE2(&d4), + C: FromE12(&c), + } + + err := test.IsSolved(&e12MulBy034by034{}, &witness, ecc.BN254.ScalarField()) + assert.NoError(err) + +} + +type e12Square struct { + A, C E12 +} + +func (circuit *e12Square) Define(api frontend.API) error { + ba, _ := emulated.NewField[emulated.BN254Fp](api) + e := NewExt12(ba) + + expected := e.Square(&circuit.A) + e.AssertIsEqual(expected, &circuit.C) + return nil +} + +func TestSquareFp12(t *testing.T) { + + assert := test.NewAssert(t) + // witness values + var a, c bn254.E12 + _, _ = a.SetRandom() + c.Square(&a) + + witness := e12Square{ + A: FromE12(&a), + C: FromE12(&c), + } + + err := test.IsSolved(&e12Square{}, &witness, ecc.BN254.ScalarField()) + assert.NoError(err) + +} + +type e12CycloSquare struct { + A E12 + C E12 `gnark:",public"` +} + +func (circuit *e12CycloSquare) Define(api frontend.API) error { + + ba, _ := emulated.NewField[emulated.BN254Fp](api) + e := NewExt12(ba) + u := e.Square(&circuit.A) + v := e.CyclotomicSquare(&circuit.A) + e.AssertIsEqual(u, v) + e.AssertIsEqual(u, &circuit.C) + return nil +} + +func TestFp12CyclotomicSquare(t *testing.T) { + + assert := test.NewAssert(t) + // witness values + var a, c bn254.E12 + _, _ = a.SetRandom() + + // put a in the cyclotomic subgroup + var tmp bn254.E12 + tmp.Conjugate(&a) + a.Inverse(&a) + tmp.Mul(&tmp, &a) + a.FrobeniusSquare(&tmp).Mul(&a, &tmp) + c.CyclotomicSquare(&a) + + witness := e12CycloSquare{ + A: FromE12(&a), + C: FromE12(&c), + } + + err := test.IsSolved(&e12CycloSquare{}, &witness, ecc.BN254.ScalarField()) + assert.NoError(err) +} + +type e12Conjugate struct { + A E12 + C E12 `gnark:",public"` +} + +func (circuit *e12Conjugate) Define(api frontend.API) error { + ba, _ := emulated.NewField[emulated.BN254Fp](api) + e := NewExt12(ba) + expected := e.Conjugate(&circuit.A) + e.AssertIsEqual(expected, &circuit.C) + + return nil +} + +func TestConjugateFp12(t *testing.T) { + + assert := test.NewAssert(t) + // witness values + var a, c bn254.E12 + _, _ = a.SetRandom() + c.Conjugate(&a) + + witness := e12Conjugate{ + A: FromE12(&a), + C: FromE12(&c), + } + + err := test.IsSolved(&e12Conjugate{}, &witness, ecc.BN254.ScalarField()) + assert.NoError(err) +} + +type e12Inverse struct { + A E12 + C E12 `gnark:",public"` +} + +func (circuit *e12Inverse) Define(api frontend.API) error { + + ba, _ := emulated.NewField[emulated.BN254Fp](api) + e := NewExt12(ba) + expected := e.Inverse(&circuit.A) + e.AssertIsEqual(expected, &circuit.C) + + return nil +} + +func TestInverseFp12(t *testing.T) { + + assert := test.NewAssert(t) + // witness values + var a, c bn254.E12 + _, _ = a.SetRandom() + c.Inverse(&a) + + witness := e12Inverse{ + A: FromE12(&a), + C: FromE12(&c), + } + + err := test.IsSolved(&e12Inverse{}, &witness, ecc.BN254.ScalarField()) + assert.NoError(err) +} + +type e12Expt struct { + A E12 + C E12 `gnark:",public"` +} + +func (circuit *e12Expt) Define(api frontend.API) error { + + ba, _ := emulated.NewField[emulated.BN254Fp](api) + e := NewExt12(ba) + expected := e.Expt(&circuit.A) + e.AssertIsEqual(expected, &circuit.C) + + return nil +} + +func TestFp12Expt(t *testing.T) { + + assert := test.NewAssert(t) + // witness values + var a, c bn254.E12 + _, _ = a.SetRandom() + + // put a in the cyclotomic subgroup + var tmp bn254.E12 + tmp.Conjugate(&a) + a.Inverse(&a) + tmp.Mul(&tmp, &a) + a.FrobeniusSquare(&tmp).Mul(&a, &tmp) + + c.Expt(&a) + + witness := e12Expt{ + A: FromE12(&a), + C: FromE12(&c), + } + + err := test.IsSolved(&e12Expt{}, &witness, ecc.BN254.ScalarField()) + assert.NoError(err) +} diff --git a/std/algebra/emulated/fields_bn254/e2.go b/std/algebra/emulated/fields_bn254/e2.go index 8ba71003c7..63fdc6f78c 100644 --- a/std/algebra/emulated/fields_bn254/e2.go +++ b/std/algebra/emulated/fields_bn254/e2.go @@ -3,6 +3,7 @@ package fields_bn254 import ( "math/big" + "github.com/consensys/gnark-crypto/ecc/bn254" "github.com/consensys/gnark/std/math/emulated" ) @@ -310,3 +311,11 @@ func (e Ext2) AssertIsEqual(x, y *E2) { e.fp.AssertIsEqual(&x.A0, &y.A0) e.fp.AssertIsEqual(&x.A1, &y.A1) } + +func FromE2(y *bn254.E2) E2 { + return E2{ + A0: emulated.ValueOf[emulated.BN254Fp](y.A0), + A1: emulated.ValueOf[emulated.BN254Fp](y.A1), + } + +} diff --git a/std/algebra/emulated/fields_bn254/e2_test.go b/std/algebra/emulated/fields_bn254/e2_test.go new file mode 100644 index 0000000000..99b2db5aa1 --- /dev/null +++ b/std/algebra/emulated/fields_bn254/e2_test.go @@ -0,0 +1,429 @@ +package fields_bn254 + +import ( + "testing" + + "github.com/consensys/gnark-crypto/ecc" + "github.com/consensys/gnark-crypto/ecc/bn254" + "github.com/consensys/gnark-crypto/ecc/bn254/fp" + "github.com/consensys/gnark/frontend" + "github.com/consensys/gnark/std/math/emulated" + "github.com/consensys/gnark/test" +) + +type e2Add struct { + A, B, C E2 +} + +func (circuit *e2Add) Define(api frontend.API) error { + ba, _ := emulated.NewField[emulated.BN254Fp](api) + e := NewExt2(ba) + expected := e.Add(&circuit.A, &circuit.B) + e.AssertIsEqual(expected, &circuit.C) + return nil +} + +func TestAddFp2(t *testing.T) { + + assert := test.NewAssert(t) + // witness values + var a, b, c bn254.E2 + _, _ = a.SetRandom() + _, _ = b.SetRandom() + c.Add(&a, &b) + + witness := e2Add{ + A: FromE2(&a), + B: FromE2(&b), + C: FromE2(&c), + } + + err := test.IsSolved(&e2Add{}, &witness, ecc.BN254.ScalarField()) + assert.NoError(err) + +} + +type e2Sub struct { + A, B, C E2 +} + +func (circuit *e2Sub) Define(api frontend.API) error { + ba, _ := emulated.NewField[emulated.BN254Fp](api) + e := NewExt2(ba) + expected := e.Sub(&circuit.A, &circuit.B) + e.AssertIsEqual(expected, &circuit.C) + return nil +} + +func TestSubFp2(t *testing.T) { + + assert := test.NewAssert(t) + // witness values + var a, b, c bn254.E2 + _, _ = a.SetRandom() + _, _ = b.SetRandom() + c.Sub(&a, &b) + + witness := e2Sub{ + A: FromE2(&a), + B: FromE2(&b), + C: FromE2(&c), + } + + err := test.IsSolved(&e2Sub{}, &witness, ecc.BN254.ScalarField()) + assert.NoError(err) + +} + +type e2Double struct { + A, C E2 +} + +func (circuit *e2Double) Define(api frontend.API) error { + ba, _ := emulated.NewField[emulated.BN254Fp](api) + e := NewExt2(ba) + expected := e.Double(&circuit.A) + e.AssertIsEqual(expected, &circuit.C) + return nil +} + +func TestDoubleFp2(t *testing.T) { + + assert := test.NewAssert(t) + // witness values + var a, b, c bn254.E2 + _, _ = a.SetRandom() + _, _ = b.SetRandom() + c.Double(&a) + + witness := e2Double{ + A: FromE2(&a), + C: FromE2(&c), + } + + err := test.IsSolved(&e2Double{}, &witness, ecc.BN254.ScalarField()) + assert.NoError(err) + +} + +type e2Halve struct { + A, C E2 +} + +func (circuit *e2Halve) Define(api frontend.API) error { + ba, _ := emulated.NewField[emulated.BN254Fp](api) + e := NewExt2(ba) + expected := e.Halve(&circuit.A) + e.AssertIsEqual(expected, &circuit.C) + return nil +} + +func TestHalveFp2(t *testing.T) { + + assert := test.NewAssert(t) + // witness values + var a, b, c bn254.E2 + _, _ = a.SetRandom() + _, _ = b.SetRandom() + c = a + c.Halve() + + witness := e2Halve{ + A: FromE2(&a), + C: FromE2(&c), + } + + err := test.IsSolved(&e2Halve{}, &witness, ecc.BN254.ScalarField()) + assert.NoError(err) + +} + +type e2Mul struct { + A, B, C E2 +} + +func (circuit *e2Mul) Define(api frontend.API) error { + ba, _ := emulated.NewField[emulated.BN254Fp](api) + e := NewExt2(ba) + + expected := e.Mul(&circuit.A, &circuit.B) + e.AssertIsEqual(expected, &circuit.C) + return nil +} + +func TestMulFp2(t *testing.T) { + + assert := test.NewAssert(t) + // witness values + var a, b, c bn254.E2 + _, _ = a.SetRandom() + _, _ = b.SetRandom() + c.Mul(&a, &b) + + witness := e2Mul{ + A: FromE2(&a), + B: FromE2(&b), + C: FromE2(&c), + } + + err := test.IsSolved(&e2Mul{}, &witness, ecc.BN254.ScalarField()) + assert.NoError(err) + +} + +type e2Square struct { + A, C E2 +} + +func (circuit *e2Square) Define(api frontend.API) error { + ba, _ := emulated.NewField[emulated.BN254Fp](api) + e := NewExt2(ba) + + expected := e.Square(&circuit.A) + e.AssertIsEqual(expected, &circuit.C) + return nil +} + +func TestSquareFp2(t *testing.T) { + + assert := test.NewAssert(t) + // witness values + var a, c bn254.E2 + _, _ = a.SetRandom() + c.Square(&a) + + witness := e2Square{ + A: FromE2(&a), + C: FromE2(&c), + } + + err := test.IsSolved(&e2Square{}, &witness, ecc.BN254.ScalarField()) + assert.NoError(err) + +} + +type e2MulByElement struct { + A E2 + B baseEl + C E2 `gnark:",public"` +} + +func (circuit *e2MulByElement) Define(api frontend.API) error { + ba, _ := emulated.NewField[emulated.BN254Fp](api) + e := NewExt2(ba) + expected := e.MulByElement(&circuit.A, &circuit.B) + e.AssertIsEqual(expected, &circuit.C) + + return nil +} + +func TestMulByElement(t *testing.T) { + + assert := test.NewAssert(t) + // witness values + var a, c bn254.E2 + var b fp.Element + _, _ = a.SetRandom() + _, _ = b.SetRandom() + c.MulByElement(&a, &b) + + witness := e2MulByElement{ + A: FromE2(&a), + B: emulated.ValueOf[emulated.BN254Fp](b), + C: FromE2(&c), + } + + err := test.IsSolved(&e2MulByElement{}, &witness, ecc.BN254.ScalarField()) + assert.NoError(err) + +} + +type e2MulBybTwistCurveCoeff struct { + A E2 + C E2 `gnark:",public"` +} + +func (circuit *e2MulBybTwistCurveCoeff) Define(api frontend.API) error { + ba, _ := emulated.NewField[emulated.BN254Fp](api) + e := NewExt2(ba) + expected := e.MulBybTwistCurveCoeff(&circuit.A) + e.AssertIsEqual(expected, &circuit.C) + + return nil +} + +func TestMulFp2BybTwistCurveCoeff(t *testing.T) { + + assert := test.NewAssert(t) + // witness values + var a, c bn254.E2 + _, _ = a.SetRandom() + c.MulBybTwistCurveCoeff(&a) + + witness := e2MulBybTwistCurveCoeff{ + A: FromE2(&a), + C: FromE2(&c), + } + + err := test.IsSolved(&e2MulBybTwistCurveCoeff{}, &witness, ecc.BN254.ScalarField()) + assert.NoError(err) + +} + +type e2MulByNonResidue struct { + A E2 + C E2 `gnark:",public"` +} + +func (circuit *e2MulByNonResidue) Define(api frontend.API) error { + ba, _ := emulated.NewField[emulated.BN254Fp](api) + e := NewExt2(ba) + expected := e.MulByNonResidue(&circuit.A) + e.AssertIsEqual(expected, &circuit.C) + + return nil +} + +func TestMulFp2ByNonResidue(t *testing.T) { + + assert := test.NewAssert(t) + // witness values + var a, c bn254.E2 + _, _ = a.SetRandom() + c.MulByNonResidue(&a) + + witness := e2MulByNonResidue{ + A: FromE2(&a), + C: FromE2(&c), + } + + err := test.IsSolved(&e2MulByNonResidue{}, &witness, ecc.BN254.ScalarField()) + assert.NoError(err) + +} + +type e2MulByNonResidueInv struct { + A E2 + C E2 `gnark:",public"` +} + +func (circuit *e2MulByNonResidueInv) Define(api frontend.API) error { + ba, _ := emulated.NewField[emulated.BN254Fp](api) + e := NewExt2(ba) + expected := e.MulByNonResidueInv(&circuit.A) + e.AssertIsEqual(expected, &circuit.C) + + return nil +} + +func TestMulFp2ByNonResidueInv(t *testing.T) { + + assert := test.NewAssert(t) + // witness values + var a, c bn254.E2 + _, _ = a.SetRandom() + c.MulByNonResidueInv(&a) + + witness := e2MulByNonResidueInv{ + A: FromE2(&a), + C: FromE2(&c), + } + + err := test.IsSolved(&e2MulByNonResidueInv{}, &witness, ecc.BN254.ScalarField()) + assert.NoError(err) + +} + +type e2Neg struct { + A E2 + C E2 `gnark:",public"` +} + +func (circuit *e2Neg) Define(api frontend.API) error { + ba, _ := emulated.NewField[emulated.BN254Fp](api) + e := NewExt2(ba) + expected := e.Neg(&circuit.A) + e.AssertIsEqual(expected, &circuit.C) + + return nil +} + +func TestNegFp2(t *testing.T) { + + assert := test.NewAssert(t) + // witness values + var a, c bn254.E2 + _, _ = a.SetRandom() + c.Neg(&a) + + witness := e2Neg{ + A: FromE2(&a), + C: FromE2(&c), + } + + err := test.IsSolved(&e2Neg{}, &witness, ecc.BN254.ScalarField()) + assert.NoError(err) +} + +type e2Conjugate struct { + A E2 + C E2 `gnark:",public"` +} + +func (circuit *e2Conjugate) Define(api frontend.API) error { + ba, _ := emulated.NewField[emulated.BN254Fp](api) + e := NewExt2(ba) + expected := e.Conjugate(&circuit.A) + e.AssertIsEqual(expected, &circuit.C) + + return nil +} + +func TestConjugateFp2(t *testing.T) { + + assert := test.NewAssert(t) + // witness values + var a, c bn254.E2 + _, _ = a.SetRandom() + c.Conjugate(&a) + + witness := e2Conjugate{ + A: FromE2(&a), + C: FromE2(&c), + } + + err := test.IsSolved(&e2Conjugate{}, &witness, ecc.BN254.ScalarField()) + assert.NoError(err) +} + +type e2Inverse struct { + A E2 + C E2 `gnark:",public"` +} + +func (circuit *e2Inverse) Define(api frontend.API) error { + + ba, _ := emulated.NewField[emulated.BN254Fp](api) + e := NewExt2(ba) + expected := e.Inverse(&circuit.A) + e.AssertIsEqual(expected, &circuit.C) + + return nil +} + +func TestInverseFp2(t *testing.T) { + + assert := test.NewAssert(t) + // witness values + var a, c bn254.E2 + _, _ = a.SetRandom() + c.Inverse(&a) + + witness := e2Inverse{ + A: FromE2(&a), + C: FromE2(&c), + } + + err := test.IsSolved(&e2Inverse{}, &witness, ecc.BN254.ScalarField()) + assert.NoError(err) +} diff --git a/std/algebra/emulated/fields_bn254/e6.go b/std/algebra/emulated/fields_bn254/e6.go index a07d04d015..9120a33f18 100644 --- a/std/algebra/emulated/fields_bn254/e6.go +++ b/std/algebra/emulated/fields_bn254/e6.go @@ -1,5 +1,9 @@ package fields_bn254 +import ( + "github.com/consensys/gnark-crypto/ecc/bn254" +) + type E6 struct { B0, B1, B2 E2 } @@ -199,3 +203,12 @@ func (e Ext6) AssertIsEqual(x, y *E6) { e.Ext2.AssertIsEqual(&x.B1, &y.B1) e.Ext2.AssertIsEqual(&x.B2, &y.B2) } + +func FromE6(y *bn254.E6) E6 { + return E6{ + B0: FromE2(&y.B0), + B1: FromE2(&y.B1), + B2: FromE2(&y.B2), + } + +} diff --git a/std/algebra/emulated/fields_bn254/e6_test.go b/std/algebra/emulated/fields_bn254/e6_test.go new file mode 100644 index 0000000000..f37c6ba24d --- /dev/null +++ b/std/algebra/emulated/fields_bn254/e6_test.go @@ -0,0 +1,309 @@ +package fields_bn254 + +import ( + "testing" + + "github.com/consensys/gnark-crypto/ecc" + "github.com/consensys/gnark-crypto/ecc/bn254" + "github.com/consensys/gnark/frontend" + "github.com/consensys/gnark/std/math/emulated" + "github.com/consensys/gnark/test" +) + +type e6Add struct { + A, B, C E6 +} + +func (circuit *e6Add) Define(api frontend.API) error { + ba, _ := emulated.NewField[emulated.BN254Fp](api) + e := NewExt6(ba) + expected := e.Add(&circuit.A, &circuit.B) + e.AssertIsEqual(expected, &circuit.C) + return nil +} + +func TestAddFp6(t *testing.T) { + + assert := test.NewAssert(t) + // witness values + var a, b, c bn254.E6 + _, _ = a.SetRandom() + _, _ = b.SetRandom() + c.Add(&a, &b) + + witness := e6Add{ + A: FromE6(&a), + B: FromE6(&b), + C: FromE6(&c), + } + + err := test.IsSolved(&e6Add{}, &witness, ecc.BN254.ScalarField()) + assert.NoError(err) + +} + +type e6Sub struct { + A, B, C E6 +} + +func (circuit *e6Sub) Define(api frontend.API) error { + ba, _ := emulated.NewField[emulated.BN254Fp](api) + e := NewExt6(ba) + expected := e.Sub(&circuit.A, &circuit.B) + e.AssertIsEqual(expected, &circuit.C) + return nil +} + +func TestSubFp6(t *testing.T) { + + assert := test.NewAssert(t) + // witness values + var a, b, c bn254.E6 + _, _ = a.SetRandom() + _, _ = b.SetRandom() + c.Sub(&a, &b) + + witness := e6Sub{ + A: FromE6(&a), + B: FromE6(&b), + C: FromE6(&c), + } + + err := test.IsSolved(&e6Sub{}, &witness, ecc.BN254.ScalarField()) + assert.NoError(err) + +} + +type e6Mul struct { + A, B, C E6 +} + +func (circuit *e6Mul) Define(api frontend.API) error { + ba, _ := emulated.NewField[emulated.BN254Fp](api) + e := NewExt6(ba) + + expected := e.Mul(&circuit.A, &circuit.B) + e.AssertIsEqual(expected, &circuit.C) + return nil +} + +func TestMulFp6(t *testing.T) { + + assert := test.NewAssert(t) + // witness values + var a, b, c bn254.E6 + _, _ = a.SetRandom() + _, _ = b.SetRandom() + c.Mul(&a, &b) + + witness := e6Mul{ + A: FromE6(&a), + B: FromE6(&b), + C: FromE6(&c), + } + + err := test.IsSolved(&e6Mul{}, &witness, ecc.BN254.ScalarField()) + assert.NoError(err) + +} + +type e6Square struct { + A, C E6 +} + +func (circuit *e6Square) Define(api frontend.API) error { + ba, _ := emulated.NewField[emulated.BN254Fp](api) + e := NewExt6(ba) + + expected := e.Square(&circuit.A) + e.AssertIsEqual(expected, &circuit.C) + return nil +} + +func TestSquareFp6(t *testing.T) { + + assert := test.NewAssert(t) + // witness values + var a, c bn254.E6 + _, _ = a.SetRandom() + c.Square(&a) + + witness := e6Square{ + A: FromE6(&a), + C: FromE6(&c), + } + + err := test.IsSolved(&e6Square{}, &witness, ecc.BN254.ScalarField()) + assert.NoError(err) + +} + +type e6MulByNonResidue struct { + A E6 + C E6 `gnark:",public"` +} + +func (circuit *e6MulByNonResidue) Define(api frontend.API) error { + ba, _ := emulated.NewField[emulated.BN254Fp](api) + e := NewExt6(ba) + expected := e.MulByNonResidue(&circuit.A) + e.AssertIsEqual(expected, &circuit.C) + + return nil +} + +func TestMulFp6ByNonResidue(t *testing.T) { + + assert := test.NewAssert(t) + // witness values + var a, c bn254.E6 + _, _ = a.SetRandom() + c.MulByNonResidue(&a) + + witness := e6MulByNonResidue{ + A: FromE6(&a), + C: FromE6(&c), + } + + err := test.IsSolved(&e6MulByNonResidue{}, &witness, ecc.BN254.ScalarField()) + assert.NoError(err) + +} + +type e6MulByE2 struct { + A E6 + B E2 + C E6 `gnark:",public"` +} + +func (circuit *e6MulByE2) Define(api frontend.API) error { + ba, _ := emulated.NewField[emulated.BN254Fp](api) + e := NewExt6(ba) + expected := e.MulByE2(&circuit.A, &circuit.B) + e.AssertIsEqual(expected, &circuit.C) + + return nil +} + +func TestMulFp6ByE2(t *testing.T) { + + assert := test.NewAssert(t) + // witness values + var a, c bn254.E6 + var b bn254.E2 + _, _ = a.SetRandom() + _, _ = b.SetRandom() + c.MulByE2(&a, &b) + + witness := e6MulByE2{ + A: FromE6(&a), + B: FromE2(&b), + C: FromE6(&c), + } + + err := test.IsSolved(&e6MulByE2{}, &witness, ecc.BN254.ScalarField()) + assert.NoError(err) + +} + +type e6MulBy01 struct { + A E6 + C0, C1 E2 + C E6 `gnark:",public"` +} + +func (circuit *e6MulBy01) Define(api frontend.API) error { + ba, _ := emulated.NewField[emulated.BN254Fp](api) + e := NewExt6(ba) + expected := e.MulBy01(&circuit.A, &circuit.C0, &circuit.C1) + e.AssertIsEqual(expected, &circuit.C) + + return nil +} + +func TestMulFp6By01(t *testing.T) { + + assert := test.NewAssert(t) + // witness values + var a, c bn254.E6 + var C0, C1 bn254.E2 + _, _ = a.SetRandom() + _, _ = C0.SetRandom() + _, _ = C1.SetRandom() + c.Set(&a) + c.MulBy01(&C0, &C1) + + witness := e6MulBy01{ + A: FromE6(&a), + C0: FromE2(&C0), + C1: FromE2(&C1), + C: FromE6(&c), + } + + err := test.IsSolved(&e6MulBy01{}, &witness, ecc.BN254.ScalarField()) + assert.NoError(err) + +} + +type e6Neg struct { + A E6 + C E6 `gnark:",public"` +} + +func (circuit *e6Neg) Define(api frontend.API) error { + ba, _ := emulated.NewField[emulated.BN254Fp](api) + e := NewExt6(ba) + expected := e.Neg(&circuit.A) + e.AssertIsEqual(expected, &circuit.C) + + return nil +} + +func TestNegFp6(t *testing.T) { + + assert := test.NewAssert(t) + // witness values + var a, c bn254.E6 + _, _ = a.SetRandom() + c.Neg(&a) + + witness := e6Neg{ + A: FromE6(&a), + C: FromE6(&c), + } + + err := test.IsSolved(&e6Neg{}, &witness, ecc.BN254.ScalarField()) + assert.NoError(err) +} + +type e6Inverse struct { + A E6 + C E6 `gnark:",public"` +} + +func (circuit *e6Inverse) Define(api frontend.API) error { + + ba, _ := emulated.NewField[emulated.BN254Fp](api) + e := NewExt6(ba) + expected := e.Inverse(&circuit.A) + e.AssertIsEqual(expected, &circuit.C) + + return nil +} + +func TestInverseFp6(t *testing.T) { + + assert := test.NewAssert(t) + // witness values + var a, c bn254.E6 + _, _ = a.SetRandom() + c.Inverse(&a) + + witness := e6Inverse{ + A: FromE6(&a), + C: FromE6(&c), + } + + err := test.IsSolved(&e6Inverse{}, &witness, ecc.BN254.ScalarField()) + assert.NoError(err) +}