Prover: beta v1.2

prover/backend/execution/constraints-versions.txt

@@ -1,2 +1 @@
-v0.8.0-rc7
-v0.8.0-rc8
+beta-v1.2/v0.1.0-rc3.1

prover/backend/execution/craft.go

@@ -36,13 +36,13 @@ func CraftProverOutput(
 ) Response {
 
 	// Split the embedded file contents into a string slice
-	constraintsVersions := strings.Split(strings.TrimSpace(constraintsVersionsStr), "\n")
+	// constraintsVersions := strings.Split(strings.TrimSpace(constraintsVersionsStr), "\n")
 
 	// Check the arithmetization version used to generate the trace is contained in the prover request
 	// and fail fast if the constraint version is not supported
-	if err := checkArithmetizationVersion(req.ConflatedExecutionTracesFile, req.TracesEngineVersion, constraintsVersions); err != nil {
-		panic(err.Error())
-	}
+	// if err := checkArithmetizationVersion(req.ConflatedExecutionTracesFile, req.TracesEngineVersion, constraintsVersions); err != nil {
+	// 	panic(err.Error())
+	// }
 
 	var (
 		l2BridgeAddress = cfg.Layer2.MsgSvcContract
@@ -238,6 +238,7 @@ func NewWitness(cfg *config.Config, req *Request, rsp *Response) *Witness {
 			TxHashes:        txHashes,
 			L2BridgeAddress: cfg.Layer2.MsgSvcContract,
 			ChainID:         cfg.Layer2.ChainID,
+			BlockHashList:   getBlockHashList(rsp),
 		},
 		FuncInp: rsp.FuncInput(),
 	}
@@ -286,3 +287,11 @@ func validateAndExtractVersion(traceFileName string) (string, error) {
 	}
 	return "", fmt.Errorf("conflated trace file: %s not in the appropriate format or version not found", traceFileName)
 }
+
+func getBlockHashList(rsp *Response) []types.FullBytes32 {
+	res := []types.FullBytes32{}
+	for i := range rsp.BlocksData {
+		res = append(res, rsp.BlocksData[i].BlockHash)
+	}
+	return res
+}

prover/circuits/execution/circuit.go

@@ -7,7 +7,6 @@ import (
 	public_input "github.com/consensys/linea-monorepo/prover/public-input"
 
 	"github.com/consensys/gnark-crypto/ecc"
-	"github.com/consensys/gnark/backend/plonk"
 	"github.com/consensys/gnark/frontend"
 	"github.com/consensys/linea-monorepo/prover/circuits"
 	"github.com/consensys/linea-monorepo/prover/protocol/wizard"
@@ -100,40 +99,20 @@ func MakeProof(
 ) string {
 
 	assignment := assign(limits, comp, wproof, funcInputs)
-	witness, err := frontend.NewWitness(&assignment, ecc.BLS12_377.ScalarField())
-	if err != nil {
-		panic(err)
-	}
 
-	proof, err := plonk.Prove(
-		setup.Circuit,
-		setup.ProvingKey,
-		witness,
+	proof, err := circuits.ProveCheck(
+		&setup,
+		&assignment,
 		emPlonk.GetNativeProverOptions(ecc.BW6_761.ScalarField(), setup.Circuit.Field()),
+		emPlonk.GetNativeVerifierOptions(ecc.BW6_761.ScalarField(), setup.Circuit.Field()),
 	)
+
 	if err != nil {
 		panic(err)
 	}
 
 	logrus.Infof("generated outer-circuit proof `%++v` for input `%v`", proof, assignment.PublicInput.(*big.Int).String())
 
-	// Sanity-check : the proof must pass
-	{
-		pubwitness, err := frontend.NewWitness(
-			&assignment,
-			ecc.BLS12_377.ScalarField(),
-			frontend.PublicOnly(),
-		)
-		if err != nil {
-			panic(err)
-		}
-
-		err = plonk.Verify(proof, setup.VerifyingKey, pubwitness, emPlonk.GetNativeVerifierOptions(ecc.BW6_761.ScalarField(), setup.Circuit.Field()))
-		if err != nil {
-			panic(err)
-		}
-	}
-
 	// Write the serialized proof
 	return circuits.SerializeProofRaw(proof)
 }

prover/circuits/prove.go

@@ -3,9 +3,10 @@ package circuits
 import (
 	"bytes"
 	"fmt"
-	"github.com/consensys/gnark/backend/witness"
 	"os"
 
+	"github.com/consensys/gnark/backend/witness"
+
 	"github.com/consensys/gnark/backend"
 	"github.com/consensys/gnark/backend/plonk"
 	"github.com/consensys/gnark/constraint/solver"

prover/go.mod

@@ -10,10 +10,11 @@ require (
 	github.com/consensys/compress v0.2.5
 	github.com/consensys/gnark v0.11.1-0.20250107100237-2cb190338a01
 	github.com/consensys/gnark-crypto v0.14.1-0.20241217134352-810063550bd4
-	github.com/consensys/go-corset v0.0.0-20241125005324-5cb0c289c021
+	github.com/consensys/go-corset v0.0.0-20250129030528-04c6bba7ccfd
 	github.com/crate-crypto/go-kzg-4844 v1.1.0
 	github.com/dlclark/regexp2 v1.11.2
 	github.com/fxamacker/cbor/v2 v2.7.0
+	github.com/go-playground/assert/v2 v2.2.0
 	github.com/go-playground/validator/v10 v10.22.0
 	github.com/iancoleman/strcase v0.3.0
 	github.com/icza/bitio v1.1.0

prover/go.sum

@@ -100,8 +100,8 @@ github.com/consensys/gnark v0.11.1-0.20250107100237-2cb190338a01 h1:YCHI04nMKFC6
 github.com/consensys/gnark v0.11.1-0.20250107100237-2cb190338a01/go.mod h1:8YNyW/+XsYiLRzROLaj/PSktYO4VAdv6YW1b1P3UsZk=
 github.com/consensys/gnark-crypto v0.14.1-0.20241217134352-810063550bd4 h1:Kp6egjRqKZf4469dfAWqFe6gi3MRs4VvNHmTfEjUlS8=
 github.com/consensys/gnark-crypto v0.14.1-0.20241217134352-810063550bd4/go.mod h1:GMPeN3dUSslNBYJsK3WTjIGd3l0ccfMbcEh/d5knFrc=
-github.com/consensys/go-corset v0.0.0-20241125005324-5cb0c289c021 h1:zAPMHjY72pXmjuyb/niQ816pd+B9RAmZoL/W/f5uJSU=
-github.com/consensys/go-corset v0.0.0-20241125005324-5cb0c289c021/go.mod h1:J64guTfpmfXl4Yk2D7lsWdYg0ilP+N8JWPudP7+sZpA=
+github.com/consensys/go-corset v0.0.0-20250129030528-04c6bba7ccfd h1:GQFLOm7l3hKtngBCuxw7f1NZajizIfWkK1gkUet+kFE=
+github.com/consensys/go-corset v0.0.0-20250129030528-04c6bba7ccfd/go.mod h1:J64guTfpmfXl4Yk2D7lsWdYg0ilP+N8JWPudP7+sZpA=
 github.com/coreos/go-semver v0.3.0/go.mod h1:nnelYz7RCh+5ahJtPPxZlU+153eP4D4r3EedlOD2RNk=
 github.com/coreos/go-systemd/v22 v22.3.2/go.mod h1:Y58oyj3AT4RCenI/lSvhwexgC+NSVTIJ3seZv2GcEnc=
 github.com/coreos/go-systemd/v22 v22.5.0/go.mod h1:Y58oyj3AT4RCenI/lSvhwexgC+NSVTIJ3seZv2GcEnc=

prover/maths/common/smartvectors/smartvectors.go

@@ -233,3 +233,50 @@ func WindowExt(v SmartVector) []fext.Element {
 		panic(fmt.Sprintf("unexpected type %T", v))
 	}
 }
+
+// TryReduceSize detects if the input smart-vector can be reduced to a constant
+// smart-vector. It will only apply over the following types: [Regular].
+func TryReduceSize(v SmartVector) SmartVector {
+
+	switch w := v.(type) {
+	case *Constant, *Rotated, *Pooled, *PaddedCircularWindow:
+		return w
+	case *Regular:
+
+		// to detect if a regular vector can be reduced to a constant, we need to
+		// check if all the values are equals. That's an expensive, so we instead
+		// by comparing values that would be likely to be unequal if it was not a
+		// constant. Also, we need to rule out the case where len(*w) because it
+		// is irrelevant to reducing the size.
+		if len(*w) <= 1 {
+			return w
+		}
+
+		if (*w)[0] != (*w)[1] {
+			return w
+		}
+
+		if (*w)[0] != (*w)[len(*w)-1] {
+			return w
+		}
+
+		if (*w)[0] != (*w)[len(*w)/2] {
+			return w
+		}
+
+		// This is expensive check where we check all the values in the vector
+		// to see if they are all equal. This is not the most efficient way to
+		// detect if a vector is a constant but the only reliable one.
+		for i := range *w {
+			if (*w)[i] != (*w)[0] {
+				return w
+			}
+		}
+
+		return NewConstant((*w)[0], len(*w))
+
+	default:
+		panic(fmt.Sprintf("unexpected type %T", v))
+	}
+
+}

prover/protocol/compiler/globalcs/factoring.go

@@ -4,6 +4,7 @@ import (
 	"fmt"
 	"io"
 	"reflect"
+	"sync"
 
 	"github.com/consensys/linea-monorepo/prover/protocol/accessors"
 	"github.com/consensys/linea-monorepo/prover/protocol/serialization"
@@ -13,12 +14,20 @@ import (
 	"github.com/consensys/linea-monorepo/prover/utils"
 )
 
-// factorExpressionList applies [factorExpression] over a list of expression
+// factorExpressionList applies [factorExpression] over a list of expressions
 func factorExpressionList(comp *wizard.CompiledIOP, exprList []*symbolic.Expression) []*symbolic.Expression {
 	res := make([]*symbolic.Expression, len(exprList))
+	var wg sync.WaitGroup
+
 	for i, expr := range exprList {
-		res[i] = factorExpression(comp, expr)
+		wg.Add(1)
+		go func(i int, expr *symbolic.Expression) {
+			defer wg.Done()
+			res[i] = factorExpression(comp, expr)
+		}(i, expr)
 	}
+
+	wg.Wait()
 	return res
 }
 

prover/protocol/compiler/permutation/compiler.go

@@ -1,12 +1,15 @@
 package permutation
 
 import (
+	"slices"
+
 	"github.com/consensys/linea-monorepo/prover/protocol/coin"
 	"github.com/consensys/linea-monorepo/prover/protocol/ifaces"
 	"github.com/consensys/linea-monorepo/prover/protocol/query"
 	"github.com/consensys/linea-monorepo/prover/protocol/wizard"
 	"github.com/consensys/linea-monorepo/prover/protocol/wizardutils"
 	"github.com/consensys/linea-monorepo/prover/symbolic"
+	"golang.org/x/exp/maps"
 )
 
 // CompileGrandProduct scans `comp`, looking for [query.Permutation] queries and
@@ -40,9 +43,16 @@ func CompileGrandProduct(comp *wizard.CompiledIOP) {
 		dispatchPermutation(comp, zCatalog, round, permutation)
 	}
 
-	for entry, zC := range zCatalog {
+	zCEntriesOrdered, zCsOrdered := mapAsTupleDeterministic(zCatalog)
+
+	for i := range zCEntriesOrdered {
+
+		var (
+			zC    = zCsOrdered[i]
+			round = zCEntriesOrdered[i][0]
+		)
+
 		zC.compile(comp)
-		round := entry[0]
 		allProverActions[round] = append(allProverActions[round], zC)
 	}
 
@@ -108,3 +118,22 @@ func dispatchPermutation(
 		}
 	}
 }
+
+func mapAsTupleDeterministic(m map[[2]int]*ZCtx) (keys [][2]int, values []*ZCtx) {
+
+	keys = maps.Keys(m)
+	values = make([]*ZCtx, len(keys))
+
+	slices.SortFunc(keys, func(a, b [2]int) int {
+		if a[0] != b[0] {
+			return a[0] - b[0]
+		}
+		return a[1] - b[1]
+	})
+
+	for i := range keys {
+		values[i] = m[keys[i]]
+	}
+
+	return keys, values
+}

prover/protocol/compiler/univariates/naturalize.go

@@ -348,25 +348,20 @@ func (ctx naturalizationCtx) Verify(run *wizard.VerifierRuntime) error {
 
 func (ctx naturalizationCtx) GnarkVerify(api frontend.API, c *wizard.WizardVerifierCircuit) {
 
-	logrus.Tracef("verifying naturalization")
-
 	// Get the original query
 	originalQuery := c.GetUnivariateEval(ctx.q.QueryID)
 	originalQueryParams := c.GetUnivariateParams(ctx.q.QueryID)
 
 	// Collect the subqueries and the collection in finalYs evaluations
 	subQueries := []query.UnivariateEval{}
-	subQueriesParamsX := []frontend.Variable{}
-	subQueriesParamsYs := [][]frontend.Variable{}
+	subQueriesParams := []query.GnarkUnivariateEvalParams{}
 	finalYs := collection.NewMapping[string, frontend.Variable]()
 
 	for qID, qName := range ctx.subQueriesNames {
 		subQueries = append(subQueries, c.GetUnivariateEval(qName))
-		params := c.GetUnivariateParams(qName)
-		subQueriesParamsX = append(subQueriesParamsX, params.X)
-		subQueriesParamsYs = append(subQueriesParamsYs, params.Ys)
+		subQueriesParams = append(subQueriesParams, c.GetUnivariateParams(qName))
 		repr := ctx.deduplicatedReprs[qID]
-		for j, derivedY := range subQueriesParamsYs[qID] {
+		for j, derivedY := range subQueriesParams[qID].Ys {
 			finalYs.InsertNew(column.DerivedYRepr(repr, subQueries[qID].Pols[j]), derivedY)
 		}
 	}
@@ -402,8 +397,8 @@ func (ctx naturalizationCtx) GnarkVerify(api frontend.API, c *wizard.WizardVerif
 			}
 			recoveredX := recoveredXs[i]
 			qID := ctx.reprToSubQueryID[subrepr]
-			submittedX := subQueriesParamsX[qID]
-			// Or it is a mismatch between the evaluation queries and the derived query
+			submittedX := subQueriesParams[qID].X
+
 			api.AssertIsEqual(recoveredX, submittedX)
 		}
 
@@ -412,7 +407,5 @@ func (ctx naturalizationCtx) GnarkVerify(api frontend.API, c *wizard.WizardVerif
 		*/
 		recoveredY := column.GnarkVerifyYConsistency(api, originH, "", cachedXs, finalYs)
 		api.AssertIsEqual(recoveredY, originalQueryParams.Ys[originPolID])
-
-		logrus.Tracef("verifying naturalization DONE")
 	}
 }

prover/protocol/wizard/compiled.go

@@ -166,7 +166,10 @@ func (c *CompiledIOP) InsertCommit(round int, name ifaces.ColID, size int) iface
 //   - if the size of the column is not a power of 2
 //   - if a column using the same name has already been registered
 func (c *CompiledIOP) InsertColumn(round int, name ifaces.ColID, size int, status column.Status) ifaces.Column {
-
+	// Panic if the size is not a power of 2
+	if !utils.IsPowerOfTwo(size) {
+		utils.Panic("Registering column %v with a non power of two size = %v", name, size)
+	}
 	// @alex: this has actually caught a few typos. When wrongly setting an
 	// incorrect but very large size here, it will generate a disproportionate
 	// wizard

prover/protocol/wizard/prover.go

@@ -388,6 +388,10 @@ func (run *ProverRuntime) AssignColumn(name ifaces.ColID, witness ifaces.ColAssi
 		utils.Panic("Witness with non-power of two sizes, should have been caught earlier")
 	}
 
+	// This reduction is a trade-off between runtime and memory. It
+	// costs CPU but can save a significant amount of memory.
+	witness = smartvectors.TryReduceSize(witness)
+
 	// Adds it to the assignments
 	run.Columns.InsertNew(handle.GetColID(), witness)
 }

prover/symbolic/expression.go

@@ -3,6 +3,7 @@ package symbolic
 import (
 	"fmt"
 	"reflect"
+	"sync"
 
 	"github.com/consensys/gnark/frontend"
 	"github.com/consensys/linea-monorepo/prover/maths/common/mempool"
@@ -244,9 +245,17 @@ func (e *Expression) ReconstructBottomUp(
 	// LinComb or Product or PolyEval. This is an intermediate expression.
 	case LinComb, Product, PolyEval:
 		children := make([]*Expression, len(e.Children))
+		var wg sync.WaitGroup
+		wg.Add(len(e.Children))
+
 		for i, c := range e.Children {
-			children[i] = c.ReconstructBottomUp(constructor)
+			go func(i int, c *Expression) {
+				defer wg.Done()
+				children[i] = c.ReconstructBottomUp(constructor)
+			}(i, c)
 		}
+
+		wg.Wait()
 		return constructor(e, children)
 	}