1package fri
  2
  3import (
  4	gl "github.com/succinctlabs/gnark-plonky2-verifier/goldilocks"
  5	"github.com/succinctlabs/gnark-plonky2-verifier/types"
  6)
  7
  8type OpeningBatch struct {
  9	Values []gl.QuadraticExtensionVariable
 10}
 11
 12type Openings struct {
 13	Batches []OpeningBatch
 14}
 15
 16func ToOpenings(c types.OpeningSet) Openings {
 17	values := c.Constants                         // num_constants + 1
 18	values = append(values, c.PlonkSigmas...)     // num_routed_wires
 19	values = append(values, c.Wires...)           // num_wires
 20	values = append(values, c.PlonkZs...)         // num_challenges
 21	values = append(values, c.PartialProducts...) // num_challenges * num_partial_products
 22	values = append(values, c.QuotientPolys...)   // num_challenges * quotient_degree_factor
 23	zetaBatch := OpeningBatch{Values: values}
 24	zetaNextBatch := OpeningBatch{Values: c.PlonkZsNext}
 25	return Openings{Batches: []OpeningBatch{zetaBatch, zetaNextBatch}}
 26}
 27
 28type PolynomialInfo struct {
 29	OracleIndex    uint64
 30	PolynomialInfo uint64
 31}
 32
 33type OracleInfo struct {
 34	NumPolys uint64
 35	Blinding bool
 36}
 37
 38type BatchInfo struct {
 39	Point       gl.QuadraticExtensionVariable
 40	Polynomials []PolynomialInfo
 41}
 42
 43type InstanceInfo struct {
 44	Oracles []OracleInfo
 45	Batches []BatchInfo
 46}
 47
 48type PlonkOracle struct {
 49	index    uint64
 50	blinding bool
 51}
 52
 53var CONSTANTS_SIGMAS = PlonkOracle{
 54	index:    0,
 55	blinding: false,
 56}
 57
 58var WIRES = PlonkOracle{
 59	index:    1,
 60	blinding: true,
 61}
 62
 63var ZS_PARTIAL_PRODUCTS = PlonkOracle{
 64	index:    2,
 65	blinding: true,
 66}
 67
 68var QUOTIENT = PlonkOracle{
 69	index:    3,
 70	blinding: true,
 71}
 72
 73func polynomialInfoFromRange(c *types.CommonCircuitData, oracleIdx uint64, startPolyIdx uint64, endPolyIdx uint64) []PolynomialInfo {
 74	returnArr := make([]PolynomialInfo, 0)
 75	for i := startPolyIdx; i < endPolyIdx; i++ {
 76		returnArr = append(returnArr,
 77			PolynomialInfo{
 78				OracleIndex:    oracleIdx,
 79				PolynomialInfo: i,
 80			})
 81	}
 82
 83	return returnArr
 84}
 85
 86// Range of the sigma polynomials in the `constants_sigmas_commitment`.
 87func sigmasRange(c *types.CommonCircuitData) []uint64 {
 88	returnArr := make([]uint64, 0)
 89	for i := c.NumConstants; i <= c.NumConstants+c.Config.NumRoutedWires; i++ {
 90		returnArr = append(returnArr, i)
 91	}
 92
 93	return returnArr
 94}
 95
 96func numPreprocessedPolys(c *types.CommonCircuitData) uint64 {
 97	sigmasRange := sigmasRange(c)
 98	return sigmasRange[len(sigmasRange)-1]
 99}
100
101func numZSPartialProductsPolys(c *types.CommonCircuitData) uint64 {
102	return c.Config.NumChallenges * (1 + c.NumPartialProducts)
103}
104
105func numQuotientPolys(c *types.CommonCircuitData) uint64 {
106	return c.Config.NumChallenges * c.QuotientDegreeFactor
107}
108
109func friPreprocessedPolys(c *types.CommonCircuitData) []PolynomialInfo {
110	return polynomialInfoFromRange(
111		c,
112		CONSTANTS_SIGMAS.index,
113		0,
114		numPreprocessedPolys(c),
115	)
116}
117
118func friWirePolys(c *types.CommonCircuitData) []PolynomialInfo {
119	numWirePolys := c.Config.NumWires
120	return polynomialInfoFromRange(c, WIRES.index, 0, numWirePolys)
121}
122
123func friZSPartialProductsPolys(c *types.CommonCircuitData) []PolynomialInfo {
124	return polynomialInfoFromRange(
125		c,
126		ZS_PARTIAL_PRODUCTS.index,
127		0,
128		numZSPartialProductsPolys(c),
129	)
130}
131
132func friQuotientPolys(c *types.CommonCircuitData) []PolynomialInfo {
133	return polynomialInfoFromRange(
134		c,
135		QUOTIENT.index,
136		0,
137		numQuotientPolys(c),
138	)
139}
140
141func friZSPolys(c *types.CommonCircuitData) []PolynomialInfo {
142	return polynomialInfoFromRange(
143		c,
144		ZS_PARTIAL_PRODUCTS.index,
145		0,
146		c.Config.NumChallenges,
147	)
148}
149
150func friOracles(c *types.CommonCircuitData) []OracleInfo {
151	return []OracleInfo{
152		{
153			NumPolys: numPreprocessedPolys(c),
154			Blinding: CONSTANTS_SIGMAS.blinding,
155		},
156		{
157			NumPolys: c.Config.NumWires,
158			Blinding: WIRES.blinding,
159		},
160		{
161			NumPolys: numZSPartialProductsPolys(c),
162			Blinding: ZS_PARTIAL_PRODUCTS.blinding,
163		},
164		{
165			NumPolys: numQuotientPolys(c),
166			Blinding: QUOTIENT.blinding,
167		},
168	}
169}
170
171func friAllPolys(c *types.CommonCircuitData) []PolynomialInfo {
172	returnArr := make([]PolynomialInfo, 0)
173	returnArr = append(returnArr, friPreprocessedPolys(c)...)
174	returnArr = append(returnArr, friWirePolys(c)...)
175	returnArr = append(returnArr, friZSPartialProductsPolys(c)...)
176	returnArr = append(returnArr, friQuotientPolys(c)...)
177
178	return returnArr
179}
180
181func GetInstance(c *types.CommonCircuitData, glApi *gl.Chip, zeta gl.QuadraticExtensionVariable, degreeBits uint64) InstanceInfo {
182	zetaBatch := BatchInfo{
183		Point:       zeta,
184		Polynomials: friAllPolys(c),
185	}
186
187	g := gl.PrimitiveRootOfUnity(degreeBits)
188	zetaNext := glApi.MulExtension(
189		gl.NewVariable(g.Uint64()).ToQuadraticExtension(),
190		zeta,
191	)
192
193	zetaNextBath := BatchInfo{
194		Point:       zetaNext,
195		Polynomials: friZSPolys(c),
196	}
197
198	return InstanceInfo{
199		Oracles: friOracles(c),
200		Batches: []BatchInfo{zetaBatch, zetaNextBath},
201	}
202}