Test: emulated/fields_bn254

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),
+	}
+
+}

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,

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