Semantic relations in an Akita fold
This page derives the semantic relations proved by one non-terminal Akita fold. The central question is the second correctness obligation from the previous page: are the method-selected partial evaluations consistent with the same incoming polynomial that is being folded?
The presentation starts with one polynomial group and one opening claim. The commitment relations use the ordinary source ring
The opening-consistency relation has two method-dependent geometries:
EvaluationTracekeeps a full ring partial and proves the relation in .SubringCoefficientPackingkeeps extension-field coefficients, proves the corresponding relation in the challenge subring, and embeds the same sparse challenge into for the source fold.
The other three semantic roles—inner-commitment, outer-commitment, and opening-commitment consistency—are unchanged by that choice.
The current implementation also supports more elaborate physical layouts. These include commitment groups, witness chunks, and different ordinary , , and ring dimensions. These extensions do not change the four core relations developed below. This page establishes only the basic case; advanced layouts are outside its scope. The advanced relation layouts page develops the multi-group case. The raw and compressed realizations use the same semantic relations; the compression realization introduces its own smaller ring dimensions.
The four families below are the semantic source relations. The current implementation realizes the and commitment relations either by transmitting their semantic commitments as raw payloads or by binding those commitments to smaller terminal payloads through compression relations. This choice changes their physical realization, not the four semantic constraints derived here.
The goal of the fold is to reduce the claims about the current polynomial blocks to an opening claim about a new digit witness. This is a reduction of the statement carried forward, not a guarantee that the complete next-level witness is smaller. The fold proves that the new witness is consistent with:
- the opening data computed from the old polynomial;
- the inner and outer commitments; and
- the random fold of the old polynomial blocks.
These statements form the semantic core of the physical ring relation. The scalar evaluation claim from Field-to-ring evaluation reduction is a separate field-valued relation. Each opening method supplies its own public linear map from opening digits to that scalar. This page instead proves the source-consistency relation that justifies those digits. The scalar row and physical rows are fused later.
Contents
Inputs and objects derived in the fold
A fold starts from a public opening claim
for a polynomial whose commitment payload is already fixed. We call the semantic commitment behind that payload. In raw mode, itself is transmitted; in compressed mode, the payload is the smaller terminal commitment , which is bound to by the compression relations on the realizations page.
The prover and verifier have different views of these inputs. The prover holds the polynomial blocks, their inner-digit representation, the commitment hint generated when the commitment was formed, and the public commitment payload. The verifier knows that payload and the opening claim, but receives neither the blocks nor the hint.
From these inputs, the current fold derives two new representations of the committed polynomial. The opening point determines partial evaluations inside each block, while fresh transcript challenges fold the old block digits into a response . Both are digit-decomposed before entering the next committed witness. The four relation families later prove that these derived objects are consistent with the same hidden opening of .
The committed polynomial and opening query
As in the previous page, split the ring-valued polynomial table into blocks. Let index a live block and a position inside that block. Pack the inner coefficient axis into the ring element
The field-to-ring evaluation
reduction splits into
inner, position, and block coordinates and defines their interpolation weights
, , and . We reuse those definitions here rather than
deriving them again. The position weights produce below, while the
block weights and inner weights belong to the field-valued
evaluation relation. The opening claim enters this page with target . An
EvaluationTrace fold later writes its reduced target as ;
a SubringCoefficientPacking fold binds the original scalar target directly.
For the single base-field claim considered here, the valid method-selected
target equals .
Balanced digit representations
Both the existing commitment opening and the next committed witness must have bounded coefficients. This shortness condition is what lets commitment binding reduce to Module-SIS: two distinct bounded openings of the same linear commitment would yield a short, nonzero kernel vector.
Akita obtains these bounded representations by decomposing ring coefficients into balanced base- digits. Let be an even power of two, let be the digit depth, and let . A balanced decomposition of consists of digit rings , indexed by and , such that
for every coefficient position . Stack the digit rings with innermost into . Define the gadget row and its block-diagonal recomposition matrix by
The coefficientwise identities then become the vector equation
The entries of are public scalars embedded as constant ring elements. Thus is a deterministic recomposition matrix, not a commitment matrix such as , , or . Digit decomposition produces ; multiplication by reconstructs . The protocol's range check certifies that the committed coefficients of lie in the balanced digit range.
Akita chooses separate bases and depths for different witness roles. To keep the derivation readable, write , , , and for the corresponding scalar gadget weights. The four recomposition identities used on this page are
The first two identities describe commitment-side data already fixed by the incoming commitment payload: is the incoming inner-digit representation, and is reconstructed from the incoming hint. The latter two digit families, and , are newly derived from the opening point and fold challenges. We now place each identity in its protocol context.
Polynomial blocks and commitment hint
The commitment-side inputs are fixed before the polynomial is queried. For each block, the prover has the inner digit rings and can therefore recompose the polynomial rings as
For one block, collect the digit rings into a vector . The inner commitment matrix maps this block vector to an inner image
Each coordinate of is itself represented by balanced outer digits:
where selects a row of . Stack these digits over all blocks to obtain . The outer commitment matrix then gives the semantic commitment
The two matrices have distinct roles: forms one inner image per block, whereas commits the digit-decomposed inner images across all blocks. The prover's commitment hint stores the recomposed inner images ; this fold decomposes them to recover . At a recursive level, the polynomial blocks, hint, and public payload were produced by the preceding level. At the root, they come from the original commitment. The semantic commitment fixes this commitment-side data. Equations (1)--(4) describe its hidden opening, which the later relation rows bind to .
Partial evaluations and opening digits
The first new witness object derived in this fold comes from the opening point. Use its position weights to evaluate the position coordinate inside each block. In the base-field setting of the previous page, acts as a constant in :
Digit-decompose each with the opening gadget weights :
The fold witness contains the digit rings , not a second copy of the recomposed . Their semantic opening commitment is
Here commits to the digit-decomposed partial evaluations.
Equations (5) to (7) show the EvaluationTrace shape, where each partial is a
full ring element. With SubringCoefficientPacking, the previous page instead
splits the source coefficient index as
contracts , and retains . The resulting partial is
Writing each -coefficient in the canonical basis gives base-field coordinates:
Thus the two methods create different opening-digit layouts, but in both cases binds the newly derived digits. The scalar derivation already showed how the packed coordinates recombine into the original opening claim. The next subsection proves that they came from the folded source.
The subscript in distinguishes this ring-vector commitment from the scalar opening target and its method-selected field relation. Equation (7) binds the newly derived opening digits; it does not by itself prove the scalar evaluation claim.
The folded response and its digitization
The semantic opening commitment commits the prover to . It does not by itself show that the corresponding partial evaluations were computed from the incoming polynomial blocks. That missing link is method-dependent.
Evaluation-trace consistency
For EvaluationTrace, correctness in every block requires
Equation (8) connects the partial evaluation derived in this fold to the incoming block witness . The semantic commitment creates a second consistency requirement. Equation (4), , binds the outer digits , which recompose the inner images through Equation (3). However, this commitment relation does not by itself show that the inner images were computed from the incoming block witness. The missing link is the blockwise relation from Equation (2).
Checking both relations separately for every live block would retain the block index in the next proof. Instead, after the public payloads binding and have been fixed, the transcript samples one sparse ring-valued challenge for each live block. These challenges are separate from the query weights . The prover folds the incoming block witnesses into one response:
The folded response no longer carries a live-block index. Because both blockwise relations are linear in , the same challenges batch them into relations on this single response. For the partial evaluations, Equations (8) and (9) give
For the inner commitments, Equations (2) and (9) give the vector relation
Equation (9a) says that evaluating within each block and then folding gives the same result as first folding the block witnesses into and then applying the evaluation weights. Equation (9b) similarly connects to the inner images bound through . If any blockwise relation is incorrect, its error is unlikely to disappear in the corresponding random combination. Thus the challenges remove the block index while preserving the two links from the incoming witness: one to the partial evaluations created in this fold, and one to the commitment that entered it.
Subring-coefficient-packing consistency
Recall the coefficient-table index split
Here (read "ell") is only the flat coefficient index in the A ring: selects a column and selects a row. The packed partial has already taken the same weighted sum across the columns of every row. It keeps the rows, so the fold challenge must act on those rows without mixing the already-contracted column axis. This is why it is sampled from
We use two linear maps. The first symbol below is (Greek "iota", not the index ). It embeds a row operation from into the source ring :
The second map, , is the public packing map from one source-block vector to . For any vector with the same shape as , define
Thus first recomposes the inner digits with , then contracts the position axis and the column axis , while leaving one output coefficient for every row . Together with the definition of above, Equation (1) gives . The intuition is now simple: moves rows, while compresses each row. For example, take , , , and . The source table has two rows of width four. In this picture, and already include the position sum over and the inner-digit recomposition over :
u = 0 1 2 3 after applying L
j = 0 a0 a1 a2 a3 ----------------------> e0
j = 1 b0 b1 b2 b3 ----------------------> e1
Both rows use the same packing weights, so
Since , multiplying in moves the first row to the second and wraps the second row back with a minus sign. Thus becomes . Applying after this move gives . Applying first gives , and multiplying by in gives the same result because :
Because any is a linear combination of these row shifts, the same commuting identity holds for every challenge:
The transcript draws one per live block and the prover forms
Linearity and Equation (9c) then give the packed source-consistency identity
The same embedded challenges are used in the inner-commitment identity . There is no second challenge draw for the A relation. This shared challenge is what makes the packed partial and the source fold describe the same random combination of blocks.
This compression has an arithmetic cost: combining the blocks increases
coefficient magnitudes. Let bound the coefficient norm of
every digit block , and let
, using itself for
EvaluationTrace and its sparse embedding for packing.
Negacyclic multiplication gives
where is the set of live blocks. The schedule fixes the challenge family, its relevant norm bounds, an admissible fold-response bound , and a digit depth large enough to represent the accepted response. The implementation may resample the transcript nonce until the resulting fits that scheduled bound. This grinding helps the honest prover find a compact response; the range check on its committed digits is what certifies the bound in the protocol.
Equations (9a), (9b), and (9e) are identities among recomposed values; they do not yet use the opening digits , the outer digits , or bounded digits for . The next-level committed witness contains digit rings rather than itself so that its shortness is certified for the Module-SIS binding argument. Akita therefore decomposes once more:
The three main digit segments assembled for the next witness are therefore
They have different origins:
| Segment | What it digit-decomposes | Why it is needed |
|---|---|---|
| the challenge-folded block digits | becomes the smaller folded response | |
| the position-folded rings | carries the opening data into the fold | |
| the inner images | binds the folded response to the existing commitment |
The four semantic relation families
Equation (11) specifies how the three digit segments are assembled, but it does not impose any algebraic relation among them. Substituting the balanced recompositions into the identities above gives two relations among the private witness segments. Equations (4) and (7) provide two additional relations that define the semantic commitments and computed by and , respectively. Together, these give four semantic roles. Three are ordinary ring relations over
The opening-consistency family is also over for EvaluationTrace; for
packing, it is over and is later realized through coordinate
planes. Vector equations are interpreted coordinatewise in their stated ring.
The first two families connect private witness segments to one another. The
last two define the semantic commitments and .
1. Fold-evaluation consistency
For EvaluationTrace, Equation (9a) is the fold-evaluation identity among the
recomposed values. Substitute the balanced digit representations of
from Equation (6) and from Equation (10) to obtain
This relation uses the random fold challenges , not the block-opening weights . The latter belong to the separate field-valued evaluation relation on . In particular, this ring relation does not contain the scalar target .
For SubringCoefficientPacking, substitute the packed opening-digit
recomposition and Equation (10) into Equation (9e):
The outer is essential: it reconstructs each coordinate separately before applies the position weights , the inner gadget weights , and the packing weights . Equivalently, the right-hand side is
This is the same semantic obligation in the smaller geometry: the packed partials on the left and the packed folded source on the right must agree. The expression is one logical -valued relation. Its physical realization uses extension-coordinate planes. The packed E/Q contributions enter the common relation-weight factorization, while the folded-source contribution is a separate packing-Z Stage-2 term. Together they realize one protocol claim, not independent claims.
2. Inner-commitment consistency
Equation (9b) is the inner-commitment identity among the recomposed values. The next-fold witness stores their balanced digits instead. Substitute Equation (3) for and Equation (10) for . For every row of , this gives
For packing, every in Equation (13) denotes the embedded element . Thus Equations (12b) and (13) use the same transcript challenge in their respective native geometries.
There is no factor on the right of Equation (13): already acts on the inner digit vector , whose columns are indexed by .
3. Outer-commitment consistency
The first two families compare private witness segments but do not yet define the commitment produced by the outer commitment matrix. The semantic outer-commitment relation is
Here , where is the output rank of . Equation (14) binds the private outer digits to the semantic commitment and does not use the fold challenges. In the raw realization, the prover proves this equation directly against the public . In the compressed realization, remains the semantic intermediate value: the prover recommits it through an chain and proves that the chain ends at the smaller public payload .
4. Opening-commitment consistency
Likewise, the semantic opening-commitment relation defines the commitment to the opening digits under :
Here , where is the output rank of . Equation (15) similarly binds the private opening digits to the semantic opening commitment . In the raw realization, the prover proves this equation directly against the public . In the compressed realization, remains the semantic intermediate value: the prover recommits it through an chain and proves that the chain ends at the smaller public payload .
The public value binding this relation is absorbed before the fold challenges are sampled: raw mode absorbs , whereas compressed mode absorbs . Together with the boundedness of and Module-SIS binding, this prevents the prover from adapting the partial-evaluation digits after learning those challenges. Like the other three families, Equation (15) is a ring-valued relation distinct from the field-valued scalar evaluation claim.
The four families above determine the algebraic constraints of a valid fold, but they do not yet determine which commitment values are transmitted, which additional witness segments are required, or which native-ring rows appear in the proved matrix relation. Raw and compressed realizations of an Akita fold makes those choices explicit while preserving the method-selected Equation (12a) or (12b) together with Equations (13)--(15) as their semantic source.