Keyboard shortcuts

Press ← or → to navigate between chapters

Press S or / to search in the book

Press ? to show this help

Press Esc to hide this help

Advanced relation layouts

The semantic relations in an Akita fold start with one commitment group, one witness chunk, and one common ring dimension, while the realizations page turns those relations into physical rows. This page develops three independent extensions: multiple commitment groups, multiple witness chunks, and mixed commitment-ring dimensions. All three preserve the four semantic relation families. Multiple groups add group-local rows around one level-owned D relation, multiple chunks divide one group's witness columns across block ranges without duplicating those rows, and mixed rings assign each row family its role-native dimension.

The physical opening-commitment relation remains distinct from the field-valued evaluation trace. Each section isolates one extension under its own simplifying assumptions before explaining how it composes with the other axes.

Contents

Multiple commitment groups

Why multiple commitment groups

In zkVM applications, polynomials such as execution traces, advice, and preprocessed data may be committed at different times. When one commitment is formed, the prover may not yet know which other commitments it will later be opened with, the opening point, or the root schedule that will combine them. Akita calls the polynomials held under one independently formed outer commitment a commitment group. The layout associates one complete opening point with each group, shared by all claims in that group. Different groups may be opened at different points. One group is the final/new group, while commitments formed earlier enter as precommitted groups with already-fixed parameters.

Proving each commitment group separately would repeat the entire recursive opening protocol. Akita instead batches the groups in one root transition and then resumes the ordinary single-opening recursion. The batching preserves the separate group commitments and folded responses: each group has its own , , and group-local consistency | A | B relations. On the opening side, however, every group contributes an segment to one logically concatenated vector. One matrix binds that entire vector, and the field-level evaluation trace separately batches the claimed evaluations at their group-local points.

Group-local folded responses and relations

To isolate the group axis, assume one witness chunk, one common ring dimension, and one polynomial claim per group, then add a group index to the previous notation. Group has its own blocks , fold challenges , and folded response

There is no sum over : the folded responses remain separate. The basic consistency, , and relations are repeated independently for every group. In the semantic relation, the rows bind to that group's outer commitment . Each group also produces opening digits , which become one segment of the shared opening vector.

The fold and outer-commitment parts remain group-local because each commitment fixes its own and matrices, decomposition parameters, and semantic target . Its folded response is formed with that group's challenges and must be checked against those fixed parameters. Combining the responses across groups would lose these group-specific commitment bindings.

The shared opening-commitment relation

The relation can be shared for a different reason. Unlike and , is owned by the fold level rather than by an individual commitment group. Every segment uses the same opening-role ring dimension and decomposition basis, so the segments can occupy disjoint column ranges of the single opening-commitment matrix and form one input vector:

Here the concatenation is logical and follows relation order: the final/new group first, then the precommitted groups in public order. It combines only the opening-digit inputs to ; the original group witnesses, folded responses, and outer-commitment digits remain group-local. The fixed column ranges record which coordinates came from each group, and the group-local consistency rows prove what each segment represents at that group's own opening point.

Semantic relations and witness layout

In the canonical semantic-row order, the final/new group is placed first, followed by the precommitted groups. The shared rows follow all group-local rows:

The semantic target vector is therefore

The semantic layout is block sparse: a group's consistency, , and rows touch only that group's witness segment, whereas the shared rows touch the segments from every group. Stage 2 batches the realized physical rows into one sumcheck, but this batching does not merge the group-local relations.

The corresponding logical witness layout is

The displayed rows, target vector, and are the complete semantic multi-group relation under this section's single-chunk, common-ring assumptions. They specify the algebraic variables, row support, and group ordering without choosing a public payload representation.

Raw and compressed modes realize this semantic layout as described on the realizations page. Multi-grouping changes the group-local row blocks and the input layout of the shared relation, but not the ordinary quotient or compression machinery.

Return to the single-group recursion

The root fold consumes this multi-group semantic structure. After the semantic rows have been realized and prepared for field checking, their witness coordinates form one complete flat ring-switch witness. That witness is aligned to the successor commitment ring dimension and committed once. Stage 2 evaluates it at its sumcheck-derived opening point, producing one witness-side opening claim for the next fold.

Thus the contribution descended from the original root batch is one committed witness and one opening claim. Its coordinates retain the original group ranges inside the flat layout, but those root groups no longer define separate folded responses or relation rows. If setup offloading is active, the next fold may also receive an independent setup-prefix group; that extra group does not preserve or recreate the original root grouping.

Multiple witness chunks

Why multiple witness chunks

The basic fold immediately reduces all live blocks to one folded response

This is algebraically compact, but it creates a synchronization point when the source blocks are distributed across GPU workgroups, devices, or machines. Each worker already owns a contiguous block range together with the semantic inner rows retained in the commitment hint. Forming one outgoing would require the workers to reduce their full-width responses before that response could enter the next witness.

A multi-chunk fold retains those local responses instead. A worker can derive its opening digits and folded-response digits from the same local blocks and contribute one unit

to the outgoing witness. The smaller outer- and opening-commitment images can still be combined across chunks. Linearity then lets the relation sum all chunk contributions in the original rows. Thus multi-chunking changes the witness columns, not the semantic row families or their public targets.

The protocol defines chunks as witness block ranges, not as trusted parties or a required execution schedule. An implementation may map a chunk to one GPU workgroup, device, or machine. The current prover also retains the aggregate internally where useful; the protocol-level change is that the committed witness carries the local responses rather than one global response.

This locality has a cost. The and segments are partitioned across chunks and do not grow in total, but every chunk carries a full-width segment. For chunks, the live ordinary witness therefore gains coordinates relative to the single-chunk layout.

ObjectEffect of multi-chunking
Replaced by full-width local responses
Partitioned by block range; total width is unchanged
Remain aggregate commitment images
Semantic rows and targetsRemain unchanged

Chunk ranges and commitment-side data

To isolate the chunk axis, assume one commitment group, one polynomial claim, the EvaluationTrace opening method, one unsliced matrix, and one common ring

Commitment slicing is a separate axis. It uses the same proportional partition, as described in B slices and chunks.

Let be the number of live blocks. Let be a supported power-of-two chunk count and, for this derivation, assume . For , chunk owns the equal-sized range

Root source chunks use the canonical proportional partition, including unequal and empty ranges. When the producer has multiple chunks, each emitted Z/E/T body is aligned to a multiple of the next fold's source-block coefficient width. The canonical prover fills the alignment gaps with zero. The next fold inherits those bodies instead of repartitioning the witness equally; if its chunk count contracts, it merges adjacent owners. The last owner also receives the complete quotient and compression tail and the final power-of-two padding. T ranges end before the alignment gaps, which add no semantic Z/E/T coordinates. The gaps belong to the committed witness and obey the ordinary digit range constraints, but carry no relation equations. Verification does not require zero. Zero filling adds no energy to the honest prover's source model; nonzero filler becomes part of the next fold's source and can affect its responses, which must still meet that fold's enforced bounds. See response security accounting. This ownership changes no relation below. The transcript still samples one challenge for every global live block; it does not sample an independent challenge family for each chunk.

Before the opening query, the incoming commitment has already fixed the commitment-side data. For every , the commitment computation viewed the -th polynomial block as one vector and formed its inner image

Here contains all inner-digit ring elements in block ; no additional coordinate indices are needed for this commitment path. Let denote the outer gadget-recomposition map applied coordinatewise to an inner image. Its bounded digit representation satisfies

The commitment hint retains the recomposed inner images , not materialized outer digits. During the current fold, chunk decomposes the images belonging to its range and collects the recovered digits as

The complete outer-digit vector and the corresponding column partition of are

The chunk-local outer image

is an algebraic partial contribution, not a separate payload. The semantic commitment is

Raw mode exposes the aggregate . In compressed mode, the chunk-local images are first reduced to this single ; only then is used as the hidden source of one shared chain. Multi-chunking does not create one compression payload per chunk.

Chunk-local partial evaluations and opening commitment

The opening point supplies the same opening vector as in the basic derivation. Let recompose the inner digits at every position of a block, and let be the row map induced by the weights . For every block , chunk computes the partial evaluation directly from its block vector and decomposes the result:

Here recomposes the opening digits of . Collect the blocks belonging to chunk into . The complete opening-digit vector is their concatenation:

The partial evaluations and the digit segments remain local to their chunks. Partition the columns of the opening-commitment matrix along the same ranges,

Chunk can then compute its opening-commitment contribution directly:

By linearity, the semantic opening commitment is obtained by reducing only these smaller images:

Thus a distributed prover does not aggregate the block-indexed partial evaluations or their digit segments. Each worker first applies its local columns of , and the workers aggregate only the resulting opening-commitment images. Like , the partial image is not a public payload. Raw mode exposes the aggregate . In compressed mode, the workers likewise first reduce their partial images to the single ; only then is used as the hidden source of one shared chain. Multi-chunking does not create one compression chain per chunk.

Chunk-local folded responses and witness relations

The payload binding and is fixed before the transcript samples the fold challenges . Computing the basic global response at this point would require the workers to reduce a full-width vector. Multi-chunking instead keeps the response local.

Chunk then folds only its own source blocks:

Each has the same full ambient width as the single response . It is a partial sum over blocks, not a width slice. Decompose it with the ordinary fold gadget. Writing for its coordinatewise recomposition map gives

Together with the local opening and outer-commitment digits, this gives the chunk-local witness unit

Within the logical witness for the four ordinary semantic relation families, the three segments of each unit are contiguous, and the units themselves are concatenated in chunk order:

Thus is the complete chunk-major logical witness for those four families, not one separately proved witness per chunk. The physical witness aligns multi-chunk bodies with zeros, then appends quotient digits and compression data as required by the selected relation and payload modes. The complete witness layouts describe both choices.

The local responses still define the same global folded response algebraically:

The global is therefore determined by the chunk-local witnesses, but it is not an additional committed coordinate and need not be materialized through a full-width reduction before constructing the outgoing witness. The distributed prover explains how the workers combine partial commitments to that witness.

The basic is not a concatenation or reordering of the local segments. Recovering that digit vector would require materializing the global and decomposing it again; the multi-chunk relation avoids that full-width reduction by acting on the local digit vectors directly.

This aggregation must also be reflected in weak binding. Stage 1 checks every against the same balanced digit interval, but the shared A rows bind . For basis and fold depth , one accepted chunk has exact difference diameter ; accepted chunks therefore have aggregate diameter . The A-role SIS row is sized for this aggregate envelope, not for a single chunk. Honest chunk norms may differ because the block ranges are ragged, but every chunk keeps the same basis, depth, and full ambient Z width.

Because the ranges partition the live blocks, this derived still satisfies the two recomposed identities from the basic setting:

Substituting the digit decompositions of , , and the derived gives the aggregate fold-evaluation consistency relation

The same substitution gives aggregate inner-commitment consistency:

Semantic relations remain unchanged

For the complete chunked witness , the four proved semantic relations can be read together in canonical row-family order:

These are the same four semantic relations as in the basic setting. Their semantic target remains

Each relation sums the relevant chunk-local witness contributions inside the original rows. Multi-chunking does not create a separately proved row family for every chunk; it changes the witness layout and the column support of those rows.

Raw and compressed modes realize these same semantic relations as described on the realizations page. Chunking does not replicate the ordinary quotient family or the shared compression chains. The field-valued evaluation trace likewise remains one virtual relation over the chunk-local opening-digit ranges, not an additional physical ring row; its construction is described in Field-to-ring evaluation reduction.

When , the sole range contains every live block, the single local response is , and every equation and witness layout above reduces to the basic single-chunk construction.

Mixed commitment-ring dimensions

Why use different ring dimensions

The common-ring derivation gives , , and one dimension because that is the simplest setting in which to see the four semantic relations. The three matrices perform different jobs, however, and need not have the same best dimension. The matrix carries the source and folded witness, the matrix binds the outer-commitment digits, and the matrix binds the opening digits. A larger ring may improve fold geometry or shorten the recursive schedule, while smaller or rings may give better commitment ranks, quotient sizes, setup cost, or verifier work.

To isolate this axis, return to one commitment group, one witness chunk, and the EvaluationTrace opening method, but allow the three commitment matrices to use

The supported dimensions are powers of two and satisfy

There is no ordering requirement between and . The uniform setting is the projection-ratio-one instance of the same protocol, not a separate relation path.

Mixed rings preserve the meaning of the four semantic relations. They change the native ring in which each physical row is represented:

Semantic relation familyNative ring
fold-evaluation consistency
inner-commitment consistency
outer-commitment consistency
opening-commitment consistency

Thus the four families do not each receive an arbitrary ring. The two consistency families remain -native, while the two commitment-image families use the native rings of and .

Role-native projection and decomposition

The source block , its inner image , the partial evaluation , and the folded response are first formed over . Before is decomposed for , or is decomposed for , the implementation splits the -native value into exact role-native coefficient subcolumns.

Let be either or , and let . For , define

Taking the canonical representative of degree less than , has the exact decomposition

Here is digit-decomposed inside its native role ring. Equation (6) is a coefficient identity, not an embedding of into and not padding to an -sized carrier. The physical digit order is

[semantic value][role subcolumn][digit][native coefficient].

The representation of an -native value therefore has subcolumns, and its representation has subcolumns. Write and for the corresponding recomposition maps, including the shifts and from Equation (6). They reconstruct -native values from the role-native digits used by the consistency relations.

The four relations in their native rings

The fold still computes

With role-native recomposition made explicit, the four semantic relations are

The first two rows compare values that originate from the -native source, so they recompose the - or -native digits back into . The last two rows operate directly on those role-native digits. The physical columns of and include the subcolumn axis, so neither matrix pads its input back to .

The canonical row-family order and targets remain

This notation records the row order and semantic targets; in the mixed setting it is not one vector equation over a common ring. Each component is interpreted in the native ring shown in Equation (7).

The ordinary witness is stored as one flat coefficient vector. Its segment is -native, its and segments use the role-native subcolumn layout, and every quotient row added by the physical realization is stored at that row's exact native dimension. No batch-wide carrier ring is introduced for witness storage.

Check each row in its native ring

For EvaluationTrace, consistency and rows use , rows use , and rows use . Apply the selected checking method to each row at that row's native dimension . Quotient lifting uses its modulus factor and private quotient digits. Reduced evaluation uses its public kernel without quotient digits.

Both methods evaluate at the shared field point . The resulting scalar claims lie in the same extension field and can be batched with . This does not convert the original relations into one common quotient ring. Checking ring relations over a field derives the two checks and their handoff to Stage 2.

Relation to compressed realization

Compressed realization uses the selected ring-relation mode for its additional native rows as well. In raw mode, the semantic commitment images and are public. In compressed mode they are private intermediate values, and additional and rows bind them to smaller public payloads. Those compression rows have their own native ring dimensions. Quotient lifting gives each one a native quotient; reduced evaluation uses the corresponding residue weights without quotient digits.

The difference is structural. Mixed // dimensions assign native rings to the existing four semantic relation families. Compression adds new / physical row families. Once the rows have been formed, the selected ring-relation mode turns them into field claims before Stage 2.

Choosing a smaller or is not automatically cheaper. The physical column counts expand by the projection ratios

and, for fixed digit depths, splitting a value does not reduce the total number of its or coefficients. The benefit instead comes from the complete interaction among native commitment ranks, payload and quotient sizes, setup geometry, verifier arithmetic, and later fold levels. The planner therefore prices complete schedules rather than minimizing each dimension independently.

Composition with groups and chunks

Mixed dimensions compose with the two earlier axes without changing their ownership rules. Each commitment group owns its and dimensions, while the consuming level owns the shared dimension. Each chunk retains the layouts of its group's unit; chunking changes the block ranges and column support, not the ring assigned to a relation row.

With multiple groups and chunks, the exact unit order is

The resulting physical witness remains one chunk-major flat coefficient vector with any required compression suffix. Quotient-lift mode adds the shared ordinary quotient digits and any compression quotients. Each row uses its own dimension in the quotient-lift weights or the reduced-evaluation kernel. Thus group, chunk, and mixed-ring layouts combine without introducing a common carrier ring.