Try   HackMD

Lookup argument for folding

Example
Assume in lookup arguments, we have two columns

(A,S), and try to lookup
Ai∈S. Firstly, we cannot directly fold two such instances, e.g. with random factor
r=1:
A1=[1,1,2,3],S1=[1,2,3,4,5]A2=[1,1,1,2],S2=[1,2,3,4,5]A1+A2=[2,2,3,5],S1+S2=[2,4,6,8,10]
Obviously
(A1+A2,S1+S2) will not work. And since the lookup is arbitrary, we probably will not have any explicit formula to make the folding of
(A,S) work.

Attempt 1
Assume we want to calcualte a function

F:X→Y. Instead of writing circuit for
F, we do lookup argument that
(x,F(x))∈S. Here
S={(x,F(x))|x∈X}.

Encoding: we use encoder

enc to encode
(x,F(x)) to be a field element, i.e.
A(x):=enc[x,F(x)]∈Fq
Now the table is
T={enc[x,F(x)]|x∈X}. When we do lookup of row
x across two columns
(x,F(x)), we first encode as
A(x)=enc(x,F(x)) and prove
A(x)∈S.

In the following, we will only consider the case that

X is closed under linear combination, i.e.
∀x1,x2∈X, we have
x1+rx2∈X. In this case, we say the table
T is closed.

Assume we have two instances:

(A,S),
(B,S), where
Ai=enc[xA[i],F(xA[i])],
Bi=enc[xB[i],F(xB[i])].

We define folded instances of

A and
B as:
Ci:=enc[xA[i]+rxB[i],F(xA[i]+rxB[i])]
Notice that table
S is closed by our assumption, we have
Ci∈S. The folding prover needs to recalculate the new value
F(xA[i]+rxB[i]).

During in folding, the prover will first fold input value

x=x1+r⋅x2, then calculate
F(x) and fill it into corresponding advice column.

There are

3 kinds of columns, one type is for folding (like Sangria and Nova); one type is advice column calculated by applying
F on folded lookup key (it seems we can prove the soundness for this type); one type is fixed table column (i.e. will not change during folding). However, even this approach work, this is only suitable for hash, bit operation but not for range check (range check table is not closed).

Attempt 2
We can try to fold two instances such that the polynomial constraints below are still satisfied:

Z(ωX)⋅(A′(X)+β)⋅(S′(X)+γ)−Z(x)⋅(A(x)+β)⋅(S(X)+γ)=0(A′(X)−S′(X))⋅(A′(X)−A′(ω−1X))=0

As example, let's fold the second relation. First rewrite it as:

G=A′⋅A′+A′⋅A′ω−S′⋅A′−S′A′ω=0
Take two instances
U1=(A1,A1′,S1′),
U2=(A2,A2′,S2′).
A=A1+rA2,A′=A1′+rA2′,S′=S1′+S2′G=G1+r2⋅G2+r⋅(2A1′A2′+A1′A2′ω+A1′ωA2′−S1′A2′−S2′A1′−S1′A2′ω−S2′A1′ω)=G1+r2⋅G2+r⋅T
Thus, we need modify the second relation as
P:=A′⋅A′+A′⋅A′ω−S′⋅A′−S′A′ω+E
Then the folding will stay the same format. i.e.
Fold(U1,U2)=G+E=(G1+r2G2)+(E1+r2E2+rT)

Last changed by 
 
Chao
0
2
584

Read more

Barrett Reduction

Barrett reduction allows us to quickly calculate the quotient $q$ and reminder $r$ of $a \pmod n$, i.e. $a = q\cdot n + r, 0\leq r<n$. GLV One of the use case is in GLV decomposition. For simplicity, we consider all the integers below are less than $2^{256}$. We want to decompose $k=k_1+k_2\cdot\lambda$ with both $k_1, k_2$ are small. Here is the correspondence $$k\rightarrow a,k_1\rightarrow r, k_2\rightarrow q, \lambda\rightarrow n$$ When $\lambda$ is $128$ bit, we can use Barrett reduction to derive $k_1, k_2$ with $k_1<2^{128}, k_2<2^{128}$. In the glv paper, it considers more general case where $\lambda$ might not be $128$ bit and hence use lattice based algorithm to derive small $k_1, k_2$ (which might not less than $2^{128}$)

Mar 24, 2023
Montgomery modular multiplication

Original version Suppose $a,b\in \mathbb{Z}_N$, modular multiplication $[ab]$ requires first multiply them in the range $[0,N^2-2N+1]$, and then use Euclidean division theorem to get $ab=qN+r,q=\lfloor ab/N\rfloor$, such that $[ab]=r$. The division is quite expensive. Montgomery form is to choose a different divisor $R>N$ with $\gcd{(R, N)}=1$. For example, by choose $R=2^n$, the division is just shift by $n$ bits. Thus, we just want to make sure the numerator is divisible by $R$. Montgomery form of $a$ is defined as $\bar{a}=[aR]$, i.e. residual class of $aR$. We have: $$\gcd{(R,N)}=1\implies \exists R^{-1}:RR^{-1}\equiv 1\implies\exists N'<R:RR^{-1}=N'N+1$$ i.e. $N'$ is negative mod inverse of $N$ w.r.t $R$. And we have multiplication by $R$ is ring isomorphism. And: $$T=[aR][bR]\equiv abR\cdot R\equiv [abR]\cdot R$$ Notice $T<N\cdot N< R*N$. For any $0\leq T < RN$, define reduction form of $T$ as: $$t=redc(T):=TR^{-1}\pmod N$$ i.e. $\overline{ab}=redc(\bar{a}\bar{b})$. We use the following algorithm to do the reduction:

Feb 10, 2023
Plonk By Hand

Reference plonk by hand (part1) plonk by hand (part2) plonk by hand (part3) Codes All the codes below are python with SageMath.

Feb 2, 2023
MACI v1.0: top-up voice credits

Introduction In previous design, when an user signup, she will get an initial voice credit balance. This info is stored in corresponding stateLeaf. For multiple polls, an user can spend credits upto this initial balance. e.g. If an user has initial 100 credits. Then she can spend a total of 100 credits for each poll. If she wants to spend more than initial balance, she has to signup again. The purpose of top-up feature is to allow users to add more credits without signup again. Design One approach is to modify the voiceCreditBalance on the stateLeaf each time when user deposit new credits. This is the current approach we are going to take. Proposal Notice that an user cannot just arbitrarily send a topup command to add credits. Instead, we add an ERC20 contract to store voting credits. Then the user can use the topup function in poll.sol to deposit tokens into the contract address. In the current design, we don't allow users to withdraw their tokens. The reason is that withdraw feature can allow malicious one to bribe others offline to transfer their keys. Without withdraw function, the malicious cannot distinguish whether key transferred is valid or not. Since now the poll.sol contract address will hold all the funds deposit from users for the current pollID. At the end of poll, the coordinator (or anyone) can transfer funds in poll.sol into hardcoded address which is used for public goods.

Jan 19, 2023
Read more from Chao
Published on HackMD