Circuit commitments
Committing to the circuit assignments
At the start of proof creation, the prover has a table of cell assignments that it claims satisfy the constraint system. The table has $n=2_{k}$ rows, and is broken into advice, instance, and fixed columns. We define $F_{i,j}$ as the assignment in the $j$th row of the $i$th fixed column. Without loss of generality, we'll similarly define $A_{i,j}$ to represent the advice and instance assignments.
We separate fixed columns here because they are provided by the verifier, whereas the advice and instance columns are provided by the prover. In practice, the commitments to instance and fixed columns are computed by both the prover and verifier, and only the advice commitments are stored in the proof.
To commit to these assignments, we construct Lagrange polynomials of degree $n−1$ for each column, over an evaluation domain of size $n$ (where $ω$ is the $n$th primitive root of unity):
 $a_{i}(X)$ interpolates such that $a_{i}(ω_{j})=A_{i,j}$.
 $f_{i}(X)$ interpolates such that $f_{i}(ω_{j})=F_{i,j}$.
We then create a blinding commitment to the polynomial for each column:
$A=[Commit(a_{0}(X)),…,Commit(a_{i}(X))]$ $F=[Commit(f_{0}(X)),…,Commit(f_{i}(X))]$
$F$ is constructed as part of key generation, using a blinding factor of $1$. $A$ is constructed by the prover and sent to the verifier.
Committing to the lookup permutations
The verifier starts by sampling $θ$, which is used to keep individual columns within lookups independent. Then, the prover commits to the permutations for each lookup as follows:

Given a lookup with input column polynomials $[A_{0}(X),…,A_{m−1}(X)]$ and table column polynomials $[S_{0}(X),…,S_{m−1}(X)]$, the prover constructs two compressed polynomials
$A_{compressed}(X)=θ_{m−1}A_{0}(X)+θ_{m−2}A_{1}(X)+⋯+θA_{m−2}(X)+A_{m−1}(X)$ $S_{compressed}(X)=θ_{m−1}S_{0}(X)+θ_{m−2}S_{1}(X)+⋯+θS_{m−2}(X)+S_{m−1}(X)$

The prover then permutes $A_{compressed}(X)$ and $S_{compressed}(X)$ according to the rules of the lookup argument, obtaining $A_{′}(X)$ and $S_{′}(X)$.
The prover creates blinding commitments for all of the lookups
$L=[(Commit(A_{′}(X))),Commit(S_{′}(X))),…]$
and sends them to the verifier.
After the verifier receives $A$, $F$, and $L$, it samples challenges $β$ and $γ$ that will be used in the permutation argument and the remainder of the lookup argument below. (These challenges can be reused because the arguments are independent.)
Committing to the equality constraint permutation
Let $c$ be the number of columns that are enabled for equality constraints.
Let $m$ be the maximum number of columns that can accommodated by a column set without exceeding the PLONK configuration's maximum constraint degree.
Let $u$ be the number of “usable” rows as defined in the Permutation argument section.
Let $b=ceiling(c/m).$
The prover constructs a vector $P$ of length $bu$ such that for each column set $0≤a<b$ and each row $0≤j<u,$
$P_{au+j}=i=am∏min(c,(a+1)m)−1 v_{i}(ω_{j})+β⋅s_{i}(ω_{j})+γv_{i}(ω_{j})+β⋅δ_{i}⋅ω_{j}+γ .$
The prover then computes a running product of $P$, starting at $1$, and a vector of polynomials $Z_{P,0..b−1}$ that each have a Lagrange basis representation corresponding to a $u$sized slice of this running product, as described in the Permutation argument section.
The prover creates blinding commitments to each $Z_{P,a}$ polynomial:
$Z_{P}=[Commit(Z_{P,0}(X)),…,Commit(Z_{P,b−1}(X))]$
and sends them to the verifier.
Committing to the lookup permutation product columns
In addition to committing to the individual permuted lookups, for each lookup, the prover needs to commit to the permutation product column:
 The prover constructs a vector $P$:
$P_{j}=(A_{′}(ω_{j})+β)(S_{′}(ω_{j})+γ)(A_{compressed}(ω_{j})+β)(S_{compressed}(ω_{j})+γ) $
 The prover constructs a polynomial $Z_{L}$ which has a Lagrange basis representation corresponding to a running product of $P$, starting at $Z_{L}(1)=1$.
$β$ and $γ$ are used to combine the permutation arguments for $A_{′}(X)$ and $S_{′}(X)$ while keeping them independent. The important thing here is that the verifier samples $β$ and $γ$ after the prover has created $A$, $F$, and $L$ (and thus committed to all the cell values used in lookup columns, as well as $A_{′}(X)$ and $S_{′}(X)$ for each lookup).
As before, the prover creates blinding commitments to each $Z_{L}$ polynomial:
$Z_{L}=[Commit(Z_{L}(X)),…]$
and sends them to the verifier.