smartvector-type for product

Author: Soleimani193

prover/maths/common/smartvectors/arithmetic_gen.go

@@ -110,12 +110,12 @@ func processOperator(op operator, coeffs []int, svecs []SmartVector, p ...mempoo
 
 	switch {
 	case matchedRegular == totalToMatch:
-		return regularRes
+		return &regularRes.Regular
 	case matchedRegular+matchedConst == totalToMatch:
 		// In this case, there are no windowed in the list. This means we only
 		// need to merge the const one into the regular one before returning
 		op.constTermIntoVec(regularRes.Regular, &constRes.val)
-		return regularRes
+		return &regularRes.Regular
 	default:
 
 		// If windowRes is a regular (can happen if all windows arguments cover the full circle)

prover/protocol/compiler/innerproduct/context.go

@@ -91,13 +91,8 @@ func compileForSize(
 			}
 		}
 
-		// @Azam the following function is commented out due to the issue https://github.com/Consensys/linea-monorepo/issues/192
-		// ctx.Collapsed = symbolic.NewPolyEval(batchingCoin.AsVariable(), pairProduct)
-		res := symbolic.NewConstant(0)
-		for i := len(pairProduct) - 1; i >= 0; i-- {
-			res = symbolic.Mul(res, batchingCoin)
-			res = symbolic.Add(res, pairProduct[i])
-		}
+		// random linear combination over the pairs of inner-product.
+		res := symbolic.NewPolyEval(batchingCoin.AsVariable(), pairProduct)
 
 		ctx.Collapsed = res
 		ctx.CollapsedBoard = ctx.Collapsed.Board()

prover/protocol/wizardutils/wizardutils_test.go

@@ -0,0 +1,81 @@
+package wizardutils
+
+import (
+	"testing"
+
+	"github.com/consensys/linea-monorepo/prover/maths/common/smartvectors"
+	"github.com/consensys/linea-monorepo/prover/maths/field"
+	"github.com/consensys/linea-monorepo/prover/protocol/coin"
+	"github.com/consensys/linea-monorepo/prover/protocol/column/verifiercol"
+	"github.com/consensys/linea-monorepo/prover/protocol/compiler/dummy"
+	"github.com/consensys/linea-monorepo/prover/protocol/ifaces"
+	"github.com/consensys/linea-monorepo/prover/protocol/wizard"
+	"github.com/consensys/linea-monorepo/prover/symbolic"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestWizarldutils(t *testing.T) {
+	var res1, res11, res2, res22 *symbolic.Expression
+	define := func(b *wizard.Builder) {
+		var (
+			size = 4
+			col1 = b.RegisterCommit("P1", size)
+			col2 = b.RegisterCommit("P2", size)
+
+			col5 = b.RegisterPrecomputed("P3", smartvectors.ForTest(1, 0, 1, 1))
+			col6 = verifiercol.NewConstantCol(field.NewElement(3), size)
+
+			coin = b.RegisterRandomCoin(coin.Namef("Coin"), coin.Field)
+		)
+
+		// PolyEval over columns
+		res1 = symbolic.NewPolyEval(coin.AsVariable(), []*symbolic.Expression{ifaces.ColumnAsVariable(col1), ifaces.ColumnAsVariable(col2)})
+		res11 = linCom(coin.AsVariable(), []*symbolic.Expression{ifaces.ColumnAsVariable(col1), ifaces.ColumnAsVariable(col2)})
+
+		// PolyEval over PolyEval and Mul.
+		expr := symbolic.Mul(col6, col5, coin)
+		res2 = symbolic.NewPolyEval(coin.AsVariable(), []*symbolic.Expression{res1, expr})
+		res22 = linCom(coin.AsVariable(), []*symbolic.Expression{res1, expr})
+
+	}
+	prover := func(run *wizard.ProverRuntime) {
+		var (
+			col1 = smartvectors.ForTest(1, 2, 1, 0)
+			col2 = smartvectors.ForTest(1, 1, 3, 1)
+		)
+		run.AssignColumn("P1", col1)
+		run.AssignColumn("P2", col2)
+
+		run.GetRandomCoinField(coin.Namef("Coin"))
+
+		res1Wit := EvalExprColumn(run, res1.Board()).IntoRegVecSaveAlloc()
+		res11Wit := EvalExprColumn(run, res11.Board()).IntoRegVecSaveAlloc()
+		for i := range res11Wit {
+			if res1Wit[i].Cmp(&res11Wit[i]) != 0 {
+				panic("err")
+			}
+		}
+
+		res2Wit := EvalExprColumn(run, res2.Board()).IntoRegVecSaveAlloc()
+		res22Wit := EvalExprColumn(run, res22.Board()).IntoRegVecSaveAlloc()
+		for i := range res11Wit {
+			if res2Wit[i].Cmp(&res22Wit[i]) != 0 {
+				panic("err")
+			}
+		}
+
+	}
+
+	comp := wizard.Compile(define, dummy.Compile)
+	proof := wizard.Prove(comp, prover)
+	assert.NoErrorf(t, wizard.Verify(comp, proof), "invalid proof")
+}
+
+func linCom(x *symbolic.Expression, coeff []*symbolic.Expression) *symbolic.Expression {
+	res := symbolic.NewConstant(0)
+	for i := len(coeff) - 1; i >= 0; i-- {
+		res = symbolic.Mul(res, x)
+		res = symbolic.Add(res, coeff[i])
+	}
+	return res
+}

prover/symbolic/constant.go

@@ -16,6 +16,11 @@ type Constant struct {
 	Val field.Element
 }
 
+// Name returns the name for the Constant [Operator].
+func (Constant) Name() string {
+	return "Constant"
+}
+
 // Degree implements the [Operator] interface
 func (Constant) Degree([]int) int {
 	panic("we never call it for a constant")

prover/symbolic/expression.go

@@ -65,6 +65,8 @@ type Operator interface {
 	Degree([]int) int
 	// GnarkEval returns an evaluation of the operator in a gnark circuit.
 	GnarkEval(frontend.API, []frontend.Variable) frontend.Variable
+	// Name of the operator, used for debugging.
+	Name() string
 }
 
 // Board pins down the expression into an ExpressionBoard. This converts the

prover/symbolic/lincomb.go

@@ -89,6 +89,11 @@ func NewLinComb(items []*Expression, coeffs []int) *Expression {
 	return e
 }
 
+// Name outputs the name for the LinComb [Operator]
+func (LinComb) Name() string {
+	return "LinComb"
+}
+
 // Degree implements the [Operator] interface and returns the maximum degree of
 // the underlying expression.
 func (LinComb) Degree(inputDegrees []int) int {

prover/symbolic/polyeval.go

@@ -52,6 +52,11 @@ func NewPolyEval(x *Expression, coeffs []*Expression) *Expression {
 	}
 }
 
+// Name outputs the name for the PolyEval [Operator].
+func (PolyEval) Name() string {
+	return "PolyEval"
+}
+
 /*
 Returns the degree of the operation given, as input, the degree of the children
 */

prover/symbolic/product.go

@@ -112,6 +112,11 @@ func NewProduct(items []*Expression, exponents []int) *Expression {
 	return e
 }
 
+// Name outputs the name for the Product [Operator]
+func (Product) Name() string {
+	return "Product"
+}
+
 // Degree implements the [Operator] interface and returns the sum of the degree
 // of all the operands weighted by the exponents.
 func (prod Product) Degree(inputDegrees []int) int {

prover/symbolic/variable.go

@@ -28,6 +28,11 @@ type Variable struct {
 	Metadata Metadata
 }
 
+// Name outputs the name for the Variable [Operator].
+func (Variable) Name() string {
+	return "Variable"
+}
+
 // Degree implements the [Operator] interface. Yet, this panics if this is called.
 func (Variable) Degree([]int) int {
 	panic("we never call it for a variable")