Source: Unlocking the lookup singularity with Lasso

Setting

We have a vectors and . We want to show that element in is in . This is equivalent to showing that there exists a matrix whose rows consist of unit vectors, such that

Up to negligible soundness error, this is equivalent to:

where , , and are the multilinear extensions and is a random verifier challenge.

Starting Point: Spark

We commit to using Spark. However, we can specialize it such that:

  • The scheme becomes concretely more efficient
  • It automatically enforces that rows are unit vectors

Recall that in the standard Spark evaluation proof, we would show that:

where commitments to , and represent the commitment to . But because ’s rows should be unit vectors we have:

  • , so it can be removed
  • , which means we have one less helper polynomial to commit to

Also, Lasso uses the general version of Spark, which factors the Lagrange polynomials into parts, so the prover commits to -variate polynomials and shows that:

Surge: A generalization of Spark, providing Lasso

Surge generalizes Spark to directly prove:

for some and multi-linear extension of a table .

Another way to look at it is that:

where iterates over the indices from to and is the ith lookup!

We assume that the table has a Spark-only structure (SOS) (or: is decomposable), which means that each entry (with ) can be evaluated quickly by consulting subtables of size . To evaluate with , write . Then, there should be an -variate polynomial such that:

where .

So, we can write:

The rest is a straight-forward generalization of Spark:

  • The commitment to consists of commitments to -variate dense polynomials
  • For evaluation, the prover commits to -variate helper polynomials (purported to be the multilinear extensions of the arguments of above)
  • To show that , the Multivariate Sum-Check Protocol is applied to polynomial
  • Finally, the prover shows that are well-formed using Offline Memory Checking (which requires it to send commitments to read counts for each)

TLDR

IMO, all of this is just a complicated way of describing the following protocol:

  1. The prover commits to indices in the sub-table ()
  2. The prover commits to multilinear extensions of the sub-table lookups () and proves the correctness via Offline Memory Checking
  3. The Multivariate Zero Check Protocol is run to prove that