You signed in with another tab or window. Reload to refresh your session.You signed out in another tab or window. Reload to refresh your session.You switched accounts on another tab or window. Reload to refresh your session.Dismiss alert
{{ message }}
This repository was archived by the owner on Sep 12, 2026. It is now read-only.
Repository navigation
Commit a72c025
Browse filesBrowse the repository at this point in the historyBrowse files
In particular, the memory log-size $\kmem$ is a non deterministic parameter, freely chosen at the beginning of execution, with the constraint $16\le\kmem\le32$.
48
48
49
-
\paragraph{Operands and addressing.} An operand is either an \emph{immediate}, a literal $\E$-element used as given, or an \emph{fp-relative reference}: an offset $j$ into the current frame, encoded as the $\gen$-power $o=\gen^{\,j}$. With the frame based at $\fp=\gen^{\mathrm{base}}$, the reference names the cell
49
+
\paragraph{Operands and addressing.} An instruction is an opcode followed by a list of $\K$-valued operands. An operand is either an \emph{fp-relative reference}, an offset $j$ into the current frame encoded as the $\gen$-power $o=\gen^{\,j}$, or one $\K$-lane of an \emph{immediate} ($k_0,k_1,k_2$ in \texttt{SET\_CONSTANT}, or $\md_0,\md_1$ in \texttt{BLAKE2S}). With the frame based at $\fp=\gen^{\mathrm{base}}$, a reference names the cell
\paragraph{Instruction set.} The machine implements six instructions. Below, $o,o_A,\dots$ are fp-relative references in $\K$, $k$ is an immediate operand in $\E$.
54
+
\paragraph{Instruction set.} The machine implements six instructions.
55
55
\begin{center}
56
56
\begin{tabularx}{\textwidth}{@{}llX@{}}
57
57
\hline
58
58
Instruction & Operands & Semantics\\
59
59
\hline
60
60
\texttt{XOR} & $[o_A,o_B,o_C]$ & $\loc{o_C}=\loc{o_A}+\loc{o_B}$\quad(addition in $\E$)\\
61
61
\texttt{MUL\_NATIVE} & $[o_A,o_B,o_C]$ & $\loc{o_C}=\loc{o_A}\cdot\loc{o_B}$ (multiplication in $\E$)\\
\texttt{BLAKE2S} is the standard BLAKE2s compression, consuming a $64$-byte message block and a $32$-byte chaining value and producing $32$ bytes. Each $128$-bit chunk occupies one full $\E$ memory cell through the canonical embedding $a_0+a_1y\mapsto a_0+a_1y+0y^2$; using a cell as a BLAKE2s operand therefore constrains its top limb to zero. The four message chunks are addressed \emph{independently} by references $o_0,\dots,o_3$ (chunk $i$ at $\loc{o_i}=\fp\cdot o_i$), while $o_V$ names two \emph{consecutive} chaining-value cells $\loc{o_V},\loc{\gen\cdot o_V}$. The $256$-bit result is written to the consecutive cells $\loc{o_C},\loc{\gen\cdot o_C}$, so each row accesses eight cells. The $128$-bit immediate $\md\in\E$ (with top lane zero) packs the standard compression metadata in little-endian order,
90
+
\texttt{BLAKE2S} is the standard BLAKE2s compression, consuming a $64$-byte message block and a $32$-byte chaining value and producing $32$ bytes. Each $128$-bit chunk occupies one full $\E$ memory cell through the canonical embedding $a_0+a_1y\mapsto a_0+a_1y+0y^2$; using a cell as a BLAKE2s operand therefore constrains its top limb to zero. The four message chunks are addressed \emph{independently} by references $o_0,\dots,o_3$ (chunk $i$ at $\loc{o_i}=\fp\cdot o_i$), while $o_V$ names two \emph{consecutive} chaining-value cells $\loc{o_V},\loc{\gen\cdot o_V}$. The $256$-bit result is written to the consecutive cells $\loc{o_C},\loc{\gen\cdot o_C}$, so each row accesses eight cells. The metadata immediate $\md=\md_0+\md_1y$ packs the standard compression metadata in little-endian order,
\paragraph{Tables and columns.} A column of height $2^{\kappa}$ is a function $\cube{\kappa}\to\K$. A table is a group of columns of equal height. The arithmetization fixes the number of tables $\ntab$ and, for each table $T_j$, its number of columns $\ncol{j}$, its $\ncons{j}$ constraints and its $\nfl{j}$ bus flushes. The table heights are not fixed: the prover announces each table's log height $\tau_j$ at the beginning of the proof.
9
9
10
-
\paragraph{Constraints.} The constraints of $T_j$ are $C_{j,1},\dots,C_{j,\ncons{j}}$, each a polynomial of degree at most $d$ ($d=2$ throughout) in the $\ncol{j}$ columns, required to vanish on every row in $\cube{\tau_j}$.
10
+
\paragraph{Constraints.} The constraints of $T_j$ are $C_{j,1},\dots,C_{j,\ncons{j}}$, each a polynomial in $\K$of degree at most $d$ ($d=2$ throughout) in the $\ncol{j}$ columns, required to vanish on every row in $\cube{\tau_j}$.
11
11
12
12
\paragraph{The bus.} All interactions (between tables) share a single \emph{bus}, a channel carrying tuples of up to $m=16$$\K$-elements (shorter ones are zero-padded). Table $T_j$ has $\nfl{j}$ flushes $\btup_{j,1},\dots,\btup_{j,\nfl{j}}$, each is either a \emph{push} or a \emph{pull}. Each one of the $m$ coordinates in each tuple is a fixed polynomial of degree at most $d$ in the table's columns. A few \emph{boundary} tuples are pushed (resp. pulled) by default to the bus (for instance for the VM state $(\dsep{ST}, \pc, \fp)$, the initial $(\dsep{ST}, \gen^0, \gen^0)$ is pushed and the final $(\dsep{ST}, \gen^{\,\nprog-1}, \gen^{0})$ is pulled).
13
13
@@ -76,74 +76,70 @@ \subsubsection{Two layers at a time}
76
76
77
77
\subsubsection{Batching several grand-products}
78
78
79
-
For recursion friendliness, $T$ grand productsare proven in one pass, at one sumcheck per layer instead of $T$.
79
+
For recursion friendliness, the $\nside$ grand products, numbered $s=1,\dots,\nside$, are proven in one pass, at one sumcheck per layer instead of $\nside$.
80
80
81
-
Pad every tree with $1$-leaves up to the depth $\mu$ of the deepest. The verifier then samples a combiner $\lambda\in\E$, and each layer runs a single sumcheck on the random linear combination of the $T$ identities,
81
+
Pad every tree with $1$-leaves up to the depth $\mu$ of the deepest. The verifier then samples at every layer a combiner $\lambda\in\E$, and each layer runs a single sumcheck on the random linear combination of the $\nside$ identities,
drawing a fresh $\lambda$ after every layer, which binds each tree's own tail values and not merely the combination they entered in. A round costs what one tree's round costs; only the layer-end values are per tree. All $T$trees leave the pass on claims at the one point $\zeta$.
85
+
All $\nside$trees leave the pass on claims at one shared terminal point $\zeta$.
86
86
87
87
\subsection{Stacking the leaves}\label{sec:leafstack}
88
88
89
89
The GKR grand-product argument reduces each side of \eqref{eq:gp} to a single evaluation $\widetilde V_0(\zeta)$ of its \emph{leaves}, the product's factors $\beta-\pi_\alpha(\btup)$, one per bus tuple $\btup$.
90
90
91
-
\paragraph{Flush blocks.} The leaves split into \emph{blocks}, one per flush rule and one per boundary set. A block of a $2^{\kappa}$-row table holds $2^{\kappa}$ leaves; the row-$z$ leaf is $\beta-\sum_{i}\eq(\alpha,i)\,c_{i}(z)$, with $c_{i}(z)$ coordinate $i$ of the row's tuple. Each $c_i$ is a polynomial of degree at most $d$ in the row's columns (\S\ref{sec:m3}).
91
+
\paragraph{Flush blocks.} The leaves split into \emph{blocks}, one per flush rule and one per boundary set. A block of a $2^{\kappa}$-row table holds $2^{\kappa}$ leaves; the row-$z$ leaf is $\beta-\sum_{i}\eq(\alpha,i)\,c_{i}(z)$, with $c_{i}(z)$ coordinate $i$ of the row's tuple. Each $c_i$ is a polynomial of degree at most $d = 2$ in the columns (at the corresponding row) (\S\ref{sec:m3}).
92
92
93
-
\paragraph{Layout.} Order the blocks largest first at aligned offsets, padding to $2^{\mu}$ leaves with $1$s, which leave the product unchanged. This is the stacking of \S\ref{sec:stacking} applied to blocks: block $b$, of $2^{\kappa_b}$ leaves, occupies the subcube $\{(z,\mathsf{sel}_b):z\in\cube{\kappa_b}\}$ for a fixed selector $\mathsf{sel}_b$.
93
+
\paragraph{Layout.} Order the blocks largest first at aligned offsets, padding to $2^{\mu}$ leaves with $1$s, which leave the product unchanged. This is the stacking of \S\ref{sec:stacking} applied to blocks: block $b$, of $2^{\kappa_b}$ leaves, occupies the subcube $\{(z,\mathsf{sel}_b):z\in\cube{\kappa_b}\}$ for a fixed selector $\mathsf{sel}_b$ (that depends only on the table, bytecode and memory sizes).
94
94
95
95
\paragraph{Decomposition.} Split $\zeta=(\zeta^{b}_{\mathrm{lo}},\zeta^{b}_{\mathrm{hi}})$ at block $b$'s boundary. Each block is a subcube, so the leaf MLE splits into a public selector times the block's own MLE, plus what the padding contributes:
That last term is the padding's weight, for the final $\dots1111$.
100
100
101
-
\paragraph{Settling it.} The boundary tuples (\S\ref{sec:m3}) and each array's seed and finalization (\S\ref{sec:lookup}) belong to no table. Their entries have degree one: a constant, the index column (\S\ref{sec:idxcol}), a public component, or one committed column. The prover sends, for each such committed multilinear, its evaluation at $\zeta^{b}_{\mathrm{lo}}$. These claims are then deferred to the PCS (\S\ref{sec:stacking}). The verifier finally evaluates each contribution, and subtracts them, with the corresponding padding term, from the claimed value of $\widetildeV_0(\zeta)$. Call the remainder $R_{\mathrm{side}}$: it remains to prove an equation similar to \eqref{eq:gkr_leaves}, summing only on the flush blocks from tables.
101
+
\paragraph{Settling it.} Fix one side $s$. The boundary tuples (\S\ref{sec:m3}) and each array's seed and finalization (\S\ref{sec:lookup}) belong to no table. Their entries have degree one: a constant, the index column (\S\ref{sec:idxcol}), a public component, or one committed column. The prover sends, for each such committed multilinear, its evaluation at $\zeta^{b}_{\mathrm{lo}}$. These claims are then deferred to the PCS (\S\ref{sec:stacking}). The verifier finally evaluates each contribution, and subtracts them, with the corresponding padding term, from the claimed value of $\widetildeV^{s}_0(\zeta)$. Call the remainder $R_{s}$: it remains to prove an equation similar to \eqref{eq:gkr_leaves}, summing only on the flush blocks from tables.
102
102
103
103
Let $\mathcal B$ be the blocks of $T_j$'s flushes in this leaf vector, one per flush rule (\S\ref{sec:m3}). Each holds one leaf per row of $T_j$, so each is $2^{\tau_j}$ tall and all of them split $\zeta$ at the same place, $\zeta^{b}_{\mathrm{lo}}=\zeta_{<\tau_j}$ and $\zeta^{b}_{\mathrm{hi}}=\zeta_{\ge\tau_j}$, differing only through their selector. Exchanging the two sums,
$B_j$ has degree at most $d$ in $T_j$'s columns, and the verifier builds its coefficients from $\alpha$, $\beta$ and the selectors. What remains to prove is
109
+
$B^{s}_j$ has degree at most $d$ in $T_j$'s columns, and the verifier builds its coefficients from $\alpha$, $\beta$ and the selectors. What remains to prove is
Nothing is sent for these blocks. Each constraint of $T_j$ owes a sum of the same shape, so one sumcheck over the tables' rows proves both (\S\ref{sec:air}).
113
+
There is one such equation per side. Nothing is sent for these blocks. Each constraint of $T_j$ owes a sum of the same shape, so one sumcheck over the tables' rows proves them all (\S\ref{sec:air}).
114
114
115
115
\subsection{Table sumcheck}\label{sec:air}
116
116
117
-
Number the sides $s=1,\dots,T$, one per grand product (\S\ref{sec:gkr}), and write $B^{s}_j$ and $R_{s}$ for the forms and totals of \S\ref{sec:leafstack}. One sumcheck proves two types of statements:
the first for every constraint of every table, the second for every side. Both are $\eq$-weighted sums over one table's rows of a polynomial of degree at most $d$ in its columns, which is what lets a single sumcheck carry them all.
117
+
\paragraph{Proving constraints via zerocheck.} $C_{j,i}$ is a polynomial in $T_j$'s columns, so it is a function $\cube{\tau_j}\to\K$ that must vanish on every row. Following Fact~\ref{fact:eq}, this can be proved by sampling $r\in\E^{\tau_j}$ uniformly at random and running sumcheck on:
\paragraph{Constraints are $\K$-valued.} A constraint $C_{j,i}$ takes values in $\K$, like the columns it reads and like the bus coordinates (\S\ref{sec:m3}); only the $\xi$-powers and $\eq(\zeta,\cdot)$ that weight it lie in $\E$. A relation between machine words is therefore stated lane by lane, three $\K$ constraints rather than one $\E$ constraint, with the tower multiplication unrolled (\S\ref{sec:tab-mul}); the two have the same zero set, since $\{1,y,y^{2}\}$ is a $\K$-basis of $\E$. The prover gains by it: in the round a table joins the batch its columns are still $\K$-valued (below), so a $\K$ constraint is evaluated in $64$-bit arithmetic and meets $\E$ only in the mixed product against its $\xi$-power, while an $\E$ constraint would cost a full $\E$ multiplication per row.
122
+
\paragraph{Zerocheck point recycling.} Nothing forces $r$ to be sampled just before the zerocheck: it may come from a previous sub-protocol, as long as it results from uniform sampling occurring after the table columns are committed. We take $r=\zeta_{<\tau_j}$, the first $\tau_j$ coordinates of the GKR terminal point $\zeta$ (\S\ref{sec:gkr}). Validity of the constraints is thus reduced to:
\paragraph{The point is already drawn.} A zerocheck tests its polynomial at a point drawn after the commitment (Definition~\ref{def:zerocheck}), and $\zeta$ is such a point: its coordinates are the challenges of the GKR pass (\S\ref{sec:gkr}), uniform in $\E$ and drawn after the witness was committed. The constraints played no part in producing them. So no fresh point is needed, and the constraints are zerochecked at $\zeta_{<\tau_j}$, where the bus forms already stand.
128
+
\paragraph{The bus claims join in.} \S\ref{sec:leafstack} left one per side, at that same point,
Both \eqref{eq:cons} and \eqref{eq:bus} are built from $\eq(\zeta_{<\tau_j},\cdot)$-weighted sums over one table's rows of a polynomial of degree at most $d$ in its columns: we batch them in a single sumcheck.
127
134
128
-
\paragraph{One challenge.} The verifier samples $\xi\in\E$, after the totals are fixed. Each table mixes everything it owes into one polynomial in its own columns,
135
+
\paragraph{Back-loaded batched sumcheck.} The verifier samples $\xi\in\E$ and gives each claim its own power of it: $\xi^{\,s-1}$ for side $s$, and $\xi^{\,\nside+o_j+i-1}$ for $C_{j,i}$, with $o_j=\ncons{1}+\dots+\ncons{j-1}$ numbering the constraints table by table. A sumcheck runs over one cube, so write $\taumax=\max_j\tau_j$, let $X_{<\tau_j}=(X_0,\dots,X_{\tau_j-1})$ be the variables $T_j$ uses, and multiply in the ones it does not:
with$\sigma=\sum_j\ncons{j}$ the total number of constraints and $o_j=\ncons{1}+\dots+\ncons{j-1}$. The constraint powers are disjoint across tables, so no table's violation is cancelled by another's. The $T$ bus powers are shared by every table, which is what the bus needs, only the totals being pinned. If every constraint vanishes then
141
+
Since$\sum_{x\in\cube{m}}x_0\cdots x_{m-1}=1$, the padded variables contribute a factor $1$, so summing $F$ over $\cube{\taumax}$ gives back what each table owes. We thus run a single sumcheck:
a number the verifier formed before drawing $\xi$. Reaching it forces the $T$ bus equations at once, and a zero in every constraint slot, up to $(n+\sigma+T)/|\E|$ over $\zeta$ and $\xi$ (Corollary~\ref{cor:idtest}), writing $\taumax=\max_j\tau_j$.
140
-
141
-
\paragraph{One sumcheck.} The $S_j$ are claims of different lengths. Lift each onto $\cube{\taumax}$ by attaching the indicator of the all-ones assignment on the $\taumax-\tau_j$ variables $T_j$ does not use,
so that $\sum_{x\in\cube{\taumax}}f_j(x)=S_j$, since $\sum_x\prod_ix_i=1$. With $F=\sum_jf_j$ the whole statement is one claim, $\sum_{x\in\cube{\taumax}}F(x)=\sum_jS_j$, proven in $n$ rounds.
146
-
147
-
The rounds bind $X_{\taumax-1}$ first and $X_0$ last, so the first $\taumax-\tau_j$ of them touch only variables $T_j$ does not use: there $f_j$ contributes the line $Y\,k\,S_j$, with $k$ the product of the challenges drawn so far. Table $T_j$ enters at round $\taumax-\tau_j$ and binds $X_{\tau_j-1},\dots,X_0$ in turn. A short claim waits, then joins weighted by the rounds it sat out.
148
-
149
-
The batch ends with one claim per column of $T_j$, at that table's own point $\fc_{<\tau_j}$, each a prefix of the one $\fc$. Those are what the PCS opening settles (\S\ref{sec:stacking}); no column is ever opened at $\zeta$.
145
+
the verifier computing the right side itself, at soundness error $\bigl(\taumax+\nside+\sum_j\ncons{j}\bigr)/|\E|$ (Corollary~\ref{cor:idtest}). Rounds bind $X_{\taumax-1}$ first, so $T_j$ joins only at round $\taumax-\tau_j$: hence \emph{back-loaded}. The end yields one claim per column, $T_j$'s at $\fc_{<\tau_j}$, settled by the PCS opening (\S\ref{sec:stacking}).
0 commit comments