Unexpected output in CosineSimilarityCircuit when utilizing AssertIsEqual

[sigridjineth]

Hello,

I'm new to writing gnark circuits directly, without using any DSLs like Circom, and I've encountered an issue with my CosineSimilarityCircuit.

In my CosineSimilarityCircuit test, I've set CS_RAW to 0 at runtime. However, when I run the test, I receive an error message where c.CS is not 0 but a (weirdly) large number.

Here's the error message:

Error:      	groth16(bn254): [assertIsEqual] 50216813883093446110346033018740392865355468948280507891712 == 50216813883093446110547209845212575495486108231950859142099
emulated.(*Field[...]).rsh
field_assert.go:56
emulated.(*Field[...]).assertLimbsEqualitySlow
field_assert.go:35
emulated.(*Field[...]).AssertLimbsEquality
field_assert.go:88
emulated.(*Field[...]).AssertIsEqual
field_assert.go:144
cosine-similiarity.(*CosineSimilarityCircuit).Define
main.go:41

Here is the link to the CosineSimilarityCircuit test and the CosineSimilarityCircuit definition:

// main_test.go
package main

import (
	"fmt"
	"github.com/consensys/gnark-crypto/ecc"
	"github.com/consensys/gnark/backend"
	"github.com/consensys/gnark/std"
	"github.com/consensys/gnark/std/math/emulated"
	"github.com/consensys/gnark/test"
	"math"
	"testing"
)

func TestCosineSimilarity(t *testing.T) {
	assert := test.NewAssert(t)
	std.RegisterHints()

	var circuit CosineSimilarityCircuit

	// Define your vectors as quadratic residues
	A := [2]float64{2, 4}
	B := [2]float64{4, 16}

	// Calculate the square roots of the magnitudes
	sqrtMagnitudeA := math.Sqrt(A[0]*A[0] + A[1]*A[1])
	sqrtMagnitudeB := math.Sqrt(B[0]*B[0] + B[1]*B[1])

	// Calculate the cosine similarity
	dotProduct := A[0]*B[0] + A[1]*B[1]
	cosineSimilarity := dotProduct / (sqrtMagnitudeA * sqrtMagnitudeB)

	// Scale factor
	scaleFactor := 1.0

	witnessA_X := fmt.Sprintf("%d", int64(A[0]*scaleFactor))
	witnessA_Y := fmt.Sprintf("%d", int64(A[1]*scaleFactor))
	witnessB_X := fmt.Sprintf("%d", int64(B[0]*scaleFactor))
	witnessB_Y := fmt.Sprintf("%d", int64(B[1]*scaleFactor))
	CS_RAW := fmt.Sprintf("%d", int64(cosineSimilarity*scaleFactor))
	SQRT_MAG_A := fmt.Sprintf("%d", int64(sqrtMagnitudeA*scaleFactor))
	SQRT_MAG_B := fmt.Sprintf("%d", int64(sqrtMagnitudeB*scaleFactor))
	EPSILON_RAW := fmt.Sprintf("%d", int64(1*scaleFactor))

	witness := &CosineSimilarityCircuit{
		A_X:            emulated.ValueOf[emulated.Secp256k1Fp](witnessA_X),
		A_Y:            emulated.ValueOf[emulated.Secp256k1Fp](witnessA_Y),
		B_X:            emulated.ValueOf[emulated.Secp256k1Fp](witnessB_X),
		B_Y:            emulated.ValueOf[emulated.Secp256k1Fp](witnessB_Y),
		CS:             emulated.ValueOf[emulated.Secp256k1Fp](CS_RAW),
		SqrtMagnitudeA: emulated.ValueOf[emulated.Secp256k1Fp](SQRT_MAG_A),
		SqrtMagnitudeB: emulated.ValueOf[emulated.Secp256k1Fp](SQRT_MAG_B),
		Epsilon:        emulated.ValueOf[emulated.Secp256k1Fp](EPSILON_RAW),
	}

	assert.ProverSucceeded(&circuit, witness, test.WithCurves(ecc.BN254), test.WithBackends(backend.GROTH16), test.NoSerialization())
}

// main.go
package main

import (
	"github.com/consensys/gnark/frontend"
	"github.com/consensys/gnark/std/math/emulated"
)

type CosineSimilarityCircuit struct {
	A_X            emulated.Element[emulated.Secp256k1Fp]
	A_Y            emulated.Element[emulated.Secp256k1Fp]
	B_X            emulated.Element[emulated.Secp256k1Fp]
	B_Y            emulated.Element[emulated.Secp256k1Fp]
	CS             emulated.Element[emulated.Secp256k1Fp]
	SqrtMagnitudeA emulated.Element[emulated.Secp256k1Fp]
	SqrtMagnitudeB emulated.Element[emulated.Secp256k1Fp]
	Epsilon        emulated.Element[emulated.Secp256k1Fp]
}

func (c *CosineSimilarityCircuit) Define(api frontend.API) error {
	secp256k1, _ := emulated.NewField[emulated.Secp256k1Fp](api)

	// Calculate the dot product of vectors A and B
	dotProduct := secp256k1.Mul(&c.A_X, &c.B_X)
	dotProduct = secp256k1.Add(dotProduct, secp256k1.Mul(&c.A_Y, &c.B_Y))

	// Calculate the magnitude of vectors A and B
	magnitudeA := secp256k1.Mul(&c.A_X, &c.B_X)
	magnitudeA = secp256k1.Add(magnitudeA, secp256k1.Mul(&c.A_Y, &c.B_Y))

	magnitudeB := secp256k1.Mul(&c.B_X, &c.B_X)
	magnitudeB = secp256k1.Add(magnitudeB, secp256k1.Mul(&c.B_Y, &c.B_Y))

	elem := secp256k1.NewElement(magnitudeA)
	sqrtedMgA := secp256k1.Sqrt(elem)
	sqrtedMgB := secp256k1.Sqrt(secp256k1.NewElement(magnitudeB))

	dotProductToElement := secp256k1.NewElement(dotProduct)
	denominator := secp256k1.Mul(sqrtedMgA, sqrtedMgB)

	cosineSimilarity := secp256k1.Div(dotProductToElement, denominator)
	secp256k1.AssertIsEqual(cosineSimilarity, &c.CS)

	return nil
}

Additionally, it is difficult to debug since the elliptic curve of secp256k1 doesn't have the Println method unlike api package.
I would appreciate any guidance on why this might be happening and how to fix it.
Thank you.

[ivokub]

Without going through the math thoroughly, I think the problems is that we work in different domains: the witness is computed using the floats, but the computations in-circuit are defined in the emulated field. For example Sqrt(20) in floats is 4.nnn, but in a finite field it is a large field element.

I'm not sure if gnark is right now applicable to your use case as it doesn't support floating point arithmetic and we do not plan implementing near term. There has been another user interested in floating point arithmetic, see #684 (comment). Maybe you could cooperate on implementing it?