# Overview

Here’s some notes on how STARK works, following my read of the ethSTARK Documentation (thanks Bobbin for the pointer!).

Warning: the following explanation should look surprisingly close to PlonK or SNARKs in general, to anyone familiar with these other schemes. If you know PlonK, maybe you can think of STARKs as turboplonk without preprocessing and without copy constraints/permutation. Just turboplonk with a single custom gate that updates the next row, also the commitment scheme makes everything complicated.

## The execution trace table

Imagine a table with $W$ columns representing **registers**, which can be used as temporary values in our program/circuit. The table has $N$ rows, which represent the temporary values of each of these registers in each “**step**” of the program/circuit.

For example, a table of 3 registers and 3 steps:

r0 | r1 | r2 | |
---|---|---|---|

1 | 0 | 1 | 534 |

2 | 4 | 1 | 235 |

3 | 3 | 4 | 5 |

## The constraints

There are two types of constraints which we want to enforce on this execution trace table to simulate our program:

**boundary constraints**: if I understand correctly this is for initializing the inputs of your program in the first rows of the table (e.g.*the second register must be set to 1 initially*) as well as the outputs (e.g.*the registers in the last two rows must contain $3$, $4$, and $5$*).**state transitions**: these are constraints that apply to ALL contiguous pairs of rows (e.g.*the first two registers added together in a row equal the value of the third register in the next row*). The particularity of STARKs (and what makes them “scallable” and fast in practice) is that the same constraint is applied repeatidly. This is also why people like to use STARKs to implement zkVMs, as VMs do the same thing over and over.

This way of encoding a circuit as constraints is called **AIR (for Algebraic Intermediate Representation)**.

## Straw man 1: Doing things in the clear coz YOLO

Let’s see an example of how a STARK could work as a naive interactive protocol between a prover and verifier:

- the prover constructs the execution trace table and sends it to the verifier
- the verifier checks the constraints on the execution trace table by themselves

This protocol works if we don’t care about zero-knowledge, but it is obviously not very efficient: the prover sends a huge table to the verifier, and the verifier has to check that the table makes sense (vis a vis of the constraints) by checking every rows involved in the boundary constraints, and checking every contiguous pair of rows involved in the state transition constraints.

## Straw man 2: Encoding things as polynomials for future profit

Let’s try to improve on the previous protocol by using polynomials. This step will not immediately improve anything, but will set the stage for the step afterwards. Before we talk about the change to the protocol let’s see two different observations:

First, let’s note that one can encode a list of values as a polynomial by applying a **low-degree extension (LDE)**. That is, if your list of values look like this: $(y_{0},y_{1},y_{2},⋯)$, then interpolate these values into a polynomial $f$ such that $f(0)=y_{0},f(1)=y_{1},f(2)=y_{2},⋯$

Usually, as we’re acting in a field, a subgroup of large-enough size is chosen in place of $0,1,2$ as domain. You can read why’s that here. (This domain is called the “**trace evaluation domain**” by ethSTARK.)

Second, let’s see how to represent a constraint like “*the first two registers added together in a row equal the value of the third register in the next row*” as a polynomial. If the three registers in our examples are encoded as the polynomials $f_{1},f_{2},f_{3}$ then we need a way to encode “the next row”. If our domain is simply $(0,1,2,⋯)$ then the next row for a polynomial $f_{1}(x)$ is simply $f_{1}(x+1)$. Similarly, if we’re using a subgroup generated by $g$ as domain, we can write the next row as $f_{1}(x⋅g)$. So the previous example constraint can be written as the constraint polynomial $c_{0}(x)=f_{1}(x)+f_{2}(x)−f_{3}(x⋅g)$.

If a constraint polynomial $c_{0}(x)$ is correctly satisfied by a given execution trace, then it should be zero on the entire domain (for state transition constraints) or on some values of the domain (for boundary constraints). This means we can write it as $c_{0}(x)=t(x)⋅∏_{i}(x−g_{i})$ for some “quotient” polynomial $t$ and the evaluation points $g_{i}$ (that encode the rows) where the constraint should apply. (In other words, you can factor $c_{0}$ using its roots $g_{i}$.)

Note: for STARKs to be efficient, you shouldn’t have too many roots. Hence why boundary constraints should be limited to a few rows. But how does it work for state transition constraints that need to be applied to all the rows? The answer is that since we are in a subgroup there’s a very efficient way to compute $∏_{i}(x−g_{i})$. You can read more about that in Efficient computation of the vanishing polynomial of the Mina book.

At this point, you should understand that a prover that wants to convince you that a constraint $c_{1}$ applies to an execution trace table can do so by showing you that $t$ exists. The prover can do so by sending the verifier the $t$ polynomial and the verifier computes $c_{1}$ from the register polynomials and verifies that it is indeed equal to $t$ multiplied by the $∏_{i}(x−g_{i})$. This is what is done both in Plonk and in STARK.

Note: if a constraint doesn’t satisfy the execution trace, then you won’t be able to factor it with $∏_{i}(x−g_{i})$ as not all of the $g_{i}$ will be roots. For this reason you’ll get something like $c_{1}(x)=t(x)⋅∏_{i}(x−g_{i})+r(x)$ for $r$ some “rest” polynomial. TODO: at this point can we still get a $t$ but it will have a high degree? If not then why do we have to do a low-degree test later?

Now let’s see our modification to the previous protocol:

- Instead of sending the execution trace table, the prover encodes each column of the execution trace table (of height $N$) as polynomials, and sends the polynomials to the verifier.
- The prover then creates the constraint polynomials $c_{0},c_{1},⋯$ (as described above) for each constraint involved in the AIR.
- The prover then computes the associated quotient polynomials $t_{0},t_{1},⋯$ (as described above) and sends them to the verifier. Note that the ethSTARK paper call these quotient polynomials the constraint polynomials (sorry for the confusion).
- The verifier now has to check two things:
**low-degree check**: that these quotient polynomials are indeed low-degree. This is easy as we’re doing everything in the clear for now (TODO: why do we need to check that though?)**correctness check**: that these quotient polynomials were correctly constructed. For example, the verifier can check that for $t_{0}$ by computing $c_{0}$ themselves using the execution trace polynomials and then checking that it equals $t_{0}⋅(x−1)$. That is, assuming that the first constraint $c_{0}$ only apply to the first row $g_{0}=1$.

## Straw man 3: Let’s make use of the polynomials with the Schwartz-Zippel optimization!

The verifier doesn’t actually have to compute and compare large polynomials in the **correctness check**. Using the Schwartz-Zippel lemma one can check that two polynomials are equal by evaluating both of them at a random value and checking that the evaluations match. This is because Schwartz-Zippel tells us that two polynomials that are equal will be equal on all their evaluations, but if they differ they will differ on *most* of their evaluations.

So the previous protocol can be modified to:

- The prover sends the columns of the execution trace as polynomials $f_{0},f_{1},⋯$ to the verifier.
- The prover produces the quotient polynomials $t_{0},t_{1},⋯$ and sends them to the verifier.
- The verifier produces a random evaluation point $z$.
- The verifier checks that each quotient polynomial has been computed correctly. For example, for the first constraint, they evaluate $c_{0}$ at $z$, then evaluate $t_{0}(z)⋅(z−1)$, then check that both evaluations match.

## Straw man 4: Using commitments to hide stuff and reduce proof size!

As the title indicates, we eventually want to use commitments in our scheme so that we can add zero-knowledge (by hiding the polynomials we’re sending) and reduce the proof size (our commitments will be much smaller than what they commit).

The commitments used in STARKs are merkle trees, where the leaves contain evaluations of a polynomial. Unlike the commitments used in SNARKs (like IPA and KZG), merkle trees don’t have an algebraic structure and thus are quite limited in what they allow us to do. Most of the complexity in STARKs come from the commitments. In this section we will not open that pandora box, and assume that the commitments we’re using are normal polynomial commitment schemes which allow us to not only commit to polynomials, but also evaluate them and provide proofs that the evaluations are correct.

Now our protocol looks like this:

- The prover commits to the execution trace columns polynomials, then sends the commitments to the verifier.
- The prover commits to the quotient polynomials, the sends them to the verifier.
- The verifier sends a random value $z$.
- The prover evaluates the execution trace column polynomials at $z$ and $z⋅g$ (remember the verifier might want to evaluate a constraint that looks like this $c_{0}(x)=f_{1}(x)+f_{2}(x)−f_{3}(x⋅g)$ as it also uses the next row) and sends the evaluations to the verifier.
- The prover evaluates the quotient polynomials at $z$ and sends the evaluations to the verifier (these evaluations are called “masks” in the paper).
- For each evaluation, the prover also sends evaluation proofs.
- The verifier verifies all evaluation proofs.
- The verifier then checks that each constraint is satisfied, by checking the $c=t⋅∏_{i}(x−g_{i})$ equation
*in the clear*(using the evaluations provided by the prover).

## Straw man 5: a random linear combination to reduce all the checks to a single check

If you’ve been reading STARK papers you’re probably wondering where the heck is the **composition polynomial**. That final polynomial is simply a way to aggregate a number of checks in order to optimize the protocol.

The idea is that instead of checking a property on a list of polynomials, you can check that property on a random linear combination. For example, instead of checking that $f_{1}(z)=3$ and $f_{2}(z)=4$, and $f_{3}(z)=8$, you can check that for random values $r_{1},r_{2},r_{3}$ you have:

$r_{1}⋅f_{1}(z)+r_{2}⋅f_{2}(z)+r_{3}⋅f_{3}(z)=3r_{1}+4r_{2}+8r_{3}$

Often we avoid generating multiple random values and instead use powers of a single random value, which is a tiny bit less secure but much more practical for a number of reasons I won’t touch here. So things often look like this instead, with a random value $r$:

$f_{1}(z)+r⋅f_{2}(z)+r_{2}⋅f_{3}(z)=3+4r+8r_{2}$

Now our protocol should look like this:

- The prover commits to the execution trace columns polynomials, then sends the commitments to the verifier.
- The verifier sends a random value $r$.
- The prover produces a random linear combination of the constraint polynomials.
- The prover produces the quotient polynomial for that random linear combination, which ethSTARK calls the composition polynomial.
- The prover commits to the composition polynomial, then sends them to the verifier.
- The protocol continues pretty much like the previous one

Note: in the ethSTARK paper they note that the composition polynomial is likely of higher degree than the polynomials encoding the execution trace columns. (The degree of the composition polynomial is equal to the degree of the highest-degree constraint.) For this reason, there’s some further optimization that split the composition polynomial into several polynomials, but we will avoid talking about it here.

We now have a protocol that looks somewhat clean, which seems contradictory with the level of complexity introduced by the various papers. Let’s fix that in the next blogpost on FRI…