Implement LogUp in PIL

[georgwiese]

Similar to how we already implemented a permutation argument in PIL (see #1297 and #1306), we could implement a variant of LogUp (also see this summary).

As a first version, it could look like this:

• A witness column m is added, containing the multiplicities. For now, we can only provide them via a hint for a concrete example (adding support by automatic witness generation is a next step).
• A helper column h is added for each lookup, supposed to contain $hi = h{i - 1} + \frac{1}{\alpha - a_i} - \frac{m_i}{\alpha - b_i}$ (with $h0 := 0$). This can also be provided via a hint. Note that in the original LogUp, they don't add $h{i - 1}$ and instead run the sum-check protocol on the entire column. But our backends don't expose sum-check, and I don't see a big downside of this approach!
• The last cell of $h$ should be constrained to be $0$

So I think, the constraints would look something like this:

h' * (alpha - A) * (alpha - B) = h * (alpha - A) * (alpha - B) + (alpha - B) + m * (alpha - A);

# Actually, I don't think this constraint is needed for soundness, because of the wrapping
IS_FIRST' * h = 0;

(Note that because of wrapping $h_0 = h_4 = 0$, so row $1$ does not have to be handled separately.)

This leaves out two details, which should be handled analogously to the permutation argument:

• If we look up tuples of values, the tuple should be folded first, using another verifier challenge.
• If the field is too small, these operations need to happen on an appropriate extension field (see #1306).

Compared to the original LogUp, this implementation lacks some optimization applicable to multiple lookups, especially if they have the same left-hand side. But I think it would be a good first step and allow for some first benchmarks already.

[onurinanc]

@georgwiese I think the first constraint should be fixed from h' * (alpha - A) * (alpha - B) = h * (alpha - A) * (alpha - B) + (alpha - B) + m * (alpha - A);  to h' * (alpha - A) * (alpha - B) + m * (alpha - A) = h * (alpha - A) * (alpha - B) + (alpha - B);